Add YV16 convert

media/base/yuv_convert.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.
 
 // 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
 // excerpt from wiki:
 //   These formulae are based on the NTSC standard;
 //     Y' = 0.299 x R + 0.587 x G + 0.114 x B
 //     U = -0.147 x R - 0.289 x G + 0.436 x B
 //     V =  0.615 x R - 0.515 x G - 0.100 x B
 //   On older, non-SIMD architectures, floating point arithmetic is much
 //    slower than using fixed-point arithmetic, so an alternative formulation
 //    is:
 //      C = Y' - 16
 //      D = U - 128
 //      E = V - 128
 //   Using the previous coefficients and noting that clip() denotes clipping a
 //    value to the range of 0 to 255, the following formulae provide the
 //    conversion from Y'UV to RGB (NTSC version):
 //      R = clip((298 x C + 409 x E + 128) >> 8)
 //      G = clip((298 x C - 100 x D - 208 x E + 128) >> 8)
 //      B = clip((298 x C + 516 x D + 128) >> 8)
 //
 // 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
+//
 // Implimentation notes
 //   This version uses MMX for Visual C and GCC, which should cover all
 //   current platforms.  C++ is included for reference and future platforms.
 //
-//   ARGB pixel format is assumed, which on little endian is stored as BGRA.
+//   ARGB pixel format is output, which on little endian is stored as BGRA.
 //   The alpha is filled in, allowing the application to use RGBA or RGB32.
-//   The row based conversion allows for a future YV16 version, and simplifies
-//   the platform specific portion of the code.
 //
 //  The Visual C assembler is considered the source.
 //  The GCC asm was created by compiling with Visual C and disassembling
 //  with GNU objdump.
 //    cl /c /Ox yuv_convert.cc
 //    objdump -d yuv_convert.o
 //  The code almost copy/pasted in, except the table lookups, which produced
 //    movq   0x800(,%eax,8),%mm0
 //  and needed to be changed to cdecl style table names
 //   "movq   _coefficients_RGB_U(,%eax,8),%mm0\n"
@@ skipping 328 matching lines @@
   asm(
 "ConvertYV12ToRGB32Row:\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"
   "shr    %ecx\n"
 "1:\n"
-  "movzbl (%edi),%eax\n"
+  "movzb  (%edi),%eax\n"
   "add    $0x1,%edi\n"
-  "movzbl (%esi),%ebx\n"
+  "movzb  (%esi),%ebx\n"
   "add    $0x1,%esi\n"
   "movq   coefficients_RGB_U(,%eax,8),%mm0\n"
-  "movzbl (%edx),%eax\n"
+  "movzb  (%edx),%eax\n"
   "paddsw coefficients_RGB_V(,%ebx,8),%mm0\n"
-  "movzbl 0x1(%edx),%ebx\n"
+  "movzb  0x1(%edx),%ebx\n"
   "movq   coefficients_RGB_Y(,%eax,8),%mm1\n"
   "add    $0x2,%edx\n"
   "movq   coefficients_RGB_Y(,%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"
@@ skipping 17 matching lines @@
   "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"
   "shr    %ecx\n"
   "xor    %eax,%eax\n"
   "xor    %ebx,%ebx\n"
 "1:\n"
-  "movzbl (%edi),%eax\n"
+  "movzb  (%edi),%eax\n"
   "add    $0x1,%edi\n"
-  "movzbl (%esi),%ebx\n"
+  "movzb  (%esi),%ebx\n"
   "add    $0x1,%esi\n"
   "movq   _coefficients_RGB_U(,%eax,8),%mm0\n"
-  "movzbl (%edx),%eax\n"
+  "movzb  (%edx),%eax\n"
   "paddsw _coefficients_RGB_V(,%ebx,8),%mm0\n"
-  "movzbl 0x1(%edx),%ebx\n"
+  "movzb  0x1(%edx),%ebx\n"
   "movq   _coefficients_RGB_Y(,%eax,8),%mm1\n"
   "add    $0x2,%edx\n"
   "movq   _coefficients_RGB_Y(,%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"
   "sub    $0x1,%ecx\n"
   "jne    1b\n"
   "popa\n"
   "ret\n"
 );
 
 #endif  // MSC_VER
 }  // extern "C"
 
 #else  // USE_MMX
 
 void ConvertYV12ToRGB32Row(const uint8* y_buf,
                            const uint8* u_buf,
                            const uint8* v_buf,
                            uint8* rgb_buf,
                            size_t width);
 #endif
 
-// Convert a frame of YUV to 32 bit ARGB.
+// Convert a frame of YV12 (aka YUV420) to 32 bit ARGB.
 void ConvertYV12ToRGB32(const uint8* y_buf,
                         const uint8* u_buf,
                         const uint8* v_buf,
                         uint8* rgb_buf,
                         size_t width,
                         size_t height,
                         int y_pitch,
                         int uv_pitch,
                         int rgb_pitch) {
   // Image must be multiple of 2 in width.
@@ skipping 18 matching lines @@
   }
 #if USE_MMX
 #if defined(_MSC_VER)
   __asm emms;
 #else
   asm("emms");
 #endif
 #endif
 }
 
+// Convert a frame of YV16 (aka YUV422) to 32 bit ARGB.
+void ConvertYV16ToRGB32(const uint8* y_buf,
+                        const uint8* u_buf,
+                        const uint8* v_buf,
+                        uint8* rgb_buf,
+                        size_t width,
+                        size_t height,
+                        int y_pitch,
+                        int uv_pitch,
+                        int rgb_pitch) {
+  // Image must be multiple of 2 in width.
+  DCHECK((width & 1) == 0);
+  // Check alignment. Use memalign to allocate the buffer if you hit this
+  // check:
+  DCHECK((reinterpret_cast<uintptr_t>(rgb_buf) & 7) == 0);
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+  for (int y = 0; y < static_cast<int>(height); ++y) {
+    uint8* d1 = rgb_buf + y * rgb_pitch;
+    const uint8* y_ptr = y_buf + y * y_pitch;
+    const uint8* u_ptr = u_buf + y * uv_pitch;
+    const uint8* v_ptr = v_buf + y * uv_pitch;
+
+    ConvertYV12ToRGB32Row(y_ptr,
+                          u_ptr,
+                          v_ptr,
+                          d1,
+                          width);
+  }
+#if USE_MMX
+#if defined(_MSC_VER)
+  __asm emms;
+#else
+  asm("emms");
+#endif
+#endif
+}
+
 //------------------------------------------------------------------------------
 // This is pure C code
 
 #if !USE_MMX
 
 // Reference version of YUV converter.
 static const int kClipTableSize = 256;
 static const int kClipOverflow = 128;
 
 static uint8 g_rgb_clip_table[kClipOverflow
@@ skipping 107 matching lines @@
                                            | 0xff000000;
 
     rgb_buf += 8;  // Advance 2 pixels.
   }
 }
 #endif
 
 
 }  // namespace media