/*
 *  Copyright 2013 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"
#include "libyuv/scale_row.h"

#ifdef __cplusplus
namespace libyuv {
extern "C" {
#endif

// This module is for GCC x86 and x64.
#if !defined(LIBYUV_DISABLE_X86) && \
    (defined(__x86_64__) || (defined(__i386__) && !defined(_MSC_VER)))

// Offsets for source bytes 0 to 9
static const uvec8 kShuf0 = {0,   1,   3,   4,   5,   7,   8,   9,
                             128, 128, 128, 128, 128, 128, 128, 128};

// Offsets for source bytes 11 to 20 with 8 subtracted = 3 to 12.
static const uvec8 kShuf1 = {3,   4,   5,   7,   8,   9,   11,  12,
                             128, 128, 128, 128, 128, 128, 128, 128};

// Offsets for source bytes 21 to 31 with 16 subtracted = 5 to 31.
static const uvec8 kShuf2 = {5,   7,   8,   9,   11,  12,  13,  15,
                             128, 128, 128, 128, 128, 128, 128, 128};

// Offsets for source bytes 0 to 10
static const uvec8 kShuf01 = {0, 1, 1, 2, 2, 3, 4, 5, 5, 6, 6, 7, 8, 9, 9, 10};

// Offsets for source bytes 10 to 21 with 8 subtracted = 3 to 13.
static const uvec8 kShuf11 = {2, 3, 4, 5,  5,  6,  6,  7,
                              8, 9, 9, 10, 10, 11, 12, 13};

// Offsets for source bytes 21 to 31 with 16 subtracted = 5 to 31.
static const uvec8 kShuf21 = {5,  6,  6,  7,  8,  9,  9,  10,
                              10, 11, 12, 13, 13, 14, 14, 15};

// Coefficients for source bytes 0 to 10
static const uvec8 kMadd01 = {3, 1, 2, 2, 1, 3, 3, 1, 2, 2, 1, 3, 3, 1, 2, 2};

// Coefficients for source bytes 10 to 21
static const uvec8 kMadd11 = {1, 3, 3, 1, 2, 2, 1, 3, 3, 1, 2, 2, 1, 3, 3, 1};

// Coefficients for source bytes 21 to 31
static const uvec8 kMadd21 = {2, 2, 1, 3, 3, 1, 2, 2, 1, 3, 3, 1, 2, 2, 1, 3};

// Coefficients for source bytes 21 to 31
static const vec16 kRound34 = {2, 2, 2, 2, 2, 2, 2, 2};

static const uvec8 kShuf38a = {0,   3,   6,   8,   11,  14,  128, 128,
                               128, 128, 128, 128, 128, 128, 128, 128};

static const uvec8 kShuf38b = {128, 128, 128, 128, 128, 128, 0,   3,
                               6,   8,   11,  14,  128, 128, 128, 128};

// Arrange words 0,3,6 into 0,1,2
static const uvec8 kShufAc = {0,   1,   6,   7,   12,  13,  128, 128,
                              128, 128, 128, 128, 128, 128, 128, 128};

// Arrange words 0,3,6 into 3,4,5
static const uvec8 kShufAc3 = {128, 128, 128, 128, 128, 128, 0,   1,
                               6,   7,   12,  13,  128, 128, 128, 128};

// Scaling values for boxes of 3x3 and 2x3
static const uvec16 kScaleAc33 = {65536 / 9, 65536 / 9, 65536 / 6, 65536 / 9,
                                  65536 / 9, 65536 / 6, 0,         0};

// Arrange first value for pixels 0,1,2,3,4,5
static const uvec8 kShufAb0 = {0,  128, 3,  128, 6,   128, 8,   128,
                               11, 128, 14, 128, 128, 128, 128, 128};

// Arrange second value for pixels 0,1,2,3,4,5
static const uvec8 kShufAb1 = {1,  128, 4,  128, 7,   128, 9,   128,
                               12, 128, 15, 128, 128, 128, 128, 128};

// Arrange third value for pixels 0,1,2,3,4,5
static const uvec8 kShufAb2 = {2,  128, 5,   128, 128, 128, 10,  128,
                               13, 128, 128, 128, 128, 128, 128, 128};

// Scaling values for boxes of 3x2 and 2x2
static const uvec16 kScaleAb2 = {65536 / 3, 65536 / 3, 65536 / 2, 65536 / 3,
                                 65536 / 3, 65536 / 2, 0,         0};

// GCC versions of row functions are verbatim conversions from Visual C.
// Generated using gcc disassembly on Visual C object file:
// objdump -D yuvscaler.obj >yuvscaler.txt

void ScaleRowDown2_SSSE3(const uint8_t* src_ptr,
                         ptrdiff_t src_stride,
                         uint8_t* dst_ptr,
                         int dst_width) {
  (void)src_stride;
  asm volatile(
      // 16 pixel loop.
      LABELALIGN
      "1:                                        \n"
      "movdqu    (%0),%%xmm0                     \n"
      "movdqu    0x10(%0),%%xmm1                 \n"
      "lea       0x20(%0),%0                     \n"
      "psrlw     $0x8,%%xmm0                     \n"
      "psrlw     $0x8,%%xmm1                     \n"
      "packuswb  %%xmm1,%%xmm0                   \n"
      "movdqu    %%xmm0,(%1)                     \n"
      "lea       0x10(%1),%1                     \n"
      "sub       $0x10,%2                        \n"
      "jg        1b                              \n"
      : "+r"(src_ptr),   // %0
        "+r"(dst_ptr),   // %1
        "+r"(dst_width)  // %2
        ::"memory",
        "cc", "xmm0", "xmm1");
}

void ScaleRowDown2Linear_SSSE3(const uint8_t* src_ptr,
                               ptrdiff_t src_stride,
                               uint8_t* dst_ptr,
                               int dst_width) {
  (void)src_stride;
  asm volatile(
      "pcmpeqb    %%xmm4,%%xmm4                  \n"
      "psrlw      $0xf,%%xmm4                    \n"
      "packuswb   %%xmm4,%%xmm4                  \n"
      "pxor       %%xmm5,%%xmm5                  \n"

      LABELALIGN
      "1:                                        \n"
      "movdqu    (%0),%%xmm0                     \n"
      "movdqu    0x10(%0),%%xmm1                 \n"
      "lea       0x20(%0),%0                     \n"
      "pmaddubsw  %%xmm4,%%xmm0                  \n"
      "pmaddubsw  %%xmm4,%%xmm1                  \n"
      "pavgw      %%xmm5,%%xmm0                  \n"
      "pavgw      %%xmm5,%%xmm1                  \n"
      "packuswb   %%xmm1,%%xmm0                  \n"
      "movdqu    %%xmm0,(%1)                     \n"
      "lea       0x10(%1),%1                     \n"
      "sub       $0x10,%2                        \n"
      "jg        1b                              \n"
      : "+r"(src_ptr),   // %0
        "+r"(dst_ptr),   // %1
        "+r"(dst_width)  // %2
        ::"memory",
        "cc", "xmm0", "xmm1", "xmm4", "xmm5");
}

void ScaleRowDown2Box_SSSE3(const uint8_t* src_ptr,
                            ptrdiff_t src_stride,
                            uint8_t* dst_ptr,
                            int dst_width) {
  asm volatile(
      "pcmpeqb    %%xmm4,%%xmm4                  \n"
      "psrlw      $0xf,%%xmm4                    \n"
      "packuswb   %%xmm4,%%xmm4                  \n"
      "pxor       %%xmm5,%%xmm5                  \n"

      LABELALIGN
      "1:                                        \n"
      "movdqu    (%0),%%xmm0                     \n"
      "movdqu    0x10(%0),%%xmm1                 \n"
      "movdqu    0x00(%0,%3,1),%%xmm2            \n"
      "movdqu    0x10(%0,%3,1),%%xmm3            \n"
      "lea       0x20(%0),%0                     \n"
      "pmaddubsw  %%xmm4,%%xmm0                  \n"
      "pmaddubsw  %%xmm4,%%xmm1                  \n"
      "pmaddubsw  %%xmm4,%%xmm2                  \n"
      "pmaddubsw  %%xmm4,%%xmm3                  \n"
      "paddw      %%xmm2,%%xmm0                  \n"
      "paddw      %%xmm3,%%xmm1                  \n"
      "psrlw      $0x1,%%xmm0                    \n"
      "psrlw      $0x1,%%xmm1                    \n"
      "pavgw      %%xmm5,%%xmm0                  \n"
      "pavgw      %%xmm5,%%xmm1                  \n"
      "packuswb   %%xmm1,%%xmm0                  \n"
      "movdqu    %%xmm0,(%1)                     \n"
      "lea       0x10(%1),%1                     \n"
      "sub       $0x10,%2                        \n"
      "jg        1b                              \n"
      : "+r"(src_ptr),               // %0
        "+r"(dst_ptr),               // %1
        "+r"(dst_width)              // %2
      : "r"((intptr_t)(src_stride))  // %3
      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
}

#ifdef HAS_SCALEROWDOWN2_AVX2
void ScaleRowDown2_AVX2(const uint8_t* src_ptr,
                        ptrdiff_t src_stride,
                        uint8_t* dst_ptr,
                        int dst_width) {
  (void)src_stride;
  asm volatile(

      LABELALIGN
      "1:                                        \n"
      "vmovdqu    (%0),%%ymm0                    \n"
      "vmovdqu    0x20(%0),%%ymm1                \n"
      "lea        0x40(%0),%0                    \n"
      "vpsrlw     $0x8,%%ymm0,%%ymm0             \n"
      "vpsrlw     $0x8,%%ymm1,%%ymm1             \n"
      "vpackuswb  %%ymm1,%%ymm0,%%ymm0           \n"
      "vpermq     $0xd8,%%ymm0,%%ymm0            \n"
      "vmovdqu    %%ymm0,(%1)                    \n"
      "lea        0x20(%1),%1                    \n"
      "sub        $0x20,%2                       \n"
      "jg         1b                             \n"
      "vzeroupper                                \n"
      : "+r"(src_ptr),   // %0
        "+r"(dst_ptr),   // %1
        "+r"(dst_width)  // %2
        ::"memory",
        "cc", "xmm0", "xmm1");
}

void ScaleRowDown2Linear_AVX2(const uint8_t* src_ptr,
                              ptrdiff_t src_stride,
                              uint8_t* dst_ptr,
                              int dst_width) {
  (void)src_stride;
  asm volatile(
      "vpcmpeqb   %%ymm4,%%ymm4,%%ymm4           \n"
      "vpsrlw     $0xf,%%ymm4,%%ymm4             \n"
      "vpackuswb  %%ymm4,%%ymm4,%%ymm4           \n"
      "vpxor      %%ymm5,%%ymm5,%%ymm5           \n"

      LABELALIGN
      "1:                                        \n"
      "vmovdqu    (%0),%%ymm0                    \n"
      "vmovdqu    0x20(%0),%%ymm1                \n"
      "lea        0x40(%0),%0                    \n"
      "vpmaddubsw %%ymm4,%%ymm0,%%ymm0           \n"
      "vpmaddubsw %%ymm4,%%ymm1,%%ymm1           \n"
      "vpavgw     %%ymm5,%%ymm0,%%ymm0           \n"
      "vpavgw     %%ymm5,%%ymm1,%%ymm1           \n"
      "vpackuswb  %%ymm1,%%ymm0,%%ymm0           \n"
      "vpermq     $0xd8,%%ymm0,%%ymm0            \n"
      "vmovdqu    %%ymm0,(%1)                    \n"
      "lea        0x20(%1),%1                    \n"
      "sub        $0x20,%2                       \n"
      "jg         1b                             \n"
      "vzeroupper                                \n"
      : "+r"(src_ptr),   // %0
        "+r"(dst_ptr),   // %1
        "+r"(dst_width)  // %2
        ::"memory",
        "cc", "xmm0", "xmm1", "xmm4", "xmm5");
}

void ScaleRowDown2Box_AVX2(const uint8_t* src_ptr,
                           ptrdiff_t src_stride,
                           uint8_t* dst_ptr,
                           int dst_width) {
  asm volatile(
      "vpcmpeqb   %%ymm4,%%ymm4,%%ymm4           \n"
      "vpsrlw     $0xf,%%ymm4,%%ymm4             \n"
      "vpackuswb  %%ymm4,%%ymm4,%%ymm4           \n"
      "vpxor      %%ymm5,%%ymm5,%%ymm5           \n"

      LABELALIGN
      "1:                                        \n"
      "vmovdqu    (%0),%%ymm0                    \n"
      "vmovdqu    0x20(%0),%%ymm1                \n"
      "vmovdqu    0x00(%0,%3,1),%%ymm2           \n"
      "vmovdqu    0x20(%0,%3,1),%%ymm3           \n"
      "lea        0x40(%0),%0                    \n"
      "vpmaddubsw %%ymm4,%%ymm0,%%ymm0           \n"
      "vpmaddubsw %%ymm4,%%ymm1,%%ymm1           \n"
      "vpmaddubsw %%ymm4,%%ymm2,%%ymm2           \n"
      "vpmaddubsw %%ymm4,%%ymm3,%%ymm3           \n"
      "vpaddw     %%ymm2,%%ymm0,%%ymm0           \n"
      "vpaddw     %%ymm3,%%ymm1,%%ymm1           \n"
      "vpsrlw     $0x1,%%ymm0,%%ymm0             \n"
      "vpsrlw     $0x1,%%ymm1,%%ymm1             \n"
      "vpavgw     %%ymm5,%%ymm0,%%ymm0           \n"
      "vpavgw     %%ymm5,%%ymm1,%%ymm1           \n"
      "vpackuswb  %%ymm1,%%ymm0,%%ymm0           \n"
      "vpermq     $0xd8,%%ymm0,%%ymm0            \n"
      "vmovdqu    %%ymm0,(%1)                    \n"
      "lea        0x20(%1),%1                    \n"
      "sub        $0x20,%2                       \n"
      "jg         1b                             \n"
      "vzeroupper                                \n"
      : "+r"(src_ptr),               // %0
        "+r"(dst_ptr),               // %1
        "+r"(dst_width)              // %2
      : "r"((intptr_t)(src_stride))  // %3
      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
}
#endif  // HAS_SCALEROWDOWN2_AVX2

void ScaleRowDown4_SSSE3(const uint8_t* src_ptr,
                         ptrdiff_t src_stride,
                         uint8_t* dst_ptr,
                         int dst_width) {
  (void)src_stride;
  asm volatile(
      "pcmpeqb   %%xmm5,%%xmm5                   \n"
      "psrld     $0x18,%%xmm5                    \n"
      "pslld     $0x10,%%xmm5                    \n"

      LABELALIGN
      "1:                                        \n"
      "movdqu    (%0),%%xmm0                     \n"
      "movdqu    0x10(%0),%%xmm1                 \n"
      "lea       0x20(%0),%0                     \n"
      "pand      %%xmm5,%%xmm0                   \n"
      "pand      %%xmm5,%%xmm1                   \n"
      "packuswb  %%xmm1,%%xmm0                   \n"
      "psrlw     $0x8,%%xmm0                     \n"
      "packuswb  %%xmm0,%%xmm0                   \n"
      "movq      %%xmm0,(%1)                     \n"
      "lea       0x8(%1),%1                      \n"
      "sub       $0x8,%2                         \n"
      "jg        1b                              \n"
      : "+r"(src_ptr),   // %0
        "+r"(dst_ptr),   // %1
        "+r"(dst_width)  // %2
        ::"memory",
        "cc", "xmm0", "xmm1", "xmm5");
}

void ScaleRowDown4Box_SSSE3(const uint8_t* src_ptr,
                            ptrdiff_t src_stride,
                            uint8_t* dst_ptr,
                            int dst_width) {
  intptr_t stridex3;
  asm volatile(
      "pcmpeqb    %%xmm4,%%xmm4                  \n"
      "psrlw      $0xf,%%xmm4                    \n"
      "movdqa     %%xmm4,%%xmm5                  \n"
      "packuswb   %%xmm4,%%xmm4                  \n"
      "psllw      $0x3,%%xmm5                    \n"
      "lea       0x00(%4,%4,2),%3                \n"

      LABELALIGN
      "1:                                        \n"
      "movdqu    (%0),%%xmm0                     \n"
      "movdqu    0x10(%0),%%xmm1                 \n"
      "movdqu    0x00(%0,%4,1),%%xmm2            \n"
      "movdqu    0x10(%0,%4,1),%%xmm3            \n"
      "pmaddubsw  %%xmm4,%%xmm0                  \n"
      "pmaddubsw  %%xmm4,%%xmm1                  \n"
      "pmaddubsw  %%xmm4,%%xmm2                  \n"
      "pmaddubsw  %%xmm4,%%xmm3                  \n"
      "paddw      %%xmm2,%%xmm0                  \n"
      "paddw      %%xmm3,%%xmm1                  \n"
      "movdqu    0x00(%0,%4,2),%%xmm2            \n"
      "movdqu    0x10(%0,%4,2),%%xmm3            \n"
      "pmaddubsw  %%xmm4,%%xmm2                  \n"
      "pmaddubsw  %%xmm4,%%xmm3                  \n"
      "paddw      %%xmm2,%%xmm0                  \n"
      "paddw      %%xmm3,%%xmm1                  \n"
      "movdqu    0x00(%0,%3,1),%%xmm2            \n"
      "movdqu    0x10(%0,%3,1),%%xmm3            \n"
      "lea       0x20(%0),%0                     \n"
      "pmaddubsw  %%xmm4,%%xmm2                  \n"
      "pmaddubsw  %%xmm4,%%xmm3                  \n"
      "paddw      %%xmm2,%%xmm0                  \n"
      "paddw      %%xmm3,%%xmm1                  \n"
      "phaddw     %%xmm1,%%xmm0                  \n"
      "paddw      %%xmm5,%%xmm0                  \n"
      "psrlw      $0x4,%%xmm0                    \n"
      "packuswb   %%xmm0,%%xmm0                  \n"
      "movq      %%xmm0,(%1)                     \n"
      "lea       0x8(%1),%1                      \n"
      "sub       $0x8,%2                         \n"
      "jg        1b                              \n"
      : "+r"(src_ptr),               // %0
        "+r"(dst_ptr),               // %1
        "+r"(dst_width),             // %2
        "=&r"(stridex3)              // %3
      : "r"((intptr_t)(src_stride))  // %4
      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
}

#ifdef HAS_SCALEROWDOWN4_AVX2
void ScaleRowDown4_AVX2(const uint8_t* src_ptr,
                        ptrdiff_t src_stride,
                        uint8_t* dst_ptr,
                        int dst_width) {
  (void)src_stride;
  asm volatile(
      "vpcmpeqb   %%ymm5,%%ymm5,%%ymm5           \n"
      "vpsrld     $0x18,%%ymm5,%%ymm5            \n"
      "vpslld     $0x10,%%ymm5,%%ymm5            \n"

      LABELALIGN
      "1:                                        \n"
      "vmovdqu    (%0),%%ymm0                    \n"
      "vmovdqu    0x20(%0),%%ymm1                \n"
      "lea        0x40(%0),%0                    \n"
      "vpand      %%ymm5,%%ymm0,%%ymm0           \n"
      "vpand      %%ymm5,%%ymm1,%%ymm1           \n"
      "vpackuswb  %%ymm1,%%ymm0,%%ymm0           \n"
      "vpermq     $0xd8,%%ymm0,%%ymm0            \n"
      "vpsrlw     $0x8,%%ymm0,%%ymm0             \n"
      "vpackuswb  %%ymm0,%%ymm0,%%ymm0           \n"
      "vpermq     $0xd8,%%ymm0,%%ymm0            \n"
      "vmovdqu    %%xmm0,(%1)                    \n"
      "lea        0x10(%1),%1                    \n"
      "sub        $0x10,%2                       \n"
      "jg         1b                             \n"
      "vzeroupper                                \n"
      : "+r"(src_ptr),   // %0
        "+r"(dst_ptr),   // %1
        "+r"(dst_width)  // %2
        ::"memory",
        "cc", "xmm0", "xmm1", "xmm5");
}

void ScaleRowDown4Box_AVX2(const uint8_t* src_ptr,
                           ptrdiff_t src_stride,
                           uint8_t* dst_ptr,
                           int dst_width) {
  asm volatile(
      "vpcmpeqb   %%ymm4,%%ymm4,%%ymm4           \n"
      "vpsrlw     $0xf,%%ymm4,%%ymm4             \n"
      "vpsllw     $0x3,%%ymm4,%%ymm5             \n"
      "vpackuswb  %%ymm4,%%ymm4,%%ymm4           \n"

      LABELALIGN
      "1:                                        \n"
      "vmovdqu    (%0),%%ymm0                    \n"
      "vmovdqu    0x20(%0),%%ymm1                \n"
      "vmovdqu    0x00(%0,%3,1),%%ymm2           \n"
      "vmovdqu    0x20(%0,%3,1),%%ymm3           \n"
      "vpmaddubsw %%ymm4,%%ymm0,%%ymm0           \n"
      "vpmaddubsw %%ymm4,%%ymm1,%%ymm1           \n"
      "vpmaddubsw %%ymm4,%%ymm2,%%ymm2           \n"
      "vpmaddubsw %%ymm4,%%ymm3,%%ymm3           \n"
      "vpaddw     %%ymm2,%%ymm0,%%ymm0           \n"
      "vpaddw     %%ymm3,%%ymm1,%%ymm1           \n"
      "vmovdqu    0x00(%0,%3,2),%%ymm2           \n"
      "vmovdqu    0x20(%0,%3,2),%%ymm3           \n"
      "vpmaddubsw %%ymm4,%%ymm2,%%ymm2           \n"
      "vpmaddubsw %%ymm4,%%ymm3,%%ymm3           \n"
      "vpaddw     %%ymm2,%%ymm0,%%ymm0           \n"
      "vpaddw     %%ymm3,%%ymm1,%%ymm1           \n"
      "vmovdqu    0x00(%0,%4,1),%%ymm2           \n"
      "vmovdqu    0x20(%0,%4,1),%%ymm3           \n"
      "lea        0x40(%0),%0                    \n"
      "vpmaddubsw %%ymm4,%%ymm2,%%ymm2           \n"
      "vpmaddubsw %%ymm4,%%ymm3,%%ymm3           \n"
      "vpaddw     %%ymm2,%%ymm0,%%ymm0           \n"
      "vpaddw     %%ymm3,%%ymm1,%%ymm1           \n"
      "vphaddw    %%ymm1,%%ymm0,%%ymm0           \n"
      "vpermq     $0xd8,%%ymm0,%%ymm0            \n"
      "vpaddw     %%ymm5,%%ymm0,%%ymm0           \n"
      "vpsrlw     $0x4,%%ymm0,%%ymm0             \n"
      "vpackuswb  %%ymm0,%%ymm0,%%ymm0           \n"
      "vpermq     $0xd8,%%ymm0,%%ymm0            \n"
      "vmovdqu    %%xmm0,(%1)                    \n"
      "lea        0x10(%1),%1                    \n"
      "sub        $0x10,%2                       \n"
      "jg         1b                             \n"
      "vzeroupper                                \n"
      : "+r"(src_ptr),                   // %0
        "+r"(dst_ptr),                   // %1
        "+r"(dst_width)                  // %2
      : "r"((intptr_t)(src_stride)),     // %3
        "r"((intptr_t)(src_stride * 3))  // %4
      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
}
#endif  // HAS_SCALEROWDOWN4_AVX2

void ScaleRowDown34_SSSE3(const uint8_t* src_ptr,
                          ptrdiff_t src_stride,
                          uint8_t* dst_ptr,
                          int dst_width) {
  (void)src_stride;
  asm volatile(
      "movdqa    %0,%%xmm3                       \n"
      "movdqa    %1,%%xmm4                       \n"
      "movdqa    %2,%%xmm5                       \n"
      :
      : "m"(kShuf0),  // %0
        "m"(kShuf1),  // %1
        "m"(kShuf2)   // %2
  );
  asm volatile(

      LABELALIGN
      "1:                                        \n"
      "movdqu    (%0),%%xmm0                     \n"
      "movdqu    0x10(%0),%%xmm2                 \n"
      "lea       0x20(%0),%0                     \n"
      "movdqa    %%xmm2,%%xmm1                   \n"
      "palignr   $0x8,%%xmm0,%%xmm1              \n"
      "pshufb    %%xmm3,%%xmm0                   \n"
      "pshufb    %%xmm4,%%xmm1                   \n"
      "pshufb    %%xmm5,%%xmm2                   \n"
      "movq      %%xmm0,(%1)                     \n"
      "movq      %%xmm1,0x8(%1)                  \n"
      "movq      %%xmm2,0x10(%1)                 \n"
      "lea       0x18(%1),%1                     \n"
      "sub       $0x18,%2                        \n"
      "jg        1b                              \n"
      : "+r"(src_ptr),   // %0
        "+r"(dst_ptr),   // %1
        "+r"(dst_width)  // %2
        ::"memory",
        "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
}

void ScaleRowDown34_1_Box_SSSE3(const uint8_t* src_ptr,
                                ptrdiff_t src_stride,
                                uint8_t* dst_ptr,
                                int dst_width) {
  asm volatile(
      "movdqa    %0,%%xmm2                       \n"  // kShuf01
      "movdqa    %1,%%xmm3                       \n"  // kShuf11
      "movdqa    %2,%%xmm4                       \n"  // kShuf21
      :
      : "m"(kShuf01),  // %0
        "m"(kShuf11),  // %1
        "m"(kShuf21)   // %2
  );
  asm volatile(
      "movdqa    %0,%%xmm5                       \n"  // kMadd01
      "movdqa    %1,%%xmm0                       \n"  // kMadd11
      "movdqa    %2,%%xmm1                       \n"  // kRound34
      :
      : "m"(kMadd01),  // %0
        "m"(kMadd11),  // %1
        "m"(kRound34)  // %2
  );
  asm volatile(

      LABELALIGN
      "1:                                        \n"
      "movdqu    (%0),%%xmm6                     \n"
      "movdqu    0x00(%0,%3,1),%%xmm7            \n"
      "pavgb     %%xmm7,%%xmm6                   \n"
      "pshufb    %%xmm2,%%xmm6                   \n"
      "pmaddubsw %%xmm5,%%xmm6                   \n"
      "paddsw    %%xmm1,%%xmm6                   \n"
      "psrlw     $0x2,%%xmm6                     \n"
      "packuswb  %%xmm6,%%xmm6                   \n"
      "movq      %%xmm6,(%1)                     \n"
      "movdqu    0x8(%0),%%xmm6                  \n"
      "movdqu    0x8(%0,%3,1),%%xmm7             \n"
      "pavgb     %%xmm7,%%xmm6                   \n"
      "pshufb    %%xmm3,%%xmm6                   \n"
      "pmaddubsw %%xmm0,%%xmm6                   \n"
      "paddsw    %%xmm1,%%xmm6                   \n"
      "psrlw     $0x2,%%xmm6                     \n"
      "packuswb  %%xmm6,%%xmm6                   \n"
      "movq      %%xmm6,0x8(%1)                  \n"
      "movdqu    0x10(%0),%%xmm6                 \n"
      "movdqu    0x10(%0,%3,1),%%xmm7            \n"
      "lea       0x20(%0),%0                     \n"
      "pavgb     %%xmm7,%%xmm6                   \n"
      "pshufb    %%xmm4,%%xmm6                   \n"
      "pmaddubsw %4,%%xmm6                       \n"
      "paddsw    %%xmm1,%%xmm6                   \n"
      "psrlw     $0x2,%%xmm6                     \n"
      "packuswb  %%xmm6,%%xmm6                   \n"
      "movq      %%xmm6,0x10(%1)                 \n"
      "lea       0x18(%1),%1                     \n"
      "sub       $0x18,%2                        \n"
      "jg        1b                              \n"
      : "+r"(src_ptr),                // %0
        "+r"(dst_ptr),                // %1
        "+r"(dst_width)               // %2
      : "r"((intptr_t)(src_stride)),  // %3
        "m"(kMadd21)                  // %4
      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
        "xmm7");
}

void ScaleRowDown34_0_Box_SSSE3(const uint8_t* src_ptr,
                                ptrdiff_t src_stride,
                                uint8_t* dst_ptr,
                                int dst_width) {
  asm volatile(
      "movdqa    %0,%%xmm2                       \n"  // kShuf01
      "movdqa    %1,%%xmm3                       \n"  // kShuf11
      "movdqa    %2,%%xmm4                       \n"  // kShuf21
      :
      : "m"(kShuf01),  // %0
        "m"(kShuf11),  // %1
        "m"(kShuf21)   // %2
  );
  asm volatile(
      "movdqa    %0,%%xmm5                       \n"  // kMadd01
      "movdqa    %1,%%xmm0                       \n"  // kMadd11
      "movdqa    %2,%%xmm1                       \n"  // kRound34
      :
      : "m"(kMadd01),  // %0
        "m"(kMadd11),  // %1
        "m"(kRound34)  // %2
  );

  asm volatile(

      LABELALIGN
      "1:                                        \n"
      "movdqu    (%0),%%xmm6                     \n"
      "movdqu    0x00(%0,%3,1),%%xmm7            \n"
      "pavgb     %%xmm6,%%xmm7                   \n"
      "pavgb     %%xmm7,%%xmm6                   \n"
      "pshufb    %%xmm2,%%xmm6                   \n"
      "pmaddubsw %%xmm5,%%xmm6                   \n"
      "paddsw    %%xmm1,%%xmm6                   \n"
      "psrlw     $0x2,%%xmm6                     \n"
      "packuswb  %%xmm6,%%xmm6                   \n"
      "movq      %%xmm6,(%1)                     \n"
      "movdqu    0x8(%0),%%xmm6                  \n"
      "movdqu    0x8(%0,%3,1),%%xmm7             \n"
      "pavgb     %%xmm6,%%xmm7                   \n"
      "pavgb     %%xmm7,%%xmm6                   \n"
      "pshufb    %%xmm3,%%xmm6                   \n"
      "pmaddubsw %%xmm0,%%xmm6                   \n"
      "paddsw    %%xmm1,%%xmm6                   \n"
      "psrlw     $0x2,%%xmm6                     \n"
      "packuswb  %%xmm6,%%xmm6                   \n"
      "movq      %%xmm6,0x8(%1)                  \n"
      "movdqu    0x10(%0),%%xmm6                 \n"
      "movdqu    0x10(%0,%3,1),%%xmm7            \n"
      "lea       0x20(%0),%0                     \n"
      "pavgb     %%xmm6,%%xmm7                   \n"
      "pavgb     %%xmm7,%%xmm6                   \n"
      "pshufb    %%xmm4,%%xmm6                   \n"
      "pmaddubsw %4,%%xmm6                       \n"
      "paddsw    %%xmm1,%%xmm6                   \n"
      "psrlw     $0x2,%%xmm6                     \n"
      "packuswb  %%xmm6,%%xmm6                   \n"
      "movq      %%xmm6,0x10(%1)                 \n"
      "lea       0x18(%1),%1                     \n"
      "sub       $0x18,%2                        \n"
      "jg        1b                              \n"
      : "+r"(src_ptr),                // %0
        "+r"(dst_ptr),                // %1
        "+r"(dst_width)               // %2
      : "r"((intptr_t)(src_stride)),  // %3
        "m"(kMadd21)                  // %4
      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
        "xmm7");
}

void ScaleRowDown38_SSSE3(const uint8_t* src_ptr,
                          ptrdiff_t src_stride,
                          uint8_t* dst_ptr,
                          int dst_width) {
  (void)src_stride;
  asm volatile(
      "movdqa    %3,%%xmm4                       \n"
      "movdqa    %4,%%xmm5                       \n"

      LABELALIGN
      "1:                                        \n"
      "movdqu    (%0),%%xmm0                     \n"
      "movdqu    0x10(%0),%%xmm1                 \n"
      "lea       0x20(%0),%0                     \n"
      "pshufb    %%xmm4,%%xmm0                   \n"
      "pshufb    %%xmm5,%%xmm1                   \n"
      "paddusb   %%xmm1,%%xmm0                   \n"
      "movq      %%xmm0,(%1)                     \n"
      "movhlps   %%xmm0,%%xmm1                   \n"
      "movd      %%xmm1,0x8(%1)                  \n"
      "lea       0xc(%1),%1                      \n"
      "sub       $0xc,%2                         \n"
      "jg        1b                              \n"
      : "+r"(src_ptr),   // %0
        "+r"(dst_ptr),   // %1
        "+r"(dst_width)  // %2
      : "m"(kShuf38a),   // %3
        "m"(kShuf38b)    // %4
      : "memory", "cc", "xmm0", "xmm1", "xmm4", "xmm5");
}

void ScaleRowDown38_2_Box_SSSE3(const uint8_t* src_ptr,
                                ptrdiff_t src_stride,
                                uint8_t* dst_ptr,
                                int dst_width) {
  asm volatile(
      "movdqa    %0,%%xmm2                       \n"
      "movdqa    %1,%%xmm3                       \n"
      "movdqa    %2,%%xmm4                       \n"
      "movdqa    %3,%%xmm5                       \n"
      :
      : "m"(kShufAb0),  // %0
        "m"(kShufAb1),  // %1
        "m"(kShufAb2),  // %2
        "m"(kScaleAb2)  // %3
  );
  asm volatile(

      LABELALIGN
      "1:                                        \n"
      "movdqu    (%0),%%xmm0                     \n"
      "movdqu    0x00(%0,%3,1),%%xmm1            \n"
      "lea       0x10(%0),%0                     \n"
      "pavgb     %%xmm1,%%xmm0                   \n"
      "movdqa    %%xmm0,%%xmm1                   \n"
      "pshufb    %%xmm2,%%xmm1                   \n"
      "movdqa    %%xmm0,%%xmm6                   \n"
      "pshufb    %%xmm3,%%xmm6                   \n"
      "paddusw   %%xmm6,%%xmm1                   \n"
      "pshufb    %%xmm4,%%xmm0                   \n"
      "paddusw   %%xmm0,%%xmm1                   \n"
      "pmulhuw   %%xmm5,%%xmm1                   \n"
      "packuswb  %%xmm1,%%xmm1                   \n"
      "movd      %%xmm1,(%1)                     \n"
      "psrlq     $0x10,%%xmm1                    \n"
      "movd      %%xmm1,0x2(%1)                  \n"
      "lea       0x6(%1),%1                      \n"
      "sub       $0x6,%2                         \n"
      "jg        1b                              \n"
      : "+r"(src_ptr),               // %0
        "+r"(dst_ptr),               // %1
        "+r"(dst_width)              // %2
      : "r"((intptr_t)(src_stride))  // %3
      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
}

void ScaleRowDown38_3_Box_SSSE3(const uint8_t* src_ptr,
                                ptrdiff_t src_stride,
                                uint8_t* dst_ptr,
                                int dst_width) {
  asm volatile(
      "movdqa    %0,%%xmm2                       \n"
      "movdqa    %1,%%xmm3                       \n"
      "movdqa    %2,%%xmm4                       \n"
      "pxor      %%xmm5,%%xmm5                   \n"
      :
      : "m"(kShufAc),    // %0
        "m"(kShufAc3),   // %1
        "m"(kScaleAc33)  // %2
  );
  asm volatile(

      LABELALIGN
      "1:                                        \n"
      "movdqu    (%0),%%xmm0                     \n"
      "movdqu    0x00(%0,%3,1),%%xmm6            \n"
      "movhlps   %%xmm0,%%xmm1                   \n"
      "movhlps   %%xmm6,%%xmm7                   \n"
      "punpcklbw %%xmm5,%%xmm0                   \n"
      "punpcklbw %%xmm5,%%xmm1                   \n"
      "punpcklbw %%xmm5,%%xmm6                   \n"
      "punpcklbw %%xmm5,%%xmm7                   \n"
      "paddusw   %%xmm6,%%xmm0                   \n"
      "paddusw   %%xmm7,%%xmm1                   \n"
      "movdqu    0x00(%0,%3,2),%%xmm6            \n"
      "lea       0x10(%0),%0                     \n"
      "movhlps   %%xmm6,%%xmm7                   \n"
      "punpcklbw %%xmm5,%%xmm6                   \n"
      "punpcklbw %%xmm5,%%xmm7                   \n"
      "paddusw   %%xmm6,%%xmm0                   \n"
      "paddusw   %%xmm7,%%xmm1                   \n"
      "movdqa    %%xmm0,%%xmm6                   \n"
      "psrldq    $0x2,%%xmm0                     \n"
      "paddusw   %%xmm0,%%xmm6                   \n"
      "psrldq    $0x2,%%xmm0                     \n"
      "paddusw   %%xmm0,%%xmm6                   \n"
      "pshufb    %%xmm2,%%xmm6                   \n"
      "movdqa    %%xmm1,%%xmm7                   \n"
      "psrldq    $0x2,%%xmm1                     \n"
      "paddusw   %%xmm1,%%xmm7                   \n"
      "psrldq    $0x2,%%xmm1                     \n"
      "paddusw   %%xmm1,%%xmm7                   \n"
      "pshufb    %%xmm3,%%xmm7                   \n"
      "paddusw   %%xmm7,%%xmm6                   \n"
      "pmulhuw   %%xmm4,%%xmm6                   \n"
      "packuswb  %%xmm6,%%xmm6                   \n"
      "movd      %%xmm6,(%1)                     \n"
      "psrlq     $0x10,%%xmm6                    \n"
      "movd      %%xmm6,0x2(%1)                  \n"
      "lea       0x6(%1),%1                      \n"
      "sub       $0x6,%2                         \n"
      "jg        1b                              \n"
      : "+r"(src_ptr),               // %0
        "+r"(dst_ptr),               // %1
        "+r"(dst_width)              // %2
      : "r"((intptr_t)(src_stride))  // %3
      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
        "xmm7");
}

// Reads 16xN bytes and produces 16 shorts at a time.
void ScaleAddRow_SSE2(const uint8_t* src_ptr,
                      uint16_t* dst_ptr,
                      int src_width) {
  asm volatile(

      "pxor      %%xmm5,%%xmm5                   \n"

      // 16 pixel loop.
      LABELALIGN
      "1:                                        \n"
      "movdqu    (%0),%%xmm3                     \n"
      "lea       0x10(%0),%0                     \n"  // src_ptr += 16
      "movdqu    (%1),%%xmm0                     \n"
      "movdqu    0x10(%1),%%xmm1                 \n"
      "movdqa    %%xmm3,%%xmm2                   \n"
      "punpcklbw %%xmm5,%%xmm2                   \n"
      "punpckhbw %%xmm5,%%xmm3                   \n"
      "paddusw   %%xmm2,%%xmm0                   \n"
      "paddusw   %%xmm3,%%xmm1                   \n"
      "movdqu    %%xmm0,(%1)                     \n"
      "movdqu    %%xmm1,0x10(%1)                 \n"
      "lea       0x20(%1),%1                     \n"
      "sub       $0x10,%2                        \n"
      "jg        1b                              \n"
      : "+r"(src_ptr),   // %0
        "+r"(dst_ptr),   // %1
        "+r"(src_width)  // %2
      :
      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
}

#ifdef HAS_SCALEADDROW_AVX2
// Reads 32 bytes and accumulates to 32 shorts at a time.
void ScaleAddRow_AVX2(const uint8_t* src_ptr,
                      uint16_t* dst_ptr,
                      int src_width) {
  asm volatile(

      "vpxor      %%ymm5,%%ymm5,%%ymm5           \n"

      LABELALIGN
      "1:                                        \n"
      "vmovdqu    (%0),%%ymm3                    \n"
      "lea        0x20(%0),%0                    \n"  // src_ptr += 32
      "vpermq     $0xd8,%%ymm3,%%ymm3            \n"
      "vpunpcklbw %%ymm5,%%ymm3,%%ymm2           \n"
      "vpunpckhbw %%ymm5,%%ymm3,%%ymm3           \n"
      "vpaddusw   (%1),%%ymm2,%%ymm0             \n"
      "vpaddusw   0x20(%1),%%ymm3,%%ymm1         \n"
      "vmovdqu    %%ymm0,(%1)                    \n"
      "vmovdqu    %%ymm1,0x20(%1)                \n"
      "lea       0x40(%1),%1                     \n"
      "sub       $0x20,%2                        \n"
      "jg        1b                              \n"
      "vzeroupper                                \n"
      : "+r"(src_ptr),   // %0
        "+r"(dst_ptr),   // %1
        "+r"(src_width)  // %2
      :
      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
}
#endif  // HAS_SCALEADDROW_AVX2

// Constant for making pixels signed to avoid pmaddubsw
// saturation.
static const uvec8 kFsub80 = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
                              0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80};

// Constant for making pixels unsigned and adding .5 for rounding.
static const uvec16 kFadd40 = {0x4040, 0x4040, 0x4040, 0x4040,
                               0x4040, 0x4040, 0x4040, 0x4040};

// Bilinear column filtering. SSSE3 version.
void ScaleFilterCols_SSSE3(uint8_t* dst_ptr,
                           const uint8_t* src_ptr,
                           int dst_width,
                           int x,
                           int dx) {
  intptr_t x0, x1, temp_pixel;
  asm volatile(
      "movd      %6,%%xmm2                       \n"
      "movd      %7,%%xmm3                       \n"
      "movl      $0x04040000,%k2                 \n"
      "movd      %k2,%%xmm5                      \n"
      "pcmpeqb   %%xmm6,%%xmm6                   \n"
      "psrlw     $0x9,%%xmm6                     \n"  // 0x007f007f
      "pcmpeqb   %%xmm7,%%xmm7                   \n"
      "psrlw     $15,%%xmm7                      \n"  // 0x00010001

      "pextrw    $0x1,%%xmm2,%k3                 \n"
      "subl      $0x2,%5                         \n"
      "jl        29f                             \n"
      "movdqa    %%xmm2,%%xmm0                   \n"
      "paddd     %%xmm3,%%xmm0                   \n"
      "punpckldq %%xmm0,%%xmm2                   \n"
      "punpckldq %%xmm3,%%xmm3                   \n"
      "paddd     %%xmm3,%%xmm3                   \n"
      "pextrw    $0x3,%%xmm2,%k4                 \n"

      LABELALIGN
      "2:                                        \n"
      "movdqa    %%xmm2,%%xmm1                   \n"
      "paddd     %%xmm3,%%xmm2                   \n"
      "movzwl    0x00(%1,%3,1),%k2               \n"
      "movd      %k2,%%xmm0                      \n"
      "psrlw     $0x9,%%xmm1                     \n"
      "movzwl    0x00(%1,%4,1),%k2               \n"
      "movd      %k2,%%xmm4                      \n"
      "pshufb    %%xmm5,%%xmm1                   \n"
      "punpcklwd %%xmm4,%%xmm0                   \n"
      "psubb     %8,%%xmm0                       \n"  // make pixels signed.
      "pxor      %%xmm6,%%xmm1                   \n"  // 128 - f = (f ^ 127 ) +
                                                      // 1
      "paddusb   %%xmm7,%%xmm1                   \n"
      "pmaddubsw %%xmm0,%%xmm1                   \n"
      "pextrw    $0x1,%%xmm2,%k3                 \n"
      "pextrw    $0x3,%%xmm2,%k4                 \n"
      "paddw     %9,%%xmm1                       \n"  // make pixels unsigned.
      "psrlw     $0x7,%%xmm1                     \n"
      "packuswb  %%xmm1,%%xmm1                   \n"
      "movd      %%xmm1,%k2                      \n"
      "mov       %w2,(%0)                        \n"
      "lea       0x2(%0),%0                      \n"
      "subl      $0x2,%5                         \n"
      "jge       2b                              \n"

      LABELALIGN
      "29:                                       \n"
      "addl      $0x1,%5                         \n"
      "jl        99f                             \n"
      "movzwl    0x00(%1,%3,1),%k2               \n"
      "movd      %k2,%%xmm0                      \n"
      "psrlw     $0x9,%%xmm2                     \n"
      "pshufb    %%xmm5,%%xmm2                   \n"
      "psubb     %8,%%xmm0                       \n"  // make pixels signed.
      "pxor      %%xmm6,%%xmm2                   \n"
      "paddusb   %%xmm7,%%xmm2                   \n"
      "pmaddubsw %%xmm0,%%xmm2                   \n"
      "paddw     %9,%%xmm2                       \n"  // make pixels unsigned.
      "psrlw     $0x7,%%xmm2                     \n"
      "packuswb  %%xmm2,%%xmm2                   \n"
      "movd      %%xmm2,%k2                      \n"
      "mov       %b2,(%0)                        \n"
      "99:                                       \n"
      : "+r"(dst_ptr),      // %0
        "+r"(src_ptr),      // %1
        "=&a"(temp_pixel),  // %2
        "=&r"(x0),          // %3
        "=&r"(x1),          // %4
#if defined(__x86_64__)
        "+rm"(dst_width)  // %5
#else
        "+m"(dst_width)  // %5
#endif
      : "rm"(x),   // %6
        "rm"(dx),  // %7
#if defined(__x86_64__)
        "x"(kFsub80),  // %8
        "x"(kFadd40)   // %9
#else
        "m"(kFsub80),    // %8
        "m"(kFadd40)     // %9
#endif
      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
        "xmm7");
}

// Reads 4 pixels, duplicates them and writes 8 pixels.
// Alignment requirement: src_argb 16 byte aligned, dst_argb 16 byte aligned.
void ScaleColsUp2_SSE2(uint8_t* dst_ptr,
                       const uint8_t* src_ptr,
                       int dst_width,
                       int x,
                       int dx) {
  (void)x;
  (void)dx;
  asm volatile(

      LABELALIGN
      "1:                                        \n"
      "movdqu    (%1),%%xmm0                     \n"
      "lea       0x10(%1),%1                     \n"
      "movdqa    %%xmm0,%%xmm1                   \n"
      "punpcklbw %%xmm0,%%xmm0                   \n"
      "punpckhbw %%xmm1,%%xmm1                   \n"
      "movdqu    %%xmm0,(%0)                     \n"
      "movdqu    %%xmm1,0x10(%0)                 \n"
      "lea       0x20(%0),%0                     \n"
      "sub       $0x20,%2                        \n"
      "jg        1b                              \n"

      : "+r"(dst_ptr),   // %0
        "+r"(src_ptr),   // %1
        "+r"(dst_width)  // %2
        ::"memory",
        "cc", "xmm0", "xmm1");
}

void ScaleARGBRowDown2_SSE2(const uint8_t* src_argb,
                            ptrdiff_t src_stride,
                            uint8_t* dst_argb,
                            int dst_width) {
  (void)src_stride;
  asm volatile(

      LABELALIGN
      "1:                                        \n"
      "movdqu    (%0),%%xmm0                     \n"
      "movdqu    0x10(%0),%%xmm1                 \n"
      "lea       0x20(%0),%0                     \n"
      "shufps    $0xdd,%%xmm1,%%xmm0             \n"
      "movdqu    %%xmm0,(%1)                     \n"
      "lea       0x10(%1),%1                     \n"
      "sub       $0x4,%2                         \n"
      "jg        1b                              \n"
      : "+r"(src_argb),  // %0
        "+r"(dst_argb),  // %1
        "+r"(dst_width)  // %2
        ::"memory",
        "cc", "xmm0", "xmm1");
}

void ScaleARGBRowDown2Linear_SSE2(const uint8_t* src_argb,
                                  ptrdiff_t src_stride,
                                  uint8_t* dst_argb,
                                  int dst_width) {
  (void)src_stride;
  asm volatile(

      LABELALIGN
      "1:                                        \n"
      "movdqu    (%0),%%xmm0                     \n"
      "movdqu    0x10(%0),%%xmm1                 \n"
      "lea       0x20(%0),%0                     \n"
      "movdqa    %%xmm0,%%xmm2                   \n"
      "shufps    $0x88,%%xmm1,%%xmm0             \n"
      "shufps    $0xdd,%%xmm1,%%xmm2             \n"
      "pavgb     %%xmm2,%%xmm0                   \n"
      "movdqu    %%xmm0,(%1)                     \n"
      "lea       0x10(%1),%1                     \n"
      "sub       $0x4,%2                         \n"
      "jg        1b                              \n"
      : "+r"(src_argb),  // %0
        "+r"(dst_argb),  // %1
        "+r"(dst_width)  // %2
        ::"memory",
        "cc", "xmm0", "xmm1");
}

void ScaleARGBRowDown2Box_SSE2(const uint8_t* src_argb,
                               ptrdiff_t src_stride,
                               uint8_t* dst_argb,
                               int dst_width) {
  asm volatile(

      LABELALIGN
      "1:                                        \n"
      "movdqu    (%0),%%xmm0                     \n"
      "movdqu    0x10(%0),%%xmm1                 \n"
      "movdqu    0x00(%0,%3,1),%%xmm2            \n"
      "movdqu    0x10(%0,%3,1),%%xmm3            \n"
      "lea       0x20(%0),%0                     \n"
      "pavgb     %%xmm2,%%xmm0                   \n"
      "pavgb     %%xmm3,%%xmm1                   \n"
      "movdqa    %%xmm0,%%xmm2                   \n"
      "shufps    $0x88,%%xmm1,%%xmm0             \n"
      "shufps    $0xdd,%%xmm1,%%xmm2             \n"
      "pavgb     %%xmm2,%%xmm0                   \n"
      "movdqu    %%xmm0,(%1)                     \n"
      "lea       0x10(%1),%1                     \n"
      "sub       $0x4,%2                         \n"
      "jg        1b                              \n"
      : "+r"(src_argb),              // %0
        "+r"(dst_argb),              // %1
        "+r"(dst_width)              // %2
      : "r"((intptr_t)(src_stride))  // %3
      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3");
}

// Reads 4 pixels at a time.
// Alignment requirement: dst_argb 16 byte aligned.
void ScaleARGBRowDownEven_SSE2(const uint8_t* src_argb,
                               ptrdiff_t src_stride,
                               int src_stepx,
                               uint8_t* dst_argb,
                               int dst_width) {
  intptr_t src_stepx_x4 = (intptr_t)(src_stepx);
  intptr_t src_stepx_x12;
  (void)src_stride;
  asm volatile(
      "lea       0x00(,%1,4),%1                  \n"
      "lea       0x00(%1,%1,2),%4                \n"

      LABELALIGN
      "1:                                        \n"
      "movd      (%0),%%xmm0                     \n"
      "movd      0x00(%0,%1,1),%%xmm1            \n"
      "punpckldq %%xmm1,%%xmm0                   \n"
      "movd      0x00(%0,%1,2),%%xmm2            \n"
      "movd      0x00(%0,%4,1),%%xmm3            \n"
      "lea       0x00(%0,%1,4),%0                \n"
      "punpckldq %%xmm3,%%xmm2                   \n"
      "punpcklqdq %%xmm2,%%xmm0                  \n"
      "movdqu    %%xmm0,(%2)                     \n"
      "lea       0x10(%2),%2                     \n"
      "sub       $0x4,%3                         \n"
      "jg        1b                              \n"
      : "+r"(src_argb),       // %0
        "+r"(src_stepx_x4),   // %1
        "+r"(dst_argb),       // %2
        "+r"(dst_width),      // %3
        "=&r"(src_stepx_x12)  // %4
        ::"memory",
        "cc", "xmm0", "xmm1", "xmm2", "xmm3");
}

// Blends four 2x2 to 4x1.
// Alignment requirement: dst_argb 16 byte aligned.
void ScaleARGBRowDownEvenBox_SSE2(const uint8_t* src_argb,
                                  ptrdiff_t src_stride,
                                  int src_stepx,
                                  uint8_t* dst_argb,
                                  int dst_width) {
  intptr_t src_stepx_x4 = (intptr_t)(src_stepx);
  intptr_t src_stepx_x12;
  intptr_t row1 = (intptr_t)(src_stride);
  asm volatile(
      "lea       0x00(,%1,4),%1                  \n"
      "lea       0x00(%1,%1,2),%4                \n"
      "lea       0x00(%0,%5,1),%5                \n"

      LABELALIGN
      "1:                                        \n"
      "movq      (%0),%%xmm0                     \n"
      "movhps    0x00(%0,%1,1),%%xmm0            \n"
      "movq      0x00(%0,%1,2),%%xmm1            \n"
      "movhps    0x00(%0,%4,1),%%xmm1            \n"
      "lea       0x00(%0,%1,4),%0                \n"
      "movq      (%5),%%xmm2                     \n"
      "movhps    0x00(%5,%1,1),%%xmm2            \n"
      "movq      0x00(%5,%1,2),%%xmm3            \n"
      "movhps    0x00(%5,%4,1),%%xmm3            \n"
      "lea       0x00(%5,%1,4),%5                \n"
      "pavgb     %%xmm2,%%xmm0                   \n"
      "pavgb     %%xmm3,%%xmm1                   \n"
      "movdqa    %%xmm0,%%xmm2                   \n"
      "shufps    $0x88,%%xmm1,%%xmm0             \n"
      "shufps    $0xdd,%%xmm1,%%xmm2             \n"
      "pavgb     %%xmm2,%%xmm0                   \n"
      "movdqu    %%xmm0,(%2)                     \n"
      "lea       0x10(%2),%2                     \n"
      "sub       $0x4,%3                         \n"
      "jg        1b                              \n"
      : "+r"(src_argb),        // %0
        "+r"(src_stepx_x4),    // %1
        "+r"(dst_argb),        // %2
        "+rm"(dst_width),      // %3
        "=&r"(src_stepx_x12),  // %4
        "+r"(row1)             // %5
        ::"memory",
        "cc", "xmm0", "xmm1", "xmm2", "xmm3");
}

void ScaleARGBCols_SSE2(uint8_t* dst_argb,
                        const uint8_t* src_argb,
                        int dst_width,
                        int x,
                        int dx) {
  intptr_t x0, x1;
  asm volatile(
      "movd      %5,%%xmm2                       \n"
      "movd      %6,%%xmm3                       \n"
      "pshufd    $0x0,%%xmm2,%%xmm2              \n"
      "pshufd    $0x11,%%xmm3,%%xmm0             \n"
      "paddd     %%xmm0,%%xmm2                   \n"
      "paddd     %%xmm3,%%xmm3                   \n"
      "pshufd    $0x5,%%xmm3,%%xmm0              \n"
      "paddd     %%xmm0,%%xmm2                   \n"
      "paddd     %%xmm3,%%xmm3                   \n"
      "pshufd    $0x0,%%xmm3,%%xmm3              \n"
      "pextrw    $0x1,%%xmm2,%k0                 \n"
      "pextrw    $0x3,%%xmm2,%k1                 \n"
      "cmp       $0x0,%4                         \n"
      "jl        99f                             \n"
      "sub       $0x4,%4                         \n"
      "jl        49f                             \n"

      LABELALIGN
      "40:                                       \n"
      "movd      0x00(%3,%0,4),%%xmm0            \n"
      "movd      0x00(%3,%1,4),%%xmm1            \n"
      "pextrw    $0x5,%%xmm2,%k0                 \n"
      "pextrw    $0x7,%%xmm2,%k1                 \n"
      "paddd     %%xmm3,%%xmm2                   \n"
      "punpckldq %%xmm1,%%xmm0                   \n"
      "movd      0x00(%3,%0,4),%%xmm1            \n"
      "movd      0x00(%3,%1,4),%%xmm4            \n"
      "pextrw    $0x1,%%xmm2,%k0                 \n"
      "pextrw    $0x3,%%xmm2,%k1                 \n"
      "punpckldq %%xmm4,%%xmm1                   \n"
      "punpcklqdq %%xmm1,%%xmm0                  \n"
      "movdqu    %%xmm0,(%2)                     \n"
      "lea       0x10(%2),%2                     \n"
      "sub       $0x4,%4                         \n"
      "jge       40b                             \n"

      "49:                                       \n"
      "test      $0x2,%4                         \n"
      "je        29f                             \n"
      "movd      0x00(%3,%0,4),%%xmm0            \n"
      "movd      0x00(%3,%1,4),%%xmm1            \n"
      "pextrw    $0x5,%%xmm2,%k0                 \n"
      "punpckldq %%xmm1,%%xmm0                   \n"
      "movq      %%xmm0,(%2)                     \n"
      "lea       0x8(%2),%2                      \n"
      "29:                                       \n"
      "test      $0x1,%4                         \n"
      "je        99f                             \n"
      "movd      0x00(%3,%0,4),%%xmm0            \n"
      "movd      %%xmm0,(%2)                     \n"
      "99:                                       \n"
      : "=&a"(x0),       // %0
        "=&d"(x1),       // %1
        "+r"(dst_argb),  // %2
        "+r"(src_argb),  // %3
        "+r"(dst_width)  // %4
      : "rm"(x),         // %5
        "rm"(dx)         // %6
      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4");
}

// Reads 4 pixels, duplicates them and writes 8 pixels.
// Alignment requirement: src_argb 16 byte aligned, dst_argb 16 byte aligned.
void ScaleARGBColsUp2_SSE2(uint8_t* dst_argb,
                           const uint8_t* src_argb,
                           int dst_width,
                           int x,
                           int dx) {
  (void)x;
  (void)dx;
  asm volatile(

      LABELALIGN
      "1:                                        \n"
      "movdqu    (%1),%%xmm0                     \n"
      "lea       0x10(%1),%1                     \n"
      "movdqa    %%xmm0,%%xmm1                   \n"
      "punpckldq %%xmm0,%%xmm0                   \n"
      "punpckhdq %%xmm1,%%xmm1                   \n"
      "movdqu    %%xmm0,(%0)                     \n"
      "movdqu    %%xmm1,0x10(%0)                 \n"
      "lea       0x20(%0),%0                     \n"
      "sub       $0x8,%2                         \n"
      "jg        1b                              \n"

      : "+r"(dst_argb),  // %0
        "+r"(src_argb),  // %1
        "+r"(dst_width)  // %2
        ::"memory",
        "cc", "xmm0", "xmm1");
}

// Shuffle table for arranging 2 pixels into pairs for pmaddubsw
static const uvec8 kShuffleColARGB = {
    0u, 4u,  1u, 5u,  2u,  6u,  3u,  7u,  // bbggrraa 1st pixel
    8u, 12u, 9u, 13u, 10u, 14u, 11u, 15u  // bbggrraa 2nd pixel
};

// Shuffle table for duplicating 2 fractions into 8 bytes each
static const uvec8 kShuffleFractions = {
    0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 4u, 4u, 4u, 4u, 4u, 4u, 4u, 4u,
};

// Bilinear row filtering combines 4x2 -> 4x1. SSSE3 version
void ScaleARGBFilterCols_SSSE3(uint8_t* dst_argb,
                               const uint8_t* src_argb,
                               int dst_width,
                               int x,
                               int dx) {
  intptr_t x0, x1;
  asm volatile(
      "movdqa    %0,%%xmm4                       \n"
      "movdqa    %1,%%xmm5                       \n"
      :
      : "m"(kShuffleColARGB),   // %0
        "m"(kShuffleFractions)  // %1
  );

  asm volatile(
      "movd      %5,%%xmm2                       \n"
      "movd      %6,%%xmm3                       \n"
      "pcmpeqb   %%xmm6,%%xmm6                   \n"
      "psrlw     $0x9,%%xmm6                     \n"
      "pextrw    $0x1,%%xmm2,%k3                 \n"
      "sub       $0x2,%2                         \n"
      "jl        29f                             \n"
      "movdqa    %%xmm2,%%xmm0                   \n"
      "paddd     %%xmm3,%%xmm0                   \n"
      "punpckldq %%xmm0,%%xmm2                   \n"
      "punpckldq %%xmm3,%%xmm3                   \n"
      "paddd     %%xmm3,%%xmm3                   \n"
      "pextrw    $0x3,%%xmm2,%k4                 \n"

      LABELALIGN
      "2:                                        \n"
      "movdqa    %%xmm2,%%xmm1                   \n"
      "paddd     %%xmm3,%%xmm2                   \n"
      "movq      0x00(%1,%3,4),%%xmm0            \n"
      "psrlw     $0x9,%%xmm1                     \n"
      "movhps    0x00(%1,%4,4),%%xmm0            \n"
      "pshufb    %%xmm5,%%xmm1                   \n"
      "pshufb    %%xmm4,%%xmm0                   \n"
      "pxor      %%xmm6,%%xmm1                   \n"
      "pmaddubsw %%xmm1,%%xmm0                   \n"
      "psrlw     $0x7,%%xmm0                     \n"
      "pextrw    $0x1,%%xmm2,%k3                 \n"
      "pextrw    $0x3,%%xmm2,%k4                 \n"
      "packuswb  %%xmm0,%%xmm0                   \n"
      "movq      %%xmm0,(%0)                     \n"
      "lea       0x8(%0),%0                      \n"
      "sub       $0x2,%2                         \n"
      "jge       2b                              \n"

      LABELALIGN
      "29:                                       \n"
      "add       $0x1,%2                         \n"
      "jl        99f                             \n"
      "psrlw     $0x9,%%xmm2                     \n"
      "movq      0x00(%1,%3,4),%%xmm0            \n"
      "pshufb    %%xmm5,%%xmm2                   \n"
      "pshufb    %%xmm4,%%xmm0                   \n"
      "pxor      %%xmm6,%%xmm2                   \n"
      "pmaddubsw %%xmm2,%%xmm0                   \n"
      "psrlw     $0x7,%%xmm0                     \n"
      "packuswb  %%xmm0,%%xmm0                   \n"
      "movd      %%xmm0,(%0)                     \n"

      LABELALIGN "99:                            \n"  // clang-format error.

      : "+r"(dst_argb),    // %0
        "+r"(src_argb),    // %1
        "+rm"(dst_width),  // %2
        "=&r"(x0),         // %3
        "=&r"(x1)          // %4
      : "rm"(x),           // %5
        "rm"(dx)           // %6
      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
}

// Divide num by div and return as 16.16 fixed point result.
int FixedDiv_X86(int num, int div) {
  asm volatile(
      "cdq                                       \n"
      "shld      $0x10,%%eax,%%edx               \n"
      "shl       $0x10,%%eax                     \n"
      "idiv      %1                              \n"
      "mov       %0, %%eax                       \n"
      : "+a"(num)  // %0
      : "c"(div)   // %1
      : "memory", "cc", "edx");
  return num;
}

// Divide num - 1 by div - 1 and return as 16.16 fixed point result.
int FixedDiv1_X86(int num, int div) {
  asm volatile(
      "cdq                                       \n"
      "shld      $0x10,%%eax,%%edx               \n"
      "shl       $0x10,%%eax                     \n"
      "sub       $0x10001,%%eax                  \n"
      "sbb       $0x0,%%edx                      \n"
      "sub       $0x1,%1                         \n"
      "idiv      %1                              \n"
      "mov       %0, %%eax                       \n"
      : "+a"(num)  // %0
      : "c"(div)   // %1
      : "memory", "cc", "edx");
  return num;
}

#endif  // defined(__x86_64__) || defined(__i386__)

#ifdef __cplusplus
}  // extern "C"
}  // namespace libyuv
#endif
