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

   1 ;******************************************************************************
   2 ;* x86-optimized input routines; does shuffling of packed
   3 ;* YUV formats into individual planes, and converts RGB
   4 ;* into YUV planes also.
   5 ;* Copyright (c) 2012 Ronald S. Bultje <rsbultje@gmail.com>
   6 ;*
   7 ;* This file is part of Libav.
   8 ;*
   9 ;* Libav is free software; you can redistribute it and/or
  10 ;* modify it under the terms of the GNU Lesser General Public
  11 ;* License as published by the Free Software Foundation; either
  12 ;* version 2.1 of the License, or (at your option) any later version.
  13 ;*
  14 ;* Libav is distributed in the hope that it will be useful,
  15 ;* but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 ;* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17 ;* Lesser General Public License for more details.
  18 ;*
  19 ;* You should have received a copy of the GNU Lesser General Public
  20 ;* License along with Libav; if not, write to the Free Software
  21 ;* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22 ;******************************************************************************
  23
  24 %include "x86inc.asm"
  25 %include "x86util.asm"
  26
  27 SECTION_RODATA
  28
  29 SECTION .text
  30
  31 ;-----------------------------------------------------------------------------
  32 ; YUYV/UYVY/NV12/NV21 packed pixel shuffling.
  33 ;
  34 ; void <fmt>ToY_<opt>(uint8_t *dst, const uint8_t *src, int w);
  35 ; and
  36 ; void <fmt>toUV_<opt>(uint8_t *dstU, uint8_t *dstV, const uint8_t *src,
  37 ;                      const uint8_t *unused, int w);
  38 ;-----------------------------------------------------------------------------
  39
  40 ; %1 = a (aligned) or u (unaligned)
  41 ; %2 = yuyv or uyvy
  42 %macro LOOP_YUYV_TO_Y 2
  43 .loop_%1:
  44     mov%1          m0, [srcq+wq*2]        ; (byte) { Y0, U0, Y1, V0, ... }
  45     mov%1          m1, [srcq+wq*2+mmsize] ; (byte) { Y8, U4, Y9, V4, ... }
  46 %ifidn %2, yuyv
  47     pand           m0, m2                 ; (word) { Y0, Y1, ..., Y7 }
  48     pand           m1, m2                 ; (word) { Y8, Y9, ..., Y15 }
  49 %else ; uyvy
  50     psrlw          m0, 8                  ; (word) { Y0, Y1, ..., Y7 }
  51     psrlw          m1, 8                  ; (word) { Y8, Y9, ..., Y15 }
  52 %endif ; yuyv/uyvy
  53     packuswb       m0, m1                 ; (byte) { Y0, ..., Y15 }
  54     mova    [dstq+wq], m0
  55     add            wq, mmsize
  56     jl .loop_%1
  57     REP_RET
  58 %endmacro
  59
  60 ; %1 = nr. of XMM registers
  61 ; %2 = yuyv or uyvy
  62 ; %3 = if specified, it means that unaligned and aligned code in loop
  63 ;      will be the same (i.e. YUYV+AVX), and thus we don't need to
  64 ;      split the loop in an aligned and unaligned case
  65 %macro YUYV_TO_Y_FN 2-3
  66 cglobal %2ToY, 5, 5, %1, dst, unused0, unused1, src, w
  67 %ifdef ARCH_X86_64
  68     movsxd         wq, wd
  69 %endif
  70     add          dstq, wq
  71 %if mmsize == 16
  72     test         srcq, 15
  73 %endif
  74     lea          srcq, [srcq+wq*2]
  75 %ifidn %2, yuyv
  76     pcmpeqb        m2, m2                 ; (byte) { 0xff } x 16
  77     psrlw          m2, 8                  ; (word) { 0x00ff } x 8
  78 %endif ; yuyv
  79 %if mmsize == 16
  80     jnz .loop_u_start
  81     neg            wq
  82     LOOP_YUYV_TO_Y  a, %2
  83 .loop_u_start:
  84     neg            wq
  85     LOOP_YUYV_TO_Y  u, %2
  86 %else ; mmsize == 8
  87     neg            wq
  88     LOOP_YUYV_TO_Y  a, %2
  89 %endif ; mmsize == 8/16
  90 %endmacro
  91
  92 ; %1 = a (aligned) or u (unaligned)
  93 ; %2 = yuyv or uyvy
  94 %macro LOOP_YUYV_TO_UV 2
  95 .loop_%1:
  96 %ifidn %2, yuyv
  97     mov%1          m0, [srcq+wq*4]        ; (byte) { Y0, U0, Y1, V0, ... }
  98     mov%1          m1, [srcq+wq*4+mmsize] ; (byte) { Y8, U4, Y9, V4, ... }
  99     psrlw          m0, 8                  ; (word) { U0, V0, ..., U3, V3 }
 100     psrlw          m1, 8                  ; (word) { U4, V4, ..., U7, V7 }
 101 %else ; uyvy
 102 %if cpuflag(avx)
 103     vpand          m0, m2, [srcq+wq*4]        ; (word) { U0, V0, ..., U3, V3 }
 104     vpand          m1, m2, [srcq+wq*4+mmsize] ; (word) { U4, V4, ..., U7, V7 }
 105 %else
 106     mov%1          m0, [srcq+wq*4]        ; (byte) { Y0, U0, Y1, V0, ... }
 107     mov%1          m1, [srcq+wq*4+mmsize] ; (byte) { Y8, U4, Y9, V4, ... }
 108     pand           m0, m2                 ; (word) { U0, V0, ..., U3, V3 }
 109     pand           m1, m2                 ; (word) { U4, V4, ..., U7, V7 }
 110 %endif
 111 %endif ; yuyv/uyvy
 112     packuswb       m0, m1                 ; (byte) { U0, V0, ..., U7, V7 }
 113     pand           m1, m0, m2             ; (word) { U0, U1, ..., U7 }
 114     psrlw          m0, 8                  ; (word) { V0, V1, ..., V7 }
 115 %if mmsize == 16
 116     packuswb       m1, m0                 ; (byte) { U0, ... U7, V1, ... V7 }
 117     movh   [dstUq+wq], m1
 118     movhps [dstVq+wq], m1
 119 %else ; mmsize == 8
 120     packuswb       m1, m1                 ; (byte) { U0, ... U3 }
 121     packuswb       m0, m0                 ; (byte) { V0, ... V3 }
 122     movh   [dstUq+wq], m1
 123     movh   [dstVq+wq], m0
 124 %endif ; mmsize == 8/16
 125     add            wq, mmsize / 2
 126     jl .loop_%1
 127     REP_RET
 128 %endmacro
 129
 130 ; %1 = nr. of XMM registers
 131 ; %2 = yuyv or uyvy
 132 ; %3 = if specified, it means that unaligned and aligned code in loop
 133 ;      will be the same (i.e. UYVY+AVX), and thus we don't need to
 134 ;      split the loop in an aligned and unaligned case
 135 %macro YUYV_TO_UV_FN 2-3
 136 cglobal %2ToUV, 4, 5, %1, dstU, dstV, unused, src, w
 137 %ifdef ARCH_X86_64
 138     movsxd         wq, dword r5m
 139 %else ; x86-32
 140     mov            wq, r5m
 141 %endif
 142     add         dstUq, wq
 143     add         dstVq, wq
 144 %if mmsize == 16 && %0 == 2
 145     test         srcq, 15
 146 %endif
 147     lea          srcq, [srcq+wq*4]
 148     pcmpeqb        m2, m2                 ; (byte) { 0xff } x 16
 149     psrlw          m2, 8                  ; (word) { 0x00ff } x 8
 150     ; NOTE: if uyvy+avx, u/a are identical
 151 %if mmsize == 16 && %0 == 2
 152     jnz .loop_u_start
 153     neg            wq
 154     LOOP_YUYV_TO_UV a, %2
 155 .loop_u_start:
 156     neg            wq
 157     LOOP_YUYV_TO_UV u, %2
 158 %else ; mmsize == 8
 159     neg            wq
 160     LOOP_YUYV_TO_UV a, %2
 161 %endif ; mmsize == 8/16
 162 %endmacro
 163
 164 ; %1 = a (aligned) or u (unaligned)
 165 ; %2 = nv12 or nv21
 166 %macro LOOP_NVXX_TO_UV 2
 167 .loop_%1:
 168     mov%1          m0, [srcq+wq*2]        ; (byte) { U0, V0, U1, V1, ... }
 169     mov%1          m1, [srcq+wq*2+mmsize] ; (byte) { U8, V8, U9, V9, ... }
 170     pand           m2, m0, m5             ; (word) { U0, U1, ..., U7 }
 171     pand           m3, m1, m5             ; (word) { U8, U9, ..., U15 }
 172     psrlw          m0, 8                  ; (word) { V0, V1, ..., V7 }
 173     psrlw          m1, 8                  ; (word) { V8, V9, ..., V15 }
 174     packuswb       m2, m3                 ; (byte) { U0, ..., U15 }
 175     packuswb       m0, m1                 ; (byte) { V0, ..., V15 }
 176 %ifidn %2, nv12
 177     mova   [dstUq+wq], m2
 178     mova   [dstVq+wq], m0
 179 %else ; nv21
 180     mova   [dstVq+wq], m2
 181     mova   [dstUq+wq], m0
 182 %endif ; nv12/21
 183     add            wq, mmsize
 184     jl .loop_%1
 185     REP_RET
 186 %endmacro
 187
 188 ; %1 = nr. of XMM registers
 189 ; %2 = nv12 or nv21
 190 %macro NVXX_TO_UV_FN 2
 191 cglobal %2ToUV, 4, 5, %1, dstU, dstV, unused, src, w
 192 %ifdef ARCH_X86_64
 193     movsxd         wq, dword r5m
 194 %else ; x86-32
 195     mov            wq, r5m
 196 %endif
 197     add         dstUq, wq
 198     add         dstVq, wq
 199 %if mmsize == 16
 200     test         srcq, 15
 201 %endif
 202     lea          srcq, [srcq+wq*2]
 203     pcmpeqb        m5, m5                 ; (byte) { 0xff } x 16
 204     psrlw          m5, 8                  ; (word) { 0x00ff } x 8
 205 %if mmsize == 16
 206     jnz .loop_u_start
 207     neg            wq
 208     LOOP_NVXX_TO_UV a, %2
 209 .loop_u_start:
 210     neg            wq
 211     LOOP_NVXX_TO_UV u, %2
 212 %else ; mmsize == 8
 213     neg            wq
 214     LOOP_NVXX_TO_UV a, %2
 215 %endif ; mmsize == 8/16
 216 %endmacro
 217
 218 %ifdef ARCH_X86_32
 219 INIT_MMX mmx
 220 YUYV_TO_Y_FN  0, yuyv
 221 YUYV_TO_Y_FN  0, uyvy
 222 YUYV_TO_UV_FN 0, yuyv
 223 YUYV_TO_UV_FN 0, uyvy
 224 NVXX_TO_UV_FN 0, nv12
 225 NVXX_TO_UV_FN 0, nv21
 226 %endif
 227
 228 INIT_XMM sse2
 229 YUYV_TO_Y_FN  3, yuyv
 230 YUYV_TO_Y_FN  2, uyvy
 231 YUYV_TO_UV_FN 3, yuyv
 232 YUYV_TO_UV_FN 3, uyvy
 233 NVXX_TO_UV_FN 5, nv12
 234 NVXX_TO_UV_FN 5, nv21
 235
 236 INIT_XMM avx
 237 ; in theory, we could write a yuy2-to-y using vpand (i.e. AVX), but
 238 ; that's not faster in practice
 239 YUYV_TO_UV_FN 3, yuyv
 240 YUYV_TO_UV_FN 3, uyvy, 1
 241 NVXX_TO_UV_FN 5, nv12
 242 NVXX_TO_UV_FN 5, nv21