git.sesse.net Git - ffmpeg/blob - libswscale/x86/scale.asm

   1 ;******************************************************************************
   2 ;* x86-optimized horizontal/vertical line scaling functions
   3 ;* Copyright (c) 2011 Ronald S. Bultje <rsbultje@gmail.com>
   4 ;*                    Kieran Kunhya <kieran@kunhya.com>
   5 ;*
   6 ;* This file is part of Libav.
   7 ;*
   8 ;* Libav is free software; you can redistribute it and/or
   9 ;* modify it under the terms of the GNU Lesser General Public
  10 ;* License as published by the Free Software Foundation; either
  11 ;* version 2.1 of the License, or (at your option) any later version.
  12 ;*
  13 ;* Libav is distributed in the hope that it will be useful,
  14 ;* but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 ;* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 ;* Lesser General Public License for more details.
  17 ;*
  18 ;* You should have received a copy of the GNU Lesser General Public
  19 ;* License along with Libav; if not, write to the Free Software
  20 ;* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21 ;******************************************************************************
  22
  23 %include "x86inc.asm"
  24 %include "x86util.asm"
  25
  26 SECTION_RODATA
  27
  28 max_19bit_int: times 4 dd 0x7ffff
  29 max_19bit_flt: times 4 dd 524287.0
  30 minshort:      times 8 dw 0x8000
  31 unicoeff:      times 4 dd 0x20000000
  32 yuv2yuvX_16_start:  times 4 dd 0x4000 - 0x40000000
  33 yuv2yuvX_10_start:  times 4 dd 0x10000
  34 yuv2yuvX_9_start:   times 4 dd 0x20000
  35 yuv2yuvX_10_upper:  times 8 dw 0x3ff
  36 yuv2yuvX_9_upper:   times 8 dw 0x1ff
  37
  38 SECTION .text
  39
  40 ;-----------------------------------------------------------------------------
  41 ; horizontal line scaling
  42 ;
  43 ; void hscale<source_width>to<intermediate_nbits>_<filterSize>_<opt>
  44 ;                               (SwsContext *c, int{16,32}_t *dst,
  45 ;                                int dstW, const uint{8,16}_t *src,
  46 ;                                const int16_t *filter,
  47 ;                                const int16_t *filterPos, int filterSize);
  48 ;
  49 ; Scale one horizontal line. Input is either 8-bits width or 16-bits width
  50 ; ($source_width can be either 8, 9, 10 or 16, difference is whether we have to
  51 ; downscale before multiplying). Filter is 14-bits. Output is either 15bits
  52 ; (in int16_t) or 19bits (in int32_t), as given in $intermediate_nbits. Each
  53 ; output pixel is generated from $filterSize input pixels, the position of
  54 ; the first pixel is given in filterPos[nOutputPixel].
  55 ;-----------------------------------------------------------------------------
  56
  57 ; SCALE_FUNC source_width, intermediate_nbits, filtersize, filtersuffix, opt, n_args, n_xmm
  58 %macro SCALE_FUNC 7
  59 cglobal hscale%1to%2_%4_%5, %6, 7, %7
  60 %ifdef ARCH_X86_64
  61     movsxd        r2, r2d
  62 %endif ; x86-64
  63 %if %2 == 19
  64 %if mmsize == 8 ; mmx
  65     mova          m2, [max_19bit_int]
  66 %elifidn %5, sse4
  67     mova          m2, [max_19bit_int]
  68 %else ; ssse3/sse2
  69     mova          m2, [max_19bit_flt]
  70 %endif ; mmx/sse2/ssse3/sse4
  71 %endif ; %2 == 19
  72 %if %1 == 16
  73     mova          m6, [minshort]
  74     mova          m7, [unicoeff]
  75 %elif %1 == 8
  76     pxor          m3, m3
  77 %endif ; %1 == 8/16
  78
  79 %if %1 == 8
  80 %define movlh movd
  81 %define movbh movh
  82 %define srcmul 1
  83 %else ; %1 == 9-16
  84 %define movlh movq
  85 %define movbh movu
  86 %define srcmul 2
  87 %endif ; %1 == 8/9-16
  88
  89 %ifnidn %3, X
  90
  91     ; setup loop
  92 %if %3 == 8
  93     shl           r2, 1                  ; this allows *16 (i.e. now *8) in lea instructions for the 8-tap filter
  94 %define r2shr 1
  95 %else ; %3 == 4
  96 %define r2shr 0
  97 %endif ; %3 == 8
  98     lea           r4, [r4+r2*8]
  99 %if %2 == 15
 100     lea           r1, [r1+r2*(2>>r2shr)]
 101 %else ; %2 == 19
 102     lea           r1, [r1+r2*(4>>r2shr)]
 103 %endif ; %2 == 15/19
 104     lea           r5, [r5+r2*(2>>r2shr)]
 105     neg           r2
 106
 107 .loop:
 108 %if %3 == 4 ; filterSize == 4 scaling
 109     ; load 2x4 or 4x4 source pixels into m0/m1
 110     movsx         r0, word [r5+r2*2+0]   ; filterPos[0]
 111     movsx         r6, word [r5+r2*2+2]   ; filterPos[1]
 112     movlh         m0, [r3+r0*srcmul]     ; src[filterPos[0] + {0,1,2,3}]
 113 %if mmsize == 8
 114     movlh         m1, [r3+r6*srcmul]     ; src[filterPos[1] + {0,1,2,3}]
 115 %else ; mmsize == 16
 116 %if %1 > 8
 117     movhps        m0, [r3+r6*srcmul]     ; src[filterPos[1] + {0,1,2,3}]
 118 %else ; %1 == 8
 119     movd          m4, [r3+r6*srcmul]     ; src[filterPos[1] + {0,1,2,3}]
 120 %endif
 121     movsx         r0, word [r5+r2*2+4]   ; filterPos[2]
 122     movsx         r6, word [r5+r2*2+6]   ; filterPos[3]
 123     movlh         m1, [r3+r0*srcmul]     ; src[filterPos[2] + {0,1,2,3}]
 124 %if %1 > 8
 125     movhps        m1, [r3+r6*srcmul]     ; src[filterPos[3] + {0,1,2,3}]
 126 %else ; %1 == 8
 127     movd          m5, [r3+r6*srcmul]     ; src[filterPos[3] + {0,1,2,3}]
 128     punpckldq     m0, m4
 129     punpckldq     m1, m5
 130 %endif ; %1 == 8 && %5 <= ssse
 131 %endif ; mmsize == 8/16
 132 %if %1 == 8
 133     punpcklbw     m0, m3                 ; byte -> word
 134     punpcklbw     m1, m3                 ; byte -> word
 135 %endif ; %1 == 8
 136
 137     ; multiply with filter coefficients
 138 %if %1 == 16 ; pmaddwd needs signed adds, so this moves unsigned -> signed, we'll
 139              ; add back 0x8000 * sum(coeffs) after the horizontal add
 140     psubw         m0, m6
 141     psubw         m1, m6
 142 %endif ; %1 == 16
 143     pmaddwd       m0, [r4+r2*8+mmsize*0] ; *= filter[{0,1,..,6,7}]
 144     pmaddwd       m1, [r4+r2*8+mmsize*1] ; *= filter[{8,9,..,14,15}]
 145
 146     ; add up horizontally (4 srcpix * 4 coefficients -> 1 dstpix)
 147 %if mmsize == 8 ; mmx
 148     movq          m4, m0
 149     punpckldq     m0, m1
 150     punpckhdq     m4, m1
 151     paddd         m0, m4
 152 %elifidn %5, sse2
 153     mova          m4, m0
 154     shufps        m0, m1, 10001000b
 155     shufps        m4, m1, 11011101b
 156     paddd         m0, m4
 157 %else ; ssse3/sse4
 158     phaddd        m0, m1                 ; filter[{ 0, 1, 2, 3}]*src[filterPos[0]+{0,1,2,3}],
 159                                          ; filter[{ 4, 5, 6, 7}]*src[filterPos[1]+{0,1,2,3}],
 160                                          ; filter[{ 8, 9,10,11}]*src[filterPos[2]+{0,1,2,3}],
 161                                          ; filter[{12,13,14,15}]*src[filterPos[3]+{0,1,2,3}]
 162 %endif ; mmx/sse2/ssse3/sse4
 163 %else ; %3 == 8, i.e. filterSize == 8 scaling
 164     ; load 2x8 or 4x8 source pixels into m0, m1, m4 and m5
 165     movsx         r0, word [r5+r2*1+0]   ; filterPos[0]
 166     movsx         r6, word [r5+r2*1+2]   ; filterPos[1]
 167     movbh         m0, [r3+ r0   *srcmul] ; src[filterPos[0] + {0,1,2,3,4,5,6,7}]
 168 %if mmsize == 8
 169     movbh         m1, [r3+(r0+4)*srcmul] ; src[filterPos[0] + {4,5,6,7}]
 170     movbh         m4, [r3+ r6   *srcmul] ; src[filterPos[1] + {0,1,2,3}]
 171     movbh         m5, [r3+(r6+4)*srcmul] ; src[filterPos[1] + {4,5,6,7}]
 172 %else ; mmsize == 16
 173     movbh         m1, [r3+ r6   *srcmul] ; src[filterPos[1] + {0,1,2,3,4,5,6,7}]
 174     movsx         r0, word [r5+r2*1+4]   ; filterPos[2]
 175     movsx         r6, word [r5+r2*1+6]   ; filterPos[3]
 176     movbh         m4, [r3+ r0   *srcmul] ; src[filterPos[2] + {0,1,2,3,4,5,6,7}]
 177     movbh         m5, [r3+ r6   *srcmul] ; src[filterPos[3] + {0,1,2,3,4,5,6,7}]
 178 %endif ; mmsize == 8/16
 179 %if %1 == 8
 180     punpcklbw     m0, m3                 ; byte -> word
 181     punpcklbw     m1, m3                 ; byte -> word
 182     punpcklbw     m4, m3                 ; byte -> word
 183     punpcklbw     m5, m3                 ; byte -> word
 184 %endif ; %1 == 8
 185
 186     ; multiply
 187 %if %1 == 16 ; pmaddwd needs signed adds, so this moves unsigned -> signed, we'll
 188              ; add back 0x8000 * sum(coeffs) after the horizontal add
 189     psubw         m0, m6
 190     psubw         m1, m6
 191     psubw         m4, m6
 192     psubw         m5, m6
 193 %endif ; %1 == 16
 194     pmaddwd       m0, [r4+r2*8+mmsize*0] ; *= filter[{0,1,..,6,7}]
 195     pmaddwd       m1, [r4+r2*8+mmsize*1] ; *= filter[{8,9,..,14,15}]
 196     pmaddwd       m4, [r4+r2*8+mmsize*2] ; *= filter[{16,17,..,22,23}]
 197     pmaddwd       m5, [r4+r2*8+mmsize*3] ; *= filter[{24,25,..,30,31}]
 198
 199     ; add up horizontally (8 srcpix * 8 coefficients -> 1 dstpix)
 200 %if mmsize == 8
 201     paddd         m0, m1
 202     paddd         m4, m5
 203     movq          m1, m0
 204     punpckldq     m0, m4
 205     punpckhdq     m1, m4
 206     paddd         m0, m1
 207 %elifidn %5, sse2
 208 %if %1 == 8
 209 %define mex m6
 210 %else
 211 %define mex m3
 212 %endif
 213     ; emulate horizontal add as transpose + vertical add
 214     mova         mex, m0
 215     punpckldq     m0, m1
 216     punpckhdq    mex, m1
 217     paddd         m0, mex
 218     mova          m1, m4
 219     punpckldq     m4, m5
 220     punpckhdq     m1, m5
 221     paddd         m4, m1
 222     mova          m1, m0
 223     punpcklqdq    m0, m4
 224     punpckhqdq    m1, m4
 225     paddd         m0, m1
 226 %else ; ssse3/sse4
 227     ; FIXME if we rearrange the filter in pairs of 4, we can
 228     ; load pixels likewise and use 2 x paddd + phaddd instead
 229     ; of 3 x phaddd here, faster on older cpus
 230     phaddd        m0, m1
 231     phaddd        m4, m5
 232     phaddd        m0, m4                 ; filter[{ 0, 1,..., 6, 7}]*src[filterPos[0]+{0,1,...,6,7}],
 233                                          ; filter[{ 8, 9,...,14,15}]*src[filterPos[1]+{0,1,...,6,7}],
 234                                          ; filter[{16,17,...,22,23}]*src[filterPos[2]+{0,1,...,6,7}],
 235                                          ; filter[{24,25,...,30,31}]*src[filterPos[3]+{0,1,...,6,7}]
 236 %endif ; mmx/sse2/ssse3/sse4
 237 %endif ; %3 == 4/8
 238
 239 %else ; %3 == X, i.e. any filterSize scaling
 240
 241 %ifidn %4, X4
 242 %define r6sub 4
 243 %else ; %4 == X || %4 == X8
 244 %define r6sub 0
 245 %endif ; %4 ==/!= X4
 246 %ifdef ARCH_X86_64
 247     push         r12
 248     movsxd        r6, r6d                ; filterSize
 249     lea          r12, [r3+(r6-r6sub)*srcmul] ; &src[filterSize&~4]
 250 %define src_reg r11
 251 %define r1x     r10
 252 %define filter2 r12
 253 %else ; x86-32
 254     lea           r0, [r3+(r6-r6sub)*srcmul] ; &src[filterSize&~4]
 255     mov          r6m, r0
 256 %define src_reg r3
 257 %define r1x     r1
 258 %define filter2 r6m
 259 %endif ; x86-32/64
 260     lea           r5, [r5+r2*2]
 261 %if %2 == 15
 262     lea           r1, [r1+r2*2]
 263 %else ; %2 == 19
 264     lea           r1, [r1+r2*4]
 265 %endif ; %2 == 15/19
 266     movifnidn   r1mp, r1
 267     neg           r2
 268
 269 .loop:
 270     movsx         r0, word [r5+r2*2+0]   ; filterPos[0]
 271     movsx        r1x, word [r5+r2*2+2]   ; filterPos[1]
 272     ; FIXME maybe do 4px/iteration on x86-64 (x86-32 wouldn't have enough regs)?
 273     pxor          m4, m4
 274     pxor          m5, m5
 275     mov      src_reg, r3mp
 276
 277 .innerloop:
 278     ; load 2x4 (mmx) or 2x8 (sse) source pixels into m0/m1 -> m4/m5
 279     movbh         m0, [src_reg+r0 *srcmul]    ; src[filterPos[0] + {0,1,2,3(,4,5,6,7)}]
 280     movbh         m1, [src_reg+(r1x+r6sub)*srcmul]    ; src[filterPos[1] + {0,1,2,3(,4,5,6,7)}]
 281 %if %1 == 8
 282     punpcklbw     m0, m3
 283     punpcklbw     m1, m3
 284 %endif ; %1 == 8
 285
 286     ; multiply
 287 %if %1 == 16 ; pmaddwd needs signed adds, so this moves unsigned -> signed, we'll
 288              ; add back 0x8000 * sum(coeffs) after the horizontal add
 289     psubw         m0, m6
 290     psubw         m1, m6
 291 %endif ; %1 == 16
 292     pmaddwd       m0, [r4     ]          ; filter[{0,1,2,3(,4,5,6,7)}]
 293     pmaddwd       m1, [r4+(r6+r6sub)*2]          ; filter[filtersize+{0,1,2,3(,4,5,6,7)}]
 294     paddd         m4, m0
 295     paddd         m5, m1
 296     add           r4, mmsize
 297     add      src_reg, srcmul*mmsize/2
 298     cmp      src_reg, filter2            ; while (src += 4) < &src[filterSize]
 299     jl .innerloop
 300
 301 %ifidn %4, X4
 302     movsx        r1x, word [r5+r2*2+2]   ; filterPos[1]
 303     movlh         m0, [src_reg+r0 *srcmul] ; split last 4 srcpx of dstpx[0]
 304     sub          r1x, r6                   ; and first 4 srcpx of dstpx[1]
 305 %if %1 > 8
 306     movhps        m0, [src_reg+(r1x+r6sub)*srcmul]
 307 %else ; %1 == 8
 308     movd          m1, [src_reg+(r1x+r6sub)*srcmul]
 309     punpckldq     m0, m1
 310 %endif ; %1 == 8 && %5 <= ssse
 311 %if %1 == 8
 312     punpcklbw     m0, m3
 313 %endif ; %1 == 8
 314 %if %1 == 16 ; pmaddwd needs signed adds, so this moves unsigned -> signed, we'll
 315              ; add back 0x8000 * sum(coeffs) after the horizontal add
 316     psubw         m0, m6
 317 %endif ; %1 == 16
 318     pmaddwd       m0, [r4]
 319 %endif ; %4 == X4
 320
 321     lea           r4, [r4+(r6+r6sub)*2]
 322
 323 %if mmsize == 8 ; mmx
 324     movq          m0, m4
 325     punpckldq     m4, m5
 326     punpckhdq     m0, m5
 327     paddd         m0, m4
 328 %else ; mmsize == 16
 329 %ifidn %5, sse2
 330     mova          m1, m4
 331     punpcklqdq    m4, m5
 332     punpckhqdq    m1, m5
 333     paddd         m4, m1
 334 %else ; ssse3/sse4
 335     phaddd        m4, m5
 336 %endif ; sse2/ssse3/sse4
 337 %ifidn %4, X4
 338     paddd         m4, m0
 339 %endif ; %3 == X4
 340 %ifidn %5, sse2
 341     pshufd        m4, m4, 11011000b
 342     movhlps       m0, m4
 343     paddd         m0, m4
 344 %else ; ssse3/sse4
 345     phaddd        m4, m4
 346     SWAP           0, 4
 347 %endif ; sse2/ssse3/sse4
 348 %endif ; mmsize == 8/16
 349 %endif ; %3 ==/!= X
 350
 351 %if %1 == 16 ; add 0x8000 * sum(coeffs), i.e. back from signed -> unsigned
 352     paddd         m0, m7
 353 %endif ; %1 == 16
 354
 355     ; clip, store
 356     psrad         m0, 14 + %1 - %2
 357 %ifidn %3, X
 358     movifnidn     r1, r1mp
 359 %endif ; %3 == X
 360 %if %2 == 15
 361     packssdw      m0, m0
 362 %ifnidn %3, X
 363     movh [r1+r2*(2>>r2shr)], m0
 364 %else ; %3 == X
 365     movd   [r1+r2*2], m0
 366 %endif ; %3 ==/!= X
 367 %else ; %2 == 19
 368 %if mmsize == 8
 369     PMINSD_MMX    m0, m2, m4
 370 %elifidn %5, sse4
 371     pminsd        m0, m2
 372 %else ; sse2/ssse3
 373     cvtdq2ps      m0, m0
 374     minps         m0, m2
 375     cvtps2dq      m0, m0
 376 %endif ; mmx/sse2/ssse3/sse4
 377 %ifnidn %3, X
 378     mova [r1+r2*(4>>r2shr)], m0
 379 %else ; %3 == X
 380     movq   [r1+r2*4], m0
 381 %endif ; %3 ==/!= X
 382 %endif ; %2 == 15/19
 383 %ifnidn %3, X
 384     add           r2, (mmsize<<r2shr)/4  ; both 8tap and 4tap really only do 4 pixels (or for mmx: 2 pixels)
 385                                          ; per iteration. see "shl r2,1" above as for why we do this
 386 %else ; %3 == X
 387     add           r2, 2
 388 %endif ; %3 ==/!= X
 389     jl .loop
 390 %ifnidn %3, X
 391     REP_RET
 392 %else ; %3 == X
 393 %ifdef ARCH_X86_64
 394     pop          r12
 395     RET
 396 %else ; x86-32
 397     REP_RET
 398 %endif ; x86-32/64
 399 %endif ; %3 ==/!= X
 400 %endmacro
 401
 402 ; SCALE_FUNCS source_width, intermediate_nbits, opt, n_xmm
 403 %macro SCALE_FUNCS 4
 404 SCALE_FUNC %1, %2, 4, 4,  %3, 6, %4
 405 SCALE_FUNC %1, %2, 8, 8,  %3, 6, %4
 406 %if mmsize == 8
 407 SCALE_FUNC %1, %2, X, X,  %3, 7, %4
 408 %else
 409 SCALE_FUNC %1, %2, X, X4, %3, 7, %4
 410 SCALE_FUNC %1, %2, X, X8, %3, 7, %4
 411 %endif
 412 %endmacro
 413
 414 ; SCALE_FUNCS2 opt, 8_xmm_args, 9to10_xmm_args, 16_xmm_args
 415 %macro SCALE_FUNCS2 4
 416 %ifnidn %1, sse4
 417 SCALE_FUNCS  8, 15, %1, %2
 418 SCALE_FUNCS  9, 15, %1, %3
 419 SCALE_FUNCS 10, 15, %1, %3
 420 SCALE_FUNCS 14, 15, %1, %3
 421 SCALE_FUNCS 16, 15, %1, %4
 422 %endif ; !sse4
 423 SCALE_FUNCS  8, 19, %1, %2
 424 SCALE_FUNCS  9, 19, %1, %3
 425 SCALE_FUNCS 10, 19, %1, %3
 426 SCALE_FUNCS 14, 19, %1, %3
 427 SCALE_FUNCS 16, 19, %1, %4
 428 %endmacro
 429
 430 %ifdef ARCH_X86_32
 431 INIT_MMX
 432 SCALE_FUNCS2 mmx,   0, 0, 0
 433 %endif
 434 INIT_XMM
 435 SCALE_FUNCS2 sse2,  6, 7, 8
 436 SCALE_FUNCS2 ssse3, 6, 6, 8
 437 SCALE_FUNCS2 sse4,  6, 6, 8
 438
 439 ;-----------------------------------------------------------------------------
 440 ; vertical line scaling
 441 ;
 442 ; void yuv2plane1_<output_size>_<opt>(const int16_t *src, uint8_t *dst, int dstW,
 443 ;                                     const uint8_t *dither, int offset)
 444 ; and
 445 ; void yuv2planeX_<output_size>_<opt>(const int16_t *filter, int filterSize,
 446 ;                                     const int16_t **src, uint8_t *dst, int dstW,
 447 ;                                     const uint8_t *dither, int offset)
 448 ;
 449 ; Scale one or $filterSize lines of source data to generate one line of output
 450 ; data. The input is 15-bit in int16_t if $output_size is [8,10] and 19-bit in
 451 ; int32_t if $output_size is 16. $filter is 12-bits. $filterSize is a multiple
 452 ; of 2. $offset is either 0 or 3. $dither holds 8 values.
 453 ;-----------------------------------------------------------------------------
 454
 455 %macro yuv2planeX_fn 4
 456
 457 %ifdef ARCH_X86_32
 458 %define cntr_reg r1
 459 %define movsx mov
 460 %else
 461 %define cntr_reg r11
 462 %define movsx movsxd
 463 %endif
 464
 465 cglobal yuv2planeX_%2_%1, %4, 7, %3
 466 %if %2 == 8 || %2 == 9 || %2 == 10
 467     pxor            m6,  m6
 468 %endif ; %2 == 8/9/10
 469
 470 %if %2 == 8
 471 %ifdef ARCH_X86_32
 472 %assign pad 0x2c - (stack_offset & 15)
 473     SUB             rsp, pad
 474 %define m_dith m7
 475 %else ; x86-64
 476 %define m_dith m9
 477 %endif ; x86-32
 478
 479     ; create registers holding dither
 480     movq        m_dith, [r5]             ; dither
 481     test            r6d, r6d
 482     jz              .no_rot
 483 %if mmsize == 16
 484     punpcklqdq  m_dith,  m_dith
 485 %endif ; mmsize == 16
 486     PALIGNR     m_dith,  m_dith,  3,  m0
 487 .no_rot:
 488 %if mmsize == 16
 489     punpcklbw   m_dith,  m6
 490 %ifdef ARCH_X86_64
 491     punpcklwd       m8,  m_dith,  m6
 492     pslld           m8,  12
 493 %else ; x86-32
 494     punpcklwd       m5,  m_dith,  m6
 495     pslld           m5,  12
 496 %endif ; x86-32/64
 497     punpckhwd   m_dith,  m6
 498     pslld       m_dith,  12
 499 %ifdef ARCH_X86_32
 500     mova      [rsp+ 0],  m5
 501     mova      [rsp+16],  m_dith
 502 %endif
 503 %else ; mmsize == 8
 504     punpcklbw       m5,  m_dith,  m6
 505     punpckhbw   m_dith,  m6
 506     punpcklwd       m4,  m5,  m6
 507     punpckhwd       m5,  m6
 508     punpcklwd       m3,  m_dith,  m6
 509     punpckhwd   m_dith,  m6
 510     pslld           m4,  12
 511     pslld           m5,  12
 512     pslld           m3,  12
 513     pslld       m_dith,  12
 514     mova      [rsp+ 0],  m4
 515     mova      [rsp+ 8],  m5
 516     mova      [rsp+16],  m3
 517     mova      [rsp+24],  m_dith
 518 %endif ; mmsize == 8/16
 519 %endif ; %2 == 8
 520
 521     xor             r5,  r5
 522
 523 .pixelloop:
 524 %assign %%i 0
 525     ; the rep here is for the 8bit output mmx case, where dither covers
 526     ; 8 pixels but we can only handle 2 pixels per register, and thus 4
 527     ; pixels per iteration. In order to not have to keep track of where
 528     ; we are w.r.t. dithering, we unroll the mmx/8bit loop x2.
 529 %if %2 == 8
 530 %rep 16/mmsize
 531 %endif ; %2 == 8
 532
 533 %if %2 == 8
 534 %ifdef ARCH_X86_32
 535     mova            m2, [rsp+mmsize*(0+%%i)]
 536     mova            m1, [rsp+mmsize*(1+%%i)]
 537 %else ; x86-64
 538     mova            m2,  m8
 539     mova            m1,  m_dith
 540 %endif ; x86-32/64
 541 %else ; %2 == 9/10/16
 542     mova            m1, [yuv2yuvX_%2_start]
 543     mova            m2,  m1
 544 %endif ; %2 == 8/9/10/16
 545     movsx     cntr_reg,  r1m
 546 .filterloop_ %+ %%i:
 547     ; input pixels
 548     mov             r6, [r2+gprsize*cntr_reg-2*gprsize]
 549 %if %2 == 16
 550     mova            m3, [r6+r5*4]
 551     mova            m5, [r6+r5*4+mmsize]
 552 %else ; %2 == 8/9/10
 553     mova            m3, [r6+r5*2]
 554 %endif ; %2 == 8/9/10/16
 555     mov             r6, [r2+gprsize*cntr_reg-gprsize]
 556 %if %2 == 16
 557     mova            m4, [r6+r5*4]
 558     mova            m6, [r6+r5*4+mmsize]
 559 %else ; %2 == 8/9/10
 560     mova            m4, [r6+r5*2]
 561 %endif ; %2 == 8/9/10/16
 562
 563     ; coefficients
 564     movd            m0, [r0+2*cntr_reg-4]; coeff[0], coeff[1]
 565 %if %2 == 16
 566     pshuflw         m7,  m0,  0          ; coeff[0]
 567     pshuflw         m0,  m0,  0x55       ; coeff[1]
 568     pmovsxwd        m7,  m7              ; word -> dword
 569     pmovsxwd        m0,  m0              ; word -> dword
 570
 571     pmulld          m3,  m7
 572     pmulld          m5,  m7
 573     pmulld          m4,  m0
 574     pmulld          m6,  m0
 575
 576     paddd           m2,  m3
 577     paddd           m1,  m5
 578     paddd           m2,  m4
 579     paddd           m1,  m6
 580 %else ; %2 == 10/9/8
 581     punpcklwd       m5,  m3,  m4
 582     punpckhwd       m3,  m4
 583     SPLATD          m0,  m0
 584
 585     pmaddwd         m5,  m0
 586     pmaddwd         m3,  m0
 587
 588     paddd           m2,  m5
 589     paddd           m1,  m3
 590 %endif ; %2 == 8/9/10/16
 591
 592     sub       cntr_reg,  2
 593     jg .filterloop_ %+ %%i
 594
 595 %if %2 == 16
 596     psrad           m2,  31 - %2
 597     psrad           m1,  31 - %2
 598 %else ; %2 == 10/9/8
 599     psrad           m2,  27 - %2
 600     psrad           m1,  27 - %2
 601 %endif ; %2 == 8/9/10/16
 602
 603 %if %2 == 8
 604     packssdw        m2,  m1
 605     packuswb        m2,  m2
 606     movh     [r3+r5*1],  m2
 607 %else ; %2 == 9/10/16
 608 %if %2 == 16
 609     packssdw        m2,  m1
 610     paddw           m2, [minshort]
 611 %else ; %2 == 9/10
 612 %ifidn %1, sse4
 613     packusdw        m2,  m1
 614 %elifidn %1, avx
 615     packusdw        m2,  m1
 616 %else ; mmx2/sse2
 617     packssdw        m2,  m1
 618     pmaxsw          m2,  m6
 619 %endif ; mmx2/sse2/sse4/avx
 620     pminsw          m2, [yuv2yuvX_%2_upper]
 621 %endif ; %2 == 9/10/16
 622     mova     [r3+r5*2],  m2
 623 %endif ; %2 == 8/9/10/16
 624
 625     add             r5,  mmsize/2
 626     sub             r4d, mmsize/2
 627 %if %2 == 8
 628 %assign %%i %%i+2
 629 %endrep
 630 %endif ; %2 == 8
 631     jg .pixelloop
 632
 633 %if %2 == 8
 634 %ifdef ARCH_X86_32
 635     ADD             rsp, pad
 636     RET
 637 %else ; x86-64
 638     REP_RET
 639 %endif ; x86-32/64
 640 %else ; %2 == 9/10/16
 641     REP_RET
 642 %endif ; %2 == 8/9/10/16
 643 %endmacro
 644
 645 %define PALIGNR PALIGNR_MMX
 646 %ifdef ARCH_X86_32
 647 INIT_MMX
 648 yuv2planeX_fn mmx,   8,  0, 7
 649 yuv2planeX_fn mmx2,  9,  0, 5
 650 yuv2planeX_fn mmx2, 10,  0, 5
 651 %endif
 652
 653 INIT_XMM
 654 yuv2planeX_fn sse2,  8, 10, 7
 655 yuv2planeX_fn sse2,  9,  7, 5
 656 yuv2planeX_fn sse2, 10,  7, 5
 657
 658 %define PALIGNR PALIGNR_SSSE3
 659 yuv2planeX_fn sse4,  8, 10, 7
 660 yuv2planeX_fn sse4,  9,  7, 5
 661 yuv2planeX_fn sse4, 10,  7, 5
 662 yuv2planeX_fn sse4, 16,  8, 5
 663
 664 INIT_AVX
 665 yuv2planeX_fn avx,   8, 10, 7
 666 yuv2planeX_fn avx,   9,  7, 5
 667 yuv2planeX_fn avx,  10,  7, 5