The Tor Browser / file revision

 /*

  *  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.

  */

 #include "libyuv/row.h"

 #ifdef __cplusplus

 namespace libyuv {

 extern "C" {

 #endif

 // This module is for Visual C x86.

 #if !defined(LIBYUV_DISABLE_X86) && defined(_M_IX86) && defined(_MSC_VER)

 #ifdef HAS_ARGBTOYROW_SSSE3

 // Constants for ARGB.

 static const vec8 kARGBToY = {

   13, 65, 33, 0, 13, 65, 33, 0, 13, 65, 33, 0, 13, 65, 33, 0

 };

 // JPeg full range.

 static const vec8 kARGBToYJ = {

   15, 75, 38, 0, 15, 75, 38, 0, 15, 75, 38, 0, 15, 75, 38, 0

 };

 static const vec8 kARGBToU = {

   112, -74, -38, 0, 112, -74, -38, 0, 112, -74, -38, 0, 112, -74, -38, 0

 };

 static const vec8 kARGBToUJ = {

   127, -84, -43, 0, 127, -84, -43, 0, 127, -84, -43, 0, 127, -84, -43, 0

 };

 static const vec8 kARGBToV = {

   -18, -94, 112, 0, -18, -94, 112, 0, -18, -94, 112, 0, -18, -94, 112, 0,

 };

 static const vec8 kARGBToVJ = {

   -20, -107, 127, 0, -20, -107, 127, 0, -20, -107, 127, 0, -20, -107, 127, 0

 };

 // vpermd for vphaddw + vpackuswb vpermd.

 static const lvec32 kPermdARGBToY_AVX = {

   0, 4, 1, 5, 2, 6, 3, 7

 };

 // vpshufb for vphaddw + vpackuswb packed to shorts.

 static const lvec8 kShufARGBToUV_AVX = {

   0, 1, 8, 9, 2, 3, 10, 11, 4, 5, 12, 13, 6, 7, 14, 15,

   0, 1, 8, 9, 2, 3, 10, 11, 4, 5, 12, 13, 6, 7, 14, 15,

 };

 // Constants for BGRA.

 static const vec8 kBGRAToY = {

   0, 33, 65, 13, 0, 33, 65, 13, 0, 33, 65, 13, 0, 33, 65, 13

 };

 static const vec8 kBGRAToU = {

   0, -38, -74, 112, 0, -38, -74, 112, 0, -38, -74, 112, 0, -38, -74, 112

 };

 static const vec8 kBGRAToV = {

   0, 112, -94, -18, 0, 112, -94, -18, 0, 112, -94, -18, 0, 112, -94, -18

 };

 // Constants for ABGR.

 static const vec8 kABGRToY = {

   33, 65, 13, 0, 33, 65, 13, 0, 33, 65, 13, 0, 33, 65, 13, 0

 };

 static const vec8 kABGRToU = {

   -38, -74, 112, 0, -38, -74, 112, 0, -38, -74, 112, 0, -38, -74, 112, 0

 };

 static const vec8 kABGRToV = {

   112, -94, -18, 0, 112, -94, -18, 0, 112, -94, -18, 0, 112, -94, -18, 0

 };

 // Constants for RGBA.

 static const vec8 kRGBAToY = {

   0, 13, 65, 33, 0, 13, 65, 33, 0, 13, 65, 33, 0, 13, 65, 33

 };

 static const vec8 kRGBAToU = {

   0, 112, -74, -38, 0, 112, -74, -38, 0, 112, -74, -38, 0, 112, -74, -38

 };

 static const vec8 kRGBAToV = {

   0, -18, -94, 112, 0, -18, -94, 112, 0, -18, -94, 112, 0, -18, -94, 112

 };

 static const uvec8 kAddY16 = {

   16u, 16u, 16u, 16u, 16u, 16u, 16u, 16u, 16u, 16u, 16u, 16u, 16u, 16u, 16u, 16u

 };

 static const vec16 kAddYJ64 = {

   64, 64, 64, 64, 64, 64, 64, 64

 };

 static const uvec8 kAddUV128 = {

   128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u,

   128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u

 };

 static const uvec16 kAddUVJ128 = {

   0x8080u, 0x8080u, 0x8080u, 0x8080u, 0x8080u, 0x8080u, 0x8080u, 0x8080u

 };

 // Shuffle table for converting RGB24 to ARGB.

 static const uvec8 kShuffleMaskRGB24ToARGB = {

   0u, 1u, 2u, 12u, 3u, 4u, 5u, 13u, 6u, 7u, 8u, 14u, 9u, 10u, 11u, 15u

 };

 // Shuffle table for converting RAW to ARGB.

 static const uvec8 kShuffleMaskRAWToARGB = {

   2u, 1u, 0u, 12u, 5u, 4u, 3u, 13u, 8u, 7u, 6u, 14u, 11u, 10u, 9u, 15u

 };

 // Shuffle table for converting ARGB to RGB24.

 static const uvec8 kShuffleMaskARGBToRGB24 = {

   0u, 1u, 2u, 4u, 5u, 6u, 8u, 9u, 10u, 12u, 13u, 14u, 128u, 128u, 128u, 128u

 };

 // Shuffle table for converting ARGB to RAW.

 static const uvec8 kShuffleMaskARGBToRAW = {

   2u, 1u, 0u, 6u, 5u, 4u, 10u, 9u, 8u, 14u, 13u, 12u, 128u, 128u, 128u, 128u

 };

 // Shuffle table for converting ARGBToRGB24 for I422ToRGB24.  First 8 + next 4

 static const uvec8 kShuffleMaskARGBToRGB24_0 = {

   0u, 1u, 2u, 4u, 5u, 6u, 8u, 9u, 128u, 128u, 128u, 128u, 10u, 12u, 13u, 14u

 };

 // Shuffle table for converting ARGB to RAW.

 static const uvec8 kShuffleMaskARGBToRAW_0 = {

   2u, 1u, 0u, 6u, 5u, 4u, 10u, 9u, 128u, 128u, 128u, 128u, 8u, 14u, 13u, 12u

 };

 // Duplicates gray value 3 times and fills in alpha opaque.

 __declspec(naked) __declspec(align(16))

 void I400ToARGBRow_SSE2(const uint8* src_y, uint8* dst_argb, int pix) {

   __asm {

     mov        eax, [esp + 4]        // src_y

     mov        edx, [esp + 8]        // dst_argb

     mov        ecx, [esp + 12]       // pix

     pcmpeqb    xmm5, xmm5            // generate mask 0xff000000

     pslld      xmm5, 24

     align      4

   convertloop:

     movq       xmm0, qword ptr [eax]

     lea        eax,  [eax + 8]

     punpcklbw  xmm0, xmm0

     movdqa     xmm1, xmm0

     punpcklwd  xmm0, xmm0

     punpckhwd  xmm1, xmm1

     por        xmm0, xmm5

     por        xmm1, xmm5

     movdqa     [edx], xmm0

     movdqa     [edx + 16], xmm1

     lea        edx, [edx + 32]

     sub        ecx, 8

     jg         convertloop

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void I400ToARGBRow_Unaligned_SSE2(const uint8* src_y, uint8* dst_argb,

                                   int pix) {

   __asm {

     mov        eax, [esp + 4]        // src_y

     mov        edx, [esp + 8]        // dst_argb

     mov        ecx, [esp + 12]       // pix

     pcmpeqb    xmm5, xmm5            // generate mask 0xff000000

     pslld      xmm5, 24

     align      4

   convertloop:

     movq       xmm0, qword ptr [eax]

     lea        eax,  [eax + 8]

     punpcklbw  xmm0, xmm0

     movdqa     xmm1, xmm0

     punpcklwd  xmm0, xmm0

     punpckhwd  xmm1, xmm1

     por        xmm0, xmm5

     por        xmm1, xmm5

     movdqu     [edx], xmm0

     movdqu     [edx + 16], xmm1

     lea        edx, [edx + 32]

     sub        ecx, 8

     jg         convertloop

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void RGB24ToARGBRow_SSSE3(const uint8* src_rgb24, uint8* dst_argb, int pix) {

   __asm {

     mov       eax, [esp + 4]   // src_rgb24

     mov       edx, [esp + 8]   // dst_argb

     mov       ecx, [esp + 12]  // pix

     pcmpeqb   xmm5, xmm5       // generate mask 0xff000000

     pslld     xmm5, 24

     movdqa    xmm4, kShuffleMaskRGB24ToARGB

     align      4

  convertloop:

     movdqu    xmm0, [eax]

     movdqu    xmm1, [eax + 16]

     movdqu    xmm3, [eax + 32]

     lea       eax, [eax + 48]

     movdqa    xmm2, xmm3

     palignr   xmm2, xmm1, 8    // xmm2 = { xmm3[0:3] xmm1[8:15]}

     pshufb    xmm2, xmm4

     por       xmm2, xmm5

     palignr   xmm1, xmm0, 12   // xmm1 = { xmm3[0:7] xmm0[12:15]}

     pshufb    xmm0, xmm4

     movdqa    [edx + 32], xmm2

     por       xmm0, xmm5

     pshufb    xmm1, xmm4

     movdqa    [edx], xmm0

     por       xmm1, xmm5

     palignr   xmm3, xmm3, 4    // xmm3 = { xmm3[4:15]}

     pshufb    xmm3, xmm4

     movdqa    [edx + 16], xmm1

     por       xmm3, xmm5

     sub       ecx, 16

     movdqa    [edx + 48], xmm3

     lea       edx, [edx + 64]

     jg        convertloop

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void RAWToARGBRow_SSSE3(const uint8* src_raw, uint8* dst_argb,

                         int pix) {

   __asm {

     mov       eax, [esp + 4]   // src_raw

     mov       edx, [esp + 8]   // dst_argb

     mov       ecx, [esp + 12]  // pix

     pcmpeqb   xmm5, xmm5       // generate mask 0xff000000

     pslld     xmm5, 24

     movdqa    xmm4, kShuffleMaskRAWToARGB

     align      4

  convertloop:

     movdqu    xmm0, [eax]

     movdqu    xmm1, [eax + 16]

     movdqu    xmm3, [eax + 32]

     lea       eax, [eax + 48]

     movdqa    xmm2, xmm3

     palignr   xmm2, xmm1, 8    // xmm2 = { xmm3[0:3] xmm1[8:15]}

     pshufb    xmm2, xmm4

     por       xmm2, xmm5

     palignr   xmm1, xmm0, 12   // xmm1 = { xmm3[0:7] xmm0[12:15]}

     pshufb    xmm0, xmm4

     movdqa    [edx + 32], xmm2

     por       xmm0, xmm5

     pshufb    xmm1, xmm4

     movdqa    [edx], xmm0

     por       xmm1, xmm5

     palignr   xmm3, xmm3, 4    // xmm3 = { xmm3[4:15]}

     pshufb    xmm3, xmm4

     movdqa    [edx + 16], xmm1

     por       xmm3, xmm5

     sub       ecx, 16

     movdqa    [edx + 48], xmm3

     lea       edx, [edx + 64]

     jg        convertloop

     ret

   }

 }

 // pmul method to replicate bits.

 // Math to replicate bits:

 // (v << 8) | (v << 3)

 // v * 256 + v * 8

 // v * (256 + 8)

 // G shift of 5 is incorporated, so shift is 5 + 8 and 5 + 3

 // 20 instructions.

 __declspec(naked) __declspec(align(16))

 void RGB565ToARGBRow_SSE2(const uint8* src_rgb565, uint8* dst_argb,

                           int pix) {

   __asm {

     mov       eax, 0x01080108  // generate multiplier to repeat 5 bits

     movd      xmm5, eax

     pshufd    xmm5, xmm5, 0

     mov       eax, 0x20802080  // multiplier shift by 5 and then repeat 6 bits

     movd      xmm6, eax

     pshufd    xmm6, xmm6, 0

     pcmpeqb   xmm3, xmm3       // generate mask 0xf800f800 for Red

     psllw     xmm3, 11

     pcmpeqb   xmm4, xmm4       // generate mask 0x07e007e0 for Green

     psllw     xmm4, 10

     psrlw     xmm4, 5

     pcmpeqb   xmm7, xmm7       // generate mask 0xff00ff00 for Alpha

     psllw     xmm7, 8

     mov       eax, [esp + 4]   // src_rgb565

     mov       edx, [esp + 8]   // dst_argb

     mov       ecx, [esp + 12]  // pix

     sub       edx, eax

     sub       edx, eax

     align      4

  convertloop:

     movdqu    xmm0, [eax]   // fetch 8 pixels of bgr565

     movdqa    xmm1, xmm0

     movdqa    xmm2, xmm0

     pand      xmm1, xmm3    // R in upper 5 bits

     psllw     xmm2, 11      // B in upper 5 bits

     pmulhuw   xmm1, xmm5    // * (256 + 8)

     pmulhuw   xmm2, xmm5    // * (256 + 8)

     psllw     xmm1, 8

     por       xmm1, xmm2    // RB

     pand      xmm0, xmm4    // G in middle 6 bits

     pmulhuw   xmm0, xmm6    // << 5 * (256 + 4)

     por       xmm0, xmm7    // AG

     movdqa    xmm2, xmm1

     punpcklbw xmm1, xmm0

     punpckhbw xmm2, xmm0

     movdqa    [eax * 2 + edx], xmm1  // store 4 pixels of ARGB

     movdqa    [eax * 2 + edx + 16], xmm2  // store next 4 pixels of ARGB

     lea       eax, [eax + 16]

     sub       ecx, 8

     jg        convertloop

     ret

   }

 }

 // 24 instructions

 __declspec(naked) __declspec(align(16))

 void ARGB1555ToARGBRow_SSE2(const uint8* src_argb1555, uint8* dst_argb,

                             int pix) {

   __asm {

     mov       eax, 0x01080108  // generate multiplier to repeat 5 bits

     movd      xmm5, eax

     pshufd    xmm5, xmm5, 0

     mov       eax, 0x42004200  // multiplier shift by 6 and then repeat 5 bits

     movd      xmm6, eax

     pshufd    xmm6, xmm6, 0

     pcmpeqb   xmm3, xmm3       // generate mask 0xf800f800 for Red

     psllw     xmm3, 11

     movdqa    xmm4, xmm3       // generate mask 0x03e003e0 for Green

     psrlw     xmm4, 6

     pcmpeqb   xmm7, xmm7       // generate mask 0xff00ff00 for Alpha

     psllw     xmm7, 8

     mov       eax, [esp + 4]   // src_argb1555

     mov       edx, [esp + 8]   // dst_argb

     mov       ecx, [esp + 12]  // pix

     sub       edx, eax

     sub       edx, eax

     align      4

  convertloop:

     movdqu    xmm0, [eax]   // fetch 8 pixels of 1555

     movdqa    xmm1, xmm0

     movdqa    xmm2, xmm0

     psllw     xmm1, 1       // R in upper 5 bits

     psllw     xmm2, 11      // B in upper 5 bits

     pand      xmm1, xmm3

     pmulhuw   xmm2, xmm5    // * (256 + 8)

     pmulhuw   xmm1, xmm5    // * (256 + 8)

     psllw     xmm1, 8

     por       xmm1, xmm2    // RB

     movdqa    xmm2, xmm0

     pand      xmm0, xmm4    // G in middle 5 bits

     psraw     xmm2, 8       // A

     pmulhuw   xmm0, xmm6    // << 6 * (256 + 8)

     pand      xmm2, xmm7

     por       xmm0, xmm2    // AG

     movdqa    xmm2, xmm1

     punpcklbw xmm1, xmm0

     punpckhbw xmm2, xmm0

     movdqa    [eax * 2 + edx], xmm1  // store 4 pixels of ARGB

     movdqa    [eax * 2 + edx + 16], xmm2  // store next 4 pixels of ARGB

     lea       eax, [eax + 16]

     sub       ecx, 8

     jg        convertloop

     ret

   }

 }

 // 18 instructions.

 __declspec(naked) __declspec(align(16))

 void ARGB4444ToARGBRow_SSE2(const uint8* src_argb4444, uint8* dst_argb,

                             int pix) {

   __asm {

     mov       eax, 0x0f0f0f0f  // generate mask 0x0f0f0f0f

     movd      xmm4, eax

     pshufd    xmm4, xmm4, 0

     movdqa    xmm5, xmm4       // 0xf0f0f0f0 for high nibbles

     pslld     xmm5, 4

     mov       eax, [esp + 4]   // src_argb4444

     mov       edx, [esp + 8]   // dst_argb

     mov       ecx, [esp + 12]  // pix

     sub       edx, eax

     sub       edx, eax

     align      4

  convertloop:

     movdqu    xmm0, [eax]   // fetch 8 pixels of bgra4444

     movdqa    xmm2, xmm0

     pand      xmm0, xmm4    // mask low nibbles

     pand      xmm2, xmm5    // mask high nibbles

     movdqa    xmm1, xmm0

     movdqa    xmm3, xmm2

     psllw     xmm1, 4

     psrlw     xmm3, 4

     por       xmm0, xmm1

     por       xmm2, xmm3

     movdqa    xmm1, xmm0

     punpcklbw xmm0, xmm2

     punpckhbw xmm1, xmm2

     movdqa    [eax * 2 + edx], xmm0  // store 4 pixels of ARGB

     movdqa    [eax * 2 + edx + 16], xmm1  // store next 4 pixels of ARGB

     lea       eax, [eax + 16]

     sub       ecx, 8

     jg        convertloop

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void ARGBToRGB24Row_SSSE3(const uint8* src_argb, uint8* dst_rgb, int pix) {

   __asm {

     mov       eax, [esp + 4]   // src_argb

     mov       edx, [esp + 8]   // dst_rgb

     mov       ecx, [esp + 12]  // pix

     movdqa    xmm6, kShuffleMaskARGBToRGB24

     align      4

  convertloop:

     movdqu    xmm0, [eax]   // fetch 16 pixels of argb

     movdqu    xmm1, [eax + 16]

     movdqu    xmm2, [eax + 32]

     movdqu    xmm3, [eax + 48]

     lea       eax, [eax + 64]

     pshufb    xmm0, xmm6    // pack 16 bytes of ARGB to 12 bytes of RGB

     pshufb    xmm1, xmm6

     pshufb    xmm2, xmm6

     pshufb    xmm3, xmm6

     movdqa    xmm4, xmm1   // 4 bytes from 1 for 0

     psrldq    xmm1, 4      // 8 bytes from 1

     pslldq    xmm4, 12     // 4 bytes from 1 for 0

     movdqa    xmm5, xmm2   // 8 bytes from 2 for 1

     por       xmm0, xmm4   // 4 bytes from 1 for 0

     pslldq    xmm5, 8      // 8 bytes from 2 for 1

     movdqu    [edx], xmm0  // store 0

     por       xmm1, xmm5   // 8 bytes from 2 for 1

     psrldq    xmm2, 8      // 4 bytes from 2

     pslldq    xmm3, 4      // 12 bytes from 3 for 2

     por       xmm2, xmm3   // 12 bytes from 3 for 2

     movdqu    [edx + 16], xmm1   // store 1

     movdqu    [edx + 32], xmm2   // store 2

     lea       edx, [edx + 48]

     sub       ecx, 16

     jg        convertloop

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void ARGBToRAWRow_SSSE3(const uint8* src_argb, uint8* dst_rgb, int pix) {

   __asm {

     mov       eax, [esp + 4]   // src_argb

     mov       edx, [esp + 8]   // dst_rgb

     mov       ecx, [esp + 12]  // pix

     movdqa    xmm6, kShuffleMaskARGBToRAW

     align      4

  convertloop:

     movdqu    xmm0, [eax]   // fetch 16 pixels of argb

     movdqu    xmm1, [eax + 16]

     movdqu    xmm2, [eax + 32]

     movdqu    xmm3, [eax + 48]

     lea       eax, [eax + 64]

     pshufb    xmm0, xmm6    // pack 16 bytes of ARGB to 12 bytes of RGB

     pshufb    xmm1, xmm6

     pshufb    xmm2, xmm6

     pshufb    xmm3, xmm6

     movdqa    xmm4, xmm1   // 4 bytes from 1 for 0

     psrldq    xmm1, 4      // 8 bytes from 1

     pslldq    xmm4, 12     // 4 bytes from 1 for 0

     movdqa    xmm5, xmm2   // 8 bytes from 2 for 1

     por       xmm0, xmm4   // 4 bytes from 1 for 0

     pslldq    xmm5, 8      // 8 bytes from 2 for 1

     movdqu    [edx], xmm0  // store 0

     por       xmm1, xmm5   // 8 bytes from 2 for 1

     psrldq    xmm2, 8      // 4 bytes from 2

     pslldq    xmm3, 4      // 12 bytes from 3 for 2

     por       xmm2, xmm3   // 12 bytes from 3 for 2

     movdqu    [edx + 16], xmm1   // store 1

     movdqu    [edx + 32], xmm2   // store 2

     lea       edx, [edx + 48]

     sub       ecx, 16

     jg        convertloop

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void ARGBToRGB565Row_SSE2(const uint8* src_argb, uint8* dst_rgb, int pix) {

   __asm {

     mov       eax, [esp + 4]   // src_argb

     mov       edx, [esp + 8]   // dst_rgb

     mov       ecx, [esp + 12]  // pix

     pcmpeqb   xmm3, xmm3       // generate mask 0x0000001f

     psrld     xmm3, 27

     pcmpeqb   xmm4, xmm4       // generate mask 0x000007e0

     psrld     xmm4, 26

     pslld     xmm4, 5

     pcmpeqb   xmm5, xmm5       // generate mask 0xfffff800

     pslld     xmm5, 11

     align      4

  convertloop:

     movdqa    xmm0, [eax]   // fetch 4 pixels of argb

     movdqa    xmm1, xmm0    // B

     movdqa    xmm2, xmm0    // G

     pslld     xmm0, 8       // R

     psrld     xmm1, 3       // B

     psrld     xmm2, 5       // G

     psrad     xmm0, 16      // R

     pand      xmm1, xmm3    // B

     pand      xmm2, xmm4    // G

     pand      xmm0, xmm5    // R

     por       xmm1, xmm2    // BG

     por       xmm0, xmm1    // BGR

     packssdw  xmm0, xmm0

     lea       eax, [eax + 16]

     movq      qword ptr [edx], xmm0  // store 4 pixels of RGB565

     lea       edx, [edx + 8]

     sub       ecx, 4

     jg        convertloop

     ret

   }

 }

 // TODO(fbarchard): Improve sign extension/packing.

 __declspec(naked) __declspec(align(16))

 void ARGBToARGB1555Row_SSE2(const uint8* src_argb, uint8* dst_rgb, int pix) {

   __asm {

     mov       eax, [esp + 4]   // src_argb

     mov       edx, [esp + 8]   // dst_rgb

     mov       ecx, [esp + 12]  // pix

     pcmpeqb   xmm4, xmm4       // generate mask 0x0000001f

     psrld     xmm4, 27

     movdqa    xmm5, xmm4       // generate mask 0x000003e0

     pslld     xmm5, 5

     movdqa    xmm6, xmm4       // generate mask 0x00007c00

     pslld     xmm6, 10

     pcmpeqb   xmm7, xmm7       // generate mask 0xffff8000

     pslld     xmm7, 15

     align      4

  convertloop:

     movdqa    xmm0, [eax]   // fetch 4 pixels of argb

     movdqa    xmm1, xmm0    // B

     movdqa    xmm2, xmm0    // G

     movdqa    xmm3, xmm0    // R

     psrad     xmm0, 16      // A

     psrld     xmm1, 3       // B

     psrld     xmm2, 6       // G

     psrld     xmm3, 9       // R

     pand      xmm0, xmm7    // A

     pand      xmm1, xmm4    // B

     pand      xmm2, xmm5    // G

     pand      xmm3, xmm6    // R

     por       xmm0, xmm1    // BA

     por       xmm2, xmm3    // GR

     por       xmm0, xmm2    // BGRA

     packssdw  xmm0, xmm0

     lea       eax, [eax + 16]

     movq      qword ptr [edx], xmm0  // store 4 pixels of ARGB1555

     lea       edx, [edx + 8]

     sub       ecx, 4

     jg        convertloop

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void ARGBToARGB4444Row_SSE2(const uint8* src_argb, uint8* dst_rgb, int pix) {

   __asm {

     mov       eax, [esp + 4]   // src_argb

     mov       edx, [esp + 8]   // dst_rgb

     mov       ecx, [esp + 12]  // pix

     pcmpeqb   xmm4, xmm4       // generate mask 0xf000f000

     psllw     xmm4, 12

     movdqa    xmm3, xmm4       // generate mask 0x00f000f0

     psrlw     xmm3, 8

     align      4

  convertloop:

     movdqa    xmm0, [eax]   // fetch 4 pixels of argb

     movdqa    xmm1, xmm0

     pand      xmm0, xmm3    // low nibble

     pand      xmm1, xmm4    // high nibble

     psrl      xmm0, 4

     psrl      xmm1, 8

     por       xmm0, xmm1

     packuswb  xmm0, xmm0

     lea       eax, [eax + 16]

     movq      qword ptr [edx], xmm0  // store 4 pixels of ARGB4444

     lea       edx, [edx + 8]

     sub       ecx, 4

     jg        convertloop

     ret

   }

 }

 // Convert 16 ARGB pixels (64 bytes) to 16 Y values.

 __declspec(naked) __declspec(align(16))

 void ARGBToYRow_SSSE3(const uint8* src_argb, uint8* dst_y, int pix) {

   __asm {

     mov        eax, [esp + 4]   /* src_argb */

     mov        edx, [esp + 8]   /* dst_y */

     mov        ecx, [esp + 12]  /* pix */

     movdqa     xmm5, kAddY16

     movdqa     xmm4, kARGBToY

     align      4

  convertloop:

     movdqa     xmm0, [eax]

     movdqa     xmm1, [eax + 16]

     movdqa     xmm2, [eax + 32]

     movdqa     xmm3, [eax + 48]

     pmaddubsw  xmm0, xmm4

     pmaddubsw  xmm1, xmm4

     pmaddubsw  xmm2, xmm4

     pmaddubsw  xmm3, xmm4

     lea        eax, [eax + 64]

     phaddw     xmm0, xmm1

     phaddw     xmm2, xmm3

     psrlw      xmm0, 7

     psrlw      xmm2, 7

     packuswb   xmm0, xmm2

     paddb      xmm0, xmm5

     sub        ecx, 16

     movdqa     [edx], xmm0

     lea        edx, [edx + 16]

     jg         convertloop

     ret

   }

 }

 // Convert 16 ARGB pixels (64 bytes) to 16 Y values.

 __declspec(naked) __declspec(align(16))

 void ARGBToYJRow_SSSE3(const uint8* src_argb, uint8* dst_y, int pix) {

   __asm {

     mov        eax, [esp + 4]   /* src_argb */

     mov        edx, [esp + 8]   /* dst_y */

     mov        ecx, [esp + 12]  /* pix */

     movdqa     xmm4, kARGBToYJ

     movdqa     xmm5, kAddYJ64

     align      4

  convertloop:

     movdqa     xmm0, [eax]

     movdqa     xmm1, [eax + 16]

     movdqa     xmm2, [eax + 32]

     movdqa     xmm3, [eax + 48]

     pmaddubsw  xmm0, xmm4

     pmaddubsw  xmm1, xmm4

     pmaddubsw  xmm2, xmm4

     pmaddubsw  xmm3, xmm4

     lea        eax, [eax + 64]

     phaddw     xmm0, xmm1

     phaddw     xmm2, xmm3

     paddw      xmm0, xmm5  // Add .5 for rounding.

     paddw      xmm2, xmm5

     psrlw      xmm0, 7

     psrlw      xmm2, 7

     packuswb   xmm0, xmm2

     sub        ecx, 16

     movdqa     [edx], xmm0

     lea        edx, [edx + 16]

     jg         convertloop

     ret

   }

 }

 #ifdef HAS_ARGBTOYROW_AVX2

 // Convert 32 ARGB pixels (128 bytes) to 32 Y values.

 __declspec(naked) __declspec(align(32))

 void ARGBToYRow_AVX2(const uint8* src_argb, uint8* dst_y, int pix) {

   __asm {

     mov        eax, [esp + 4]   /* src_argb */

     mov        edx, [esp + 8]   /* dst_y */

     mov        ecx, [esp + 12]  /* pix */

     vbroadcastf128 ymm4, kARGBToY

     vbroadcastf128 ymm5, kAddY16

     vmovdqa    ymm6, kPermdARGBToY_AVX

     align      4

  convertloop:

     vmovdqu    ymm0, [eax]

     vmovdqu    ymm1, [eax + 32]

     vmovdqu    ymm2, [eax + 64]

     vmovdqu    ymm3, [eax + 96]

     vpmaddubsw ymm0, ymm0, ymm4

     vpmaddubsw ymm1, ymm1, ymm4

     vpmaddubsw ymm2, ymm2, ymm4

     vpmaddubsw ymm3, ymm3, ymm4

     lea        eax, [eax + 128]

     vphaddw    ymm0, ymm0, ymm1  // mutates.

     vphaddw    ymm2, ymm2, ymm3

     vpsrlw     ymm0, ymm0, 7

     vpsrlw     ymm2, ymm2, 7

     vpackuswb  ymm0, ymm0, ymm2  // mutates.

     vpermd     ymm0, ymm6, ymm0  // For vphaddw + vpackuswb mutation.

     vpaddb     ymm0, ymm0, ymm5

     sub        ecx, 32

     vmovdqu    [edx], ymm0

     lea        edx, [edx + 32]

     jg         convertloop

     vzeroupper

     ret

   }

 }

 #endif  //  HAS_ARGBTOYROW_AVX2

 #ifdef HAS_ARGBTOYROW_AVX2

 // Convert 32 ARGB pixels (128 bytes) to 32 Y values.

 __declspec(naked) __declspec(align(32))

 void ARGBToYJRow_AVX2(const uint8* src_argb, uint8* dst_y, int pix) {

   __asm {

     mov        eax, [esp + 4]   /* src_argb */

     mov        edx, [esp + 8]   /* dst_y */

     mov        ecx, [esp + 12]  /* pix */

     vbroadcastf128 ymm4, kARGBToYJ

     vbroadcastf128 ymm5, kAddYJ64

     vmovdqa    ymm6, kPermdARGBToY_AVX

     align      4

  convertloop:

     vmovdqu    ymm0, [eax]

     vmovdqu    ymm1, [eax + 32]

     vmovdqu    ymm2, [eax + 64]

     vmovdqu    ymm3, [eax + 96]

     vpmaddubsw ymm0, ymm0, ymm4

     vpmaddubsw ymm1, ymm1, ymm4

     vpmaddubsw ymm2, ymm2, ymm4

     vpmaddubsw ymm3, ymm3, ymm4

     lea        eax, [eax + 128]

     vphaddw    ymm0, ymm0, ymm1  // mutates.

     vphaddw    ymm2, ymm2, ymm3

     vpaddw     ymm0, ymm0, ymm5  // Add .5 for rounding.

     vpaddw     ymm2, ymm2, ymm5

     vpsrlw     ymm0, ymm0, 7

     vpsrlw     ymm2, ymm2, 7

     vpackuswb  ymm0, ymm0, ymm2  // mutates.

     vpermd     ymm0, ymm6, ymm0  // For vphaddw + vpackuswb mutation.

     sub        ecx, 32

     vmovdqu    [edx], ymm0

     lea        edx, [edx + 32]

     jg         convertloop

     vzeroupper

     ret

   }

 }

 #endif  //  HAS_ARGBTOYJROW_AVX2

 __declspec(naked) __declspec(align(16))

 void ARGBToYRow_Unaligned_SSSE3(const uint8* src_argb, uint8* dst_y, int pix) {

   __asm {

     mov        eax, [esp + 4]   /* src_argb */

     mov        edx, [esp + 8]   /* dst_y */

     mov        ecx, [esp + 12]  /* pix */

     movdqa     xmm5, kAddY16

     movdqa     xmm4, kARGBToY

     align      4

  convertloop:

     movdqu     xmm0, [eax]

     movdqu     xmm1, [eax + 16]

     movdqu     xmm2, [eax + 32]

     movdqu     xmm3, [eax + 48]

     pmaddubsw  xmm0, xmm4

     pmaddubsw  xmm1, xmm4

     pmaddubsw  xmm2, xmm4

     pmaddubsw  xmm3, xmm4

     lea        eax, [eax + 64]

     phaddw     xmm0, xmm1

     phaddw     xmm2, xmm3

     psrlw      xmm0, 7

     psrlw      xmm2, 7

     packuswb   xmm0, xmm2

     paddb      xmm0, xmm5

     sub        ecx, 16

     movdqu     [edx], xmm0

     lea        edx, [edx + 16]

     jg         convertloop

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void ARGBToYJRow_Unaligned_SSSE3(const uint8* src_argb, uint8* dst_y, int pix) {

   __asm {

     mov        eax, [esp + 4]   /* src_argb */

     mov        edx, [esp + 8]   /* dst_y */

     mov        ecx, [esp + 12]  /* pix */

     movdqa     xmm4, kARGBToYJ

     movdqa     xmm5, kAddYJ64

     align      4

  convertloop:

     movdqu     xmm0, [eax]

     movdqu     xmm1, [eax + 16]

     movdqu     xmm2, [eax + 32]

     movdqu     xmm3, [eax + 48]

     pmaddubsw  xmm0, xmm4

     pmaddubsw  xmm1, xmm4

     pmaddubsw  xmm2, xmm4

     pmaddubsw  xmm3, xmm4

     lea        eax, [eax + 64]

     phaddw     xmm0, xmm1

     phaddw     xmm2, xmm3

     paddw      xmm0, xmm5

     paddw      xmm2, xmm5

     psrlw      xmm0, 7

     psrlw      xmm2, 7

     packuswb   xmm0, xmm2

     sub        ecx, 16

     movdqu     [edx], xmm0

     lea        edx, [edx + 16]

     jg         convertloop

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void BGRAToYRow_SSSE3(const uint8* src_argb, uint8* dst_y, int pix) {

   __asm {

     mov        eax, [esp + 4]   /* src_argb */

     mov        edx, [esp + 8]   /* dst_y */

     mov        ecx, [esp + 12]  /* pix */

     movdqa     xmm5, kAddY16

     movdqa     xmm4, kBGRAToY

     align      4

  convertloop:

     movdqa     xmm0, [eax]

     movdqa     xmm1, [eax + 16]

     movdqa     xmm2, [eax + 32]

     movdqa     xmm3, [eax + 48]

     pmaddubsw  xmm0, xmm4

     pmaddubsw  xmm1, xmm4

     pmaddubsw  xmm2, xmm4

     pmaddubsw  xmm3, xmm4

     lea        eax, [eax + 64]

     phaddw     xmm0, xmm1

     phaddw     xmm2, xmm3

     psrlw      xmm0, 7

     psrlw      xmm2, 7

     packuswb   xmm0, xmm2

     paddb      xmm0, xmm5

     sub        ecx, 16

     movdqa     [edx], xmm0

     lea        edx, [edx + 16]

     jg         convertloop

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void BGRAToYRow_Unaligned_SSSE3(const uint8* src_argb, uint8* dst_y, int pix) {

   __asm {

     mov        eax, [esp + 4]   /* src_argb */

     mov        edx, [esp + 8]   /* dst_y */

     mov        ecx, [esp + 12]  /* pix */

     movdqa     xmm5, kAddY16

     movdqa     xmm4, kBGRAToY

     align      4

  convertloop:

     movdqu     xmm0, [eax]

     movdqu     xmm1, [eax + 16]

     movdqu     xmm2, [eax + 32]

     movdqu     xmm3, [eax + 48]

     pmaddubsw  xmm0, xmm4

     pmaddubsw  xmm1, xmm4

     pmaddubsw  xmm2, xmm4

     pmaddubsw  xmm3, xmm4

     lea        eax, [eax + 64]

     phaddw     xmm0, xmm1

     phaddw     xmm2, xmm3

     psrlw      xmm0, 7

     psrlw      xmm2, 7

     packuswb   xmm0, xmm2

     paddb      xmm0, xmm5

     sub        ecx, 16

     movdqu     [edx], xmm0

     lea        edx, [edx + 16]

     jg         convertloop

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void ABGRToYRow_SSSE3(const uint8* src_argb, uint8* dst_y, int pix) {

   __asm {

     mov        eax, [esp + 4]   /* src_argb */

     mov        edx, [esp + 8]   /* dst_y */

     mov        ecx, [esp + 12]  /* pix */

     movdqa     xmm5, kAddY16

     movdqa     xmm4, kABGRToY

     align      4

  convertloop:

     movdqa     xmm0, [eax]

     movdqa     xmm1, [eax + 16]

     movdqa     xmm2, [eax + 32]

     movdqa     xmm3, [eax + 48]

     pmaddubsw  xmm0, xmm4

     pmaddubsw  xmm1, xmm4

     pmaddubsw  xmm2, xmm4

     pmaddubsw  xmm3, xmm4

     lea        eax, [eax + 64]

     phaddw     xmm0, xmm1

     phaddw     xmm2, xmm3

     psrlw      xmm0, 7

     psrlw      xmm2, 7

     packuswb   xmm0, xmm2

     paddb      xmm0, xmm5

     sub        ecx, 16

     movdqa     [edx], xmm0

     lea        edx, [edx + 16]

     jg         convertloop

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void ABGRToYRow_Unaligned_SSSE3(const uint8* src_argb, uint8* dst_y, int pix) {

   __asm {

     mov        eax, [esp + 4]   /* src_argb */

     mov        edx, [esp + 8]   /* dst_y */

     mov        ecx, [esp + 12]  /* pix */

     movdqa     xmm5, kAddY16

     movdqa     xmm4, kABGRToY

     align      4

  convertloop:

     movdqu     xmm0, [eax]

     movdqu     xmm1, [eax + 16]

     movdqu     xmm2, [eax + 32]

     movdqu     xmm3, [eax + 48]

     pmaddubsw  xmm0, xmm4

     pmaddubsw  xmm1, xmm4

     pmaddubsw  xmm2, xmm4

     pmaddubsw  xmm3, xmm4

     lea        eax, [eax + 64]

     phaddw     xmm0, xmm1

     phaddw     xmm2, xmm3

     psrlw      xmm0, 7

     psrlw      xmm2, 7

     packuswb   xmm0, xmm2

     paddb      xmm0, xmm5

     sub        ecx, 16

     movdqu     [edx], xmm0

     lea        edx, [edx + 16]

     jg         convertloop

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void RGBAToYRow_SSSE3(const uint8* src_argb, uint8* dst_y, int pix) {

   __asm {

     mov        eax, [esp + 4]   /* src_argb */

     mov        edx, [esp + 8]   /* dst_y */

     mov        ecx, [esp + 12]  /* pix */

     movdqa     xmm5, kAddY16

     movdqa     xmm4, kRGBAToY

     align      4

  convertloop:

     movdqa     xmm0, [eax]

     movdqa     xmm1, [eax + 16]

     movdqa     xmm2, [eax + 32]

     movdqa     xmm3, [eax + 48]

     pmaddubsw  xmm0, xmm4

     pmaddubsw  xmm1, xmm4

     pmaddubsw  xmm2, xmm4

     pmaddubsw  xmm3, xmm4

     lea        eax, [eax + 64]

     phaddw     xmm0, xmm1

     phaddw     xmm2, xmm3

     psrlw      xmm0, 7

     psrlw      xmm2, 7

     packuswb   xmm0, xmm2

     paddb      xmm0, xmm5

     sub        ecx, 16

     movdqa     [edx], xmm0

     lea        edx, [edx + 16]

     jg         convertloop

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void RGBAToYRow_Unaligned_SSSE3(const uint8* src_argb, uint8* dst_y, int pix) {

   __asm {

     mov        eax, [esp + 4]   /* src_argb */

     mov        edx, [esp + 8]   /* dst_y */

     mov        ecx, [esp + 12]  /* pix */

     movdqa     xmm5, kAddY16

     movdqa     xmm4, kRGBAToY

     align      4

  convertloop:

     movdqu     xmm0, [eax]

     movdqu     xmm1, [eax + 16]

     movdqu     xmm2, [eax + 32]

     movdqu     xmm3, [eax + 48]

     pmaddubsw  xmm0, xmm4

     pmaddubsw  xmm1, xmm4

     pmaddubsw  xmm2, xmm4

     pmaddubsw  xmm3, xmm4

     lea        eax, [eax + 64]

     phaddw     xmm0, xmm1

     phaddw     xmm2, xmm3

     psrlw      xmm0, 7

     psrlw      xmm2, 7

     packuswb   xmm0, xmm2

     paddb      xmm0, xmm5

     sub        ecx, 16

     movdqu     [edx], xmm0

     lea        edx, [edx + 16]

     jg         convertloop

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void ARGBToUVRow_SSSE3(const uint8* src_argb0, int src_stride_argb,

                        uint8* dst_u, uint8* dst_v, int width) {

   __asm {

     push       esi

     push       edi

     mov        eax, [esp + 8 + 4]   // src_argb

     mov        esi, [esp + 8 + 8]   // src_stride_argb

     mov        edx, [esp + 8 + 12]  // dst_u

     mov        edi, [esp + 8 + 16]  // dst_v

     mov        ecx, [esp + 8 + 20]  // pix

     movdqa     xmm7, kARGBToU

     movdqa     xmm6, kARGBToV

     movdqa     xmm5, kAddUV128

     sub        edi, edx             // stride from u to v

     align      4

  convertloop:

     /* step 1 - subsample 16x2 argb pixels to 8x1 */

     movdqa     xmm0, [eax]

     movdqa     xmm1, [eax + 16]

     movdqa     xmm2, [eax + 32]

     movdqa     xmm3, [eax + 48]

     pavgb      xmm0, [eax + esi]

     pavgb      xmm1, [eax + esi + 16]

     pavgb      xmm2, [eax + esi + 32]

     pavgb      xmm3, [eax + esi + 48]

     lea        eax,  [eax + 64]

     movdqa     xmm4, xmm0

     shufps     xmm0, xmm1, 0x88

     shufps     xmm4, xmm1, 0xdd

     pavgb      xmm0, xmm4

     movdqa     xmm4, xmm2

     shufps     xmm2, xmm3, 0x88

     shufps     xmm4, xmm3, 0xdd

     pavgb      xmm2, xmm4

     // step 2 - convert to U and V

     // from here down is very similar to Y code except

     // instead of 16 different pixels, its 8 pixels of U and 8 of V

     movdqa     xmm1, xmm0

     movdqa     xmm3, xmm2

     pmaddubsw  xmm0, xmm7  // U

     pmaddubsw  xmm2, xmm7

     pmaddubsw  xmm1, xmm6  // V

     pmaddubsw  xmm3, xmm6

     phaddw     xmm0, xmm2

     phaddw     xmm1, xmm3

     psraw      xmm0, 8

     psraw      xmm1, 8

     packsswb   xmm0, xmm1

     paddb      xmm0, xmm5            // -> unsigned

     // step 3 - store 8 U and 8 V values

     sub        ecx, 16

     movlps     qword ptr [edx], xmm0 // U

     movhps     qword ptr [edx + edi], xmm0 // V

     lea        edx, [edx + 8]

     jg         convertloop

     pop        edi

     pop        esi

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void ARGBToUVJRow_SSSE3(const uint8* src_argb0, int src_stride_argb,

                         uint8* dst_u, uint8* dst_v, int width) {

   __asm {

     push       esi

     push       edi

     mov        eax, [esp + 8 + 4]   // src_argb

     mov        esi, [esp + 8 + 8]   // src_stride_argb

     mov        edx, [esp + 8 + 12]  // dst_u

     mov        edi, [esp + 8 + 16]  // dst_v

     mov        ecx, [esp + 8 + 20]  // pix

     movdqa     xmm7, kARGBToUJ

     movdqa     xmm6, kARGBToVJ

     movdqa     xmm5, kAddUVJ128

     sub        edi, edx             // stride from u to v

     align      4

  convertloop:

     /* step 1 - subsample 16x2 argb pixels to 8x1 */

     movdqa     xmm0, [eax]

     movdqa     xmm1, [eax + 16]

     movdqa     xmm2, [eax + 32]

     movdqa     xmm3, [eax + 48]

     pavgb      xmm0, [eax + esi]

     pavgb      xmm1, [eax + esi + 16]

     pavgb      xmm2, [eax + esi + 32]

     pavgb      xmm3, [eax + esi + 48]

     lea        eax,  [eax + 64]

     movdqa     xmm4, xmm0

     shufps     xmm0, xmm1, 0x88

     shufps     xmm4, xmm1, 0xdd

     pavgb      xmm0, xmm4

     movdqa     xmm4, xmm2

     shufps     xmm2, xmm3, 0x88

     shufps     xmm4, xmm3, 0xdd

     pavgb      xmm2, xmm4

     // step 2 - convert to U and V

     // from here down is very similar to Y code except

     // instead of 16 different pixels, its 8 pixels of U and 8 of V

     movdqa     xmm1, xmm0

     movdqa     xmm3, xmm2

     pmaddubsw  xmm0, xmm7  // U

     pmaddubsw  xmm2, xmm7

     pmaddubsw  xmm1, xmm6  // V

     pmaddubsw  xmm3, xmm6

     phaddw     xmm0, xmm2

     phaddw     xmm1, xmm3

     paddw      xmm0, xmm5            // +.5 rounding -> unsigned

     paddw      xmm1, xmm5

     psraw      xmm0, 8

     psraw      xmm1, 8

     packsswb   xmm0, xmm1

     // step 3 - store 8 U and 8 V values

     sub        ecx, 16

     movlps     qword ptr [edx], xmm0 // U

     movhps     qword ptr [edx + edi], xmm0 // V

     lea        edx, [edx + 8]

     jg         convertloop

     pop        edi

     pop        esi

     ret

   }

 }

 #ifdef HAS_ARGBTOUVROW_AVX2

 __declspec(naked) __declspec(align(32))

 void ARGBToUVRow_AVX2(const uint8* src_argb0, int src_stride_argb,

                       uint8* dst_u, uint8* dst_v, int width) {

   __asm {

     push       esi

     push       edi

     mov        eax, [esp + 8 + 4]   // src_argb

     mov        esi, [esp + 8 + 8]   // src_stride_argb

     mov        edx, [esp + 8 + 12]  // dst_u

     mov        edi, [esp + 8 + 16]  // dst_v

     mov        ecx, [esp + 8 + 20]  // pix

     vbroadcastf128 ymm5, kAddUV128

     vbroadcastf128 ymm6, kARGBToV

     vbroadcastf128 ymm7, kARGBToU

     sub        edi, edx             // stride from u to v

     align      4

  convertloop:

     /* step 1 - subsample 32x2 argb pixels to 16x1 */

     vmovdqu    ymm0, [eax]

     vmovdqu    ymm1, [eax + 32]

     vmovdqu    ymm2, [eax + 64]

     vmovdqu    ymm3, [eax + 96]

     vpavgb     ymm0, ymm0, [eax + esi]

     vpavgb     ymm1, ymm1, [eax + esi + 32]

     vpavgb     ymm2, ymm2, [eax + esi + 64]

     vpavgb     ymm3, ymm3, [eax + esi + 96]

     lea        eax,  [eax + 128]

     vshufps    ymm4, ymm0, ymm1, 0x88

     vshufps    ymm0, ymm0, ymm1, 0xdd

     vpavgb     ymm0, ymm0, ymm4  // mutated by vshufps

     vshufps    ymm4, ymm2, ymm3, 0x88

     vshufps    ymm2, ymm2, ymm3, 0xdd

     vpavgb     ymm2, ymm2, ymm4  // mutated by vshufps

     // step 2 - convert to U and V

     // from here down is very similar to Y code except

     // instead of 32 different pixels, its 16 pixels of U and 16 of V

     vpmaddubsw ymm1, ymm0, ymm7  // U

     vpmaddubsw ymm3, ymm2, ymm7

     vpmaddubsw ymm0, ymm0, ymm6  // V

     vpmaddubsw ymm2, ymm2, ymm6

     vphaddw    ymm1, ymm1, ymm3  // mutates

     vphaddw    ymm0, ymm0, ymm2

     vpsraw     ymm1, ymm1, 8

     vpsraw     ymm0, ymm0, 8

     vpacksswb  ymm0, ymm1, ymm0  // mutates

     vpermq     ymm0, ymm0, 0xd8  // For vpacksswb

     vpshufb    ymm0, ymm0, kShufARGBToUV_AVX  // For vshufps + vphaddw

     vpaddb     ymm0, ymm0, ymm5  // -> unsigned

     // step 3 - store 16 U and 16 V values

     sub         ecx, 32

     vextractf128 [edx], ymm0, 0 // U

     vextractf128 [edx + edi], ymm0, 1 // V

     lea        edx, [edx + 16]

     jg         convertloop

     pop        edi

     pop        esi

     vzeroupper

     ret

   }

 }

 #endif  // HAS_ARGBTOUVROW_AVX2

 __declspec(naked) __declspec(align(16))

 void ARGBToUVRow_Unaligned_SSSE3(const uint8* src_argb0, int src_stride_argb,

                                  uint8* dst_u, uint8* dst_v, int width) {

   __asm {

     push       esi

     push       edi

     mov        eax, [esp + 8 + 4]   // src_argb

     mov        esi, [esp + 8 + 8]   // src_stride_argb

     mov        edx, [esp + 8 + 12]  // dst_u

     mov        edi, [esp + 8 + 16]  // dst_v

     mov        ecx, [esp + 8 + 20]  // pix

     movdqa     xmm7, kARGBToU

     movdqa     xmm6, kARGBToV

     movdqa     xmm5, kAddUV128

     sub        edi, edx             // stride from u to v

     align      4

  convertloop:

     /* step 1 - subsample 16x2 argb pixels to 8x1 */

     movdqu     xmm0, [eax]

     movdqu     xmm1, [eax + 16]

     movdqu     xmm2, [eax + 32]

     movdqu     xmm3, [eax + 48]

     movdqu     xmm4, [eax + esi]

     pavgb      xmm0, xmm4

     movdqu     xmm4, [eax + esi + 16]

     pavgb      xmm1, xmm4

     movdqu     xmm4, [eax + esi + 32]

     pavgb      xmm2, xmm4

     movdqu     xmm4, [eax + esi + 48]

     pavgb      xmm3, xmm4

     lea        eax,  [eax + 64]

     movdqa     xmm4, xmm0

     shufps     xmm0, xmm1, 0x88

     shufps     xmm4, xmm1, 0xdd

     pavgb      xmm0, xmm4

     movdqa     xmm4, xmm2

     shufps     xmm2, xmm3, 0x88

     shufps     xmm4, xmm3, 0xdd

     pavgb      xmm2, xmm4

     // step 2 - convert to U and V

     // from here down is very similar to Y code except

     // instead of 16 different pixels, its 8 pixels of U and 8 of V

     movdqa     xmm1, xmm0

     movdqa     xmm3, xmm2

     pmaddubsw  xmm0, xmm7  // U

     pmaddubsw  xmm2, xmm7

     pmaddubsw  xmm1, xmm6  // V

     pmaddubsw  xmm3, xmm6

     phaddw     xmm0, xmm2

     phaddw     xmm1, xmm3

     psraw      xmm0, 8

     psraw      xmm1, 8

     packsswb   xmm0, xmm1

     paddb      xmm0, xmm5            // -> unsigned

     // step 3 - store 8 U and 8 V values

     sub        ecx, 16

     movlps     qword ptr [edx], xmm0 // U

     movhps     qword ptr [edx + edi], xmm0 // V

     lea        edx, [edx + 8]

     jg         convertloop

     pop        edi

     pop        esi

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void ARGBToUVJRow_Unaligned_SSSE3(const uint8* src_argb0, int src_stride_argb,

                                  uint8* dst_u, uint8* dst_v, int width) {

   __asm {

     push       esi

     push       edi

     mov        eax, [esp + 8 + 4]   // src_argb

     mov        esi, [esp + 8 + 8]   // src_stride_argb

     mov        edx, [esp + 8 + 12]  // dst_u

     mov        edi, [esp + 8 + 16]  // dst_v

     mov        ecx, [esp + 8 + 20]  // pix

     movdqa     xmm7, kARGBToUJ

     movdqa     xmm6, kARGBToVJ

     movdqa     xmm5, kAddUVJ128

     sub        edi, edx             // stride from u to v

     align      4

  convertloop:

     /* step 1 - subsample 16x2 argb pixels to 8x1 */

     movdqu     xmm0, [eax]

     movdqu     xmm1, [eax + 16]

     movdqu     xmm2, [eax + 32]

     movdqu     xmm3, [eax + 48]

     movdqu     xmm4, [eax + esi]

     pavgb      xmm0, xmm4

     movdqu     xmm4, [eax + esi + 16]

     pavgb      xmm1, xmm4

     movdqu     xmm4, [eax + esi + 32]

     pavgb      xmm2, xmm4

     movdqu     xmm4, [eax + esi + 48]

     pavgb      xmm3, xmm4

     lea        eax,  [eax + 64]

     movdqa     xmm4, xmm0

     shufps     xmm0, xmm1, 0x88

     shufps     xmm4, xmm1, 0xdd

     pavgb      xmm0, xmm4

     movdqa     xmm4, xmm2

     shufps     xmm2, xmm3, 0x88

     shufps     xmm4, xmm3, 0xdd

     pavgb      xmm2, xmm4

     // step 2 - convert to U and V

     // from here down is very similar to Y code except

     // instead of 16 different pixels, its 8 pixels of U and 8 of V

     movdqa     xmm1, xmm0

     movdqa     xmm3, xmm2

     pmaddubsw  xmm0, xmm7  // U

     pmaddubsw  xmm2, xmm7

     pmaddubsw  xmm1, xmm6  // V

     pmaddubsw  xmm3, xmm6

     phaddw     xmm0, xmm2

     phaddw     xmm1, xmm3

     paddw      xmm0, xmm5            // +.5 rounding -> unsigned

     paddw      xmm1, xmm5

     psraw      xmm0, 8

     psraw      xmm1, 8

     packsswb   xmm0, xmm1

     // step 3 - store 8 U and 8 V values

     sub        ecx, 16

     movlps     qword ptr [edx], xmm0 // U

     movhps     qword ptr [edx + edi], xmm0 // V

     lea        edx, [edx + 8]

     jg         convertloop

     pop        edi

     pop        esi

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void ARGBToUV444Row_SSSE3(const uint8* src_argb0,

                           uint8* dst_u, uint8* dst_v, int width) {

   __asm {

     push       edi

     mov        eax, [esp + 4 + 4]   // src_argb

     mov        edx, [esp + 4 + 8]   // dst_u

     mov        edi, [esp + 4 + 12]  // dst_v

     mov        ecx, [esp + 4 + 16]  // pix

     movdqa     xmm7, kARGBToU

     movdqa     xmm6, kARGBToV

     movdqa     xmm5, kAddUV128

     sub        edi, edx             // stride from u to v

     align      4

  convertloop:

     /* convert to U and V */

     movdqa     xmm0, [eax]          // U

     movdqa     xmm1, [eax + 16]

     movdqa     xmm2, [eax + 32]

     movdqa     xmm3, [eax + 48]

     pmaddubsw  xmm0, xmm7

     pmaddubsw  xmm1, xmm7

     pmaddubsw  xmm2, xmm7

     pmaddubsw  xmm3, xmm7

     phaddw     xmm0, xmm1

     phaddw     xmm2, xmm3

     psraw      xmm0, 8

     psraw      xmm2, 8

     packsswb   xmm0, xmm2

     paddb      xmm0, xmm5

     sub        ecx,  16

     movdqa     [edx], xmm0

     movdqa     xmm0, [eax]          // V

     movdqa     xmm1, [eax + 16]

     movdqa     xmm2, [eax + 32]

     movdqa     xmm3, [eax + 48]

     pmaddubsw  xmm0, xmm6

     pmaddubsw  xmm1, xmm6

     pmaddubsw  xmm2, xmm6

     pmaddubsw  xmm3, xmm6

     phaddw     xmm0, xmm1

     phaddw     xmm2, xmm3

     psraw      xmm0, 8

     psraw      xmm2, 8

     packsswb   xmm0, xmm2

     paddb      xmm0, xmm5

     lea        eax,  [eax + 64]

     movdqa     [edx + edi], xmm0

     lea        edx,  [edx + 16]

     jg         convertloop

     pop        edi

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void ARGBToUV444Row_Unaligned_SSSE3(const uint8* src_argb0,

                                     uint8* dst_u, uint8* dst_v, int width) {

   __asm {

     push       edi

     mov        eax, [esp + 4 + 4]   // src_argb

     mov        edx, [esp + 4 + 8]   // dst_u

     mov        edi, [esp + 4 + 12]  // dst_v

     mov        ecx, [esp + 4 + 16]  // pix

     movdqa     xmm7, kARGBToU

     movdqa     xmm6, kARGBToV

     movdqa     xmm5, kAddUV128

     sub        edi, edx             // stride from u to v

     align      4

  convertloop:

     /* convert to U and V */

     movdqu     xmm0, [eax]          // U

     movdqu     xmm1, [eax + 16]

     movdqu     xmm2, [eax + 32]

     movdqu     xmm3, [eax + 48]

     pmaddubsw  xmm0, xmm7

     pmaddubsw  xmm1, xmm7

     pmaddubsw  xmm2, xmm7

     pmaddubsw  xmm3, xmm7

     phaddw     xmm0, xmm1

     phaddw     xmm2, xmm3

     psraw      xmm0, 8

     psraw      xmm2, 8

     packsswb   xmm0, xmm2

     paddb      xmm0, xmm5

     sub        ecx,  16

     movdqu     [edx], xmm0

     movdqu     xmm0, [eax]          // V

     movdqu     xmm1, [eax + 16]

     movdqu     xmm2, [eax + 32]

     movdqu     xmm3, [eax + 48]

     pmaddubsw  xmm0, xmm6

     pmaddubsw  xmm1, xmm6

     pmaddubsw  xmm2, xmm6

     pmaddubsw  xmm3, xmm6

     phaddw     xmm0, xmm1

     phaddw     xmm2, xmm3

     psraw      xmm0, 8

     psraw      xmm2, 8

     packsswb   xmm0, xmm2

     paddb      xmm0, xmm5

     lea        eax,  [eax + 64]

     movdqu     [edx + edi], xmm0

     lea        edx,  [edx + 16]

     jg         convertloop

     pop        edi

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void ARGBToUV422Row_SSSE3(const uint8* src_argb0,

                           uint8* dst_u, uint8* dst_v, int width) {

   __asm {

     push       edi

     mov        eax, [esp + 4 + 4]   // src_argb

     mov        edx, [esp + 4 + 8]   // dst_u

     mov        edi, [esp + 4 + 12]  // dst_v

     mov        ecx, [esp + 4 + 16]  // pix

     movdqa     xmm7, kARGBToU

     movdqa     xmm6, kARGBToV

     movdqa     xmm5, kAddUV128

     sub        edi, edx             // stride from u to v

     align      4

  convertloop:

     /* step 1 - subsample 16x2 argb pixels to 8x1 */

     movdqa     xmm0, [eax]

     movdqa     xmm1, [eax + 16]

     movdqa     xmm2, [eax + 32]

     movdqa     xmm3, [eax + 48]

     lea        eax,  [eax + 64]

     movdqa     xmm4, xmm0

     shufps     xmm0, xmm1, 0x88

     shufps     xmm4, xmm1, 0xdd

     pavgb      xmm0, xmm4

     movdqa     xmm4, xmm2

     shufps     xmm2, xmm3, 0x88

     shufps     xmm4, xmm3, 0xdd

     pavgb      xmm2, xmm4

     // step 2 - convert to U and V

     // from here down is very similar to Y code except

     // instead of 16 different pixels, its 8 pixels of U and 8 of V

     movdqa     xmm1, xmm0

     movdqa     xmm3, xmm2

     pmaddubsw  xmm0, xmm7  // U

     pmaddubsw  xmm2, xmm7

     pmaddubsw  xmm1, xmm6  // V

     pmaddubsw  xmm3, xmm6

     phaddw     xmm0, xmm2

     phaddw     xmm1, xmm3

     psraw      xmm0, 8

     psraw      xmm1, 8

     packsswb   xmm0, xmm1

     paddb      xmm0, xmm5            // -> unsigned

     // step 3 - store 8 U and 8 V values

     sub        ecx, 16

     movlps     qword ptr [edx], xmm0 // U

     movhps     qword ptr [edx + edi], xmm0 // V

     lea        edx, [edx + 8]

     jg         convertloop

     pop        edi

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void ARGBToUV422Row_Unaligned_SSSE3(const uint8* src_argb0,

                                     uint8* dst_u, uint8* dst_v, int width) {

   __asm {

     push       edi

     mov        eax, [esp + 4 + 4]   // src_argb

     mov        edx, [esp + 4 + 8]   // dst_u

     mov        edi, [esp + 4 + 12]  // dst_v

     mov        ecx, [esp + 4 + 16]  // pix

     movdqa     xmm7, kARGBToU

     movdqa     xmm6, kARGBToV

     movdqa     xmm5, kAddUV128

     sub        edi, edx             // stride from u to v

     align      4

  convertloop:

     /* step 1 - subsample 16x2 argb pixels to 8x1 */

     movdqu     xmm0, [eax]

     movdqu     xmm1, [eax + 16]

     movdqu     xmm2, [eax + 32]

     movdqu     xmm3, [eax + 48]

     lea        eax,  [eax + 64]

     movdqa     xmm4, xmm0

     shufps     xmm0, xmm1, 0x88

     shufps     xmm4, xmm1, 0xdd

     pavgb      xmm0, xmm4

     movdqa     xmm4, xmm2

     shufps     xmm2, xmm3, 0x88

     shufps     xmm4, xmm3, 0xdd

     pavgb      xmm2, xmm4

     // step 2 - convert to U and V

     // from here down is very similar to Y code except

     // instead of 16 different pixels, its 8 pixels of U and 8 of V

     movdqa     xmm1, xmm0

     movdqa     xmm3, xmm2

     pmaddubsw  xmm0, xmm7  // U

     pmaddubsw  xmm2, xmm7

     pmaddubsw  xmm1, xmm6  // V

     pmaddubsw  xmm3, xmm6

     phaddw     xmm0, xmm2

     phaddw     xmm1, xmm3

     psraw      xmm0, 8

     psraw      xmm1, 8

     packsswb   xmm0, xmm1

     paddb      xmm0, xmm5            // -> unsigned

     // step 3 - store 8 U and 8 V values

     sub        ecx, 16

     movlps     qword ptr [edx], xmm0 // U

     movhps     qword ptr [edx + edi], xmm0 // V

     lea        edx, [edx + 8]

     jg         convertloop

     pop        edi

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void BGRAToUVRow_SSSE3(const uint8* src_argb0, int src_stride_argb,

                        uint8* dst_u, uint8* dst_v, int width) {

   __asm {

     push       esi

     push       edi

     mov        eax, [esp + 8 + 4]   // src_argb

     mov        esi, [esp + 8 + 8]   // src_stride_argb

     mov        edx, [esp + 8 + 12]  // dst_u

     mov        edi, [esp + 8 + 16]  // dst_v

     mov        ecx, [esp + 8 + 20]  // pix

     movdqa     xmm7, kBGRAToU

     movdqa     xmm6, kBGRAToV

     movdqa     xmm5, kAddUV128

     sub        edi, edx             // stride from u to v

     align      4

  convertloop:

     /* step 1 - subsample 16x2 argb pixels to 8x1 */

     movdqa     xmm0, [eax]

     movdqa     xmm1, [eax + 16]

     movdqa     xmm2, [eax + 32]

     movdqa     xmm3, [eax + 48]

     pavgb      xmm0, [eax + esi]

     pavgb      xmm1, [eax + esi + 16]

     pavgb      xmm2, [eax + esi + 32]

     pavgb      xmm3, [eax + esi + 48]

     lea        eax,  [eax + 64]

     movdqa     xmm4, xmm0

     shufps     xmm0, xmm1, 0x88

     shufps     xmm4, xmm1, 0xdd

     pavgb      xmm0, xmm4

     movdqa     xmm4, xmm2

     shufps     xmm2, xmm3, 0x88

     shufps     xmm4, xmm3, 0xdd

     pavgb      xmm2, xmm4

     // step 2 - convert to U and V

     // from here down is very similar to Y code except

     // instead of 16 different pixels, its 8 pixels of U and 8 of V

     movdqa     xmm1, xmm0

     movdqa     xmm3, xmm2

     pmaddubsw  xmm0, xmm7  // U

     pmaddubsw  xmm2, xmm7

     pmaddubsw  xmm1, xmm6  // V

     pmaddubsw  xmm3, xmm6

     phaddw     xmm0, xmm2

     phaddw     xmm1, xmm3

     psraw      xmm0, 8

     psraw      xmm1, 8

     packsswb   xmm0, xmm1

     paddb      xmm0, xmm5            // -> unsigned

     // step 3 - store 8 U and 8 V values

     sub        ecx, 16

     movlps     qword ptr [edx], xmm0 // U

     movhps     qword ptr [edx + edi], xmm0 // V

     lea        edx, [edx + 8]

     jg         convertloop

     pop        edi

     pop        esi

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void BGRAToUVRow_Unaligned_SSSE3(const uint8* src_argb0, int src_stride_argb,

                                  uint8* dst_u, uint8* dst_v, int width) {

   __asm {

     push       esi

     push       edi

     mov        eax, [esp + 8 + 4]   // src_argb

     mov        esi, [esp + 8 + 8]   // src_stride_argb

     mov        edx, [esp + 8 + 12]  // dst_u

     mov        edi, [esp + 8 + 16]  // dst_v

     mov        ecx, [esp + 8 + 20]  // pix

     movdqa     xmm7, kBGRAToU

     movdqa     xmm6, kBGRAToV

     movdqa     xmm5, kAddUV128

     sub        edi, edx             // stride from u to v

     align      4

  convertloop:

     /* step 1 - subsample 16x2 argb pixels to 8x1 */

     movdqu     xmm0, [eax]

     movdqu     xmm1, [eax + 16]

     movdqu     xmm2, [eax + 32]

     movdqu     xmm3, [eax + 48]

     movdqu     xmm4, [eax + esi]

     pavgb      xmm0, xmm4

     movdqu     xmm4, [eax + esi + 16]

     pavgb      xmm1, xmm4

     movdqu     xmm4, [eax + esi + 32]

     pavgb      xmm2, xmm4

     movdqu     xmm4, [eax + esi + 48]

     pavgb      xmm3, xmm4

     lea        eax,  [eax + 64]

     movdqa     xmm4, xmm0

     shufps     xmm0, xmm1, 0x88

     shufps     xmm4, xmm1, 0xdd

     pavgb      xmm0, xmm4

     movdqa     xmm4, xmm2

     shufps     xmm2, xmm3, 0x88

     shufps     xmm4, xmm3, 0xdd

     pavgb      xmm2, xmm4

     // step 2 - convert to U and V

     // from here down is very similar to Y code except

     // instead of 16 different pixels, its 8 pixels of U and 8 of V

     movdqa     xmm1, xmm0

     movdqa     xmm3, xmm2

     pmaddubsw  xmm0, xmm7  // U

     pmaddubsw  xmm2, xmm7

     pmaddubsw  xmm1, xmm6  // V

     pmaddubsw  xmm3, xmm6

     phaddw     xmm0, xmm2

     phaddw     xmm1, xmm3

     psraw      xmm0, 8

     psraw      xmm1, 8

     packsswb   xmm0, xmm1

     paddb      xmm0, xmm5            // -> unsigned

     // step 3 - store 8 U and 8 V values

     sub        ecx, 16

     movlps     qword ptr [edx], xmm0 // U

     movhps     qword ptr [edx + edi], xmm0 // V

     lea        edx, [edx + 8]

     jg         convertloop

     pop        edi

     pop        esi

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void ABGRToUVRow_SSSE3(const uint8* src_argb0, int src_stride_argb,

                        uint8* dst_u, uint8* dst_v, int width) {

   __asm {

     push       esi

     push       edi

     mov        eax, [esp + 8 + 4]   // src_argb

     mov        esi, [esp + 8 + 8]   // src_stride_argb

     mov        edx, [esp + 8 + 12]  // dst_u

     mov        edi, [esp + 8 + 16]  // dst_v

     mov        ecx, [esp + 8 + 20]  // pix

     movdqa     xmm7, kABGRToU

     movdqa     xmm6, kABGRToV

     movdqa     xmm5, kAddUV128

     sub        edi, edx             // stride from u to v

     align      4

  convertloop:

     /* step 1 - subsample 16x2 argb pixels to 8x1 */

     movdqa     xmm0, [eax]

     movdqa     xmm1, [eax + 16]

     movdqa     xmm2, [eax + 32]

     movdqa     xmm3, [eax + 48]

     pavgb      xmm0, [eax + esi]

     pavgb      xmm1, [eax + esi + 16]

     pavgb      xmm2, [eax + esi + 32]

     pavgb      xmm3, [eax + esi + 48]

     lea        eax,  [eax + 64]

     movdqa     xmm4, xmm0

     shufps     xmm0, xmm1, 0x88

     shufps     xmm4, xmm1, 0xdd

     pavgb      xmm0, xmm4

     movdqa     xmm4, xmm2

     shufps     xmm2, xmm3, 0x88

     shufps     xmm4, xmm3, 0xdd

     pavgb      xmm2, xmm4

     // step 2 - convert to U and V

     // from here down is very similar to Y code except

     // instead of 16 different pixels, its 8 pixels of U and 8 of V

     movdqa     xmm1, xmm0

     movdqa     xmm3, xmm2

     pmaddubsw  xmm0, xmm7  // U

     pmaddubsw  xmm2, xmm7

     pmaddubsw  xmm1, xmm6  // V

     pmaddubsw  xmm3, xmm6

     phaddw     xmm0, xmm2

     phaddw     xmm1, xmm3

     psraw      xmm0, 8

     psraw      xmm1, 8

     packsswb   xmm0, xmm1

     paddb      xmm0, xmm5            // -> unsigned

     // step 3 - store 8 U and 8 V values

     sub        ecx, 16

     movlps     qword ptr [edx], xmm0 // U

     movhps     qword ptr [edx + edi], xmm0 // V

     lea        edx, [edx + 8]

     jg         convertloop

     pop        edi

     pop        esi

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void ABGRToUVRow_Unaligned_SSSE3(const uint8* src_argb0, int src_stride_argb,

                                  uint8* dst_u, uint8* dst_v, int width) {

   __asm {

     push       esi

     push       edi

     mov        eax, [esp + 8 + 4]   // src_argb

     mov        esi, [esp + 8 + 8]   // src_stride_argb

     mov        edx, [esp + 8 + 12]  // dst_u

     mov        edi, [esp + 8 + 16]  // dst_v

     mov        ecx, [esp + 8 + 20]  // pix

     movdqa     xmm7, kABGRToU

     movdqa     xmm6, kABGRToV

     movdqa     xmm5, kAddUV128

     sub        edi, edx             // stride from u to v

     align      4

  convertloop:

     /* step 1 - subsample 16x2 argb pixels to 8x1 */

     movdqu     xmm0, [eax]

     movdqu     xmm1, [eax + 16]

     movdqu     xmm2, [eax + 32]

     movdqu     xmm3, [eax + 48]

     movdqu     xmm4, [eax + esi]

     pavgb      xmm0, xmm4

     movdqu     xmm4, [eax + esi + 16]

     pavgb      xmm1, xmm4

     movdqu     xmm4, [eax + esi + 32]

     pavgb      xmm2, xmm4

     movdqu     xmm4, [eax + esi + 48]

     pavgb      xmm3, xmm4

     lea        eax,  [eax + 64]

     movdqa     xmm4, xmm0

     shufps     xmm0, xmm1, 0x88

     shufps     xmm4, xmm1, 0xdd

     pavgb      xmm0, xmm4

     movdqa     xmm4, xmm2

     shufps     xmm2, xmm3, 0x88

     shufps     xmm4, xmm3, 0xdd

     pavgb      xmm2, xmm4

     // step 2 - convert to U and V

     // from here down is very similar to Y code except

     // instead of 16 different pixels, its 8 pixels of U and 8 of V

     movdqa     xmm1, xmm0

     movdqa     xmm3, xmm2

     pmaddubsw  xmm0, xmm7  // U

     pmaddubsw  xmm2, xmm7

     pmaddubsw  xmm1, xmm6  // V

     pmaddubsw  xmm3, xmm6

     phaddw     xmm0, xmm2

     phaddw     xmm1, xmm3

     psraw      xmm0, 8

     psraw      xmm1, 8

     packsswb   xmm0, xmm1

     paddb      xmm0, xmm5            // -> unsigned

     // step 3 - store 8 U and 8 V values

     sub        ecx, 16

     movlps     qword ptr [edx], xmm0 // U

     movhps     qword ptr [edx + edi], xmm0 // V

     lea        edx, [edx + 8]

     jg         convertloop

     pop        edi

     pop        esi

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void RGBAToUVRow_SSSE3(const uint8* src_argb0, int src_stride_argb,

                        uint8* dst_u, uint8* dst_v, int width) {

   __asm {

     push       esi

     push       edi

     mov        eax, [esp + 8 + 4]   // src_argb

     mov        esi, [esp + 8 + 8]   // src_stride_argb

     mov        edx, [esp + 8 + 12]  // dst_u

     mov        edi, [esp + 8 + 16]  // dst_v

     mov        ecx, [esp + 8 + 20]  // pix

     movdqa     xmm7, kRGBAToU

     movdqa     xmm6, kRGBAToV

     movdqa     xmm5, kAddUV128

     sub        edi, edx             // stride from u to v

     align      4

  convertloop:

     /* step 1 - subsample 16x2 argb pixels to 8x1 */

     movdqa     xmm0, [eax]

     movdqa     xmm1, [eax + 16]

     movdqa     xmm2, [eax + 32]

     movdqa     xmm3, [eax + 48]

     pavgb      xmm0, [eax + esi]

     pavgb      xmm1, [eax + esi + 16]

     pavgb      xmm2, [eax + esi + 32]

     pavgb      xmm3, [eax + esi + 48]

     lea        eax,  [eax + 64]

     movdqa     xmm4, xmm0

     shufps     xmm0, xmm1, 0x88

     shufps     xmm4, xmm1, 0xdd

     pavgb      xmm0, xmm4

     movdqa     xmm4, xmm2

     shufps     xmm2, xmm3, 0x88

     shufps     xmm4, xmm3, 0xdd

     pavgb      xmm2, xmm4

     // step 2 - convert to U and V

     // from here down is very similar to Y code except

     // instead of 16 different pixels, its 8 pixels of U and 8 of V

     movdqa     xmm1, xmm0

     movdqa     xmm3, xmm2

     pmaddubsw  xmm0, xmm7  // U

     pmaddubsw  xmm2, xmm7

     pmaddubsw  xmm1, xmm6  // V

     pmaddubsw  xmm3, xmm6

     phaddw     xmm0, xmm2

     phaddw     xmm1, xmm3

     psraw      xmm0, 8

     psraw      xmm1, 8

     packsswb   xmm0, xmm1

     paddb      xmm0, xmm5            // -> unsigned

     // step 3 - store 8 U and 8 V values

     sub        ecx, 16

     movlps     qword ptr [edx], xmm0 // U

     movhps     qword ptr [edx + edi], xmm0 // V

     lea        edx, [edx + 8]

     jg         convertloop

     pop        edi

     pop        esi

     ret

   }

 }

 __declspec(naked) __declspec(align(16))

 void RGBAToUVRow_Unaligned_SSSE3(const uint8* src_argb0, int src_stride_argb,

                                  uint8* dst_u, uint8* dst_v, int width) {

   __asm {

     push       esi

     push       edi

     mov        eax, [esp + 8 + 4]   // src_argb

     mov        esi, [esp + 8 + 8]   // src_stride_argb

     mov        edx, [esp + 8 + 12]  // dst_u

     mov        edi, [esp + 8 + 16]  // dst_v

     mov        ecx, [esp + 8 + 20]  // pix

     movdqa     xmm7, kRGBAToU

     movdqa     xmm6, kRGBAToV

     movdqa     xmm5, kAddUV128

     sub        edi, edx             // stride from u to v

     align      4

  convertloop:

     /* step 1 - subsample 16x2 argb pixels to 8x1 */

     movdqu     xmm0, [eax]

     movdqu     xmm1, [eax + 16]

     movdqu     xmm2, [eax + 32]

     movdqu     xmm3, [eax + 48]

     movdqu     xmm4, [eax + esi]

     pavgb      xmm0, xmm4

     movdqu     xmm4, [eax + esi + 16]

     pavgb      xmm1, xmm4

     movdqu     xmm4, [eax + esi + 32]

     pavgb      xmm2, xmm4

     movdqu     xmm4, [eax + esi + 48]

     pavgb      xmm3, xmm4

     lea        eax,  [eax + 64]

     movdqa     xmm4, xmm0

     shufps     xmm0, xmm1, 0x88

     shufps     xmm4, xmm1, 0xdd

     pavgb      xmm0, xmm4

     movdqa     xmm4, xmm2

     shufps     xmm2, xmm3, 0x88

     shufps     xmm4, xmm3, 0xdd

     pavgb      xmm2, xmm4

     // step 2 - convert to U and V

     // from here down is very similar to Y code except

     // instead of 16 different pixels, its 8 pixels of U and 8 of V

     movdqa     xmm1, xmm0

     movdqa     xmm3, xmm2

     pmaddubsw  xmm0, xmm7  // U

     pmaddubsw  xmm2, xmm7

     pmaddubsw  xmm1, xmm6  // V

     pmaddubsw  xmm3, xmm6

     phaddw     xmm0, xmm2

     phaddw     xmm1, xmm3

     psraw      xmm0, 8

     psraw      xmm1, 8

     packsswb   xmm0, xmm1

     paddb      xmm0, xmm5            // -> unsigned

     // step 3 - store 8 U and 8 V values

     sub        ecx, 16

     movlps     qword ptr [edx], xmm0 // U

     movhps     qword ptr [edx + edi], xmm0 // V

     lea        edx, [edx + 8]

     jg         convertloop

     pop        edi

     pop        esi

     ret

   }

 }

 #endif  // HAS_ARGBTOYROW_SSSE3

 #define YG 74 /* (int8)(1.164 * 64 + 0.5) */

 #define UB 127 /* min(63,(int8)(2.018 * 64)) */

 #define UG -25 /* (int8)(-0.391 * 64 - 0.5) */

 #define UR 0

 #define VB 0

 #define VG -52 /* (int8)(-0.813 * 64 - 0.5) */

 #define VR 102 /* (int8)(1.596 * 64 + 0.5) */

 // Bias

 #define BB UB * 128 + VB * 128

 #define BG UG * 128 + VG * 128

 #define BR UR * 128 + VR * 128

 #ifdef HAS_I422TOARGBROW_AVX2

 static const lvec8 kUVToB_AVX = {

   UB, VB, UB, VB, UB, VB, UB, VB, UB, VB, UB, VB, UB, VB, UB, VB,

   UB, VB, UB, VB, UB, VB, UB, VB, UB, VB, UB, VB, UB, VB, UB, VB

 };

 static const lvec8 kUVToR_AVX = {

   UR, VR, UR, VR, UR, VR, UR, VR, UR, VR, UR, VR, UR, VR, UR, VR,

   UR, VR, UR, VR, UR, VR, UR, VR, UR, VR, UR, VR, UR, VR, UR, VR

 };

 static const lvec8 kUVToG_AVX = {

   UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG,

   UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG

 };

 static const lvec16 kYToRgb_AVX = {

   YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG

 };

 static const lvec16 kYSub16_AVX = {

   16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16

 };

 static const lvec16 kUVBiasB_AVX = {

   BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB

 };

 static const lvec16 kUVBiasG_AVX = {

   BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG

 };

 static const lvec16 kUVBiasR_AVX = {

   BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR

 };

 // 16 pixels

 // 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes).

 __declspec(naked) __declspec(align(16))

 void I422ToARGBRow_AVX2(const uint8* y_buf,

                          const uint8* u_buf,

                          const uint8* v_buf,

                          uint8* dst_argb,

                          int width) {

   __asm {

     push       esi

     push       edi

     mov        eax, [esp + 8 + 4]   // Y

     mov        esi, [esp + 8 + 8]   // U

     mov        edi, [esp + 8 + 12]  // V

     mov        edx, [esp + 8 + 16]  // argb

     mov        ecx, [esp + 8 + 20]  // width

     sub        edi, esi

     vpcmpeqb   ymm5, ymm5, ymm5     // generate 0xffffffffffffffff for alpha

     vpxor      ymm4, ymm4, ymm4

     align      4

  convertloop:

     vmovq      xmm0, qword ptr [esi]          //  U

     vmovq      xmm1, qword ptr [esi + edi]    //  V

     lea        esi,  [esi + 8]

     vpunpcklbw ymm0, ymm0, ymm1               // UV

     vpermq     ymm0, ymm0, 0xd8

     vpunpcklwd ymm0, ymm0, ymm0              // UVUV

     vpmaddubsw ymm2, ymm0, kUVToB_AVX        // scale B UV

     vpmaddubsw ymm1, ymm0, kUVToG_AVX        // scale G UV

     vpmaddubsw ymm0, ymm0, kUVToR_AVX        // scale R UV

     vpsubw     ymm2, ymm2, kUVBiasB_AVX      // unbias back to signed

     vpsubw     ymm1, ymm1, kUVBiasG_AVX

     vpsubw     ymm0, ymm0, kUVBiasR_AVX

     // Step 2: Find Y contribution to 16 R,G,B values

     vmovdqu    xmm3, [eax]                  // NOLINT

     lea        eax, [eax + 16]

     vpermq     ymm3, ymm3, 0xd8

     vpunpcklbw ymm3, ymm3, ymm4

     vpsubsw    ymm3, ymm3, kYSub16_AVX

     vpmullw    ymm3, ymm3, kYToRgb_AVX

     vpaddsw    ymm2, ymm2, ymm3           // B += Y

     vpaddsw    ymm1, ymm1, ymm3           // G += Y

     vpaddsw    ymm0, ymm0, ymm3           // R += Y

     vpsraw     ymm2, ymm2, 6

     vpsraw     ymm1, ymm1, 6

     vpsraw     ymm0, ymm0, 6

     vpackuswb  ymm2, ymm2, ymm2           // B

     vpackuswb  ymm1, ymm1, ymm1           // G

     vpackuswb  ymm0, ymm0, ymm0           // R

     // Step 3: Weave into ARGB

     vpunpcklbw ymm2, ymm2, ymm1           // BG

     vpermq     ymm2, ymm2, 0xd8

     vpunpcklbw ymm0, ymm0, ymm5           // RA

     vpermq     ymm0, ymm0, 0xd8

     vpunpcklwd ymm1, ymm2, ymm0           // BGRA first 8 pixels

     vpunpckhwd ymm2, ymm2, ymm0           // BGRA next 8 pixels

     vmovdqu    [edx], ymm1

     vmovdqu    [edx + 32], ymm2

     lea        edx,  [edx + 64]

     sub        ecx, 16

     jg         convertloop

     vzeroupper

     pop        edi

     pop        esi

     ret

   }

 }

 #endif  // HAS_I422TOARGBROW_AVX2

 #ifdef HAS_I422TOARGBROW_SSSE3

 static const vec8 kUVToB = {

   UB, VB, UB, VB, UB, VB, UB, VB, UB, VB, UB, VB, UB, VB, UB, VB

 };

 static const vec8 kUVToR = {

   UR, VR, UR, VR, UR, VR, UR, VR, UR, VR, UR, VR, UR, VR, UR, VR

 };

 static const vec8 kUVToG = {

   UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG

 };

 static const vec8 kVUToB = {

   VB, UB, VB, UB, VB, UB, VB, UB, VB, UB, VB, UB, VB, UB, VB, UB,

 };

 static const vec8 kVUToR = {

   VR, UR, VR, UR, VR, UR, VR, UR, VR, UR, VR, UR, VR, UR, VR, UR,

 };

 static const vec8 kVUToG = {

   VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG,

 };

 static const vec16 kYToRgb = { YG, YG, YG, YG, YG, YG, YG, YG };

 static const vec16 kYSub16 = { 16, 16, 16, 16, 16, 16, 16, 16 };

 static const vec16 kUVBiasB = { BB, BB, BB, BB, BB, BB, BB, BB };

 static const vec16 kUVBiasG = { BG, BG, BG, BG, BG, BG, BG, BG };

 static const vec16 kUVBiasR = { BR, BR, BR, BR, BR, BR, BR, BR };

 // 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 */                /* NOLINT */ \

     __asm movq       xmm1, qword ptr [esi + edi] /* V */          /* NOLINT */ \

     __asm lea        esi,  [esi + 8]                                           \

     __asm punpcklbw  xmm0, xmm1           /* UV */                             \

   }

 // 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) */                \

   }

 // Read 2 UV from 411, upsample to 8 UV.

 #define READYUV411 __asm {                                                     \

     __asm movzx      ebx, word ptr [esi]        /* U */           /* NOLINT */ \

     __asm movd       xmm0, ebx                                                 \

     __asm movzx      ebx, word ptr [esi + edi]  /* V */           /* NOLINT */ \

     __asm movd       xmm1, ebx                                                 \

     __asm lea        esi,  [esi + 2]                                           \

     __asm punpcklbw  xmm0, xmm1           /* UV */                             \

     __asm punpcklwd  xmm0, xmm0           /* UVUV (upsample) */                \

     __asm punpckldq  xmm0, xmm0           /* UVUV (upsample) */                \

   }

 // Read 4 UV from NV12, upsample to 8 UV.

 #define READNV12 __asm {                                                       \

     __asm movq       xmm0, qword ptr [esi] /* UV */               /* NOLINT */ \

     __asm lea        esi,  [esi + 8]                                           \

     __asm punpcklwd  xmm0, xmm0           /* UVUV (upsample) */                \

   }

 // Convert 8 pixels: 8 UV and 8 Y.

 #define YUVTORGB __asm {                                                       \

     /* Step 1: Find 4 UV contributions to 8 R,G,B values */                    \

     __asm movdqa     xmm1, xmm0                                                \

     __asm movdqa     xmm2, xmm0                                                \

     __asm pmaddubsw  xmm0, kUVToB        /* scale B UV */                      \

     __asm pmaddubsw  xmm1, kUVToG        /* scale G UV */                      \

     __asm pmaddubsw  xmm2, kUVToR        /* scale R UV */                      \

     __asm psubw      xmm0, kUVBiasB      /* unbias back to signed */           \

     __asm psubw      xmm1, kUVBiasG                                            \

     __asm psubw      xmm2, kUVBiasR                                            \

     /* Step 2: Find Y contribution to 8 R,G,B values */                        \

     __asm movq       xmm3, qword ptr [eax]                        /* NOLINT */ \

     __asm lea        eax, [eax + 8]                                            \

     __asm punpcklbw  xmm3, xmm4                                                \

     __asm psubsw     xmm3, kYSub16                                             \

     __asm pmullw     xmm3, kYToRgb                                             \

     __asm paddsw     xmm0, xmm3           /* B += Y */                         \

     __asm paddsw     xmm1, xmm3           /* G += Y */                         \

     __asm paddsw     xmm2, xmm3           /* 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 */                              \

   }

 // Convert 8 pixels: 8 VU and 8 Y.

 #define YVUTORGB __asm {                                                       \

     /* Step 1: Find 4 UV contributions to 8 R,G,B values */                    \

     __asm movdqa     xmm1, xmm0                                                \

     __asm movdqa     xmm2, xmm0                                                \

     __asm pmaddubsw  xmm0, kVUToB        /* scale B UV */                      \

     __asm pmaddubsw  xmm1, kVUToG        /* scale G UV */                      \

     __asm pmaddubsw  xmm2, kVUToR        /* scale R UV */                      \

     __asm psubw      xmm0, kUVBiasB      /* unbias back to signed */           \

     __asm psubw      xmm1, kUVBiasG                                            \

     __asm psubw      xmm2, kUVBiasR                                            \

     /* Step 2: Find Y contribution to 8 R,G,B values */                        \

     __asm movq       xmm3, qword ptr [eax]                        /* NOLINT */ \

     __asm lea        eax, [eax + 8]                                            \

     __asm punpcklbw  xmm3, xmm4                                                \

     __asm psubsw     xmm3, kYSub16                                             \

     __asm pmullw     xmm3, kYToRgb                                             \

     __asm paddsw     xmm0, xmm3           /* B += Y */                         \

     __asm paddsw     xmm1, xmm3           /* G += Y */                         \

     __asm paddsw     xmm2, xmm3           /* 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 */                              \

   }

 // 8 pixels, dest aligned 16.

 // 8 UV values, mixed with 8 Y producing 8 ARGB (32 bytes).

 __declspec(naked) __declspec(align(16))

 void I444ToARGBRow_SSSE3(const uint8* y_buf,

                          const uint8* u_buf,

                          const uint8* v_buf,

                          uint8* dst_argb,

                          int width) {

   __asm {

     push       esi

     push       edi

     mov        eax, [esp + 8 + 4]   // Y

     mov        esi, [esp + 8 + 8]   // U

     mov        edi, [esp + 8 + 12]  // V

     mov        edx, [esp + 8 + 16]  // argb

     mov        ecx, [esp + 8 + 20]  // width

     sub        edi, esi

     pcmpeqb    xmm5, xmm5           // generate 0xffffffff for alpha

     pxor       xmm4, xmm4

     align      4

  convertloop:

     READYUV444

     YUVTORGB

     // Step 3: Weave into ARGB

     punpcklbw  xmm0, xmm1           // BG

     punpcklbw  xmm2, xmm5           // RA

     movdqa     xmm1, xmm0

     punpcklwd  xmm0, xmm2           // BGRA first 4 pixels

     punpckhwd  xmm1, xmm2           // BGRA next 4 pixels

     movdqa     [edx], xmm0

     movdqa     [edx + 16], xmm1

     lea        edx,  [edx + 32]

     sub        ecx, 8

     jg         convertloop

     pop        edi

     pop        esi

     ret

   }

 }

 // 8 pixels, dest aligned 16.

 // 4 UV values upsampled to 8 UV, mixed with 8 Y producing 8 ARGB (32 bytes).

 __declspec(naked) __declspec(align(16))

 void I422ToRGB24Row_SSSE3(const uint8* y_buf,

                           const uint8* u_buf,

                           const uint8* v_buf,

                           uint8* dst_rgb24,

                           int width) {

   __asm {

     push       esi

     push       edi

     mov        eax, [esp + 8 + 4]   // Y

     mov        esi, [esp + 8 + 8]   // U

     mov        edi, [esp + 8 + 12]  // V

     mov        edx, [esp + 8 + 16]  // rgb24

     mov        ecx, [esp + 8 + 20]  // width

     sub        edi, esi

     pxor       xmm4, xmm4

     movdqa     xmm5, kShuffleMaskARGBToRGB24_0

     movdqa     xmm6, kShuffleMaskARGBToRGB24

     align      4

  convertloop:

     READYUV422

     YUVTORGB

     // Step 3: Weave into RRGB

     punpcklbw  xmm0, xmm1           // BG

     punpcklbw  xmm2, xmm2           // RR

     movdqa     xmm1, xmm0

     punpcklwd  xmm0, xmm2           // BGRR first 4 pixels

     punpckhwd  xmm1, xmm2           // BGRR next 4 pixels

     pshufb     xmm0, xmm5           // Pack into first 8 and last 4 bytes.

     pshufb     xmm1, xmm6           // Pack into first 12 bytes.

     palignr    xmm1, xmm0, 12       // last 4 bytes of xmm0 + 12 from xmm1

     movq       qword ptr [edx], xmm0  // First 8 bytes

     movdqu     [edx + 8], xmm1      // Last 16 bytes. = 24 bytes, 8 RGB pixels.

     lea        edx,  [edx + 24]

     sub        ecx, 8

     jg         convertloop

     pop        edi

     pop        esi

     ret

   }

 }

 // 8 pixels, dest aligned 16.

 // 4 UV values upsampled to 8 UV, mixed with 8 Y producing 8 ARGB (32 bytes).

 __declspec(naked) __declspec(align(16))

 void I422ToRAWRow_SSSE3(const uint8* y_buf,

                         const uint8* u_buf,

                         const uint8* v_buf,

                         uint8* dst_raw,

                         int width) {

   __asm {

     push       esi

     push       edi

     mov        eax, [esp + 8 + 4]   // Y

     mov        esi, [esp + 8 + 8]   // U

     mov        edi, [esp + 8 + 12]  // V

     mov        edx, [esp + 8 + 16]  // raw

     mov        ecx, [esp + 8 + 20]  // width

     sub        edi, esi

     pxor       xmm4, xmm4

     movdqa     xmm5, kShuffleMaskARGBToRAW_0

     movdqa     xmm6, kShuffleMaskARGBToRAW

     align      4

  convertloop:

     READYUV422

     YUVTORGB

     // Step 3: Weave into RRGB

     punpcklbw  xmm0, xmm1           // BG

     punpcklbw  xmm2, xmm2           // RR

     movdqa     xmm1, xmm0

     punpcklwd  xmm0, xmm2           // BGRR first 4 pixels

     punpckhwd  xmm1, xmm2           // BGRR next 4 pixels

     pshufb     xmm0, xmm5           // Pack into first 8 and last 4 bytes.

     pshufb     xmm1, xmm6           // Pack into first 12 bytes.

     palignr    xmm1, xmm0, 12       // last 4 bytes of xmm0 + 12 from xmm1

     movq       qword ptr [edx], xmm0  // First 8 bytes

     movdqu     [edx + 8], xmm1      // Last 16 bytes. = 24 bytes, 8 RGB pixels.

     lea        edx,  [edx + 24]

     sub        ecx, 8

     jg         convertloop

     pop        edi

     pop        esi

     ret

   }

 }

 // 8 pixels, dest unaligned.

 // 4 UV values upsampled to 8 UV, mixed with 8 Y producing 8 ARGB (32 bytes).

 __declspec(naked) __declspec(align(16))

 void I422ToRGB565Row_SSSE3(const uint8* y_buf,

                            const uint8* u_buf,

                            const uint8* v_buf,

                            uint8* rgb565_buf,

                            int width) {

   __asm {

     push       esi

     push       edi

     mov        eax, [esp + 8 + 4]   // Y

     mov        esi, [esp + 8 + 8]   // U

     mov        edi, [esp + 8 + 12]  // V

     mov        edx, [esp + 8 + 16]  // rgb565

     mov        ecx, [esp + 8 + 20]  // width

     sub        edi, esi

     pxor       xmm4, xmm4

     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

     align      4

  convertloop:

     READYUV422

     YUVTORGB

     // Step 3: Weave into RRGB

     punpcklbw  xmm0, xmm1           // BG

     punpcklbw  xmm2, xmm2           // RR

     movdqa     xmm1, xmm0

     punpcklwd  xmm0, xmm2           // BGRR first 4 pixels

     punpckhwd  xmm1, xmm2           // BGRR next 4 pixels

     // Step 3b: RRGB -> RGB565

     movdqa     xmm3, xmm0    // B  first 4 pixels of argb

     movdqa     xmm2, xmm0    // G

     pslld      xmm0, 8       // R

     psrld      xmm3, 3       // B

     psrld      xmm2, 5       // G

     psrad      xmm0, 16      // R

     pand       xmm3, xmm5    // B

     pand       xmm2, xmm6    // G

     pand       xmm0, xmm7    // R

     por        xmm3, xmm2    // BG

     por        xmm0, xmm3    // BGR

     movdqa     xmm3, xmm1    // B  next 4 pixels of argb

     movdqa     xmm2, xmm1    // G

     pslld      xmm1, 8       // R

     psrld      xmm3, 3       // B

     psrld      xmm2, 5       // G

     psrad      xmm1, 16      // R

     pand       xmm3, xmm5    // B

     pand       xmm2, xmm6    // G

     pand       xmm1, xmm7    // R

     por        xmm3, xmm2    // BG

     por        xmm1, xmm3    // BGR

     packssdw   xmm0, xmm1

     sub        ecx, 8

     movdqu     [edx], xmm0   // store 8 pixels of RGB565

     lea        edx, [edx + 16]

     jg         convertloop

     pop        edi

     pop        esi

     ret

   }

 }

 // 8 pixels, dest aligned 16.

 // 4 UV values upsampled to 8 UV, mixed with 8 Y producing 8 ARGB (32 bytes).

 __declspec(naked) __declspec(align(16))

 void I422ToARGBRow_SSSE3(const uint8* y_buf,

                          const uint8* u_buf,

                          const uint8* v_buf,

                          uint8* dst_argb,

                          int width) {

   __asm {

     push       esi

     push       edi

     mov        eax, [esp + 8 + 4]   // Y

     mov        esi, [esp + 8 + 8]   // U

     mov        edi, [esp + 8 + 12]  // V

     mov        edx, [esp + 8 + 16]  // argb

     mov        ecx, [esp + 8 + 20]  // width

     sub        edi, esi

     pcmpeqb    xmm5, xmm5           // generate 0xffffffff for alpha

     pxor       xmm4, xmm4

     align      4

  convertloop:

     READYUV422

     YUVTORGB

     // Step 3: Weave into ARGB

     punpcklbw  xmm0, xmm1           // BG

     punpcklbw  xmm2, xmm5           // RA

     movdqa     xmm1, xmm0

     punpcklwd  xmm0, xmm2           // BGRA first 4 pixels

     punpckhwd  xmm1, xmm2           // BGRA next 4 pixels

     movdqa     [edx], xmm0

     movdqa     [edx + 16], xmm1

     lea        edx,  [edx + 32]

     sub        ecx, 8

     jg         convertloop

     pop        edi

     pop        esi

     ret

   }

 }

 // 8 pixels, dest aligned 16.

 // 2 UV values upsampled to 8 UV, mixed with 8 Y producing 8 ARGB (32 bytes).

 // Similar to I420 but duplicate UV once more.

 __declspec(naked) __declspec(align(16))

 void I411ToARGBRow_SSSE3(const uint8* y_buf,

                          const uint8* u_buf,

                          const uint8* v_buf,

                          uint8* dst_argb,

                          int width) {

   __asm {

     push       ebx

     push       esi

     push       edi

     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        ecx, [esp + 12 + 20]  // width

     sub        edi, esi

     pcmpeqb    xmm5, xmm5           // generate 0xffffffff for alpha

     pxor       xmm4, xmm4

     align      4

  convertloop:

     READYUV411  // modifies EBX

     YUVTORGB

     // Step 3: Weave into ARGB

     punpcklbw  xmm0, xmm1           // BG

     punpcklbw  xmm2, xmm5           // RA

     movdqa     xmm1, xmm0

     punpcklwd  xmm0, xmm2           // BGRA first 4 pixels

     punpckhwd  xmm1, xmm2           // BGRA next 4 pixels

     movdqa     [edx], xmm0

     movdqa     [edx + 16], xmm1

     lea        edx,  [edx + 32]

     sub        ecx, 8

     jg         convertloop

     pop        edi

     pop        esi

     pop        ebx

     ret

   }

 }

 // 8 pixels, dest aligned 16.

 // 4 UV values upsampled to 8 UV, mixed with 8 Y producing 8 ARGB (32 bytes).

 __declspec(naked) __declspec(align(16))

 void NV12ToARGBRow_SSSE3(const uint8* y_buf,

                          const uint8* uv_buf,

                          uint8* dst_argb,

                          int width) {

   __asm {

     push       esi

     mov        eax, [esp + 4 + 4]   // Y

     mov        esi, [esp + 4 + 8]   // UV

     mov        edx, [esp + 4 + 12]  // argb

     mov        ecx, [esp + 4 + 16]  // width

     pcmpeqb    xmm5, xmm5           // generate 0xffffffff for alpha

     pxor       xmm4, xmm4

     align      4

  convertloop:

     READNV12

     YUVTORGB

     // Step 3: Weave into ARGB

     punpcklbw  xmm0, xmm1           // BG

     punpcklbw  xmm2, xmm5           // RA

     movdqa     xmm1, xmm0

     punpcklwd  xmm0, xmm2           // BGRA first 4 pixels

     punpckhwd  xmm1, xmm2           // BGRA next 4 pixels

     movdqa     [edx], xmm0

     movdqa     [edx + 16], xmm1

     lea        edx,  [edx + 32]

     sub        ecx, 8

     jg         convertloop

     pop        esi

     ret

   }

 }

 // 8 pixels, dest aligned 16.

 // 4 UV values upsampled to 8 UV, mixed with 8 Y producing 8 ARGB (32 bytes).

 __declspec(naked) __declspec(align(16))

 void NV21ToARGBRow_SSSE3(const uint8* y_buf,

                          const uint8* uv_buf,

                          uint8* dst_argb,

                          int width) {

   __asm {

     push       esi

     mov        eax, [esp + 4 + 4]   // Y

     mov        esi, [esp + 4 + 8]   // VU

     mov        edx, [esp + 4 + 12]  // argb

     mov        ecx, [esp + 4 + 16]  // width

     pcmpeqb    xmm5, xmm5           // generate 0xffffffff for alpha

     pxor       xmm4, xmm4

     align      4

  convertloop:

     READNV12

     YVUTORGB

     // Step 3: Weave into ARGB

     punpcklbw  xmm0, xmm1           // BG

     punpcklbw  xmm2, xmm5           // RA

     movdqa     xmm1, xmm0

     punpcklwd  xmm0, xmm2           // BGRA first 4 pixels

     punpckhwd  xmm1, xmm2           // BGRA next 4 pixels

     movdqa     [edx], xmm0

     movdqa     [edx + 16], xmm1

     lea        edx,  [edx + 32]

     sub        ecx, 8

     jg         convertloop

     pop        esi