Remove duplicate CPU detection code; use base::CPU instead.

media/base/yuv_convert.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This webpage shows layout of YV12 and other YUV formats
 // http://www.fourcc.org/yuv.php
 // The actual conversion is best described here
 // http://en.wikipedia.org/wiki/YUV
 // An article on optimizing YUV conversion using tables instead of multiplies
 // http://lestourtereaux.free.fr/papers/data/yuvrgb.pdf
 //
 // YV12 is a full plane of Y and a half height, half width chroma planes
 // YV16 is a full plane of Y and a full height, half width chroma planes
 //
 // ARGB pixel format is output, which on little endian is stored as BGRA.
 // The alpha is set to 255, allowing the application to use RGBA or RGB32.
 
 #include "media/base/yuv_convert.h"
 
+#include "base/cpu.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
-#include "media/base/cpu_features.h"
 #include "media/base/simd/convert_rgb_to_yuv.h"
 #include "media/base/simd/convert_yuv_to_rgb.h"
 #include "media/base/simd/filter_yuv.h"
 
 #if defined(ARCH_CPU_X86_FAMILY)
 #if defined(COMPILER_MSVC)
 #include <intrin.h>
 #else
 #include <mmintrin.h>
 #endif
 #endif
 
 namespace media {
 
 static FilterYUVRowsProc ChooseFilterYUVRowsProc() {
 #if defined(ARCH_CPU_X86_FAMILY)
-  if (hasSSE2())
+  base::CPU cpu;
+  if (cpu.has_sse2())
     return &FilterYUVRows_SSE2;
-  if (hasMMX())
+  if (cpu.has_mmx())
     return &FilterYUVRows_MMX;
 #endif
   return &FilterYUVRows_C;
 }
 
 static ConvertYUVToRGB32RowProc ChooseConvertYUVToRGB32RowProc() {
 #if defined(ARCH_CPU_X86_FAMILY)
-  if (hasSSE())
+  base::CPU cpu;
+  if (cpu.has_sse())
     return &ConvertYUVToRGB32Row_SSE;
-  if (hasMMX())
+  if (cpu.has_mmx())
     return &ConvertYUVToRGB32Row_MMX;
 #endif
   return &ConvertYUVToRGB32Row_C;
 }
 
 static ScaleYUVToRGB32RowProc ChooseScaleYUVToRGB32RowProc() {
 #if defined(ARCH_CPU_X86_64)
   // Use 64-bits version if possible.
   return &ScaleYUVToRGB32Row_SSE2_X64;
 #elif defined(ARCH_CPU_X86_FAMILY)
+  base::CPU cpu;
   // Choose the best one on 32-bits system.
-  if (hasSSE())
+  if (cpu.has_sse())
     return &ScaleYUVToRGB32Row_SSE;
-  if (hasMMX())
+  if (cpu.has_mmx())
     return &ScaleYUVToRGB32Row_MMX;
 #endif  // defined(ARCH_CPU_X86_64)
   return &ScaleYUVToRGB32Row_C;
 }
 
 static ScaleYUVToRGB32RowProc ChooseLinearScaleYUVToRGB32RowProc() {
 #if defined(ARCH_CPU_X86_64)
   // Use 64-bits version if possible.
   return &LinearScaleYUVToRGB32Row_MMX_X64;
 #elif defined(ARCH_CPU_X86_FAMILY)
+  base::CPU cpu;
   // 32-bits system.
-  if (hasSSE())
+  if (cpu.has_sse())
     return &LinearScaleYUVToRGB32Row_SSE;
-  if (hasMMX())
+  if (cpu.has_mmx())
     return &LinearScaleYUVToRGB32Row_MMX;
 #endif  // defined(ARCH_CPU_X86_64)
   return &LinearScaleYUVToRGB32Row_C;
 }
 
 // Empty SIMD registers state after using them.
 void EmptyRegisterState() {
 #if defined(ARCH_CPU_X86_FAMILY)
   static bool checked = false;
   static bool has_mmx = false;
   if (!checked) {
-    has_mmx = hasMMX();
+    base::CPU cpu;
+    has_mmx = cpu.has_mmx();
     checked = true;
   }
   if (has_mmx)
     _mm_empty();
 #endif
 }
 
 // 16.16 fixed point arithmetic
 const int kFractionBits = 16;
 const int kFractionMax = 1 << kFractionBits;
@@ skipping 335 matching lines @@
   static void (*convert_proc)(const uint8*, uint8*, uint8*, uint8*,
                               int, int, int, int, int) = NULL;
   if (!convert_proc) {
 #if defined(ARCH_CPU_ARM_FAMILY)
     // For ARM processors, always use C version.
     // TODO(hclam): Implement a NEON version.
     convert_proc = &ConvertRGB32ToYUV_C;
 #else
     // TODO(hclam): Switch to SSSE3 version when the cyan problem is solved.
     // See: crbug.com/100462
-      if (hasSSE2())
+    base::CPU cpu;
+    if (cpu.has_sse2())
       convert_proc = &ConvertRGB32ToYUV_SSE2;
     else
       convert_proc = &ConvertRGB32ToYUV_C;
 #endif
   }
 
   convert_proc(rgbframe, yplane, uplane, vplane, width, height,
                rgbstride, ystride, uvstride);
 }
 
 void ConvertRGB24ToYUV(const uint8* rgbframe,
                        uint8* yplane,
                        uint8* uplane,
                        uint8* vplane,
                        int width,
                        int height,
                        int rgbstride,
                        int ystride,
                        int uvstride) {
 #if defined(ARCH_CPU_ARM_FAMILY)
   ConvertRGB24ToYUV_C(rgbframe, yplane, uplane, vplane, width, height,
                       rgbstride, ystride, uvstride);
 #else
   static void (*convert_proc)(const uint8*, uint8*, uint8*, uint8*,
                               int, int, int, int, int) = NULL;
   if (!convert_proc) {
-    if (hasSSSE3())
+    base::CPU cpu;
+    if (cpu.has_ssse3())
       convert_proc = &ConvertRGB24ToYUV_SSSE3;
     else
       convert_proc = &ConvertRGB24ToYUV_C;
   }
   convert_proc(rgbframe, yplane, uplane, vplane, width, height,
                rgbstride, ystride, uvstride);
 #endif
 }
 
 void ConvertYUY2ToYUV(const uint8* src,
@@ skipping 48 matching lines @@
                        int ystride,
                        int uvstride,
                        int rgbstride,
                        YUVType yuv_type) {
 #if defined(ARCH_CPU_ARM_FAMILY)
   ConvertYUVToRGB32_C(yplane, uplane, vplane, rgbframe,
                       width, height, ystride, uvstride, rgbstride, yuv_type);
 #else
   static ConvertYUVToRGB32Proc convert_proc = NULL;
   if (!convert_proc) {
-    if (hasSSE())
+    base::CPU cpu;
+    if (cpu.has_sse())
       convert_proc = &ConvertYUVToRGB32_SSE;
-    else if (hasMMX())
+    else if (cpu.has_mmx())
       convert_proc = &ConvertYUVToRGB32_MMX;
     else
       convert_proc = &ConvertYUVToRGB32_C;
   }
 
   convert_proc(yplane, uplane, vplane, rgbframe,
                width, height, ystride, uvstride, rgbstride, yuv_type);
 #endif
 }
 
 }  // namespace media