add command line cpu info to allow android neon test

unit_test/scale_argb_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_argb.h"
 #include "libyuv/row.h"
 #include "../unit_test/unit_test.h"
 
 namespace libyuv {
 
 #define STRINGIZE(line) #line
 #define FILELINESTR(file, line) file ":" STRINGIZE(line)
 
 // Test scaling with C vs Opt and return maximum pixel difference. 0 = exact.
 static int ARGBTestFilter(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.
   int64 src_argb_plane_size = (Abs(src_width) + b * 2) *
       (Abs(src_height) + b * 2) * 4LL;
   int src_stride_argb = (b * 2 + Abs(src_width)) * 4;
 
   align_buffer_page_end(src_argb, src_argb_plane_size);
   if (!src_argb) {
     printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
     return 0;
@@ skipping 11 matching lines @@
   }
   memset(dst_argb_c, 2, dst_argb_plane_size);
   memset(dst_argb_opt, 3, dst_argb_plane_size);
 
   // Warm up both versions for consistent benchmarks.
   MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
   ARGBScale(src_argb + (src_stride_argb * b) + b * 4, src_stride_argb,
             src_width, src_height,
             dst_argb_c + (dst_stride_argb * b) + b * 4, dst_stride_argb,
             dst_width, dst_height, f);
-  MaskCpuFlags(-1);  // Enable all CPU optimization.
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
   ARGBScale(src_argb + (src_stride_argb * b) + b * 4, src_stride_argb,
             src_width, src_height,
             dst_argb_opt + (dst_stride_argb * b) + b * 4, dst_stride_argb,
             dst_width, dst_height, f);
 
   MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
   double c_time = get_time();
   ARGBScale(src_argb + (src_stride_argb * b) + b * 4, src_stride_argb,
             src_width, src_height,
             dst_argb_c + (dst_stride_argb * b) + b * 4, dst_stride_argb,
             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) {
     ARGBScale(src_argb + (src_stride_argb * b) + b * 4, src_stride_argb,
               src_width, src_height,
               dst_argb_opt + (dst_stride_argb * b) + b * 4, dst_stride_argb,
               dst_width, dst_height, f);
   }
   opt_time = (get_time() - opt_time) / benchmark_iterations;
 
   // Report performance of C vs OPT
@@ skipping 131 matching lines @@
 #define DX(x, nom, denom) static_cast<int>((Abs(x) / nom) * nom)
 #define SX(x, nom, denom) static_cast<int>((x / nom) * denom)
 
 #define TEST_FACTOR1(name, filter, nom, denom, max_diff)                       \
     TEST_F(LibYUVScaleTest, ARGBScaleDownBy##name##_##filter) {                \
       int diff = ARGBTestFilter(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, ARGBScaleDownClipBy##name##_##filter) {            \
       int diff = ARGBClipTestFilter(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 = ARGBTestFilter(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 = ARGBTestFilter(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, name##ClipTo##width##x##height##_##filter) {       \
       int diff = ARGBClipTestFilter(benchmark_width_, benchmark_height_,       \
                                     width, height,                             \
                                     kFilter##filter, benchmark_iterations_);   \
       EXPECT_LE(diff, max_diff);                                               \
     }                                                                          \
     TEST_F(LibYUVScaleTest, name##ClipFrom##width##x##height##_##filter) {     \
       int diff = ARGBClipTestFilter(width, height,                             \
@@ skipping 12 matching lines @@
 TEST_SCALETO(ARGBScale, 1, 1)
 TEST_SCALETO(ARGBScale, 320, 240)
 TEST_SCALETO(ARGBScale, 352, 288)
 TEST_SCALETO(ARGBScale, 569, 480)
 TEST_SCALETO(ARGBScale, 640, 360)
 TEST_SCALETO(ARGBScale, 1280, 720)
 #undef TEST_SCALETO1
 #undef TEST_SCALETO
 
 }  // namespace libyuv