NV12 allow NULL for Y

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 409 matching lines @@
                     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) \
+                         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));                        \
@@ skipping 23 matching lines @@
                      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,                              \
+                                 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),       \
-                                   dst_y_opt, kWidth,                          \
+                                   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;                                                            \
-  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;                                                   \
+  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;                                                   \
       }                                                                        \
@@ skipping 20 matching lines @@
   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)                         \
+                     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)                       \
+                     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)                          \
+                     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)
+                     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 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;                              \
@@ skipping 1436 matching lines @@
         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)
 
 }  // namespace libyuv