coffee/libyuv
1
0
Fork 0
mirror of https://chromium.googlesource.com/libyuv/libyuv synced 2025-12-07 01:06:46 +08:00
Code Issues Packages Projects Releases Wiki Activity

Replace random with fastrand

Browse Source 
random / rand is slow and impacts performance testing.
Although its only called to clear a frame once, a typical profile shows
it high in the overall profile, when doing 1000 frames for a benchmark.

95.10%  libyuv_unittest  libyuv_unittest      [.] YUY2ToARGBRow_SSSE3
 2.01%  libyuv_unittest  libc-2.19.so         [.] __random_r
 1.13%  libyuv_unittest  libc-2.19.so         [.] __random

Replace random is a faster version for unittests.

set LIBYUV_WIDTH=1280
set LIBYUV_HEIGHT=720
set LIBYUV_REPEAT=999
set LIBYUV_FLAGS=-1
out\release\libyuv_unittest --gtest_filter=*YUY2ToARGB*  | findms

Was
libyuvTest.YUY2ToARGB_Opt (497 ms)

Now
libyuvTest.YUY2ToARGB_Opt (454 ms)

R=harryjin@google.com
BUG=none

Review URL: https://codereview.chromium.org/1361813002 .
This commit is contained in:
Frank Barchard 2015-09-22 15:47:36 -07:00
parent 2b92ec8d0f
commit 16f12b58cc
12 changed files with 79 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
unit_test/color_test.cc
View File

@ -66,7 +66,7 @@ TEST_F(libyuvTest, TESTNAME) { \
uint8* p = orig_y; \ uint8* p = orig_y; \
for (int y = 0; y < benchmark_height_ - HS1; y += HS) { \ for (int y = 0; y < benchmark_height_ - HS1; y += HS) { \
for (int x = 0; x < benchmark_width_ - 1; x += 2) { \ for (int x = 0; x < benchmark_width_ - 1; x += 2) { \
uint8 r = static_cast<uint8>(random()); \ uint8 r = static_cast<uint8>(fastrand()); \
p[0] = r; \ p[0] = r; \
p[1] = r; \ p[1] = r; \
p[HN] = r; \ p[HN] = r; \
@ -74,7 +74,7 @@ TEST_F(libyuvTest, TESTNAME) { \
p += 2; \ p += 2; \
} \ } \
if (benchmark_width_ & 1) { \ if (benchmark_width_ & 1) { \
uint8 r = static_cast<uint8>(random()); \ uint8 r = static_cast<uint8>(fastrand()); \
p[0] = r; \ p[0] = r; \
p[HN] = r; \ p[HN] = r; \
p += 1; \ p += 1; \

21
unit_test/compare_test.cc
View File

@ -45,8 +45,8 @@ TEST_F(libyuvTest, Djb2_Test) {
EXPECT_EQ(kExpectedFoxHash, foxhash); EXPECT_EQ(kExpectedFoxHash, foxhash);
for (int i = 0; i < kMaxTest; ++i) { for (int i = 0; i < kMaxTest; ++i) {
src_a[i] = (random() & 0xff); src_a[i] = (fastrand() & 0xff);
src_b[i] = (random() & 0xff); src_b[i] = (fastrand() & 0xff);
} }
// Compare different buffers. Expect hash is different. // Compare different buffers. Expect hash is different.
uint32 h1 = HashDjb2(src_a, kMaxTest, 5381); uint32 h1 = HashDjb2(src_a, kMaxTest, 5381);
@ -256,11 +256,9 @@ TEST_F(libyuvTest, SumSquareError) {
EXPECT_EQ(kMaxWidth * 3 * 3, err); EXPECT_EQ(kMaxWidth * 3 * 3, err);
srandom(time(NULL));
for (int i = 0; i < kMaxWidth; ++i) { for (int i = 0; i < kMaxWidth; ++i) {
src_a[i] = (random() & 0xff); src_a[i] = (fastrand() & 0xff);
src_b[i] = (random() & 0xff); src_b[i] = (fastrand() & 0xff);
} }
MaskCpuFlags(disable_cpu_flags_); MaskCpuFlags(disable_cpu_flags_);
@ -373,15 +371,13 @@ TEST_F(libyuvTest, Psnr) {
EXPECT_LT(err, 6.0); EXPECT_LT(err, 6.0);
} }
srandom(time(NULL));
memset(src_a, 0, kSrcPlaneSize); memset(src_a, 0, kSrcPlaneSize);
memset(src_b, 0, kSrcPlaneSize); memset(src_b, 0, kSrcPlaneSize);
for (int i = b; i < (kSrcHeight + b); ++i) { for (int i = b; i < (kSrcHeight + b); ++i) {
for (int j = b; j < (kSrcWidth + b); ++j) { for (int j = b; j < (kSrcWidth + b); ++j) {
src_a[(i * kSrcStride) + j] = (random() & 0xff); src_a[(i * kSrcStride) + j] = (fastrand() & 0xff);
src_b[(i * kSrcStride) + j] = (random() & 0xff); src_b[(i * kSrcStride) + j] = (fastrand() & 0xff);
} }
} }
@ -487,11 +483,10 @@ TEST_F(libyuvTest, Ssim) {
EXPECT_LT(err, 0.01); EXPECT_LT(err, 0.01);
} }
srandom(time(NULL));
for (int i = b; i < (kSrcHeight + b); ++i) { for (int i = b; i < (kSrcHeight + b); ++i) {
for (int j = b; j < (kSrcWidth + b); ++j) { for (int j = b; j < (kSrcWidth + b); ++j) {
src_a[(i * kSrcStride) + j] = (random() & 0xff); src_a[(i * kSrcStride) + j] = (fastrand() & 0xff);
src_b[(i * kSrcStride) + j] = (random() & 0xff); src_b[(i * kSrcStride) + j] = (fastrand() & 0xff);
} }
} }

85
unit_test/convert_test.cc
View File

@ -56,16 +56,15 @@ TEST_F(libyuvTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \
align_buffer_64(dst_v_opt, \ align_buffer_64(dst_v_opt, \
SUBSAMPLE(kWidth, SUBSAMP_X) * \ SUBSAMPLE(kWidth, SUBSAMP_X) * \
SUBSAMPLE(kHeight, SUBSAMP_Y)); \ SUBSAMPLE(kHeight, SUBSAMP_Y)); \
srandom(time(NULL)); \
for (int i = 0; i < kHeight; ++i) \ for (int i = 0; i < kHeight; ++i) \
for (int j = 0; j < kWidth; ++j) \ for (int j = 0; j < kWidth; ++j) \
src_y[i * kWidth + j + OFF] = (random() & 0xff); \ src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \
for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \
for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \
src_u[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ src_u[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \
(random() & 0xff); \ (fastrand() & 0xff); \
src_v[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ src_v[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \
(random() & 0xff); \ (fastrand() & 0xff); \
} \ } \
} \ } \
memset(dst_y_c, 1, kWidth * kHeight); \ memset(dst_y_c, 1, kWidth * kHeight); \
@ -193,16 +192,15 @@ TEST_F(libyuvTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \
align_buffer_64(dst_y_opt, kWidth * kHeight); \ align_buffer_64(dst_y_opt, kWidth * kHeight); \
align_buffer_64(dst_uv_opt, SUBSAMPLE(kWidth * 2, SUBSAMP_X) * \ align_buffer_64(dst_uv_opt, SUBSAMPLE(kWidth * 2, SUBSAMP_X) * \
SUBSAMPLE(kHeight, SUBSAMP_Y)); \ SUBSAMPLE(kHeight, SUBSAMP_Y)); \
srandom(time(NULL)); \
for (int i = 0; i < kHeight; ++i) \ for (int i = 0; i < kHeight; ++i) \
for (int j = 0; j < kWidth; ++j) \ for (int j = 0; j < kWidth; ++j) \
src_y[i * kWidth + j + OFF] = (random() & 0xff); \ src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \
for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \
for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \
src_u[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ src_u[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \
(random() & 0xff); \ (fastrand() & 0xff); \
src_v[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ src_v[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \
(random() & 0xff); \ (fastrand() & 0xff); \
} \ } \
} \ } \
memset(dst_y_c, 1, kWidth * kHeight); \ memset(dst_y_c, 1, kWidth * kHeight); \
@ -306,14 +304,13 @@ TEST_F(libyuvTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \
align_buffer_64(dst_v_opt, \ align_buffer_64(dst_v_opt, \
SUBSAMPLE(kWidth, SUBSAMP_X) * \ SUBSAMPLE(kWidth, SUBSAMP_X) * \
SUBSAMPLE(kHeight, SUBSAMP_Y)); \ SUBSAMPLE(kHeight, SUBSAMP_Y)); \
srandom(time(NULL)); \
for (int i = 0; i < kHeight; ++i) \ for (int i = 0; i < kHeight; ++i) \
for (int j = 0; j < kWidth; ++j) \ for (int j = 0; j < kWidth; ++j) \
src_y[i * kWidth + j + OFF] = (random() & 0xff); \ src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \
for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \
for (int j = 0; j < 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ for (int j = 0; j < 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \
src_uv[(i * 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ src_uv[(i * 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \
(random() & 0xff); \ (fastrand() & 0xff); \
} \ } \
} \ } \
memset(dst_y_c, 1, kWidth * kHeight); \ memset(dst_y_c, 1, kWidth * kHeight); \
@ -425,13 +422,12 @@ TEST_F(libyuvTest, FMT_PLANAR##To##FMT_B##N) { \
align_buffer_64(src_v, kSizeUV + OFF); \ align_buffer_64(src_v, kSizeUV + OFF); \
align_buffer_64(dst_argb_c, kStrideB * kHeight + OFF); \ align_buffer_64(dst_argb_c, kStrideB * kHeight + OFF); \
align_buffer_64(dst_argb_opt, kStrideB * kHeight + OFF); \ align_buffer_64(dst_argb_opt, kStrideB * kHeight + OFF); \
srandom(time(NULL)); \
for (int i = 0; i < kWidth * kHeight; ++i) { \ for (int i = 0; i < kWidth * kHeight; ++i) { \
src_y[i + OFF] = (random() & 0xff); \ src_y[i + OFF] = (fastrand() & 0xff); \
} \ } \
for (int i = 0; i < kSizeUV; ++i) { \ for (int i = 0; i < kSizeUV; ++i) { \
src_u[i + OFF] = (random() & 0xff); \ src_u[i + OFF] = (fastrand() & 0xff); \
src_v[i + OFF] = (random() & 0xff); \ src_v[i + OFF] = (fastrand() & 0xff); \
} \ } \
memset(dst_argb_c + OFF, 1, kStrideB * kHeight); \ memset(dst_argb_c + OFF, 1, kStrideB * kHeight); \
memset(dst_argb_opt + OFF, 101, kStrideB * kHeight); \ memset(dst_argb_opt + OFF, 101, kStrideB * kHeight); \
@ -535,14 +531,13 @@ TEST_F(libyuvTest, FMT_PLANAR##To##FMT_B##N) { \
align_buffer_64(src_a, kWidth * kHeight + OFF); \ align_buffer_64(src_a, kWidth * kHeight + OFF); \
align_buffer_64(dst_argb_c, kStrideB * kHeight + OFF); \ align_buffer_64(dst_argb_c, kStrideB * kHeight + OFF); \
align_buffer_64(dst_argb_opt, kStrideB * kHeight + OFF); \ align_buffer_64(dst_argb_opt, kStrideB * kHeight + OFF); \
srandom(time(NULL)); \
for (int i = 0; i < kWidth * kHeight; ++i) { \ for (int i = 0; i < kWidth * kHeight; ++i) { \
src_y[i + OFF] = (random() & 0xff); \ src_y[i + OFF] = (fastrand() & 0xff); \
src_a[i + OFF] = (random() & 0xff); \ src_a[i + OFF] = (fastrand() & 0xff); \
} \ } \
for (int i = 0; i < kSizeUV; ++i) { \ for (int i = 0; i < kSizeUV; ++i) { \
src_u[i + OFF] = (random() & 0xff); \ src_u[i + OFF] = (fastrand() & 0xff); \
src_v[i + OFF] = (random() & 0xff); \ src_v[i + OFF] = (fastrand() & 0xff); \
} \ } \
memset(dst_argb_c + OFF, 1, kStrideB * kHeight); \ memset(dst_argb_c + OFF, 1, kStrideB * kHeight); \
memset(dst_argb_opt + OFF, 101, kStrideB * kHeight); \ memset(dst_argb_opt + OFF, 101, kStrideB * kHeight); \
@ -606,14 +601,13 @@ TEST_F(libyuvTest, FMT_PLANAR##To##FMT_B##N) { \
SUBSAMPLE(kHeight, SUBSAMP_Y) * 2 + OFF); \ SUBSAMPLE(kHeight, SUBSAMP_Y) * 2 + OFF); \
align_buffer_64(dst_argb_c, kStrideB * kHeight); \ align_buffer_64(dst_argb_c, kStrideB * kHeight); \
align_buffer_64(dst_argb_opt, kStrideB * kHeight); \ align_buffer_64(dst_argb_opt, kStrideB * kHeight); \
srandom(time(NULL)); \
for (int i = 0; i < kHeight; ++i) \ for (int i = 0; i < kHeight; ++i) \
for (int j = 0; j < kWidth; ++j) \ for (int j = 0; j < kWidth; ++j) \
src_y[i * kWidth + j + OFF] = (random() & 0xff); \ src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \
for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \
for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X) * 2; ++j) { \ for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X) * 2; ++j) { \
src_uv[i * SUBSAMPLE(kWidth, SUBSAMP_X) * 2 + j + OFF] = \ src_uv[i * SUBSAMPLE(kWidth, SUBSAMP_X) * 2 + j + OFF] = \
(random() & 0xff); \ (fastrand() & 0xff); \
} \ } \
} \ } \
memset(dst_argb_c, 1, kStrideB * kHeight); \ memset(dst_argb_c, 1, kStrideB * kHeight); \
@ -708,10 +702,9 @@ TEST_F(libyuvTest, FMT_A##To##FMT_PLANAR##N) { \
SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \
memset(dst_v_opt, 103, \ memset(dst_v_opt, 103, \
SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \
srandom(time(NULL)); \
for (int i = 0; i < kHeight; ++i) \ for (int i = 0; i < kHeight; ++i) \
for (int j = 0; j < kStride; ++j) \ for (int j = 0; j < kStride; ++j) \
src_argb[(i * kStride) + j + OFF] = (random() & 0xff); \ src_argb[(i * kStride) + j + OFF] = (fastrand() & 0xff); \
MaskCpuFlags(disable_cpu_flags_); \ MaskCpuFlags(disable_cpu_flags_); \
FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, \ FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, \
dst_y_c, kWidth, \ dst_y_c, kWidth, \
@ -810,10 +803,9 @@ TEST_F(libyuvTest, FMT_A##To##FMT_PLANAR##N) { \
align_buffer_64(dst_uv_opt, \ align_buffer_64(dst_uv_opt, \
SUBSAMPLE(kWidth, SUBSAMP_X) * 2 * \ SUBSAMPLE(kWidth, SUBSAMP_X) * 2 * \
SUBSAMPLE(kHeight, SUBSAMP_Y)); \ SUBSAMPLE(kHeight, SUBSAMP_Y)); \
srandom(time(NULL)); \
for (int i = 0; i < kHeight; ++i) \ for (int i = 0; i < kHeight; ++i) \
for (int j = 0; j < kStride; ++j) \ for (int j = 0; j < kStride; ++j) \
src_argb[(i * kStride) + j + OFF] = (random() & 0xff); \ src_argb[(i * kStride) + j + OFF] = (fastrand() & 0xff); \
memset(dst_y_c, 1, kWidth * kHeight); \ memset(dst_y_c, 1, kWidth * kHeight); \
memset(dst_uv_c, 2, SUBSAMPLE(kWidth, SUBSAMP_X) * 2 * \ memset(dst_uv_c, 2, SUBSAMPLE(kWidth, SUBSAMP_X) * 2 * \
SUBSAMPLE(kHeight, SUBSAMP_Y)); \ SUBSAMPLE(kHeight, SUBSAMP_Y)); \
@ -892,9 +884,8 @@ TEST_F(libyuvTest, FMT_A##To##FMT_B##N) { \
align_buffer_64(src_argb, kStrideA * kHeightA + OFF); \ align_buffer_64(src_argb, kStrideA * kHeightA + OFF); \
align_buffer_64(dst_argb_c, kStrideB * kHeightB); \ align_buffer_64(dst_argb_c, kStrideB * kHeightB); \
align_buffer_64(dst_argb_opt, kStrideB * kHeightB); \ align_buffer_64(dst_argb_opt, kStrideB * kHeightB); \
srandom(time(NULL)); \
for (int i = 0; i < kStrideA * kHeightA; ++i) { \ for (int i = 0; i < kStrideA * kHeightA; ++i) { \
src_argb[i + OFF] = (random() & 0xff); \ src_argb[i + OFF] = (fastrand() & 0xff); \
} \ } \
memset(dst_argb_c, 1, kStrideB * kHeightB); \ memset(dst_argb_c, 1, kStrideB * kHeightB); \
memset(dst_argb_opt, 101, kStrideB * kHeightB); \ memset(dst_argb_opt, 101, kStrideB * kHeightB); \
@ -926,10 +917,9 @@ TEST_F(libyuvTest, FMT_A##To##FMT_B##N) { \
#define TESTATOBRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ #define TESTATOBRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \
FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF) \ FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF) \
TEST_F(libyuvTest, FMT_A##To##FMT_B##_Random) { \ TEST_F(libyuvTest, FMT_A##To##FMT_B##_Random) { \
srandom(time(NULL)); \
for (int times = 0; times < benchmark_iterations_; ++times) { \ for (int times = 0; times < benchmark_iterations_; ++times) { \
const int kWidth = (random() & 63) + 1; \ const int kWidth = (fastrand() & 63) + 1; \
const int kHeight = (random() & 31) + 1; \ const int kHeight = (fastrand() & 31) + 1; \
const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \ const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \
const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B; \ 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 kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A;\
@ -938,7 +928,7 @@ TEST_F(libyuvTest, FMT_A##To##FMT_B##_Random) { \
align_buffer_page_end(dst_argb_c, kStrideB * kHeightB); \ align_buffer_page_end(dst_argb_c, kStrideB * kHeightB); \
align_buffer_page_end(dst_argb_opt, kStrideB * kHeightB); \ align_buffer_page_end(dst_argb_opt, kStrideB * kHeightB); \
for (int i = 0; i < kStrideA * kHeightA; ++i) { \ for (int i = 0; i < kStrideA * kHeightA; ++i) { \
src_argb[i] = (random() & 0xff); \ src_argb[i] = (fastrand() & 0xff); \
} \ } \
memset(dst_argb_c, 123, kStrideB * kHeightB); \ memset(dst_argb_c, 123, kStrideB * kHeightB); \
memset(dst_argb_opt, 123, kStrideB * kHeightB); \ memset(dst_argb_opt, 123, kStrideB * kHeightB); \
@ -1026,9 +1016,8 @@ TEST_F(libyuvTest, FMT_A##To##FMT_B##Dither##N) { \
align_buffer_64(src_argb, kStrideA * kHeightA + OFF); \ align_buffer_64(src_argb, kStrideA * kHeightA + OFF); \
align_buffer_64(dst_argb_c, kStrideB * kHeightB); \ align_buffer_64(dst_argb_c, kStrideB * kHeightB); \
align_buffer_64(dst_argb_opt, kStrideB * kHeightB); \ align_buffer_64(dst_argb_opt, kStrideB * kHeightB); \
srandom(time(NULL)); \
for (int i = 0; i < kStrideA * kHeightA; ++i) { \ for (int i = 0; i < kStrideA * kHeightA; ++i) { \
src_argb[i + OFF] = (random() & 0xff); \ src_argb[i + OFF] = (fastrand() & 0xff); \
} \ } \
memset(dst_argb_c, 1, kStrideB * kHeightB); \ memset(dst_argb_c, 1, kStrideB * kHeightB); \
memset(dst_argb_opt, 101, kStrideB * kHeightB); \ memset(dst_argb_opt, 101, kStrideB * kHeightB); \
@ -1060,10 +1049,9 @@ TEST_F(libyuvTest, FMT_A##To##FMT_B##Dither##N) { \
#define TESTATOBDRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ #define TESTATOBDRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \
FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF) \ FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF) \
TEST_F(libyuvTest, FMT_A##To##FMT_B##Dither_Random) { \ TEST_F(libyuvTest, FMT_A##To##FMT_B##Dither_Random) { \
srandom(time(NULL)); \
for (int times = 0; times < benchmark_iterations_; ++times) { \ for (int times = 0; times < benchmark_iterations_; ++times) { \
const int kWidth = (random() & 63) + 1; \ const int kWidth = (fastrand() & 63) + 1; \
const int kHeight = (random() & 31) + 1; \ const int kHeight = (fastrand() & 31) + 1; \
const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \ const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \
const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B; \ 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 kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A;\
@ -1072,7 +1060,7 @@ TEST_F(libyuvTest, FMT_A##To##FMT_B##Dither_Random) { \
align_buffer_page_end(dst_argb_c, kStrideB * kHeightB); \ align_buffer_page_end(dst_argb_c, kStrideB * kHeightB); \
align_buffer_page_end(dst_argb_opt, kStrideB * kHeightB); \ align_buffer_page_end(dst_argb_opt, kStrideB * kHeightB); \
for (int i = 0; i < kStrideA * kHeightA; ++i) { \ for (int i = 0; i < kStrideA * kHeightA; ++i) { \
src_argb[i] = (random() & 0xff); \ src_argb[i] = (fastrand() & 0xff); \
} \ } \
memset(dst_argb_c, 123, kStrideB * kHeightB); \ memset(dst_argb_c, 123, kStrideB * kHeightB); \
memset(dst_argb_opt, 123, kStrideB * kHeightB); \ memset(dst_argb_opt, 123, kStrideB * kHeightB); \
@ -1129,9 +1117,8 @@ TEST_F(libyuvTest, FMT_ATOB##_Symetric##N) { \
align_buffer_64(src_argb, kStrideA * kHeightA + OFF); \ align_buffer_64(src_argb, kStrideA * kHeightA + OFF); \
align_buffer_64(dst_argb_c, kStrideA * kHeightA); \ align_buffer_64(dst_argb_c, kStrideA * kHeightA); \
align_buffer_64(dst_argb_opt, kStrideA * kHeightA); \ align_buffer_64(dst_argb_opt, kStrideA * kHeightA); \
srandom(time(NULL)); \
for (int i = 0; i < kStrideA * kHeightA; ++i) { \ for (int i = 0; i < kStrideA * kHeightA; ++i) { \
src_argb[i + OFF] = (random() & 0xff); \ src_argb[i + OFF] = (fastrand() & 0xff); \
} \ } \
memset(dst_argb_c, 1, kStrideA * kHeightA); \ memset(dst_argb_c, 1, kStrideA * kHeightA); \
memset(dst_argb_opt, 101, kStrideA * kHeightA); \ memset(dst_argb_opt, 101, kStrideA * kHeightA); \
@ -1282,10 +1269,9 @@ TEST_F(libyuvTest, InvalidateJpeg) {
} }
TEST_F(libyuvTest, FuzzJpeg) { TEST_F(libyuvTest, FuzzJpeg) {
srandom(time(NULL));
// SOI but no EOI. Expect fail. // SOI but no EOI. Expect fail.
for (int times = 0; times < benchmark_iterations_; ++times) { for (int times = 0; times < benchmark_iterations_; ++times) {
const int kSize = random() % 5000 + 2; const int kSize = fastrand() % 5000 + 2;
align_buffer_page_end(orig_pixels, kSize); align_buffer_page_end(orig_pixels, kSize);
MemRandomize(orig_pixels, kSize); MemRandomize(orig_pixels, kSize);
@ -1399,13 +1385,12 @@ TEST_F(libyuvTest, CropNV12) {
SUBSAMPLE(kDestWidth, SUBSAMP_X) * SUBSAMPLE(kDestWidth, SUBSAMP_X) *
SUBSAMPLE(kDestHeight, SUBSAMP_Y)); SUBSAMPLE(kDestHeight, SUBSAMP_Y));
srandom(time(NULL));
for (int i = 0; i < kHeight * kWidth; ++i) { for (int i = 0; i < kHeight * kWidth; ++i) {
src_y[i] = (random() & 0xff); src_y[i] = (fastrand() & 0xff);
} }
for (int i = 0; i < (SUBSAMPLE(kHeight, SUBSAMP_Y) * for (int i = 0; i < (SUBSAMPLE(kHeight, SUBSAMP_Y) *
SUBSAMPLE(kWidth, SUBSAMP_X)) * 2; ++i) { SUBSAMPLE(kWidth, SUBSAMP_X)) * 2; ++i) {
src_uv[i] = (random() & 0xff); src_uv[i] = (fastrand() & 0xff);
} }
memset(dst_y, 1, kDestWidth * kDestHeight); memset(dst_y, 1, kDestWidth * kDestHeight);
memset(dst_u, 2, SUBSAMPLE(kDestWidth, SUBSAMP_X) * memset(dst_u, 2, SUBSAMPLE(kDestWidth, SUBSAMP_X) *
@ -1575,13 +1560,12 @@ TEST_F(libyuvTest, FMT_PLANAR##To##FMT_B##Dither##N) { \
align_buffer_64(src_v, kSizeUV + OFF); \ align_buffer_64(src_v, kSizeUV + OFF); \
align_buffer_64(dst_argb_c, kStrideB * kHeight + OFF); \ align_buffer_64(dst_argb_c, kStrideB * kHeight + OFF); \
align_buffer_64(dst_argb_opt, kStrideB * kHeight + OFF); \ align_buffer_64(dst_argb_opt, kStrideB * kHeight + OFF); \
srandom(time(NULL)); \
for (int i = 0; i < kWidth * kHeight; ++i) { \ for (int i = 0; i < kWidth * kHeight; ++i) { \
src_y[i + OFF] = (random() & 0xff); \ src_y[i + OFF] = (fastrand() & 0xff); \
} \ } \
for (int i = 0; i < kSizeUV; ++i) { \ for (int i = 0; i < kSizeUV; ++i) { \
src_u[i + OFF] = (random() & 0xff); \ src_u[i + OFF] = (fastrand() & 0xff); \
src_v[i + OFF] = (random() & 0xff); \ src_v[i + OFF] = (fastrand() & 0xff); \
} \ } \
memset(dst_argb_c + OFF, 1, kStrideB * kHeight); \ memset(dst_argb_c + OFF, 1, kStrideB * kHeight); \
memset(dst_argb_opt + OFF, 101, kStrideB * kHeight); \ memset(dst_argb_opt + OFF, 101, kStrideB * kHeight); \
@ -1667,7 +1651,6 @@ TEST_F(libyuvTest, NAME) { \
SUBSAMPLE(kWidth, 2) * \ SUBSAMPLE(kWidth, 2) * \
SUBSAMPLE(kHeight, 2)); \ SUBSAMPLE(kHeight, 2)); \
\ \
srandom(time(NULL)); \
MemRandomize(orig_uyvy, 4 * SUBSAMPLE(kWidth, 2) * kHeight); \ MemRandomize(orig_uyvy, 4 * SUBSAMPLE(kWidth, 2) * kHeight); \
\ \
/* Convert UYVY to NV12 in 2 steps for reference */ \ /* Convert UYVY to NV12 in 2 steps for reference */ \

3
unit_test/math_test.cc
View File

@ -66,7 +66,6 @@ TEST_F(libyuvTest, TestFixedDiv) {
} }
EXPECT_EQ(123 * 65536, libyuv::FixedDiv(123, 1)); EXPECT_EQ(123 * 65536, libyuv::FixedDiv(123, 1));
srandom(time(NULL));
MemRandomize(reinterpret_cast<uint8*>(&num[0]), sizeof(num)); MemRandomize(reinterpret_cast<uint8*>(&num[0]), sizeof(num));
MemRandomize(reinterpret_cast<uint8*>(&div[0]), sizeof(div)); MemRandomize(reinterpret_cast<uint8*>(&div[0]), sizeof(div));
for (int j = 0; j < 1280; ++j) { for (int j = 0; j < 1280; ++j) {
@ -92,7 +91,6 @@ TEST_F(libyuvTest, TestFixedDiv_Opt) {
int result_opt[1280]; int result_opt[1280];
int result_c[1280]; int result_c[1280];
srandom(time(NULL));
MemRandomize(reinterpret_cast<uint8*>(&num[0]), sizeof(num)); MemRandomize(reinterpret_cast<uint8*>(&num[0]), sizeof(num));
MemRandomize(reinterpret_cast<uint8*>(&div[0]), sizeof(div)); MemRandomize(reinterpret_cast<uint8*>(&div[0]), sizeof(div));
for (int j = 0; j < 1280; ++j) { for (int j = 0; j < 1280; ++j) {
@ -127,7 +125,6 @@ TEST_F(libyuvTest, TestFixedDiv1_Opt) {
int result_opt[1280]; int result_opt[1280];
int result_c[1280]; int result_c[1280];
srandom(time(NULL));
MemRandomize(reinterpret_cast<uint8*>(&num[0]), sizeof(num)); MemRandomize(reinterpret_cast<uint8*>(&num[0]), sizeof(num));
MemRandomize(reinterpret_cast<uint8*>(&div[0]), sizeof(div)); MemRandomize(reinterpret_cast<uint8*>(&div[0]), sizeof(div));
for (int j = 0; j < 1280; ++j) { for (int j = 0; j < 1280; ++j) {

50
unit_test/planar_test.cc
View File

@ -114,9 +114,8 @@ static int TestAttenuateI(int width, int height, int benchmark_iterations,
align_buffer_64(src_argb, kStride * height + off); align_buffer_64(src_argb, kStride * height + off);
align_buffer_64(dst_argb_c, kStride * height); align_buffer_64(dst_argb_c, kStride * height);
align_buffer_64(dst_argb_opt, kStride * height); align_buffer_64(dst_argb_opt, kStride * height);
srandom(time(NULL));
for (int i = 0; i < kStride * height; ++i) { for (int i = 0; i < kStride * height; ++i) {
src_argb[i + off] = (random() & 0xff); src_argb[i + off] = (fastrand() & 0xff);
} }
memset(dst_argb_c, 0, kStride * height); memset(dst_argb_c, 0, kStride * height);
memset(dst_argb_opt, 0, kStride * height); memset(dst_argb_opt, 0, kStride * height);
@ -180,9 +179,8 @@ static int TestUnattenuateI(int width, int height, int benchmark_iterations,
align_buffer_64(src_argb, kStride * height + off); align_buffer_64(src_argb, kStride * height + off);
align_buffer_64(dst_argb_c, kStride * height); align_buffer_64(dst_argb_c, kStride * height);
align_buffer_64(dst_argb_opt, kStride * height); align_buffer_64(dst_argb_opt, kStride * height);
srandom(time(NULL));
for (int i = 0; i < kStride * height; ++i) { for (int i = 0; i < kStride * height; ++i) {
src_argb[i + off] = (random() & 0xff); src_argb[i + off] = (fastrand() & 0xff);
} }
ARGBAttenuate(src_argb + off, kStride, ARGBAttenuate(src_argb + off, kStride,
src_argb + off, kStride, src_argb + off, kStride,
@ -936,10 +934,9 @@ TEST_F(libyuvTest, ARGBInterpolate##TERP##N) { \
align_buffer_64(src_argb_b, kStrideA * kHeight + OFF); \ align_buffer_64(src_argb_b, kStrideA * kHeight + OFF); \
align_buffer_64(dst_argb_c, kStrideB * kHeight); \ align_buffer_64(dst_argb_c, kStrideB * kHeight); \
align_buffer_64(dst_argb_opt, kStrideB * kHeight); \ align_buffer_64(dst_argb_opt, kStrideB * kHeight); \
srandom(time(NULL)); \
for (int i = 0; i < kStrideA * kHeight; ++i) { \ for (int i = 0; i < kStrideA * kHeight; ++i) { \
src_argb_a[i + OFF] = (random() & 0xff); \ src_argb_a[i + OFF] = (fastrand() & 0xff); \
src_argb_b[i + OFF] = (random() & 0xff); \ src_argb_b[i + OFF] = (fastrand() & 0xff); \
} \ } \
MaskCpuFlags(disable_cpu_flags_); \ MaskCpuFlags(disable_cpu_flags_); \
ARGBInterpolate(src_argb_a + OFF, kStrideA, \ ARGBInterpolate(src_argb_a + OFF, kStrideA, \
@ -998,10 +995,9 @@ static int TestBlend(int width, int height, int benchmark_iterations,
align_buffer_64(src_argb_b, kStride * height + off); align_buffer_64(src_argb_b, kStride * height + off);
align_buffer_64(dst_argb_c, kStride * height); align_buffer_64(dst_argb_c, kStride * height);
align_buffer_64(dst_argb_opt, kStride * height); align_buffer_64(dst_argb_opt, kStride * height);
srandom(time(NULL));
for (int i = 0; i < kStride * height; ++i) { for (int i = 0; i < kStride * height; ++i) {
src_argb_a[i + off] = (random() & 0xff); src_argb_a[i + off] = (fastrand() & 0xff);
src_argb_b[i + off] = (random() & 0xff); src_argb_b[i + off] = (fastrand() & 0xff);
} }
ARGBAttenuate(src_argb_a + off, kStride, src_argb_a + off, kStride, width, ARGBAttenuate(src_argb_a + off, kStride, src_argb_a + off, kStride, width,
height); height);
@ -1304,7 +1300,6 @@ TEST_F(libyuvTest, TestCopyPlane) {
int i, j; int i, j;
int y_plane_size = (yw + b * 2) * (yh + b * 2); int y_plane_size = (yw + b * 2) * (yh + b * 2);
srandom(time(NULL));
align_buffer_64(orig_y, y_plane_size); align_buffer_64(orig_y, y_plane_size);
align_buffer_64(dst_c, y_plane_size); align_buffer_64(dst_c, y_plane_size);
align_buffer_64(dst_opt, y_plane_size); align_buffer_64(dst_opt, y_plane_size);
@ -1316,13 +1311,13 @@ TEST_F(libyuvTest, TestCopyPlane) {
// Fill image buffers with random data. // Fill image buffers with random data.
for (i = b; i < (yh + b); ++i) { for (i = b; i < (yh + b); ++i) {
for (j = b; j < (yw + b); ++j) { for (j = b; j < (yw + b); ++j) {
orig_y[i * (yw + b * 2) + j] = random() & 0xff; orig_y[i * (yw + b * 2) + j] = fastrand() & 0xff;
} }
} }
// Fill destination buffers with random data. // Fill destination buffers with random data.
for (i = 0; i < y_plane_size; ++i) { for (i = 0; i < y_plane_size; ++i) {
uint8 random_number = random() & 0x7f; uint8 random_number = fastrand() & 0x7f;
dst_c[i] = random_number; dst_c[i] = random_number;
dst_opt[i] = dst_c[i]; dst_opt[i] = dst_c[i];
} }
@ -1371,10 +1366,9 @@ static int TestMultiply(int width, int height, int benchmark_iterations,
align_buffer_64(src_argb_b, kStride * height + off); align_buffer_64(src_argb_b, kStride * height + off);
align_buffer_64(dst_argb_c, kStride * height); align_buffer_64(dst_argb_c, kStride * height);
align_buffer_64(dst_argb_opt, kStride * height); align_buffer_64(dst_argb_opt, kStride * height);
srandom(time(NULL));
for (int i = 0; i < kStride * height; ++i) { for (int i = 0; i < kStride * height; ++i) {
src_argb_a[i + off] = (random() & 0xff); src_argb_a[i + off] = (fastrand() & 0xff);
src_argb_b[i + off] = (random() & 0xff); src_argb_b[i + off] = (fastrand() & 0xff);
} }
memset(dst_argb_c, 0, kStride * height); memset(dst_argb_c, 0, kStride * height);
memset(dst_argb_opt, 0, kStride * height); memset(dst_argb_opt, 0, kStride * height);
@ -1442,10 +1436,9 @@ static int TestAdd(int width, int height, int benchmark_iterations,
align_buffer_64(src_argb_b, kStride * height + off); align_buffer_64(src_argb_b, kStride * height + off);
align_buffer_64(dst_argb_c, kStride * height); align_buffer_64(dst_argb_c, kStride * height);
align_buffer_64(dst_argb_opt, kStride * height); align_buffer_64(dst_argb_opt, kStride * height);
srandom(time(NULL));
for (int i = 0; i < kStride * height; ++i) { for (int i = 0; i < kStride * height; ++i) {
src_argb_a[i + off] = (random() & 0xff); src_argb_a[i + off] = (fastrand() & 0xff);
src_argb_b[i + off] = (random() & 0xff); src_argb_b[i + off] = (fastrand() & 0xff);
} }
memset(dst_argb_c, 0, kStride * height); memset(dst_argb_c, 0, kStride * height);
memset(dst_argb_opt, 0, kStride * height); memset(dst_argb_opt, 0, kStride * height);
@ -1513,10 +1506,9 @@ static int TestSubtract(int width, int height, int benchmark_iterations,
align_buffer_64(src_argb_b, kStride * height + off); align_buffer_64(src_argb_b, kStride * height + off);
align_buffer_64(dst_argb_c, kStride * height); align_buffer_64(dst_argb_c, kStride * height);
align_buffer_64(dst_argb_opt, kStride * height); align_buffer_64(dst_argb_opt, kStride * height);
srandom(time(NULL));
for (int i = 0; i < kStride * height; ++i) { for (int i = 0; i < kStride * height; ++i) {
src_argb_a[i + off] = (random() & 0xff); src_argb_a[i + off] = (fastrand() & 0xff);
src_argb_b[i + off] = (random() & 0xff); src_argb_b[i + off] = (fastrand() & 0xff);
} }
memset(dst_argb_c, 0, kStride * height); memset(dst_argb_c, 0, kStride * height);
memset(dst_argb_opt, 0, kStride * height); memset(dst_argb_opt, 0, kStride * height);
@ -1584,9 +1576,8 @@ static int TestSobel(int width, int height, int benchmark_iterations,
align_buffer_64(dst_argb_c, kStride * height); align_buffer_64(dst_argb_c, kStride * height);
align_buffer_64(dst_argb_opt, kStride * height); align_buffer_64(dst_argb_opt, kStride * height);
memset(src_argb_a, 0, kStride * height + off); memset(src_argb_a, 0, kStride * height + off);
srandom(time(NULL));
for (int i = 0; i < kStride * height; ++i) { for (int i = 0; i < kStride * height; ++i) {
src_argb_a[i + off] = (random() & 0xff); src_argb_a[i + off] = (fastrand() & 0xff);
} }
memset(dst_argb_c, 0, kStride * height); memset(dst_argb_c, 0, kStride * height);
memset(dst_argb_opt, 0, kStride * height); memset(dst_argb_opt, 0, kStride * height);
@ -1653,9 +1644,8 @@ static int TestSobelToPlane(int width, int height, int benchmark_iterations,
align_buffer_64(dst_argb_c, kDstStride * height); align_buffer_64(dst_argb_c, kDstStride * height);
align_buffer_64(dst_argb_opt, kDstStride * height); align_buffer_64(dst_argb_opt, kDstStride * height);
memset(src_argb_a, 0, kSrcStride * height + off); memset(src_argb_a, 0, kSrcStride * height + off);
srandom(time(NULL));
for (int i = 0; i < kSrcStride * height; ++i) { for (int i = 0; i < kSrcStride * height; ++i) {
src_argb_a[i + off] = (random() & 0xff); src_argb_a[i + off] = (fastrand() & 0xff);
} }
memset(dst_argb_c, 0, kDstStride * height); memset(dst_argb_c, 0, kDstStride * height);
memset(dst_argb_opt, 0, kDstStride * height); memset(dst_argb_opt, 0, kDstStride * height);
@ -1720,9 +1710,8 @@ static int TestSobelXY(int width, int height, int benchmark_iterations,
align_buffer_64(dst_argb_c, kStride * height); align_buffer_64(dst_argb_c, kStride * height);
align_buffer_64(dst_argb_opt, kStride * height); align_buffer_64(dst_argb_opt, kStride * height);
memset(src_argb_a, 0, kStride * height + off); memset(src_argb_a, 0, kStride * height + off);
srandom(time(NULL));
for (int i = 0; i < kStride * height; ++i) { for (int i = 0; i < kStride * height; ++i) {
src_argb_a[i + off] = (random() & 0xff); src_argb_a[i + off] = (fastrand() & 0xff);
} }
memset(dst_argb_c, 0, kStride * height); memset(dst_argb_c, 0, kStride * height);
memset(dst_argb_opt, 0, kStride * height); memset(dst_argb_opt, 0, kStride * height);
@ -1787,9 +1776,8 @@ static int TestBlur(int width, int height, int benchmark_iterations,
align_buffer_64(dst_cumsum, width * height * 16); align_buffer_64(dst_cumsum, width * height * 16);
align_buffer_64(dst_argb_c, kStride * height); align_buffer_64(dst_argb_c, kStride * height);
align_buffer_64(dst_argb_opt, kStride * height); align_buffer_64(dst_argb_opt, kStride * height);
srandom(time(NULL));
for (int i = 0; i < kStride * height; ++i) { for (int i = 0; i < kStride * height; ++i) {
src_argb_a[i + off] = (random() & 0xff); src_argb_a[i + off] = (fastrand() & 0xff);
} }
memset(dst_cumsum, 0, width * height * 16); memset(dst_cumsum, 0, width * height * 16);
memset(dst_argb_c, 0, kStride * height); memset(dst_argb_c, 0, kStride * height);
@ -2105,7 +2093,7 @@ static int TestARGBRect(int width, int height, int benchmark_iterations,
} }
const int kStride = width * bpp; const int kStride = width * bpp;
const int kSize = kStride * height; const int kSize = kStride * height;
const uint32 v32 = random() & (bpp == 4 ? 0xffffffff : 0xff); const uint32 v32 = fastrand() & (bpp == 4 ? 0xffffffff : 0xff);
align_buffer_64(dst_argb_c, kSize + off); align_buffer_64(dst_argb_c, kSize + off);
align_buffer_64(dst_argb_opt, kSize + off); align_buffer_64(dst_argb_opt, kSize + off);

2
unit_test/rotate_argb_test.cc
View File

@ -38,7 +38,7 @@ void TestRotateBpp(int src_width, int src_height,
int src_argb_plane_size = src_stride_argb * abs(src_height); int src_argb_plane_size = src_stride_argb * abs(src_height);
align_buffer_64(src_argb, src_argb_plane_size); align_buffer_64(src_argb, src_argb_plane_size);
for (int i = 0; i < src_argb_plane_size; ++i) { for (int i = 0; i < src_argb_plane_size; ++i) {
src_argb[i] = random() & 0xff; src_argb[i] = fastrand() & 0xff;
} }
int dst_stride_argb = dst_width * kBpp; int dst_stride_argb = dst_width * kBpp;

4
unit_test/rotate_test.cc
View File

@ -38,7 +38,7 @@ static void I420TestRotate(int src_width, int src_height,
int src_i420_size = src_i420_y_size + src_i420_uv_size * 2; int src_i420_size = src_i420_y_size + src_i420_uv_size * 2;
align_buffer_64(src_i420, src_i420_size); align_buffer_64(src_i420, src_i420_size);
for (int i = 0; i < src_i420_size; ++i) { for (int i = 0; i < src_i420_size; ++i) {
src_i420[i] = random() & 0xff; src_i420[i] = fastrand() & 0xff;
} }
int dst_i420_y_size = dst_width * dst_height; int dst_i420_y_size = dst_width * dst_height;
@ -151,7 +151,7 @@ static void NV12TestRotate(int src_width, int src_height,
int src_nv12_size = src_nv12_y_size + src_nv12_uv_size; int src_nv12_size = src_nv12_y_size + src_nv12_uv_size;
align_buffer_64(src_nv12, src_nv12_size); align_buffer_64(src_nv12, src_nv12_size);
for (int i = 0; i < src_nv12_size; ++i) { for (int i = 0; i < src_nv12_size; ++i) {
src_nv12[i] = random() & 0xff; src_nv12[i] = fastrand() & 0xff;
} }
int dst_i420_y_size = dst_width * dst_height; int dst_i420_y_size = dst_width * dst_height;

5
unit_test/scale_argb_test.cc
View File

@ -37,7 +37,6 @@ static int ARGBTestFilter(int src_width, int src_height,
printf("Skipped. Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n"); printf("Skipped. Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
return 0; return 0;
} }
srandom(time(NULL));
MemRandomize(src_argb, src_argb_plane_size); MemRandomize(src_argb, src_argb_plane_size);
int64 dst_argb_plane_size = (dst_width + b * 2) * (dst_height + b * 2) * 4LL; int64 dst_argb_plane_size = (dst_width + b * 2) * (dst_height + b * 2) * 4LL;
@ -157,12 +156,10 @@ static int ARGBClipTestFilter(int src_width, int src_height,
int64 dst_argb_plane_size = (dst_width + b * 2) * (dst_height + b * 2) * 4; int64 dst_argb_plane_size = (dst_width + b * 2) * (dst_height + b * 2) * 4;
int dst_stride_argb = (b * 2 + dst_width) * 4; int dst_stride_argb = (b * 2 + dst_width) * 4;
srandom(time(NULL));
int i, j; int i, j;
for (i = b; i < (Abs(src_height) + b); ++i) { for (i = b; i < (Abs(src_height) + b); ++i) {
for (j = b; j < (Abs(src_width) + b) * 4; ++j) { for (j = b; j < (Abs(src_width) + b) * 4; ++j) {
src_argb[(i * src_stride_argb) + j] = (random() & 0xff); src_argb[(i * src_stride_argb) + j] = (fastrand() & 0xff);
} }
} }

4
unit_test/scale_color_test.cc
View File

@ -66,7 +66,7 @@ TEST_F(libyuvTest, TESTNAME) { \
uint8* p = orig_y; \ uint8* p = orig_y; \
for (int y = 0; y < benchmark_height_ - HS1; y += HS) { \ for (int y = 0; y < benchmark_height_ - HS1; y += HS) { \
for (int x = 0; x < benchmark_width_ - 1; x += 2) { \ for (int x = 0; x < benchmark_width_ - 1; x += 2) { \
uint8 r = static_cast<uint8>(random()); \ uint8 r = static_cast<uint8>(fastrand()); \
p[0] = r; \ p[0] = r; \
p[1] = r; \ p[1] = r; \
p[HN] = r; \ p[HN] = r; \
@ -74,7 +74,7 @@ TEST_F(libyuvTest, TESTNAME) { \
p += 2; \ p += 2; \
} \ } \
if (benchmark_width_ & 1) { \ if (benchmark_width_ & 1) { \
uint8 r = static_cast<uint8>(random()); \ uint8 r = static_cast<uint8>(fastrand()); \
p[0] = r; \ p[0] = r; \
p[HN] = r; \ p[HN] = r; \
p += 1; \ p += 1; \

2
unit_test/scale_test.cc
View File

@ -43,7 +43,6 @@ static int TestFilter(int src_width, int src_height,
printf("Skipped. Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n"); printf("Skipped. Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
return 0; return 0;
} }
srandom(time(NULL));
MemRandomize(src_y, src_y_plane_size); MemRandomize(src_y, src_y_plane_size);
MemRandomize(src_u, src_uv_plane_size); MemRandomize(src_u, src_uv_plane_size);
MemRandomize(src_v, src_uv_plane_size); MemRandomize(src_v, src_uv_plane_size);
@ -171,7 +170,6 @@ static int TestFilter_16(int src_width, int src_height,
uint16* p_src_u_16 = reinterpret_cast<uint16*>(src_u_16); uint16* p_src_u_16 = reinterpret_cast<uint16*>(src_u_16);
uint16* p_src_v_16 = reinterpret_cast<uint16*>(src_v_16); uint16* p_src_v_16 = reinterpret_cast<uint16*>(src_v_16);
srandom(time(NULL));
MemRandomize(src_y, src_y_plane_size); MemRandomize(src_y, src_y_plane_size);
MemRandomize(src_u, src_uv_plane_size); MemRandomize(src_u, src_uv_plane_size);
MemRandomize(src_v, src_uv_plane_size); MemRandomize(src_v, src_uv_plane_size);

2
unit_test/unit_test.cc
View File

@ -18,6 +18,8 @@
// TODO(fbarchard): Add command line parsing to pass this as option. // TODO(fbarchard): Add command line parsing to pass this as option.
#define BENCHMARK_ITERATIONS 1 #define BENCHMARK_ITERATIONS 1
int fastrand_seed = 0xfb;
libyuvTest::libyuvTest() : rotate_max_w_(128), rotate_max_h_(128), libyuvTest::libyuvTest() : rotate_max_w_(128), rotate_max_h_(128),
benchmark_iterations_(BENCHMARK_ITERATIONS), benchmark_width_(128), benchmark_iterations_(BENCHMARK_ITERATIONS), benchmark_width_(128),
benchmark_height_(72), disable_cpu_flags_(0) { benchmark_height_(72), disable_cpu_flags_(0) {

13
unit_test/unit_test.h
View File

@ -46,9 +46,6 @@ static inline double get_time() {
QueryPerformanceFrequency(&f); QueryPerformanceFrequency(&f);
return static_cast<double>(t.QuadPart) / static_cast<double>(f.QuadPart); return static_cast<double>(t.QuadPart) / static_cast<double>(f.QuadPart);
} }
#define random rand
#define srandom srand
#else #else
static inline double get_time() { static inline double get_time() {
struct timeval t; struct timeval t;
@ -58,14 +55,20 @@ static inline double get_time() {
} }
#endif #endif
extern int fastrand_seed;
inline int fastrand() {
fastrand_seed = fastrand_seed * 214013 + 2531011;
return (fastrand_seed >> 16) & 0xffff;
}
static inline void MemRandomize(uint8* dst, int64 len) { static inline void MemRandomize(uint8* dst, int64 len) {
int64 i; int64 i;
for (i = 0; i < len - 1; i += 2) { for (i = 0; i < len - 1; i += 2) {
*reinterpret_cast<uint16*>(dst) = random(); *reinterpret_cast<uint16*>(dst) = fastrand();
dst += 2; dst += 2;
} }
for (; i < len; ++i) { for (; i < len; ++i) {
*dst++ = random(); *dst++ = fastrand();
} }
} }