mmx for linux yuv convert function....

media/base/yuv_row_win.cc

 // Copyright (c) 2009 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"
 
-// Enable bilinear filtering by turning on the following macro.
-//  #define MEDIA_BILINEAR_FILTER 1
-
-namespace media {
-
+extern "C" {
 #define RGBY(i) { \
   static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \
   static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \
   static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \
   0 \
 }
 
 #define RGBU(i) { \
   static_cast<int16>(2.018 * 64 * (i - 128) + 0.5), \
   static_cast<int16>(-0.391 * 64 * (i - 128) + 0.5), \
   0, \
   static_cast<int16>(256 * 64 - 1) \
 }
 
 #define RGBV(i) { \
   0, \
   static_cast<int16>(-0.813 * 64 * (i - 128) + 0.5), \
   static_cast<int16>(1.596 * 64 * (i - 128) + 0.5), \
   0 \
 }
 
 #define MMX_ALIGNED(var) __declspec(align(16)) var
 
-extern "C" {
-MMX_ALIGNED(int16 coefficients_RGB_Y[256][4]) = {
+MMX_ALIGNED(int16 kCoefficientsRgbY[256][4]) = {
   RGBY(0x00), RGBY(0x01), RGBY(0x02), RGBY(0x03),
   RGBY(0x04), RGBY(0x05), RGBY(0x06), RGBY(0x07),
   RGBY(0x08), RGBY(0x09), RGBY(0x0A), RGBY(0x0B),
   RGBY(0x0C), RGBY(0x0D), RGBY(0x0E), RGBY(0x0F),
   RGBY(0x10), RGBY(0x11), RGBY(0x12), RGBY(0x13),
   RGBY(0x14), RGBY(0x15), RGBY(0x16), RGBY(0x17),
   RGBY(0x18), RGBY(0x19), RGBY(0x1A), RGBY(0x1B),
   RGBY(0x1C), RGBY(0x1D), RGBY(0x1E), RGBY(0x1F),
   RGBY(0x20), RGBY(0x21), RGBY(0x22), RGBY(0x23),
   RGBY(0x24), RGBY(0x25), RGBY(0x26), RGBY(0x27),
@@ skipping 46 matching lines @@
   RGBY(0xE0), RGBY(0xE1), RGBY(0xE2), RGBY(0xE3),
   RGBY(0xE4), RGBY(0xE5), RGBY(0xE6), RGBY(0xE7),
   RGBY(0xE8), RGBY(0xE9), RGBY(0xEA), RGBY(0xEB),
   RGBY(0xEC), RGBY(0xED), RGBY(0xEE), RGBY(0xEF),
   RGBY(0xF0), RGBY(0xF1), RGBY(0xF2), RGBY(0xF3),
   RGBY(0xF4), RGBY(0xF5), RGBY(0xF6), RGBY(0xF7),
   RGBY(0xF8), RGBY(0xF9), RGBY(0xFA), RGBY(0xFB),
   RGBY(0xFC), RGBY(0xFD), RGBY(0xFE), RGBY(0xFF),
 };
 
-MMX_ALIGNED(int16 coefficients_RGB_U[256][4]) = {
+MMX_ALIGNED(int16 kCoefficientsRgbU[256][4]) = {
   RGBU(0x00), RGBU(0x01), RGBU(0x02), RGBU(0x03),
   RGBU(0x04), RGBU(0x05), RGBU(0x06), RGBU(0x07),
   RGBU(0x08), RGBU(0x09), RGBU(0x0A), RGBU(0x0B),
   RGBU(0x0C), RGBU(0x0D), RGBU(0x0E), RGBU(0x0F),
   RGBU(0x10), RGBU(0x11), RGBU(0x12), RGBU(0x13),
   RGBU(0x14), RGBU(0x15), RGBU(0x16), RGBU(0x17),
   RGBU(0x18), RGBU(0x19), RGBU(0x1A), RGBU(0x1B),
   RGBU(0x1C), RGBU(0x1D), RGBU(0x1E), RGBU(0x1F),
   RGBU(0x20), RGBU(0x21), RGBU(0x22), RGBU(0x23),
   RGBU(0x24), RGBU(0x25), RGBU(0x26), RGBU(0x27),
@@ skipping 46 matching lines @@
   RGBU(0xE0), RGBU(0xE1), RGBU(0xE2), RGBU(0xE3),
   RGBU(0xE4), RGBU(0xE5), RGBU(0xE6), RGBU(0xE7),
   RGBU(0xE8), RGBU(0xE9), RGBU(0xEA), RGBU(0xEB),
   RGBU(0xEC), RGBU(0xED), RGBU(0xEE), RGBU(0xEF),
   RGBU(0xF0), RGBU(0xF1), RGBU(0xF2), RGBU(0xF3),
   RGBU(0xF4), RGBU(0xF5), RGBU(0xF6), RGBU(0xF7),
   RGBU(0xF8), RGBU(0xF9), RGBU(0xFA), RGBU(0xFB),
   RGBU(0xFC), RGBU(0xFD), RGBU(0xFE), RGBU(0xFF),
 };
 
-MMX_ALIGNED(int16 coefficients_RGB_V[256][4]) = {
+MMX_ALIGNED(int16 kCoefficientsRgbV[256][4]) = {
   RGBV(0x00), RGBV(0x01), RGBV(0x02), RGBV(0x03),
   RGBV(0x04), RGBV(0x05), RGBV(0x06), RGBV(0x07),
   RGBV(0x08), RGBV(0x09), RGBV(0x0A), RGBV(0x0B),
   RGBV(0x0C), RGBV(0x0D), RGBV(0x0E), RGBV(0x0F),
   RGBV(0x10), RGBV(0x11), RGBV(0x12), RGBV(0x13),
   RGBV(0x14), RGBV(0x15), RGBV(0x16), RGBV(0x17),
   RGBV(0x18), RGBV(0x19), RGBV(0x1A), RGBV(0x1B),
   RGBV(0x1C), RGBV(0x1D), RGBV(0x1E), RGBV(0x1F),
   RGBV(0x20), RGBV(0x21), RGBV(0x22), RGBV(0x23),
   RGBV(0x24), RGBV(0x25), RGBV(0x26), RGBV(0x27),
@@ skipping 45 matching lines @@
   RGBV(0xDC), RGBV(0xDD), RGBV(0xDE), RGBV(0xDF),
   RGBV(0xE0), RGBV(0xE1), RGBV(0xE2), RGBV(0xE3),
   RGBV(0xE4), RGBV(0xE5), RGBV(0xE6), RGBV(0xE7),
   RGBV(0xE8), RGBV(0xE9), RGBV(0xEA), RGBV(0xEB),
   RGBV(0xEC), RGBV(0xED), RGBV(0xEE), RGBV(0xEF),
   RGBV(0xF0), RGBV(0xF1), RGBV(0xF2), RGBV(0xF3),
   RGBV(0xF4), RGBV(0xF5), RGBV(0xF6), RGBV(0xF7),
   RGBV(0xF8), RGBV(0xF9), RGBV(0xFA), RGBV(0xFB),
   RGBV(0xFC), RGBV(0xFD), RGBV(0xFE), RGBV(0xFF),
 };
-}  // extern "C"
 
 #undef RGBHY
 #undef RGBY
 #undef RGBU
 #undef RGBV
 #undef MMX_ALIGNED
 
 // Warning C4799: function has no EMMS instruction.
 // EMMS() is slow and should be called by the calling function once per image.
 #pragma warning(disable: 4799)
 
 __declspec(naked)
 void FastConvertYUVToRGB32Row(const uint8* y_buf,
                               const uint8* u_buf,
                               const uint8* v_buf,
                               uint8* rgb_buf,
                               int width) {
   __asm {
     pushad
     mov       edx, [esp + 32 + 4]   // Y
     mov       edi, [esp + 32 + 8]   // U
     mov       esi, [esp + 32 + 12]  // V
     mov       ebp, [esp + 32 + 16]  // rgb
     mov       ecx, [esp + 32 + 20]  // width
-    jmp       wend
+    jmp       convertend
 
- wloop :
+ convertloop :
     movzx     eax, byte ptr [edi]
     add       edi, 1
     movzx     ebx, byte ptr [esi]
     add       esi, 1
-    movq      mm0, [coefficients_RGB_U + 8 * eax]
+    movq      mm0, [kCoefficientsRgbU + 8 * eax]
     movzx     eax, byte ptr [edx]
-    paddsw    mm0, [coefficients_RGB_V + 8 * ebx]
+    paddsw    mm0, [kCoefficientsRgbV + 8 * ebx]
     movzx     ebx, byte ptr [edx + 1]
-    movq      mm1, [coefficients_RGB_Y + 8 * eax]
+    movq      mm1, [kCoefficientsRgbY + 8 * eax]
     add       edx, 2
-    movq      mm2, [coefficients_RGB_Y + 8 * ebx]
+    movq      mm2, [kCoefficientsRgbY + 8 * ebx]
     paddsw    mm1, mm0
     paddsw    mm2, mm0
     psraw     mm1, 6
     psraw     mm2, 6
     packuswb  mm1, mm2
     movntq    [ebp], mm1
     add       ebp, 8
- wend :
+ convertend :
     sub       ecx, 2
-    jns       wloop
+    jns       convertloop
 
     and       ecx, 1  // odd number of pixels?
-    jz        wdone
+    jz        convertdone
 
     movzx     eax, byte ptr [edi]
-    movq      mm0, [coefficients_RGB_U + 8 * eax]
+    movq      mm0, [kCoefficientsRgbU + 8 * eax]
     movzx     eax, byte ptr [esi]
-    paddsw    mm0, [coefficients_RGB_V + 8 * eax]
+    paddsw    mm0, [kCoefficientsRgbV + 8 * eax]
     movzx     eax, byte ptr [edx]
-    movq      mm1, [coefficients_RGB_Y + 8 * eax]
+    movq      mm1, [kCoefficientsRgbY + 8 * eax]
     paddsw    mm1, mm0
     psraw     mm1, 6
     packuswb  mm1, mm1
     movd      [ebp], mm1
- wdone :
+ convertdone :
 
     popad
     ret
   }
 }
 
 __declspec(naked)
 void ConvertYUVToRGB32Row(const uint8* y_buf,
                           const uint8* u_buf,
                           const uint8* v_buf,
                           uint8* rgb_buf,
                           int width,
                           int step) {
   __asm {
     pushad
     mov       edx, [esp + 32 + 4]   // Y
     mov       edi, [esp + 32 + 8]   // U
     mov       esi, [esp + 32 + 12]  // V
     mov       ebp, [esp + 32 + 16]  // rgb
     mov       ecx, [esp + 32 + 20]  // width
     mov       ebx, [esp + 32 + 24]  // step
     jmp       wend
 
  wloop :
     movzx     eax, byte ptr [edi]
     add       edi, ebx
-    movq      mm0, [coefficients_RGB_U + 8 * eax]
+    movq      mm0, [kCoefficientsRgbU + 8 * eax]
     movzx     eax, byte ptr [esi]
     add       esi, ebx
-    paddsw    mm0, [coefficients_RGB_V + 8 * eax]
+    paddsw    mm0, [kCoefficientsRgbV + 8 * eax]
     movzx     eax, byte ptr [edx]
     add       edx, ebx
-    movq      mm1, [coefficients_RGB_Y + 8 * eax]
+    movq      mm1, [kCoefficientsRgbY + 8 * eax]
     movzx     eax, byte ptr [edx]
     add       edx, ebx
-    movq      mm2, [coefficients_RGB_Y + 8 * eax]
+    movq      mm2, [kCoefficientsRgbY + 8 * eax]
     paddsw    mm1, mm0
     paddsw    mm2, mm0
     psraw     mm1, 6
     psraw     mm2, 6
     packuswb  mm1, mm2
     movntq    [ebp], mm1
     add       ebp, 8
  wend :
     sub       ecx, 2
     jns       wloop
 
     and       ecx, 1  // odd number of pixels?
     jz        wdone
 
     movzx     eax, byte ptr [edi]
-    movq      mm0, [coefficients_RGB_U + 8 * eax]
+    movq      mm0, [kCoefficientsRgbU + 8 * eax]
     movzx     eax, byte ptr [esi]
-    paddsw    mm0, [coefficients_RGB_V + 8 * eax]
+    paddsw    mm0, [kCoefficientsRgbV + 8 * eax]
     movzx     eax, byte ptr [edx]
-    movq      mm1, [coefficients_RGB_Y + 8 * eax]
+    movq      mm1, [kCoefficientsRgbY + 8 * eax]
     paddsw    mm1, mm0
     psraw     mm1, 6
     packuswb  mm1, mm1
     movd      [ebp], mm1
  wdone :
 
     popad
     ret
   }
 }
@@ skipping 12 matching lines @@
     mov       edi, [esp + 32 + 8]   // U
     mov       esi, [esp + 32 + 12]  // V
     mov       ebp, [esp + 32 + 16]  // rgb
     mov       ecx, [esp + 32 + 20]  // width
     jmp       wend
 
  wloop :
     movzx     eax, byte ptr [edi]
     mov       ebx, [esp + 32 + 28]  // uvstep
     add       edi, ebx
-    movq      mm0, [coefficients_RGB_U + 8 * eax]
+    movq      mm0, [kCoefficientsRgbU + 8 * eax]
     movzx     eax, byte ptr [esi]
     add       esi, ebx
-    paddsw    mm0, [coefficients_RGB_V + 8 * eax]
+    paddsw    mm0, [kCoefficientsRgbV + 8 * eax]
     movzx     eax, byte ptr [edx]
     mov       ebx, [esp + 32 + 24]  // ystep
     add       edx, ebx
-    movq      mm1, [coefficients_RGB_Y + 8 * eax]
+    movq      mm1, [kCoefficientsRgbY + 8 * eax]
     movzx     eax, byte ptr [edx]
     add       edx, ebx
-    movq      mm2, [coefficients_RGB_Y + 8 * eax]
+    movq      mm2, [kCoefficientsRgbY + 8 * eax]
     paddsw    mm1, mm0
     paddsw    mm2, mm0
     psraw     mm1, 6
     psraw     mm2, 6
     packuswb  mm1, mm2
     movntq    [ebp], mm1
     add       ebp, 8
  wend :
     sub       ecx, 2
     jns       wloop
 
     and       ecx, 1  // odd number of pixels?
     jz        wdone
 
     movzx     eax, byte ptr [edi]
-    movq      mm0, [coefficients_RGB_U + 8 * eax]
+    movq      mm0, [kCoefficientsRgbU + 8 * eax]
     movzx     eax, byte ptr [esi]
-    paddsw    mm0, [coefficients_RGB_V + 8 * eax]
+    paddsw    mm0, [kCoefficientsRgbV + 8 * eax]
     movzx     eax, byte ptr [edx]
-    movq      mm1, [coefficients_RGB_Y + 8 * eax]
+    movq      mm1, [kCoefficientsRgbY + 8 * eax]
     paddsw    mm1, mm0
     psraw     mm1, 6
     packuswb  mm1, mm1
     movd      [ebp], mm1
  wdone :
 
     popad
     ret
   }
 }
@@ skipping 11 matching lines @@
     mov       esi, [esp + 32 + 12]  // V
     mov       ebp, [esp + 32 + 16]  // rgb
     mov       ecx, [esp + 32 + 20]  // width
     jmp       wend
 
  wloop :
     movzx     eax, byte ptr [edi]
     add       edi, 1
     movzx     ebx, byte ptr [esi]
     add       esi, 1
-    movq      mm0, [coefficients_RGB_U + 8 * eax]
+    movq      mm0, [kCoefficientsRgbU + 8 * eax]
     movzx     eax, byte ptr [edx]
-    paddsw    mm0, [coefficients_RGB_V + 8 * ebx]
-    movq      mm1, [coefficients_RGB_Y + 8 * eax]
+    paddsw    mm0, [kCoefficientsRgbV + 8 * ebx]
+    movq      mm1, [kCoefficientsRgbY + 8 * eax]
     paddsw    mm1, mm0
     psraw     mm1, 6
     packuswb  mm1, mm1
     punpckldq mm1, mm1
     movntq    [ebp], mm1
 
     movzx     ebx, byte ptr [edx + 1]
     add       edx, 2
-    paddsw    mm0, [coefficients_RGB_Y + 8 * ebx]
+    paddsw    mm0, [kCoefficientsRgbY + 8 * ebx]
     psraw     mm0, 6
     packuswb  mm0, mm0
     punpckldq mm0, mm0
     movntq    [ebp+8], mm0
     add       ebp, 16
  wend :
     sub       ecx, 4
     jns       wloop
 
     add       ecx, 4
     jz        wdone
 
     movzx     eax, byte ptr [edi]
-    movq      mm0, [coefficients_RGB_U + 8 * eax]
+    movq      mm0, [kCoefficientsRgbU + 8 * eax]
     movzx     eax, byte ptr [esi]
-    paddsw    mm0, [coefficients_RGB_V + 8 * eax]
+    paddsw    mm0, [kCoefficientsRgbV + 8 * eax]
     movzx     eax, byte ptr [edx]
-    movq      mm1, [coefficients_RGB_Y + 8 * eax]
+    movq      mm1, [kCoefficientsRgbY + 8 * eax]
     paddsw    mm1, mm0
     psraw     mm1, 6
     packuswb  mm1, mm1
     jmp       wend1
 
  wloop1 :
     movd      [ebp], mm1
     add       ebp, 4
  wend1 :
     sub       ecx, 1
@@ skipping 16 matching lines @@
                         int width,
                         int dx) {
   __asm {
     pushad
     mov       edx, [esp + 32 + 4]   // Y
     mov       edi, [esp + 32 + 8]   // U
     mov       esi, [esp + 32 + 12]  // V
     mov       ebp, [esp + 32 + 16]  // rgb
     mov       ecx, [esp + 32 + 20]  // width
     xor       ebx, ebx              // x
-    jmp       wend
+    jmp       scaleend
 
- wloop :
+ scaleloop :
     mov       eax, ebx
     sar       eax, 5
     movzx     eax, byte ptr [edi + eax]
-    movq      mm0, [coefficients_RGB_U + 8 * eax]
+    movq      mm0, [kCoefficientsRgbU + 8 * eax]
     mov       eax, ebx
     sar       eax, 5
     movzx     eax, byte ptr [esi + eax]
-    paddsw    mm0, [coefficients_RGB_V + 8 * eax]
+    paddsw    mm0, [kCoefficientsRgbV + 8 * eax]
     mov       eax, ebx
     add       ebx, [esp + 32 + 24]  // x += dx
     sar       eax, 4
     movzx     eax, byte ptr [edx + eax]
-    movq      mm1, [coefficients_RGB_Y + 8 * eax]
+    movq      mm1, [kCoefficientsRgbY + 8 * eax]
     mov       eax, ebx
     add       ebx, [esp + 32 + 24]  // x += dx
     sar       eax, 4
     movzx     eax, byte ptr [edx + eax]
-    movq      mm2, [coefficients_RGB_Y + 8 * eax]
+    movq      mm2, [kCoefficientsRgbY + 8 * eax]
     paddsw    mm1, mm0
     paddsw    mm2, mm0
     psraw     mm1, 6
     psraw     mm2, 6
     packuswb  mm1, mm2
     movntq    [ebp], mm1
     add       ebp, 8
- wend :
+ scaleend :
     sub       ecx, 2
-    jns       wloop
+    jns       scaleloop
 
     and       ecx, 1  // odd number of pixels?
-    jz        wdone
+    jz        scaledone
 
     mov       eax, ebx
     sar       eax, 5
     movzx     eax, byte ptr [edi + eax]
-    movq      mm0, [coefficients_RGB_U + 8 * eax]
+    movq      mm0, [kCoefficientsRgbU + 8 * eax]
     mov       eax, ebx
     sar       eax, 5
     movzx     eax, byte ptr [esi + eax]
-    paddsw    mm0, [coefficients_RGB_V + 8 * eax]
+    paddsw    mm0, [kCoefficientsRgbV + 8 * eax]
     mov       eax, ebx
     sar       eax, 4
     movzx     eax, byte ptr [edx + eax]
-    movq      mm1, [coefficients_RGB_Y + 8 * eax]
+    movq      mm1, [kCoefficientsRgbY + 8 * eax]
     mov       eax, ebx
     sar       eax, 4
     movzx     eax, byte ptr [edx + eax]
-    movq      mm2, [coefficients_RGB_Y + 8 * eax]
+    movq      mm2, [kCoefficientsRgbY + 8 * eax]
     paddsw    mm1, mm0
     paddsw    mm2, mm0
     psraw     mm1, 6
     psraw     mm2, 6
     packuswb  mm1, mm2
     movd      [ebp], mm1
 
- wdone :
-
+ scaledone :
     popad
     ret
   }
 }
+}  // extern "C"
 
-}  // namespace media
-