yuy2 to rgb gcc versions

source/row_win.cc

 /*
  *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS. All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 16 matching lines @@
 
 // 64 bit
 #if defined(_M_X64)
 
 // Read 4 UV from 422, upsample to 8 UV.
 #define READYUV422                                                             \
     xmm0 = _mm_cvtsi32_si128(*(uint32*)u_buf);                                 \
     xmm1 = _mm_cvtsi32_si128(*(uint32*)(u_buf + offset));                      \
     xmm0 = _mm_unpacklo_epi8(xmm0, xmm1);                                      \
     xmm0 = _mm_unpacklo_epi16(xmm0, xmm0);                                     \
-    u_buf += 4;
+    u_buf += 4;                                                                \
+    xmm4 = _mm_loadl_epi64((__m128i*)y_buf);                                   \
+    xmm4 = _mm_unpacklo_epi8(xmm4, xmm4);                                      \
+    y_buf += 8;                                                                \
 
 // Convert 8 pixels: 8 UV and 8 Y.
 #define YUVTORGB(YuvConstants)                                                 \
     xmm1 = _mm_loadu_si128(&xmm0);                                             \
     xmm2 = _mm_loadu_si128(&xmm0);                                             \
     xmm0 = _mm_maddubs_epi16(xmm0, *(__m128i*)YuvConstants->kUVToB);           \
     xmm1 = _mm_maddubs_epi16(xmm1, *(__m128i*)YuvConstants->kUVToG);           \
     xmm2 = _mm_maddubs_epi16(xmm2, *(__m128i*)YuvConstants->kUVToR);           \
     xmm0 = _mm_sub_epi16(*(__m128i*)YuvConstants->kUVBiasB, xmm0);             \
     xmm1 = _mm_sub_epi16(*(__m128i*)YuvConstants->kUVBiasG, xmm1);             \
     xmm2 = _mm_sub_epi16(*(__m128i*)YuvConstants->kUVBiasR, xmm2);             \
-    xmm3 = _mm_loadl_epi64((__m128i*)y_buf);                                   \
-    y_buf += 8;                                                                \
-    xmm3 = _mm_unpacklo_epi8(xmm3, xmm3);                                      \
-    xmm3 = _mm_mulhi_epu16(xmm3, *(__m128i*)YuvConstants->kYToRgb);            \
-    xmm0 = _mm_adds_epi16(xmm0, xmm3);                                         \
-    xmm1 = _mm_adds_epi16(xmm1, xmm3);                                         \
-    xmm2 = _mm_adds_epi16(xmm2, xmm3);                                         \
+    xmm4 = _mm_mulhi_epu16(xmm4, *(__m128i*)YuvConstants->kYToRgb);            \
+    xmm0 = _mm_adds_epi16(xmm0, xmm4);                                         \
+    xmm1 = _mm_adds_epi16(xmm1, xmm4);                                         \
+    xmm2 = _mm_adds_epi16(xmm2, xmm4);                                         \
     xmm0 = _mm_srai_epi16(xmm0, 6);                                            \
     xmm1 = _mm_srai_epi16(xmm1, 6);                                            \
     xmm2 = _mm_srai_epi16(xmm2, 6);                                            \
     xmm0 = _mm_packus_epi16(xmm0, xmm0);                                       \
     xmm1 = _mm_packus_epi16(xmm1, xmm1);                                       \
     xmm2 = _mm_packus_epi16(xmm2, xmm2);
 
 // Store 8 ARGB values.
 #define STOREARGB                                                              \
     xmm0 = _mm_unpacklo_epi8(xmm0, xmm1);                                      \
@@ skipping 17 matching lines @@
     dst_argb += 32;
 
 
 #if defined(HAS_I422TOARGBROW_SSSE3)
 void I422ToARGBRow_SSSE3(const uint8* y_buf,
                          const uint8* u_buf,
                          const uint8* v_buf,
                          uint8* dst_argb,
                          struct YuvConstants* yuvconstants,
                          int width) {
-  __m128i xmm0, xmm1, xmm2, xmm3;
+  __m128i xmm0, xmm1, xmm2, xmm4;
   const __m128i xmm5 = _mm_set1_epi8(-1);
   const ptrdiff_t offset = (uint8*)v_buf - (uint8*)u_buf;
   while (width > 0) {
     READYUV422
-    YUVTORGB(YuvConstants)
+    YUVTORGB(yuvconstants)
     STOREARGB
     width -= 8;
   }
 }
 #endif
 
 #if defined(HAS_I422TOABGRROW_SSSE3)
 void I422ToABGRRow_SSSE3(const uint8* y_buf,
                          const uint8* u_buf,
                          const uint8* v_buf,
                          uint8* dst_argb,
                          struct YuvConstants* yuvconstants,
                          int width) {
-  __m128i xmm0, xmm1, xmm2, xmm3;
+  __m128i xmm0, xmm1, xmm2, xmm4;
   const __m128i xmm5 = _mm_set1_epi8(-1);
   const ptrdiff_t offset = (uint8*)v_buf - (uint8*)u_buf;
   while (width > 0) {
     READYUV422
-    YUVTORGB(YuvConstants)
+    YUVTORGB(yuvconstants)
     STOREABGR
     width -= 8;
   }
 }
 #endif
 // 32 bit
 #else  // defined(_M_X64)
 #ifdef HAS_ARGBTOYROW_SSSE3
 
 // Constants for ARGB.
@@ skipping 1717 matching lines @@
 #endif  // HAS_ARGBTOYROW_SSSE3
 
 // Read 16 UV from 444
 #define READYUV444_AVX2 __asm {                                                \
     __asm vmovdqu    xmm0, [esi]                  /* U */                      \
     __asm vmovdqu    xmm1, [esi + edi]            /* V */                      \
     __asm lea        esi,  [esi + 16]                                          \
     __asm vpermq     ymm0, ymm0, 0xd8                                          \
     __asm vpermq     ymm1, ymm1, 0xd8                                          \
     __asm vpunpcklbw ymm0, ymm0, ymm1             /* UV */                     \
+    __asm vmovdqu    xmm4, [eax]                  /* Y */                      \
+    __asm vpermq     ymm4, ymm4, 0xd8                                          \
+    __asm vpunpcklbw ymm4, ymm4, ymm4                                          \
+    __asm lea        eax, [eax + 16]                                           \
   }
 
 // Read 8 UV from 422, upsample to 16 UV.
 #define READYUV422_AVX2 __asm {                                                \
     __asm vmovq      xmm0, qword ptr [esi]        /* U */                      \
     __asm vmovq      xmm1, qword ptr [esi + edi]  /* V */                      \
     __asm lea        esi,  [esi + 8]                                           \
     __asm vpunpcklbw ymm0, ymm0, ymm1             /* UV */                     \
     __asm vpermq     ymm0, ymm0, 0xd8                                          \
     __asm vpunpcklwd ymm0, ymm0, ymm0             /* UVUV (upsample) */        \
+    __asm vmovdqu    xmm4, [eax]                  /* Y */                      \
+    __asm vpermq     ymm4, ymm4, 0xd8                                          \
+    __asm vpunpcklbw ymm4, ymm4, ymm4                                          \
+    __asm lea        eax, [eax + 16]                                           \
   }
 
 // Read 4 UV from 411, upsample to 16 UV.
 #define READYUV411_AVX2 __asm {                                                \
     __asm vmovd      xmm0, dword ptr [esi]        /* U */                      \
     __asm vmovd      xmm1, dword ptr [esi + edi]  /* V */                      \
     __asm lea        esi,  [esi + 4]                                           \
     __asm vpunpcklbw ymm0, ymm0, ymm1             /* UV */                     \
     __asm vpunpcklwd ymm0, ymm0, ymm0             /* UVUV (upsample) */        \
     __asm vpermq     ymm0, ymm0, 0xd8                                          \
     __asm vpunpckldq ymm0, ymm0, ymm0             /* UVUVUVUV (upsample) */    \
+    __asm vmovdqu    xmm4, [eax]                  /* Y */                      \
+    __asm vpermq     ymm4, ymm4, 0xd8                                          \
+    __asm vpunpcklbw ymm4, ymm4, ymm4                                          \
+    __asm lea        eax, [eax + 16]                                           \
   }
 
 // Read 8 UV from NV12, upsample to 16 UV.
 #define READNV12_AVX2 __asm {                                                  \
     __asm vmovdqu    xmm0, [esi]                  /* UV */                     \
     __asm lea        esi,  [esi + 16]                                          \
     __asm vpermq     ymm0, ymm0, 0xd8                                          \
     __asm vpunpcklwd ymm0, ymm0, ymm0             /* UVUV (upsample) */        \
+    __asm vmovdqu    xmm4, [eax]                  /* Y */                      \
+    __asm vpermq     ymm4, ymm4, 0xd8                                          \
+    __asm vpunpcklbw ymm4, ymm4, ymm4                                          \
+    __asm lea        eax, [eax + 16]                                           \
   }
 
 // Convert 16 pixels: 16 UV and 16 Y.
 #define YUVTORGB_AVX2(YuvConstants) __asm {                                    \
     __asm vpmaddubsw ymm2, ymm0, ymmword ptr [YuvConstants + KUVTOR] /* R UV */\
     __asm vpmaddubsw ymm1, ymm0, ymmword ptr [YuvConstants + KUVTOG] /* G UV */\
     __asm vpmaddubsw ymm0, ymm0, ymmword ptr [YuvConstants + KUVTOB] /* B UV */\
     __asm vmovdqu    ymm3, ymmword ptr [YuvConstants + KUVBIASR]               \
     __asm vpsubw     ymm2, ymm3, ymm2                                          \
     __asm vmovdqu    ymm3, ymmword ptr [YuvConstants + KUVBIASG]               \
     __asm vpsubw     ymm1, ymm3, ymm1                                          \
     __asm vmovdqu    ymm3, ymmword ptr [YuvConstants + KUVBIASB]               \
     __asm vpsubw     ymm0, ymm3, ymm0                                          \
     /* Step 2: Find Y contribution to 16 R,G,B values */                       \
-    __asm vmovdqu    xmm3, [eax]                                               \
-    __asm lea        eax, [eax + 16]                                           \
-    __asm vpermq     ymm3, ymm3, 0xd8                                          \
-    __asm vpunpcklbw ymm3, ymm3, ymm3                                          \
-    __asm vpmulhuw   ymm3, ymm3, ymmword ptr [YuvConstants + KYTORGB]          \
-    __asm vpaddsw    ymm0, ymm0, ymm3           /* B += Y */                   \
-    __asm vpaddsw    ymm1, ymm1, ymm3           /* G += Y */                   \
-    __asm vpaddsw    ymm2, ymm2, ymm3           /* R += Y */                   \
+    __asm vpmulhuw   ymm4, ymm4, ymmword ptr [YuvConstants + KYTORGB]          \
+    __asm vpaddsw    ymm0, ymm0, ymm4           /* B += Y */                   \
+    __asm vpaddsw    ymm1, ymm1, ymm4           /* G += Y */                   \
+    __asm vpaddsw    ymm2, ymm2, ymm4           /* R += Y */                   \
     __asm vpsraw     ymm0, ymm0, 6                                             \
     __asm vpsraw     ymm1, ymm1, 6                                             \
     __asm vpsraw     ymm2, ymm2, 6                                             \
     __asm vpackuswb  ymm0, ymm0, ymm0           /* B */                        \
     __asm vpackuswb  ymm1, ymm1, ymm1           /* G */                        \
     __asm vpackuswb  ymm2, ymm2, ymm2           /* R */                        \
   }
 
 // Store 16 ARGB values.
 #define STOREARGB_AVX2 __asm {                                                 \
@@ skipping 58 matching lines @@
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
     push       edi
     push       ebp
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // YuvConstants
+    mov        ebp, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
 
  convertloop:
     READYUV422_AVX2
     YUVTORGB_AVX2(ebp)
     STOREARGB_AVX2
 
     sub        ecx, 16
@@ skipping 19 matching lines @@
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
     push       edi
     push       ebp
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // YuvConstants
+    mov        ebp, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
  convertloop:
     READYUV444_AVX2
     YUVTORGB_AVX2(ebp)
     STOREARGB_AVX2
 
     sub        ecx, 16
     jg         convertloop
@@ skipping 18 matching lines @@
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
     push       edi
     push       ebp
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // abgr
-    mov        ebp, [esp + 12 + 20]  // YuvConstants
+    mov        ebp, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
  convertloop:
     READYUV444_AVX2
     YUVTORGB_AVX2(ebp)
     STOREABGR_AVX2
 
     sub        ecx, 16
     jg         convertloop
@@ skipping 18 matching lines @@
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
     push       edi
     push       ebp
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // abgr
-    mov        ebp, [esp + 12 + 20]  // YuvConstants
+    mov        ebp, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
 
  convertloop:
     READYUV411_AVX2
     YUVTORGB_AVX2(ebp)
     STOREARGB_AVX2
 
     sub        ecx, 16
@@ skipping 16 matching lines @@
                         const uint8* uv_buf,
                         uint8* dst_argb,
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
     push       ebp
     mov        eax, [esp + 8 + 4]   // Y
     mov        esi, [esp + 8 + 8]   // UV
     mov        edx, [esp + 8 + 12]  // argb
-    mov        ebp, [esp + 8 + 16]  // YuvConstants
+    mov        ebp, [esp + 8 + 16]  // yuvconstants
     mov        ecx, [esp + 8 + 20]  // width
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
 
  convertloop:
     READNV12_AVX2
     YUVTORGB_AVX2(ebp)
     STOREARGB_AVX2
 
     sub        ecx, 16
     jg         convertloop
@@ skipping 18 matching lines @@
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
     push       edi
     push       ebp
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // abgr
-    mov        ebp, [esp + 12 + 20]  // YuvConstants
+    mov        ebp, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
 
  convertloop:
     READYUV422_AVX2
     YUVTORGB_AVX2(ebp)
     STOREBGRA_AVX2
 
     sub        ecx, 16
@@ skipping 19 matching lines @@
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
     push       edi
     push       ebp
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // abgr
-    mov        ebp, [esp + 12 + 20]  // YuvConstants
+    mov        ebp, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
 
  convertloop:
     READYUV422_AVX2
     YUVTORGB_AVX2(ebp)
     STORERGBA_AVX2
 
     sub        ecx, 16
@@ skipping 19 matching lines @@
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
     push       edi
     push       ebp
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // YuvConstants
+    mov        ebp, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha
 
  convertloop:
     READYUV422_AVX2
     YUVTORGB_AVX2(ebp)
     STOREABGR_AVX2
 
     sub        ecx, 16
@@ skipping 10 matching lines @@
 
 #if defined(HAS_I422TOARGBROW_SSSE3)
 // TODO(fbarchard): Read that does half size on Y and treats 420 as 444.
 
 // Read 8 UV from 444.
 #define READYUV444 __asm {                                                     \
     __asm movq       xmm0, qword ptr [esi] /* U */                             \
     __asm movq       xmm1, qword ptr [esi + edi] /* V */                       \
     __asm lea        esi,  [esi + 8]                                           \
     __asm punpcklbw  xmm0, xmm1           /* UV */                             \
+    __asm movq       xmm4, qword ptr [eax]                                     \
+    __asm punpcklbw  xmm4, xmm4                                                \
+    __asm lea        eax, [eax + 8]                                            \
   }
 
 // Read 4 UV from 422, upsample to 8 UV.
 #define READYUV422 __asm {                                                     \
     __asm movd       xmm0, [esi]          /* U */                              \
     __asm movd       xmm1, [esi + edi]    /* V */                              \
     __asm lea        esi,  [esi + 4]                                           \
     __asm punpcklbw  xmm0, xmm1           /* UV */                             \
     __asm punpcklwd  xmm0, xmm0           /* UVUV (upsample) */                \
+    __asm movq       xmm4, qword ptr [eax]                                     \
+    __asm punpcklbw  xmm4, xmm4                                                \
+    __asm lea        eax, [eax + 8]                                            \
   }
 
 // Read 2 UV from 411, upsample to 8 UV.
 #define READYUV411 __asm {                                                     \
     __asm pinsrw     xmm0, [esi], 0        /* U */                             \
     __asm pinsrw     xmm1, [esi + edi], 0  /* V */                             \
     __asm lea        esi,  [esi + 2]                                           \
     __asm punpcklbw  xmm0, xmm1            /* UV */                            \
     __asm punpcklwd  xmm0, xmm0            /* UVUV (upsample) */               \
     __asm punpckldq  xmm0, xmm0            /* UVUVUVUV (upsample) */           \
+    __asm movq       xmm4, qword ptr [eax]                                     \
+    __asm punpcklbw  xmm4, xmm4                                                \
+    __asm lea        eax, [eax + 8]                                            \
   }
 
 // Read 4 UV from NV12, upsample to 8 UV.
 #define READNV12 __asm {                                                       \
     __asm movq       xmm0, qword ptr [esi] /* UV */                            \
     __asm lea        esi,  [esi + 8]                                           \
     __asm punpcklwd  xmm0, xmm0           /* UVUV (upsample) */                \
+    __asm movq       xmm4, qword ptr [eax]                                     \
+    __asm punpcklbw  xmm4, xmm4                                                \
+    __asm lea        eax, [eax + 8]                                            \
+  }
+
+// YUY2 shuf 8 Y to 16 Y.
+static const vec8 kShuffleYUY2Y = {
+  0, 0, 2, 2, 4, 4, 6, 6, 8, 8, 10, 10, 12, 12, 14, 14
+};
+
+// YUY2 shuf 4 UV to 8 UV.
+static const vec8 kShuffleYUY2UV = {
+  1, 3, 1, 3, 5, 7, 5, 7, 9, 11, 9, 11, 13, 15, 13, 15
+};
+
+// Read 4 YUY2 with 8 Y and update 4 UV to 8 UV.
+#define READYUY2 __asm {                                                       \
+    __asm movdqu     xmm4, [eax]          /* YUY2 */                           \
+    __asm pshufb     xmm4, xmmword ptr kShuffleYUY2Y                           \
+    __asm movdqu     xmm0, [eax]          /* UV */                             \
+    __asm pshufb     xmm0, xmmword ptr kShuffleYUY2UV                          \
+    __asm lea        eax, [eax + 16]                                           \
+  }
+
+// UYVY shuf 8 Y to 16 Y.
+static const vec8 kShuffleUYVYY = {
+  1, 1, 3, 3, 5, 5, 7, 7, 9, 9, 11, 11, 13, 13, 15, 15
+};
+
+// UYVY shuf 4 UV to 8 UV.
+static const vec8 kShuffleUYVYUV = {
+  0, 2, 0, 2, 4, 6, 4, 6, 8, 10, 8, 10, 12, 14, 12, 14
+};
+
+// Read 4 UYVY with 8 Y and update 4 UV to 8 UV.
+#define READUYVY __asm {                                                       \
+    __asm movdqu     xmm4, [eax]          /* UYVY */                           \
+    __asm pshufb     xmm4, xmmword ptr kShuffleUYVYY                           \
+    __asm movdqu     xmm0, [eax]          /* UV */                             \
+    __asm pshufb     xmm0, xmmword ptr kShuffleUYVYUV                          \
+    __asm lea        eax, [eax + 16]                                           \
   }
 
 // Convert 8 pixels: 8 UV and 8 Y.
 #define YUVTORGB(YuvConstants) __asm {                                         \
     __asm movdqa     xmm1, xmm0                                                \
     __asm movdqa     xmm2, xmm0                                                \
     __asm movdqa     xmm3, xmm0                                                \
     __asm movdqa     xmm0, xmmword ptr [YuvConstants + KUVBIASB]               \
     __asm pmaddubsw  xmm1, xmmword ptr [YuvConstants + KUVTOB]                 \
     __asm psubw      xmm0, xmm1                                                \
     __asm movdqa     xmm1, xmmword ptr [YuvConstants + KUVBIASG]               \
     __asm pmaddubsw  xmm2, xmmword ptr [YuvConstants + KUVTOG]                 \
     __asm psubw      xmm1, xmm2                                                \
     __asm movdqa     xmm2, xmmword ptr [YuvConstants + KUVBIASR]               \
     __asm pmaddubsw  xmm3, xmmword ptr [YuvConstants + KUVTOR]                 \
     __asm psubw      xmm2, xmm3                                                \
-    __asm movq       xmm3, qword ptr [eax]                                     \
-    __asm lea        eax, [eax + 8]                                            \
-    __asm punpcklbw  xmm3, xmm3                                                \
-    __asm pmulhuw    xmm3, xmmword ptr [YuvConstants + KYTORGB]                \
-    __asm paddsw     xmm0, xmm3           /* B += Y */                         \
-    __asm paddsw     xmm1, xmm3           /* G += Y */                         \
-    __asm paddsw     xmm2, xmm3           /* R += Y */                         \
+    __asm pmulhuw    xmm4, xmmword ptr [YuvConstants + KYTORGB]                \
+    __asm paddsw     xmm0, xmm4           /* B += Y */                         \
+    __asm paddsw     xmm1, xmm4           /* G += Y */                         \
+    __asm paddsw     xmm2, xmm4           /* R += Y */                         \
     __asm psraw      xmm0, 6                                                   \
     __asm psraw      xmm1, 6                                                   \
     __asm psraw      xmm2, 6                                                   \
     __asm packuswb   xmm0, xmm0           /* B */                              \
     __asm packuswb   xmm1, xmm1           /* G */                              \
     __asm packuswb   xmm2, xmm2           /* R */                              \
   }
 
 // Store 8 ARGB values.
 #define STOREARGB __asm {                                                      \
@@ skipping 125 matching lines @@
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
     push       esi
     push       edi
     push       ebp
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // YuvConstants
+    mov        ebp, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     pcmpeqb    xmm5, xmm5            // generate 0xffffffff for alpha
 
  convertloop:
     READYUV444
     YUVTORGB(ebp)
     STOREARGB
 
     sub        ecx, 8
@@ skipping 16 matching lines @@
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
     push       esi
     push       edi
     push       ebp
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // abgr
-    mov        ebp, [esp + 12 + 20]  // YuvConstants
+    mov        ebp, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     pcmpeqb    xmm5, xmm5            // generate 0xffffffff for alpha
 
  convertloop:
     READYUV444
     YUVTORGB(ebp)
     STOREABGR
 
     sub        ecx, 8
@@ skipping 16 matching lines @@
                           struct YuvConstants* yuvconstants,
                           int width) {
   __asm {
     push       esi
     push       edi
     push       ebp
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // YuvConstants
+    mov        ebp, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     movdqa     xmm5, xmmword ptr kShuffleMaskARGBToRGB24_0
     movdqa     xmm6, xmmword ptr kShuffleMaskARGBToRGB24
 
  convertloop:
     READYUV422
     YUVTORGB(ebp)
     STORERGB24
 
@@ skipping 17 matching lines @@
                         struct YuvConstants* yuvconstants,
                         int width) {
   __asm {
     push       esi
     push       edi
     push       ebp
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // YuvConstants
+    mov        ebp, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     movdqa     xmm5, xmmword ptr kShuffleMaskARGBToRAW_0
     movdqa     xmm6, xmmword ptr kShuffleMaskARGBToRAW
 
  convertloop:
     READYUV422
     YUVTORGB(ebp)
     STORERAW
 
@@ skipping 17 matching lines @@
                            struct YuvConstants* yuvconstants,
                            int width) {
   __asm {
     push       esi
     push       edi
     push       ebp
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // YuvConstants
+    mov        ebp, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     pcmpeqb    xmm5, xmm5       // generate mask 0x0000001f
     psrld      xmm5, 27
     pcmpeqb    xmm6, xmm6       // generate mask 0x000007e0
     psrld      xmm6, 26
     pslld      xmm6, 5
     pcmpeqb    xmm7, xmm7       // generate mask 0xfffff800
     pslld      xmm7, 11
 
@@ skipping 22 matching lines @@
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
     push       esi
     push       edi
     push       ebp
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // YuvConstants
+    mov        ebp, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     pcmpeqb    xmm5, xmm5           // generate 0xffffffff for alpha
 
  convertloop:
     READYUV422
     YUVTORGB(ebp)
     STOREARGB
 
     sub        ecx, 8
@@ skipping 17 matching lines @@
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
     push       esi
     push       edi
     push       ebp
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // abgr
-    mov        ebp, [esp + 12 + 20]  // YuvConstants
+    mov        ebp, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     pcmpeqb    xmm5, xmm5            // generate 0xffffffff for alpha
 
  convertloop:
     READYUV411
     YUVTORGB(ebp)
     STOREARGB
 
     sub        ecx, 8
@@ skipping 13 matching lines @@
                          const uint8* uv_buf,
                          uint8* dst_argb,
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
     push       esi
     push       ebp
     mov        eax, [esp + 8 + 4]   // Y
     mov        esi, [esp + 8 + 8]   // UV
     mov        edx, [esp + 8 + 12]  // argb
-    mov        ebp, [esp + 8 + 16]  // YuvConstants
+    mov        ebp, [esp + 8 + 16]  // yuvconstants
     mov        ecx, [esp + 8 + 20]  // width
     pcmpeqb    xmm5, xmm5           // generate 0xffffffff for alpha
 
  convertloop:
     READNV12
     YUVTORGB(ebp)
     STOREARGB
 
     sub        ecx, 8
     jg         convertloop
 
     pop        ebp
     pop        esi
     ret
   }
 }
 
+// 8 pixels.
+// 4 YUY2 values with 8 Y and 4 UV producing 8 ARGB (32 bytes).
+__declspec(naked)
+void YUY2ToARGBRow_SSSE3(const uint8* src_yuy2,
+                         uint8* dst_argb,
+                         struct YuvConstants* yuvconstants,
+                         int width) {
+  __asm {
+    push       ebp
+    mov        eax, [esp + 4 + 4]   // yuy2
+    mov        edx, [esp + 4 + 8]   // argb
+    mov        ebp, [esp + 4 + 12]  // yuvconstants
+    mov        ecx, [esp + 4 + 16]  // width
+    pcmpeqb    xmm5, xmm5           // generate 0xffffffff for alpha
+
+ convertloop:
+    READYUY2
+    YUVTORGB(ebp)
+    STOREARGB
+
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        ebp
+    ret
+  }
+}
+
+// 8 pixels.
+// 4 UYVY values with 8 Y and 4 UV producing 8 ARGB (32 bytes).
+__declspec(naked)
+void UYVYToARGBRow_SSSE3(const uint8* src_uyvy,
+                         uint8* dst_argb,
+                         struct YuvConstants* yuvconstants,
+                         int width) {
+  __asm {
+    push       ebp
+    mov        eax, [esp + 4 + 4]   // uyvy
+    mov        edx, [esp + 4 + 8]   // argb
+    mov        ebp, [esp + 4 + 12]  // yuvconstants
+    mov        ecx, [esp + 4 + 16]  // width
+    pcmpeqb    xmm5, xmm5           // generate 0xffffffff for alpha
+
+ convertloop:
+    READUYVY
+    YUVTORGB(ebp)
+    STOREARGB
+
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        ebp
+    ret
+  }
+}
+
 __declspec(naked)
 void I422ToBGRARow_SSSE3(const uint8* y_buf,
                          const uint8* u_buf,
                          const uint8* v_buf,
                          uint8* dst_bgra,
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
     push       esi
     push       edi
     push       ebp
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // YuvConstants
+    mov        ebp, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
 
  convertloop:
     READYUV422
     YUVTORGB(ebp)
     STOREBGRA
 
     sub        ecx, 8
     jg         convertloop
@@ skipping 13 matching lines @@
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
     push       esi
     push       edi
     push       ebp
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // YuvConstants
+    mov        ebp, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
     pcmpeqb    xmm5, xmm5           // generate 0xffffffff for alpha
 
  convertloop:
     READYUV422
     YUVTORGB(ebp)
     STOREABGR
 
     sub        ecx, 8
@@ skipping 14 matching lines @@
                          struct YuvConstants* yuvconstants,
                          int width) {
   __asm {
     push       esi
     push       edi
     push       ebp
     mov        eax, [esp + 12 + 4]   // Y
     mov        esi, [esp + 12 + 8]   // U
     mov        edi, [esp + 12 + 12]  // V
     mov        edx, [esp + 12 + 16]  // argb
-    mov        ebp, [esp + 12 + 20]  // YuvConstants
+    mov        ebp, [esp + 12 + 20]  // yuvconstants
     mov        ecx, [esp + 12 + 24]  // width
     sub        edi, esi
 
  convertloop:
     READYUV422
     YUVTORGB(ebp)
     STORERGBA
 
     sub        ecx, 8
     jg         convertloop
@@ skipping 644 matching lines @@
     mov        ecx, [esp + 12]  // count
     rep stosd
     mov        edi, edx
     ret
   }
 }
 #endif  // HAS_SETROW_X86
 
 #ifdef HAS_YUY2TOYROW_AVX2
 __declspec(naked)
-void YUY2ToYRow_AVX2(const uint8* src_yuy2,
-                     uint8* dst_y, int pix) {
+void YUY2ToYRow_AVX2(const uint8* src_yuy2, uint8* dst_y, int pix) {
   __asm {
     mov        eax, [esp + 4]    // src_yuy2
     mov        edx, [esp + 8]    // dst_y
     mov        ecx, [esp + 12]   // pix
     vpcmpeqb   ymm5, ymm5, ymm5  // generate mask 0x00ff00ff
     vpsrlw     ymm5, ymm5, 8
 
   convertloop:
     vmovdqu    ymm0, [eax]
     vmovdqu    ymm1, [eax + 32]
@@ skipping 2733 matching lines @@
 }
 #endif  // HAS_ARGBLUMACOLORTABLEROW_SSSE3
 
 #endif  // defined(_M_X64)
 #endif  // !defined(LIBYUV_DISABLE_X86) && (defined(_M_IX86) || defined(_M_X64))
 
 #ifdef __cplusplus
 }  // extern "C"
 }  // namespace libyuv
 #endif