I420Alpha row function in 1 pass

unit_test/convert_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 500 matching lines @@
 TESTPLANARTOB(I444, 1, 1, ARGB, 4, 4, 1, 2, ARGB, 4)
 TESTPLANARTOB(I444, 1, 1, ABGR, 4, 4, 1, 2, ARGB, 4)
 TESTPLANARTOB(I420, 2, 2, YUY2, 2, 4, 1, 1, ARGB, 4)
 TESTPLANARTOB(I420, 2, 2, UYVY, 2, 4, 1, 1, ARGB, 4)
 TESTPLANARTOB(I422, 2, 1, YUY2, 2, 4, 1, 0, ARGB, 4)
 TESTPLANARTOB(I422, 2, 1, UYVY, 2, 4, 1, 0, ARGB, 4)
 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)                       \
+                       YALIGN, W1280, DIFF, N, NEG, OFF, ATTEN)                \
 TEST_F(libyuvTest, 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 kSizeUV =                                                          \
     SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y);              \
   align_buffer_64(src_y, kWidth * kHeight + OFF);                              \
   align_buffer_64(src_u, kSizeUV + OFF);                                       \
   align_buffer_64(src_v, kSizeUV + OFF);                                       \
   align_buffer_64(src_a, kWidth * kHeight + OFF);                              \
   align_buffer_64(dst_argb_c, kStrideB * kHeight + OFF);                       \
   align_buffer_64(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, SUBSAMPLE(kWidth, SUBSAMP_X),             \
                         src_v + OFF, SUBSAMPLE(kWidth, SUBSAMP_X),             \
                         src_a + OFF, kWidth,                                   \
                         dst_argb_c + OFF, kStrideB,                            \
-                        kWidth, NEG kHeight);                                  \
+                        kWidth, NEG kHeight, ATTEN);                           \
   MaskCpuFlags(-1);                                                            \
   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_opt + OFF, kStrideB,                        \
-                          kWidth, NEG kHeight);                                \
+                          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_64(src_y);                                               \
   free_aligned_buffer_64(src_u);                                               \
   free_aligned_buffer_64(src_v);                                               \
   free_aligned_buffer_64(src_a);                                               \
   free_aligned_buffer_64(dst_argb_c);                                          \
   free_aligned_buffer_64(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)                        \
+        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)                      \
+        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)                         \
+        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)
+        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(libyuvTest, FMT_PLANAR##To##FMT_B##N) {                                 \
   const int kWidth = ((W1280) > 0) ? (W1280) : 1;                              \
   const int kHeight = benchmark_height_;                                       \
   const int kStrideB = kWidth * BPP_B;                                         \
@@ skipping 1093 matching lines @@
   free_aligned_buffer_64(dst_y_orig);                                          \
   free_aligned_buffer_64(dst_uv_orig);                                         \
   free_aligned_buffer_64(dst_y);                                               \
   free_aligned_buffer_64(dst_uv);                                              \
 }
 
 TESTPTOB(TestYUY2ToNV12, YUY2ToI420, YUY2ToNV12)
 TESTPTOB(TestUYVYToNV12, UYVYToI420, UYVYToNV12)
 
 }  // namespace libyuv