add command line cpu info to allow android neon test

unit_test/scale_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.
  */
 
 #include <stdlib.h>
 #include <time.h>
 
 #include "libyuv/cpu_id.h"
 #include "libyuv/scale.h"
 #include "../unit_test/unit_test.h"
 
 #define STRINGIZE(line) #line
 #define FILELINESTR(file, line) file ":" STRINGIZE(line)
 
 namespace libyuv {
 
 // Test scaling with C vs Opt and return maximum pixel difference. 0 = exact.
 static int TestFilter(int src_width, int src_height,
                       int dst_width, int dst_height,
                       FilterMode f, int benchmark_iterations,
-                      int disable_cpu_flags) {
+                      int disable_cpu_flags, int benchmark_cpu_info) {
   int i, j;
   const int b = 0;  // 128 to test for padding/stride.
   int src_width_uv = (Abs(src_width) + 1) >> 1;
   int src_height_uv = (Abs(src_height) + 1) >> 1;
 
   int64 src_y_plane_size = (Abs(src_width) + b * 2) * (Abs(src_height) + b * 2);
   int64 src_uv_plane_size = (src_width_uv + b * 2) * (src_height_uv + b * 2);
 
   int src_stride_y = b * 2 + Abs(src_width);
   int src_stride_uv = b * 2 + src_width_uv;
@@ skipping 35 matching lines @@
   I420Scale(src_y + (src_stride_y * b) + b, src_stride_y,
             src_u + (src_stride_uv * b) + b, src_stride_uv,
             src_v + (src_stride_uv * b) + b, src_stride_uv,
             src_width, src_height,
             dst_y_c + (dst_stride_y * b) + b, dst_stride_y,
             dst_u_c + (dst_stride_uv * b) + b, dst_stride_uv,
             dst_v_c + (dst_stride_uv * b) + b, dst_stride_uv,
             dst_width, dst_height, f);
   c_time = (get_time() - c_time);
 
-  MaskCpuFlags(-1);  // Enable all CPU optimization.
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
   double opt_time = get_time();
   for (i = 0; i < benchmark_iterations; ++i) {
     I420Scale(src_y + (src_stride_y * b) + b, src_stride_y,
               src_u + (src_stride_uv * b) + b, src_stride_uv,
               src_v + (src_stride_uv * b) + b, src_stride_uv,
               src_width, src_height,
               dst_y_opt + (dst_stride_y * b) + b, dst_stride_y,
               dst_u_opt + (dst_stride_uv * b) + b, dst_stride_uv,
               dst_v_opt + (dst_stride_uv * b) + b, dst_stride_uv,
               dst_width, dst_height, f);
@@ skipping 183 matching lines @@
 #define DX(x, nom, denom) static_cast<int>((Abs(x) / nom / 2) * nom * 2)
 #define SX(x, nom, denom) static_cast<int>((x / nom / 2) * denom * 2)
 
 #define TEST_FACTOR1(name, filter, nom, denom, max_diff)                       \
     TEST_F(LibYUVScaleTest, ScaleDownBy##name##_##filter) {                    \
       int diff = TestFilter(SX(benchmark_width_, nom, denom),                  \
                             SX(benchmark_height_, nom, denom),                 \
                             DX(benchmark_width_, nom, denom),                  \
                             DX(benchmark_height_, nom, denom),                 \
                             kFilter##filter, benchmark_iterations_,            \
-                            disable_cpu_flags_);                               \
+                            disable_cpu_flags_, benchmark_cpu_info_);          \
       EXPECT_LE(diff, max_diff);                                               \
     }                                                                          \
     TEST_F(LibYUVScaleTest, DISABLED_ScaleDownBy##name##_##filter##_16) {      \
       int diff = TestFilter_16(SX(benchmark_width_, nom, denom),               \
                                SX(benchmark_height_, nom, denom),              \
                                DX(benchmark_width_, nom, denom),               \
                                DX(benchmark_height_, nom, denom),              \
                                kFilter##filter, benchmark_iterations_);        \
       EXPECT_LE(diff, max_diff);                                               \
     }
@@ skipping 15 matching lines @@
 #undef TEST_FACTOR1
 #undef TEST_FACTOR
 #undef SX
 #undef DX
 
 #define TEST_SCALETO1(name, width, height, filter, max_diff)                   \
     TEST_F(LibYUVScaleTest, name##To##width##x##height##_##filter) {           \
       int diff = TestFilter(benchmark_width_, benchmark_height_,               \
                             width, height,                                     \
                             kFilter##filter, benchmark_iterations_,            \
-                            disable_cpu_flags_);                               \
+                            disable_cpu_flags_, benchmark_cpu_info_);          \
       EXPECT_LE(diff, max_diff);                                               \
     }                                                                          \
     TEST_F(LibYUVScaleTest, name##From##width##x##height##_##filter) {         \
       int diff = TestFilter(width, height,                                     \
                             Abs(benchmark_width_), Abs(benchmark_height_),     \
                             kFilter##filter, benchmark_iterations_,            \
-                            disable_cpu_flags_);                               \
+                            disable_cpu_flags_, benchmark_cpu_info_);          \
       EXPECT_LE(diff, max_diff);                                               \
     }                                                                          \
     TEST_F(LibYUVScaleTest,                                                    \
         DISABLED_##name##To##width##x##height##_##filter##_16) {               \
       int diff = TestFilter_16(benchmark_width_, benchmark_height_,            \
                                width, height,                                  \
                                kFilter##filter, benchmark_iterations_);        \
       EXPECT_LE(diff, max_diff);                                               \
     }                                                                          \
     TEST_F(LibYUVScaleTest,                                                    \
@@ skipping 14 matching lines @@
 TEST_SCALETO(Scale, 1, 1)
 TEST_SCALETO(Scale, 320, 240)
 TEST_SCALETO(Scale, 352, 288)
 TEST_SCALETO(Scale, 569, 480)
 TEST_SCALETO(Scale, 640, 360)
 TEST_SCALETO(Scale, 1280, 720)
 #undef TEST_SCALETO1
 #undef TEST_SCALETO
 
 }  // namespace libyuv