replace random with fastrand

unit_test/planar_test.cc

 /*
  *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS. All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 96 matching lines @@
 static int TestAttenuateI(int width, int height, int benchmark_iterations,
                           int disable_cpu_flags, int invert, int off) {
   if (width < 1) {
     width = 1;
   }
   const int kBpp = 4;
   const int kStride = width * kBpp;
   align_buffer_64(src_argb, kStride * height + off);
   align_buffer_64(dst_argb_c, kStride * height);
   align_buffer_64(dst_argb_opt, kStride * height);
-  srandom(time(NULL));
   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_opt, 0, kStride * height);
 
   MaskCpuFlags(disable_cpu_flags);
   ARGBAttenuate(src_argb + off, kStride,
                 dst_argb_c, kStride,
                 width, invert * height);
   MaskCpuFlags(-1);
   for (int i = 0; i < benchmark_iterations; ++i) {
@@ skipping 43 matching lines @@
 static int TestUnattenuateI(int width, int height, int benchmark_iterations,
                             int disable_cpu_flags, int invert, int off) {
   if (width < 1) {
     width = 1;
   }
   const int kBpp = 4;
   const int kStride = width * kBpp;
   align_buffer_64(src_argb, kStride * height + off);
   align_buffer_64(dst_argb_c, kStride * height);
   align_buffer_64(dst_argb_opt, kStride * height);
-  srandom(time(NULL));
   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,
                 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,
@@ skipping 733 matching lines @@
                  W1280, TERP, DIFF, N, NEG, OFF)                               \
 TEST_F(libyuvTest, 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_64(src_argb_a, 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_opt, kStrideB * kHeight);                           \
-  srandom(time(NULL));                                                         \
   for (int i = 0; i < kStrideA * kHeight; ++i) {                               \
-    src_argb_a[i + OFF] = (random() & 0xff);                                   \
-    src_argb_b[i + OFF] = (random() & 0xff);                                   \
+    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(-1);                                                            \
   for (int i = 0; i < benchmark_iterations_; ++i) {                            \
     ARGBInterpolate(src_argb_a + OFF, kStrideA,                                \
                     src_argb_b + OFF, kStrideA,                                \
@@ skipping 38 matching lines @@
                      int disable_cpu_flags, int invert, int off) {
   if (width < 1) {
     width = 1;
   }
   const int kBpp = 4;
   const int kStride = width * kBpp;
   align_buffer_64(src_argb_a, 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_opt, kStride * height);
-  srandom(time(NULL));
   for (int i = 0; i < kStride * height; ++i) {
-    src_argb_a[i + off] = (random() & 0xff);
-    src_argb_b[i + off] = (random() & 0xff);
+    src_argb_a[i + off] = (fastrand() & 0xff);
+    src_argb_b[i + off] = (fastrand() & 0xff);
   }
   ARGBAttenuate(src_argb_a + off, kStride, src_argb_a + off, kStride, width,
                 height);
   ARGBAttenuate(src_argb_b + off, kStride, src_argb_b + off, kStride, width,
                 height);
   memset(dst_argb_c, 255, kStride * height);
   memset(dst_argb_opt, 255, kStride * height);
 
   MaskCpuFlags(disable_cpu_flags);
   ARGBBlend(src_argb_a + off, kStride,
@@ skipping 282 matching lines @@
 }
 
 TEST_F(libyuvTest, TestCopyPlane) {
   int err = 0;
   int yw = benchmark_width_;
   int yh = benchmark_height_;
   int b = 12;
   int i, j;
 
   int y_plane_size = (yw + b * 2) * (yh + b * 2);
-  srandom(time(NULL));
   align_buffer_64(orig_y, y_plane_size);
   align_buffer_64(dst_c, y_plane_size);
   align_buffer_64(dst_opt, y_plane_size);
 
   memset(orig_y, 0, y_plane_size);
   memset(dst_c, 0, y_plane_size);
   memset(dst_opt, 0, y_plane_size);
 
   // Fill image buffers with random data.
   for (i = b; i < (yh + b); ++i) {
     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.
   for (i = 0; i < y_plane_size; ++i) {
-    uint8 random_number = random() & 0x7f;
+    uint8 random_number = fastrand() & 0x7f;
     dst_c[i] = random_number;
     dst_opt[i] = dst_c[i];
   }
 
   int y_off = b * (yw + b * 2) + b;
 
   int y_st = yw + b * 2;
   int stride = 8;
 
   // Disable all optimizations.
@@ skipping 28 matching lines @@
                         int disable_cpu_flags, int invert, int off) {
   if (width < 1) {
     width = 1;
   }
   const int kBpp = 4;
   const int kStride = width * kBpp;
   align_buffer_64(src_argb_a, 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_opt, kStride * height);
-  srandom(time(NULL));
   for (int i = 0; i < kStride * height; ++i) {
-    src_argb_a[i + off] = (random() & 0xff);
-    src_argb_b[i + off] = (random() & 0xff);
+    src_argb_a[i + off] = (fastrand() & 0xff);
+    src_argb_b[i + off] = (fastrand() & 0xff);
   }
   memset(dst_argb_c, 0, kStride * height);
   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);
   MaskCpuFlags(-1);
@@ skipping 47 matching lines @@
                    int disable_cpu_flags, int invert, int off) {
   if (width < 1) {
     width = 1;
   }
   const int kBpp = 4;
   const int kStride = width * kBpp;
   align_buffer_64(src_argb_a, 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_opt, kStride * height);
-  srandom(time(NULL));
   for (int i = 0; i < kStride * height; ++i) {
-    src_argb_a[i + off] = (random() & 0xff);
-    src_argb_b[i + off] = (random() & 0xff);
+    src_argb_a[i + off] = (fastrand() & 0xff);
+    src_argb_b[i + off] = (fastrand() & 0xff);
   }
   memset(dst_argb_c, 0, kStride * height);
   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);
   MaskCpuFlags(-1);
@@ skipping 47 matching lines @@
                         int disable_cpu_flags, int invert, int off) {
   if (width < 1) {
     width = 1;
   }
   const int kBpp = 4;
   const int kStride = width * kBpp;
   align_buffer_64(src_argb_a, 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_opt, kStride * height);
-  srandom(time(NULL));
   for (int i = 0; i < kStride * height; ++i) {
-    src_argb_a[i + off] = (random() & 0xff);
-    src_argb_b[i + off] = (random() & 0xff);
+    src_argb_a[i + off] = (fastrand() & 0xff);
+    src_argb_b[i + off] = (fastrand() & 0xff);
   }
   memset(dst_argb_c, 0, kStride * height);
   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);
   MaskCpuFlags(-1);
@@ skipping 47 matching lines @@
                      int disable_cpu_flags, int invert, int off) {
   if (width < 1) {
     width = 1;
   }
   const int kBpp = 4;
   const int kStride = width * kBpp;
   align_buffer_64(src_argb_a, kStride * height + off);
   align_buffer_64(dst_argb_c, kStride * height);
   align_buffer_64(dst_argb_opt, kStride * height);
   memset(src_argb_a, 0, kStride * height + off);
-  srandom(time(NULL));
   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_opt, 0, kStride * height);
 
   MaskCpuFlags(disable_cpu_flags);
   ARGBSobel(src_argb_a + off, kStride,
             dst_argb_c, kStride,
             width, invert * height);
   MaskCpuFlags(-1);
   for (int i = 0; i < benchmark_iterations; ++i) {
@@ skipping 46 matching lines @@
     width = 1;
   }
   const int kSrcBpp = 4;
   const int kDstBpp = 1;
   const int kSrcStride = (width * kSrcBpp + 15) & ~15;
   const int kDstStride = (width * kDstBpp + 15) & ~15;
   align_buffer_64(src_argb_a, kSrcStride * height + off);
   align_buffer_64(dst_argb_c, kDstStride * height);
   align_buffer_64(dst_argb_opt, kDstStride * height);
   memset(src_argb_a, 0, kSrcStride * height + off);
-  srandom(time(NULL));
   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_opt, 0, kDstStride * height);
 
   MaskCpuFlags(disable_cpu_flags);
   ARGBSobelToPlane(src_argb_a + off, kSrcStride,
                    dst_argb_c, kDstStride,
                    width, invert * height);
   MaskCpuFlags(-1);
   for (int i = 0; i < benchmark_iterations; ++i) {
@@ skipping 44 matching lines @@
                        int disable_cpu_flags, int invert, int off) {
   if (width < 1) {
     width = 1;
   }
   const int kBpp = 4;
   const int kStride = width * kBpp;
   align_buffer_64(src_argb_a, kStride * height + off);
   align_buffer_64(dst_argb_c, kStride * height);
   align_buffer_64(dst_argb_opt, kStride * height);
   memset(src_argb_a, 0, kStride * height + off);
-  srandom(time(NULL));
   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_opt, 0, kStride * height);
 
   MaskCpuFlags(disable_cpu_flags);
   ARGBSobelXY(src_argb_a + off, kStride,
             dst_argb_c, kStride,
             width, invert * height);
   MaskCpuFlags(-1);
   for (int i = 0; i < benchmark_iterations; ++i) {
@@ skipping 44 matching lines @@
                     int disable_cpu_flags, int invert, int off, int radius) {
   if (width < 1) {
     width = 1;
   }
   const int kBpp = 4;
   const int kStride = width * kBpp;
   align_buffer_64(src_argb_a, kStride * height + off);
   align_buffer_64(dst_cumsum, width * height * 16);
   align_buffer_64(dst_argb_c, kStride * height);
   align_buffer_64(dst_argb_opt, kStride * height);
-  srandom(time(NULL));
   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_argb_c, 0, kStride * height);
   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);
@@ skipping 295 matching lines @@
   free_aligned_buffer_64(orig_pixels);
 }
 
 static int TestARGBRect(int width, int height, int benchmark_iterations,
                         int disable_cpu_flags, int invert, int off, int bpp) {
   if (width < 1) {
     width = 1;
   }
   const int kStride = width * bpp;
   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_opt, kSize + off);
 
   MemRandomize(dst_argb_c + off, kSize);
   memcpy(dst_argb_opt + off, dst_argb_c + off, kSize);
 
   MaskCpuFlags(disable_cpu_flags);
   if (bpp == 4) {
     ARGBRect(dst_argb_c + off, kStride, 0, 0, width, invert * height, v32);
@@ skipping 73 matching lines @@
 }
 
 TEST_F(libyuvTest, SetPlane_Opt) {
   int max_diff = TestARGBRect(benchmark_width_, benchmark_height_,
                               benchmark_iterations_, disable_cpu_flags_,
                               +1, 0, 1);
   EXPECT_EQ(0, max_diff);
 }
 
 }  // namespace libyuv