-fPIC buildable version of yuv for 64 bit linux.

media/base/yuv_row_linux.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"
 
 #ifdef _DEBUG
 #include "base/logging.h"
 #else
 #define DCHECK(a)
@@ skipping 21 matching lines @@
 
 #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) var __attribute__((aligned(16)))
 
-MMX_ALIGNED(int16 kCoefficientsRgbY[256][4]) = {
+
+MMX_ALIGNED(int16 kCoefficientsRgbY[768][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 44 matching lines @@
   RGBY(0xD8), RGBY(0xD9), RGBY(0xDA), RGBY(0xDB),
   RGBY(0xDC), RGBY(0xDD), RGBY(0xDE), RGBY(0xDF),
   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 kCoefficientsRgbU[256][4]) = {
+  // Chroma U table.
   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 44 matching lines @@
   RGBU(0xD8), RGBU(0xD9), RGBU(0xDA), RGBU(0xDB),
   RGBU(0xDC), RGBU(0xDD), RGBU(0xDE), RGBU(0xDF),
   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 kCoefficientsRgbV[256][4]) = {
+  // Chroma V table.
   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 53 matching lines @@
   RGBV(0xFC), RGBV(0xFD), RGBV(0xFE), RGBV(0xFF),
 };
 
 #undef RGBY
 #undef RGBU
 #undef RGBV
 #undef MMX_ALIGNED
 
 #if defined(ARCH_CPU_X86_64)
 
+// AMD64 ABI uses register paremters.
 void FastConvertYUVToRGB32Row(const uint8* y_buf,  // rdi
                               const uint8* u_buf,  // rsi
                               const uint8* v_buf,  // rdx
                               uint8* rgb_buf,      // rcx
-                              int width);          // r8
-
+                              int width) {         // r8
   asm(
-".global FastConvertYUVToRGB32Row\n"
-"FastConvertYUVToRGB32Row:\n"
   "jmp    convertend\n"
-
 "convertloop:"
-  "movzb  (%rsi),%r10\n"
-  "add    $0x1,%rsi\n"
-  "movzb  (%rdx),%r11\n"
-  "add    $0x1,%rdx\n"
-  "movq   kCoefficientsRgbU(,%r10,8),%xmm0\n"
-  "movzb  (%rdi),%r10\n"
-  "movq   kCoefficientsRgbV(,%r11,8),%xmm1\n"
-  "movzb  0x1(%rdi),%r11\n"
-  "paddsw %xmm1,%xmm0\n"
-  "movq   kCoefficientsRgbY(,%r10,8),%xmm2\n"
-  "add    $0x2,%rdi\n"
-  "movq   kCoefficientsRgbY(,%r11,8),%xmm3\n"
-  "paddsw %xmm0,%xmm2\n"
-  "paddsw %xmm0,%xmm3\n"
-  "shufps $0x44,%xmm3,%xmm2\n"
-  "psraw  $0x6,%xmm2\n"
-  "packuswb %xmm2,%xmm2\n"
-  "movq   %xmm2,0x0(%rcx)\n"
-  "add    $0x8,%rcx\n"
+  "movzb  (%1),%%r10\n"
+  "add    $0x1,%1\n"
+  "movzb  (%2),%%r11\n"
+  "add    $0x1,%2\n"
+  "movq   2048(%5,%%r10,8),%%xmm0\n"
+  "movzb  (%0),%%r10\n"
+  "movq   4096(%5,%%r11,8),%%xmm1\n"
+  "movzb  0x1(%0),%%r11\n"
+  "paddsw %%xmm1,%%xmm0\n"
+  "movq   (%5,%%r10,8),%%xmm2\n"
+  "add    $0x2,%0\n"
+  "movq   (%5,%%r11,8),%%xmm3\n"
+  "paddsw %%xmm0,%%xmm2\n"
+  "paddsw %%xmm0,%%xmm3\n"
+  "shufps $0x44,%%xmm3,%%xmm2\n"
+  "psraw  $0x6,%%xmm2\n"
+  "packuswb %%xmm2,%%xmm2\n"
+  "movq   %%xmm2,0x0(%3)\n"
+  "add    $0x8,%3\n"
 "convertend:"
-  "sub    $0x2,%r8\n"
+  "sub    $0x2,%4\n"
   "jns    convertloop\n"
 
 "convertnext:"
-  "add    $0x1,%r8\n"
+  "add    $0x1,%4\n"
   "js     convertdone\n"
 
-  "movzb  (%rsi),%r10\n"
-  "movq   kCoefficientsRgbU(,%r10,8),%xmm0\n"
-  "movzb  (%rdx),%r10\n"
-  "movq   kCoefficientsRgbV(,%r10,8),%xmm1\n"
-  "paddsw %xmm1,%xmm0\n"
-  "movzb  (%rdi),%r10\n"
-  "movq   kCoefficientsRgbY(,%r10,8),%xmm1\n"
-  "paddsw %xmm0,%xmm1\n"
-  "psraw  $0x6,%xmm1\n"
-  "packuswb %xmm1,%xmm1\n"
-  "movd   %xmm1,0x0(%rcx)\n"
+  "movzb  (%1),%%r10\n"
+  "movq   2048(%5,%%r10,8),%%xmm0\n"
+  "movzb  (%2),%%r10\n"
+  "movq   4096(%5,%%r10,8),%%xmm1\n"
+  "paddsw %%xmm1,%%xmm0\n"
+  "movzb  (%0),%%r10\n"
+  "movq   (%5,%%r10,8),%%xmm1\n"
+  "paddsw %%xmm0,%%xmm1\n"
+  "psraw  $0x6,%%xmm1\n"
+  "packuswb %%xmm1,%%xmm1\n"
+  "movd   %%xmm1,0x0(%3)\n"
 "convertdone:"
-  "ret\n"
+  :
+  : "r"(y_buf),  // %0
+    "r"(u_buf),  // %1
+    "r"(v_buf),  // %2
+    "r"(rgb_buf),  // %3
+    "r"(width),  // %4
+    "r" (kCoefficientsRgbY)  // %5
+  : "memory", "r10", "r11", "xmm0", "xmm1", "xmm2", "xmm3"
 );
-
+}
 
 void ScaleYUVToRGB32Row(const uint8* y_buf,  // rdi
                         const uint8* u_buf,  // rsi
                         const uint8* v_buf,  // rdx
                         uint8* rgb_buf,      // rcx
                         int width,           // r8
-                        int scaled_dx);      // r9
-
+                        int scaled_dx) {     // r9
   asm(
-  ".global ScaleYUVToRGB32Row\n"
-"ScaleYUVToRGB32Row:\n"
-  "xor    %r11,%r11\n"
-  "sub    $0x2,%r8\n"
+  "xor    %%r11,%%r11\n"
+  "sub    $0x2,%4\n"
   "js     scalenext\n"
 
 "scaleloop:"
-  "mov    %r11,%r10\n"
-  "sar    $0x5,%r10\n"
-  "movzb  (%rsi,%r10,1),%rax\n"
-  "movq   kCoefficientsRgbU(,%rax,8),%xmm0\n"
-  "movzb  (%rdx,%r10,1),%rax\n"
-  "movq   kCoefficientsRgbV(,%rax,8),%xmm1\n"
-  "lea    (%r11,%r9),%r10\n"
-  "sar    $0x4,%r11\n"
-  "movzb  (%rdi,%r11,1),%rax\n"
-  "paddsw %xmm1,%xmm0\n"
-  "movq   kCoefficientsRgbY(,%rax,8),%xmm1\n"
-  "lea    (%r10,%r9),%r11\n"
-  "sar    $0x4,%r10\n"
-  "movzb  (%rdi,%r10,1),%rax\n"
-  "movq   kCoefficientsRgbY(,%rax,8),%xmm2\n"
-  "paddsw %xmm0,%xmm1\n"
-  "paddsw %xmm0,%xmm2\n"
-  "shufps $0x44,%xmm2,%xmm1\n"
-  "psraw  $0x6,%xmm1\n"
-  "packuswb %xmm1,%xmm1\n"
-  "movq   %xmm1,0x0(%rcx)\n"
-  "add    $0x8,%rcx\n"
-  "sub    $0x2,%r8\n"
+  "mov    %%r11,%%r10\n"
+  "sar    $0x5,%%r10\n"
+  "movzb  (%1,%%r10,1),%%rax\n"
+  "movq   2048(%5,%%rax,8),%%xmm0\n"
+  "movzb  (%2,%%r10,1),%%rax\n"
+  "movq   4096(%5,%%rax,8),%%xmm1\n"
+  "lea    (%%r11,%6),%%r10\n"
+  "sar    $0x4,%%r11\n"
+  "movzb  (%0,%%r11,1),%%rax\n"
+  "paddsw %%xmm1,%%xmm0\n"
+  "movq   (%5,%%rax,8),%%xmm1\n"
+  "lea    (%%r10,%6),%%r11\n"
+  "sar    $0x4,%%r10\n"
+  "movzb  (%0,%%r10,1),%%rax\n"
+  "movq   (%5,%%rax,8),%%xmm2\n"
+  "paddsw %%xmm0,%%xmm1\n"
+  "paddsw %%xmm0,%%xmm2\n"
+  "shufps $0x44,%%xmm2,%%xmm1\n"
+  "psraw  $0x6,%%xmm1\n"
+  "packuswb %%xmm1,%%xmm1\n"
+  "movq   %%xmm1,0x0(%3)\n"
+  "add    $0x8,%3\n"
+  "sub    $0x2,%4\n"
   "jns    scaleloop\n"
 
 "scalenext:"
-  "add    $0x1,%r8\n"
+  "add    $0x1,%4\n"
   "js     scaledone\n"
 
-  "mov    %r11,%r10\n"
-  "sar    $0x5,%r10\n"
-  "movzb  (%rsi,%r10,1),%rax\n"
-  "movq   kCoefficientsRgbU(,%rax,8),%xmm0\n"
-  "movzb  (%rdx,%r10,1),%rax\n"
-  "movq   kCoefficientsRgbV(,%rax,8),%xmm1\n"
-  "paddsw %xmm1,%xmm0\n"
-  "sar    $0x4,%r11\n"
-  "movzb  (%rdi,%r11,1),%rax\n"
-  "movq   kCoefficientsRgbY(,%rax,8),%xmm1\n"
-  "paddsw %xmm0,%xmm1\n"
-  "psraw  $0x6,%xmm1\n"
-  "packuswb %xmm1,%xmm1\n"
-  "movd   %xmm1,0x0(%rcx)\n"
+  "mov    %%r11,%%r10\n"
+  "sar    $0x5,%%r10\n"
+  "movzb  (%1,%%r10,1),%%rax\n"
+  "movq   2048(%5,%%rax,8),%%xmm0\n"
+  "movzb  (%2,%%r10,1),%%rax\n"
+  "movq   4096(%5,%%rax,8),%%xmm1\n"
+  "paddsw %%xmm1,%%xmm0\n"
+  "sar    $0x4,%%r11\n"
+  "movzb  (%0,%%r11,1),%%rax\n"
+  "movq   (%5,%%rax,8),%%xmm1\n"
+  "paddsw %%xmm0,%%xmm1\n"
+  "psraw  $0x6,%%xmm1\n"
+  "packuswb %%xmm1,%%xmm1\n"
+  "movd   %%xmm1,0x0(%3)\n"
 
 "scaledone:"
-  "ret\n"
+  :
+  : "r"(y_buf),  // %0
+    "r"(u_buf),  // %1
+    "r"(v_buf),  // %2
+    "r"(rgb_buf),  // %3
+    "r"(width),  // %4
+    "r" (kCoefficientsRgbY),  // %5
+    "r"(static_cast<long>(scaled_dx))  // %6
+  : "memory", "r10", "r11", "rax", "xmm0", "xmm1", "xmm2"
 );
+}
 
 #else
 
 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"
   "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"
   "add    $0x1,%edi\n"
   "movzbl (%esi),%ebx\n"
   "add    $0x1,%esi\n"
-  "movq   kCoefficientsRgbU(,%eax,8),%mm0\n"
+  "movq   kCoefficientsRgbY+2048(,%eax,8),%mm0\n"
   "movzbl (%edx),%eax\n"
-  "paddsw kCoefficientsRgbV(,%ebx,8),%mm0\n"
+  "paddsw kCoefficientsRgbY+4096(,%ebx,8),%mm0\n"
   "movzbl 0x1(%edx),%ebx\n"
   "movq   kCoefficientsRgbY(,%eax,8),%mm1\n"
   "add    $0x2,%edx\n"
   "movq   kCoefficientsRgbY(,%ebx,8),%mm2\n"
   "paddsw %mm0,%mm1\n"
   "paddsw %mm0,%mm2\n"
   "psraw  $0x6,%mm1\n"
   "psraw  $0x6,%mm2\n"
   "packuswb %mm2,%mm1\n"
   "movntq %mm1,0x0(%ebp)\n"
   "add    $0x8,%ebp\n"
 "convertend:"
   "sub    $0x2,%ecx\n"
   "jns    convertloop\n"
 
   "and    $0x1,%ecx\n"
   "je     convertdone\n"
 
   "movzbl (%edi),%eax\n"
-  "movq   kCoefficientsRgbU(,%eax,8),%mm0\n"
+  "movq   kCoefficientsRgbY+2048(,%eax,8),%mm0\n"
   "movzbl (%esi),%eax\n"
-  "paddsw kCoefficientsRgbV(,%eax,8),%mm0\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"
   "ret\n"
 );
@@ skipping 15 matching lines @@
   "mov    0x2c(%esp),%esi\n"
   "mov    0x30(%esp),%ebp\n"
   "mov    0x34(%esp),%ecx\n"
   "xor    %ebx,%ebx\n"
   "jmp    scaleend\n"
 
 "scaleloop:"
   "mov    %ebx,%eax\n"
   "sar    $0x5,%eax\n"
   "movzbl (%edi,%eax,1),%eax\n"
-  "movq   kCoefficientsRgbU(,%eax,8),%mm0\n"
+  "movq   kCoefficientsRgbY+2048(,%eax,8),%mm0\n"
   "mov    %ebx,%eax\n"
   "sar    $0x5,%eax\n"
   "movzbl (%esi,%eax,1),%eax\n"
-  "paddsw kCoefficientsRgbV(,%eax,8),%mm0\n"
+  "paddsw kCoefficientsRgbY+4096(,%eax,8),%mm0\n"
   "mov    %ebx,%eax\n"
   "add    0x38(%esp),%ebx\n"
   "sar    $0x4,%eax\n"
   "movzbl (%edx,%eax,1),%eax\n"
   "movq   kCoefficientsRgbY(,%eax,8),%mm1\n"
   "mov    %ebx,%eax\n"
   "add    0x38(%esp),%ebx\n"
   "sar    $0x4,%eax\n"
   "movzbl (%edx,%eax,1),%eax\n"
   "movq   kCoefficientsRgbY(,%eax,8),%mm2\n"
   "paddsw %mm0,%mm1\n"
   "paddsw %mm0,%mm2\n"
   "psraw  $0x6,%mm1\n"
   "psraw  $0x6,%mm2\n"
   "packuswb %mm2,%mm1\n"
   "movntq %mm1,0x0(%ebp)\n"
   "add    $0x8,%ebp\n"
 "scaleend:"
   "sub    $0x2,%ecx\n"
   "jns    scaleloop\n"
 
   "and    $0x1,%ecx\n"
   "je     scaledone\n"
 
   "mov    %ebx,%eax\n"
   "sar    $0x5,%eax\n"
   "movzbl (%edi,%eax,1),%eax\n"
-  "movq   kCoefficientsRgbU(,%eax,8),%mm0\n"
+  "movq   kCoefficientsRgbY+2048(,%eax,8),%mm0\n"
   "mov    %ebx,%eax\n"
   "sar    $0x5,%eax\n"
   "movzbl (%esi,%eax,1),%eax\n"
-  "paddsw kCoefficientsRgbV(,%eax,8),%mm0\n"
+  "paddsw kCoefficientsRgbY+4096(,%eax,8),%mm0\n"
   "mov    %ebx,%eax\n"
   "sar    $0x4,%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:"
@@ skipping 182 matching lines @@
     uint8 v = v_buf[scaled_x >> 5];
     uint8 y0 = y_buf[scaled_x >> 4];
     YuvPixel(y0, u, v, rgb_buf);
     rgb_buf += 4;
     scaled_x += scaled_dx;
   }
 }
 #endif  // USE_MMX
 }  // extern "C"