Add rounding to InterpolateRow for improved quality and consistency.

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 891 matching lines @@
 
   ARGBInterpolate(&orig_pixels_0[0][0], 0, &orig_pixels_1[0][0], 0,
                   &interpolate_pixels[0][0], 0, 4, 1, 128);
   EXPECT_EQ(8u, interpolate_pixels[0][0]);
   EXPECT_EQ(16u, interpolate_pixels[0][1]);
   EXPECT_EQ(32u, interpolate_pixels[0][2]);
   EXPECT_EQ(64u, interpolate_pixels[0][3]);
   EXPECT_EQ(0u, interpolate_pixels[1][0]);
   EXPECT_EQ(0u, interpolate_pixels[1][1]);
   EXPECT_EQ(0u, interpolate_pixels[1][2]);
-  EXPECT_NEAR(128u, interpolate_pixels[1][3], 1);  // C = 127, SSE = 128.
+  EXPECT_EQ(128u, interpolate_pixels[1][3]);
   EXPECT_EQ(0u, interpolate_pixels[2][0]);
   EXPECT_EQ(0u, interpolate_pixels[2][1]);
   EXPECT_EQ(0u, interpolate_pixels[2][2]);
   EXPECT_EQ(0u, interpolate_pixels[2][3]);
-  EXPECT_NEAR(128u, interpolate_pixels[3][0], 1);
-  EXPECT_NEAR(128u, interpolate_pixels[3][1], 1);
-  EXPECT_NEAR(128u, interpolate_pixels[3][2], 1);
-  EXPECT_NEAR(128u, interpolate_pixels[3][3], 1);
+  EXPECT_EQ(128u, interpolate_pixels[3][0]);
+  EXPECT_EQ(128u, interpolate_pixels[3][1]);
+  EXPECT_EQ(128u, interpolate_pixels[3][2]);
+  EXPECT_EQ(128u, interpolate_pixels[3][3]);
 
   ARGBInterpolate(&orig_pixels_0[0][0], 0, &orig_pixels_1[0][0], 0,
                   &interpolate_pixels[0][0], 0, 4, 1, 0);
   EXPECT_EQ(16u, interpolate_pixels[0][0]);
   EXPECT_EQ(32u, interpolate_pixels[0][1]);
   EXPECT_EQ(64u, interpolate_pixels[0][2]);
   EXPECT_EQ(128u, interpolate_pixels[0][3]);
 
   ARGBInterpolate(&orig_pixels_0[0][0], 0, &orig_pixels_1[0][0], 0,
                   &interpolate_pixels[0][0], 0, 4, 1, 192);
@@ skipping 53 matching lines @@
 
   InterpolatePlane(&orig_pixels_0[0], 0, &orig_pixels_1[0], 0,
                    &interpolate_pixels[0], 0, 16, 1, 128);
   EXPECT_EQ(8u, interpolate_pixels[0]);
   EXPECT_EQ(16u, interpolate_pixels[1]);
   EXPECT_EQ(32u, interpolate_pixels[2]);
   EXPECT_EQ(64u, interpolate_pixels[3]);
   EXPECT_EQ(0u, interpolate_pixels[4]);
   EXPECT_EQ(0u, interpolate_pixels[5]);
   EXPECT_EQ(0u, interpolate_pixels[6]);
-  EXPECT_NEAR(128u, interpolate_pixels[7], 1);  // C = 127, SSE = 128.
+  EXPECT_EQ(128u, interpolate_pixels[7]);
   EXPECT_EQ(0u, interpolate_pixels[8]);
   EXPECT_EQ(0u, interpolate_pixels[9]);
   EXPECT_EQ(0u, interpolate_pixels[10]);
   EXPECT_EQ(0u, interpolate_pixels[11]);
-  EXPECT_NEAR(128u, interpolate_pixels[12], 1);
-  EXPECT_NEAR(128u, interpolate_pixels[13], 1);
-  EXPECT_NEAR(128u, interpolate_pixels[14], 1);
-  EXPECT_NEAR(128u, interpolate_pixels[15], 1);
+  EXPECT_EQ(128u, interpolate_pixels[12]);
+  EXPECT_EQ(128u, interpolate_pixels[13]);
+  EXPECT_EQ(128u, interpolate_pixels[14]);
+  EXPECT_EQ(128u, interpolate_pixels[15]);
 
   InterpolatePlane(&orig_pixels_0[0], 0, &orig_pixels_1[0], 0,
                    &interpolate_pixels[0], 0, 16, 1, 0);
   EXPECT_EQ(16u, interpolate_pixels[0]);
   EXPECT_EQ(32u, interpolate_pixels[1]);
   EXPECT_EQ(64u, interpolate_pixels[2]);
   EXPECT_EQ(128u, interpolate_pixels[3]);
 
   InterpolatePlane(&orig_pixels_0[0], 0, &orig_pixels_1[0], 0,
                    &interpolate_pixels[0], 0, 16, 1, 192);
 
   EXPECT_EQ(4u, interpolate_pixels[0]);
   EXPECT_EQ(8u, interpolate_pixels[1]);
-  EXPECT_EQ(16u,interpolate_pixels[2]);
+  EXPECT_EQ(16u, interpolate_pixels[2]);
   EXPECT_EQ(32u, interpolate_pixels[3]);
 
   for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
     InterpolatePlane(&orig_pixels_0[0], 0, &orig_pixels_1[0], 0,
-                     &interpolate_pixels[0], 0, 1280, 1, 128);
+                     &interpolate_pixels[0], 0, 1280, 1, 123);
   }
 }
 
 #define TESTTERP(FMT_A, BPP_A, STRIDE_A,                                       \
                  FMT_B, BPP_B, STRIDE_B,                                       \
                  W1280, TERP, DIFF, 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;  \
@@ skipping 1608 matching lines @@
 
 TEST_F(LibYUVPlanarTest, SetPlane_Opt) {
   int max_diff = TestARGBRect(benchmark_width_, benchmark_height_,
                               benchmark_iterations_,
                               disable_cpu_flags_, benchmark_cpu_info_,
                               +1, 0, 1);
   EXPECT_EQ(0, max_diff);
 }
 
 }  // namespace libyuv