Revert 49990 - x

media/base/yuv_row_posix.cc

 // Copyright (c) 2010 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.
 
 #include "media/base/yuv_row.h"
 
 #ifdef _DEBUG
 #include "base/logging.h"
 #else
 #define DCHECK(a)
@@ skipping 255 matching lines @@
 
 void FastConvertYUVToRGB32Row(const uint8* y_buf,
                               const uint8* u_buf,
                               const uint8* v_buf,
                               uint8* rgb_buf,
                               int width);
 
   asm(
   ".global FastConvertYUVToRGB32Row\n"
 "FastConvertYUVToRGB32Row:\n"
-#if 0
   "pusha\n"
   "mov    0x24(%esp),%edx\n"
   "mov    0x28(%esp),%edi\n"
   "mov    0x2c(%esp),%esi\n"
   "mov    0x30(%esp),%ebp\n"
   "mov    0x34(%esp),%ecx\n"
   "jmp    convertend\n"
 
 "convertloop:"
   "movzbl (%edi),%eax\n"
@@ skipping 26 matching lines @@
   "movzbl (%esi),%eax\n"
   "paddsw kCoefficientsRgbY+4096(,%eax,8),%mm0\n"
   "movzbl (%edx),%eax\n"
   "movq   kCoefficientsRgbY(,%eax,8),%mm1\n"
   "paddsw %mm0,%mm1\n"
   "psraw  $0x6,%mm1\n"
   "packuswb %mm1,%mm1\n"
   "movd   %mm1,0x0(%ebp)\n"
 "convertdone:"
   "popa\n"
-#endif
   "ret\n"
 );
 
 
 void ScaleYUVToRGB32Row(const uint8* y_buf,
                         const uint8* u_buf,
                         const uint8* v_buf,
                         uint8* rgb_buf,
                         int width,
                         int source_dx);
 
   asm(
   ".global ScaleYUVToRGB32Row\n"
 "ScaleYUVToRGB32Row:\n"
-#if 0
   "pusha\n"
   "mov    0x24(%esp),%edx\n"
   "mov    0x28(%esp),%edi\n"
   "mov    0x2c(%esp),%esi\n"
   "mov    0x30(%esp),%ebp\n"
   "mov    0x34(%esp),%ecx\n"
   "xor    %ebx,%ebx\n"
   "jmp    scaleend\n"
 
 "scaleloop:"
@@ skipping 41 matching lines @@
   "sar    $0x10,%eax\n"
   "movzbl (%edx,%eax,1),%eax\n"
   "movq   kCoefficientsRgbY(,%eax,8),%mm1\n"
   "paddsw %mm0,%mm1\n"
   "psraw  $0x6,%mm1\n"
   "packuswb %mm1,%mm1\n"
   "movd   %mm1,0x0(%ebp)\n"
 
 "scaledone:"
   "popa\n"
-#endif
   "ret\n"
 );
 
 void LinearScaleYUVToRGB32Row(const uint8* y_buf,
                               const uint8* u_buf,
                               const uint8* v_buf,
                               uint8* rgb_buf,
                               int width,
                               int source_dx);
 
   asm(
   ".global LinearScaleYUVToRGB32Row\n"
 "LinearScaleYUVToRGB32Row:\n"
-#if 0
   "pusha\n"
   "mov    0x24(%esp),%edx\n"
   "mov    0x28(%esp),%edi\n"
   "mov    0x30(%esp),%ebp\n"
 
   // source_width = width * source_dx + ebx
   "mov    0x34(%esp), %ecx\n"
   "imull  0x38(%esp), %ecx\n"
   "mov    %ecx, 0x34(%esp)\n"
 
@@ skipping 78 matching lines @@
   "jl     .lscaleloop\n"
   "popa\n"
   "ret\n"
 
 ".lscalelastpixel:"
   "paddsw %mm0, %mm1\n"
   "psraw $6, %mm1\n"
   "packuswb %mm1, %mm1\n"
   "movd %mm1, (%ebp)\n"
   "popa\n"
-#endif
   "ret\n"
 );
 
 #elif USE_MMX && !defined(ARCH_CPU_X86_64) && defined(__PIC__)
 
 extern void PICConvertYUVToRGB32Row(const uint8* y_buf,
                                     const uint8* u_buf,
                                     const uint8* v_buf,
                                     uint8* rgb_buf,
                                     int width,
                                     int16 *kCoefficientsRgbY);
   __asm__(
 "_PICConvertYUVToRGB32Row:\n"
-#if 0
   "pusha\n"
   "mov    0x24(%esp),%edx\n"
   "mov    0x28(%esp),%edi\n"
   "mov    0x2c(%esp),%esi\n"
   "mov    0x30(%esp),%ebp\n"
   "mov    0x38(%esp),%ecx\n"
 
   "jmp    .Lconvertend\n"
 
 ".Lconvertloop:"
@@ skipping 27 matching lines @@
   "movzbl (%esi),%eax\n"
   "paddsw 4096(%ecx,%eax,8),%mm0\n"
   "movzbl (%edx),%eax\n"
   "movq   0(%ecx,%eax,8),%mm1\n"
   "paddsw %mm0,%mm1\n"
   "psraw  $0x6,%mm1\n"
   "packuswb %mm1,%mm1\n"
   "movd   %mm1,0x0(%ebp)\n"
 ".Lconvertdone:\n"
   "popa\n"
-#endif
   "ret\n"
 );
 
 void FastConvertYUVToRGB32Row(const uint8* y_buf,
                               const uint8* u_buf,
                               const uint8* v_buf,
                               uint8* rgb_buf,
                               int width) {
   PICConvertYUVToRGB32Row(y_buf, u_buf, v_buf, rgb_buf, width,
                           &kCoefficientsRgbY[0][0]);
 }
 
 extern void PICScaleYUVToRGB32Row(const uint8* y_buf,
                                const uint8* u_buf,
                                const uint8* v_buf,
                                uint8* rgb_buf,
                                int width,
                                int source_dx,
                                int16 *kCoefficientsRgbY);
 
   __asm__(
 "_PICScaleYUVToRGB32Row:\n"
-#if 0
   "pusha\n"
   "mov    0x24(%esp),%edx\n"
   "mov    0x28(%esp),%edi\n"
   "mov    0x2c(%esp),%esi\n"
   "mov    0x30(%esp),%ebp\n"
   "mov    0x3c(%esp),%ecx\n"
   "xor    %ebx,%ebx\n"
   "jmp    Lscaleend\n"
 
 "Lscaleloop:"
@@ skipping 41 matching lines @@
   "sar    $0x10,%eax\n"
   "movzbl (%edx,%eax,1),%eax\n"
   "movq   0(%ecx,%eax,8),%mm1\n"
   "paddsw %mm0,%mm1\n"
   "psraw  $0x6,%mm1\n"
   "packuswb %mm1,%mm1\n"
   "movd   %mm1,0x0(%ebp)\n"
 
 "Lscaledone:"
   "popa\n"
-#endif
   "ret\n"
 );
 
 
 void ScaleYUVToRGB32Row(const uint8* y_buf,
                         const uint8* u_buf,
                         const uint8* v_buf,
                         uint8* rgb_buf,
                         int width,
                         int source_dx) {
   PICScaleYUVToRGB32Row(y_buf, u_buf, v_buf, rgb_buf, width, source_dx,
                         &kCoefficientsRgbY[0][0]);
 }
 
 void PICLinearScaleYUVToRGB32Row(const uint8* y_buf,
                                  const uint8* u_buf,
                                  const uint8* v_buf,
                                  uint8* rgb_buf,
                                  int width,
                                  int source_dx,
                                  int16 *kCoefficientsRgbY);
 
   asm(
 "_PICLinearScaleYUVToRGB32Row:\n"
-#if 0
   "pusha\n"
   "mov    0x24(%esp),%edx\n"
   "mov    0x30(%esp),%ebp\n"
   "mov    0x34(%esp),%ecx\n"
   "mov    0x3c(%esp),%edi\n"
   "xor    %ebx,%ebx\n"
 
   // source_width = width * source_dx + ebx
   "mov    0x34(%esp), %ecx\n"
   "imull  0x38(%esp), %ecx\n"
@@ skipping 81 matching lines @@
   "jg     .lscaleloop\n"
   "popa\n"
   "ret\n"
 
 ".lscalelastpixel:"
   "paddsw %mm0, %mm1\n"
   "psraw $6, %mm1\n"
   "packuswb %mm1, %mm1\n"
   "movd %mm1, (%ebp)\n"
   "popa\n"
-#endif
   "ret\n"
 );
 
 void LinearScaleYUVToRGB32Row(const uint8* y_buf,
                         const uint8* u_buf,
                         const uint8* v_buf,
                         uint8* rgb_buf,
                         int width,
                         int source_dx) {
   PICLinearScaleYUVToRGB32Row(y_buf, u_buf, v_buf, rgb_buf, width, source_dx,
@@ skipping 137 matching lines @@
       YuvPixel(y, u, v, rgb_buf+4);
       x += source_dx;
     }
     rgb_buf += 8;
   }
 }
 
 #endif  // USE_MMX
 }  // extern "C"