diff options
Diffstat (limited to 'files/unit_test')
-rw-r--r-- | files/unit_test/color_test.cc | 331 | ||||
-rw-r--r-- | files/unit_test/compare_test.cc | 111 | ||||
-rw-r--r-- | files/unit_test/convert_test.cc | 2682 | ||||
-rw-r--r-- | files/unit_test/cpu_test.cc | 25 | ||||
-rw-r--r-- | files/unit_test/math_test.cc | 2 | ||||
-rw-r--r-- | files/unit_test/planar_test.cc | 1072 | ||||
-rw-r--r-- | files/unit_test/rotate_argb_test.cc | 116 | ||||
-rw-r--r-- | files/unit_test/rotate_test.cc | 173 | ||||
-rw-r--r-- | files/unit_test/scale_argb_test.cc | 301 | ||||
-rw-r--r-- | files/unit_test/scale_test.cc | 275 | ||||
-rw-r--r-- | files/unit_test/unit_test.cc | 180 | ||||
-rw-r--r-- | files/unit_test/unit_test.h | 83 | ||||
-rw-r--r-- | files/unit_test/video_common_test.cc | 50 |
13 files changed, 2818 insertions, 2583 deletions
diff --git a/files/unit_test/color_test.cc b/files/unit_test/color_test.cc index 36041d99..0aa7a54a 100644 --- a/files/unit_test/color_test.cc +++ b/files/unit_test/color_test.cc @@ -10,13 +10,13 @@ #include <stdlib.h> +#include "../unit_test/unit_test.h" #include "libyuv/basic_types.h" #include "libyuv/convert.h" #include "libyuv/convert_argb.h" #include "libyuv/convert_from.h" #include "libyuv/convert_from_argb.h" #include "libyuv/cpu_id.h" -#include "../unit_test/unit_test.h" namespace libyuv { @@ -38,110 +38,103 @@ namespace libyuv { #define TESTCS(TESTNAME, YUVTOARGB, ARGBTOYUV, HS1, HS, HN, DIFF) \ TEST_F(LibYUVColorTest, TESTNAME) { \ - const int kPixels = benchmark_width_ * benchmark_height_; \ - const int kHalfPixels = ((benchmark_width_ + 1) / 2) * \ - ((benchmark_height_ + HS1) / HS); \ - align_buffer_page_end(orig_y, kPixels); \ - align_buffer_page_end(orig_u, kHalfPixels); \ - align_buffer_page_end(orig_v, kHalfPixels); \ - align_buffer_page_end(orig_pixels, kPixels * 4); \ - align_buffer_page_end(temp_y, kPixels); \ - align_buffer_page_end(temp_u, kHalfPixels); \ - align_buffer_page_end(temp_v, kHalfPixels); \ - align_buffer_page_end(dst_pixels_opt, kPixels * 4); \ - align_buffer_page_end(dst_pixels_c, kPixels * 4); \ + const int kPixels = benchmark_width_ * benchmark_height_; \ + const int kHalfPixels = \ + ((benchmark_width_ + 1) / 2) * ((benchmark_height_ + HS1) / HS); \ + align_buffer_page_end(orig_y, kPixels); \ + align_buffer_page_end(orig_u, kHalfPixels); \ + align_buffer_page_end(orig_v, kHalfPixels); \ + align_buffer_page_end(orig_pixels, kPixels * 4); \ + align_buffer_page_end(temp_y, kPixels); \ + align_buffer_page_end(temp_u, kHalfPixels); \ + align_buffer_page_end(temp_v, kHalfPixels); \ + align_buffer_page_end(dst_pixels_opt, kPixels * 4); \ + align_buffer_page_end(dst_pixels_c, kPixels * 4); \ \ - MemRandomize(orig_pixels, kPixels * 4); \ - MemRandomize(orig_y, kPixels); \ - MemRandomize(orig_u, kHalfPixels); \ - MemRandomize(orig_v, kHalfPixels); \ - MemRandomize(temp_y, kPixels); \ - MemRandomize(temp_u, kHalfPixels); \ - MemRandomize(temp_v, kHalfPixels); \ - MemRandomize(dst_pixels_opt, kPixels * 4); \ - MemRandomize(dst_pixels_c, kPixels * 4); \ + MemRandomize(orig_pixels, kPixels * 4); \ + MemRandomize(orig_y, kPixels); \ + MemRandomize(orig_u, kHalfPixels); \ + MemRandomize(orig_v, kHalfPixels); \ + MemRandomize(temp_y, kPixels); \ + MemRandomize(temp_u, kHalfPixels); \ + MemRandomize(temp_v, kHalfPixels); \ + MemRandomize(dst_pixels_opt, kPixels * 4); \ + MemRandomize(dst_pixels_c, kPixels * 4); \ \ - /* The test is overall for color conversion matrix being reversible, so */ \ - /* this initializes the pixel with 2x2 blocks to eliminate subsampling. */ \ - uint8* p = orig_y; \ - for (int y = 0; y < benchmark_height_ - HS1; y += HS) { \ - for (int x = 0; x < benchmark_width_ - 1; x += 2) { \ - uint8 r = static_cast<uint8>(fastrand()); \ - p[0] = r; \ - p[1] = r; \ - p[HN] = r; \ - p[HN + 1] = r; \ - p += 2; \ - } \ - if (benchmark_width_ & 1) { \ - uint8 r = static_cast<uint8>(fastrand()); \ - p[0] = r; \ - p[HN] = r; \ - p += 1; \ + /* The test is overall for color conversion matrix being reversible, so */ \ + /* this initializes the pixel with 2x2 blocks to eliminate subsampling. */ \ + uint8* p = orig_y; \ + for (int y = 0; y < benchmark_height_ - HS1; y += HS) { \ + for (int x = 0; x < benchmark_width_ - 1; x += 2) { \ + uint8 r = static_cast<uint8>(fastrand()); \ + p[0] = r; \ + p[1] = r; \ + p[HN] = r; \ + p[HN + 1] = r; \ + p += 2; \ + } \ + if (benchmark_width_ & 1) { \ + uint8 r = static_cast<uint8>(fastrand()); \ + p[0] = r; \ + p[HN] = r; \ + p += 1; \ + } \ + p += HN; \ } \ - p += HN; \ - } \ - if ((benchmark_height_ & 1) && HS == 2) { \ - for (int x = 0; x < benchmark_width_ - 1; x += 2) { \ - uint8 r = static_cast<uint8>(fastrand()); \ - p[0] = r; \ - p[1] = r; \ - p += 2; \ + if ((benchmark_height_ & 1) && HS == 2) { \ + for (int x = 0; x < benchmark_width_ - 1; x += 2) { \ + uint8 r = static_cast<uint8>(fastrand()); \ + p[0] = r; \ + p[1] = r; \ + p += 2; \ + } \ + if (benchmark_width_ & 1) { \ + uint8 r = static_cast<uint8>(fastrand()); \ + p[0] = r; \ + p += 1; \ + } \ } \ - if (benchmark_width_ & 1) { \ - uint8 r = static_cast<uint8>(fastrand()); \ - p[0] = r; \ - p += 1; \ - } \ - } \ - /* Start with YUV converted to ARGB. */ \ - YUVTOARGB(orig_y, benchmark_width_, \ - orig_u, (benchmark_width_ + 1) / 2, \ - orig_v, (benchmark_width_ + 1) / 2, \ - orig_pixels, benchmark_width_ * 4, \ - benchmark_width_, benchmark_height_); \ + /* Start with YUV converted to ARGB. */ \ + YUVTOARGB(orig_y, benchmark_width_, orig_u, (benchmark_width_ + 1) / 2, \ + orig_v, (benchmark_width_ + 1) / 2, orig_pixels, \ + benchmark_width_ * 4, benchmark_width_, benchmark_height_); \ \ - ARGBTOYUV(orig_pixels, benchmark_width_ * 4, \ - temp_y, benchmark_width_, \ - temp_u, (benchmark_width_ + 1) / 2, \ - temp_v, (benchmark_width_ + 1) / 2, \ - benchmark_width_, benchmark_height_); \ + ARGBTOYUV(orig_pixels, benchmark_width_ * 4, temp_y, benchmark_width_, \ + temp_u, (benchmark_width_ + 1) / 2, temp_v, \ + (benchmark_width_ + 1) / 2, benchmark_width_, \ + benchmark_height_); \ \ - MaskCpuFlags(disable_cpu_flags_); \ - YUVTOARGB(temp_y, benchmark_width_, \ - temp_u, (benchmark_width_ + 1) / 2, \ - temp_v, (benchmark_width_ + 1) / 2, \ - dst_pixels_c, benchmark_width_ * 4, \ - benchmark_width_, benchmark_height_); \ - MaskCpuFlags(benchmark_cpu_info_); \ + MaskCpuFlags(disable_cpu_flags_); \ + YUVTOARGB(temp_y, benchmark_width_, temp_u, (benchmark_width_ + 1) / 2, \ + temp_v, (benchmark_width_ + 1) / 2, dst_pixels_c, \ + benchmark_width_ * 4, benchmark_width_, benchmark_height_); \ + MaskCpuFlags(benchmark_cpu_info_); \ \ - for (int i = 0; i < benchmark_iterations_; ++i) { \ - YUVTOARGB(temp_y, benchmark_width_, \ - temp_u, (benchmark_width_ + 1) / 2, \ - temp_v, (benchmark_width_ + 1) / 2, \ - dst_pixels_opt, benchmark_width_ * 4, \ - benchmark_width_, benchmark_height_); \ - } \ - /* Test C and SIMD match. */ \ - for (int i = 0; i < kPixels * 4; ++i) { \ - EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]); \ - } \ - /* Test SIMD is close to original. */ \ - for (int i = 0; i < kPixels * 4; ++i) { \ - EXPECT_NEAR(static_cast<int>(orig_pixels[i]), \ - static_cast<int>(dst_pixels_opt[i]), DIFF); \ - } \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + YUVTOARGB(temp_y, benchmark_width_, temp_u, (benchmark_width_ + 1) / 2, \ + temp_v, (benchmark_width_ + 1) / 2, dst_pixels_opt, \ + benchmark_width_ * 4, benchmark_width_, benchmark_height_); \ + } \ + /* Test C and SIMD match. */ \ + for (int i = 0; i < kPixels * 4; ++i) { \ + EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]); \ + } \ + /* Test SIMD is close to original. */ \ + for (int i = 0; i < kPixels * 4; ++i) { \ + EXPECT_NEAR(static_cast<int>(orig_pixels[i]), \ + static_cast<int>(dst_pixels_opt[i]), DIFF); \ + } \ \ - free_aligned_buffer_page_end(orig_pixels); \ - free_aligned_buffer_page_end(orig_y); \ - free_aligned_buffer_page_end(orig_u); \ - free_aligned_buffer_page_end(orig_v); \ - free_aligned_buffer_page_end(temp_y); \ - free_aligned_buffer_page_end(temp_u); \ - free_aligned_buffer_page_end(temp_v); \ - free_aligned_buffer_page_end(dst_pixels_opt); \ - free_aligned_buffer_page_end(dst_pixels_c); \ -} \ + free_aligned_buffer_page_end(orig_pixels); \ + free_aligned_buffer_page_end(orig_y); \ + free_aligned_buffer_page_end(orig_u); \ + free_aligned_buffer_page_end(orig_v); \ + free_aligned_buffer_page_end(temp_y); \ + free_aligned_buffer_page_end(temp_u); \ + free_aligned_buffer_page_end(temp_v); \ + free_aligned_buffer_page_end(dst_pixels_opt); \ + free_aligned_buffer_page_end(dst_pixels_c); \ + } TESTCS(TestI420, I420ToARGB, ARGBToI420, 1, 2, benchmark_width_, ERROR_FULL) TESTCS(TestI422, I422ToARGB, ARGBToI422, 0, 1, 0, ERROR_FULL) @@ -163,11 +156,8 @@ static void YUVToRGB(int y, int u, int v, int* r, int* g, int* b) { memset(orig_v, v, kHalfPixels); /* YUV converted to ARGB. */ - I422ToARGB(orig_y, kWidth, - orig_u, (kWidth + 1) / 2, - orig_v, (kWidth + 1) / 2, - orig_pixels, kWidth * 4, - kWidth, kHeight); + I422ToARGB(orig_y, kWidth, orig_u, (kWidth + 1) / 2, orig_v, (kWidth + 1) / 2, + orig_pixels, kWidth * 4, kWidth, kHeight); *b = orig_pixels[0]; *g = orig_pixels[1]; @@ -189,11 +179,8 @@ static void YUVJToRGB(int y, int u, int v, int* r, int* g, int* b) { memset(orig_v, v, kHalfPixels); /* YUV converted to ARGB. */ - J422ToARGB(orig_y, kWidth, - orig_u, (kWidth + 1) / 2, - orig_v, (kWidth + 1) / 2, - orig_pixels, kWidth * 4, - kWidth, kHeight); + J422ToARGB(orig_y, kWidth, orig_u, (kWidth + 1) / 2, orig_v, (kWidth + 1) / 2, + orig_pixels, kWidth * 4, kWidth, kHeight); *b = orig_pixels[0]; *g = orig_pixels[1]; @@ -248,7 +235,7 @@ static void YJToRGB(int y, int* r, int* g, int* b) { #if defined(CLAMPMETHOD_IF) static int RoundToByte(float f) { - int i = ROUND(f); + int i = ROUND(f); if (i < 0) { i = 0; } @@ -259,52 +246,61 @@ static int RoundToByte(float f) { } #elif defined(CLAMPMETHOD_TABLE) static const unsigned char clamptable[811] = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 -}; + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255}; static int RoundToByte(float f) { return clamptable[ROUND(f) + 276]; @@ -317,7 +313,7 @@ static int RoundToByte(float f) { #elif defined(CLAMPMETHOD_MASK) static int RoundToByte(float f) { int i = ROUND(f); - i = ((-(i) >> 31) & (i)); // clamp to 0. + i = ((-(i) >> 31) & (i)); // clamp to 0. return (((255 - (i)) >> 31) | (i)) & 255; // clamp to 255. } #endif @@ -433,7 +429,6 @@ TEST_F(LibYUVColorTest, TestGreyYUV) { EXPECT_EQ(130, g1); EXPECT_EQ(130, b1); - for (int y = 0; y < 256; ++y) { YUVToRGBReference(y, 128, 128, &r0, &g0, &b0); YUVToRGB(y, 128, 128, &r1, &g1, &b1); @@ -477,7 +472,17 @@ static void PrintHistogram(int rh[256], int gh[256], int bh[256]) { } TEST_F(LibYUVColorTest, TestFullYUV) { - int rh[256] = { 0, }, gh[256] = { 0, }, bh[256] = { 0, }; + int rh[256] = + { + 0, + }, + gh[256] = + { + 0, + }, + bh[256] = { + 0, + }; for (int u = 0; u < 256; ++u) { for (int v = 0; v < 256; ++v) { for (int y2 = 0; y2 < 256; ++y2) { @@ -498,7 +503,17 @@ TEST_F(LibYUVColorTest, TestFullYUV) { } TEST_F(LibYUVColorTest, TestFullYUVJ) { - int rh[256] = { 0, }, gh[256] = { 0, }, bh[256] = { 0, }; + int rh[256] = + { + 0, + }, + gh[256] = + { + 0, + }, + bh[256] = { + 0, + }; for (int u = 0; u < 256; ++u) { for (int v = 0; v < 256; ++v) { for (int y2 = 0; y2 < 256; ++y2) { diff --git a/files/unit_test/compare_test.cc b/files/unit_test/compare_test.cc index a8ce671d..13f74705 100644 --- a/files/unit_test/compare_test.cc +++ b/files/unit_test/compare_test.cc @@ -36,7 +36,8 @@ TEST_F(LibYUVBaseTest, Djb2_Test) { 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); @@ -155,21 +156,21 @@ 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>(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>(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); } @@ -183,21 +184,21 @@ 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>(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>(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); } @@ -220,13 +221,14 @@ 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); @@ -242,18 +244,18 @@ TEST_F(LibYUVBaseTest, SumSquareError) { uint64 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); @@ -284,8 +286,7 @@ TEST_F(LibYUVBaseTest, BenchmarkPsnr_Opt) { double opt_time = get_time(); for (int i = 0; i < benchmark_iterations_; ++i) - CalcFramePsnr(src_a, benchmark_width_, - src_b, benchmark_width_, + CalcFramePsnr(src_a, benchmark_width_, src_b, benchmark_width_, benchmark_width_, benchmark_height_); opt_time = (get_time() - opt_time) / benchmark_iterations_; @@ -309,8 +310,7 @@ TEST_F(LibYUVBaseTest, BenchmarkPsnr_Unaligned) { double opt_time = get_time(); for (int i = 0; i < benchmark_iterations_; ++i) - CalcFramePsnr(src_a + 1, benchmark_width_, - src_b, benchmark_width_, + CalcFramePsnr(src_a + 1, benchmark_width_, src_b, benchmark_width_, benchmark_width_, benchmark_height_); opt_time = (get_time() - opt_time) / benchmark_iterations_; @@ -335,24 +335,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 +362,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 +384,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); @@ -411,8 +411,7 @@ TEST_F(LibYUVBaseTest, DISABLED_BenchmarkSsim_Opt) { double opt_time = get_time(); for (int i = 0; i < benchmark_iterations_; ++i) - CalcFrameSsim(src_a, benchmark_width_, - src_b, benchmark_width_, + CalcFrameSsim(src_a, benchmark_width_, src_b, benchmark_width_, benchmark_width_, benchmark_height_); opt_time = (get_time() - opt_time) / benchmark_iterations_; @@ -435,14 +434,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 +450,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 +460,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 +473,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 +492,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); diff --git a/files/unit_test/convert_test.cc b/files/unit_test/convert_test.cc index 56a2bfd8..0f1c7430 100644 --- a/files/unit_test/convert_test.cc +++ b/files/unit_test/convert_test.cc @@ -21,470 +21,546 @@ #ifdef HAVE_JPEG #include "libyuv/mjpeg_decoder.h" #endif +#include "../unit_test/unit_test.h" #include "libyuv/planar_functions.h" #include "libyuv/rotate.h" #include "libyuv/video_common.h" -#include "../unit_test/unit_test.h" namespace libyuv { -#define SUBSAMPLE(v, a) ((((v) + (a) - 1)) / (a)) - -#define TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF) \ -TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \ - const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ - const int kHeight = benchmark_height_; \ - align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ - align_buffer_page_end(src_u, \ - SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + OFF); \ - align_buffer_page_end(src_v, \ - SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + OFF); \ - align_buffer_page_end(dst_y_c, kWidth * kHeight); \ - align_buffer_page_end(dst_u_c, \ - SUBSAMPLE(kWidth, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - align_buffer_page_end(dst_v_c, \ - SUBSAMPLE(kWidth, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - align_buffer_page_end(dst_y_opt, kWidth * kHeight); \ - align_buffer_page_end(dst_u_opt, \ - SUBSAMPLE(kWidth, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - align_buffer_page_end(dst_v_opt, \ - SUBSAMPLE(kWidth, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - for (int i = 0; i < kHeight; ++i) \ - for (int j = 0; j < kWidth; ++j) \ - src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ - for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ - for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ - src_u[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ - (fastrand() & 0xff); \ - src_v[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ - (fastrand() & 0xff); \ - } \ - } \ - memset(dst_y_c, 1, kWidth * kHeight); \ - memset(dst_u_c, 2, SUBSAMPLE(kWidth, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - memset(dst_v_c, 3, SUBSAMPLE(kWidth, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - memset(dst_y_opt, 101, kWidth * kHeight); \ - memset(dst_u_opt, 102, SUBSAMPLE(kWidth, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - memset(dst_v_opt, 103, SUBSAMPLE(kWidth, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - MaskCpuFlags(disable_cpu_flags_); \ - SRC_FMT_PLANAR##To##FMT_PLANAR(src_y + OFF, kWidth, \ - src_u + OFF, \ - SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ - src_v + OFF, \ - SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ - dst_y_c, kWidth, \ - dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X), \ - dst_v_c, SUBSAMPLE(kWidth, SUBSAMP_X), \ - kWidth, NEG kHeight); \ - MaskCpuFlags(benchmark_cpu_info_); \ - for (int i = 0; i < benchmark_iterations_; ++i) { \ - SRC_FMT_PLANAR##To##FMT_PLANAR(src_y + OFF, kWidth, \ - src_u + OFF, \ - SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ - src_v + OFF, \ - SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ - dst_y_opt, kWidth, \ - dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X), \ - dst_v_opt, SUBSAMPLE(kWidth, SUBSAMP_X), \ - kWidth, NEG kHeight); \ - } \ - int max_diff = 0; \ - for (int i = 0; i < kHeight; ++i) { \ - for (int j = 0; j < kWidth; ++j) { \ - int abs_diff = \ - abs(static_cast<int>(dst_y_c[i * kWidth + j]) - \ - static_cast<int>(dst_y_opt[i * kWidth + j])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ - } \ - } \ - } \ - EXPECT_EQ(0, max_diff); \ - for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ - for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ - int abs_diff = \ - abs(static_cast<int>(dst_u_c[i * \ - SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ - static_cast<int>(dst_u_opt[i * \ - SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ - } \ - } \ - } \ - EXPECT_LE(max_diff, 3); \ - for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ - for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ - int abs_diff = \ - abs(static_cast<int>(dst_v_c[i * \ - SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ - static_cast<int>(dst_v_opt[i * \ - SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ - } \ - } \ - } \ - EXPECT_LE(max_diff, 3); \ - free_aligned_buffer_page_end(dst_y_c); \ - free_aligned_buffer_page_end(dst_u_c); \ - free_aligned_buffer_page_end(dst_v_c); \ - free_aligned_buffer_page_end(dst_y_opt); \ - free_aligned_buffer_page_end(dst_u_opt); \ - free_aligned_buffer_page_end(dst_v_opt); \ - free_aligned_buffer_page_end(src_y); \ - free_aligned_buffer_page_end(src_u); \ - free_aligned_buffer_page_end(src_v); \ -} +#define SUBSAMPLE(v, a) ((((v) + (a)-1)) / (a)) + +#define TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ + FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF) \ + TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \ + const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ + const int kHeight = benchmark_height_; \ + align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ + align_buffer_page_end(src_u, SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + \ + OFF); \ + align_buffer_page_end(src_v, SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + \ + OFF); \ + align_buffer_page_end(dst_y_c, kWidth* kHeight); \ + align_buffer_page_end(dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + align_buffer_page_end(dst_v_c, SUBSAMPLE(kWidth, SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + align_buffer_page_end(dst_y_opt, kWidth* kHeight); \ + align_buffer_page_end(dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + align_buffer_page_end(dst_v_opt, SUBSAMPLE(kWidth, SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + for (int i = 0; i < kHeight; ++i) \ + for (int j = 0; j < kWidth; ++j) \ + src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ + for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ + for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ + src_u[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ + (fastrand() & 0xff); \ + src_v[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ + (fastrand() & 0xff); \ + } \ + } \ + memset(dst_y_c, 1, kWidth* kHeight); \ + memset(dst_u_c, 2, \ + SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + memset(dst_v_c, 3, \ + SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + memset(dst_y_opt, 101, kWidth* kHeight); \ + memset(dst_u_opt, 102, \ + SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + memset(dst_v_opt, 103, \ + SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + MaskCpuFlags(disable_cpu_flags_); \ + SRC_FMT_PLANAR##To##FMT_PLANAR( \ + src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ + src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), dst_y_c, kWidth, \ + dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X), dst_v_c, \ + SUBSAMPLE(kWidth, SUBSAMP_X), kWidth, NEG kHeight); \ + MaskCpuFlags(benchmark_cpu_info_); \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + SRC_FMT_PLANAR##To##FMT_PLANAR( \ + src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ + src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), dst_y_opt, kWidth, \ + dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X), dst_v_opt, \ + SUBSAMPLE(kWidth, SUBSAMP_X), kWidth, NEG kHeight); \ + } \ + int max_diff = 0; \ + for (int i = 0; i < kHeight; ++i) { \ + for (int j = 0; j < kWidth; ++j) { \ + int abs_diff = abs(static_cast<int>(dst_y_c[i * kWidth + j]) - \ + static_cast<int>(dst_y_opt[i * kWidth + j])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ + } \ + EXPECT_EQ(0, max_diff); \ + for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ + for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ + int abs_diff = abs( \ + static_cast<int>(dst_u_c[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ + static_cast<int>( \ + dst_u_opt[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ + } \ + EXPECT_LE(max_diff, 3); \ + for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ + for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ + int abs_diff = abs( \ + static_cast<int>(dst_v_c[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ + static_cast<int>( \ + dst_v_opt[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ + } \ + EXPECT_LE(max_diff, 3); \ + free_aligned_buffer_page_end(dst_y_c); \ + free_aligned_buffer_page_end(dst_u_c); \ + free_aligned_buffer_page_end(dst_v_c); \ + free_aligned_buffer_page_end(dst_y_opt); \ + free_aligned_buffer_page_end(dst_u_opt); \ + free_aligned_buffer_page_end(dst_v_opt); \ + free_aligned_buffer_page_end(src_y); \ + free_aligned_buffer_page_end(src_u); \ + free_aligned_buffer_page_end(src_v); \ + } -#define TESTPLANARTOP(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \ - TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_ - 4, _Any, +, 0) \ - TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_, _Unaligned, +, 1) \ - TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_, _Invert, -, 0) \ - TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_, _Opt, +, 0) +#define TESTPLANARTOP(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ + FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \ + TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ + SUBSAMP_X, SUBSAMP_Y, benchmark_width_ - 4, _Any, +, 0) \ + TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ + SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Unaligned, +, 1) \ + TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ + SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Invert, -, 0) \ + TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ + SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Opt, +, 0) TESTPLANARTOP(I420, 2, 2, I420, 2, 2) TESTPLANARTOP(I422, 2, 1, I420, 2, 2) TESTPLANARTOP(I444, 1, 1, I420, 2, 2) -TESTPLANARTOP(I411, 4, 1, I420, 2, 2) TESTPLANARTOP(I420, 2, 2, I422, 2, 1) TESTPLANARTOP(I420, 2, 2, I444, 1, 1) -TESTPLANARTOP(I420, 2, 2, I411, 4, 1) TESTPLANARTOP(I420, 2, 2, I420Mirror, 2, 2) TESTPLANARTOP(I422, 2, 1, I422, 2, 1) TESTPLANARTOP(I444, 1, 1, I444, 1, 1) -#define TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF) \ -TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \ - const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ - const int kHeight = benchmark_height_; \ - align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ - align_buffer_page_end(src_u, \ - SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + OFF); \ - align_buffer_page_end(src_v, \ - SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + OFF); \ - align_buffer_page_end(dst_y_c, kWidth * kHeight); \ - align_buffer_page_end(dst_uv_c, SUBSAMPLE(kWidth * 2, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - align_buffer_page_end(dst_y_opt, kWidth * kHeight); \ - align_buffer_page_end(dst_uv_opt, SUBSAMPLE(kWidth * 2, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - for (int i = 0; i < kHeight; ++i) \ - for (int j = 0; j < kWidth; ++j) \ - src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ - for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ - for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ - src_u[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ - (fastrand() & 0xff); \ - src_v[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ - (fastrand() & 0xff); \ - } \ - } \ - memset(dst_y_c, 1, kWidth * kHeight); \ - memset(dst_uv_c, 2, SUBSAMPLE(kWidth * 2, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - memset(dst_y_opt, 101, kWidth * kHeight); \ - memset(dst_uv_opt, 102, SUBSAMPLE(kWidth * 2, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - MaskCpuFlags(disable_cpu_flags_); \ - SRC_FMT_PLANAR##To##FMT_PLANAR(src_y + OFF, kWidth, \ - src_u + OFF, \ - SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ - src_v + OFF, \ - SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ - dst_y_c, kWidth, \ - dst_uv_c, SUBSAMPLE(kWidth * 2, SUBSAMP_X), \ - kWidth, NEG kHeight); \ - MaskCpuFlags(benchmark_cpu_info_); \ - for (int i = 0; i < benchmark_iterations_; ++i) { \ - SRC_FMT_PLANAR##To##FMT_PLANAR(src_y + OFF, kWidth, \ - src_u + OFF, \ - SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ - src_v + OFF, \ - SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ - dst_y_opt, kWidth, \ - dst_uv_opt, \ - SUBSAMPLE(kWidth * 2, SUBSAMP_X), \ - kWidth, NEG kHeight); \ - } \ - int max_diff = 0; \ - for (int i = 0; i < kHeight; ++i) { \ - for (int j = 0; j < kWidth; ++j) { \ - int abs_diff = \ - abs(static_cast<int>(dst_y_c[i * kWidth + j]) - \ - static_cast<int>(dst_y_opt[i * kWidth + j])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ - } \ - } \ - } \ - EXPECT_LE(max_diff, 1); \ - for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ - for (int j = 0; j < SUBSAMPLE(kWidth * 2, SUBSAMP_X); ++j) { \ - int abs_diff = \ - abs(static_cast<int>(dst_uv_c[i * \ - SUBSAMPLE(kWidth * 2, SUBSAMP_X) + j]) - \ - static_cast<int>(dst_uv_opt[i * \ - SUBSAMPLE(kWidth * 2, SUBSAMP_X) + j])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ - } \ - } \ - } \ - EXPECT_LE(max_diff, 1); \ - free_aligned_buffer_page_end(dst_y_c); \ - free_aligned_buffer_page_end(dst_uv_c); \ - free_aligned_buffer_page_end(dst_y_opt); \ - free_aligned_buffer_page_end(dst_uv_opt); \ - free_aligned_buffer_page_end(src_y); \ - free_aligned_buffer_page_end(src_u); \ - free_aligned_buffer_page_end(src_v); \ -} +// Test Android 420 to I420 +#define TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X, \ + SRC_SUBSAMP_Y, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ + W1280, N, NEG, OFF, PN, OFF_U, OFF_V) \ + TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##_##PN##N) { \ + const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ + const int kHeight = benchmark_height_; \ + const int kSizeUV = \ + SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); \ + align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ + align_buffer_page_end(src_uv, \ + kSizeUV*((PIXEL_STRIDE == 3) ? 3 : 2) + OFF); \ + align_buffer_page_end(dst_y_c, kWidth* kHeight); \ + align_buffer_page_end(dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + align_buffer_page_end(dst_v_c, SUBSAMPLE(kWidth, SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + align_buffer_page_end(dst_y_opt, kWidth* kHeight); \ + align_buffer_page_end(dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + align_buffer_page_end(dst_v_opt, SUBSAMPLE(kWidth, SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + uint8* src_u = src_uv + OFF_U; \ + uint8* src_v = src_uv + (PIXEL_STRIDE == 1 ? kSizeUV : OFF_V); \ + int src_stride_uv = SUBSAMPLE(kWidth, SUBSAMP_X) * PIXEL_STRIDE; \ + for (int i = 0; i < kHeight; ++i) \ + for (int j = 0; j < kWidth; ++j) \ + src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ + for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ + for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ + src_u[(i * src_stride_uv) + j * PIXEL_STRIDE + OFF] = \ + (fastrand() & 0xff); \ + src_v[(i * src_stride_uv) + j * PIXEL_STRIDE + OFF] = \ + (fastrand() & 0xff); \ + } \ + } \ + memset(dst_y_c, 1, kWidth* kHeight); \ + memset(dst_u_c, 2, \ + SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + memset(dst_v_c, 3, \ + SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + memset(dst_y_opt, 101, kWidth* kHeight); \ + memset(dst_u_opt, 102, \ + SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + memset(dst_v_opt, 103, \ + SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + MaskCpuFlags(disable_cpu_flags_); \ + SRC_FMT_PLANAR##To##FMT_PLANAR( \ + src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ + src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), PIXEL_STRIDE, dst_y_c, \ + kWidth, dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X), dst_v_c, \ + SUBSAMPLE(kWidth, SUBSAMP_X), kWidth, NEG kHeight); \ + MaskCpuFlags(benchmark_cpu_info_); \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + SRC_FMT_PLANAR##To##FMT_PLANAR( \ + src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ + src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), PIXEL_STRIDE, \ + dst_y_opt, kWidth, dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X), \ + dst_v_opt, SUBSAMPLE(kWidth, SUBSAMP_X), kWidth, NEG kHeight); \ + } \ + int max_diff = 0; \ + for (int i = 0; i < kHeight; ++i) { \ + for (int j = 0; j < kWidth; ++j) { \ + int abs_diff = abs(static_cast<int>(dst_y_c[i * kWidth + j]) - \ + static_cast<int>(dst_y_opt[i * kWidth + j])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ + } \ + EXPECT_EQ(0, max_diff); \ + for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ + for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ + int abs_diff = abs( \ + static_cast<int>(dst_u_c[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ + static_cast<int>( \ + dst_u_opt[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ + } \ + EXPECT_LE(max_diff, 3); \ + for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ + for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ + int abs_diff = abs( \ + static_cast<int>(dst_v_c[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ + static_cast<int>( \ + dst_v_opt[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ + } \ + EXPECT_LE(max_diff, 3); \ + free_aligned_buffer_page_end(dst_y_c); \ + free_aligned_buffer_page_end(dst_u_c); \ + free_aligned_buffer_page_end(dst_v_c); \ + free_aligned_buffer_page_end(dst_y_opt); \ + free_aligned_buffer_page_end(dst_u_opt); \ + free_aligned_buffer_page_end(dst_v_opt); \ + free_aligned_buffer_page_end(src_y); \ + free_aligned_buffer_page_end(src_uv); \ + } + +#define TESTAPLANARTOP(SRC_FMT_PLANAR, PN, PIXEL_STRIDE, OFF_U, OFF_V, \ + SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, SUBSAMP_X, \ + SUBSAMP_Y) \ + TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ + FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, benchmark_width_ - 4, \ + _Any, +, 0, PN, OFF_U, OFF_V) \ + TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ + FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, benchmark_width_, \ + _Unaligned, +, 1, PN, OFF_U, OFF_V) \ + TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ + FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Invert, \ + -, 0, PN, OFF_U, OFF_V) \ + TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ + FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Opt, +, \ + 0, PN, OFF_U, OFF_V) + +TESTAPLANARTOP(Android420, I420, 1, 0, 0, 2, 2, I420, 2, 2) +TESTAPLANARTOP(Android420, NV12, 2, 0, 1, 2, 2, I420, 2, 2) +TESTAPLANARTOP(Android420, NV21, 2, 1, 0, 2, 2, I420, 2, 2) + +#define TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ + FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF) \ + TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \ + const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ + const int kHeight = benchmark_height_; \ + align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ + align_buffer_page_end(src_u, SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + \ + OFF); \ + align_buffer_page_end(src_v, SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + \ + OFF); \ + align_buffer_page_end(dst_y_c, kWidth* kHeight); \ + align_buffer_page_end(dst_uv_c, SUBSAMPLE(kWidth * 2, SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + align_buffer_page_end(dst_y_opt, kWidth* kHeight); \ + align_buffer_page_end(dst_uv_opt, SUBSAMPLE(kWidth * 2, SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + for (int i = 0; i < kHeight; ++i) \ + for (int j = 0; j < kWidth; ++j) \ + src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ + for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ + for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ + src_u[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ + (fastrand() & 0xff); \ + src_v[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ + (fastrand() & 0xff); \ + } \ + } \ + memset(dst_y_c, 1, kWidth* kHeight); \ + memset(dst_uv_c, 2, \ + SUBSAMPLE(kWidth * 2, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + memset(dst_y_opt, 101, kWidth* kHeight); \ + memset(dst_uv_opt, 102, \ + SUBSAMPLE(kWidth * 2, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + MaskCpuFlags(disable_cpu_flags_); \ + SRC_FMT_PLANAR##To##FMT_PLANAR( \ + src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ + src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), dst_y_c, kWidth, \ + dst_uv_c, SUBSAMPLE(kWidth * 2, SUBSAMP_X), kWidth, NEG kHeight); \ + MaskCpuFlags(benchmark_cpu_info_); \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + SRC_FMT_PLANAR##To##FMT_PLANAR( \ + src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ + src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), dst_y_opt, kWidth, \ + dst_uv_opt, SUBSAMPLE(kWidth * 2, SUBSAMP_X), kWidth, NEG kHeight); \ + } \ + int max_diff = 0; \ + for (int i = 0; i < kHeight; ++i) { \ + for (int j = 0; j < kWidth; ++j) { \ + int abs_diff = abs(static_cast<int>(dst_y_c[i * kWidth + j]) - \ + static_cast<int>(dst_y_opt[i * kWidth + j])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ + } \ + EXPECT_LE(max_diff, 1); \ + for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ + for (int j = 0; j < SUBSAMPLE(kWidth * 2, SUBSAMP_X); ++j) { \ + int abs_diff = \ + abs(static_cast<int>( \ + dst_uv_c[i * SUBSAMPLE(kWidth * 2, SUBSAMP_X) + j]) - \ + static_cast<int>( \ + dst_uv_opt[i * SUBSAMPLE(kWidth * 2, SUBSAMP_X) + j])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ + } \ + EXPECT_LE(max_diff, 1); \ + free_aligned_buffer_page_end(dst_y_c); \ + free_aligned_buffer_page_end(dst_uv_c); \ + free_aligned_buffer_page_end(dst_y_opt); \ + free_aligned_buffer_page_end(dst_uv_opt); \ + free_aligned_buffer_page_end(src_y); \ + free_aligned_buffer_page_end(src_u); \ + free_aligned_buffer_page_end(src_v); \ + } -#define TESTPLANARTOBP(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \ - TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_ - 4, _Any, +, 0) \ - TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_, _Unaligned, +, 1) \ - TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_, _Invert, -, 0) \ - TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_, _Opt, +, 0) +#define TESTPLANARTOBP(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ + FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \ + TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ + SUBSAMP_X, SUBSAMP_Y, benchmark_width_ - 4, _Any, +, 0) \ + TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ + SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Unaligned, +, 1) \ + TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ + SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Invert, -, 0) \ + TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ + SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Opt, +, 0) TESTPLANARTOBP(I420, 2, 2, NV12, 2, 2) TESTPLANARTOBP(I420, 2, 2, NV21, 2, 2) #define TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF) \ -TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \ - const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ - const int kHeight = benchmark_height_; \ - align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ - align_buffer_page_end(src_uv, 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + OFF); \ - align_buffer_page_end(dst_y_c, kWidth * kHeight); \ - align_buffer_page_end(dst_u_c, \ - SUBSAMPLE(kWidth, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - align_buffer_page_end(dst_v_c, \ - SUBSAMPLE(kWidth, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - align_buffer_page_end(dst_y_opt, kWidth * kHeight); \ - align_buffer_page_end(dst_u_opt, \ - SUBSAMPLE(kWidth, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - align_buffer_page_end(dst_v_opt, \ - SUBSAMPLE(kWidth, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - for (int i = 0; i < kHeight; ++i) \ - for (int j = 0; j < kWidth; ++j) \ - src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ - for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ - for (int j = 0; j < 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ - src_uv[(i * 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ - (fastrand() & 0xff); \ + FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF, \ + DOY) \ + TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \ + const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ + const int kHeight = benchmark_height_; \ + align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ + align_buffer_page_end(src_uv, 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + \ + OFF); \ + align_buffer_page_end(dst_y_c, kWidth* kHeight); \ + align_buffer_page_end(dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + align_buffer_page_end(dst_v_c, SUBSAMPLE(kWidth, SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + align_buffer_page_end(dst_y_opt, kWidth* kHeight); \ + align_buffer_page_end(dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + align_buffer_page_end(dst_v_opt, SUBSAMPLE(kWidth, SUBSAMP_X) * \ + SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + for (int i = 0; i < kHeight; ++i) \ + for (int j = 0; j < kWidth; ++j) \ + src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ + for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ + for (int j = 0; j < 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ + src_uv[(i * 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ + (fastrand() & 0xff); \ + } \ } \ - } \ - memset(dst_y_c, 1, kWidth * kHeight); \ - memset(dst_u_c, 2, SUBSAMPLE(kWidth, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - memset(dst_v_c, 3, SUBSAMPLE(kWidth, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - memset(dst_y_opt, 101, kWidth * kHeight); \ - memset(dst_u_opt, 102, SUBSAMPLE(kWidth, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - memset(dst_v_opt, 103, SUBSAMPLE(kWidth, SUBSAMP_X) * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - MaskCpuFlags(disable_cpu_flags_); \ - SRC_FMT_PLANAR##To##FMT_PLANAR(src_y + OFF, kWidth, \ - src_uv + OFF, \ - 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ - dst_y_c, kWidth, \ - dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X), \ - dst_v_c, SUBSAMPLE(kWidth, SUBSAMP_X), \ - kWidth, NEG kHeight); \ - MaskCpuFlags(benchmark_cpu_info_); \ - for (int i = 0; i < benchmark_iterations_; ++i) { \ - SRC_FMT_PLANAR##To##FMT_PLANAR(src_y + OFF, kWidth, \ - src_uv + OFF, \ - 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ - dst_y_opt, kWidth, \ - dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X), \ - dst_v_opt, SUBSAMPLE(kWidth, SUBSAMP_X), \ - kWidth, NEG kHeight); \ - } \ - int max_diff = 0; \ - for (int i = 0; i < kHeight; ++i) { \ - for (int j = 0; j < kWidth; ++j) { \ - int abs_diff = \ - abs(static_cast<int>(dst_y_c[i * kWidth + j]) - \ - static_cast<int>(dst_y_opt[i * kWidth + j])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ + memset(dst_y_c, 1, kWidth* kHeight); \ + memset(dst_u_c, 2, \ + SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + memset(dst_v_c, 3, \ + SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + memset(dst_y_opt, 101, kWidth* kHeight); \ + memset(dst_u_opt, 102, \ + SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + memset(dst_v_opt, 103, \ + SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + MaskCpuFlags(disable_cpu_flags_); \ + SRC_FMT_PLANAR##To##FMT_PLANAR( \ + src_y + OFF, kWidth, src_uv + OFF, \ + 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X), DOY ? dst_y_c : NULL, kWidth, \ + dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X), dst_v_c, \ + SUBSAMPLE(kWidth, SUBSAMP_X), kWidth, NEG kHeight); \ + MaskCpuFlags(benchmark_cpu_info_); \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + SRC_FMT_PLANAR##To##FMT_PLANAR( \ + src_y + OFF, kWidth, src_uv + OFF, \ + 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X), DOY ? dst_y_opt : NULL, \ + kWidth, dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X), dst_v_opt, \ + SUBSAMPLE(kWidth, SUBSAMP_X), kWidth, NEG kHeight); \ + } \ + int max_diff = 0; \ + if (DOY) { \ + for (int i = 0; i < kHeight; ++i) { \ + for (int j = 0; j < kWidth; ++j) { \ + int abs_diff = abs(static_cast<int>(dst_y_c[i * kWidth + j]) - \ + static_cast<int>(dst_y_opt[i * kWidth + j])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ } \ + EXPECT_LE(max_diff, 1); \ } \ - } \ - EXPECT_LE(max_diff, 1); \ - for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ - for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ - int abs_diff = \ - abs(static_cast<int>(dst_u_c[i * \ - SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ - static_cast<int>(dst_u_opt[i * \ - SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ + for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ + for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ + int abs_diff = abs( \ + static_cast<int>(dst_u_c[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ + static_cast<int>( \ + dst_u_opt[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ } \ } \ - } \ - EXPECT_LE(max_diff, 1); \ - for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ - for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ - int abs_diff = \ - abs(static_cast<int>(dst_v_c[i * \ - SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ - static_cast<int>(dst_v_opt[i * \ - SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ + EXPECT_LE(max_diff, 1); \ + for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ + for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ + int abs_diff = abs( \ + static_cast<int>(dst_v_c[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ + static_cast<int>( \ + dst_v_opt[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ } \ } \ - } \ - EXPECT_LE(max_diff, 1); \ - free_aligned_buffer_page_end(dst_y_c); \ - free_aligned_buffer_page_end(dst_u_c); \ - free_aligned_buffer_page_end(dst_v_c); \ - free_aligned_buffer_page_end(dst_y_opt); \ - free_aligned_buffer_page_end(dst_u_opt); \ - free_aligned_buffer_page_end(dst_v_opt); \ - free_aligned_buffer_page_end(src_y); \ - free_aligned_buffer_page_end(src_uv); \ -} + EXPECT_LE(max_diff, 1); \ + free_aligned_buffer_page_end(dst_y_c); \ + free_aligned_buffer_page_end(dst_u_c); \ + free_aligned_buffer_page_end(dst_v_c); \ + free_aligned_buffer_page_end(dst_y_opt); \ + free_aligned_buffer_page_end(dst_u_opt); \ + free_aligned_buffer_page_end(dst_v_opt); \ + free_aligned_buffer_page_end(src_y); \ + free_aligned_buffer_page_end(src_uv); \ + } -#define TESTBIPLANARTOP(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \ - TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_ - 4, _Any, +, 0) \ - TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_, _Unaligned, +, 1) \ - TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_, _Invert, -, 0) \ - TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ - FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_, _Opt, +, 0) +#define TESTBIPLANARTOP(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ + FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \ + TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ + SUBSAMP_X, SUBSAMP_Y, benchmark_width_ - 4, _Any, +, 0, 1) \ + TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ + SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Unaligned, +, 1, \ + 1) \ + TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ + SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Invert, -, 0, 1) \ + TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ + SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Opt, +, 0, 1) \ + TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ + SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _NullY, +, 0, 0) TESTBIPLANARTOP(NV12, 2, 2, I420, 2, 2) TESTBIPLANARTOP(NV21, 2, 2, I420, 2, 2) -#define ALIGNINT(V, ALIGN) (((V) + (ALIGN) - 1) / (ALIGN) * (ALIGN)) +#define ALIGNINT(V, ALIGN) (((V) + (ALIGN)-1) / (ALIGN) * (ALIGN)) #define TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ YALIGN, W1280, DIFF, N, NEG, OFF, FMT_C, BPP_C) \ -TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) { \ - const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ - const int kHeight = ALIGNINT(benchmark_height_, YALIGN); \ - const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN); \ - const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ - const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y); \ - align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ - align_buffer_page_end(src_u, kSizeUV + OFF); \ - align_buffer_page_end(src_v, kSizeUV + OFF); \ - align_buffer_page_end(dst_argb_c, kStrideB * kHeight + OFF); \ - align_buffer_page_end(dst_argb_opt, kStrideB * kHeight + OFF); \ - for (int i = 0; i < kWidth * kHeight; ++i) { \ - src_y[i + OFF] = (fastrand() & 0xff); \ - } \ - for (int i = 0; i < kSizeUV; ++i) { \ - src_u[i + OFF] = (fastrand() & 0xff); \ - src_v[i + OFF] = (fastrand() & 0xff); \ - } \ - memset(dst_argb_c + OFF, 1, kStrideB * kHeight); \ - memset(dst_argb_opt + OFF, 101, kStrideB * kHeight); \ - MaskCpuFlags(disable_cpu_flags_); \ - FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, \ - src_u + OFF, kStrideUV, \ - src_v + OFF, kStrideUV, \ - dst_argb_c + OFF, kStrideB, \ - kWidth, NEG kHeight); \ - MaskCpuFlags(benchmark_cpu_info_); \ - for (int i = 0; i < benchmark_iterations_; ++i) { \ - FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, \ - src_u + OFF, kStrideUV, \ - src_v + OFF, kStrideUV, \ - dst_argb_opt + OFF, kStrideB, \ + TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) { \ + const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ + const int kHeight = ALIGNINT(benchmark_height_, YALIGN); \ + const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN); \ + const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ + const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y); \ + align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ + align_buffer_page_end(src_u, kSizeUV + OFF); \ + align_buffer_page_end(src_v, kSizeUV + OFF); \ + align_buffer_page_end(dst_argb_c, kStrideB* kHeight + OFF); \ + align_buffer_page_end(dst_argb_opt, kStrideB* kHeight + OFF); \ + for (int i = 0; i < kWidth * kHeight; ++i) { \ + src_y[i + OFF] = (fastrand() & 0xff); \ + } \ + for (int i = 0; i < kSizeUV; ++i) { \ + src_u[i + OFF] = (fastrand() & 0xff); \ + src_v[i + OFF] = (fastrand() & 0xff); \ + } \ + memset(dst_argb_c + OFF, 1, kStrideB * kHeight); \ + memset(dst_argb_opt + OFF, 101, kStrideB * kHeight); \ + MaskCpuFlags(disable_cpu_flags_); \ + FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, src_u + OFF, kStrideUV, \ + src_v + OFF, kStrideUV, dst_argb_c + OFF, kStrideB, \ kWidth, NEG kHeight); \ - } \ - int max_diff = 0; \ - /* Convert to ARGB so 565 is expanded to bytes that can be compared. */ \ - align_buffer_page_end(dst_argb32_c, kWidth * BPP_C * kHeight); \ - align_buffer_page_end(dst_argb32_opt, kWidth * BPP_C * kHeight); \ - memset(dst_argb32_c, 2, kWidth * BPP_C * kHeight); \ - memset(dst_argb32_opt, 102, kWidth * BPP_C * kHeight); \ - FMT_B##To##FMT_C(dst_argb_c + OFF, kStrideB, \ - dst_argb32_c, kWidth * BPP_C , \ - kWidth, kHeight); \ - FMT_B##To##FMT_C(dst_argb_opt + OFF, kStrideB, \ - dst_argb32_opt, kWidth * BPP_C , \ - kWidth, kHeight); \ - for (int i = 0; i < kWidth * BPP_C * kHeight; ++i) { \ - int abs_diff = \ - abs(static_cast<int>(dst_argb32_c[i]) - \ - static_cast<int>(dst_argb32_opt[i])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ + MaskCpuFlags(benchmark_cpu_info_); \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, src_u + OFF, kStrideUV, \ + src_v + OFF, kStrideUV, dst_argb_opt + OFF, \ + kStrideB, kWidth, NEG kHeight); \ } \ - } \ - EXPECT_LE(max_diff, DIFF); \ - free_aligned_buffer_page_end(src_y); \ - free_aligned_buffer_page_end(src_u); \ - free_aligned_buffer_page_end(src_v); \ - free_aligned_buffer_page_end(dst_argb_c); \ - free_aligned_buffer_page_end(dst_argb_opt); \ - free_aligned_buffer_page_end(dst_argb32_c); \ - free_aligned_buffer_page_end(dst_argb32_opt); \ -} + int max_diff = 0; \ + /* Convert to ARGB so 565 is expanded to bytes that can be compared. */ \ + align_buffer_page_end(dst_argb32_c, kWidth* BPP_C* kHeight); \ + align_buffer_page_end(dst_argb32_opt, kWidth* BPP_C* kHeight); \ + memset(dst_argb32_c, 2, kWidth* BPP_C* kHeight); \ + memset(dst_argb32_opt, 102, kWidth* BPP_C* kHeight); \ + FMT_B##To##FMT_C(dst_argb_c + OFF, kStrideB, dst_argb32_c, kWidth * BPP_C, \ + kWidth, kHeight); \ + FMT_B##To##FMT_C(dst_argb_opt + OFF, kStrideB, dst_argb32_opt, \ + kWidth * BPP_C, kWidth, kHeight); \ + for (int i = 0; i < kWidth * BPP_C * kHeight; ++i) { \ + int abs_diff = abs(static_cast<int>(dst_argb32_c[i]) - \ + static_cast<int>(dst_argb32_opt[i])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ + EXPECT_LE(max_diff, DIFF); \ + free_aligned_buffer_page_end(src_y); \ + free_aligned_buffer_page_end(src_u); \ + free_aligned_buffer_page_end(src_v); \ + free_aligned_buffer_page_end(dst_argb_c); \ + free_aligned_buffer_page_end(dst_argb_opt); \ + free_aligned_buffer_page_end(dst_argb32_c); \ + free_aligned_buffer_page_end(dst_argb32_opt); \ + } #define TESTPLANARTOB(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ YALIGN, DIFF, FMT_C, BPP_C) \ - TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ - YALIGN, benchmark_width_ - 4, DIFF, _Any, +, 0, FMT_C, BPP_C) \ - TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ - YALIGN, benchmark_width_, DIFF, _Unaligned, +, 1, FMT_C, BPP_C) \ - TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ - YALIGN, benchmark_width_, DIFF, _Invert, -, 0, FMT_C, BPP_C) \ - TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ - YALIGN, benchmark_width_, DIFF, _Opt, +, 0, FMT_C, BPP_C) + TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ + YALIGN, benchmark_width_ - 4, DIFF, _Any, +, 0, FMT_C, BPP_C) \ + TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ + YALIGN, benchmark_width_, DIFF, _Unaligned, +, 1, FMT_C, \ + BPP_C) \ + TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ + YALIGN, benchmark_width_, DIFF, _Invert, -, 0, FMT_C, BPP_C) \ + TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ + YALIGN, benchmark_width_, DIFF, _Opt, +, 0, FMT_C, BPP_C) TESTPLANARTOB(I420, 2, 2, ARGB, 4, 4, 1, 2, ARGB, 4) TESTPLANARTOB(J420, 2, 2, ARGB, 4, 4, 1, 2, ARGB, 4) @@ -507,7 +583,6 @@ TESTPLANARTOB(H422, 2, 1, ABGR, 4, 4, 1, 2, ARGB, 4) TESTPLANARTOB(I422, 2, 1, BGRA, 4, 4, 1, 2, ARGB, 4) TESTPLANARTOB(I422, 2, 1, ABGR, 4, 4, 1, 2, ARGB, 4) TESTPLANARTOB(I422, 2, 1, RGBA, 4, 4, 1, 2, ARGB, 4) -TESTPLANARTOB(I411, 4, 1, ARGB, 4, 4, 1, 2, ARGB, 4) TESTPLANARTOB(I444, 1, 1, ARGB, 4, 4, 1, 2, ARGB, 4) TESTPLANARTOB(J444, 1, 1, ARGB, 4, 4, 1, 2, ARGB, 4) TESTPLANARTOB(I444, 1, 1, ABGR, 4, 4, 1, 2, ARGB, 4) @@ -519,247 +594,275 @@ TESTPLANARTOB(I420, 2, 2, I400, 1, 1, 1, 0, ARGB, 4) TESTPLANARTOB(J420, 2, 2, J400, 1, 1, 1, 0, ARGB, 4) #define TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ - YALIGN, W1280, DIFF, N, NEG, OFF, ATTEN) \ -TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) { \ - const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ - const int kHeight = ALIGNINT(benchmark_height_, YALIGN); \ - const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN); \ - const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ - const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y); \ - align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ - align_buffer_page_end(src_u, kSizeUV + OFF); \ - align_buffer_page_end(src_v, kSizeUV + OFF); \ - align_buffer_page_end(src_a, kWidth * kHeight + OFF); \ - align_buffer_page_end(dst_argb_c, kStrideB * kHeight + OFF); \ - align_buffer_page_end(dst_argb_opt, kStrideB * kHeight + OFF); \ - for (int i = 0; i < kWidth * kHeight; ++i) { \ - src_y[i + OFF] = (fastrand() & 0xff); \ - src_a[i + OFF] = (fastrand() & 0xff); \ - } \ - for (int i = 0; i < kSizeUV; ++i) { \ - src_u[i + OFF] = (fastrand() & 0xff); \ - src_v[i + OFF] = (fastrand() & 0xff); \ - } \ - memset(dst_argb_c + OFF, 1, kStrideB * kHeight); \ - memset(dst_argb_opt + OFF, 101, kStrideB * kHeight); \ - MaskCpuFlags(disable_cpu_flags_); \ - FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, \ - src_u + OFF, kStrideUV, \ - src_v + OFF, kStrideUV, \ - src_a + OFF, kWidth, \ - dst_argb_c + OFF, kStrideB, \ - kWidth, NEG kHeight, ATTEN); \ - MaskCpuFlags(benchmark_cpu_info_); \ - for (int i = 0; i < benchmark_iterations_; ++i) { \ - FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, \ - src_u + OFF, kStrideUV, \ - src_v + OFF, kStrideUV, \ - src_a + OFF, kWidth, \ - dst_argb_opt + OFF, kStrideB, \ - kWidth, NEG kHeight, ATTEN); \ - } \ - int max_diff = 0; \ - for (int i = 0; i < kWidth * BPP_B * kHeight; ++i) { \ - int abs_diff = \ - abs(static_cast<int>(dst_argb_c[i + OFF]) - \ - static_cast<int>(dst_argb_opt[i + OFF])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ + YALIGN, W1280, DIFF, N, NEG, OFF, ATTEN) \ + TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) { \ + const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ + const int kHeight = ALIGNINT(benchmark_height_, YALIGN); \ + const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN); \ + const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ + const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y); \ + align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ + align_buffer_page_end(src_u, kSizeUV + OFF); \ + align_buffer_page_end(src_v, kSizeUV + OFF); \ + align_buffer_page_end(src_a, kWidth* kHeight + OFF); \ + align_buffer_page_end(dst_argb_c, kStrideB* kHeight + OFF); \ + align_buffer_page_end(dst_argb_opt, kStrideB* kHeight + OFF); \ + for (int i = 0; i < kWidth * kHeight; ++i) { \ + src_y[i + OFF] = (fastrand() & 0xff); \ + src_a[i + OFF] = (fastrand() & 0xff); \ } \ - } \ - EXPECT_LE(max_diff, DIFF); \ - free_aligned_buffer_page_end(src_y); \ - free_aligned_buffer_page_end(src_u); \ - free_aligned_buffer_page_end(src_v); \ - free_aligned_buffer_page_end(src_a); \ - free_aligned_buffer_page_end(dst_argb_c); \ - free_aligned_buffer_page_end(dst_argb_opt); \ -} + for (int i = 0; i < kSizeUV; ++i) { \ + src_u[i + OFF] = (fastrand() & 0xff); \ + src_v[i + OFF] = (fastrand() & 0xff); \ + } \ + memset(dst_argb_c + OFF, 1, kStrideB * kHeight); \ + memset(dst_argb_opt + OFF, 101, kStrideB * kHeight); \ + MaskCpuFlags(disable_cpu_flags_); \ + FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, src_u + OFF, kStrideUV, \ + src_v + OFF, kStrideUV, src_a + OFF, kWidth, \ + dst_argb_c + OFF, kStrideB, kWidth, NEG kHeight, \ + ATTEN); \ + MaskCpuFlags(benchmark_cpu_info_); \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, src_u + OFF, kStrideUV, \ + src_v + OFF, kStrideUV, src_a + OFF, kWidth, \ + dst_argb_opt + OFF, kStrideB, kWidth, NEG kHeight, \ + ATTEN); \ + } \ + int max_diff = 0; \ + for (int i = 0; i < kWidth * BPP_B * kHeight; ++i) { \ + int abs_diff = abs(static_cast<int>(dst_argb_c[i + OFF]) - \ + static_cast<int>(dst_argb_opt[i + OFF])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ + EXPECT_LE(max_diff, DIFF); \ + free_aligned_buffer_page_end(src_y); \ + free_aligned_buffer_page_end(src_u); \ + free_aligned_buffer_page_end(src_v); \ + free_aligned_buffer_page_end(src_a); \ + free_aligned_buffer_page_end(dst_argb_c); \ + free_aligned_buffer_page_end(dst_argb_opt); \ + } -#define TESTQPLANARTOB(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ - YALIGN, DIFF) \ - TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ - YALIGN, benchmark_width_ - 4, DIFF, _Any, +, 0, 0) \ - TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ - YALIGN, benchmark_width_, DIFF, _Unaligned, +, 1, 0) \ - TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ - YALIGN, benchmark_width_, DIFF, _Invert, -, 0, 0) \ - TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ - YALIGN, benchmark_width_, DIFF, _Opt, +, 0, 0) \ - TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ - YALIGN, benchmark_width_, DIFF, _Premult, +, 0, 1) +#define TESTQPLANARTOB(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ + YALIGN, DIFF) \ + TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ + YALIGN, benchmark_width_ - 4, DIFF, _Any, +, 0, 0) \ + TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ + YALIGN, benchmark_width_, DIFF, _Unaligned, +, 1, 0) \ + TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ + YALIGN, benchmark_width_, DIFF, _Invert, -, 0, 0) \ + TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ + YALIGN, benchmark_width_, DIFF, _Opt, +, 0, 0) \ + TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ + YALIGN, benchmark_width_, DIFF, _Premult, +, 0, 1) TESTQPLANARTOB(I420Alpha, 2, 2, ARGB, 4, 4, 1, 2) TESTQPLANARTOB(I420Alpha, 2, 2, ABGR, 4, 4, 1, 2) #define TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, \ W1280, DIFF, N, NEG, OFF) \ -TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) { \ - const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ - const int kHeight = benchmark_height_; \ - const int kStrideB = kWidth * BPP_B; \ - const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ - align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ - align_buffer_page_end(src_uv, \ - kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y) * 2 + OFF); \ - align_buffer_page_end(dst_argb_c, kStrideB * kHeight); \ - align_buffer_page_end(dst_argb_opt, kStrideB * kHeight); \ - for (int i = 0; i < kHeight; ++i) \ - for (int j = 0; j < kWidth; ++j) \ - src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ - for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ - for (int j = 0; j < kStrideUV * 2; ++j) { \ - src_uv[i * kStrideUV * 2 + j + OFF] = (fastrand() & 0xff); \ + TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) { \ + const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ + const int kHeight = benchmark_height_; \ + const int kStrideB = kWidth * BPP_B; \ + const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ + align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ + align_buffer_page_end(src_uv, \ + kStrideUV* SUBSAMPLE(kHeight, SUBSAMP_Y) * 2 + OFF); \ + align_buffer_page_end(dst_argb_c, kStrideB* kHeight); \ + align_buffer_page_end(dst_argb_opt, kStrideB* kHeight); \ + for (int i = 0; i < kHeight; ++i) \ + for (int j = 0; j < kWidth; ++j) \ + src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ + for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ + for (int j = 0; j < kStrideUV * 2; ++j) { \ + src_uv[i * kStrideUV * 2 + j + OFF] = (fastrand() & 0xff); \ + } \ } \ - } \ - memset(dst_argb_c, 1, kStrideB * kHeight); \ - memset(dst_argb_opt, 101, kStrideB * kHeight); \ - MaskCpuFlags(disable_cpu_flags_); \ - FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, \ - src_uv + OFF, kStrideUV * 2, \ - dst_argb_c, kWidth * BPP_B, \ - kWidth, NEG kHeight); \ - MaskCpuFlags(benchmark_cpu_info_); \ - for (int i = 0; i < benchmark_iterations_; ++i) { \ - FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, \ - src_uv + OFF, kStrideUV * 2, \ - dst_argb_opt, kWidth * BPP_B, \ - kWidth, NEG kHeight); \ - } \ - /* Convert to ARGB so 565 is expanded to bytes that can be compared. */ \ - align_buffer_page_end(dst_argb32_c, kWidth * 4 * kHeight); \ - align_buffer_page_end(dst_argb32_opt, kWidth * 4 * kHeight); \ - memset(dst_argb32_c, 2, kWidth * 4 * kHeight); \ - memset(dst_argb32_opt, 102, kWidth * 4 * kHeight); \ - FMT_B##ToARGB(dst_argb_c, kStrideB, \ - dst_argb32_c, kWidth * 4, \ - kWidth, kHeight); \ - FMT_B##ToARGB(dst_argb_opt, kStrideB, \ - dst_argb32_opt, kWidth * 4, \ - kWidth, kHeight); \ - int max_diff = 0; \ - for (int i = 0; i < kHeight; ++i) { \ - for (int j = 0; j < kWidth * 4; ++j) { \ - int abs_diff = \ - abs(static_cast<int>(dst_argb32_c[i * kWidth * 4 + j]) - \ - static_cast<int>(dst_argb32_opt[i * kWidth * 4 + j])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ + memset(dst_argb_c, 1, kStrideB* kHeight); \ + memset(dst_argb_opt, 101, kStrideB* kHeight); \ + MaskCpuFlags(disable_cpu_flags_); \ + FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, src_uv + OFF, kStrideUV * 2, \ + dst_argb_c, kWidth * BPP_B, kWidth, NEG kHeight); \ + MaskCpuFlags(benchmark_cpu_info_); \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, src_uv + OFF, kStrideUV * 2, \ + dst_argb_opt, kWidth * BPP_B, kWidth, \ + NEG kHeight); \ + } \ + /* Convert to ARGB so 565 is expanded to bytes that can be compared. */ \ + align_buffer_page_end(dst_argb32_c, kWidth * 4 * kHeight); \ + align_buffer_page_end(dst_argb32_opt, kWidth * 4 * kHeight); \ + memset(dst_argb32_c, 2, kWidth * 4 * kHeight); \ + memset(dst_argb32_opt, 102, kWidth * 4 * kHeight); \ + FMT_B##ToARGB(dst_argb_c, kStrideB, dst_argb32_c, kWidth * 4, kWidth, \ + kHeight); \ + FMT_B##ToARGB(dst_argb_opt, kStrideB, dst_argb32_opt, kWidth * 4, kWidth, \ + kHeight); \ + int max_diff = 0; \ + for (int i = 0; i < kHeight; ++i) { \ + for (int j = 0; j < kWidth * 4; ++j) { \ + int abs_diff = \ + abs(static_cast<int>(dst_argb32_c[i * kWidth * 4 + j]) - \ + static_cast<int>(dst_argb32_opt[i * kWidth * 4 + j])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ } \ } \ - } \ - EXPECT_LE(max_diff, DIFF); \ - free_aligned_buffer_page_end(src_y); \ - free_aligned_buffer_page_end(src_uv); \ - free_aligned_buffer_page_end(dst_argb_c); \ - free_aligned_buffer_page_end(dst_argb_opt); \ - free_aligned_buffer_page_end(dst_argb32_c); \ - free_aligned_buffer_page_end(dst_argb32_opt); \ -} + EXPECT_LE(max_diff, DIFF); \ + free_aligned_buffer_page_end(src_y); \ + free_aligned_buffer_page_end(src_uv); \ + free_aligned_buffer_page_end(dst_argb_c); \ + free_aligned_buffer_page_end(dst_argb_opt); \ + free_aligned_buffer_page_end(dst_argb32_c); \ + free_aligned_buffer_page_end(dst_argb32_opt); \ + } -#define TESTBIPLANARTOB(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, DIFF) \ - TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, \ - benchmark_width_ - 4, DIFF, _Any, +, 0) \ - TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, \ - benchmark_width_, DIFF, _Unaligned, +, 1) \ - TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, \ - benchmark_width_, DIFF, _Invert, -, 0) \ - TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, \ - benchmark_width_, DIFF, _Opt, +, 0) +#define TESTBIPLANARTOB(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, DIFF) \ + TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, \ + benchmark_width_ - 4, DIFF, _Any, +, 0) \ + TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, \ + benchmark_width_, DIFF, _Unaligned, +, 1) \ + TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, \ + benchmark_width_, DIFF, _Invert, -, 0) \ + TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, \ + benchmark_width_, DIFF, _Opt, +, 0) TESTBIPLANARTOB(NV12, 2, 2, ARGB, 4, 2) TESTBIPLANARTOB(NV21, 2, 2, ARGB, 4, 2) TESTBIPLANARTOB(NV12, 2, 2, RGB565, 2, 9) +#ifdef DO_THREE_PLANES +// Do 3 allocations for yuv. conventional but slower. +#define TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ + W1280, DIFF, N, NEG, OFF) \ + TEST_F(LibYUVConvertTest, FMT_A##To##FMT_PLANAR##N) { \ + const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ + const int kHeight = ALIGNINT(benchmark_height_, YALIGN); \ + const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ + const int kStride = (kStrideUV * SUBSAMP_X * 8 * BPP_A + 7) / 8; \ + align_buffer_page_end(src_argb, kStride* kHeight + OFF); \ + align_buffer_page_end(dst_y_c, kWidth* kHeight); \ + align_buffer_page_end(dst_u_c, kStrideUV* SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + align_buffer_page_end(dst_v_c, kStrideUV* SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + align_buffer_page_end(dst_y_opt, kWidth* kHeight); \ + align_buffer_page_end(dst_u_opt, \ + kStrideUV* SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + align_buffer_page_end(dst_v_opt, \ + kStrideUV* SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + memset(dst_y_c, 1, kWidth* kHeight); \ + memset(dst_u_c, 2, kStrideUV* SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + memset(dst_v_c, 3, kStrideUV* SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + memset(dst_y_opt, 101, kWidth* kHeight); \ + memset(dst_u_opt, 102, kStrideUV* SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + memset(dst_v_opt, 103, kStrideUV* SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + for (int i = 0; i < kHeight; ++i) \ + for (int j = 0; j < kStride; ++j) \ + src_argb[(i * kStride) + j + OFF] = (fastrand() & 0xff); \ + MaskCpuFlags(disable_cpu_flags_); \ + FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, dst_y_c, kWidth, dst_u_c, \ + kStrideUV, dst_v_c, kStrideUV, kWidth, NEG kHeight); \ + MaskCpuFlags(benchmark_cpu_info_); \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, dst_y_opt, kWidth, \ + dst_u_opt, kStrideUV, dst_v_opt, kStrideUV, \ + kWidth, NEG kHeight); \ + } \ + for (int i = 0; i < kHeight; ++i) { \ + for (int j = 0; j < kWidth; ++j) { \ + EXPECT_NEAR(static_cast<int>(dst_y_c[i * kWidth + j]), \ + static_cast<int>(dst_y_opt[i * kWidth + j]), DIFF); \ + } \ + } \ + for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ + for (int j = 0; j < kStrideUV; ++j) { \ + EXPECT_NEAR(static_cast<int>(dst_u_c[i * kStrideUV + j]), \ + static_cast<int>(dst_u_opt[i * kStrideUV + j]), DIFF); \ + } \ + } \ + for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ + for (int j = 0; j < kStrideUV; ++j) { \ + EXPECT_NEAR(static_cast<int>(dst_v_c[i * kStrideUV + j]), \ + static_cast<int>(dst_v_opt[i * kStrideUV + j]), DIFF); \ + } \ + } \ + free_aligned_buffer_page_end(dst_y_c); \ + free_aligned_buffer_page_end(dst_u_c); \ + free_aligned_buffer_page_end(dst_v_c); \ + free_aligned_buffer_page_end(dst_y_opt); \ + free_aligned_buffer_page_end(dst_u_opt); \ + free_aligned_buffer_page_end(dst_v_opt); \ + free_aligned_buffer_page_end(src_argb); \ + } +#else #define TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ W1280, DIFF, N, NEG, OFF) \ -TEST_F(LibYUVConvertTest, FMT_A##To##FMT_PLANAR##N) { \ - const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ - const int kHeight = ALIGNINT(benchmark_height_, YALIGN); \ - const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ - const int kStride = \ - (kStrideUV * SUBSAMP_X * 8 * BPP_A + 7) / 8; \ - align_buffer_page_end(src_argb, kStride * kHeight + OFF); \ - align_buffer_page_end(dst_y_c, kWidth * kHeight); \ - align_buffer_page_end(dst_u_c, \ - kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - align_buffer_page_end(dst_v_c, \ - kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - align_buffer_page_end(dst_y_opt, kWidth * kHeight); \ - align_buffer_page_end(dst_u_opt, \ - kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - align_buffer_page_end(dst_v_opt, \ - kStrideUV * \ - SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - memset(dst_y_c, 1, kWidth * kHeight); \ - memset(dst_u_c, 2, \ - kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - memset(dst_v_c, 3, \ - kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - memset(dst_y_opt, 101, kWidth * kHeight); \ - memset(dst_u_opt, 102, \ - kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - memset(dst_v_opt, 103, \ - kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - for (int i = 0; i < kHeight; ++i) \ - for (int j = 0; j < kStride; ++j) \ - src_argb[(i * kStride) + j + OFF] = (fastrand() & 0xff); \ - MaskCpuFlags(disable_cpu_flags_); \ - FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, \ - dst_y_c, kWidth, \ - dst_u_c, kStrideUV, \ - dst_v_c, kStrideUV, \ - kWidth, NEG kHeight); \ - MaskCpuFlags(benchmark_cpu_info_); \ - for (int i = 0; i < benchmark_iterations_; ++i) { \ - FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, \ - dst_y_opt, kWidth, \ - dst_u_opt, kStrideUV, \ - dst_v_opt, kStrideUV, \ + TEST_F(LibYUVConvertTest, FMT_A##To##FMT_PLANAR##N) { \ + const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ + const int kHeight = ALIGNINT(benchmark_height_, YALIGN); \ + const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ + const int kStride = (kStrideUV * SUBSAMP_X * 8 * BPP_A + 7) / 8; \ + align_buffer_page_end(src_argb, kStride* kHeight + OFF); \ + align_buffer_page_end(dst_y_c, kWidth* kHeight); \ + align_buffer_page_end(dst_uv_c, \ + kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + align_buffer_page_end(dst_y_opt, kWidth* kHeight); \ + align_buffer_page_end(dst_uv_opt, \ + kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + memset(dst_y_c, 1, kWidth* kHeight); \ + memset(dst_uv_c, 2, kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + memset(dst_y_opt, 101, kWidth* kHeight); \ + memset(dst_uv_opt, 102, kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + for (int i = 0; i < kHeight; ++i) \ + for (int j = 0; j < kStride; ++j) \ + src_argb[(i * kStride) + j + OFF] = (fastrand() & 0xff); \ + MaskCpuFlags(disable_cpu_flags_); \ + FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, dst_y_c, kWidth, dst_uv_c, \ + kStrideUV * 2, dst_uv_c + kStrideUV, kStrideUV * 2, \ kWidth, NEG kHeight); \ - } \ - for (int i = 0; i < kHeight; ++i) { \ - for (int j = 0; j < kWidth; ++j) { \ - EXPECT_NEAR(static_cast<int>(dst_y_c[i * kWidth + j]), \ - static_cast<int>(dst_y_opt[i * kWidth + j]), DIFF); \ + MaskCpuFlags(benchmark_cpu_info_); \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, dst_y_opt, kWidth, \ + dst_uv_opt, kStrideUV * 2, dst_uv_opt + kStrideUV, \ + kStrideUV * 2, kWidth, NEG kHeight); \ } \ - } \ - for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ - for (int j = 0; j < kStrideUV; ++j) { \ - EXPECT_NEAR(static_cast<int>(dst_u_c[i * kStrideUV + j]), \ - static_cast<int>(dst_u_opt[i * kStrideUV + j]), DIFF); \ + for (int i = 0; i < kHeight; ++i) { \ + for (int j = 0; j < kWidth; ++j) { \ + EXPECT_NEAR(static_cast<int>(dst_y_c[i * kWidth + j]), \ + static_cast<int>(dst_y_opt[i * kWidth + j]), DIFF); \ + } \ } \ - } \ - for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ - for (int j = 0; j < kStrideUV; ++j) { \ - EXPECT_NEAR(static_cast<int>(dst_v_c[i * \ - kStrideUV + j]), \ - static_cast<int>(dst_v_opt[i * \ - kStrideUV + j]), DIFF); \ + for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y) * 2; ++i) { \ + for (int j = 0; j < kStrideUV; ++j) { \ + EXPECT_NEAR(static_cast<int>(dst_uv_c[i * kStrideUV + j]), \ + static_cast<int>(dst_uv_opt[i * kStrideUV + j]), DIFF); \ + } \ } \ - } \ - free_aligned_buffer_page_end(dst_y_c); \ - free_aligned_buffer_page_end(dst_u_c); \ - free_aligned_buffer_page_end(dst_v_c); \ - free_aligned_buffer_page_end(dst_y_opt); \ - free_aligned_buffer_page_end(dst_u_opt); \ - free_aligned_buffer_page_end(dst_v_opt); \ - free_aligned_buffer_page_end(src_argb); \ -} + free_aligned_buffer_page_end(dst_y_c); \ + free_aligned_buffer_page_end(dst_uv_c); \ + free_aligned_buffer_page_end(dst_y_opt); \ + free_aligned_buffer_page_end(dst_uv_opt); \ + free_aligned_buffer_page_end(src_argb); \ + } +#endif -#define TESTATOPLANAR(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - DIFF) \ - TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_ - 4, DIFF, _Any, +, 0) \ - TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_, DIFF, _Unaligned, +, 1) \ - TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_, DIFF, _Invert, -, 0) \ - TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_, DIFF, _Opt, +, 0) +#define TESTATOPLANAR(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ + DIFF) \ + TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ + benchmark_width_ - 4, DIFF, _Any, +, 0) \ + TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ + benchmark_width_, DIFF, _Unaligned, +, 1) \ + TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ + benchmark_width_, DIFF, _Invert, -, 0) \ + TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ + benchmark_width_, DIFF, _Opt, +, 0) TESTATOPLANAR(ARGB, 4, 1, I420, 2, 2, 4) -#if defined(__arm__) || defined (__aarch64__) +#if defined(__arm__) || defined(__aarch64__) // arm version subsamples by summing 4 pixels then multiplying by matrix with // 4x smaller coefficients which are rounded to nearest integer. TESTATOPLANAR(ARGB, 4, 1, J420, 2, 2, 4) @@ -777,7 +880,6 @@ TESTATOPLANAR(RGB565, 2, 1, I420, 2, 2, 5) // TODO(fbarchard): Make 1555 neon work same as C code, reduce to diff 9. TESTATOPLANAR(ARGB1555, 2, 1, I420, 2, 2, 15) TESTATOPLANAR(ARGB4444, 2, 1, I420, 2, 2, 17) -TESTATOPLANAR(ARGB, 4, 1, I411, 4, 1, 4) TESTATOPLANAR(ARGB, 4, 1, I422, 2, 1, 2) TESTATOPLANAR(ARGB, 4, 1, I444, 1, 1, 2) TESTATOPLANAR(YUY2, 2, 1, I420, 2, 2, 2) @@ -787,183 +889,173 @@ TESTATOPLANAR(UYVY, 2, 1, I422, 2, 1, 2) TESTATOPLANAR(I400, 1, 1, I420, 2, 2, 2) TESTATOPLANAR(J400, 1, 1, J420, 2, 2, 2) -#define TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, \ - SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF) \ -TEST_F(LibYUVConvertTest, FMT_A##To##FMT_PLANAR##N) { \ - const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ - const int kHeight = benchmark_height_; \ - const int kStride = SUBSAMPLE(kWidth, SUB_A) * BPP_A; \ - const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ - align_buffer_page_end(src_argb, kStride * kHeight + OFF); \ - align_buffer_page_end(dst_y_c, kWidth * kHeight); \ - align_buffer_page_end(dst_uv_c, \ - kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - align_buffer_page_end(dst_y_opt, kWidth * kHeight); \ - align_buffer_page_end(dst_uv_opt, \ - kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - for (int i = 0; i < kHeight; ++i) \ - for (int j = 0; j < kStride; ++j) \ - src_argb[(i * kStride) + j + OFF] = (fastrand() & 0xff); \ - memset(dst_y_c, 1, kWidth * kHeight); \ - memset(dst_uv_c, 2, kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - memset(dst_y_opt, 101, kWidth * kHeight); \ - memset(dst_uv_opt, 102, kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ - MaskCpuFlags(disable_cpu_flags_); \ - FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, \ - dst_y_c, kWidth, dst_uv_c, kStrideUV * 2, \ - kWidth, NEG kHeight); \ - MaskCpuFlags(benchmark_cpu_info_); \ - for (int i = 0; i < benchmark_iterations_; ++i) { \ - FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, \ - dst_y_opt, kWidth, \ - dst_uv_opt, kStrideUV * 2, kWidth, NEG kHeight); \ - } \ - int max_diff = 0; \ - for (int i = 0; i < kHeight; ++i) { \ - for (int j = 0; j < kWidth; ++j) { \ - int abs_diff = \ - abs(static_cast<int>(dst_y_c[i * kWidth + j]) - \ - static_cast<int>(dst_y_opt[i * kWidth + j])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ - } \ - } \ - } \ - EXPECT_LE(max_diff, 4); \ - for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ - for (int j = 0; j < kStrideUV * 2; ++j) { \ - int abs_diff = \ - abs(static_cast<int>(dst_uv_c[i * kStrideUV * 2 + j]) - \ - static_cast<int>(dst_uv_opt[i * kStrideUV * 2 + j])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ - } \ - } \ - } \ - EXPECT_LE(max_diff, 4); \ - free_aligned_buffer_page_end(dst_y_c); \ - free_aligned_buffer_page_end(dst_uv_c); \ - free_aligned_buffer_page_end(dst_y_opt); \ - free_aligned_buffer_page_end(dst_uv_opt); \ - free_aligned_buffer_page_end(src_argb); \ -} +#define TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, \ + SUBSAMP_Y, W1280, N, NEG, OFF) \ + TEST_F(LibYUVConvertTest, FMT_A##To##FMT_PLANAR##N) { \ + const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ + const int kHeight = benchmark_height_; \ + const int kStride = SUBSAMPLE(kWidth, SUB_A) * BPP_A; \ + const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ + align_buffer_page_end(src_argb, kStride* kHeight + OFF); \ + align_buffer_page_end(dst_y_c, kWidth* kHeight); \ + align_buffer_page_end(dst_uv_c, \ + kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + align_buffer_page_end(dst_y_opt, kWidth* kHeight); \ + align_buffer_page_end(dst_uv_opt, \ + kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + for (int i = 0; i < kHeight; ++i) \ + for (int j = 0; j < kStride; ++j) \ + src_argb[(i * kStride) + j + OFF] = (fastrand() & 0xff); \ + memset(dst_y_c, 1, kWidth* kHeight); \ + memset(dst_uv_c, 2, kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + memset(dst_y_opt, 101, kWidth* kHeight); \ + memset(dst_uv_opt, 102, kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ + MaskCpuFlags(disable_cpu_flags_); \ + FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, dst_y_c, kWidth, dst_uv_c, \ + kStrideUV * 2, kWidth, NEG kHeight); \ + MaskCpuFlags(benchmark_cpu_info_); \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, dst_y_opt, kWidth, \ + dst_uv_opt, kStrideUV * 2, kWidth, NEG kHeight); \ + } \ + int max_diff = 0; \ + for (int i = 0; i < kHeight; ++i) { \ + for (int j = 0; j < kWidth; ++j) { \ + int abs_diff = abs(static_cast<int>(dst_y_c[i * kWidth + j]) - \ + static_cast<int>(dst_y_opt[i * kWidth + j])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ + } \ + EXPECT_LE(max_diff, 4); \ + for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ + for (int j = 0; j < kStrideUV * 2; ++j) { \ + int abs_diff = \ + abs(static_cast<int>(dst_uv_c[i * kStrideUV * 2 + j]) - \ + static_cast<int>(dst_uv_opt[i * kStrideUV * 2 + j])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ + } \ + EXPECT_LE(max_diff, 4); \ + free_aligned_buffer_page_end(dst_y_c); \ + free_aligned_buffer_page_end(dst_uv_c); \ + free_aligned_buffer_page_end(dst_y_opt); \ + free_aligned_buffer_page_end(dst_uv_opt); \ + free_aligned_buffer_page_end(src_argb); \ + } #define TESTATOBIPLANAR(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \ - TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_ - 4, _Any, +, 0) \ - TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_, _Unaligned, +, 1) \ - TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_, _Invert, -, 0) \ - TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ - benchmark_width_, _Opt, +, 0) + TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ + benchmark_width_ - 4, _Any, +, 0) \ + TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ + benchmark_width_, _Unaligned, +, 1) \ + TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ + benchmark_width_, _Invert, -, 0) \ + TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ + benchmark_width_, _Opt, +, 0) TESTATOBIPLANAR(ARGB, 1, 4, NV12, 2, 2) TESTATOBIPLANAR(ARGB, 1, 4, NV21, 2, 2) TESTATOBIPLANAR(YUY2, 2, 4, NV12, 2, 2) TESTATOBIPLANAR(UYVY, 2, 4, NV12, 2, 2) -#define TESTATOBI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ - FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ - W1280, DIFF, N, NEG, OFF) \ -TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##N) { \ - const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ - const int kHeight = benchmark_height_; \ - const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \ - const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B; \ - const int kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A; \ - const int kStrideB = (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B; \ - align_buffer_page_end(src_argb, kStrideA * kHeightA + OFF); \ - align_buffer_page_end(dst_argb_c, kStrideB * kHeightB); \ - align_buffer_page_end(dst_argb_opt, kStrideB * kHeightB); \ - for (int i = 0; i < kStrideA * kHeightA; ++i) { \ - src_argb[i + OFF] = (fastrand() & 0xff); \ - } \ - memset(dst_argb_c, 1, kStrideB * kHeightB); \ - memset(dst_argb_opt, 101, kStrideB * kHeightB); \ - MaskCpuFlags(disable_cpu_flags_); \ - FMT_A##To##FMT_B(src_argb + OFF, kStrideA, \ - dst_argb_c, kStrideB, \ - kWidth, NEG kHeight); \ - MaskCpuFlags(benchmark_cpu_info_); \ - for (int i = 0; i < benchmark_iterations_; ++i) { \ - FMT_A##To##FMT_B(src_argb + OFF, kStrideA, \ - dst_argb_opt, kStrideB, \ - kWidth, NEG kHeight); \ - } \ - int max_diff = 0; \ - for (int i = 0; i < kStrideB * kHeightB; ++i) { \ - int abs_diff = \ - abs(static_cast<int>(dst_argb_c[i]) - \ - static_cast<int>(dst_argb_opt[i])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ - } \ - } \ - EXPECT_LE(max_diff, DIFF); \ - free_aligned_buffer_page_end(src_argb); \ - free_aligned_buffer_page_end(dst_argb_c); \ - free_aligned_buffer_page_end(dst_argb_opt); \ -} +#define TESTATOBI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B, \ + HEIGHT_B, W1280, DIFF, N, NEG, OFF) \ + TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##N) { \ + const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ + const int kHeight = benchmark_height_; \ + const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \ + const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B; \ + const int kStrideA = \ + (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A; \ + const int kStrideB = \ + (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B; \ + align_buffer_page_end(src_argb, kStrideA* kHeightA + OFF); \ + align_buffer_page_end(dst_argb_c, kStrideB* kHeightB); \ + align_buffer_page_end(dst_argb_opt, kStrideB* kHeightB); \ + for (int i = 0; i < kStrideA * kHeightA; ++i) { \ + src_argb[i + OFF] = (fastrand() & 0xff); \ + } \ + memset(dst_argb_c, 1, kStrideB* kHeightB); \ + memset(dst_argb_opt, 101, kStrideB* kHeightB); \ + MaskCpuFlags(disable_cpu_flags_); \ + FMT_A##To##FMT_B(src_argb + OFF, kStrideA, dst_argb_c, kStrideB, kWidth, \ + NEG kHeight); \ + MaskCpuFlags(benchmark_cpu_info_); \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + FMT_A##To##FMT_B(src_argb + OFF, kStrideA, dst_argb_opt, kStrideB, \ + kWidth, NEG kHeight); \ + } \ + int max_diff = 0; \ + for (int i = 0; i < kStrideB * kHeightB; ++i) { \ + int abs_diff = abs(static_cast<int>(dst_argb_c[i]) - \ + static_cast<int>(dst_argb_opt[i])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ + EXPECT_LE(max_diff, DIFF); \ + free_aligned_buffer_page_end(src_argb); \ + free_aligned_buffer_page_end(dst_argb_c); \ + free_aligned_buffer_page_end(dst_argb_opt); \ + } -#define TESTATOBRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ - FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF) \ -TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##_Random) { \ - for (int times = 0; times < benchmark_iterations_; ++times) { \ - const int kWidth = (fastrand() & 63) + 1; \ - const int kHeight = (fastrand() & 31) + 1; \ - const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \ - const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B; \ - const int kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A;\ - const int kStrideB = (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B;\ - align_buffer_page_end(src_argb, kStrideA * kHeightA); \ - align_buffer_page_end(dst_argb_c, kStrideB * kHeightB); \ - align_buffer_page_end(dst_argb_opt, kStrideB * kHeightB); \ - for (int i = 0; i < kStrideA * kHeightA; ++i) { \ - src_argb[i] = (fastrand() & 0xff); \ - } \ - memset(dst_argb_c, 123, kStrideB * kHeightB); \ - memset(dst_argb_opt, 123, kStrideB * kHeightB); \ - MaskCpuFlags(disable_cpu_flags_); \ - FMT_A##To##FMT_B(src_argb, kStrideA, \ - dst_argb_c, kStrideB, \ - kWidth, kHeight); \ - MaskCpuFlags(benchmark_cpu_info_); \ - FMT_A##To##FMT_B(src_argb, kStrideA, \ - dst_argb_opt, kStrideB, \ - kWidth, kHeight); \ - int max_diff = 0; \ - for (int i = 0; i < kStrideB * kHeightB; ++i) { \ - int abs_diff = \ - abs(static_cast<int>(dst_argb_c[i]) - \ - static_cast<int>(dst_argb_opt[i])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ - } \ - } \ - EXPECT_LE(max_diff, DIFF); \ - free_aligned_buffer_page_end(src_argb); \ - free_aligned_buffer_page_end(dst_argb_c); \ - free_aligned_buffer_page_end(dst_argb_opt); \ - } \ -} +#define TESTATOBRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, \ + STRIDE_B, HEIGHT_B, DIFF) \ + TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##_Random) { \ + for (int times = 0; times < benchmark_iterations_; ++times) { \ + const int kWidth = (fastrand() & 63) + 1; \ + const int kHeight = (fastrand() & 31) + 1; \ + const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \ + const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B; \ + const int kStrideA = \ + (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A; \ + const int kStrideB = \ + (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B; \ + align_buffer_page_end(src_argb, kStrideA* kHeightA); \ + align_buffer_page_end(dst_argb_c, kStrideB* kHeightB); \ + align_buffer_page_end(dst_argb_opt, kStrideB* kHeightB); \ + for (int i = 0; i < kStrideA * kHeightA; ++i) { \ + src_argb[i] = (fastrand() & 0xff); \ + } \ + memset(dst_argb_c, 123, kStrideB* kHeightB); \ + memset(dst_argb_opt, 123, kStrideB* kHeightB); \ + MaskCpuFlags(disable_cpu_flags_); \ + FMT_A##To##FMT_B(src_argb, kStrideA, dst_argb_c, kStrideB, kWidth, \ + kHeight); \ + MaskCpuFlags(benchmark_cpu_info_); \ + FMT_A##To##FMT_B(src_argb, kStrideA, dst_argb_opt, kStrideB, kWidth, \ + kHeight); \ + int max_diff = 0; \ + for (int i = 0; i < kStrideB * kHeightB; ++i) { \ + int abs_diff = abs(static_cast<int>(dst_argb_c[i]) - \ + static_cast<int>(dst_argb_opt[i])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ + EXPECT_LE(max_diff, DIFF); \ + free_aligned_buffer_page_end(src_argb); \ + free_aligned_buffer_page_end(dst_argb_c); \ + free_aligned_buffer_page_end(dst_argb_opt); \ + } \ + } -#define TESTATOB(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ - FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF) \ - TESTATOBI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ - FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ - benchmark_width_ - 4, DIFF, _Any, +, 0) \ - TESTATOBI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ - FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ - benchmark_width_, DIFF, _Unaligned, +, 1) \ - TESTATOBI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ - FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ - benchmark_width_, DIFF, _Invert, -, 0) \ - TESTATOBI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ - FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ - benchmark_width_, DIFF, _Opt, +, 0) \ - TESTATOBRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ - FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF) +#define TESTATOB(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B, \ + HEIGHT_B, DIFF) \ + TESTATOBI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B, \ + HEIGHT_B, benchmark_width_ - 4, DIFF, _Any, +, 0) \ + TESTATOBI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B, \ + HEIGHT_B, benchmark_width_, DIFF, _Unaligned, +, 1) \ + TESTATOBI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B, \ + HEIGHT_B, benchmark_width_, DIFF, _Invert, -, 0) \ + TESTATOBI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B, \ + HEIGHT_B, benchmark_width_, DIFF, _Opt, +, 0) \ + TESTATOBRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B, \ + HEIGHT_B, DIFF) TESTATOB(ARGB, 4, 4, 1, ARGB, 4, 4, 1, 0) TESTATOB(ARGB, 4, 4, 1, BGRA, 4, 4, 1, 0) @@ -989,6 +1081,7 @@ TESTATOB(ARGB1555, 2, 2, 1, ARGB, 4, 4, 1, 0) TESTATOB(ARGB4444, 2, 2, 1, ARGB, 4, 4, 1, 0) TESTATOB(YUY2, 2, 4, 1, ARGB, 4, 4, 1, 4) TESTATOB(UYVY, 2, 4, 1, ARGB, 4, 4, 1, 4) +TESTATOB(YUY2, 2, 4, 1, Y, 1, 1, 1, 0) TESTATOB(I400, 1, 1, 1, ARGB, 4, 4, 1, 0) TESTATOB(J400, 1, 1, 1, ARGB, 4, 4, 1, 0) TESTATOB(I400, 1, 1, 1, I400, 1, 1, 1, 0) @@ -996,159 +1089,146 @@ TESTATOB(J400, 1, 1, 1, J400, 1, 1, 1, 0) TESTATOB(I400, 1, 1, 1, I400Mirror, 1, 1, 1, 0) TESTATOB(ARGB, 4, 4, 1, ARGBMirror, 4, 4, 1, 0) -#define TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ - FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ - W1280, DIFF, N, NEG, OFF) \ -TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##Dither##N) { \ - const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ - const int kHeight = benchmark_height_; \ - const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \ - const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B; \ - const int kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A; \ - const int kStrideB = (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B; \ - align_buffer_page_end(src_argb, kStrideA * kHeightA + OFF); \ - align_buffer_page_end(dst_argb_c, kStrideB * kHeightB); \ - align_buffer_page_end(dst_argb_opt, kStrideB * kHeightB); \ - for (int i = 0; i < kStrideA * kHeightA; ++i) { \ - src_argb[i + OFF] = (fastrand() & 0xff); \ - } \ - memset(dst_argb_c, 1, kStrideB * kHeightB); \ - memset(dst_argb_opt, 101, kStrideB * kHeightB); \ - MaskCpuFlags(disable_cpu_flags_); \ - FMT_A##To##FMT_B##Dither(src_argb + OFF, kStrideA, \ - dst_argb_c, kStrideB, \ - NULL, kWidth, NEG kHeight); \ - MaskCpuFlags(benchmark_cpu_info_); \ - for (int i = 0; i < benchmark_iterations_; ++i) { \ - FMT_A##To##FMT_B##Dither(src_argb + OFF, kStrideA, \ - dst_argb_opt, kStrideB, \ - NULL, kWidth, NEG kHeight); \ - } \ - int max_diff = 0; \ - for (int i = 0; i < kStrideB * kHeightB; ++i) { \ - int abs_diff = \ - abs(static_cast<int>(dst_argb_c[i]) - \ - static_cast<int>(dst_argb_opt[i])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ +#define TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B, \ + HEIGHT_B, W1280, DIFF, N, NEG, OFF) \ + TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##Dither##N) { \ + const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ + const int kHeight = benchmark_height_; \ + const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \ + const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B; \ + const int kStrideA = \ + (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A; \ + const int kStrideB = \ + (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B; \ + align_buffer_page_end(src_argb, kStrideA* kHeightA + OFF); \ + align_buffer_page_end(dst_argb_c, kStrideB* kHeightB); \ + align_buffer_page_end(dst_argb_opt, kStrideB* kHeightB); \ + for (int i = 0; i < kStrideA * kHeightA; ++i) { \ + src_argb[i + OFF] = (fastrand() & 0xff); \ + } \ + memset(dst_argb_c, 1, kStrideB* kHeightB); \ + memset(dst_argb_opt, 101, kStrideB* kHeightB); \ + MaskCpuFlags(disable_cpu_flags_); \ + FMT_A##To##FMT_B##Dither(src_argb + OFF, kStrideA, dst_argb_c, kStrideB, \ + NULL, kWidth, NEG kHeight); \ + MaskCpuFlags(benchmark_cpu_info_); \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + FMT_A##To##FMT_B##Dither(src_argb + OFF, kStrideA, dst_argb_opt, \ + kStrideB, NULL, kWidth, NEG kHeight); \ + } \ + int max_diff = 0; \ + for (int i = 0; i < kStrideB * kHeightB; ++i) { \ + int abs_diff = abs(static_cast<int>(dst_argb_c[i]) - \ + static_cast<int>(dst_argb_opt[i])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ + EXPECT_LE(max_diff, DIFF); \ + free_aligned_buffer_page_end(src_argb); \ + free_aligned_buffer_page_end(dst_argb_c); \ + free_aligned_buffer_page_end(dst_argb_opt); \ + } + +#define TESTATOBDRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, \ + STRIDE_B, HEIGHT_B, DIFF) \ + TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##Dither_Random) { \ + for (int times = 0; times < benchmark_iterations_; ++times) { \ + const int kWidth = (fastrand() & 63) + 1; \ + const int kHeight = (fastrand() & 31) + 1; \ + const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \ + const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B; \ + const int kStrideA = \ + (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A; \ + const int kStrideB = \ + (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B; \ + align_buffer_page_end(src_argb, kStrideA* kHeightA); \ + align_buffer_page_end(dst_argb_c, kStrideB* kHeightB); \ + align_buffer_page_end(dst_argb_opt, kStrideB* kHeightB); \ + for (int i = 0; i < kStrideA * kHeightA; ++i) { \ + src_argb[i] = (fastrand() & 0xff); \ + } \ + memset(dst_argb_c, 123, kStrideB* kHeightB); \ + memset(dst_argb_opt, 123, kStrideB* kHeightB); \ + MaskCpuFlags(disable_cpu_flags_); \ + FMT_A##To##FMT_B##Dither(src_argb, kStrideA, dst_argb_c, kStrideB, NULL, \ + kWidth, kHeight); \ + MaskCpuFlags(benchmark_cpu_info_); \ + FMT_A##To##FMT_B##Dither(src_argb, kStrideA, dst_argb_opt, kStrideB, \ + NULL, kWidth, kHeight); \ + int max_diff = 0; \ + for (int i = 0; i < kStrideB * kHeightB; ++i) { \ + int abs_diff = abs(static_cast<int>(dst_argb_c[i]) - \ + static_cast<int>(dst_argb_opt[i])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ + EXPECT_LE(max_diff, DIFF); \ + free_aligned_buffer_page_end(src_argb); \ + free_aligned_buffer_page_end(dst_argb_c); \ + free_aligned_buffer_page_end(dst_argb_opt); \ } \ - } \ - EXPECT_LE(max_diff, DIFF); \ - free_aligned_buffer_page_end(src_argb); \ - free_aligned_buffer_page_end(dst_argb_c); \ - free_aligned_buffer_page_end(dst_argb_opt); \ -} + } + +#define TESTATOBD(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B, \ + HEIGHT_B, DIFF) \ + TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B, \ + HEIGHT_B, benchmark_width_ - 4, DIFF, _Any, +, 0) \ + TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B, \ + HEIGHT_B, benchmark_width_, DIFF, _Unaligned, +, 1) \ + TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B, \ + HEIGHT_B, benchmark_width_, DIFF, _Invert, -, 0) \ + TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B, \ + HEIGHT_B, benchmark_width_, DIFF, _Opt, +, 0) \ + TESTATOBDRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B, \ + HEIGHT_B, DIFF) + +TESTATOBD(ARGB, 4, 4, 1, RGB565, 2, 2, 1, 0) -#define TESTATOBDRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ - FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF) \ -TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##Dither_Random) { \ - for (int times = 0; times < benchmark_iterations_; ++times) { \ - const int kWidth = (fastrand() & 63) + 1; \ - const int kHeight = (fastrand() & 31) + 1; \ +#define TESTSYMI(FMT_ATOB, BPP_A, STRIDE_A, HEIGHT_A, W1280, N, NEG, OFF) \ + TEST_F(LibYUVConvertTest, FMT_ATOB##_Symetric##N) { \ + const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ + const int kHeight = benchmark_height_; \ const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \ - const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B; \ - const int kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A;\ - const int kStrideB = (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B;\ - align_buffer_page_end(src_argb, kStrideA * kHeightA); \ - align_buffer_page_end(dst_argb_c, kStrideB * kHeightB); \ - align_buffer_page_end(dst_argb_opt, kStrideB * kHeightB); \ + const int kStrideA = \ + (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A; \ + align_buffer_page_end(src_argb, kStrideA* kHeightA + OFF); \ + align_buffer_page_end(dst_argb_c, kStrideA* kHeightA); \ + align_buffer_page_end(dst_argb_opt, kStrideA* kHeightA); \ for (int i = 0; i < kStrideA * kHeightA; ++i) { \ - src_argb[i] = (fastrand() & 0xff); \ + src_argb[i + OFF] = (fastrand() & 0xff); \ } \ - memset(dst_argb_c, 123, kStrideB * kHeightB); \ - memset(dst_argb_opt, 123, kStrideB * kHeightB); \ + memset(dst_argb_c, 1, kStrideA* kHeightA); \ + memset(dst_argb_opt, 101, kStrideA* kHeightA); \ MaskCpuFlags(disable_cpu_flags_); \ - FMT_A##To##FMT_B##Dither(src_argb, kStrideA, \ - dst_argb_c, kStrideB, \ - NULL, kWidth, kHeight); \ + FMT_ATOB(src_argb + OFF, kStrideA, dst_argb_c, kStrideA, kWidth, \ + NEG kHeight); \ MaskCpuFlags(benchmark_cpu_info_); \ - FMT_A##To##FMT_B##Dither(src_argb, kStrideA, \ - dst_argb_opt, kStrideB, \ - NULL, kWidth, kHeight); \ - int max_diff = 0; \ - for (int i = 0; i < kStrideB * kHeightB; ++i) { \ - int abs_diff = \ - abs(static_cast<int>(dst_argb_c[i]) - \ - static_cast<int>(dst_argb_opt[i])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ - } \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + FMT_ATOB(src_argb + OFF, kStrideA, dst_argb_opt, kStrideA, kWidth, \ + NEG kHeight); \ + } \ + MaskCpuFlags(disable_cpu_flags_); \ + FMT_ATOB(dst_argb_c, kStrideA, dst_argb_c, kStrideA, kWidth, NEG kHeight); \ + MaskCpuFlags(benchmark_cpu_info_); \ + FMT_ATOB(dst_argb_opt, kStrideA, dst_argb_opt, kStrideA, kWidth, \ + NEG kHeight); \ + for (int i = 0; i < kStrideA * kHeightA; ++i) { \ + EXPECT_EQ(src_argb[i + OFF], dst_argb_opt[i]); \ + EXPECT_EQ(dst_argb_c[i], dst_argb_opt[i]); \ } \ - EXPECT_LE(max_diff, DIFF); \ free_aligned_buffer_page_end(src_argb); \ free_aligned_buffer_page_end(dst_argb_c); \ free_aligned_buffer_page_end(dst_argb_opt); \ - } \ -} - -#define TESTATOBD(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ - FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF) \ - TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ - FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ - benchmark_width_ - 4, DIFF, _Any, +, 0) \ - TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ - FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ - benchmark_width_, DIFF, _Unaligned, +, 1) \ - TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ - FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ - benchmark_width_, DIFF, _Invert, -, 0) \ - TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ - FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ - benchmark_width_, DIFF, _Opt, +, 0) \ - TESTATOBDRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ - FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF) - -TESTATOBD(ARGB, 4, 4, 1, RGB565, 2, 2, 1, 0) - -#define TESTSYMI(FMT_ATOB, BPP_A, STRIDE_A, HEIGHT_A, \ - W1280, N, NEG, OFF) \ -TEST_F(LibYUVConvertTest, FMT_ATOB##_Symetric##N) { \ - const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ - const int kHeight = benchmark_height_; \ - const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \ - const int kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A; \ - align_buffer_page_end(src_argb, kStrideA * kHeightA + OFF); \ - align_buffer_page_end(dst_argb_c, kStrideA * kHeightA); \ - align_buffer_page_end(dst_argb_opt, kStrideA * kHeightA); \ - for (int i = 0; i < kStrideA * kHeightA; ++i) { \ - src_argb[i + OFF] = (fastrand() & 0xff); \ - } \ - memset(dst_argb_c, 1, kStrideA * kHeightA); \ - memset(dst_argb_opt, 101, kStrideA * kHeightA); \ - MaskCpuFlags(disable_cpu_flags_); \ - FMT_ATOB(src_argb + OFF, kStrideA, \ - dst_argb_c, kStrideA, \ - kWidth, NEG kHeight); \ - MaskCpuFlags(benchmark_cpu_info_); \ - for (int i = 0; i < benchmark_iterations_; ++i) { \ - FMT_ATOB(src_argb + OFF, kStrideA, \ - dst_argb_opt, kStrideA, \ - kWidth, NEG kHeight); \ - } \ - MaskCpuFlags(disable_cpu_flags_); \ - FMT_ATOB(dst_argb_c, kStrideA, \ - dst_argb_c, kStrideA, \ - kWidth, NEG kHeight); \ - MaskCpuFlags(benchmark_cpu_info_); \ - FMT_ATOB(dst_argb_opt, kStrideA, \ - dst_argb_opt, kStrideA, \ - kWidth, NEG kHeight); \ - for (int i = 0; i < kStrideA * kHeightA; ++i) { \ - EXPECT_EQ(src_argb[i + OFF], dst_argb_opt[i]); \ - EXPECT_EQ(dst_argb_c[i], dst_argb_opt[i]); \ - } \ - free_aligned_buffer_page_end(src_argb); \ - free_aligned_buffer_page_end(dst_argb_c); \ - free_aligned_buffer_page_end(dst_argb_opt); \ -} + } #define TESTSYM(FMT_ATOB, BPP_A, STRIDE_A, HEIGHT_A) \ - TESTSYMI(FMT_ATOB, BPP_A, STRIDE_A, HEIGHT_A, \ - benchmark_width_ - 4, _Any, +, 0) \ - TESTSYMI(FMT_ATOB, BPP_A, STRIDE_A, HEIGHT_A, \ - benchmark_width_, _Unaligned, +, 1) \ - TESTSYMI(FMT_ATOB, BPP_A, STRIDE_A, HEIGHT_A, \ - benchmark_width_, _Opt, +, 0) + TESTSYMI(FMT_ATOB, BPP_A, STRIDE_A, HEIGHT_A, benchmark_width_ - 4, _Any, +, \ + 0) \ + TESTSYMI(FMT_ATOB, BPP_A, STRIDE_A, HEIGHT_A, benchmark_width_, _Unaligned, \ + +, 1) \ + TESTSYMI(FMT_ATOB, BPP_A, STRIDE_A, HEIGHT_A, benchmark_width_, _Opt, +, 0) TESTSYM(ARGBToARGB, 4, 4, 1) TESTSYM(ARGBToBGRA, 4, 4, 1) @@ -1174,8 +1254,9 @@ TEST_F(LibYUVConvertTest, Test565) { TEST_F(LibYUVConvertTest, ValidateJpeg) { const int kOff = 10; const int kMinJpeg = 64; - const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg ? - benchmark_width_ * benchmark_height_ : kMinJpeg; + const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg + ? benchmark_width_ * benchmark_height_ + : kMinJpeg; const int kSize = kImageSize + kOff; align_buffer_page_end(orig_pixels, kSize); @@ -1201,8 +1282,9 @@ TEST_F(LibYUVConvertTest, ValidateJpeg) { TEST_F(LibYUVConvertTest, ValidateJpegLarge) { const int kOff = 10; const int kMinJpeg = 64; - const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg ? - benchmark_width_ * benchmark_height_ : kMinJpeg; + const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg + ? benchmark_width_ * benchmark_height_ + : kMinJpeg; const int kSize = kImageSize + kOff; const int kMultiple = 10; const int kBufSize = kImageSize * kMultiple + kOff; @@ -1226,8 +1308,9 @@ TEST_F(LibYUVConvertTest, ValidateJpegLarge) { TEST_F(LibYUVConvertTest, InvalidateJpeg) { const int kOff = 10; const int kMinJpeg = 64; - const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg ? - benchmark_width_ * benchmark_height_ : kMinJpeg; + const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg + ? benchmark_width_ * benchmark_height_ + : kMinJpeg; const int kSize = kImageSize + kOff; align_buffer_page_end(orig_pixels, kSize); @@ -1280,17 +1363,16 @@ TEST_F(LibYUVConvertTest, FuzzJpeg) { TEST_F(LibYUVConvertTest, MJPGToI420) { const int kOff = 10; const int kMinJpeg = 64; - const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg ? - benchmark_width_ * benchmark_height_ : kMinJpeg; + const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg + ? benchmark_width_ * benchmark_height_ + : kMinJpeg; const int kSize = kImageSize + kOff; align_buffer_page_end(orig_pixels, kSize); align_buffer_page_end(dst_y_opt, benchmark_width_ * benchmark_height_); - align_buffer_page_end(dst_u_opt, - SUBSAMPLE(benchmark_width_, 2) * - SUBSAMPLE(benchmark_height_, 2)); - align_buffer_page_end(dst_v_opt, - SUBSAMPLE(benchmark_width_, 2) * - SUBSAMPLE(benchmark_height_, 2)); + align_buffer_page_end(dst_u_opt, SUBSAMPLE(benchmark_width_, 2) * + SUBSAMPLE(benchmark_height_, 2)); + align_buffer_page_end(dst_v_opt, SUBSAMPLE(benchmark_width_, 2) * + SUBSAMPLE(benchmark_height_, 2)); // EOI, SOI to make MJPG appear valid. memset(orig_pixels, 0, kSize); @@ -1300,12 +1382,11 @@ TEST_F(LibYUVConvertTest, MJPGToI420) { orig_pixels[kSize - kOff + 1] = 0xd9; // EOI. for (int times = 0; times < benchmark_iterations_; ++times) { - int ret = MJPGToI420(orig_pixels, kSize, - dst_y_opt, benchmark_width_, - dst_u_opt, SUBSAMPLE(benchmark_width_, 2), - dst_v_opt, SUBSAMPLE(benchmark_width_, 2), - benchmark_width_, benchmark_height_, - benchmark_width_, benchmark_height_); + int ret = + MJPGToI420(orig_pixels, kSize, dst_y_opt, benchmark_width_, dst_u_opt, + SUBSAMPLE(benchmark_width_, 2), dst_v_opt, + SUBSAMPLE(benchmark_width_, 2), benchmark_width_, + benchmark_height_, benchmark_width_, benchmark_height_); // Expect failure because image is not really valid. EXPECT_EQ(1, ret); } @@ -1319,8 +1400,9 @@ TEST_F(LibYUVConvertTest, MJPGToI420) { TEST_F(LibYUVConvertTest, MJPGToARGB) { const int kOff = 10; const int kMinJpeg = 64; - const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg ? - benchmark_width_ * benchmark_height_ : kMinJpeg; + const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg + ? benchmark_width_ * benchmark_height_ + : kMinJpeg; const int kSize = kImageSize + kOff; align_buffer_page_end(orig_pixels, kSize); align_buffer_page_end(dst_argb_opt, benchmark_width_ * benchmark_height_ * 4); @@ -1333,10 +1415,9 @@ TEST_F(LibYUVConvertTest, MJPGToARGB) { orig_pixels[kSize - kOff + 1] = 0xd9; // EOI. for (int times = 0; times < benchmark_iterations_; ++times) { - int ret = MJPGToARGB(orig_pixels, kSize, - dst_argb_opt, benchmark_width_ * 4, - benchmark_width_, benchmark_height_, - benchmark_width_, benchmark_height_); + int ret = MJPGToARGB(orig_pixels, kSize, dst_argb_opt, benchmark_width_ * 4, + benchmark_width_, benchmark_height_, benchmark_width_, + benchmark_height_); // Expect failure because image is not really valid. EXPECT_EQ(1, ret); } @@ -1353,66 +1434,53 @@ TEST_F(LibYUVConvertTest, NV12Crop) { const int kWidth = benchmark_width_; const int kHeight = benchmark_height_; const int crop_y = - ((benchmark_height_ - (benchmark_height_ * 360 / 480)) / 2 + 1) & ~1; + ((benchmark_height_ - (benchmark_height_ * 360 / 480)) / 2 + 1) & ~1; const int kDestWidth = benchmark_width_; const int kDestHeight = benchmark_height_ - crop_y * 2; const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); - const int sample_size = kWidth * kHeight + - kStrideUV * - SUBSAMPLE(kHeight, SUBSAMP_Y) * 2; + const int sample_size = + kWidth * kHeight + kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y) * 2; align_buffer_page_end(src_y, sample_size); uint8* src_uv = src_y + kWidth * kHeight; align_buffer_page_end(dst_y, kDestWidth * kDestHeight); - align_buffer_page_end(dst_u, - SUBSAMPLE(kDestWidth, SUBSAMP_X) * - SUBSAMPLE(kDestHeight, SUBSAMP_Y)); - align_buffer_page_end(dst_v, - SUBSAMPLE(kDestWidth, SUBSAMP_X) * - SUBSAMPLE(kDestHeight, SUBSAMP_Y)); + align_buffer_page_end(dst_u, SUBSAMPLE(kDestWidth, SUBSAMP_X) * + SUBSAMPLE(kDestHeight, SUBSAMP_Y)); + align_buffer_page_end(dst_v, SUBSAMPLE(kDestWidth, SUBSAMP_X) * + SUBSAMPLE(kDestHeight, SUBSAMP_Y)); align_buffer_page_end(dst_y_2, kDestWidth * kDestHeight); - align_buffer_page_end(dst_u_2, - SUBSAMPLE(kDestWidth, SUBSAMP_X) * - SUBSAMPLE(kDestHeight, SUBSAMP_Y)); - align_buffer_page_end(dst_v_2, - SUBSAMPLE(kDestWidth, SUBSAMP_X) * - SUBSAMPLE(kDestHeight, SUBSAMP_Y)); + align_buffer_page_end(dst_u_2, SUBSAMPLE(kDestWidth, SUBSAMP_X) * + SUBSAMPLE(kDestHeight, SUBSAMP_Y)); + align_buffer_page_end(dst_v_2, SUBSAMPLE(kDestWidth, SUBSAMP_X) * + SUBSAMPLE(kDestHeight, SUBSAMP_Y)); for (int i = 0; i < kHeight * kWidth; ++i) { src_y[i] = (fastrand() & 0xff); } - for (int i = 0; i < (SUBSAMPLE(kHeight, SUBSAMP_Y) * - kStrideUV) * 2; ++i) { + for (int i = 0; i < (SUBSAMPLE(kHeight, SUBSAMP_Y) * kStrideUV) * 2; ++i) { src_uv[i] = (fastrand() & 0xff); } memset(dst_y, 1, kDestWidth * kDestHeight); - memset(dst_u, 2, SUBSAMPLE(kDestWidth, SUBSAMP_X) * - SUBSAMPLE(kDestHeight, SUBSAMP_Y)); - memset(dst_v, 3, SUBSAMPLE(kDestWidth, SUBSAMP_X) * - SUBSAMPLE(kDestHeight, SUBSAMP_Y)); + memset(dst_u, 2, + SUBSAMPLE(kDestWidth, SUBSAMP_X) * SUBSAMPLE(kDestHeight, SUBSAMP_Y)); + memset(dst_v, 3, + SUBSAMPLE(kDestWidth, SUBSAMP_X) * SUBSAMPLE(kDestHeight, SUBSAMP_Y)); memset(dst_y_2, 1, kDestWidth * kDestHeight); - memset(dst_u_2, 2, SUBSAMPLE(kDestWidth, SUBSAMP_X) * - SUBSAMPLE(kDestHeight, SUBSAMP_Y)); - memset(dst_v_2, 3, SUBSAMPLE(kDestWidth, SUBSAMP_X) * - SUBSAMPLE(kDestHeight, SUBSAMP_Y)); - - ConvertToI420(src_y, sample_size, - dst_y_2, kDestWidth, - dst_u_2, SUBSAMPLE(kDestWidth, SUBSAMP_X), - dst_v_2, SUBSAMPLE(kDestWidth, SUBSAMP_X), - 0, crop_y, - kWidth, kHeight, - kDestWidth, kDestHeight, - libyuv::kRotate0, libyuv::FOURCC_NV12); + memset(dst_u_2, 2, + SUBSAMPLE(kDestWidth, SUBSAMP_X) * SUBSAMPLE(kDestHeight, SUBSAMP_Y)); + memset(dst_v_2, 3, + SUBSAMPLE(kDestWidth, SUBSAMP_X) * SUBSAMPLE(kDestHeight, SUBSAMP_Y)); + + ConvertToI420(src_y, sample_size, dst_y_2, kDestWidth, dst_u_2, + SUBSAMPLE(kDestWidth, SUBSAMP_X), dst_v_2, + SUBSAMPLE(kDestWidth, SUBSAMP_X), 0, crop_y, kWidth, kHeight, + kDestWidth, kDestHeight, libyuv::kRotate0, libyuv::FOURCC_NV12); NV12ToI420(src_y + crop_y * kWidth, kWidth, - src_uv + (crop_y / 2) * kStrideUV * 2, - kStrideUV * 2, - dst_y, kDestWidth, - dst_u, SUBSAMPLE(kDestWidth, SUBSAMP_X), - dst_v, SUBSAMPLE(kDestWidth, SUBSAMP_X), - kDestWidth, kDestHeight); + src_uv + (crop_y / 2) * kStrideUV * 2, kStrideUV * 2, dst_y, + kDestWidth, dst_u, SUBSAMPLE(kDestWidth, SUBSAMP_X), dst_v, + SUBSAMPLE(kDestWidth, SUBSAMP_X), kDestWidth, kDestHeight); for (int i = 0; i < kDestHeight; ++i) { for (int j = 0; j < kDestWidth; ++j) { @@ -1452,10 +1520,7 @@ TEST_F(LibYUVConvertTest, TestYToARGB) { for (int i = 0; i < 32; ++i) { printf("%2d %d: %d <-> %d,%d,%d,%d\n", i, y[i], expectedg[i], - argb[i * 4 + 0], - argb[i * 4 + 1], - argb[i * 4 + 2], - argb[i * 4 + 3]); + argb[i * 4 + 0], argb[i * 4 + 1], argb[i * 4 + 2], argb[i * 4 + 3]); } for (int i = 0; i < 32; ++i) { EXPECT_EQ(expectedg[i], argb[i * 4 + 0]); @@ -1463,10 +1528,7 @@ TEST_F(LibYUVConvertTest, TestYToARGB) { } static const uint8 kNoDither4x4[16] = { - 0, 0, 0, 0, - 0, 0, 0, 0, - 0, 0, 0, 0, - 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; TEST_F(LibYUVConvertTest, TestNoDither) { @@ -1477,12 +1539,11 @@ TEST_F(LibYUVConvertTest, TestNoDither) { MemRandomize(src_argb, benchmark_width_ * benchmark_height_ * 4); MemRandomize(dst_rgb565, benchmark_width_ * benchmark_height_ * 2); MemRandomize(dst_rgb565dither, benchmark_width_ * benchmark_height_ * 2); - ARGBToRGB565(src_argb, benchmark_width_ * 4, - dst_rgb565, benchmark_width_ * 2, + ARGBToRGB565(src_argb, benchmark_width_ * 4, dst_rgb565, benchmark_width_ * 2, benchmark_width_, benchmark_height_); - ARGBToRGB565Dither(src_argb, benchmark_width_ * 4, - dst_rgb565dither, benchmark_width_ * 2, - kNoDither4x4, benchmark_width_, benchmark_height_); + ARGBToRGB565Dither(src_argb, benchmark_width_ * 4, dst_rgb565dither, + benchmark_width_ * 2, kNoDither4x4, benchmark_width_, + benchmark_height_); for (int i = 0; i < benchmark_width_ * benchmark_height_ * 2; ++i) { EXPECT_EQ(dst_rgb565[i], dst_rgb565dither[i]); } @@ -1494,10 +1555,7 @@ TEST_F(LibYUVConvertTest, TestNoDither) { // Ordered 4x4 dither for 888 to 565. Values from 0 to 7. static const uint8 kDither565_4x4[16] = { - 0, 4, 1, 5, - 6, 2, 7, 3, - 1, 5, 0, 4, - 7, 3, 6, 2, + 0, 4, 1, 5, 6, 2, 7, 3, 1, 5, 0, 4, 7, 3, 6, 2, }; TEST_F(LibYUVConvertTest, TestDither) { @@ -1513,18 +1571,15 @@ TEST_F(LibYUVConvertTest, TestDither) { MemRandomize(dst_rgb565dither, benchmark_width_ * benchmark_height_ * 2); MemRandomize(dst_argb, benchmark_width_ * benchmark_height_ * 4); MemRandomize(dst_argbdither, benchmark_width_ * benchmark_height_ * 4); - ARGBToRGB565(src_argb, benchmark_width_ * 4, - dst_rgb565, benchmark_width_ * 2, + ARGBToRGB565(src_argb, benchmark_width_ * 4, dst_rgb565, benchmark_width_ * 2, benchmark_width_, benchmark_height_); - ARGBToRGB565Dither(src_argb, benchmark_width_ * 4, - dst_rgb565dither, benchmark_width_ * 2, - kDither565_4x4, benchmark_width_, benchmark_height_); - RGB565ToARGB(dst_rgb565, benchmark_width_ * 2, - dst_argb, benchmark_width_ * 4, - benchmark_width_, benchmark_height_); - RGB565ToARGB(dst_rgb565dither, benchmark_width_ * 2, - dst_argbdither, benchmark_width_ * 4, + ARGBToRGB565Dither(src_argb, benchmark_width_ * 4, dst_rgb565dither, + benchmark_width_ * 2, kDither565_4x4, benchmark_width_, + benchmark_height_); + RGB565ToARGB(dst_rgb565, benchmark_width_ * 2, dst_argb, benchmark_width_ * 4, benchmark_width_, benchmark_height_); + RGB565ToARGB(dst_rgb565dither, benchmark_width_ * 2, dst_argbdither, + benchmark_width_ * 4, benchmark_width_, benchmark_height_); for (int i = 0; i < benchmark_width_ * benchmark_height_ * 4; ++i) { EXPECT_NEAR(dst_argb[i], dst_argbdither[i], 9); @@ -1537,218 +1592,197 @@ TEST_F(LibYUVConvertTest, TestDither) { } #define TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ - YALIGN, W1280, DIFF, N, NEG, OFF, FMT_C, BPP_C) \ -TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##Dither##N) { \ - const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ - const int kHeight = ALIGNINT(benchmark_height_, YALIGN); \ - const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN); \ - const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ - const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y); \ - align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ - align_buffer_page_end(src_u, kSizeUV + OFF); \ - align_buffer_page_end(src_v, kSizeUV + OFF); \ - align_buffer_page_end(dst_argb_c, kStrideB * kHeight + OFF); \ - align_buffer_page_end(dst_argb_opt, kStrideB * kHeight + OFF); \ - for (int i = 0; i < kWidth * kHeight; ++i) { \ - src_y[i + OFF] = (fastrand() & 0xff); \ - } \ - for (int i = 0; i < kSizeUV; ++i) { \ - src_u[i + OFF] = (fastrand() & 0xff); \ - src_v[i + OFF] = (fastrand() & 0xff); \ - } \ - memset(dst_argb_c + OFF, 1, kStrideB * kHeight); \ - memset(dst_argb_opt + OFF, 101, kStrideB * kHeight); \ - MaskCpuFlags(disable_cpu_flags_); \ - FMT_PLANAR##To##FMT_B##Dither(src_y + OFF, kWidth, \ - src_u + OFF, kStrideUV, \ - src_v + OFF, kStrideUV, \ - dst_argb_c + OFF, kStrideB, \ - NULL, kWidth, NEG kHeight); \ - MaskCpuFlags(benchmark_cpu_info_); \ - for (int i = 0; i < benchmark_iterations_; ++i) { \ - FMT_PLANAR##To##FMT_B##Dither(src_y + OFF, kWidth, \ - src_u + OFF, kStrideUV, \ - src_v + OFF, kStrideUV, \ - dst_argb_opt + OFF, kStrideB, \ - NULL, kWidth, NEG kHeight); \ - } \ - int max_diff = 0; \ - /* Convert to ARGB so 565 is expanded to bytes that can be compared. */ \ - align_buffer_page_end(dst_argb32_c, kWidth * BPP_C * kHeight); \ - align_buffer_page_end(dst_argb32_opt, kWidth * BPP_C * kHeight); \ - memset(dst_argb32_c, 2, kWidth * BPP_C * kHeight); \ - memset(dst_argb32_opt, 102, kWidth * BPP_C * kHeight); \ - FMT_B##To##FMT_C(dst_argb_c + OFF, kStrideB, \ - dst_argb32_c, kWidth * BPP_C , \ - kWidth, kHeight); \ - FMT_B##To##FMT_C(dst_argb_opt + OFF, kStrideB, \ - dst_argb32_opt, kWidth * BPP_C , \ - kWidth, kHeight); \ - for (int i = 0; i < kWidth * BPP_C * kHeight; ++i) { \ - int abs_diff = \ - abs(static_cast<int>(dst_argb32_c[i]) - \ - static_cast<int>(dst_argb32_opt[i])); \ - if (abs_diff > max_diff) { \ - max_diff = abs_diff; \ + YALIGN, W1280, DIFF, N, NEG, OFF, FMT_C, BPP_C) \ + TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##Dither##N) { \ + const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ + const int kHeight = ALIGNINT(benchmark_height_, YALIGN); \ + const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN); \ + const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ + const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y); \ + align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ + align_buffer_page_end(src_u, kSizeUV + OFF); \ + align_buffer_page_end(src_v, kSizeUV + OFF); \ + align_buffer_page_end(dst_argb_c, kStrideB* kHeight + OFF); \ + align_buffer_page_end(dst_argb_opt, kStrideB* kHeight + OFF); \ + for (int i = 0; i < kWidth * kHeight; ++i) { \ + src_y[i + OFF] = (fastrand() & 0xff); \ } \ - } \ - EXPECT_LE(max_diff, DIFF); \ - free_aligned_buffer_page_end(src_y); \ - free_aligned_buffer_page_end(src_u); \ - free_aligned_buffer_page_end(src_v); \ - free_aligned_buffer_page_end(dst_argb_c); \ - free_aligned_buffer_page_end(dst_argb_opt); \ - free_aligned_buffer_page_end(dst_argb32_c); \ - free_aligned_buffer_page_end(dst_argb32_opt); \ -} + for (int i = 0; i < kSizeUV; ++i) { \ + src_u[i + OFF] = (fastrand() & 0xff); \ + src_v[i + OFF] = (fastrand() & 0xff); \ + } \ + memset(dst_argb_c + OFF, 1, kStrideB * kHeight); \ + memset(dst_argb_opt + OFF, 101, kStrideB * kHeight); \ + MaskCpuFlags(disable_cpu_flags_); \ + FMT_PLANAR##To##FMT_B##Dither(src_y + OFF, kWidth, src_u + OFF, kStrideUV, \ + src_v + OFF, kStrideUV, dst_argb_c + OFF, \ + kStrideB, NULL, kWidth, NEG kHeight); \ + MaskCpuFlags(benchmark_cpu_info_); \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + FMT_PLANAR##To##FMT_B##Dither( \ + src_y + OFF, kWidth, src_u + OFF, kStrideUV, src_v + OFF, kStrideUV, \ + dst_argb_opt + OFF, kStrideB, NULL, kWidth, NEG kHeight); \ + } \ + int max_diff = 0; \ + /* Convert to ARGB so 565 is expanded to bytes that can be compared. */ \ + align_buffer_page_end(dst_argb32_c, kWidth* BPP_C* kHeight); \ + align_buffer_page_end(dst_argb32_opt, kWidth* BPP_C* kHeight); \ + memset(dst_argb32_c, 2, kWidth* BPP_C* kHeight); \ + memset(dst_argb32_opt, 102, kWidth* BPP_C* kHeight); \ + FMT_B##To##FMT_C(dst_argb_c + OFF, kStrideB, dst_argb32_c, kWidth * BPP_C, \ + kWidth, kHeight); \ + FMT_B##To##FMT_C(dst_argb_opt + OFF, kStrideB, dst_argb32_opt, \ + kWidth * BPP_C, kWidth, kHeight); \ + for (int i = 0; i < kWidth * BPP_C * kHeight; ++i) { \ + int abs_diff = abs(static_cast<int>(dst_argb32_c[i]) - \ + static_cast<int>(dst_argb32_opt[i])); \ + if (abs_diff > max_diff) { \ + max_diff = abs_diff; \ + } \ + } \ + EXPECT_LE(max_diff, DIFF); \ + free_aligned_buffer_page_end(src_y); \ + free_aligned_buffer_page_end(src_u); \ + free_aligned_buffer_page_end(src_v); \ + free_aligned_buffer_page_end(dst_argb_c); \ + free_aligned_buffer_page_end(dst_argb_opt); \ + free_aligned_buffer_page_end(dst_argb32_c); \ + free_aligned_buffer_page_end(dst_argb32_opt); \ + } #define TESTPLANARTOBD(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ - YALIGN, DIFF, FMT_C, BPP_C) \ - TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ - YALIGN, benchmark_width_ - 4, DIFF, _Any, +, 0, FMT_C, BPP_C) \ - TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ - YALIGN, benchmark_width_, DIFF, _Unaligned, +, 1, FMT_C, BPP_C) \ - TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ - YALIGN, benchmark_width_, DIFF, _Invert, -, 0, FMT_C, BPP_C) \ - TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ - YALIGN, benchmark_width_, DIFF, _Opt, +, 0, FMT_C, BPP_C) + YALIGN, DIFF, FMT_C, BPP_C) \ + TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ + YALIGN, benchmark_width_ - 4, DIFF, _Any, +, 0, FMT_C, \ + BPP_C) \ + TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ + YALIGN, benchmark_width_, DIFF, _Unaligned, +, 1, FMT_C, \ + BPP_C) \ + TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ + YALIGN, benchmark_width_, DIFF, _Invert, -, 0, FMT_C, BPP_C) \ + TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ + YALIGN, benchmark_width_, DIFF, _Opt, +, 0, FMT_C, BPP_C) TESTPLANARTOBD(I420, 2, 2, RGB565, 2, 2, 1, 9, ARGB, 4) -#define TESTPTOB(NAME, UYVYTOI420, UYVYTONV12) \ -TEST_F(LibYUVConvertTest, NAME) { \ - const int kWidth = benchmark_width_; \ - const int kHeight = benchmark_height_; \ - \ - align_buffer_page_end(orig_uyvy, \ - 4 * SUBSAMPLE(kWidth, 2) * kHeight); \ - align_buffer_page_end(orig_y, kWidth * kHeight); \ - align_buffer_page_end(orig_u, \ - SUBSAMPLE(kWidth, 2) * \ - SUBSAMPLE(kHeight, 2)); \ - align_buffer_page_end(orig_v, \ - SUBSAMPLE(kWidth, 2) * \ - SUBSAMPLE(kHeight, 2)); \ - \ - align_buffer_page_end(dst_y_orig, kWidth * kHeight); \ - align_buffer_page_end(dst_uv_orig, 2 * \ - SUBSAMPLE(kWidth, 2) * \ - SUBSAMPLE(kHeight, 2)); \ - \ - align_buffer_page_end(dst_y, kWidth * kHeight); \ - align_buffer_page_end(dst_uv, 2 * \ - SUBSAMPLE(kWidth, 2) * \ - SUBSAMPLE(kHeight, 2)); \ - \ - MemRandomize(orig_uyvy, 4 * SUBSAMPLE(kWidth, 2) * kHeight); \ - \ - /* Convert UYVY to NV12 in 2 steps for reference */ \ - libyuv::UYVYTOI420(orig_uyvy, 4 * SUBSAMPLE(kWidth, 2), \ - orig_y, kWidth, \ - orig_u, SUBSAMPLE(kWidth, 2), \ - orig_v, SUBSAMPLE(kWidth, 2), \ - kWidth, kHeight); \ - libyuv::I420ToNV12(orig_y, kWidth, \ - orig_u, SUBSAMPLE(kWidth, 2), \ - orig_v, SUBSAMPLE(kWidth, 2), \ - dst_y_orig, kWidth, \ - dst_uv_orig, 2 * SUBSAMPLE(kWidth, 2), \ - kWidth, kHeight); \ - \ - /* Convert to NV12 */ \ - for (int i = 0; i < benchmark_iterations_; ++i) { \ - libyuv::UYVYTONV12(orig_uyvy, 4 * SUBSAMPLE(kWidth, 2), \ - dst_y, kWidth, \ - dst_uv, 2 * SUBSAMPLE(kWidth, 2), \ - kWidth, kHeight); \ - } \ - \ - for (int i = 0; i < kWidth * kHeight; ++i) { \ - EXPECT_EQ(orig_y[i], dst_y[i]); \ - } \ - for (int i = 0; i < kWidth * kHeight; ++i) { \ - EXPECT_EQ(dst_y_orig[i], dst_y[i]); \ - } \ - for (int i = 0; i < 2 * SUBSAMPLE(kWidth, 2) * SUBSAMPLE(kHeight, 2); ++i) { \ - EXPECT_EQ(dst_uv_orig[i], dst_uv[i]); \ - } \ - \ - free_aligned_buffer_page_end(orig_uyvy); \ - free_aligned_buffer_page_end(orig_y); \ - free_aligned_buffer_page_end(orig_u); \ - free_aligned_buffer_page_end(orig_v); \ - free_aligned_buffer_page_end(dst_y_orig); \ - free_aligned_buffer_page_end(dst_uv_orig); \ - free_aligned_buffer_page_end(dst_y); \ - free_aligned_buffer_page_end(dst_uv); \ -} +#define TESTPTOB(NAME, UYVYTOI420, UYVYTONV12) \ + TEST_F(LibYUVConvertTest, NAME) { \ + const int kWidth = benchmark_width_; \ + const int kHeight = benchmark_height_; \ + \ + align_buffer_page_end(orig_uyvy, 4 * SUBSAMPLE(kWidth, 2) * kHeight); \ + align_buffer_page_end(orig_y, kWidth* kHeight); \ + align_buffer_page_end(orig_u, \ + SUBSAMPLE(kWidth, 2) * SUBSAMPLE(kHeight, 2)); \ + align_buffer_page_end(orig_v, \ + SUBSAMPLE(kWidth, 2) * SUBSAMPLE(kHeight, 2)); \ + \ + align_buffer_page_end(dst_y_orig, kWidth* kHeight); \ + align_buffer_page_end(dst_uv_orig, \ + 2 * SUBSAMPLE(kWidth, 2) * SUBSAMPLE(kHeight, 2)); \ + \ + align_buffer_page_end(dst_y, kWidth* kHeight); \ + align_buffer_page_end(dst_uv, \ + 2 * SUBSAMPLE(kWidth, 2) * SUBSAMPLE(kHeight, 2)); \ + \ + MemRandomize(orig_uyvy, 4 * SUBSAMPLE(kWidth, 2) * kHeight); \ + \ + /* Convert UYVY to NV12 in 2 steps for reference */ \ + libyuv::UYVYTOI420(orig_uyvy, 4 * SUBSAMPLE(kWidth, 2), orig_y, kWidth, \ + orig_u, SUBSAMPLE(kWidth, 2), orig_v, \ + SUBSAMPLE(kWidth, 2), kWidth, kHeight); \ + libyuv::I420ToNV12(orig_y, kWidth, orig_u, SUBSAMPLE(kWidth, 2), orig_v, \ + SUBSAMPLE(kWidth, 2), dst_y_orig, kWidth, dst_uv_orig, \ + 2 * SUBSAMPLE(kWidth, 2), kWidth, kHeight); \ + \ + /* Convert to NV12 */ \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + libyuv::UYVYTONV12(orig_uyvy, 4 * SUBSAMPLE(kWidth, 2), dst_y, kWidth, \ + dst_uv, 2 * SUBSAMPLE(kWidth, 2), kWidth, kHeight); \ + } \ + \ + for (int i = 0; i < kWidth * kHeight; ++i) { \ + EXPECT_EQ(orig_y[i], dst_y[i]); \ + } \ + for (int i = 0; i < kWidth * kHeight; ++i) { \ + EXPECT_EQ(dst_y_orig[i], dst_y[i]); \ + } \ + for (int i = 0; i < 2 * SUBSAMPLE(kWidth, 2) * SUBSAMPLE(kHeight, 2); \ + ++i) { \ + EXPECT_EQ(dst_uv_orig[i], dst_uv[i]); \ + } \ + \ + free_aligned_buffer_page_end(orig_uyvy); \ + free_aligned_buffer_page_end(orig_y); \ + free_aligned_buffer_page_end(orig_u); \ + free_aligned_buffer_page_end(orig_v); \ + free_aligned_buffer_page_end(dst_y_orig); \ + free_aligned_buffer_page_end(dst_uv_orig); \ + free_aligned_buffer_page_end(dst_y); \ + free_aligned_buffer_page_end(dst_uv); \ + } TESTPTOB(TestYUY2ToNV12, YUY2ToI420, YUY2ToNV12) TESTPTOB(TestUYVYToNV12, UYVYToI420, UYVYToNV12) -#define TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ - W1280, N, NEG, OFF, FMT_C, BPP_C) \ -TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##_##FMT_C##N) { \ - const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ - const int kHeight = benchmark_height_; \ - const int kStrideB = SUBSAMPLE(kWidth, SUB_B) * BPP_B; \ - const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ - const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y); \ - align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ - align_buffer_page_end(src_u, kSizeUV + OFF); \ - align_buffer_page_end(src_v, kSizeUV + OFF); \ - align_buffer_page_end(dst_argb_b, kStrideB * kHeight + OFF); \ - for (int i = 0; i < kWidth * kHeight; ++i) { \ - src_y[i + OFF] = (fastrand() & 0xff); \ - } \ - for (int i = 0; i < kSizeUV; ++i) { \ - src_u[i + OFF] = (fastrand() & 0xff); \ - src_v[i + OFF] = (fastrand() & 0xff); \ - } \ - memset(dst_argb_b + OFF, 1, kStrideB * kHeight); \ - for (int i = 0; i < benchmark_iterations_; ++i) { \ - FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, \ - src_u + OFF, kStrideUV, \ - src_v + OFF, kStrideUV, \ - dst_argb_b + OFF, kStrideB, \ - kWidth, NEG kHeight); \ - } \ - /* Convert to a 3rd format in 1 step and 2 steps and compare */ \ - const int kStrideC = kWidth * BPP_C; \ - align_buffer_page_end(dst_argb_c, kStrideC * kHeight + OFF); \ - align_buffer_page_end(dst_argb_bc, kStrideC * kHeight + OFF); \ - memset(dst_argb_c + OFF, 2, kStrideC * kHeight); \ - memset(dst_argb_bc + OFF, 3, kStrideC * kHeight); \ - FMT_PLANAR##To##FMT_C(src_y + OFF, kWidth, \ - src_u + OFF, kStrideUV, \ - src_v + OFF, kStrideUV, \ - dst_argb_c + OFF, kStrideC, \ - kWidth, NEG kHeight); \ - /* Convert B to C */ \ - FMT_B##To##FMT_C(dst_argb_b + OFF, kStrideB, \ - dst_argb_bc + OFF, kStrideC, \ - kWidth, kHeight); \ - for (int i = 0; i < kStrideC * kHeight; ++i) { \ - EXPECT_EQ(dst_argb_c[i + OFF], dst_argb_bc[i + OFF]); \ - } \ - free_aligned_buffer_page_end(src_y); \ - free_aligned_buffer_page_end(src_u); \ - free_aligned_buffer_page_end(src_v); \ - free_aligned_buffer_page_end(dst_argb_b); \ - free_aligned_buffer_page_end(dst_argb_c); \ - free_aligned_buffer_page_end(dst_argb_bc); \ -} +#define TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ + W1280, N, NEG, OFF, FMT_C, BPP_C) \ + TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##_##FMT_C##N) { \ + const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ + const int kHeight = benchmark_height_; \ + const int kStrideB = SUBSAMPLE(kWidth, SUB_B) * BPP_B; \ + const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ + const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y); \ + align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ + align_buffer_page_end(src_u, kSizeUV + OFF); \ + align_buffer_page_end(src_v, kSizeUV + OFF); \ + align_buffer_page_end(dst_argb_b, kStrideB* kHeight + OFF); \ + for (int i = 0; i < kWidth * kHeight; ++i) { \ + src_y[i + OFF] = (fastrand() & 0xff); \ + } \ + for (int i = 0; i < kSizeUV; ++i) { \ + src_u[i + OFF] = (fastrand() & 0xff); \ + src_v[i + OFF] = (fastrand() & 0xff); \ + } \ + memset(dst_argb_b + OFF, 1, kStrideB * kHeight); \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, src_u + OFF, kStrideUV, \ + src_v + OFF, kStrideUV, dst_argb_b + OFF, \ + kStrideB, kWidth, NEG kHeight); \ + } \ + /* Convert to a 3rd format in 1 step and 2 steps and compare */ \ + const int kStrideC = kWidth * BPP_C; \ + align_buffer_page_end(dst_argb_c, kStrideC* kHeight + OFF); \ + align_buffer_page_end(dst_argb_bc, kStrideC* kHeight + OFF); \ + memset(dst_argb_c + OFF, 2, kStrideC * kHeight); \ + memset(dst_argb_bc + OFF, 3, kStrideC * kHeight); \ + FMT_PLANAR##To##FMT_C(src_y + OFF, kWidth, src_u + OFF, kStrideUV, \ + src_v + OFF, kStrideUV, dst_argb_c + OFF, kStrideC, \ + kWidth, NEG kHeight); \ + /* Convert B to C */ \ + FMT_B##To##FMT_C(dst_argb_b + OFF, kStrideB, dst_argb_bc + OFF, kStrideC, \ + kWidth, kHeight); \ + for (int i = 0; i < kStrideC * kHeight; ++i) { \ + EXPECT_EQ(dst_argb_c[i + OFF], dst_argb_bc[i + OFF]); \ + } \ + free_aligned_buffer_page_end(src_y); \ + free_aligned_buffer_page_end(src_u); \ + free_aligned_buffer_page_end(src_v); \ + free_aligned_buffer_page_end(dst_argb_b); \ + free_aligned_buffer_page_end(dst_argb_c); \ + free_aligned_buffer_page_end(dst_argb_bc); \ + } -#define TESTPLANARTOE(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ - FMT_C, BPP_C) \ - TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ - benchmark_width_ - 4, _Any, +, 0, FMT_C, BPP_C) \ - TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ - benchmark_width_, _Unaligned, +, 1, FMT_C, BPP_C) \ - TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ - benchmark_width_, _Invert, -, 0, FMT_C, BPP_C) \ - TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ - benchmark_width_, _Opt, +, 0, FMT_C, BPP_C) +#define TESTPLANARTOE(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ + FMT_C, BPP_C) \ + TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ + benchmark_width_ - 4, _Any, +, 0, FMT_C, BPP_C) \ + TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ + benchmark_width_, _Unaligned, +, 1, FMT_C, BPP_C) \ + TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ + benchmark_width_, _Invert, -, 0, FMT_C, BPP_C) \ + TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ + benchmark_width_, _Opt, +, 0, FMT_C, BPP_C) TESTPLANARTOE(I420, 2, 2, ARGB, 1, 4, ABGR, 4) TESTPLANARTOE(J420, 2, 2, ARGB, 1, 4, ARGB, 4) @@ -1774,7 +1808,6 @@ TESTPLANARTOE(H422, 2, 1, ABGR, 1, 4, ARGB, 4) TESTPLANARTOE(I422, 2, 1, BGRA, 1, 4, ARGB, 4) TESTPLANARTOE(I422, 2, 1, ABGR, 1, 4, ARGB, 4) TESTPLANARTOE(I422, 2, 1, RGBA, 1, 4, ARGB, 4) -TESTPLANARTOE(I411, 4, 1, ARGB, 1, 4, ARGB, 4) TESTPLANARTOE(I444, 1, 1, ARGB, 1, 4, ARGB, 4) TESTPLANARTOE(J444, 1, 1, ARGB, 1, 4, ARGB, 4) TESTPLANARTOE(I444, 1, 1, ABGR, 1, 4, ARGB, 4) @@ -1784,78 +1817,107 @@ TESTPLANARTOE(I422, 2, 1, YUY2, 2, 4, ARGB, 4) TESTPLANARTOE(I422, 2, 1, UYVY, 2, 4, ARGB, 4) #define TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ - W1280, N, NEG, OFF, FMT_C, BPP_C, ATTEN) \ -TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##_##FMT_C##N) { \ - const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ - const int kHeight = benchmark_height_; \ - const int kStrideB = SUBSAMPLE(kWidth, SUB_B) * BPP_B; \ - const int kSizeUV = \ - SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y); \ - align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ - align_buffer_page_end(src_u, kSizeUV + OFF); \ - align_buffer_page_end(src_v, kSizeUV + OFF); \ - align_buffer_page_end(src_a, kWidth * kHeight + OFF); \ - align_buffer_page_end(dst_argb_b, kStrideB * kHeight + OFF); \ - for (int i = 0; i < kWidth * kHeight; ++i) { \ - src_y[i + OFF] = (fastrand() & 0xff); \ - src_a[i + OFF] = (fastrand() & 0xff); \ - } \ - for (int i = 0; i < kSizeUV; ++i) { \ - src_u[i + OFF] = (fastrand() & 0xff); \ - src_v[i + OFF] = (fastrand() & 0xff); \ - } \ - memset(dst_argb_b + OFF, 1, kStrideB * kHeight); \ - for (int i = 0; i < benchmark_iterations_; ++i) { \ - FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, \ - src_u + OFF, SUBSAMPLE(kWidth, SUBSAMP_X), \ - src_v + OFF, SUBSAMPLE(kWidth, SUBSAMP_X), \ - src_a + OFF, kWidth, \ - dst_argb_b + OFF, kStrideB, \ - kWidth, NEG kHeight, ATTEN); \ - } \ - int max_diff = 0; \ - /* Convert to a 3rd format in 1 step and 2 steps and compare */ \ - const int kStrideC = kWidth * BPP_C; \ - align_buffer_page_end(dst_argb_c, kStrideC * kHeight + OFF); \ - align_buffer_page_end(dst_argb_bc, kStrideC * kHeight + OFF); \ - memset(dst_argb_c + OFF, 2, kStrideC * kHeight); \ - memset(dst_argb_bc + OFF, 3, kStrideC * kHeight); \ - FMT_PLANAR##To##FMT_C(src_y + OFF, kWidth, \ - src_u + OFF, SUBSAMPLE(kWidth, SUBSAMP_X), \ - src_v + OFF, SUBSAMPLE(kWidth, SUBSAMP_X), \ - src_a + OFF, kWidth, \ - dst_argb_c + OFF, kStrideC, \ - kWidth, NEG kHeight, ATTEN); \ - /* Convert B to C */ \ - FMT_B##To##FMT_C(dst_argb_b + OFF, kStrideB, \ - dst_argb_bc + OFF, kStrideC, \ - kWidth, kHeight); \ - for (int i = 0; i < kStrideC * kHeight; ++i) { \ - EXPECT_EQ(dst_argb_c[i + OFF], dst_argb_bc[i + OFF]); \ - } \ - free_aligned_buffer_page_end(src_y); \ - free_aligned_buffer_page_end(src_u); \ - free_aligned_buffer_page_end(src_v); \ - free_aligned_buffer_page_end(src_a); \ - free_aligned_buffer_page_end(dst_argb_b); \ - free_aligned_buffer_page_end(dst_argb_c); \ - free_aligned_buffer_page_end(dst_argb_bc); \ -} + W1280, N, NEG, OFF, FMT_C, BPP_C, ATTEN) \ + TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##_##FMT_C##N) { \ + const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ + const int kHeight = benchmark_height_; \ + const int kStrideB = SUBSAMPLE(kWidth, SUB_B) * BPP_B; \ + const int kSizeUV = \ + SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y); \ + align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ + align_buffer_page_end(src_u, kSizeUV + OFF); \ + align_buffer_page_end(src_v, kSizeUV + OFF); \ + align_buffer_page_end(src_a, kWidth* kHeight + OFF); \ + align_buffer_page_end(dst_argb_b, kStrideB* kHeight + OFF); \ + for (int i = 0; i < kWidth * kHeight; ++i) { \ + src_y[i + OFF] = (fastrand() & 0xff); \ + src_a[i + OFF] = (fastrand() & 0xff); \ + } \ + for (int i = 0; i < kSizeUV; ++i) { \ + src_u[i + OFF] = (fastrand() & 0xff); \ + src_v[i + OFF] = (fastrand() & 0xff); \ + } \ + memset(dst_argb_b + OFF, 1, kStrideB * kHeight); \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + FMT_PLANAR##To##FMT_B( \ + src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SUBSAMP_X), \ + src_v + OFF, SUBSAMPLE(kWidth, SUBSAMP_X), src_a + OFF, kWidth, \ + dst_argb_b + OFF, kStrideB, kWidth, NEG kHeight, ATTEN); \ + } \ + /* Convert to a 3rd format in 1 step and 2 steps and compare */ \ + const int kStrideC = kWidth * BPP_C; \ + align_buffer_page_end(dst_argb_c, kStrideC* kHeight + OFF); \ + align_buffer_page_end(dst_argb_bc, kStrideC* kHeight + OFF); \ + memset(dst_argb_c + OFF, 2, kStrideC * kHeight); \ + memset(dst_argb_bc + OFF, 3, kStrideC * kHeight); \ + FMT_PLANAR##To##FMT_C( \ + src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SUBSAMP_X), \ + src_v + OFF, SUBSAMPLE(kWidth, SUBSAMP_X), src_a + OFF, kWidth, \ + dst_argb_c + OFF, kStrideC, kWidth, NEG kHeight, ATTEN); \ + /* Convert B to C */ \ + FMT_B##To##FMT_C(dst_argb_b + OFF, kStrideB, dst_argb_bc + OFF, kStrideC, \ + kWidth, kHeight); \ + for (int i = 0; i < kStrideC * kHeight; ++i) { \ + EXPECT_EQ(dst_argb_c[i + OFF], dst_argb_bc[i + OFF]); \ + } \ + free_aligned_buffer_page_end(src_y); \ + free_aligned_buffer_page_end(src_u); \ + free_aligned_buffer_page_end(src_v); \ + free_aligned_buffer_page_end(src_a); \ + free_aligned_buffer_page_end(dst_argb_b); \ + free_aligned_buffer_page_end(dst_argb_c); \ + free_aligned_buffer_page_end(dst_argb_bc); \ + } -#define TESTQPLANARTOE(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ - FMT_C, BPP_C) \ - TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ - benchmark_width_ - 4, _Any, +, 0, FMT_C, BPP_C, 0) \ - TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ - benchmark_width_, _Unaligned, +, 1, FMT_C, BPP_C, 0) \ - TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ - benchmark_width_, _Invert, -, 0, FMT_C, BPP_C, 0) \ - TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ - benchmark_width_, _Opt, +, 0, FMT_C, BPP_C, 0) \ - TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ - benchmark_width_, _Premult, +, 0, FMT_C, BPP_C, 1) +#define TESTQPLANARTOE(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ + FMT_C, BPP_C) \ + TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ + benchmark_width_ - 4, _Any, +, 0, FMT_C, BPP_C, 0) \ + TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ + benchmark_width_, _Unaligned, +, 1, FMT_C, BPP_C, 0) \ + TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ + benchmark_width_, _Invert, -, 0, FMT_C, BPP_C, 0) \ + TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ + benchmark_width_, _Opt, +, 0, FMT_C, BPP_C, 0) \ + TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ + benchmark_width_, _Premult, +, 0, FMT_C, BPP_C, 1) TESTQPLANARTOE(I420Alpha, 2, 2, ARGB, 1, 4, ABGR, 4) TESTQPLANARTOE(I420Alpha, 2, 2, ABGR, 1, 4, ARGB, 4) +TEST_F(LibYUVConvertTest, RotateWithARGBSource) { + // 2x2 frames + uint32_t src[4]; + uint32_t dst[4]; + // some random input + src[0] = 0x11000000; + src[1] = 0x00450000; + src[2] = 0x00009f00; + src[3] = 0x000000ff; + // zeros on destination + dst[0] = 0x00000000; + dst[1] = 0x00000000; + dst[2] = 0x00000000; + dst[3] = 0x00000000; + + int r = ConvertToARGB(reinterpret_cast<uint8_t*>(src), + 16, // input size + reinterpret_cast<uint8_t*>(dst), + 8, // destination stride + 0, // crop_x + 0, // crop_y + 2, // width + 2, // height + 2, // crop width + 2, // crop height + kRotate90, FOURCC_ARGB); + + EXPECT_EQ(r, 0); + // 90 degrees rotation, no conversion + EXPECT_EQ(dst[0], src[2]); + EXPECT_EQ(dst[1], src[0]); + EXPECT_EQ(dst[2], src[3]); + EXPECT_EQ(dst[3], src[1]); +} + } // namespace libyuv diff --git a/files/unit_test/cpu_test.cc b/files/unit_test/cpu_test.cc index 0cd06f9b..048ed31a 100644 --- a/files/unit_test/cpu_test.cc +++ b/files/unit_test/cpu_test.cc @@ -11,10 +11,10 @@ #include <stdlib.h> #include <string.h> +#include "../unit_test/unit_test.h" #include "libyuv/basic_types.h" #include "libyuv/cpu_id.h" #include "libyuv/version.h" -#include "../unit_test/unit_test.h" namespace libyuv { @@ -45,10 +45,14 @@ TEST_F(LibYUVBaseTest, TestCpuHas) { printf("Has FMA3 %x\n", has_fma3); int has_avx3 = TestCpuFlag(kCpuHasAVX3); printf("Has AVX3 %x\n", has_avx3); + int has_f16c = TestCpuFlag(kCpuHasF16C); + printf("Has F16C %x\n", has_f16c); int has_mips = TestCpuFlag(kCpuHasMIPS); printf("Has MIPS %x\n", has_mips); int has_dspr2 = TestCpuFlag(kCpuHasDSPR2); printf("Has DSPR2 %x\n", has_dspr2); + int has_msa = TestCpuFlag(kCpuHasMSA); + printf("Has MSA %x\n", has_msa); } TEST_F(LibYUVBaseTest, TestCpuCompilerEnabled) { @@ -62,19 +66,20 @@ TEST_F(LibYUVBaseTest, TestCpuCompilerEnabled) { printf("x64 build\n"); #endif #ifdef _MSC_VER -printf("_MSC_VER %d\n", _MSC_VER); + printf("_MSC_VER %d\n", _MSC_VER); #endif -#if !defined(LIBYUV_DISABLE_X86) && (defined(GCC_HAS_AVX2) || \ - defined(CLANG_HAS_AVX2) || defined(VISUALC_HAS_AVX2)) +#if !defined(LIBYUV_DISABLE_X86) && \ + (defined(GCC_HAS_AVX2) || defined(CLANG_HAS_AVX2) || \ + defined(VISUALC_HAS_AVX2)) printf("Has AVX2 1\n"); #else printf("Has AVX2 0\n"); - // If compiler does not support AVX2, the following function not expected: +// If compiler does not support AVX2, the following function not expected: #endif } -#if defined(__i386__) || defined(__x86_64__) || \ - defined(_M_IX86) || defined(_M_X64) +#if defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || \ + defined(_M_X64) TEST_F(LibYUVBaseTest, TestCpuId) { int has_x86 = TestCpuFlag(kCpuHasX86); if (has_x86) { @@ -96,7 +101,7 @@ TEST_F(LibYUVBaseTest, TestCpuId) { cpu_info[3] = 0; printf("Cpu Vendor: %s %x %x %x\n", reinterpret_cast<char*>(&cpu_info[0]), cpu_info[0], cpu_info[1], cpu_info[2]); - EXPECT_EQ(12, strlen(reinterpret_cast<char*>(&cpu_info[0]))); + EXPECT_EQ(12u, strlen(reinterpret_cast<char*>(&cpu_info[0]))); // CPU Family and Model // 3:0 - Stepping @@ -108,8 +113,8 @@ TEST_F(LibYUVBaseTest, TestCpuId) { CpuId(1, 0, cpu_info); int family = ((cpu_info[0] >> 8) & 0x0f) | ((cpu_info[0] >> 16) & 0xff0); int model = ((cpu_info[0] >> 4) & 0x0f) | ((cpu_info[0] >> 12) & 0xf0); - printf("Cpu Family %d (0x%x), Model %d (0x%x)\n", family, family, - model, model); + printf("Cpu Family %d (0x%x), Model %d (0x%x)\n", family, family, model, + model); } } #endif diff --git a/files/unit_test/math_test.cc b/files/unit_test/math_test.cc index 19af9f6b..2b4b57b1 100644 --- a/files/unit_test/math_test.cc +++ b/files/unit_test/math_test.cc @@ -12,11 +12,11 @@ #include <string.h> #include <time.h> +#include "../unit_test/unit_test.h" #include "libyuv/basic_types.h" #include "libyuv/cpu_id.h" #include "libyuv/scale.h" #include "libyuv/scale_row.h" -#include "../unit_test/unit_test.h" namespace libyuv { diff --git a/files/unit_test/planar_test.cc b/files/unit_test/planar_test.cc index bc0eebb5..2d53cc02 100644 --- a/files/unit_test/planar_test.cc +++ b/files/unit_test/planar_test.cc @@ -90,11 +90,11 @@ TEST_F(LibYUVPlanarTest, TestAttenuate) { EXPECT_EQ(0, atten_pixels[0 * 4 + 3]); EXPECT_EQ(64, atten_pixels[128 * 4 + 0]); EXPECT_EQ(32, atten_pixels[128 * 4 + 1]); - EXPECT_EQ(21, atten_pixels[128 * 4 + 2]); + EXPECT_EQ(21, atten_pixels[128 * 4 + 2]); EXPECT_EQ(128, atten_pixels[128 * 4 + 3]); EXPECT_NEAR(255, atten_pixels[255 * 4 + 0], 1); EXPECT_NEAR(127, atten_pixels[255 * 4 + 1], 1); - EXPECT_NEAR(85, atten_pixels[255 * 4 + 2], 1); + EXPECT_NEAR(85, atten_pixels[255 * 4 + 2], 1); EXPECT_EQ(255, atten_pixels[255 * 4 + 3]); free_aligned_buffer_page_end(atten2_pixels); @@ -103,9 +103,13 @@ TEST_F(LibYUVPlanarTest, TestAttenuate) { free_aligned_buffer_page_end(orig_pixels); } -static int TestAttenuateI(int width, int height, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info, - int invert, int off) { +static int TestAttenuateI(int width, + int height, + int benchmark_iterations, + int disable_cpu_flags, + int benchmark_cpu_info, + int invert, + int off) { if (width < 1) { width = 1; } @@ -121,20 +125,17 @@ static int TestAttenuateI(int width, int height, int benchmark_iterations, memset(dst_argb_opt, 0, kStride * height); MaskCpuFlags(disable_cpu_flags); - ARGBAttenuate(src_argb + off, kStride, - dst_argb_c, kStride, - width, invert * height); + ARGBAttenuate(src_argb + off, kStride, dst_argb_c, kStride, width, + invert * height); MaskCpuFlags(benchmark_cpu_info); for (int i = 0; i < benchmark_iterations; ++i) { - ARGBAttenuate(src_argb + off, kStride, - dst_argb_opt, kStride, - width, invert * height); + ARGBAttenuate(src_argb + off, kStride, dst_argb_opt, kStride, width, + invert * height); } int max_diff = 0; for (int i = 0; i < kStride * height; ++i) { - int abs_diff = - abs(static_cast<int>(dst_argb_c[i]) - - static_cast<int>(dst_argb_opt[i])); + int abs_diff = abs(static_cast<int>(dst_argb_c[i]) - + static_cast<int>(dst_argb_opt[i])); if (abs_diff > max_diff) { max_diff = abs_diff; } @@ -147,39 +148,39 @@ static int TestAttenuateI(int width, int height, int benchmark_iterations, TEST_F(LibYUVPlanarTest, ARGBAttenuate_Any) { int max_diff = TestAttenuateI(benchmark_width_ - 1, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 0); + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, +1, 0); EXPECT_LE(max_diff, 2); } TEST_F(LibYUVPlanarTest, ARGBAttenuate_Unaligned) { - int max_diff = TestAttenuateI(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 1); + int max_diff = + TestAttenuateI(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 1); EXPECT_LE(max_diff, 2); } TEST_F(LibYUVPlanarTest, ARGBAttenuate_Invert) { - int max_diff = TestAttenuateI(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - -1, 0); + int max_diff = + TestAttenuateI(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, -1, 0); EXPECT_LE(max_diff, 2); } TEST_F(LibYUVPlanarTest, ARGBAttenuate_Opt) { - int max_diff = TestAttenuateI(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 0); + int max_diff = + TestAttenuateI(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 0); EXPECT_LE(max_diff, 2); } -static int TestUnattenuateI(int width, int height, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info, - int invert, int off) { +static int TestUnattenuateI(int width, + int height, + int benchmark_iterations, + int disable_cpu_flags, + int benchmark_cpu_info, + int invert, + int off) { if (width < 1) { width = 1; } @@ -191,27 +192,23 @@ static int TestUnattenuateI(int width, int height, int benchmark_iterations, for (int i = 0; i < kStride * height; ++i) { src_argb[i + off] = (fastrand() & 0xff); } - ARGBAttenuate(src_argb + off, kStride, - src_argb + off, kStride, - width, height); + ARGBAttenuate(src_argb + off, kStride, src_argb + off, kStride, width, + height); memset(dst_argb_c, 0, kStride * height); memset(dst_argb_opt, 0, kStride * height); MaskCpuFlags(disable_cpu_flags); - ARGBUnattenuate(src_argb + off, kStride, - dst_argb_c, kStride, - width, invert * height); + ARGBUnattenuate(src_argb + off, kStride, dst_argb_c, kStride, width, + invert * height); MaskCpuFlags(benchmark_cpu_info); for (int i = 0; i < benchmark_iterations; ++i) { - ARGBUnattenuate(src_argb + off, kStride, - dst_argb_opt, kStride, - width, invert * height); + ARGBUnattenuate(src_argb + off, kStride, dst_argb_opt, kStride, width, + invert * height); } int max_diff = 0; for (int i = 0; i < kStride * height; ++i) { - int abs_diff = - abs(static_cast<int>(dst_argb_c[i]) - - static_cast<int>(dst_argb_opt[i])); + int abs_diff = abs(static_cast<int>(dst_argb_c[i]) - + static_cast<int>(dst_argb_opt[i])); if (abs_diff > max_diff) { max_diff = abs_diff; } @@ -224,33 +221,29 @@ static int TestUnattenuateI(int width, int height, int benchmark_iterations, TEST_F(LibYUVPlanarTest, ARGBUnattenuate_Any) { int max_diff = TestUnattenuateI(benchmark_width_ - 1, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 0); + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, +1, 0); EXPECT_LE(max_diff, 2); } TEST_F(LibYUVPlanarTest, ARGBUnattenuate_Unaligned) { int max_diff = TestUnattenuateI(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 1); + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, +1, 1); EXPECT_LE(max_diff, 2); } TEST_F(LibYUVPlanarTest, ARGBUnattenuate_Invert) { int max_diff = TestUnattenuateI(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - -1, 0); + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, -1, 0); EXPECT_LE(max_diff, 2); } TEST_F(LibYUVPlanarTest, ARGBUnattenuate_Opt) { int max_diff = TestUnattenuateI(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 0); + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, +1, 0); EXPECT_LE(max_diff, 2); } @@ -268,8 +261,7 @@ TEST_F(LibYUVPlanarTest, TestARGBComputeCumulativeSum) { } ARGBComputeCumulativeSum(&orig_pixels[0][0][0], 16 * 4, - &added_pixels[0][0][0], 16 * 4, - 16, 16); + &added_pixels[0][0][0], 16 * 4, 16, 16); for (int y = 0; y < 16; ++y) { for (int x = 0; x < 16; ++x) { @@ -503,10 +495,8 @@ TEST_F(LibYUVPlanarTest, TestARGBColorMatrix) { // Matrix for Sepia. SIMD_ALIGNED(static const int8 kRGBToSepia[]) = { - 17 / 2, 68 / 2, 35 / 2, 0, - 22 / 2, 88 / 2, 45 / 2, 0, - 24 / 2, 98 / 2, 50 / 2, 0, - 0, 0, 0, 64, // Copy alpha. + 17 / 2, 68 / 2, 35 / 2, 0, 22 / 2, 88 / 2, 45 / 2, 0, + 24 / 2, 98 / 2, 50 / 2, 0, 0, 0, 0, 64, // Copy alpha. }; memset(orig_pixels, 0, sizeof(orig_pixels)); @@ -579,10 +569,8 @@ TEST_F(LibYUVPlanarTest, TestRGBColorMatrix) { // Matrix for Sepia. SIMD_ALIGNED(static const int8 kRGBToSepia[]) = { - 17, 68, 35, 0, - 22, 88, 45, 0, - 24, 98, 50, 0, - 0, 0, 0, 0, // Unused but makes matrix 16 bytes. + 17, 68, 35, 0, 22, 88, 45, 0, + 24, 98, 50, 0, 0, 0, 0, 0, // Unused but makes matrix 16 bytes. }; memset(orig_pixels, 0, sizeof(orig_pixels)); @@ -642,10 +630,7 @@ TEST_F(LibYUVPlanarTest, TestARGBColorTable) { // Matrix for Sepia. static const uint8 kARGBTable[256 * 4] = { - 1u, 2u, 3u, 4u, - 5u, 6u, 7u, 8u, - 9u, 10u, 11u, 12u, - 13u, 14u, 15u, 16u, + 1u, 2u, 3u, 4u, 5u, 6u, 7u, 8u, 9u, 10u, 11u, 12u, 13u, 14u, 15u, 16u, }; orig_pixels[0][0] = 0u; @@ -701,10 +686,7 @@ TEST_F(LibYUVPlanarTest, TestRGBColorTable) { // Matrix for Sepia. static const uint8 kARGBTable[256 * 4] = { - 1u, 2u, 3u, 4u, - 5u, 6u, 7u, 8u, - 9u, 10u, 11u, 12u, - 13u, 14u, 15u, 16u, + 1u, 2u, 3u, 4u, 5u, 6u, 7u, 8u, 9u, 10u, 11u, 12u, 13u, 14u, 15u, 16u, }; orig_pixels[0][0] = 0u; @@ -762,8 +744,8 @@ TEST_F(LibYUVPlanarTest, TestARGBQuantize) { orig_pixels[i][2] = i / 3; orig_pixels[i][3] = i; } - ARGBQuantize(&orig_pixels[0][0], 0, - (65536 + (8 / 2)) / 8, 8, 8 / 2, 0, 0, 1280, 1); + ARGBQuantize(&orig_pixels[0][0], 0, (65536 + (8 / 2)) / 8, 8, 8 / 2, 0, 0, + 1280, 1); for (int i = 0; i < 1280; ++i) { EXPECT_EQ((i / 8 * 8 + 8 / 2) & 255, orig_pixels[i][0]); @@ -772,8 +754,8 @@ TEST_F(LibYUVPlanarTest, TestARGBQuantize) { EXPECT_EQ(i & 255, orig_pixels[i][3]); } for (int i = 0; i < benchmark_pixels_div1280_; ++i) { - ARGBQuantize(&orig_pixels[0][0], 0, - (65536 + (8 / 2)) / 8, 8, 8 / 2, 0, 0, 1280, 1); + ARGBQuantize(&orig_pixels[0][0], 0, (65536 + (8 / 2)) / 8, 8, 8 / 2, 0, 0, + 1280, 1); } } @@ -1020,48 +1002,45 @@ TEST_F(LibYUVPlanarTest, TestInterpolatePlane) { } } -#define TESTTERP(FMT_A, BPP_A, STRIDE_A, \ - FMT_B, BPP_B, STRIDE_B, \ - W1280, TERP, N, NEG, OFF) \ -TEST_F(LibYUVPlanarTest, ARGBInterpolate##TERP##N) { \ - const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ - const int kHeight = benchmark_height_; \ - const int kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A; \ - const int kStrideB = (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B; \ - align_buffer_page_end(src_argb_a, kStrideA * kHeight + OFF); \ - align_buffer_page_end(src_argb_b, kStrideA * kHeight + OFF); \ - align_buffer_page_end(dst_argb_c, kStrideB * kHeight); \ - align_buffer_page_end(dst_argb_opt, kStrideB * kHeight); \ - for (int i = 0; i < kStrideA * kHeight; ++i) { \ - src_argb_a[i + OFF] = (fastrand() & 0xff); \ - src_argb_b[i + OFF] = (fastrand() & 0xff); \ - } \ - MaskCpuFlags(disable_cpu_flags_); \ - ARGBInterpolate(src_argb_a + OFF, kStrideA, \ - src_argb_b + OFF, kStrideA, \ - dst_argb_c, kStrideB, \ - kWidth, NEG kHeight, TERP); \ - MaskCpuFlags(benchmark_cpu_info_); \ - for (int i = 0; i < benchmark_iterations_; ++i) { \ - ARGBInterpolate(src_argb_a + OFF, kStrideA, \ - src_argb_b + OFF, kStrideA, \ - dst_argb_opt, kStrideB, \ - kWidth, NEG kHeight, TERP); \ - } \ - for (int i = 0; i < kStrideB * kHeight; ++i) { \ - EXPECT_EQ(dst_argb_c[i], dst_argb_opt[i]); \ - } \ - free_aligned_buffer_page_end(src_argb_a); \ - free_aligned_buffer_page_end(src_argb_b); \ - free_aligned_buffer_page_end(dst_argb_c); \ - free_aligned_buffer_page_end(dst_argb_opt); \ -} - -#define TESTINTERPOLATE(TERP) \ - TESTTERP(ARGB, 4, 1, ARGB, 4, 1, benchmark_width_ - 1, TERP, _Any, +, 0) \ - TESTTERP(ARGB, 4, 1, ARGB, 4, 1, benchmark_width_, TERP, _Unaligned, +, 1) \ - TESTTERP(ARGB, 4, 1, ARGB, 4, 1, benchmark_width_, TERP, _Invert, -, 0) \ - TESTTERP(ARGB, 4, 1, ARGB, 4, 1, benchmark_width_, TERP, _Opt, +, 0) +#define TESTTERP(FMT_A, BPP_A, STRIDE_A, FMT_B, BPP_B, STRIDE_B, W1280, TERP, \ + N, NEG, OFF) \ + TEST_F(LibYUVPlanarTest, ARGBInterpolate##TERP##N) { \ + const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ + const int kHeight = benchmark_height_; \ + const int kStrideA = \ + (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A; \ + const int kStrideB = \ + (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B; \ + align_buffer_page_end(src_argb_a, kStrideA* kHeight + OFF); \ + align_buffer_page_end(src_argb_b, kStrideA* kHeight + OFF); \ + align_buffer_page_end(dst_argb_c, kStrideB* kHeight); \ + align_buffer_page_end(dst_argb_opt, kStrideB* kHeight); \ + for (int i = 0; i < kStrideA * kHeight; ++i) { \ + src_argb_a[i + OFF] = (fastrand() & 0xff); \ + src_argb_b[i + OFF] = (fastrand() & 0xff); \ + } \ + MaskCpuFlags(disable_cpu_flags_); \ + ARGBInterpolate(src_argb_a + OFF, kStrideA, src_argb_b + OFF, kStrideA, \ + dst_argb_c, kStrideB, kWidth, NEG kHeight, TERP); \ + MaskCpuFlags(benchmark_cpu_info_); \ + for (int i = 0; i < benchmark_iterations_; ++i) { \ + ARGBInterpolate(src_argb_a + OFF, kStrideA, src_argb_b + OFF, kStrideA, \ + dst_argb_opt, kStrideB, kWidth, NEG kHeight, TERP); \ + } \ + for (int i = 0; i < kStrideB * kHeight; ++i) { \ + EXPECT_EQ(dst_argb_c[i], dst_argb_opt[i]); \ + } \ + free_aligned_buffer_page_end(src_argb_a); \ + free_aligned_buffer_page_end(src_argb_b); \ + free_aligned_buffer_page_end(dst_argb_c); \ + free_aligned_buffer_page_end(dst_argb_opt); \ + } + +#define TESTINTERPOLATE(TERP) \ + TESTTERP(ARGB, 4, 1, ARGB, 4, 1, benchmark_width_ - 1, TERP, _Any, +, 0) \ + TESTTERP(ARGB, 4, 1, ARGB, 4, 1, benchmark_width_, TERP, _Unaligned, +, 1) \ + TESTTERP(ARGB, 4, 1, ARGB, 4, 1, benchmark_width_, TERP, _Invert, -, 0) \ + TESTTERP(ARGB, 4, 1, ARGB, 4, 1, benchmark_width_, TERP, _Opt, +, 0) TESTINTERPOLATE(0) TESTINTERPOLATE(64) @@ -1069,9 +1048,13 @@ TESTINTERPOLATE(128) TESTINTERPOLATE(192) TESTINTERPOLATE(255) -static int TestBlend(int width, int height, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info, - int invert, int off) { +static int TestBlend(int width, + int height, + int benchmark_iterations, + int disable_cpu_flags, + int benchmark_cpu_info, + int invert, + int off) { if (width < 1) { width = 1; } @@ -1093,22 +1076,17 @@ static int TestBlend(int width, int height, int benchmark_iterations, memset(dst_argb_opt, 255, kStride * height); MaskCpuFlags(disable_cpu_flags); - ARGBBlend(src_argb_a + off, kStride, - src_argb_b + off, kStride, - dst_argb_c, kStride, - width, invert * height); + ARGBBlend(src_argb_a + off, kStride, src_argb_b + off, kStride, dst_argb_c, + kStride, width, invert * height); MaskCpuFlags(benchmark_cpu_info); for (int i = 0; i < benchmark_iterations; ++i) { - ARGBBlend(src_argb_a + off, kStride, - src_argb_b + off, kStride, - dst_argb_opt, kStride, - width, invert * height); + ARGBBlend(src_argb_a + off, kStride, src_argb_b + off, kStride, + dst_argb_opt, kStride, width, invert * height); } int max_diff = 0; for (int i = 0; i < kStride * height; ++i) { - int abs_diff = - abs(static_cast<int>(dst_argb_c[i]) - - static_cast<int>(dst_argb_opt[i])); + int abs_diff = abs(static_cast<int>(dst_argb_c[i]) - + static_cast<int>(dst_argb_opt[i])); if (abs_diff > max_diff) { max_diff = abs_diff; } @@ -1121,36 +1099,40 @@ static int TestBlend(int width, int height, int benchmark_iterations, } TEST_F(LibYUVPlanarTest, ARGBBlend_Any) { - int max_diff = TestBlend(benchmark_width_ - 4, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 0); + int max_diff = + TestBlend(benchmark_width_ - 4, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 0); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBBlend_Unaligned) { - int max_diff = TestBlend(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 1); + int max_diff = + TestBlend(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 1); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBBlend_Invert) { - int max_diff = TestBlend(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, -1, 0); + int max_diff = + TestBlend(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, -1, 0); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBBlend_Opt) { - int max_diff = TestBlend(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 0); + int max_diff = + TestBlend(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 0); EXPECT_LE(max_diff, 1); } -static void TestBlendPlane(int width, int height, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info, - int invert, int off) { +static void TestBlendPlane(int width, + int height, + int benchmark_iterations, + int disable_cpu_flags, + int benchmark_cpu_info, + int invert, + int off) { if (width < 1) { width = 1; } @@ -1170,21 +1152,15 @@ static void TestBlendPlane(int width, int height, int benchmark_iterations, src_argb_b[i + off] = 255 - (i & 255); } memset(src_argb_alpha + off, 255, width); - BlendPlane(src_argb_a + off, width, - src_argb_b + off, width, - src_argb_alpha + off, width, - dst_argb_opt + off, width, - width, 1); + BlendPlane(src_argb_a + off, width, src_argb_b + off, width, + src_argb_alpha + off, width, dst_argb_opt + off, width, width, 1); for (int i = 0; i < width; ++i) { EXPECT_EQ(src_argb_a[i + off], dst_argb_opt[i + off]); } // Test destination is maintained exactly if alpha is 0. memset(src_argb_alpha + off, 0, width); - BlendPlane(src_argb_a + off, width, - src_argb_b + off, width, - src_argb_alpha + off, width, - dst_argb_opt + off, width, - width, 1); + BlendPlane(src_argb_a + off, width, src_argb_b + off, width, + src_argb_alpha + off, width, dst_argb_opt + off, width, width, 1); for (int i = 0; i < width; ++i) { EXPECT_EQ(src_argb_b[i + off], dst_argb_opt[i + off]); } @@ -1195,18 +1171,14 @@ static void TestBlendPlane(int width, int height, int benchmark_iterations, } MaskCpuFlags(disable_cpu_flags); - BlendPlane(src_argb_a + off, width, - src_argb_b + off, width, - src_argb_alpha + off, width, - dst_argb_c + off, width, - width, height); + BlendPlane(src_argb_a + off, width, src_argb_b + off, width, + src_argb_alpha + off, width, dst_argb_c + off, width, width, + invert * height); MaskCpuFlags(benchmark_cpu_info); for (int i = 0; i < benchmark_iterations; ++i) { - BlendPlane(src_argb_a + off, width, - src_argb_b + off, width, - src_argb_alpha + off, width, - dst_argb_opt + off, width, - width, height); + BlendPlane(src_argb_a + off, width, src_argb_b + off, width, + src_argb_alpha + off, width, dst_argb_opt + off, width, width, + invert * height); } for (int i = 0; i < kStride * height; ++i) { EXPECT_EQ(dst_argb_c[i + off], dst_argb_opt[i + off]); @@ -1236,11 +1208,15 @@ TEST_F(LibYUVPlanarTest, BlendPlane_Invert) { disable_cpu_flags_, benchmark_cpu_info_, -1, 1); } -#define SUBSAMPLE(v, a) ((((v) + (a) - 1)) / (a)) +#define SUBSAMPLE(v, a) ((((v) + (a)-1)) / (a)) -static void TestI420Blend(int width, int height, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info, - int invert, int off) { +static void TestI420Blend(int width, + int height, + int benchmark_iterations, + int disable_cpu_flags, + int benchmark_cpu_info, + int invert, + int off) { width = ((width) > 0) ? (width) : 1; const int kStrideUV = SUBSAMPLE(width, 2); const int kSizeUV = kStrideUV * SUBSAMPLE(height, 2); @@ -1273,30 +1249,18 @@ static void TestI420Blend(int width, int height, int benchmark_iterations, memset(dst_v_opt, 255, kSizeUV + off); MaskCpuFlags(disable_cpu_flags); - I420Blend(src_y0 + off, width, - src_u0 + off, kStrideUV, - src_v0 + off, kStrideUV, - src_y1 + off, width, - src_u1 + off, kStrideUV, - src_v1 + off, kStrideUV, - src_a + off, width, - dst_y_c + off, width, - dst_u_c + off, kStrideUV, - dst_v_c + off, kStrideUV, - width, height); + I420Blend(src_y0 + off, width, src_u0 + off, kStrideUV, src_v0 + off, + kStrideUV, src_y1 + off, width, src_u1 + off, kStrideUV, + src_v1 + off, kStrideUV, src_a + off, width, dst_y_c + off, width, + dst_u_c + off, kStrideUV, dst_v_c + off, kStrideUV, width, + invert * height); MaskCpuFlags(benchmark_cpu_info); for (int i = 0; i < benchmark_iterations; ++i) { - I420Blend(src_y0 + off, width, - src_u0 + off, kStrideUV, - src_v0 + off, kStrideUV, - src_y1 + off, width, - src_u1 + off, kStrideUV, - src_v1 + off, kStrideUV, - src_a + off, width, - dst_y_opt + off, width, - dst_u_opt + off, kStrideUV, - dst_v_opt + off, kStrideUV, - width, height); + I420Blend(src_y0 + off, width, src_u0 + off, kStrideUV, src_v0 + off, + kStrideUV, src_y1 + off, width, src_u1 + off, kStrideUV, + src_v1 + off, kStrideUV, src_a + off, width, dst_y_opt + off, + width, dst_u_opt + off, kStrideUV, dst_v_opt + off, kStrideUV, + width, invert * height); } for (int i = 0; i < width * height; ++i) { EXPECT_EQ(dst_y_c[i + off], dst_y_opt[i + off]); @@ -1323,21 +1287,21 @@ static void TestI420Blend(int width, int height, int benchmark_iterations, TEST_F(LibYUVPlanarTest, I420Blend_Opt) { TestI420Blend(benchmark_width_, benchmark_height_, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 0); + disable_cpu_flags_, benchmark_cpu_info_, +1, 0); } TEST_F(LibYUVPlanarTest, I420Blend_Unaligned) { TestI420Blend(benchmark_width_, benchmark_height_, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 1); + disable_cpu_flags_, benchmark_cpu_info_, +1, 1); } // TODO(fbarchard): DISABLED because _Any uses C. Avoid C and re-enable. TEST_F(LibYUVPlanarTest, DISABLED_I420Blend_Any) { TestI420Blend(benchmark_width_ - 4, benchmark_height_, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 0); + disable_cpu_flags_, benchmark_cpu_info_, +1, 0); } TEST_F(LibYUVPlanarTest, I420Blend_Invert) { TestI420Blend(benchmark_width_, benchmark_height_, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, -1, 0); + disable_cpu_flags_, benchmark_cpu_info_, -1, 0); } TEST_F(LibYUVPlanarTest, TestAffine) { @@ -1350,10 +1314,10 @@ TEST_F(LibYUVPlanarTest, TestAffine) { } } - float uv_step[4] = { 0.f, 0.f, 0.75f, 0.f }; + float uv_step[4] = {0.f, 0.f, 0.75f, 0.f}; - ARGBAffineRow_C(&orig_pixels_0[0][0], 0, &interpolate_pixels_C[0][0], - uv_step, 1280); + ARGBAffineRow_C(&orig_pixels_0[0][0], 0, &interpolate_pixels_C[0][0], uv_step, + 1280); EXPECT_EQ(0u, interpolate_pixels_C[0][0]); EXPECT_EQ(96u, interpolate_pixels_C[128][0]); EXPECT_EQ(191u, interpolate_pixels_C[255][3]); @@ -1411,19 +1375,15 @@ TEST_F(LibYUVPlanarTest, TestCopyPlane) { // Disable all optimizations. MaskCpuFlags(disable_cpu_flags_); - double c_time = get_time(); for (j = 0; j < benchmark_iterations_; j++) { CopyPlane(orig_y + y_off, y_st, dst_c + y_off, stride, yw, yh); } - c_time = (get_time() - c_time) / benchmark_iterations_; // Enable optimizations. MaskCpuFlags(benchmark_cpu_info_); - double opt_time = get_time(); for (j = 0; j < benchmark_iterations_; j++) { CopyPlane(orig_y + y_off, y_st, dst_opt + y_off, stride, yw, yh); } - opt_time = (get_time() - opt_time) / benchmark_iterations_; for (i = 0; i < y_plane_size; ++i) { if (dst_c[i] != dst_opt[i]) @@ -1437,9 +1397,13 @@ TEST_F(LibYUVPlanarTest, TestCopyPlane) { EXPECT_EQ(0, err); } -static int TestMultiply(int width, int height, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info, - int invert, int off) { +static int TestMultiply(int width, + int height, + int benchmark_iterations, + int disable_cpu_flags, + int benchmark_cpu_info, + int invert, + int off) { if (width < 1) { width = 1; } @@ -1457,22 +1421,17 @@ static int TestMultiply(int width, int height, int benchmark_iterations, memset(dst_argb_opt, 0, kStride * height); MaskCpuFlags(disable_cpu_flags); - ARGBMultiply(src_argb_a + off, kStride, - src_argb_b + off, kStride, - dst_argb_c, kStride, - width, invert * height); + ARGBMultiply(src_argb_a + off, kStride, src_argb_b + off, kStride, dst_argb_c, + kStride, width, invert * height); MaskCpuFlags(benchmark_cpu_info); for (int i = 0; i < benchmark_iterations; ++i) { - ARGBMultiply(src_argb_a + off, kStride, - src_argb_b + off, kStride, - dst_argb_opt, kStride, - width, invert * height); + ARGBMultiply(src_argb_a + off, kStride, src_argb_b + off, kStride, + dst_argb_opt, kStride, width, invert * height); } int max_diff = 0; for (int i = 0; i < kStride * height; ++i) { - int abs_diff = - abs(static_cast<int>(dst_argb_c[i]) - - static_cast<int>(dst_argb_opt[i])); + int abs_diff = abs(static_cast<int>(dst_argb_c[i]) - + static_cast<int>(dst_argb_opt[i])); if (abs_diff > max_diff) { max_diff = abs_diff; } @@ -1486,35 +1445,39 @@ static int TestMultiply(int width, int height, int benchmark_iterations, TEST_F(LibYUVPlanarTest, ARGBMultiply_Any) { int max_diff = TestMultiply(benchmark_width_ - 1, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 0); + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, +1, 0); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBMultiply_Unaligned) { - int max_diff = TestMultiply(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 1); + int max_diff = + TestMultiply(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 1); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBMultiply_Invert) { - int max_diff = TestMultiply(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, -1, 0); + int max_diff = + TestMultiply(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, -1, 0); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBMultiply_Opt) { - int max_diff = TestMultiply(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 0); + int max_diff = + TestMultiply(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 0); EXPECT_LE(max_diff, 1); } -static int TestAdd(int width, int height, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info, - int invert, int off) { +static int TestAdd(int width, + int height, + int benchmark_iterations, + int disable_cpu_flags, + int benchmark_cpu_info, + int invert, + int off) { if (width < 1) { width = 1; } @@ -1532,22 +1495,17 @@ static int TestAdd(int width, int height, int benchmark_iterations, memset(dst_argb_opt, 0, kStride * height); MaskCpuFlags(disable_cpu_flags); - ARGBAdd(src_argb_a + off, kStride, - src_argb_b + off, kStride, - dst_argb_c, kStride, - width, invert * height); + ARGBAdd(src_argb_a + off, kStride, src_argb_b + off, kStride, dst_argb_c, + kStride, width, invert * height); MaskCpuFlags(benchmark_cpu_info); for (int i = 0; i < benchmark_iterations; ++i) { - ARGBAdd(src_argb_a + off, kStride, - src_argb_b + off, kStride, - dst_argb_opt, kStride, - width, invert * height); + ARGBAdd(src_argb_a + off, kStride, src_argb_b + off, kStride, dst_argb_opt, + kStride, width, invert * height); } int max_diff = 0; for (int i = 0; i < kStride * height; ++i) { - int abs_diff = - abs(static_cast<int>(dst_argb_c[i]) - - static_cast<int>(dst_argb_opt[i])); + int abs_diff = abs(static_cast<int>(dst_argb_c[i]) - + static_cast<int>(dst_argb_opt[i])); if (abs_diff > max_diff) { max_diff = abs_diff; } @@ -1560,36 +1518,40 @@ static int TestAdd(int width, int height, int benchmark_iterations, } TEST_F(LibYUVPlanarTest, ARGBAdd_Any) { - int max_diff = TestAdd(benchmark_width_ - 1, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 0); + int max_diff = + TestAdd(benchmark_width_ - 1, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 0); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBAdd_Unaligned) { - int max_diff = TestAdd(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 1); + int max_diff = + TestAdd(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 1); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBAdd_Invert) { - int max_diff = TestAdd(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, -1, 0); + int max_diff = + TestAdd(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, -1, 0); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBAdd_Opt) { - int max_diff = TestAdd(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 0); + int max_diff = + TestAdd(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 0); EXPECT_LE(max_diff, 1); } -static int TestSubtract(int width, int height, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info, - int invert, int off) { +static int TestSubtract(int width, + int height, + int benchmark_iterations, + int disable_cpu_flags, + int benchmark_cpu_info, + int invert, + int off) { if (width < 1) { width = 1; } @@ -1607,22 +1569,17 @@ static int TestSubtract(int width, int height, int benchmark_iterations, memset(dst_argb_opt, 0, kStride * height); MaskCpuFlags(disable_cpu_flags); - ARGBSubtract(src_argb_a + off, kStride, - src_argb_b + off, kStride, - dst_argb_c, kStride, - width, invert * height); + ARGBSubtract(src_argb_a + off, kStride, src_argb_b + off, kStride, dst_argb_c, + kStride, width, invert * height); MaskCpuFlags(benchmark_cpu_info); for (int i = 0; i < benchmark_iterations; ++i) { - ARGBSubtract(src_argb_a + off, kStride, - src_argb_b + off, kStride, - dst_argb_opt, kStride, - width, invert * height); + ARGBSubtract(src_argb_a + off, kStride, src_argb_b + off, kStride, + dst_argb_opt, kStride, width, invert * height); } int max_diff = 0; for (int i = 0; i < kStride * height; ++i) { - int abs_diff = - abs(static_cast<int>(dst_argb_c[i]) - - static_cast<int>(dst_argb_opt[i])); + int abs_diff = abs(static_cast<int>(dst_argb_c[i]) - + static_cast<int>(dst_argb_opt[i])); if (abs_diff > max_diff) { max_diff = abs_diff; } @@ -1636,35 +1593,39 @@ static int TestSubtract(int width, int height, int benchmark_iterations, TEST_F(LibYUVPlanarTest, ARGBSubtract_Any) { int max_diff = TestSubtract(benchmark_width_ - 1, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 0); + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, +1, 0); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBSubtract_Unaligned) { - int max_diff = TestSubtract(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 1); + int max_diff = + TestSubtract(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 1); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBSubtract_Invert) { - int max_diff = TestSubtract(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, -1, 0); + int max_diff = + TestSubtract(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, -1, 0); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBSubtract_Opt) { - int max_diff = TestSubtract(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 0); + int max_diff = + TestSubtract(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 0); EXPECT_LE(max_diff, 1); } -static int TestSobel(int width, int height, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info, - int invert, int off) { +static int TestSobel(int width, + int height, + int benchmark_iterations, + int disable_cpu_flags, + int benchmark_cpu_info, + int invert, + int off) { if (width < 1) { width = 1; } @@ -1681,20 +1642,17 @@ static int TestSobel(int width, int height, int benchmark_iterations, memset(dst_argb_opt, 0, kStride * height); MaskCpuFlags(disable_cpu_flags); - ARGBSobel(src_argb_a + off, kStride, - dst_argb_c, kStride, - width, invert * height); + ARGBSobel(src_argb_a + off, kStride, dst_argb_c, kStride, width, + invert * height); MaskCpuFlags(benchmark_cpu_info); for (int i = 0; i < benchmark_iterations; ++i) { - ARGBSobel(src_argb_a + off, kStride, - dst_argb_opt, kStride, - width, invert * height); + ARGBSobel(src_argb_a + off, kStride, dst_argb_opt, kStride, width, + invert * height); } int max_diff = 0; for (int i = 0; i < kStride * height; ++i) { - int abs_diff = - abs(static_cast<int>(dst_argb_c[i]) - - static_cast<int>(dst_argb_opt[i])); + int abs_diff = abs(static_cast<int>(dst_argb_c[i]) - + static_cast<int>(dst_argb_opt[i])); if (abs_diff > max_diff) { max_diff = abs_diff; } @@ -1706,36 +1664,40 @@ static int TestSobel(int width, int height, int benchmark_iterations, } TEST_F(LibYUVPlanarTest, ARGBSobel_Any) { - int max_diff = TestSobel(benchmark_width_ - 1, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 0); + int max_diff = + TestSobel(benchmark_width_ - 1, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 0); EXPECT_EQ(0, max_diff); } TEST_F(LibYUVPlanarTest, ARGBSobel_Unaligned) { - int max_diff = TestSobel(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 1); + int max_diff = + TestSobel(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 1); EXPECT_EQ(0, max_diff); } TEST_F(LibYUVPlanarTest, ARGBSobel_Invert) { - int max_diff = TestSobel(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, -1, 0); + int max_diff = + TestSobel(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, -1, 0); EXPECT_EQ(0, max_diff); } TEST_F(LibYUVPlanarTest, ARGBSobel_Opt) { - int max_diff = TestSobel(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 0); + int max_diff = + TestSobel(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 0); EXPECT_EQ(0, max_diff); } -static int TestSobelToPlane(int width, int height, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info, - int invert, int off) { +static int TestSobelToPlane(int width, + int height, + int benchmark_iterations, + int disable_cpu_flags, + int benchmark_cpu_info, + int invert, + int off) { if (width < 1) { width = 1; } @@ -1754,20 +1716,17 @@ static int TestSobelToPlane(int width, int height, int benchmark_iterations, memset(dst_argb_opt, 0, kDstStride * height); MaskCpuFlags(disable_cpu_flags); - ARGBSobelToPlane(src_argb_a + off, kSrcStride, - dst_argb_c, kDstStride, - width, invert * height); + ARGBSobelToPlane(src_argb_a + off, kSrcStride, dst_argb_c, kDstStride, width, + invert * height); MaskCpuFlags(benchmark_cpu_info); for (int i = 0; i < benchmark_iterations; ++i) { - ARGBSobelToPlane(src_argb_a + off, kSrcStride, - dst_argb_opt, kDstStride, + ARGBSobelToPlane(src_argb_a + off, kSrcStride, dst_argb_opt, kDstStride, width, invert * height); } int max_diff = 0; for (int i = 0; i < kDstStride * height; ++i) { - int abs_diff = - abs(static_cast<int>(dst_argb_c[i]) - - static_cast<int>(dst_argb_opt[i])); + int abs_diff = abs(static_cast<int>(dst_argb_c[i]) - + static_cast<int>(dst_argb_opt[i])); if (abs_diff > max_diff) { max_diff = abs_diff; } @@ -1780,39 +1739,39 @@ static int TestSobelToPlane(int width, int height, int benchmark_iterations, TEST_F(LibYUVPlanarTest, ARGBSobelToPlane_Any) { int max_diff = TestSobelToPlane(benchmark_width_ - 1, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 0); + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, +1, 0); EXPECT_EQ(0, max_diff); } TEST_F(LibYUVPlanarTest, ARGBSobelToPlane_Unaligned) { int max_diff = TestSobelToPlane(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 1); + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, +1, 1); EXPECT_EQ(0, max_diff); } TEST_F(LibYUVPlanarTest, ARGBSobelToPlane_Invert) { int max_diff = TestSobelToPlane(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - -1, 0); + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, -1, 0); EXPECT_EQ(0, max_diff); } TEST_F(LibYUVPlanarTest, ARGBSobelToPlane_Opt) { int max_diff = TestSobelToPlane(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 0); + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, +1, 0); EXPECT_EQ(0, max_diff); } -static int TestSobelXY(int width, int height, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info, - int invert, int off) { +static int TestSobelXY(int width, + int height, + int benchmark_iterations, + int disable_cpu_flags, + int benchmark_cpu_info, + int invert, + int off) { if (width < 1) { width = 1; } @@ -1829,20 +1788,17 @@ static int TestSobelXY(int width, int height, int benchmark_iterations, memset(dst_argb_opt, 0, kStride * height); MaskCpuFlags(disable_cpu_flags); - ARGBSobelXY(src_argb_a + off, kStride, - dst_argb_c, kStride, - width, invert * height); + ARGBSobelXY(src_argb_a + off, kStride, dst_argb_c, kStride, width, + invert * height); MaskCpuFlags(benchmark_cpu_info); for (int i = 0; i < benchmark_iterations; ++i) { - ARGBSobelXY(src_argb_a + off, kStride, - dst_argb_opt, kStride, - width, invert * height); + ARGBSobelXY(src_argb_a + off, kStride, dst_argb_opt, kStride, width, + invert * height); } int max_diff = 0; for (int i = 0; i < kStride * height; ++i) { - int abs_diff = - abs(static_cast<int>(dst_argb_c[i]) - - static_cast<int>(dst_argb_opt[i])); + int abs_diff = abs(static_cast<int>(dst_argb_c[i]) - + static_cast<int>(dst_argb_opt[i])); if (abs_diff > max_diff) { max_diff = abs_diff; } @@ -1855,35 +1811,40 @@ static int TestSobelXY(int width, int height, int benchmark_iterations, TEST_F(LibYUVPlanarTest, ARGBSobelXY_Any) { int max_diff = TestSobelXY(benchmark_width_ - 1, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 0); + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, +1, 0); EXPECT_EQ(0, max_diff); } TEST_F(LibYUVPlanarTest, ARGBSobelXY_Unaligned) { - int max_diff = TestSobelXY(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 1); + int max_diff = + TestSobelXY(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 1); EXPECT_EQ(0, max_diff); } TEST_F(LibYUVPlanarTest, ARGBSobelXY_Invert) { - int max_diff = TestSobelXY(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, -1, 0); + int max_diff = + TestSobelXY(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, -1, 0); EXPECT_EQ(0, max_diff); } TEST_F(LibYUVPlanarTest, ARGBSobelXY_Opt) { - int max_diff = TestSobelXY(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, +1, 0); + int max_diff = + TestSobelXY(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 0); EXPECT_EQ(0, max_diff); } -static int TestBlur(int width, int height, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info, - int invert, int off, int radius) { +static int TestBlur(int width, + int height, + int benchmark_iterations, + int disable_cpu_flags, + int benchmark_cpu_info, + int invert, + int off, + int radius) { if (width < 1) { width = 1; } @@ -1901,22 +1862,19 @@ static int TestBlur(int width, int height, int benchmark_iterations, memset(dst_argb_opt, 0, kStride * height); MaskCpuFlags(disable_cpu_flags); - ARGBBlur(src_argb_a + off, kStride, - dst_argb_c, kStride, - reinterpret_cast<int32*>(dst_cumsum), width * 4, - width, invert * height, radius); + ARGBBlur(src_argb_a + off, kStride, dst_argb_c, kStride, + reinterpret_cast<int32*>(dst_cumsum), width * 4, width, + invert * height, radius); MaskCpuFlags(benchmark_cpu_info); for (int i = 0; i < benchmark_iterations; ++i) { - ARGBBlur(src_argb_a + off, kStride, - dst_argb_opt, kStride, - reinterpret_cast<int32*>(dst_cumsum), width * 4, - width, invert * height, radius); + ARGBBlur(src_argb_a + off, kStride, dst_argb_opt, kStride, + reinterpret_cast<int32*>(dst_cumsum), width * 4, width, + invert * height, radius); } int max_diff = 0; for (int i = 0; i < kStride * height; ++i) { - int abs_diff = - abs(static_cast<int>(dst_argb_c[i]) - - static_cast<int>(dst_argb_opt[i])); + int abs_diff = abs(static_cast<int>(dst_argb_c[i]) - + static_cast<int>(dst_argb_opt[i])); if (abs_diff > max_diff) { max_diff = abs_diff; } @@ -1930,67 +1888,59 @@ static int TestBlur(int width, int height, int benchmark_iterations, static const int kBlurSize = 55; TEST_F(LibYUVPlanarTest, ARGBBlur_Any) { - int max_diff = TestBlur(benchmark_width_ - 1, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 0, kBlurSize); + int max_diff = + TestBlur(benchmark_width_ - 1, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 0, kBlurSize); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBBlur_Unaligned) { - int max_diff = TestBlur(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 1, kBlurSize); + int max_diff = + TestBlur(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 1, kBlurSize); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBBlur_Invert) { - int max_diff = TestBlur(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - -1, 0, kBlurSize); + int max_diff = + TestBlur(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, -1, 0, kBlurSize); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBBlur_Opt) { - int max_diff = TestBlur(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 0, kBlurSize); + int max_diff = + TestBlur(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 0, kBlurSize); EXPECT_LE(max_diff, 1); } static const int kBlurSmallSize = 5; TEST_F(LibYUVPlanarTest, ARGBBlurSmall_Any) { - int max_diff = TestBlur(benchmark_width_ - 1, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 0, kBlurSmallSize); + int max_diff = + TestBlur(benchmark_width_ - 1, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 0, kBlurSmallSize); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBBlurSmall_Unaligned) { - int max_diff = TestBlur(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 1, kBlurSmallSize); + int max_diff = + TestBlur(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 1, kBlurSmallSize); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBBlurSmall_Invert) { - int max_diff = TestBlur(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - -1, 0, kBlurSmallSize); + int max_diff = + TestBlur(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, -1, 0, kBlurSmallSize); EXPECT_LE(max_diff, 1); } TEST_F(LibYUVPlanarTest, ARGBBlurSmall_Opt) { - int max_diff = TestBlur(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 0, kBlurSmallSize); + int max_diff = + TestBlur(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 0, kBlurSmallSize); EXPECT_LE(max_diff, 1); } @@ -2001,10 +1951,10 @@ TEST_F(LibYUVPlanarTest, TestARGBPolynomial) { memset(orig_pixels, 0, sizeof(orig_pixels)); SIMD_ALIGNED(static const float kWarmifyPolynomial[16]) = { - 0.94230f, -3.03300f, -2.92500f, 0.f, // C0 - 0.584500f, 1.112000f, 1.535000f, 1.f, // C1 x - 0.001313f, -0.002503f, -0.004496f, 0.f, // C2 x * x - 0.0f, 0.000006965f, 0.000008781f, 0.f, // C3 x * x * x + 0.94230f, -3.03300f, -2.92500f, 0.f, // C0 + 0.584500f, 1.112000f, 1.535000f, 1.f, // C1 x + 0.001313f, -0.002503f, -0.004496f, 0.f, // C2 x * x + 0.0f, 0.000006965f, 0.000008781f, 0.f, // C3 x * x * x }; // Test blue @@ -2081,6 +2031,139 @@ TEST_F(LibYUVPlanarTest, TestARGBPolynomial) { } } +int TestHalfFloatPlane(int benchmark_width, + int benchmark_height, + int benchmark_iterations, + int disable_cpu_flags, + int benchmark_cpu_info, + float scale, + int mask) { + int i, j; + const int y_plane_size = benchmark_width * benchmark_height * 2; + + align_buffer_page_end(orig_y, y_plane_size * 3); + uint8* dst_opt = orig_y + y_plane_size; + uint8* dst_c = orig_y + y_plane_size * 2; + + MemRandomize(orig_y, y_plane_size); + memset(dst_c, 0, y_plane_size); + memset(dst_opt, 1, y_plane_size); + + for (i = 0; i < y_plane_size / 2; ++i) { + reinterpret_cast<uint16*>(orig_y)[i] &= mask; + } + + // Disable all optimizations. + MaskCpuFlags(disable_cpu_flags); + for (j = 0; j < benchmark_iterations; j++) { + HalfFloatPlane(reinterpret_cast<uint16*>(orig_y), benchmark_width * 2, + reinterpret_cast<uint16*>(dst_c), benchmark_width * 2, scale, + benchmark_width, benchmark_height); + } + + // Enable optimizations. + MaskCpuFlags(benchmark_cpu_info); + for (j = 0; j < benchmark_iterations; j++) { + HalfFloatPlane(reinterpret_cast<uint16*>(orig_y), benchmark_width * 2, + reinterpret_cast<uint16*>(dst_opt), benchmark_width * 2, + scale, benchmark_width, benchmark_height); + } + + int max_diff = 0; + for (i = 0; i < y_plane_size / 2; ++i) { + int abs_diff = abs(static_cast<int>(reinterpret_cast<uint16*>(dst_c)[i]) - + static_cast<int>(reinterpret_cast<uint16*>(dst_opt)[i])); + if (abs_diff > max_diff) { + max_diff = abs_diff; + } + } + + free_aligned_buffer_page_end(orig_y); + return max_diff; +} + +#if defined(__arm__) +static void EnableFlushDenormalToZero(void) { + uint32_t cw; + __asm__ __volatile__( + "vmrs %0, fpscr \n" + "orr %0, %0, #0x1000000 \n" + "vmsr fpscr, %0 \n" + : "=r"(cw)::"memory"); +} +#endif + +// 5 bit exponent with bias of 15 will underflow to a denormal if scale causes +// exponent to be less than 0. 15 - log2(65536) = -1/ This shouldnt normally +// happen since scale is 1/(1<<bits) where bits is 9, 10 or 12. + +TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_16bit_denormal) { +// 32 bit arm rounding on denormal case is off by 1 compared to C. +#if defined(__arm__) + EnableFlushDenormalToZero(); +#endif + int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, 1.0f / 65536.0f, 65535); + EXPECT_EQ(0, diff); +} + +TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_16bit_One) { + int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, 1.0f, 65535); + EXPECT_LE(diff, 1); +} + +TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_16bit_Opt) { + int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, 1.0f / 4096.0f, 65535); + EXPECT_EQ(0, diff); +} + +TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_10bit_Opt) { + int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, 1.0f / 1024.0f, 1023); + EXPECT_EQ(0, diff); +} + +TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_9bit_Opt) { + int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, 1.0f / 512.0f, 511); + EXPECT_EQ(0, diff); +} + +TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_Opt) { + int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, 1.0f / 4096.0f, 4095); + EXPECT_EQ(0, diff); +} + +TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_Offby1) { + int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, 1.0f / 4095.0f, 4095); + EXPECT_EQ(0, diff); +} + +TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_One) { + int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, 1.0f, 2047); + EXPECT_EQ(0, diff); +} + +TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_12bit_One) { + int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, 1.0f, 4095); + EXPECT_LE(diff, 1); +} + TEST_F(LibYUVPlanarTest, TestARGBLumaColorTable) { SIMD_ALIGNED(uint8 orig_pixels[1280][4]); SIMD_ALIGNED(uint8 dst_pixels_opt[1280][4]); @@ -2170,15 +2253,13 @@ TEST_F(LibYUVPlanarTest, TestARGBCopyAlpha) { memcpy(dst_pixels_c, dst_pixels_opt, kSize); MaskCpuFlags(disable_cpu_flags_); - ARGBCopyAlpha(orig_pixels, benchmark_width_ * 4, - dst_pixels_c, benchmark_width_ * 4, - benchmark_width_, benchmark_height_); + ARGBCopyAlpha(orig_pixels, benchmark_width_ * 4, dst_pixels_c, + benchmark_width_ * 4, benchmark_width_, benchmark_height_); MaskCpuFlags(benchmark_cpu_info_); for (int i = 0; i < benchmark_iterations_; ++i) { - ARGBCopyAlpha(orig_pixels, benchmark_width_ * 4, - dst_pixels_opt, benchmark_width_ * 4, - benchmark_width_, benchmark_height_); + ARGBCopyAlpha(orig_pixels, benchmark_width_ * 4, dst_pixels_opt, + benchmark_width_ * 4, benchmark_width_, benchmark_height_); } for (int i = 0; i < kSize; ++i) { EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]); @@ -2200,15 +2281,13 @@ TEST_F(LibYUVPlanarTest, TestARGBExtractAlpha) { memcpy(dst_pixels_c, dst_pixels_opt, kPixels); MaskCpuFlags(disable_cpu_flags_); - ARGBExtractAlpha(src_pixels, benchmark_width_ * 4, - dst_pixels_c, benchmark_width_, - benchmark_width_, benchmark_height_); + ARGBExtractAlpha(src_pixels, benchmark_width_ * 4, dst_pixels_c, + benchmark_width_, benchmark_width_, benchmark_height_); MaskCpuFlags(benchmark_cpu_info_); for (int i = 0; i < benchmark_iterations_; ++i) { - ARGBExtractAlpha(src_pixels, benchmark_width_ * 4, - dst_pixels_opt, benchmark_width_, - benchmark_width_, benchmark_height_); + ARGBExtractAlpha(src_pixels, benchmark_width_ * 4, dst_pixels_opt, + benchmark_width_, benchmark_width_, benchmark_height_); } for (int i = 0; i < kPixels; ++i) { EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]); @@ -2230,15 +2309,13 @@ TEST_F(LibYUVPlanarTest, TestARGBCopyYToAlpha) { memcpy(dst_pixels_c, dst_pixels_opt, kPixels * 4); MaskCpuFlags(disable_cpu_flags_); - ARGBCopyYToAlpha(orig_pixels, benchmark_width_, - dst_pixels_c, benchmark_width_ * 4, - benchmark_width_, benchmark_height_); + ARGBCopyYToAlpha(orig_pixels, benchmark_width_, dst_pixels_c, + benchmark_width_ * 4, benchmark_width_, benchmark_height_); MaskCpuFlags(benchmark_cpu_info_); for (int i = 0; i < benchmark_iterations_; ++i) { - ARGBCopyYToAlpha(orig_pixels, benchmark_width_, - dst_pixels_opt, benchmark_width_ * 4, - benchmark_width_, benchmark_height_); + ARGBCopyYToAlpha(orig_pixels, benchmark_width_, dst_pixels_opt, + benchmark_width_ * 4, benchmark_width_, benchmark_height_); } for (int i = 0; i < kPixels * 4; ++i) { EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]); @@ -2249,9 +2326,14 @@ TEST_F(LibYUVPlanarTest, TestARGBCopyYToAlpha) { free_aligned_buffer_page_end(orig_pixels); } -static int TestARGBRect(int width, int height, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info, - int invert, int off, int bpp) { +static int TestARGBRect(int width, + int height, + int benchmark_iterations, + int disable_cpu_flags, + int benchmark_cpu_info, + int invert, + int off, + int bpp) { if (width < 1) { width = 1; } @@ -2282,9 +2364,8 @@ static int TestARGBRect(int width, int height, int benchmark_iterations, } int max_diff = 0; for (int i = 0; i < kStride * height; ++i) { - int abs_diff = - abs(static_cast<int>(dst_argb_c[i + off]) - - static_cast<int>(dst_argb_opt[i + off])); + int abs_diff = abs(static_cast<int>(dst_argb_c[i + off]) - + static_cast<int>(dst_argb_opt[i + off])); if (abs_diff > max_diff) { max_diff = abs_diff; } @@ -2296,66 +2377,145 @@ static int TestARGBRect(int width, int height, int benchmark_iterations, TEST_F(LibYUVPlanarTest, ARGBRect_Any) { int max_diff = TestARGBRect(benchmark_width_ - 1, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 0, 4); + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, +1, 0, 4); EXPECT_EQ(0, max_diff); } TEST_F(LibYUVPlanarTest, ARGBRect_Unaligned) { - int max_diff = TestARGBRect(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 1, 4); + int max_diff = + TestARGBRect(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 1, 4); EXPECT_EQ(0, max_diff); } TEST_F(LibYUVPlanarTest, ARGBRect_Invert) { - int max_diff = TestARGBRect(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - -1, 0, 4); + int max_diff = + TestARGBRect(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, -1, 0, 4); EXPECT_EQ(0, max_diff); } TEST_F(LibYUVPlanarTest, ARGBRect_Opt) { - int max_diff = TestARGBRect(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 0, 4); + int max_diff = + TestARGBRect(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 0, 4); EXPECT_EQ(0, max_diff); } TEST_F(LibYUVPlanarTest, SetPlane_Any) { int max_diff = TestARGBRect(benchmark_width_ - 1, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 0, 1); + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_, +1, 0, 1); EXPECT_EQ(0, max_diff); } TEST_F(LibYUVPlanarTest, SetPlane_Unaligned) { - int max_diff = TestARGBRect(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 1, 1); + int max_diff = + TestARGBRect(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 1, 1); EXPECT_EQ(0, max_diff); } TEST_F(LibYUVPlanarTest, SetPlane_Invert) { - int max_diff = TestARGBRect(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - -1, 0, 1); + int max_diff = + TestARGBRect(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, -1, 0, 1); EXPECT_EQ(0, max_diff); } TEST_F(LibYUVPlanarTest, SetPlane_Opt) { - int max_diff = TestARGBRect(benchmark_width_, benchmark_height_, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_, - +1, 0, 1); + int max_diff = + TestARGBRect(benchmark_width_, benchmark_height_, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_, +1, 0, 1); EXPECT_EQ(0, max_diff); } +TEST_F(LibYUVPlanarTest, MergeUVPlane_Opt) { + const int kPixels = benchmark_width_ * benchmark_height_; + align_buffer_page_end(src_pixels, kPixels * 2); + align_buffer_page_end(tmp_pixels_u, kPixels); + align_buffer_page_end(tmp_pixels_v, kPixels); + align_buffer_page_end(dst_pixels_opt, kPixels * 2); + align_buffer_page_end(dst_pixels_c, kPixels * 2); + + MemRandomize(src_pixels, kPixels * 2); + MemRandomize(tmp_pixels_u, kPixels); + MemRandomize(tmp_pixels_v, kPixels); + MemRandomize(dst_pixels_opt, kPixels * 2); + MemRandomize(dst_pixels_c, kPixels * 2); + + MaskCpuFlags(disable_cpu_flags_); + SplitUVPlane(src_pixels, benchmark_width_ * 2, tmp_pixels_u, benchmark_width_, + tmp_pixels_v, benchmark_width_, benchmark_width_, + benchmark_height_); + MergeUVPlane(tmp_pixels_u, benchmark_width_, tmp_pixels_v, benchmark_width_, + dst_pixels_c, benchmark_width_ * 2, benchmark_width_, + benchmark_height_); + MaskCpuFlags(benchmark_cpu_info_); + + SplitUVPlane(src_pixels, benchmark_width_ * 2, tmp_pixels_u, benchmark_width_, + tmp_pixels_v, benchmark_width_, benchmark_width_, + benchmark_height_); + + for (int i = 0; i < benchmark_iterations_; ++i) { + MergeUVPlane(tmp_pixels_u, benchmark_width_, tmp_pixels_v, benchmark_width_, + dst_pixels_opt, benchmark_width_ * 2, benchmark_width_, + benchmark_height_); + } + + for (int i = 0; i < kPixels * 2; ++i) { + EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]); + } + + free_aligned_buffer_page_end(src_pixels); + free_aligned_buffer_page_end(tmp_pixels_u); + free_aligned_buffer_page_end(tmp_pixels_v); + free_aligned_buffer_page_end(dst_pixels_opt); + free_aligned_buffer_page_end(dst_pixels_c); +} + +TEST_F(LibYUVPlanarTest, SplitUVPlane_Opt) { + const int kPixels = benchmark_width_ * benchmark_height_; + align_buffer_page_end(src_pixels, kPixels * 2); + align_buffer_page_end(tmp_pixels_u, kPixels); + align_buffer_page_end(tmp_pixels_v, kPixels); + align_buffer_page_end(dst_pixels_opt, kPixels * 2); + align_buffer_page_end(dst_pixels_c, kPixels * 2); + + MemRandomize(src_pixels, kPixels * 2); + MemRandomize(tmp_pixels_u, kPixels); + MemRandomize(tmp_pixels_v, kPixels); + MemRandomize(dst_pixels_opt, kPixels * 2); + MemRandomize(dst_pixels_c, kPixels * 2); + + MaskCpuFlags(disable_cpu_flags_); + SplitUVPlane(src_pixels, benchmark_width_ * 2, tmp_pixels_u, benchmark_width_, + tmp_pixels_v, benchmark_width_, benchmark_width_, + benchmark_height_); + MergeUVPlane(tmp_pixels_u, benchmark_width_, tmp_pixels_v, benchmark_width_, + dst_pixels_c, benchmark_width_ * 2, benchmark_width_, + benchmark_height_); + MaskCpuFlags(benchmark_cpu_info_); + + for (int i = 0; i < benchmark_iterations_; ++i) { + SplitUVPlane(src_pixels, benchmark_width_ * 2, tmp_pixels_u, + benchmark_width_, tmp_pixels_v, benchmark_width_, + benchmark_width_, benchmark_height_); + } + MergeUVPlane(tmp_pixels_u, benchmark_width_, tmp_pixels_v, benchmark_width_, + dst_pixels_opt, benchmark_width_ * 2, benchmark_width_, + benchmark_height_); + + for (int i = 0; i < kPixels * 2; ++i) { + EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]); + } + + free_aligned_buffer_page_end(src_pixels); + free_aligned_buffer_page_end(tmp_pixels_u); + free_aligned_buffer_page_end(tmp_pixels_v); + free_aligned_buffer_page_end(dst_pixels_opt); + free_aligned_buffer_page_end(dst_pixels_c); +} + } // namespace libyuv diff --git a/files/unit_test/rotate_argb_test.cc b/files/unit_test/rotate_argb_test.cc index 9c83c356..d2003895 100644 --- a/files/unit_test/rotate_argb_test.cc +++ b/files/unit_test/rotate_argb_test.cc @@ -10,14 +10,16 @@ #include <stdlib.h> +#include "../unit_test/unit_test.h" #include "libyuv/cpu_id.h" #include "libyuv/rotate_argb.h" -#include "../unit_test/unit_test.h" namespace libyuv { -void TestRotateBpp(int src_width, int src_height, - int dst_width, int dst_height, +void TestRotateBpp(int src_width, + int src_height, + int dst_width, + int dst_height, libyuv::RotationMode mode, int benchmark_iterations, int disable_cpu_flags, @@ -51,26 +53,22 @@ void TestRotateBpp(int src_width, int src_height, if (kBpp == 1) { MaskCpuFlags(disable_cpu_flags); // Disable all CPU optimization. - RotatePlane(src_argb, src_stride_argb, - dst_argb_c, dst_stride_argb, + RotatePlane(src_argb, src_stride_argb, dst_argb_c, dst_stride_argb, src_width, src_height, mode); MaskCpuFlags(benchmark_cpu_info); // Enable all CPU optimization. for (int i = 0; i < benchmark_iterations; ++i) { - RotatePlane(src_argb, src_stride_argb, - dst_argb_opt, dst_stride_argb, + RotatePlane(src_argb, src_stride_argb, dst_argb_opt, dst_stride_argb, src_width, src_height, mode); } } else if (kBpp == 4) { MaskCpuFlags(disable_cpu_flags); // Disable all CPU optimization. - ARGBRotate(src_argb, src_stride_argb, - dst_argb_c, dst_stride_argb, + ARGBRotate(src_argb, src_stride_argb, dst_argb_c, dst_stride_argb, src_width, src_height, mode); MaskCpuFlags(benchmark_cpu_info); // Enable all CPU optimization. for (int i = 0; i < benchmark_iterations; ++i) { - ARGBRotate(src_argb, src_stride_argb, - dst_argb_opt, dst_stride_argb, + ARGBRotate(src_argb, src_stride_argb, dst_argb_opt, dst_stride_argb, src_width, src_height, mode); } } @@ -85,112 +83,104 @@ void TestRotateBpp(int src_width, int src_height, free_aligned_buffer_page_end(src_argb); } -static void ARGBTestRotate(int src_width, int src_height, - int dst_width, int dst_height, +static void ARGBTestRotate(int src_width, + int src_height, + int dst_width, + int dst_height, libyuv::RotationMode mode, int benchmark_iterations, int disable_cpu_flags, int benchmark_cpu_info) { - TestRotateBpp(src_width, src_height, - dst_width, dst_height, - mode, benchmark_iterations, - disable_cpu_flags, benchmark_cpu_info, 4); + TestRotateBpp(src_width, src_height, dst_width, dst_height, mode, + benchmark_iterations, disable_cpu_flags, benchmark_cpu_info, 4); } TEST_F(LibYUVRotateTest, ARGBRotate0_Opt) { - ARGBTestRotate(benchmark_width_, benchmark_height_, - benchmark_width_, benchmark_height_, - kRotate0, benchmark_iterations_, + ARGBTestRotate(benchmark_width_, benchmark_height_, benchmark_width_, + benchmark_height_, kRotate0, benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, ARGBRotate90_Opt) { - ARGBTestRotate(benchmark_width_, benchmark_height_, - benchmark_height_, benchmark_width_, - kRotate90, benchmark_iterations_, + ARGBTestRotate(benchmark_width_, benchmark_height_, benchmark_height_, + benchmark_width_, kRotate90, benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, ARGBRotate180_Opt) { - ARGBTestRotate(benchmark_width_, benchmark_height_, - benchmark_width_, benchmark_height_, - kRotate180, benchmark_iterations_, + ARGBTestRotate(benchmark_width_, benchmark_height_, benchmark_width_, + benchmark_height_, kRotate180, benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, ARGBRotate270_Opt) { - ARGBTestRotate(benchmark_width_, benchmark_height_, - benchmark_height_, benchmark_width_, - kRotate270, benchmark_iterations_, + ARGBTestRotate(benchmark_width_, benchmark_height_, benchmark_height_, + benchmark_width_, kRotate270, benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_); } -static void TestRotatePlane(int src_width, int src_height, - int dst_width, int dst_height, +static void TestRotatePlane(int src_width, + int src_height, + int dst_width, + int dst_height, libyuv::RotationMode mode, int benchmark_iterations, int disable_cpu_flags, int benchmark_cpu_info) { - TestRotateBpp(src_width, src_height, - dst_width, dst_height, - mode, benchmark_iterations, - disable_cpu_flags, benchmark_cpu_info, 1); + TestRotateBpp(src_width, src_height, dst_width, dst_height, mode, + benchmark_iterations, disable_cpu_flags, benchmark_cpu_info, 1); } TEST_F(LibYUVRotateTest, RotatePlane0_Opt) { - TestRotatePlane(benchmark_width_, benchmark_height_, - benchmark_width_, benchmark_height_, - kRotate0, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + TestRotatePlane(benchmark_width_, benchmark_height_, benchmark_width_, + benchmark_height_, kRotate0, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, RotatePlane90_Opt) { - TestRotatePlane(benchmark_width_, benchmark_height_, - benchmark_height_, benchmark_width_, - kRotate90, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + TestRotatePlane(benchmark_width_, benchmark_height_, benchmark_height_, + benchmark_width_, kRotate90, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, RotatePlane180_Opt) { - TestRotatePlane(benchmark_width_, benchmark_height_, - benchmark_width_, benchmark_height_, - kRotate180, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + TestRotatePlane(benchmark_width_, benchmark_height_, benchmark_width_, + benchmark_height_, kRotate180, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, RotatePlane270_Opt) { - TestRotatePlane(benchmark_width_, benchmark_height_, - benchmark_height_, benchmark_width_, - kRotate270, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + TestRotatePlane(benchmark_width_, benchmark_height_, benchmark_height_, + benchmark_width_, kRotate270, benchmark_iterations_, + disable_cpu_flags_, benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, DISABLED_RotatePlane0_Odd) { TestRotatePlane(benchmark_width_ - 3, benchmark_height_ - 1, - benchmark_width_ - 3, benchmark_height_ - 1, - kRotate0, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + benchmark_width_ - 3, benchmark_height_ - 1, kRotate0, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, DISABLED_RotatePlane90_Odd) { TestRotatePlane(benchmark_width_ - 3, benchmark_height_ - 1, - benchmark_height_ - 1, benchmark_width_ - 3, - kRotate90, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + benchmark_height_ - 1, benchmark_width_ - 3, kRotate90, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, DISABLED_RotatePlane180_Odd) { TestRotatePlane(benchmark_width_ - 3, benchmark_height_ - 1, - benchmark_width_ - 3, benchmark_height_ - 1, - kRotate180, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + benchmark_width_ - 3, benchmark_height_ - 1, kRotate180, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, DISABLED_RotatePlane270_Odd) { TestRotatePlane(benchmark_width_ - 3, benchmark_height_ - 1, - benchmark_height_ - 1, benchmark_width_ - 3, - kRotate270, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + benchmark_height_ - 1, benchmark_width_ - 3, kRotate270, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_); } } // namespace libyuv diff --git a/files/unit_test/rotate_test.cc b/files/unit_test/rotate_test.cc index 07e2f73a..d04b96e9 100644 --- a/files/unit_test/rotate_test.cc +++ b/files/unit_test/rotate_test.cc @@ -10,17 +10,20 @@ #include <stdlib.h> +#include "../unit_test/unit_test.h" #include "libyuv/cpu_id.h" #include "libyuv/rotate.h" -#include "../unit_test/unit_test.h" namespace libyuv { -static void I420TestRotate(int src_width, int src_height, - int dst_width, int dst_height, +static void I420TestRotate(int src_width, + int src_height, + int dst_width, + int dst_height, libyuv::RotationMode mode, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info) { + int disable_cpu_flags, + int benchmark_cpu_info) { if (src_width < 1) { src_width = 1; } @@ -50,26 +53,21 @@ static void I420TestRotate(int src_width, int src_height, memset(dst_i420_opt, 3, dst_i420_size); MaskCpuFlags(disable_cpu_flags); // Disable all CPU optimization. - I420Rotate(src_i420, src_width, - src_i420 + src_i420_y_size, (src_width + 1) / 2, - src_i420 + src_i420_y_size + src_i420_uv_size, (src_width + 1) / 2, - dst_i420_c, dst_width, + I420Rotate(src_i420, src_width, src_i420 + src_i420_y_size, + (src_width + 1) / 2, src_i420 + src_i420_y_size + src_i420_uv_size, + (src_width + 1) / 2, dst_i420_c, dst_width, dst_i420_c + dst_i420_y_size, (dst_width + 1) / 2, dst_i420_c + dst_i420_y_size + dst_i420_uv_size, - (dst_width + 1) / 2, - src_width, src_height, mode); + (dst_width + 1) / 2, src_width, src_height, mode); MaskCpuFlags(benchmark_cpu_info); // Enable all CPU optimization. for (int i = 0; i < benchmark_iterations; ++i) { - I420Rotate(src_i420, src_width, - src_i420 + src_i420_y_size, (src_width + 1) / 2, - src_i420 + src_i420_y_size + src_i420_uv_size, - (src_width + 1) / 2, - dst_i420_opt, dst_width, - dst_i420_opt + dst_i420_y_size, (dst_width + 1) / 2, - dst_i420_opt + dst_i420_y_size + dst_i420_uv_size, - (dst_width + 1) / 2, - src_width, src_height, mode); + I420Rotate( + src_i420, src_width, src_i420 + src_i420_y_size, (src_width + 1) / 2, + src_i420 + src_i420_y_size + src_i420_uv_size, (src_width + 1) / 2, + dst_i420_opt, dst_width, dst_i420_opt + dst_i420_y_size, + (dst_width + 1) / 2, dst_i420_opt + dst_i420_y_size + dst_i420_uv_size, + (dst_width + 1) / 2, src_width, src_height, mode); } // Rotation should be exact. @@ -83,30 +81,26 @@ static void I420TestRotate(int src_width, int src_height, } TEST_F(LibYUVRotateTest, I420Rotate0_Opt) { - I420TestRotate(benchmark_width_, benchmark_height_, - benchmark_width_, benchmark_height_, - kRotate0, benchmark_iterations_, + I420TestRotate(benchmark_width_, benchmark_height_, benchmark_width_, + benchmark_height_, kRotate0, benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, I420Rotate90_Opt) { - I420TestRotate(benchmark_width_, benchmark_height_, - benchmark_height_, benchmark_width_, - kRotate90, benchmark_iterations_, + I420TestRotate(benchmark_width_, benchmark_height_, benchmark_height_, + benchmark_width_, kRotate90, benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, I420Rotate180_Opt) { - I420TestRotate(benchmark_width_, benchmark_height_, - benchmark_width_, benchmark_height_, - kRotate180, benchmark_iterations_, + I420TestRotate(benchmark_width_, benchmark_height_, benchmark_width_, + benchmark_height_, kRotate180, benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, I420Rotate270_Opt) { - I420TestRotate(benchmark_width_, benchmark_height_, - benchmark_height_, benchmark_width_, - kRotate270, benchmark_iterations_, + I420TestRotate(benchmark_width_, benchmark_height_, benchmark_height_, + benchmark_width_, kRotate270, benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_); } @@ -115,37 +109,40 @@ TEST_F(LibYUVRotateTest, I420Rotate270_Opt) { // tested by passing an odd width command line or environment variable. TEST_F(LibYUVRotateTest, DISABLED_I420Rotate0_Odd) { I420TestRotate(benchmark_width_ - 3, benchmark_height_ - 1, - benchmark_width_ - 3, benchmark_height_ - 1, - kRotate0, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + benchmark_width_ - 3, benchmark_height_ - 1, kRotate0, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, DISABLED_I420Rotate90_Odd) { I420TestRotate(benchmark_width_ - 3, benchmark_height_ - 1, - benchmark_height_ - 1, benchmark_width_ - 3, - kRotate90, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + benchmark_height_ - 1, benchmark_width_ - 3, kRotate90, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, DISABLED_I420Rotate180_Odd) { I420TestRotate(benchmark_width_ - 3, benchmark_height_ - 1, - benchmark_width_ - 3, benchmark_height_ - 1, - kRotate180, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + benchmark_width_ - 3, benchmark_height_ - 1, kRotate180, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, DISABLED_I420Rotate270_Odd) { I420TestRotate(benchmark_width_ - 3, benchmark_height_ - 1, - benchmark_height_ - 1, benchmark_width_ - 3, - kRotate270, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + benchmark_height_ - 1, benchmark_width_ - 3, kRotate270, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_); } -static void NV12TestRotate(int src_width, int src_height, - int dst_width, int dst_height, +static void NV12TestRotate(int src_width, + int src_height, + int dst_width, + int dst_height, libyuv::RotationMode mode, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info) { + int disable_cpu_flags, + int benchmark_cpu_info) { if (src_width < 1) { src_width = 1; } @@ -176,23 +173,19 @@ static void NV12TestRotate(int src_width, int src_height, memset(dst_i420_opt, 3, dst_i420_size); MaskCpuFlags(disable_cpu_flags); // Disable all CPU optimization. - NV12ToI420Rotate(src_nv12, src_width, - src_nv12 + src_nv12_y_size, (src_width + 1) & ~1, - dst_i420_c, dst_width, + NV12ToI420Rotate(src_nv12, src_width, src_nv12 + src_nv12_y_size, + (src_width + 1) & ~1, dst_i420_c, dst_width, dst_i420_c + dst_i420_y_size, (dst_width + 1) / 2, dst_i420_c + dst_i420_y_size + dst_i420_uv_size, - (dst_width + 1) / 2, - src_width, src_height, mode); + (dst_width + 1) / 2, src_width, src_height, mode); MaskCpuFlags(benchmark_cpu_info); // Enable all CPU optimization. for (int i = 0; i < benchmark_iterations; ++i) { - NV12ToI420Rotate(src_nv12, src_width, - src_nv12 + src_nv12_y_size, (src_width + 1) & ~1, - dst_i420_opt, dst_width, + NV12ToI420Rotate(src_nv12, src_width, src_nv12 + src_nv12_y_size, + (src_width + 1) & ~1, dst_i420_opt, dst_width, dst_i420_opt + dst_i420_y_size, (dst_width + 1) / 2, dst_i420_opt + dst_i420_y_size + dst_i420_uv_size, - (dst_width + 1) / 2, - src_width, src_height, mode); + (dst_width + 1) / 2, src_width, src_height, mode); } // Rotation should be exact. @@ -206,91 +199,79 @@ static void NV12TestRotate(int src_width, int src_height, } TEST_F(LibYUVRotateTest, NV12Rotate0_Opt) { - NV12TestRotate(benchmark_width_, benchmark_height_, - benchmark_width_, benchmark_height_, - kRotate0, benchmark_iterations_, + NV12TestRotate(benchmark_width_, benchmark_height_, benchmark_width_, + benchmark_height_, kRotate0, benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, NV12Rotate90_Opt) { - NV12TestRotate(benchmark_width_, benchmark_height_, - benchmark_height_, benchmark_width_, - kRotate90, benchmark_iterations_, + NV12TestRotate(benchmark_width_, benchmark_height_, benchmark_height_, + benchmark_width_, kRotate90, benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, NV12Rotate180_Opt) { - NV12TestRotate(benchmark_width_, benchmark_height_, - benchmark_width_, benchmark_height_, - kRotate180, benchmark_iterations_, + NV12TestRotate(benchmark_width_, benchmark_height_, benchmark_width_, + benchmark_height_, kRotate180, benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, NV12Rotate270_Opt) { - NV12TestRotate(benchmark_width_, benchmark_height_, - benchmark_height_, benchmark_width_, - kRotate270, benchmark_iterations_, + NV12TestRotate(benchmark_width_, benchmark_height_, benchmark_height_, + benchmark_width_, kRotate270, benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, DISABLED_NV12Rotate0_Odd) { NV12TestRotate(benchmark_width_ - 3, benchmark_height_ - 1, - benchmark_width_ - 3, benchmark_height_ - 1, - kRotate0, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + benchmark_width_ - 3, benchmark_height_ - 1, kRotate0, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, DISABLED_NV12Rotate90_Odd) { NV12TestRotate(benchmark_width_ - 3, benchmark_height_ - 1, - benchmark_height_ - 1, benchmark_width_ - 3, - kRotate90, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + benchmark_height_ - 1, benchmark_width_ - 3, kRotate90, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, DISABLED_NV12Rotate180_Odd) { NV12TestRotate(benchmark_width_ - 3, benchmark_height_ - 1, - benchmark_width_ - 3, benchmark_height_ - 1, - kRotate180, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + benchmark_width_ - 3, benchmark_height_ - 1, kRotate180, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, DISABLED_NV12Rotate270_Odd) { NV12TestRotate(benchmark_width_ - 3, benchmark_height_ - 1, - benchmark_height_ - 1, benchmark_width_ - 3, - kRotate270, benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + benchmark_height_ - 1, benchmark_width_ - 3, kRotate270, + benchmark_iterations_, disable_cpu_flags_, + benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, NV12Rotate0_Invert) { - NV12TestRotate(benchmark_width_, -benchmark_height_, - benchmark_width_, benchmark_height_, - kRotate0, benchmark_iterations_, + NV12TestRotate(benchmark_width_, -benchmark_height_, benchmark_width_, + benchmark_height_, kRotate0, benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, NV12Rotate90_Invert) { - NV12TestRotate(benchmark_width_, -benchmark_height_, - benchmark_height_, benchmark_width_, - kRotate90, benchmark_iterations_, + NV12TestRotate(benchmark_width_, -benchmark_height_, benchmark_height_, + benchmark_width_, kRotate90, benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, NV12Rotate180_Invert) { - NV12TestRotate(benchmark_width_, -benchmark_height_, - benchmark_width_, benchmark_height_, - kRotate180, benchmark_iterations_, + NV12TestRotate(benchmark_width_, -benchmark_height_, benchmark_width_, + benchmark_height_, kRotate180, benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_); } TEST_F(LibYUVRotateTest, NV12Rotate270_Invert) { - NV12TestRotate(benchmark_width_, -benchmark_height_, - benchmark_height_, benchmark_width_, - kRotate270, benchmark_iterations_, + NV12TestRotate(benchmark_width_, -benchmark_height_, benchmark_height_, + benchmark_width_, kRotate270, benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_); } - - - - } // namespace libyuv diff --git a/files/unit_test/scale_argb_test.cc b/files/unit_test/scale_argb_test.cc index f99782f7..d11aec20 100644 --- a/files/unit_test/scale_argb_test.cc +++ b/files/unit_test/scale_argb_test.cc @@ -11,11 +11,11 @@ #include <stdlib.h> #include <time.h> +#include "../unit_test/unit_test.h" #include "libyuv/convert_argb.h" #include "libyuv/cpu_id.h" #include "libyuv/scale_argb.h" #include "libyuv/video_common.h" -#include "../unit_test/unit_test.h" namespace libyuv { @@ -23,18 +23,22 @@ namespace libyuv { #define FILELINESTR(file, line) file ":" STRINGIZE(line) // Test scaling with C vs Opt and return maximum pixel difference. 0 = exact. -static int ARGBTestFilter(int src_width, int src_height, - int dst_width, int dst_height, - FilterMode f, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info) { +static int ARGBTestFilter(int src_width, + int src_height, + int dst_width, + int dst_height, + FilterMode f, + int benchmark_iterations, + int disable_cpu_flags, + int benchmark_cpu_info) { if (!SizeValid(src_width, src_height, dst_width, dst_height)) { return 0; } int i, j; const int b = 0; // 128 to test for padding/stride. - int64 src_argb_plane_size = (Abs(src_width) + b * 2) * - (Abs(src_height) + b * 2) * 4LL; + int64 src_argb_plane_size = + (Abs(src_width) + b * 2) * (Abs(src_height) + b * 2) * 4LL; int src_stride_argb = (b * 2 + Abs(src_width)) * 4; align_buffer_page_end(src_argb, src_argb_plane_size); @@ -59,21 +63,18 @@ static int ARGBTestFilter(int src_width, int src_height, // Warm up both versions for consistent benchmarks. MaskCpuFlags(disable_cpu_flags); // Disable all CPU optimization. ARGBScale(src_argb + (src_stride_argb * b) + b * 4, src_stride_argb, - src_width, src_height, - dst_argb_c + (dst_stride_argb * b) + b * 4, dst_stride_argb, - dst_width, dst_height, f); + src_width, src_height, dst_argb_c + (dst_stride_argb * b) + b * 4, + dst_stride_argb, dst_width, dst_height, f); MaskCpuFlags(benchmark_cpu_info); // Enable all CPU optimization. ARGBScale(src_argb + (src_stride_argb * b) + b * 4, src_stride_argb, - src_width, src_height, - dst_argb_opt + (dst_stride_argb * b) + b * 4, dst_stride_argb, - dst_width, dst_height, f); + src_width, src_height, dst_argb_opt + (dst_stride_argb * b) + b * 4, + dst_stride_argb, dst_width, dst_height, f); MaskCpuFlags(disable_cpu_flags); // Disable all CPU optimization. double c_time = get_time(); ARGBScale(src_argb + (src_stride_argb * b) + b * 4, src_stride_argb, - src_width, src_height, - dst_argb_c + (dst_stride_argb * b) + b * 4, dst_stride_argb, - dst_width, dst_height, f); + src_width, src_height, dst_argb_c + (dst_stride_argb * b) + b * 4, + dst_stride_argb, dst_width, dst_height, f); c_time = (get_time() - c_time); @@ -88,8 +89,8 @@ static int ARGBTestFilter(int src_width, int src_height, opt_time = (get_time() - opt_time) / benchmark_iterations; // Report performance of C vs OPT - printf("filter %d - %8d us C - %8d us OPT\n", - f, static_cast<int>(c_time * 1e6), static_cast<int>(opt_time * 1e6)); + printf("filter %d - %8d us C - %8d us OPT\n", f, + static_cast<int>(c_time * 1e6), static_cast<int>(opt_time * 1e6)); // C version may be a little off from the optimized. Order of // operations may introduce rounding somewhere. So do a difference @@ -115,10 +116,14 @@ static int ARGBTestFilter(int src_width, int src_height, static const int kTileX = 8; static const int kTileY = 8; -static int TileARGBScale(const uint8* src_argb, int src_stride_argb, - int src_width, int src_height, - uint8* dst_argb, int dst_stride_argb, - int dst_width, int dst_height, +static int TileARGBScale(const uint8* src_argb, + int src_stride_argb, + int src_width, + int src_height, + uint8* dst_argb, + int dst_stride_argb, + int dst_width, + int dst_height, FilterMode filtering) { for (int y = 0; y < dst_height; y += kTileY) { for (int x = 0; x < dst_width; x += kTileX) { @@ -130,11 +135,9 @@ static int TileARGBScale(const uint8* src_argb, int src_stride_argb, if (y + clip_height > dst_height) { clip_height = dst_height - y; } - int r = ARGBScaleClip(src_argb, src_stride_argb, - src_width, src_height, - dst_argb, dst_stride_argb, - dst_width, dst_height, - x, y, clip_width, clip_height, filtering); + int r = ARGBScaleClip(src_argb, src_stride_argb, src_width, src_height, + dst_argb, dst_stride_argb, dst_width, dst_height, x, + y, clip_width, clip_height, filtering); if (r) { return r; } @@ -143,16 +146,19 @@ static int TileARGBScale(const uint8* src_argb, int src_stride_argb, return 0; } -static int ARGBClipTestFilter(int src_width, int src_height, - int dst_width, int dst_height, - FilterMode f, int benchmark_iterations) { +static int ARGBClipTestFilter(int src_width, + int src_height, + int dst_width, + int dst_height, + FilterMode f, + int benchmark_iterations) { if (!SizeValid(src_width, src_height, dst_width, dst_height)) { return 0; } const int b = 128; - int64 src_argb_plane_size = (Abs(src_width) + b * 2) * - (Abs(src_height) + b * 2) * 4; + int64 src_argb_plane_size = + (Abs(src_width) + b * 2) * (Abs(src_height) + b * 2) * 4; int src_stride_argb = (b * 2 + Abs(src_width)) * 4; align_buffer_page_end(src_argb, src_argb_plane_size); @@ -184,9 +190,8 @@ static int ARGBClipTestFilter(int src_width, int src_height, // Do full image, no clipping. double c_time = get_time(); ARGBScale(src_argb + (src_stride_argb * b) + b * 4, src_stride_argb, - src_width, src_height, - dst_argb_c + (dst_stride_argb * b) + b * 4, dst_stride_argb, - dst_width, dst_height, f); + src_width, src_height, dst_argb_c + (dst_stride_argb * b) + b * 4, + dst_stride_argb, dst_width, dst_height, f); c_time = (get_time() - c_time); // Do tiled image, clipping scale to a tile at a time. @@ -200,8 +205,8 @@ static int ARGBClipTestFilter(int src_width, int src_height, opt_time = (get_time() - opt_time) / benchmark_iterations; // Report performance of Full vs Tiled. - printf("filter %d - %8d us Full - %8d us Tiled\n", - f, static_cast<int>(c_time * 1e6), static_cast<int>(opt_time * 1e6)); + printf("filter %d - %8d us Full - %8d us Tiled\n", f, + static_cast<int>(c_time * 1e6), static_cast<int>(opt_time * 1e6)); // Compare full scaled image vs tiled image. int max_diff = 0; @@ -226,32 +231,30 @@ static int ARGBClipTestFilter(int src_width, int src_height, #define DX(x, nom, denom) static_cast<int>((Abs(x) / nom) * nom) #define SX(x, nom, denom) static_cast<int>((x / nom) * denom) -#define TEST_FACTOR1(name, filter, nom, denom, max_diff) \ - TEST_F(LibYUVScaleTest, ARGBScaleDownBy##name##_##filter) { \ - int diff = ARGBTestFilter(SX(benchmark_width_, nom, denom), \ - SX(benchmark_height_, nom, denom), \ - DX(benchmark_width_, nom, denom), \ - DX(benchmark_height_, nom, denom), \ - kFilter##filter, benchmark_iterations_, \ - disable_cpu_flags_, benchmark_cpu_info_); \ - EXPECT_LE(diff, max_diff); \ - } \ - TEST_F(LibYUVScaleTest, ARGBScaleDownClipBy##name##_##filter) { \ - int diff = ARGBClipTestFilter(SX(benchmark_width_, nom, denom), \ - SX(benchmark_height_, nom, denom), \ - DX(benchmark_width_, nom, denom), \ - DX(benchmark_height_, nom, denom), \ - kFilter##filter, benchmark_iterations_); \ - EXPECT_LE(diff, max_diff); \ - } +#define TEST_FACTOR1(name, filter, nom, denom, max_diff) \ + TEST_F(LibYUVScaleTest, ARGBScaleDownBy##name##_##filter) { \ + int diff = ARGBTestFilter( \ + SX(benchmark_width_, nom, denom), SX(benchmark_height_, nom, denom), \ + DX(benchmark_width_, nom, denom), DX(benchmark_height_, nom, denom), \ + kFilter##filter, benchmark_iterations_, disable_cpu_flags_, \ + benchmark_cpu_info_); \ + EXPECT_LE(diff, max_diff); \ + } \ + TEST_F(LibYUVScaleTest, ARGBScaleDownClipBy##name##_##filter) { \ + int diff = ARGBClipTestFilter( \ + SX(benchmark_width_, nom, denom), SX(benchmark_height_, nom, denom), \ + DX(benchmark_width_, nom, denom), DX(benchmark_height_, nom, denom), \ + kFilter##filter, benchmark_iterations_); \ + EXPECT_LE(diff, max_diff); \ + } // Test a scale factor with all 4 filters. Expect unfiltered to be exact, but // filtering is different fixed point implementations for SSSE3, Neon and C. -#define TEST_FACTOR(name, nom, denom) \ - TEST_FACTOR1(name, None, nom, denom, 0) \ - TEST_FACTOR1(name, Linear, nom, denom, 3) \ - TEST_FACTOR1(name, Bilinear, nom, denom, 3) \ - TEST_FACTOR1(name, Box, nom, denom, 3) +#define TEST_FACTOR(name, nom, denom) \ + TEST_FACTOR1(name, None, nom, denom, 0) \ + TEST_FACTOR1(name, Linear, nom, denom, 3) \ + TEST_FACTOR1(name, Bilinear, nom, denom, 3) \ + TEST_FACTOR1(name, Box, nom, denom, 3) TEST_FACTOR(2, 1, 2) TEST_FACTOR(4, 1, 4) @@ -265,39 +268,37 @@ TEST_FACTOR(3, 1, 3) #undef DX #define TEST_SCALETO1(name, width, height, filter, max_diff) \ - TEST_F(LibYUVScaleTest, name##To##width##x##height##_##filter) { \ - int diff = ARGBTestFilter(benchmark_width_, benchmark_height_, \ - width, height, \ - kFilter##filter, benchmark_iterations_, \ - disable_cpu_flags_, benchmark_cpu_info_); \ - EXPECT_LE(diff, max_diff); \ - } \ - TEST_F(LibYUVScaleTest, name##From##width##x##height##_##filter) { \ - int diff = ARGBTestFilter(width, height, \ - Abs(benchmark_width_), Abs(benchmark_height_), \ - kFilter##filter, benchmark_iterations_, \ - disable_cpu_flags_, benchmark_cpu_info_); \ - EXPECT_LE(diff, max_diff); \ - } \ - TEST_F(LibYUVScaleTest, name##ClipTo##width##x##height##_##filter) { \ - int diff = ARGBClipTestFilter(benchmark_width_, benchmark_height_, \ - width, height, \ - kFilter##filter, benchmark_iterations_); \ - EXPECT_LE(diff, max_diff); \ - } \ - TEST_F(LibYUVScaleTest, name##ClipFrom##width##x##height##_##filter) { \ - int diff = ARGBClipTestFilter(width, height, \ - Abs(benchmark_width_), \ - Abs(benchmark_height_), \ - kFilter##filter, benchmark_iterations_); \ - EXPECT_LE(diff, max_diff); \ - } + TEST_F(LibYUVScaleTest, name##To##width##x##height##_##filter) { \ + int diff = ARGBTestFilter(benchmark_width_, benchmark_height_, width, \ + height, kFilter##filter, benchmark_iterations_, \ + disable_cpu_flags_, benchmark_cpu_info_); \ + EXPECT_LE(diff, max_diff); \ + } \ + TEST_F(LibYUVScaleTest, name##From##width##x##height##_##filter) { \ + int diff = ARGBTestFilter(width, height, Abs(benchmark_width_), \ + Abs(benchmark_height_), kFilter##filter, \ + benchmark_iterations_, disable_cpu_flags_, \ + benchmark_cpu_info_); \ + EXPECT_LE(diff, max_diff); \ + } \ + TEST_F(LibYUVScaleTest, name##ClipTo##width##x##height##_##filter) { \ + int diff = \ + ARGBClipTestFilter(benchmark_width_, benchmark_height_, width, height, \ + kFilter##filter, benchmark_iterations_); \ + EXPECT_LE(diff, max_diff); \ + } \ + TEST_F(LibYUVScaleTest, name##ClipFrom##width##x##height##_##filter) { \ + int diff = ARGBClipTestFilter(width, height, Abs(benchmark_width_), \ + Abs(benchmark_height_), kFilter##filter, \ + benchmark_iterations_); \ + EXPECT_LE(diff, max_diff); \ + } /// Test scale to a specified size with all 4 filters. -#define TEST_SCALETO(name, width, height) \ - TEST_SCALETO1(name, width, height, None, 0) \ - TEST_SCALETO1(name, width, height, Linear, 3) \ - TEST_SCALETO1(name, width, height, Bilinear, 3) +#define TEST_SCALETO(name, width, height) \ + TEST_SCALETO1(name, width, height, None, 0) \ + TEST_SCALETO1(name, width, height, Linear, 3) \ + TEST_SCALETO1(name, width, height, Bilinear, 3) TEST_SCALETO(ARGBScale, 1, 1) TEST_SCALETO(ARGBScale, 320, 240) @@ -310,31 +311,33 @@ TEST_SCALETO(ARGBScale, 1280, 720) // Scale with YUV conversion to ARGB and clipping. LIBYUV_API -int YUVToARGBScaleReference2(const uint8* src_y, int src_stride_y, - const uint8* src_u, int src_stride_u, - const uint8* src_v, int src_stride_v, - uint32 src_fourcc, - int src_width, int src_height, - uint8* dst_argb, int dst_stride_argb, - uint32 dst_fourcc, - int dst_width, int dst_height, - int clip_x, int clip_y, - int clip_width, int clip_height, +int YUVToARGBScaleReference2(const uint8* src_y, + int src_stride_y, + const uint8* src_u, + int src_stride_u, + const uint8* src_v, + int src_stride_v, + uint32 /* src_fourcc */, // TODO: Add support. + int src_width, + int src_height, + uint8* dst_argb, + int dst_stride_argb, + uint32 /* dst_fourcc */, // TODO: Add support. + int dst_width, + int dst_height, + int clip_x, + int clip_y, + int clip_width, + int clip_height, enum FilterMode filtering) { uint8* argb_buffer = static_cast<uint8*>(malloc(src_width * src_height * 4)); int r; - I420ToARGB(src_y, src_stride_y, - src_u, src_stride_u, - src_v, src_stride_v, - argb_buffer, src_width * 4, - src_width, src_height); - - r = ARGBScaleClip(argb_buffer, src_width * 4, - src_width, src_height, - dst_argb, dst_stride_argb, - dst_width, dst_height, - clip_x, clip_y, clip_width, clip_height, - filtering); + I420ToARGB(src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v, + argb_buffer, src_width * 4, src_width, src_height); + + r = ARGBScaleClip(argb_buffer, src_width * 4, src_width, src_height, dst_argb, + dst_stride_argb, dst_width, dst_height, clip_x, clip_y, + clip_width, clip_height, filtering); free(argb_buffer); return r; } @@ -360,13 +363,15 @@ static void FillRamp(uint8* buf, int width, int height, int v, int dx, int dy) { } // Test scaling with C vs Opt and return maximum pixel difference. 0 = exact. -static int YUVToARGBTestFilter(int src_width, int src_height, - int dst_width, int dst_height, - FilterMode f, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info) { +static int YUVToARGBTestFilter(int src_width, + int src_height, + int dst_width, + int dst_height, + FilterMode f, + int benchmark_iterations) { int64 src_y_plane_size = Abs(src_width) * Abs(src_height); - int64 src_uv_plane_size = ((Abs(src_width) + 1) / 2) * - ((Abs(src_height) + 1) / 2); + int64 src_uv_plane_size = + ((Abs(src_width) + 1) / 2) * ((Abs(src_height) + 1) / 2); int src_stride_y = Abs(src_width); int src_stride_uv = (Abs(src_width) + 1) / 2; @@ -374,8 +379,8 @@ static int YUVToARGBTestFilter(int src_width, int src_height, align_buffer_page_end(src_u, src_uv_plane_size); align_buffer_page_end(src_v, src_uv_plane_size); - int64 dst_argb_plane_size = (dst_width) * (dst_height) * 4LL; - int dst_stride_argb = (dst_width) * 4; + int64 dst_argb_plane_size = (dst_width) * (dst_height)*4LL; + int dst_stride_argb = (dst_width)*4; align_buffer_page_end(dst_argb_c, dst_argb_plane_size); align_buffer_page_end(dst_argb_opt, dst_argb_plane_size); if (!dst_argb_c || !dst_argb_opt || !src_y || !src_u || !src_v) { @@ -390,28 +395,18 @@ static int YUVToARGBTestFilter(int src_width, int src_height, memset(dst_argb_c, 2, dst_argb_plane_size); memset(dst_argb_opt, 3, dst_argb_plane_size); - YUVToARGBScaleReference2(src_y, src_stride_y, - src_u, src_stride_uv, - src_v, src_stride_uv, - libyuv::FOURCC_I420, - src_width, src_height, - dst_argb_c, dst_stride_argb, - libyuv::FOURCC_I420, - dst_width, dst_height, - 0, 0, dst_width, dst_height, - f); + YUVToARGBScaleReference2(src_y, src_stride_y, src_u, src_stride_uv, src_v, + src_stride_uv, libyuv::FOURCC_I420, src_width, + src_height, dst_argb_c, dst_stride_argb, + libyuv::FOURCC_I420, dst_width, dst_height, 0, 0, + dst_width, dst_height, f); for (int i = 0; i < benchmark_iterations; ++i) { - YUVToARGBScaleClip(src_y, src_stride_y, - src_u, src_stride_uv, - src_v, src_stride_uv, - libyuv::FOURCC_I420, - src_width, src_height, - dst_argb_opt, dst_stride_argb, - libyuv::FOURCC_I420, - dst_width, dst_height, - 0, 0, dst_width, dst_height, - f); + YUVToARGBScaleClip(src_y, src_stride_y, src_u, src_stride_uv, src_v, + src_stride_uv, libyuv::FOURCC_I420, src_width, + src_height, dst_argb_opt, dst_stride_argb, + libyuv::FOURCC_I420, dst_width, dst_height, 0, 0, + dst_width, dst_height, f); } int max_diff = 0; for (int i = 0; i < dst_height; ++i) { @@ -419,9 +414,7 @@ static int YUVToARGBTestFilter(int src_width, int src_height, int abs_diff = Abs(dst_argb_c[(i * dst_stride_argb) + j] - dst_argb_opt[(i * dst_stride_argb) + j]); if (abs_diff > max_diff) { - printf("error %d at %d,%d c %d opt %d", - abs_diff, - j, i, + printf("error %d at %d,%d c %d opt %d", abs_diff, j, i, dst_argb_c[(i * dst_stride_argb) + j], dst_argb_opt[(i * dst_stride_argb) + j]); EXPECT_LE(abs_diff, 40); @@ -439,24 +432,18 @@ static int YUVToARGBTestFilter(int src_width, int src_height, } TEST_F(LibYUVScaleTest, YUVToRGBScaleUp) { - int diff = YUVToARGBTestFilter(benchmark_width_, benchmark_height_, - benchmark_width_ * 3 / 2, - benchmark_height_ * 3 / 2, - libyuv::kFilterBilinear, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + int diff = + YUVToARGBTestFilter(benchmark_width_, benchmark_height_, + benchmark_width_ * 3 / 2, benchmark_height_ * 3 / 2, + libyuv::kFilterBilinear, benchmark_iterations_); EXPECT_LE(diff, 10); } TEST_F(LibYUVScaleTest, YUVToRGBScaleDown) { - int diff = YUVToARGBTestFilter(benchmark_width_ * 3 / 2, - benchmark_height_ * 3 / 2, - benchmark_width_, benchmark_height_, - libyuv::kFilterBilinear, - benchmark_iterations_, - disable_cpu_flags_, benchmark_cpu_info_); + int diff = YUVToARGBTestFilter( + benchmark_width_ * 3 / 2, benchmark_height_ * 3 / 2, benchmark_width_, + benchmark_height_, libyuv::kFilterBilinear, benchmark_iterations_); EXPECT_LE(diff, 10); } - } // namespace libyuv diff --git a/files/unit_test/scale_test.cc b/files/unit_test/scale_test.cc index f40443e2..0b4ec30b 100644 --- a/files/unit_test/scale_test.cc +++ b/files/unit_test/scale_test.cc @@ -11,9 +11,9 @@ #include <stdlib.h> #include <time.h> +#include "../unit_test/unit_test.h" #include "libyuv/cpu_id.h" #include "libyuv/scale.h" -#include "../unit_test/unit_test.h" #define STRINGIZE(line) #line #define FILELINESTR(file, line) file ":" STRINGIZE(line) @@ -21,10 +21,14 @@ namespace libyuv { // Test scaling with C vs Opt and return maximum pixel difference. 0 = exact. -static int TestFilter(int src_width, int src_height, - int dst_width, int dst_height, - FilterMode f, int benchmark_iterations, - int disable_cpu_flags, int benchmark_cpu_info) { +static int TestFilter(int src_width, + int src_height, + int dst_width, + int dst_height, + FilterMode f, + int benchmark_iterations, + int disable_cpu_flags, + int benchmark_cpu_info) { if (!SizeValid(src_width, src_height, dst_width, dst_height)) { return 0; } @@ -41,9 +45,8 @@ static int TestFilter(int src_width, int src_height, int src_stride_uv = b * 2 + src_width_uv; align_buffer_page_end(src_y, src_y_plane_size) - align_buffer_page_end(src_u, src_uv_plane_size) - align_buffer_page_end(src_v, src_uv_plane_size) - if (!src_y || !src_u || !src_v) { + align_buffer_page_end(src_u, src_uv_plane_size) align_buffer_page_end( + src_v, src_uv_plane_size) if (!src_y || !src_u || !src_v) { printf("Skipped. Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n"); return 0; } @@ -61,13 +64,15 @@ static int TestFilter(int src_width, int src_height, int dst_stride_uv = b * 2 + dst_width_uv; align_buffer_page_end(dst_y_c, dst_y_plane_size) - align_buffer_page_end(dst_u_c, dst_uv_plane_size) - align_buffer_page_end(dst_v_c, dst_uv_plane_size) - align_buffer_page_end(dst_y_opt, dst_y_plane_size) - align_buffer_page_end(dst_u_opt, dst_uv_plane_size) - align_buffer_page_end(dst_v_opt, dst_uv_plane_size) - if (!dst_y_c || !dst_u_c || !dst_v_c || - !dst_y_opt|| !dst_u_opt|| !dst_v_opt) { + align_buffer_page_end(dst_u_c, dst_uv_plane_size) + align_buffer_page_end(dst_v_c, dst_uv_plane_size) + align_buffer_page_end(dst_y_opt, dst_y_plane_size) + align_buffer_page_end(dst_u_opt, dst_uv_plane_size) + align_buffer_page_end( + dst_v_opt, + dst_uv_plane_size) if (!dst_y_c || !dst_u_c || + !dst_v_c || !dst_y_opt || + !dst_u_opt || !dst_v_opt) { printf("Skipped. Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n"); return 0; } @@ -76,12 +81,11 @@ static int TestFilter(int src_width, int src_height, double c_time = get_time(); I420Scale(src_y + (src_stride_y * b) + b, src_stride_y, src_u + (src_stride_uv * b) + b, src_stride_uv, - src_v + (src_stride_uv * b) + b, src_stride_uv, - src_width, src_height, - dst_y_c + (dst_stride_y * b) + b, dst_stride_y, + src_v + (src_stride_uv * b) + b, src_stride_uv, src_width, + src_height, dst_y_c + (dst_stride_y * b) + b, dst_stride_y, dst_u_c + (dst_stride_uv * b) + b, dst_stride_uv, - dst_v_c + (dst_stride_uv * b) + b, dst_stride_uv, - dst_width, dst_height, f); + dst_v_c + (dst_stride_uv * b) + b, dst_stride_uv, dst_width, + dst_height, f); c_time = (get_time() - c_time); MaskCpuFlags(benchmark_cpu_info); // Enable all CPU optimization. @@ -89,19 +93,16 @@ static int TestFilter(int src_width, int src_height, for (i = 0; i < benchmark_iterations; ++i) { I420Scale(src_y + (src_stride_y * b) + b, src_stride_y, src_u + (src_stride_uv * b) + b, src_stride_uv, - src_v + (src_stride_uv * b) + b, src_stride_uv, - src_width, src_height, - dst_y_opt + (dst_stride_y * b) + b, dst_stride_y, + src_v + (src_stride_uv * b) + b, src_stride_uv, src_width, + src_height, dst_y_opt + (dst_stride_y * b) + b, dst_stride_y, dst_u_opt + (dst_stride_uv * b) + b, dst_stride_uv, - dst_v_opt + (dst_stride_uv * b) + b, dst_stride_uv, - dst_width, dst_height, f); + dst_v_opt + (dst_stride_uv * b) + b, dst_stride_uv, dst_width, + dst_height, f); } opt_time = (get_time() - opt_time) / benchmark_iterations; // Report performance of C vs OPT - printf("filter %d - %8d us C - %8d us OPT\n", - f, - static_cast<int>(c_time * 1e6), - static_cast<int>(opt_time * 1e6)); + printf("filter %d - %8d us C - %8d us OPT\n", f, + static_cast<int>(c_time * 1e6), static_cast<int>(opt_time * 1e6)); // C version may be a little off from the optimized. Order of // operations may introduce rounding somewhere. So do a difference @@ -133,25 +134,27 @@ static int TestFilter(int src_width, int src_height, } } - free_aligned_buffer_page_end(dst_y_c) - free_aligned_buffer_page_end(dst_u_c) - free_aligned_buffer_page_end(dst_v_c) - free_aligned_buffer_page_end(dst_y_opt) - free_aligned_buffer_page_end(dst_u_opt) - free_aligned_buffer_page_end(dst_v_opt) + free_aligned_buffer_page_end(dst_y_c) free_aligned_buffer_page_end(dst_u_c) + free_aligned_buffer_page_end(dst_v_c) + free_aligned_buffer_page_end(dst_y_opt) + free_aligned_buffer_page_end(dst_u_opt) + free_aligned_buffer_page_end(dst_v_opt) - free_aligned_buffer_page_end(src_y) - free_aligned_buffer_page_end(src_u) - free_aligned_buffer_page_end(src_v) + free_aligned_buffer_page_end(src_y) + free_aligned_buffer_page_end(src_u) + free_aligned_buffer_page_end(src_v) - return max_diff; + return max_diff; } // Test scaling with 8 bit C vs 16 bit C and return maximum pixel difference. // 0 = exact. -static int TestFilter_16(int src_width, int src_height, - int dst_width, int dst_height, - FilterMode f, int benchmark_iterations) { +static int TestFilter_16(int src_width, + int src_height, + int dst_width, + int dst_height, + FilterMode f, + int benchmark_iterations) { if (!SizeValid(src_width, src_height, dst_width, dst_height)) { return 0; } @@ -161,20 +164,18 @@ static int TestFilter_16(int src_width, int src_height, int src_width_uv = (Abs(src_width) + 1) >> 1; int src_height_uv = (Abs(src_height) + 1) >> 1; - int64 src_y_plane_size = (Abs(src_width) + b * 2) * - (Abs(src_height) + b * 2); + int64 src_y_plane_size = (Abs(src_width) + b * 2) * (Abs(src_height) + b * 2); int64 src_uv_plane_size = (src_width_uv + b * 2) * (src_height_uv + b * 2); int src_stride_y = b * 2 + Abs(src_width); int src_stride_uv = b * 2 + src_width_uv; - align_buffer_page_end(src_y, src_y_plane_size) - align_buffer_page_end(src_u, src_uv_plane_size) - align_buffer_page_end(src_v, src_uv_plane_size) - align_buffer_page_end(src_y_16, src_y_plane_size * 2) - align_buffer_page_end(src_u_16, src_uv_plane_size * 2) - align_buffer_page_end(src_v_16, src_uv_plane_size * 2) - uint16* p_src_y_16 = reinterpret_cast<uint16*>(src_y_16); + align_buffer_page_end(src_y, src_y_plane_size) align_buffer_page_end( + src_u, src_uv_plane_size) align_buffer_page_end(src_v, src_uv_plane_size) + align_buffer_page_end(src_y_16, src_y_plane_size * 2) + align_buffer_page_end(src_u_16, src_uv_plane_size * 2) + align_buffer_page_end(src_v_16, src_uv_plane_size * 2) + uint16* p_src_y_16 = reinterpret_cast<uint16*>(src_y_16); uint16* p_src_u_16 = reinterpret_cast<uint16*>(src_u_16); uint16* p_src_v_16 = reinterpret_cast<uint16*>(src_v_16); @@ -205,34 +206,33 @@ static int TestFilter_16(int src_width, int src_height, int dst_stride_uv = b * 2 + dst_width_uv; align_buffer_page_end(dst_y_8, dst_y_plane_size) - align_buffer_page_end(dst_u_8, dst_uv_plane_size) - align_buffer_page_end(dst_v_8, dst_uv_plane_size) - align_buffer_page_end(dst_y_16, dst_y_plane_size * 2) - align_buffer_page_end(dst_u_16, dst_uv_plane_size * 2) - align_buffer_page_end(dst_v_16, dst_uv_plane_size * 2) - - uint16* p_dst_y_16 = reinterpret_cast<uint16*>(dst_y_16); + align_buffer_page_end(dst_u_8, dst_uv_plane_size) + align_buffer_page_end(dst_v_8, dst_uv_plane_size) + align_buffer_page_end(dst_y_16, dst_y_plane_size * 2) + align_buffer_page_end(dst_u_16, dst_uv_plane_size * 2) + align_buffer_page_end(dst_v_16, dst_uv_plane_size * 2) + + uint16* p_dst_y_16 = + reinterpret_cast<uint16*>(dst_y_16); uint16* p_dst_u_16 = reinterpret_cast<uint16*>(dst_u_16); uint16* p_dst_v_16 = reinterpret_cast<uint16*>(dst_v_16); I420Scale(src_y + (src_stride_y * b) + b, src_stride_y, src_u + (src_stride_uv * b) + b, src_stride_uv, - src_v + (src_stride_uv * b) + b, src_stride_uv, - src_width, src_height, - dst_y_8 + (dst_stride_y * b) + b, dst_stride_y, + src_v + (src_stride_uv * b) + b, src_stride_uv, src_width, + src_height, dst_y_8 + (dst_stride_y * b) + b, dst_stride_y, dst_u_8 + (dst_stride_uv * b) + b, dst_stride_uv, - dst_v_8 + (dst_stride_uv * b) + b, dst_stride_uv, - dst_width, dst_height, f); + dst_v_8 + (dst_stride_uv * b) + b, dst_stride_uv, dst_width, + dst_height, f); for (i = 0; i < benchmark_iterations; ++i) { I420Scale_16(p_src_y_16 + (src_stride_y * b) + b, src_stride_y, p_src_u_16 + (src_stride_uv * b) + b, src_stride_uv, - p_src_v_16 + (src_stride_uv * b) + b, src_stride_uv, - src_width, src_height, - p_dst_y_16 + (dst_stride_y * b) + b, dst_stride_y, + p_src_v_16 + (src_stride_uv * b) + b, src_stride_uv, src_width, + src_height, p_dst_y_16 + (dst_stride_y * b) + b, dst_stride_y, p_dst_u_16 + (dst_stride_uv * b) + b, dst_stride_uv, - p_dst_v_16 + (dst_stride_uv * b) + b, dst_stride_uv, - dst_width, dst_height, f); + p_dst_v_16 + (dst_stride_uv * b) + b, dst_stride_uv, dst_width, + dst_height, f); } // Expect an exact match @@ -262,21 +262,20 @@ static int TestFilter_16(int src_width, int src_height, } } - free_aligned_buffer_page_end(dst_y_8) - free_aligned_buffer_page_end(dst_u_8) - free_aligned_buffer_page_end(dst_v_8) - free_aligned_buffer_page_end(dst_y_16) - free_aligned_buffer_page_end(dst_u_16) - free_aligned_buffer_page_end(dst_v_16) - - free_aligned_buffer_page_end(src_y) - free_aligned_buffer_page_end(src_u) - free_aligned_buffer_page_end(src_v) - free_aligned_buffer_page_end(src_y_16) - free_aligned_buffer_page_end(src_u_16) - free_aligned_buffer_page_end(src_v_16) - - return max_diff; + free_aligned_buffer_page_end(dst_y_8) free_aligned_buffer_page_end(dst_u_8) + free_aligned_buffer_page_end(dst_v_8) + free_aligned_buffer_page_end(dst_y_16) + free_aligned_buffer_page_end(dst_u_16) + free_aligned_buffer_page_end(dst_v_16) + + free_aligned_buffer_page_end(src_y) + free_aligned_buffer_page_end(src_u) + free_aligned_buffer_page_end(src_v) + free_aligned_buffer_page_end(src_y_16) + free_aligned_buffer_page_end(src_u_16) + free_aligned_buffer_page_end(src_v_16) + + return max_diff; } // The following adjustments in dimensions ensure the scale factor will be @@ -285,32 +284,30 @@ static int TestFilter_16(int src_width, int src_height, #define DX(x, nom, denom) static_cast<int>(((Abs(x) / nom + 1) / 2) * nom * 2) #define SX(x, nom, denom) static_cast<int>(((x / nom + 1) / 2) * denom * 2) -#define TEST_FACTOR1(name, filter, nom, denom, max_diff) \ - TEST_F(LibYUVScaleTest, ScaleDownBy##name##_##filter) { \ - int diff = TestFilter(SX(benchmark_width_, nom, denom), \ - SX(benchmark_height_, nom, denom), \ - DX(benchmark_width_, nom, denom), \ - DX(benchmark_height_, nom, denom), \ - kFilter##filter, benchmark_iterations_, \ - disable_cpu_flags_, benchmark_cpu_info_); \ - EXPECT_LE(diff, max_diff); \ - } \ - TEST_F(LibYUVScaleTest, DISABLED_ScaleDownBy##name##_##filter##_16) { \ - int diff = TestFilter_16(SX(benchmark_width_, nom, denom), \ - SX(benchmark_height_, nom, denom), \ - DX(benchmark_width_, nom, denom), \ - DX(benchmark_height_, nom, denom), \ - kFilter##filter, benchmark_iterations_); \ - EXPECT_LE(diff, max_diff); \ - } +#define TEST_FACTOR1(name, filter, nom, denom, max_diff) \ + TEST_F(LibYUVScaleTest, ScaleDownBy##name##_##filter) { \ + int diff = TestFilter( \ + SX(benchmark_width_, nom, denom), SX(benchmark_height_, nom, denom), \ + DX(benchmark_width_, nom, denom), DX(benchmark_height_, nom, denom), \ + kFilter##filter, benchmark_iterations_, disable_cpu_flags_, \ + benchmark_cpu_info_); \ + EXPECT_LE(diff, max_diff); \ + } \ + TEST_F(LibYUVScaleTest, DISABLED_ScaleDownBy##name##_##filter##_16) { \ + int diff = TestFilter_16( \ + SX(benchmark_width_, nom, denom), SX(benchmark_height_, nom, denom), \ + DX(benchmark_width_, nom, denom), DX(benchmark_height_, nom, denom), \ + kFilter##filter, benchmark_iterations_); \ + EXPECT_LE(diff, max_diff); \ + } // Test a scale factor with all 4 filters. Expect unfiltered to be exact, but // filtering is different fixed point implementations for SSSE3, Neon and C. -#define TEST_FACTOR(name, nom, denom, boxdiff) \ - TEST_FACTOR1(name, None, nom, denom, 0) \ - TEST_FACTOR1(name, Linear, nom, denom, 3) \ - TEST_FACTOR1(name, Bilinear, nom, denom, 3) \ - TEST_FACTOR1(name, Box, nom, denom, boxdiff) +#define TEST_FACTOR(name, nom, denom, boxdiff) \ + TEST_FACTOR1(name, None, nom, denom, 0) \ + TEST_FACTOR1(name, Linear, nom, denom, 3) \ + TEST_FACTOR1(name, Bilinear, nom, denom, 3) \ + TEST_FACTOR1(name, Box, nom, denom, boxdiff) TEST_FACTOR(2, 1, 2, 0) TEST_FACTOR(4, 1, 4, 0) @@ -323,42 +320,40 @@ TEST_FACTOR(3, 1, 3, 0) #undef SX #undef DX -#define TEST_SCALETO1(name, width, height, filter, max_diff) \ - TEST_F(LibYUVScaleTest, name##To##width##x##height##_##filter) { \ - int diff = TestFilter(benchmark_width_, benchmark_height_, \ - width, height, \ - kFilter##filter, benchmark_iterations_, \ - disable_cpu_flags_, benchmark_cpu_info_); \ - EXPECT_LE(diff, max_diff); \ - } \ - TEST_F(LibYUVScaleTest, name##From##width##x##height##_##filter) { \ - int diff = TestFilter(width, height, \ - Abs(benchmark_width_), Abs(benchmark_height_), \ - kFilter##filter, benchmark_iterations_, \ - disable_cpu_flags_, benchmark_cpu_info_); \ - EXPECT_LE(diff, max_diff); \ - } \ - TEST_F(LibYUVScaleTest, \ - DISABLED_##name##To##width##x##height##_##filter##_16) { \ - int diff = TestFilter_16(benchmark_width_, benchmark_height_, \ - width, height, \ - kFilter##filter, benchmark_iterations_); \ - EXPECT_LE(diff, max_diff); \ - } \ - TEST_F(LibYUVScaleTest, \ - DISABLED_##name##From##width##x##height##_##filter##_16) { \ - int diff = TestFilter_16(width, height, \ - Abs(benchmark_width_), Abs(benchmark_height_), \ - kFilter##filter, benchmark_iterations_); \ - EXPECT_LE(diff, max_diff); \ - } +#define TEST_SCALETO1(name, width, height, filter, max_diff) \ + TEST_F(LibYUVScaleTest, name##To##width##x##height##_##filter) { \ + int diff = TestFilter(benchmark_width_, benchmark_height_, width, height, \ + kFilter##filter, benchmark_iterations_, \ + disable_cpu_flags_, benchmark_cpu_info_); \ + EXPECT_LE(diff, max_diff); \ + } \ + TEST_F(LibYUVScaleTest, name##From##width##x##height##_##filter) { \ + int diff = TestFilter(width, height, Abs(benchmark_width_), \ + Abs(benchmark_height_), kFilter##filter, \ + benchmark_iterations_, disable_cpu_flags_, \ + benchmark_cpu_info_); \ + EXPECT_LE(diff, max_diff); \ + } \ + TEST_F(LibYUVScaleTest, \ + DISABLED_##name##To##width##x##height##_##filter##_16) { \ + int diff = TestFilter_16(benchmark_width_, benchmark_height_, width, \ + height, kFilter##filter, benchmark_iterations_); \ + EXPECT_LE(diff, max_diff); \ + } \ + TEST_F(LibYUVScaleTest, \ + DISABLED_##name##From##width##x##height##_##filter##_16) { \ + int diff = TestFilter_16(width, height, Abs(benchmark_width_), \ + Abs(benchmark_height_), kFilter##filter, \ + benchmark_iterations_); \ + EXPECT_LE(diff, max_diff); \ + } // Test scale to a specified size with all 4 filters. -#define TEST_SCALETO(name, width, height) \ - TEST_SCALETO1(name, width, height, None, 0) \ - TEST_SCALETO1(name, width, height, Linear, 0) \ - TEST_SCALETO1(name, width, height, Bilinear, 0) \ - TEST_SCALETO1(name, width, height, Box, 0) +#define TEST_SCALETO(name, width, height) \ + TEST_SCALETO1(name, width, height, None, 0) \ + TEST_SCALETO1(name, width, height, Linear, 0) \ + TEST_SCALETO1(name, width, height, Bilinear, 0) \ + TEST_SCALETO1(name, width, height, Box, 0) TEST_SCALETO(Scale, 1, 1) TEST_SCALETO(Scale, 320, 240) diff --git a/files/unit_test/unit_test.cc b/files/unit_test/unit_test.cc index e75510fd..7f8bcf8f 100644 --- a/files/unit_test/unit_test.cc +++ b/files/unit_test/unit_test.cc @@ -25,18 +25,21 @@ unsigned int fastrand_seed = 0xfb; DEFINE_int32(libyuv_width, 0, "width of test image."); DEFINE_int32(libyuv_height, 0, "height of test image."); DEFINE_int32(libyuv_repeat, 0, "number of times to repeat test."); -DEFINE_int32(libyuv_flags, 0, - "cpu flags for reference code. 1 = C, -1 = SIMD"); -DEFINE_int32(libyuv_cpu_info, 0, +DEFINE_int32(libyuv_flags, 0, "cpu flags for reference code. 1 = C, -1 = SIMD"); +DEFINE_int32(libyuv_cpu_info, + 0, "cpu flags for benchmark code. 1 = C, -1 = SIMD"); // For quicker unittests, default is 128 x 72. But when benchmarking, // default to 720p. Allow size to specify. // Set flags to -1 for benchmarking to avoid slower C code. -LibYUVConvertTest::LibYUVConvertTest() : - benchmark_iterations_(BENCHMARK_ITERATIONS), benchmark_width_(128), - benchmark_height_(72), disable_cpu_flags_(1), benchmark_cpu_info_(-1) { +LibYUVConvertTest::LibYUVConvertTest() + : benchmark_iterations_(BENCHMARK_ITERATIONS), + benchmark_width_(128), + benchmark_height_(72), + disable_cpu_flags_(1), + benchmark_cpu_info_(-1) { const char* repeat = getenv("LIBYUV_REPEAT"); if (repeat) { benchmark_iterations_ = atoi(repeat); // NOLINT @@ -76,19 +79,26 @@ LibYUVConvertTest::LibYUVConvertTest() : if (FLAGS_libyuv_cpu_info) { benchmark_cpu_info_ = FLAGS_libyuv_cpu_info; } - benchmark_pixels_div256_ = static_cast<int>(( - static_cast<double>(Abs(benchmark_width_)) * - static_cast<double>(Abs(benchmark_height_)) * - static_cast<double>(benchmark_iterations_) + 255.0) / 256.0); - benchmark_pixels_div1280_ = static_cast<int>(( - static_cast<double>(Abs(benchmark_width_)) * - static_cast<double>(Abs(benchmark_height_)) * - static_cast<double>(benchmark_iterations_) + 1279.0) / 1280.0); + benchmark_pixels_div256_ = + static_cast<int>((static_cast<double>(Abs(benchmark_width_)) * + static_cast<double>(Abs(benchmark_height_)) * + static_cast<double>(benchmark_iterations_) + + 255.0) / + 256.0); + benchmark_pixels_div1280_ = + static_cast<int>((static_cast<double>(Abs(benchmark_width_)) * + static_cast<double>(Abs(benchmark_height_)) * + static_cast<double>(benchmark_iterations_) + + 1279.0) / + 1280.0); } -LibYUVColorTest::LibYUVColorTest() : - benchmark_iterations_(BENCHMARK_ITERATIONS), benchmark_width_(128), - benchmark_height_(72), disable_cpu_flags_(1), benchmark_cpu_info_(-1) { +LibYUVColorTest::LibYUVColorTest() + : benchmark_iterations_(BENCHMARK_ITERATIONS), + benchmark_width_(128), + benchmark_height_(72), + disable_cpu_flags_(1), + benchmark_cpu_info_(-1) { const char* repeat = getenv("LIBYUV_REPEAT"); if (repeat) { benchmark_iterations_ = atoi(repeat); // NOLINT @@ -128,19 +138,26 @@ LibYUVColorTest::LibYUVColorTest() : if (FLAGS_libyuv_cpu_info) { benchmark_cpu_info_ = FLAGS_libyuv_cpu_info; } - benchmark_pixels_div256_ = static_cast<int>(( - static_cast<double>(Abs(benchmark_width_)) * - static_cast<double>(Abs(benchmark_height_)) * - static_cast<double>(benchmark_iterations_) + 255.0) / 256.0); - benchmark_pixels_div1280_ = static_cast<int>(( - static_cast<double>(Abs(benchmark_width_)) * - static_cast<double>(Abs(benchmark_height_)) * - static_cast<double>(benchmark_iterations_) + 1279.0) / 1280.0); + benchmark_pixels_div256_ = + static_cast<int>((static_cast<double>(Abs(benchmark_width_)) * + static_cast<double>(Abs(benchmark_height_)) * + static_cast<double>(benchmark_iterations_) + + 255.0) / + 256.0); + benchmark_pixels_div1280_ = + static_cast<int>((static_cast<double>(Abs(benchmark_width_)) * + static_cast<double>(Abs(benchmark_height_)) * + static_cast<double>(benchmark_iterations_) + + 1279.0) / + 1280.0); } -LibYUVScaleTest::LibYUVScaleTest() : - benchmark_iterations_(BENCHMARK_ITERATIONS), benchmark_width_(128), - benchmark_height_(72), disable_cpu_flags_(1), benchmark_cpu_info_(-1) { +LibYUVScaleTest::LibYUVScaleTest() + : benchmark_iterations_(BENCHMARK_ITERATIONS), + benchmark_width_(128), + benchmark_height_(72), + disable_cpu_flags_(1), + benchmark_cpu_info_(-1) { const char* repeat = getenv("LIBYUV_REPEAT"); if (repeat) { benchmark_iterations_ = atoi(repeat); // NOLINT @@ -180,19 +197,26 @@ LibYUVScaleTest::LibYUVScaleTest() : if (FLAGS_libyuv_cpu_info) { benchmark_cpu_info_ = FLAGS_libyuv_cpu_info; } - benchmark_pixels_div256_ = static_cast<int>(( - static_cast<double>(Abs(benchmark_width_)) * - static_cast<double>(Abs(benchmark_height_)) * - static_cast<double>(benchmark_iterations_) + 255.0) / 256.0); - benchmark_pixels_div1280_ = static_cast<int>(( - static_cast<double>(Abs(benchmark_width_)) * - static_cast<double>(Abs(benchmark_height_)) * - static_cast<double>(benchmark_iterations_) + 1279.0) / 1280.0); + benchmark_pixels_div256_ = + static_cast<int>((static_cast<double>(Abs(benchmark_width_)) * + static_cast<double>(Abs(benchmark_height_)) * + static_cast<double>(benchmark_iterations_) + + 255.0) / + 256.0); + benchmark_pixels_div1280_ = + static_cast<int>((static_cast<double>(Abs(benchmark_width_)) * + static_cast<double>(Abs(benchmark_height_)) * + static_cast<double>(benchmark_iterations_) + + 1279.0) / + 1280.0); } -LibYUVRotateTest::LibYUVRotateTest() : - benchmark_iterations_(BENCHMARK_ITERATIONS), benchmark_width_(128), - benchmark_height_(72), disable_cpu_flags_(1), benchmark_cpu_info_(-1) { +LibYUVRotateTest::LibYUVRotateTest() + : benchmark_iterations_(BENCHMARK_ITERATIONS), + benchmark_width_(128), + benchmark_height_(72), + disable_cpu_flags_(1), + benchmark_cpu_info_(-1) { const char* repeat = getenv("LIBYUV_REPEAT"); if (repeat) { benchmark_iterations_ = atoi(repeat); // NOLINT @@ -232,19 +256,26 @@ LibYUVRotateTest::LibYUVRotateTest() : if (FLAGS_libyuv_cpu_info) { benchmark_cpu_info_ = FLAGS_libyuv_cpu_info; } - benchmark_pixels_div256_ = static_cast<int>(( - static_cast<double>(Abs(benchmark_width_)) * - static_cast<double>(Abs(benchmark_height_)) * - static_cast<double>(benchmark_iterations_) + 255.0) / 256.0); - benchmark_pixels_div1280_ = static_cast<int>(( - static_cast<double>(Abs(benchmark_width_)) * - static_cast<double>(Abs(benchmark_height_)) * - static_cast<double>(benchmark_iterations_) + 1279.0) / 1280.0); + benchmark_pixels_div256_ = + static_cast<int>((static_cast<double>(Abs(benchmark_width_)) * + static_cast<double>(Abs(benchmark_height_)) * + static_cast<double>(benchmark_iterations_) + + 255.0) / + 256.0); + benchmark_pixels_div1280_ = + static_cast<int>((static_cast<double>(Abs(benchmark_width_)) * + static_cast<double>(Abs(benchmark_height_)) * + static_cast<double>(benchmark_iterations_) + + 1279.0) / + 1280.0); } -LibYUVPlanarTest::LibYUVPlanarTest() : - benchmark_iterations_(BENCHMARK_ITERATIONS), benchmark_width_(128), - benchmark_height_(72), disable_cpu_flags_(1), benchmark_cpu_info_(-1) { +LibYUVPlanarTest::LibYUVPlanarTest() + : benchmark_iterations_(BENCHMARK_ITERATIONS), + benchmark_width_(128), + benchmark_height_(72), + disable_cpu_flags_(1), + benchmark_cpu_info_(-1) { const char* repeat = getenv("LIBYUV_REPEAT"); if (repeat) { benchmark_iterations_ = atoi(repeat); // NOLINT @@ -284,19 +315,26 @@ LibYUVPlanarTest::LibYUVPlanarTest() : if (FLAGS_libyuv_cpu_info) { benchmark_cpu_info_ = FLAGS_libyuv_cpu_info; } - benchmark_pixels_div256_ = static_cast<int>(( - static_cast<double>(Abs(benchmark_width_)) * - static_cast<double>(Abs(benchmark_height_)) * - static_cast<double>(benchmark_iterations_) + 255.0) / 256.0); - benchmark_pixels_div1280_ = static_cast<int>(( - static_cast<double>(Abs(benchmark_width_)) * - static_cast<double>(Abs(benchmark_height_)) * - static_cast<double>(benchmark_iterations_) + 1279.0) / 1280.0); + benchmark_pixels_div256_ = + static_cast<int>((static_cast<double>(Abs(benchmark_width_)) * + static_cast<double>(Abs(benchmark_height_)) * + static_cast<double>(benchmark_iterations_) + + 255.0) / + 256.0); + benchmark_pixels_div1280_ = + static_cast<int>((static_cast<double>(Abs(benchmark_width_)) * + static_cast<double>(Abs(benchmark_height_)) * + static_cast<double>(benchmark_iterations_) + + 1279.0) / + 1280.0); } -LibYUVBaseTest::LibYUVBaseTest() : - benchmark_iterations_(BENCHMARK_ITERATIONS), benchmark_width_(128), - benchmark_height_(72), disable_cpu_flags_(1), benchmark_cpu_info_(-1) { +LibYUVBaseTest::LibYUVBaseTest() + : benchmark_iterations_(BENCHMARK_ITERATIONS), + benchmark_width_(128), + benchmark_height_(72), + disable_cpu_flags_(1), + benchmark_cpu_info_(-1) { const char* repeat = getenv("LIBYUV_REPEAT"); if (repeat) { benchmark_iterations_ = atoi(repeat); // NOLINT @@ -336,14 +374,18 @@ LibYUVBaseTest::LibYUVBaseTest() : if (FLAGS_libyuv_cpu_info) { benchmark_cpu_info_ = FLAGS_libyuv_cpu_info; } - benchmark_pixels_div256_ = static_cast<int>(( - static_cast<double>(Abs(benchmark_width_)) * - static_cast<double>(Abs(benchmark_height_)) * - static_cast<double>(benchmark_iterations_) + 255.0) / 256.0); - benchmark_pixels_div1280_ = static_cast<int>(( - static_cast<double>(Abs(benchmark_width_)) * - static_cast<double>(Abs(benchmark_height_)) * - static_cast<double>(benchmark_iterations_) + 1279.0) / 1280.0); + benchmark_pixels_div256_ = + static_cast<int>((static_cast<double>(Abs(benchmark_width_)) * + static_cast<double>(Abs(benchmark_height_)) * + static_cast<double>(benchmark_iterations_) + + 255.0) / + 256.0); + benchmark_pixels_div1280_ = + static_cast<int>((static_cast<double>(Abs(benchmark_width_)) * + static_cast<double>(Abs(benchmark_height_)) * + static_cast<double>(benchmark_iterations_) + + 1279.0) / + 1280.0); } int main(int argc, char** argv) { diff --git a/files/unit_test/unit_test.h b/files/unit_test/unit_test.h index f2c4bef0..f7d60a76 100644 --- a/files/unit_test/unit_test.h +++ b/files/unit_test/unit_test.h @@ -14,8 +14,8 @@ #ifdef WIN32 #include <windows.h> #else -#include <sys/time.h> #include <sys/resource.h> +#include <sys/time.h> #endif #include <gtest/gtest.h> @@ -54,8 +54,10 @@ static __inline int Abs(int v) { static const int kMaxWidth = 32768; static const int kMaxHeight = 32768; -static inline bool SizeValid(int src_width, int src_height, - int dst_width, int dst_height) { +static inline bool SizeValid(int src_width, + int src_height, + int dst_width, + int dst_height) { if (src_width > kMaxWidth || src_height > kMaxHeight || dst_width > kMaxWidth || dst_height > kMaxHeight) { printf("Warning - size too large to test. Skipping\n"); @@ -64,15 +66,16 @@ static inline bool SizeValid(int src_width, int src_height, return true; } -#define align_buffer_page_end(var, size) \ - uint8* var; \ - uint8* var##_mem; \ - var##_mem = reinterpret_cast<uint8*>(malloc(((size) + 4095 + 63) & ~4095)); \ - var = (uint8*)((intptr_t)(var##_mem + (((size) + 4095 + 63) & ~4095) - \ - (size)) & ~63); +#define align_buffer_page_end(var, size) \ + uint8* var; \ + uint8* var##_mem; \ + var##_mem = reinterpret_cast<uint8*>(malloc(((size) + 4095 + 63) & ~4095)); \ + var = (uint8*)((intptr_t)(var##_mem + (((size) + 4095 + 63) & ~4095) - \ + (size)) & \ + ~63); #define free_aligned_buffer_page_end(var) \ - free(var##_mem); \ + free(var##_mem); \ var = 0; #ifdef WIN32 @@ -122,78 +125,78 @@ class LibYUVColorTest : public ::testing::Test { protected: LibYUVColorTest(); - int benchmark_iterations_; // Default 1. Use 1000 for benchmarking. - int benchmark_width_; // Default 1280. Use 640 for benchmarking VGA. - int benchmark_height_; // Default 720. Use 360 for benchmarking VGA. + int benchmark_iterations_; // Default 1. Use 1000 for benchmarking. + int benchmark_width_; // Default 1280. Use 640 for benchmarking VGA. + int benchmark_height_; // Default 720. Use 360 for benchmarking VGA. int benchmark_pixels_div256_; // Total pixels to benchmark / 256. int benchmark_pixels_div1280_; // Total pixels to benchmark / 1280. - int disable_cpu_flags_; // Default 1. Use -1 for benchmarking. - int benchmark_cpu_info_; // Default -1. Use 1 to disable SIMD. + int disable_cpu_flags_; // Default 1. Use -1 for benchmarking. + int benchmark_cpu_info_; // Default -1. Use 1 to disable SIMD. }; class LibYUVConvertTest : public ::testing::Test { protected: LibYUVConvertTest(); - int benchmark_iterations_; // Default 1. Use 1000 for benchmarking. - int benchmark_width_; // Default 1280. Use 640 for benchmarking VGA. - int benchmark_height_; // Default 720. Use 360 for benchmarking VGA. + int benchmark_iterations_; // Default 1. Use 1000 for benchmarking. + int benchmark_width_; // Default 1280. Use 640 for benchmarking VGA. + int benchmark_height_; // Default 720. Use 360 for benchmarking VGA. int benchmark_pixels_div256_; // Total pixels to benchmark / 256. int benchmark_pixels_div1280_; // Total pixels to benchmark / 1280. - int disable_cpu_flags_; // Default 1. Use -1 for benchmarking. - int benchmark_cpu_info_; // Default -1. Use 1 to disable SIMD. + int disable_cpu_flags_; // Default 1. Use -1 for benchmarking. + int benchmark_cpu_info_; // Default -1. Use 1 to disable SIMD. }; class LibYUVScaleTest : public ::testing::Test { protected: LibYUVScaleTest(); - int benchmark_iterations_; // Default 1. Use 1000 for benchmarking. - int benchmark_width_; // Default 1280. Use 640 for benchmarking VGA. - int benchmark_height_; // Default 720. Use 360 for benchmarking VGA. + int benchmark_iterations_; // Default 1. Use 1000 for benchmarking. + int benchmark_width_; // Default 1280. Use 640 for benchmarking VGA. + int benchmark_height_; // Default 720. Use 360 for benchmarking VGA. int benchmark_pixels_div256_; // Total pixels to benchmark / 256. int benchmark_pixels_div1280_; // Total pixels to benchmark / 1280. - int disable_cpu_flags_; // Default 1. Use -1 for benchmarking. - int benchmark_cpu_info_; // Default -1. Use 1 to disable SIMD. + int disable_cpu_flags_; // Default 1. Use -1 for benchmarking. + int benchmark_cpu_info_; // Default -1. Use 1 to disable SIMD. }; class LibYUVRotateTest : public ::testing::Test { protected: LibYUVRotateTest(); - int benchmark_iterations_; // Default 1. Use 1000 for benchmarking. - int benchmark_width_; // Default 1280. Use 640 for benchmarking VGA. - int benchmark_height_; // Default 720. Use 360 for benchmarking VGA. + int benchmark_iterations_; // Default 1. Use 1000 for benchmarking. + int benchmark_width_; // Default 1280. Use 640 for benchmarking VGA. + int benchmark_height_; // Default 720. Use 360 for benchmarking VGA. int benchmark_pixels_div256_; // Total pixels to benchmark / 256. int benchmark_pixels_div1280_; // Total pixels to benchmark / 1280. - int disable_cpu_flags_; // Default 1. Use -1 for benchmarking. - int benchmark_cpu_info_; // Default -1. Use 1 to disable SIMD. + int disable_cpu_flags_; // Default 1. Use -1 for benchmarking. + int benchmark_cpu_info_; // Default -1. Use 1 to disable SIMD. }; class LibYUVPlanarTest : public ::testing::Test { protected: LibYUVPlanarTest(); - int benchmark_iterations_; // Default 1. Use 1000 for benchmarking. - int benchmark_width_; // Default 1280. Use 640 for benchmarking VGA. - int benchmark_height_; // Default 720. Use 360 for benchmarking VGA. + int benchmark_iterations_; // Default 1. Use 1000 for benchmarking. + int benchmark_width_; // Default 1280. Use 640 for benchmarking VGA. + int benchmark_height_; // Default 720. Use 360 for benchmarking VGA. int benchmark_pixels_div256_; // Total pixels to benchmark / 256. int benchmark_pixels_div1280_; // Total pixels to benchmark / 1280. - int disable_cpu_flags_; // Default 1. Use -1 for benchmarking. - int benchmark_cpu_info_; // Default -1. Use 1 to disable SIMD. + int disable_cpu_flags_; // Default 1. Use -1 for benchmarking. + int benchmark_cpu_info_; // Default -1. Use 1 to disable SIMD. }; class LibYUVBaseTest : public ::testing::Test { protected: LibYUVBaseTest(); - int benchmark_iterations_; // Default 1. Use 1000 for benchmarking. - int benchmark_width_; // Default 1280. Use 640 for benchmarking VGA. - int benchmark_height_; // Default 720. Use 360 for benchmarking VGA. + int benchmark_iterations_; // Default 1. Use 1000 for benchmarking. + int benchmark_width_; // Default 1280. Use 640 for benchmarking VGA. + int benchmark_height_; // Default 720. Use 360 for benchmarking VGA. int benchmark_pixels_div256_; // Total pixels to benchmark / 256. int benchmark_pixels_div1280_; // Total pixels to benchmark / 1280. - int disable_cpu_flags_; // Default 1. Use -1 for benchmarking. - int benchmark_cpu_info_; // Default -1. Use 1 to disable SIMD. + int disable_cpu_flags_; // Default 1. Use -1 for benchmarking. + int benchmark_cpu_info_; // Default -1. Use 1 to disable SIMD. }; #endif // UNIT_TEST_UNIT_TEST_H_ NOLINT diff --git a/files/unit_test/video_common_test.cc b/files/unit_test/video_common_test.cc index ac97d0f3..f16b6772 100644 --- a/files/unit_test/video_common_test.cc +++ b/files/unit_test/video_common_test.cc @@ -11,26 +11,23 @@ #include <stdlib.h> #include <string.h> -#include "libyuv/video_common.h" #include "../unit_test/unit_test.h" +#include "libyuv/video_common.h" namespace libyuv { // Tests FourCC codes in video common, which are used for ConvertToI420(). static bool TestValidChar(uint32 onecc) { - if ((onecc >= '0' && onecc <= '9') || - (onecc >= 'A' && onecc <= 'Z') || - (onecc >= 'a' && onecc <= 'z') || - (onecc == ' ') || (onecc == 0xff)) { + if ((onecc >= '0' && onecc <= '9') || (onecc >= 'A' && onecc <= 'Z') || + (onecc >= 'a' && onecc <= 'z') || (onecc == ' ') || (onecc == 0xff)) { return true; } return false; } static bool TestValidFourCC(uint32 fourcc, int bpp) { - if (!TestValidChar(fourcc & 0xff) || - !TestValidChar((fourcc >> 8) & 0xff) || + if (!TestValidChar(fourcc & 0xff) || !TestValidChar((fourcc >> 8) & 0xff) || !TestValidChar((fourcc >> 16) & 0xff) || !TestValidChar((fourcc >> 24) & 0xff)) { return false; @@ -42,23 +39,23 @@ static bool TestValidFourCC(uint32 fourcc, int bpp) { } TEST_F(LibYUVBaseTest, TestCanonicalFourCC) { - EXPECT_EQ(FOURCC_I420, CanonicalFourCC(FOURCC_IYUV)); - EXPECT_EQ(FOURCC_I420, CanonicalFourCC(FOURCC_YU12)); - EXPECT_EQ(FOURCC_I422, CanonicalFourCC(FOURCC_YU16)); - EXPECT_EQ(FOURCC_I444, CanonicalFourCC(FOURCC_YU24)); - EXPECT_EQ(FOURCC_YUY2, CanonicalFourCC(FOURCC_YUYV)); - EXPECT_EQ(FOURCC_YUY2, CanonicalFourCC(FOURCC_YUVS)); - EXPECT_EQ(FOURCC_UYVY, CanonicalFourCC(FOURCC_HDYC)); - EXPECT_EQ(FOURCC_UYVY, CanonicalFourCC(FOURCC_2VUY)); - EXPECT_EQ(FOURCC_MJPG, CanonicalFourCC(FOURCC_JPEG)); - EXPECT_EQ(FOURCC_MJPG, CanonicalFourCC(FOURCC_DMB1)); - EXPECT_EQ(FOURCC_RAW, CanonicalFourCC(FOURCC_RGB3)); - EXPECT_EQ(FOURCC_24BG, CanonicalFourCC(FOURCC_BGR3)); - EXPECT_EQ(FOURCC_BGRA, CanonicalFourCC(FOURCC_CM32)); - EXPECT_EQ(FOURCC_RAW, CanonicalFourCC(FOURCC_CM24)); - EXPECT_EQ(FOURCC_RGBO, CanonicalFourCC(FOURCC_L555)); - EXPECT_EQ(FOURCC_RGBP, CanonicalFourCC(FOURCC_L565)); - EXPECT_EQ(FOURCC_RGBO, CanonicalFourCC(FOURCC_5551)); + EXPECT_EQ(static_cast<uint32>(FOURCC_I420), CanonicalFourCC(FOURCC_IYUV)); + EXPECT_EQ(static_cast<uint32>(FOURCC_I420), CanonicalFourCC(FOURCC_YU12)); + EXPECT_EQ(static_cast<uint32>(FOURCC_I422), CanonicalFourCC(FOURCC_YU16)); + EXPECT_EQ(static_cast<uint32>(FOURCC_I444), CanonicalFourCC(FOURCC_YU24)); + EXPECT_EQ(static_cast<uint32>(FOURCC_YUY2), CanonicalFourCC(FOURCC_YUYV)); + EXPECT_EQ(static_cast<uint32>(FOURCC_YUY2), CanonicalFourCC(FOURCC_YUVS)); + EXPECT_EQ(static_cast<uint32>(FOURCC_UYVY), CanonicalFourCC(FOURCC_HDYC)); + EXPECT_EQ(static_cast<uint32>(FOURCC_UYVY), CanonicalFourCC(FOURCC_2VUY)); + EXPECT_EQ(static_cast<uint32>(FOURCC_MJPG), CanonicalFourCC(FOURCC_JPEG)); + EXPECT_EQ(static_cast<uint32>(FOURCC_MJPG), CanonicalFourCC(FOURCC_DMB1)); + EXPECT_EQ(static_cast<uint32>(FOURCC_RAW), CanonicalFourCC(FOURCC_RGB3)); + EXPECT_EQ(static_cast<uint32>(FOURCC_24BG), CanonicalFourCC(FOURCC_BGR3)); + EXPECT_EQ(static_cast<uint32>(FOURCC_BGRA), CanonicalFourCC(FOURCC_CM32)); + EXPECT_EQ(static_cast<uint32>(FOURCC_RAW), CanonicalFourCC(FOURCC_CM24)); + EXPECT_EQ(static_cast<uint32>(FOURCC_RGBO), CanonicalFourCC(FOURCC_L555)); + EXPECT_EQ(static_cast<uint32>(FOURCC_RGBP), CanonicalFourCC(FOURCC_L565)); + EXPECT_EQ(static_cast<uint32>(FOURCC_RGBO), CanonicalFourCC(FOURCC_5551)); } TEST_F(LibYUVBaseTest, TestFourCC) { @@ -66,7 +63,6 @@ TEST_F(LibYUVBaseTest, TestFourCC) { EXPECT_TRUE(TestValidFourCC(FOURCC_I420, FOURCC_BPP_I420)); EXPECT_TRUE(TestValidFourCC(FOURCC_I422, FOURCC_BPP_I422)); EXPECT_TRUE(TestValidFourCC(FOURCC_I444, FOURCC_BPP_I444)); - EXPECT_TRUE(TestValidFourCC(FOURCC_I411, FOURCC_BPP_I411)); EXPECT_TRUE(TestValidFourCC(FOURCC_I400, FOURCC_BPP_I400)); EXPECT_TRUE(TestValidFourCC(FOURCC_NV21, FOURCC_BPP_NV21)); EXPECT_TRUE(TestValidFourCC(FOURCC_NV12, FOURCC_BPP_NV12)); @@ -78,7 +74,7 @@ TEST_F(LibYUVBaseTest, TestFourCC) { EXPECT_TRUE(TestValidFourCC(FOURCC_BGRA, FOURCC_BPP_BGRA)); EXPECT_TRUE(TestValidFourCC(FOURCC_ABGR, FOURCC_BPP_ABGR)); EXPECT_TRUE(TestValidFourCC(FOURCC_24BG, FOURCC_BPP_24BG)); - EXPECT_TRUE(TestValidFourCC(FOURCC_RAW, FOURCC_BPP_RAW)); + EXPECT_TRUE(TestValidFourCC(FOURCC_RAW, FOURCC_BPP_RAW)); EXPECT_TRUE(TestValidFourCC(FOURCC_RGBA, FOURCC_BPP_RGBA)); EXPECT_TRUE(TestValidFourCC(FOURCC_RGBP, FOURCC_BPP_RGBP)); EXPECT_TRUE(TestValidFourCC(FOURCC_RGBO, FOURCC_BPP_RGBO)); @@ -101,7 +97,7 @@ TEST_F(LibYUVBaseTest, TestFourCC) { EXPECT_TRUE(TestValidFourCC(FOURCC_RGB3, FOURCC_BPP_RGB3)); EXPECT_TRUE(TestValidFourCC(FOURCC_BGR3, FOURCC_BPP_BGR3)); EXPECT_TRUE(TestValidFourCC(FOURCC_H264, FOURCC_BPP_H264)); - EXPECT_TRUE(TestValidFourCC(FOURCC_ANY, FOURCC_BPP_ANY)); + EXPECT_TRUE(TestValidFourCC(FOURCC_ANY, FOURCC_BPP_ANY)); } } // namespace libyuv |