falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
34093 Commits
32 Branches
283MB
Tree: 5ed032fb8b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5ed032fb8b'
${ noResults }
FFmpeg/libswscale/x86/input.asm

670 lines
24KB
Raw Blame History 

  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. %define RY 0x20DE

  30. %define GY 0x4087

  31. %define BY 0x0C88

  32. %define RU 0xECFF

  33. %define GU 0xDAC8

  34. %define BU 0x3838

  35. %define RV 0x3838

  36. %define GV 0xD0E3

  37. %define BV 0xF6E4

  38. 

  39. rgb_Yrnd:        times 4 dd 0x84000        ;  16.5 << 15

  40. rgb_UVrnd:       times 4 dd 0x404000       ; 128.5 << 15

  41. bgr_Ycoeff_12x4: times 2 dw BY, GY, 0, BY

  42. bgr_Ycoeff_3x56: times 2 dw RY, 0, GY, RY

  43. rgb_Ycoeff_12x4: times 2 dw RY, GY, 0, RY

  44. rgb_Ycoeff_3x56: times 2 dw BY, 0, GY, BY

  45. bgr_Ucoeff_12x4: times 2 dw BU, GU, 0, BU

  46. bgr_Ucoeff_3x56: times 2 dw RU, 0, GU, RU

  47. rgb_Ucoeff_12x4: times 2 dw RU, GU, 0, RU

  48. rgb_Ucoeff_3x56: times 2 dw BU, 0, GU, BU

  49. bgr_Vcoeff_12x4: times 2 dw BV, GV, 0, BV

  50. bgr_Vcoeff_3x56: times 2 dw RV, 0, GV, RV

  51. rgb_Vcoeff_12x4: times 2 dw RV, GV, 0, RV

  52. rgb_Vcoeff_3x56: times 2 dw BV, 0, GV, BV

  53. 

  54. rgba_Ycoeff_rb:  times 4 dw RY, BY

  55. rgba_Ycoeff_br:  times 4 dw BY, RY

  56. rgba_Ycoeff_ga:  times 4 dw GY, 0

  57. rgba_Ycoeff_ag:  times 4 dw 0,  GY

  58. rgba_Ucoeff_rb:  times 4 dw RU, BU

  59. rgba_Ucoeff_br:  times 4 dw BU, RU

  60. rgba_Ucoeff_ga:  times 4 dw GU, 0

  61. rgba_Ucoeff_ag:  times 4 dw 0,  GU

  62. rgba_Vcoeff_rb:  times 4 dw RV, BV

  63. rgba_Vcoeff_br:  times 4 dw BV, RV

  64. rgba_Vcoeff_ga:  times 4 dw GV, 0

  65. rgba_Vcoeff_ag:  times 4 dw 0,  GV

  66. 

  67. shuf_rgb_12x4:   db 0, 0x80, 1, 0x80,  2, 0x80,  3, 0x80, \

  68.                     6, 0x80, 7, 0x80,  8, 0x80,  9, 0x80

  69. shuf_rgb_3x56:   db 2, 0x80, 3, 0x80,  4, 0x80,  5, 0x80, \

  70.                     8, 0x80, 9, 0x80, 10, 0x80, 11, 0x80

  71. 

  72. SECTION .text

  73. 

  74. ;-----------------------------------------------------------------------------

  75. ; RGB to Y/UV.

  76. ;

  77. ; void <fmt>ToY_<opt>(uint8_t *dst, const uint8_t *src, int w);

  78. ; and

  79. ; void <fmt>toUV_<opt>(uint8_t *dstU, uint8_t *dstV, const uint8_t *src,

  80. ;                      const uint8_t *unused, int w);

  81. ;-----------------------------------------------------------------------------

  82. 

  83. ; %1 = nr. of XMM registers

  84. ; %2 = rgb or bgr

  85. %macro RGB24_TO_Y_FN 2-3

  86. cglobal %2 %+ 24ToY, 3, 3, %1, dst, src, w

  87. %if mmsize == 8

  88.     mova           m5, [%2_Ycoeff_12x4]

  89.     mova           m6, [%2_Ycoeff_3x56]

  90. %define coeff1 m5

  91. %define coeff2 m6

  92. %elif ARCH_X86_64

  93.     mova           m8, [%2_Ycoeff_12x4]

  94.     mova           m9, [%2_Ycoeff_3x56]

  95. %define coeff1 m8

  96. %define coeff2 m9

  97. %else ; x86-32 && mmsize == 16

  98. %define coeff1 [%2_Ycoeff_12x4]

  99. %define coeff2 [%2_Ycoeff_3x56]

  100. %endif ; x86-32/64 && mmsize == 8/16

  101. %if (ARCH_X86_64 || mmsize == 8) && %0 == 3

  102.     jmp mangle(program_name %+ _ %+ %3 %+ 24ToY %+ SUFFIX).body

  103. %else ; (ARCH_X86_64 && %0 == 3) || mmsize == 8

  104. .body:

  105. %if cpuflag(ssse3)

  106.     mova           m7, [shuf_rgb_12x4]

  107. %define shuf_rgb1 m7

  108. %if ARCH_X86_64

  109.     mova          m10, [shuf_rgb_3x56]

  110. %define shuf_rgb2 m10

  111. %else ; x86-32

  112. %define shuf_rgb2 [shuf_rgb_3x56]

  113. %endif ; x86-32/64

  114. %endif ; cpuflag(ssse3)

  115. %if ARCH_X86_64

  116.     movsxd         wq, wd

  117. %endif

  118.     add          dstq, wq

  119.     neg            wq

  120. %if notcpuflag(ssse3)

  121.     pxor           m7, m7

  122. %endif ; !cpuflag(ssse3)

  123.     mova           m4, [rgb_Yrnd]

  124. .loop:

  125. %if cpuflag(ssse3)

  126.     movu           m0, [srcq+0]           ; (byte) { Bx, Gx, Rx }[0-3]

  127.     movu           m2, [srcq+12]          ; (byte) { Bx, Gx, Rx }[4-7]

  128.     pshufb         m1, m0, shuf_rgb2      ; (word) { R0, B1, G1, R1, R2, B3, G3, R3 }

  129.     pshufb         m0, shuf_rgb1          ; (word) { B0, G0, R0, B1, B2, G2, R2, B3 }

  130.     pshufb         m3, m2, shuf_rgb2      ; (word) { R4, B5, G5, R5, R6, B7, G7, R7 }

  131.     pshufb         m2, shuf_rgb1          ; (word) { B4, G4, R4, B5, B6, G6, R6, B7 }

  132. %else ; !cpuflag(ssse3)

  133.     movd           m0, [srcq+0]           ; (byte) { B0, G0, R0, B1 }

  134.     movd           m1, [srcq+2]           ; (byte) { R0, B1, G1, R1 }

  135.     movd           m2, [srcq+6]           ; (byte) { B2, G2, R2, B3 }

  136.     movd           m3, [srcq+8]           ; (byte) { R2, B3, G3, R3 }

  137. %if mmsize == 16 ; i.e. sse2

  138.     punpckldq      m0, m2                 ; (byte) { B0, G0, R0, B1, B2, G2, R2, B3 }

  139.     punpckldq      m1, m3                 ; (byte) { R0, B1, G1, R1, R2, B3, G3, R3 }

  140.     movd           m2, [srcq+12]          ; (byte) { B4, G4, R4, B5 }

  141.     movd           m3, [srcq+14]          ; (byte) { R4, B5, G5, R5 }

  142.     movd           m5, [srcq+18]          ; (byte) { B6, G6, R6, B7 }

  143.     movd           m6, [srcq+20]          ; (byte) { R6, B7, G7, R7 }

  144.     punpckldq      m2, m5                 ; (byte) { B4, G4, R4, B5, B6, G6, R6, B7 }

  145.     punpckldq      m3, m6                 ; (byte) { R4, B5, G5, R5, R6, B7, G7, R7 }

  146. %endif ; mmsize == 16

  147.     punpcklbw      m0, m7                 ; (word) { B0, G0, R0, B1, B2, G2, R2, B3 }

  148.     punpcklbw      m1, m7                 ; (word) { R0, B1, G1, R1, R2, B3, G3, R3 }

  149.     punpcklbw      m2, m7                 ; (word) { B4, G4, R4, B5, B6, G6, R6, B7 }

  150.     punpcklbw      m3, m7                 ; (word) { R4, B5, G5, R5, R6, B7, G7, R7 }

  151. %endif ; cpuflag(ssse3)

  152.     add          srcq, 3 * mmsize / 2

  153.     pmaddwd        m0, coeff1             ; (dword) { B0*BY + G0*GY, B1*BY, B2*BY + G2*GY, B3*BY }

  154.     pmaddwd        m1, coeff2             ; (dword) { R0*RY, G1+GY + R1*RY, R2*RY, G3+GY + R3*RY }

  155.     pmaddwd        m2, coeff1             ; (dword) { B4*BY + G4*GY, B5*BY, B6*BY + G6*GY, B7*BY }

  156.     pmaddwd        m3, coeff2             ; (dword) { R4*RY, G5+GY + R5*RY, R6*RY, G7+GY + R7*RY }

  157.     paddd          m0, m1                 ; (dword) { Bx*BY + Gx*GY + Rx*RY }[0-3]

  158.     paddd          m2, m3                 ; (dword) { Bx*BY + Gx*GY + Rx*RY }[4-7]

  159.     paddd          m0, m4                 ; += rgb_Yrnd, i.e. (dword) { Y[0-3] }

  160.     paddd          m2, m4                 ; += rgb_Yrnd, i.e. (dword) { Y[4-7] }

  161.     psrad          m0, 15

  162.     psrad          m2, 15

  163.     packssdw       m0, m2                 ; (word) { Y[0-7] }

  164.     packuswb       m0, m0                 ; (byte) { Y[0-7] }

  165.     movh    [dstq+wq], m0

  166.     add            wq, mmsize / 2

  167.     jl .loop

  168.     REP_RET

  169. %endif ; (ARCH_X86_64 && %0 == 3) || mmsize == 8

  170. %endmacro

  171. 

  172. ; %1 = nr. of XMM registers

  173. ; %2 = rgb or bgr

  174. %macro RGB24_TO_UV_FN 2-3

  175. cglobal %2 %+ 24ToUV, 3, 4, %1, dstU, dstV, src, w

  176. %if ARCH_X86_64

  177.     mova           m8, [%2_Ucoeff_12x4]

  178.     mova           m9, [%2_Ucoeff_3x56]

  179.     mova          m10, [%2_Vcoeff_12x4]

  180.     mova          m11, [%2_Vcoeff_3x56]

  181. %define coeffU1 m8

  182. %define coeffU2 m9

  183. %define coeffV1 m10

  184. %define coeffV2 m11

  185. %else ; x86-32

  186. %define coeffU1 [%2_Ucoeff_12x4]

  187. %define coeffU2 [%2_Ucoeff_3x56]

  188. %define coeffV1 [%2_Vcoeff_12x4]

  189. %define coeffV2 [%2_Vcoeff_3x56]

  190. %endif ; x86-32/64

  191. %if ARCH_X86_64 && %0 == 3

  192.     jmp mangle(program_name %+ _ %+ %3 %+ 24ToUV %+ SUFFIX).body

  193. %else ; ARCH_X86_64 && %0 == 3

  194. .body:

  195. %if cpuflag(ssse3)

  196.     mova           m7, [shuf_rgb_12x4]

  197. %define shuf_rgb1 m7

  198. %if ARCH_X86_64

  199.     mova          m12, [shuf_rgb_3x56]

  200. %define shuf_rgb2 m12

  201. %else ; x86-32

  202. %define shuf_rgb2 [shuf_rgb_3x56]

  203. %endif ; x86-32/64

  204. %endif ; cpuflag(ssse3)

  205. %if ARCH_X86_64

  206.     movsxd         wq, dword r4m

  207. %else ; x86-32

  208.     mov            wq, r4m

  209. %endif

  210.     add         dstUq, wq

  211.     add         dstVq, wq

  212.     neg            wq

  213.     mova           m6, [rgb_UVrnd]

  214. %if notcpuflag(ssse3)

  215.     pxor           m7, m7

  216. %endif

  217. .loop:

  218. %if cpuflag(ssse3)

  219.     movu           m0, [srcq+0]           ; (byte) { Bx, Gx, Rx }[0-3]

  220.     movu           m4, [srcq+12]          ; (byte) { Bx, Gx, Rx }[4-7]

  221.     pshufb         m1, m0, shuf_rgb2      ; (word) { R0, B1, G1, R1, R2, B3, G3, R3 }

  222.     pshufb         m0, shuf_rgb1          ; (word) { B0, G0, R0, B1, B2, G2, R2, B3 }

  223. %else ; !cpuflag(ssse3)

  224.     movd           m0, [srcq+0]           ; (byte) { B0, G0, R0, B1 }

  225.     movd           m1, [srcq+2]           ; (byte) { R0, B1, G1, R1 }

  226.     movd           m4, [srcq+6]           ; (byte) { B2, G2, R2, B3 }

  227.     movd           m5, [srcq+8]           ; (byte) { R2, B3, G3, R3 }

  228. %if mmsize == 16

  229.     punpckldq      m0, m4                 ; (byte) { B0, G0, R0, B1, B2, G2, R2, B3 }

  230.     punpckldq      m1, m5                 ; (byte) { R0, B1, G1, R1, R2, B3, G3, R3 }

  231.     movd           m4, [srcq+12]          ; (byte) { B4, G4, R4, B5 }

  232.     movd           m5, [srcq+14]          ; (byte) { R4, B5, G5, R5 }

  233. %endif ; mmsize == 16

  234.     punpcklbw      m0, m7                 ; (word) { B0, G0, R0, B1, B2, G2, R2, B3 }

  235.     punpcklbw      m1, m7                 ; (word) { R0, B1, G1, R1, R2, B3, G3, R3 }

  236. %endif ; cpuflag(ssse3)

  237.     pmaddwd        m2, m0, coeffV1        ; (dword) { B0*BV + G0*GV, B1*BV, B2*BV + G2*GV, B3*BV }

  238.     pmaddwd        m3, m1, coeffV2        ; (dword) { R0*BV, G1*GV + R1*BV, R2*BV, G3*GV + R3*BV }

  239.     pmaddwd        m0, coeffU1            ; (dword) { B0*BU + G0*GU, B1*BU, B2*BU + G2*GU, B3*BU }

  240.     pmaddwd        m1, coeffU2            ; (dword) { R0*BU, G1*GU + R1*BU, R2*BU, G3*GU + R3*BU }

  241.     paddd          m0, m1                 ; (dword) { Bx*BU + Gx*GU + Rx*RU }[0-3]

  242.     paddd          m2, m3                 ; (dword) { Bx*BV + Gx*GV + Rx*RV }[0-3]

  243. %if cpuflag(ssse3)

  244.     pshufb         m5, m4, shuf_rgb2      ; (word) { R4, B5, G5, R5, R6, B7, G7, R7 }

  245.     pshufb         m4, shuf_rgb1          ; (word) { B4, G4, R4, B5, B6, G6, R6, B7 }

  246. %else ; !cpuflag(ssse3)

  247. %if mmsize == 16

  248.     movd           m1, [srcq+18]          ; (byte) { B6, G6, R6, B7 }

  249.     movd           m3, [srcq+20]          ; (byte) { R6, B7, G7, R7 }

  250.     punpckldq      m4, m1                 ; (byte) { B4, G4, R4, B5, B6, G6, R6, B7 }

  251.     punpckldq      m5, m3                 ; (byte) { R4, B5, G5, R5, R6, B7, G7, R7 }

  252. %endif ; mmsize == 16 && !cpuflag(ssse3)

  253.     punpcklbw      m4, m7                 ; (word) { B4, G4, R4, B5, B6, G6, R6, B7 }

  254.     punpcklbw      m5, m7                 ; (word) { R4, B5, G5, R5, R6, B7, G7, R7 }

  255. %endif ; cpuflag(ssse3)

  256.     add          srcq, 3 * mmsize / 2

  257.     pmaddwd        m1, m4, coeffU1        ; (dword) { B4*BU + G4*GU, B5*BU, B6*BU + G6*GU, B7*BU }

  258.     pmaddwd        m3, m5, coeffU2        ; (dword) { R4*BU, G5*GU + R5*BU, R6*BU, G7*GU + R7*BU }

  259.     pmaddwd        m4, coeffV1            ; (dword) { B4*BV + G4*GV, B5*BV, B6*BV + G6*GV, B7*BV }

  260.     pmaddwd        m5, coeffV2            ; (dword) { R4*BV, G5*GV + R5*BV, R6*BV, G7*GV + R7*BV }

  261.     paddd          m1, m3                 ; (dword) { Bx*BU + Gx*GU + Rx*RU }[4-7]

  262.     paddd          m4, m5                 ; (dword) { Bx*BV + Gx*GV + Rx*RV }[4-7]

  263.     paddd          m0, m6                 ; += rgb_UVrnd, i.e. (dword) { U[0-3] }

  264.     paddd          m2, m6                 ; += rgb_UVrnd, i.e. (dword) { V[0-3] }

  265.     paddd          m1, m6                 ; += rgb_UVrnd, i.e. (dword) { U[4-7] }

  266.     paddd          m4, m6                 ; += rgb_UVrnd, i.e. (dword) { V[4-7] }

  267.     psrad          m0, 15

  268.     psrad          m2, 15

  269.     psrad          m1, 15

  270.     psrad          m4, 15

  271.     packssdw       m0, m1                 ; (word) { U[0-7] }

  272.     packssdw       m2, m4                 ; (word) { V[0-7] }

  273. %if mmsize == 8

  274.     packuswb       m0, m0                 ; (byte) { U[0-3] }

  275.     packuswb       m2, m2                 ; (byte) { V[0-3] }

  276.     movh   [dstUq+wq], m0

  277.     movh   [dstVq+wq], m2

  278. %else ; mmsize == 16

  279.     packuswb       m0, m2                 ; (byte) { U[0-7], V[0-7] }

  280.     movh   [dstUq+wq], m0

  281.     movhps [dstVq+wq], m0

  282. %endif ; mmsize == 8/16

  283.     add            wq, mmsize / 2

  284.     jl .loop

  285.     REP_RET

  286. %endif ; ARCH_X86_64 && %0 == 3

  287. %endmacro

  288. 

  289. ; %1 = nr. of XMM registers for rgb-to-Y func

  290. ; %2 = nr. of XMM registers for rgb-to-UV func

  291. %macro RGB24_FUNCS 2

  292. RGB24_TO_Y_FN %1, rgb

  293. RGB24_TO_Y_FN %1, bgr, rgb

  294. RGB24_TO_UV_FN %2, rgb

  295. RGB24_TO_UV_FN %2, bgr, rgb

  296. %endmacro

  297. 

  298. %if ARCH_X86_32

  299. INIT_MMX mmx

  300. RGB24_FUNCS 0, 0

  301. %endif

  302. 

  303. INIT_XMM sse2

  304. RGB24_FUNCS 10, 12

  305. 

  306. INIT_XMM ssse3

  307. RGB24_FUNCS 11, 13

  308. 

  309. INIT_XMM avx

  310. RGB24_FUNCS 11, 13

  311. 

  312. ; %1 = nr. of XMM registers

  313. ; %2-5 = rgba, bgra, argb or abgr (in individual characters)

  314. %macro RGB32_TO_Y_FN 5-6

  315. cglobal %2%3%4%5 %+ ToY, 3, 3, %1, dst, src, w

  316.     mova           m5, [rgba_Ycoeff_%2%4]

  317.     mova           m6, [rgba_Ycoeff_%3%5]

  318. %if %0 == 6

  319.     jmp mangle(program_name %+ _ %+ %6 %+ ToY %+ SUFFIX).body

  320. %else ; %0 == 6

  321. .body:

  322. %if ARCH_X86_64

  323.     movsxd         wq, wd

  324. %endif

  325.     lea          srcq, [srcq+wq*4]

  326.     add          dstq, wq

  327.     neg            wq

  328.     mova           m4, [rgb_Yrnd]

  329.     pcmpeqb        m7, m7

  330.     psrlw          m7, 8                  ; (word) { 0x00ff } x4

  331. .loop:

  332.     ; FIXME check alignment and use mova

  333.     movu           m0, [srcq+wq*4+0]      ; (byte) { Bx, Gx, Rx, xx }[0-3]

  334.     movu           m2, [srcq+wq*4+mmsize] ; (byte) { Bx, Gx, Rx, xx }[4-7]

  335.     DEINTB          1,  0,  3,  2,  7     ; (word) { Gx, xx (m0/m2) or Bx, Rx (m1/m3) }[0-3]/[4-7]

  336.     pmaddwd        m1, m5                 ; (dword) { Bx*BY + Rx*RY }[0-3]

  337.     pmaddwd        m0, m6                 ; (dword) { Gx*GY }[0-3]

  338.     pmaddwd        m3, m5                 ; (dword) { Bx*BY + Rx*RY }[4-7]

  339.     pmaddwd        m2, m6                 ; (dword) { Gx*GY }[4-7]

  340.     paddd          m0, m4                 ; += rgb_Yrnd

  341.     paddd          m2, m4                 ; += rgb_Yrnd

  342.     paddd          m0, m1                 ; (dword) { Y[0-3] }

  343.     paddd          m2, m3                 ; (dword) { Y[4-7] }

  344.     psrad          m0, 15

  345.     psrad          m2, 15

  346.     packssdw       m0, m2                 ; (word) { Y[0-7] }

  347.     packuswb       m0, m0                 ; (byte) { Y[0-7] }

  348.     movh    [dstq+wq], m0

  349.     add            wq, mmsize / 2

  350.     jl .loop

  351.     REP_RET

  352. %endif ; %0 == 3

  353. %endmacro

  354. 

  355. ; %1 = nr. of XMM registers

  356. ; %2-5 = rgba, bgra, argb or abgr (in individual characters)

  357. %macro RGB32_TO_UV_FN 5-6

  358. cglobal %2%3%4%5 %+ ToUV, 3, 4, %1, dstU, dstV, src, w

  359. %if ARCH_X86_64

  360.     mova           m8, [rgba_Ucoeff_%2%4]

  361.     mova           m9, [rgba_Ucoeff_%3%5]

  362.     mova          m10, [rgba_Vcoeff_%2%4]

  363.     mova          m11, [rgba_Vcoeff_%3%5]

  364. %define coeffU1 m8

  365. %define coeffU2 m9

  366. %define coeffV1 m10

  367. %define coeffV2 m11

  368. %else ; x86-32

  369. %define coeffU1 [rgba_Ucoeff_%2%4]

  370. %define coeffU2 [rgba_Ucoeff_%3%5]

  371. %define coeffV1 [rgba_Vcoeff_%2%4]

  372. %define coeffV2 [rgba_Vcoeff_%3%5]

  373. %endif ; x86-64/32

  374. %if ARCH_X86_64 && %0 == 6

  375.     jmp mangle(program_name %+ _ %+ %6 %+ ToUV %+ SUFFIX).body

  376. %else ; ARCH_X86_64 && %0 == 6

  377. .body:

  378. %if ARCH_X86_64

  379.     movsxd         wq, dword r4m

  380. %else ; x86-32

  381.     mov            wq, r4m

  382. %endif

  383.     add         dstUq, wq

  384.     add         dstVq, wq

  385.     lea          srcq, [srcq+wq*4]

  386.     neg            wq

  387.     pcmpeqb        m7, m7

  388.     psrlw          m7, 8                  ; (word) { 0x00ff } x4

  389.     mova           m6, [rgb_UVrnd]

  390. .loop:

  391.     ; FIXME check alignment and use mova

  392.     movu           m0, [srcq+wq*4+0]      ; (byte) { Bx, Gx, Rx, xx }[0-3]

  393.     movu           m4, [srcq+wq*4+mmsize] ; (byte) { Bx, Gx, Rx, xx }[4-7]

  394.     DEINTB          1,  0,  5,  4,  7     ; (word) { Gx, xx (m0/m4) or Bx, Rx (m1/m5) }[0-3]/[4-7]

  395.     pmaddwd        m3, m1, coeffV1        ; (dword) { Bx*BV + Rx*RV }[0-3]

  396.     pmaddwd        m2, m0, coeffV2        ; (dword) { Gx*GV }[0-3]

  397.     pmaddwd        m1, coeffU1            ; (dword) { Bx*BU + Rx*RU }[0-3]

  398.     pmaddwd        m0, coeffU2            ; (dword) { Gx*GU }[0-3]

  399.     paddd          m3, m6                 ; += rgb_UVrnd

  400.     paddd          m1, m6                 ; += rgb_UVrnd

  401.     paddd          m2, m3                 ; (dword) { V[0-3] }

  402.     paddd          m0, m1                 ; (dword) { U[0-3] }

  403.     pmaddwd        m3, m5, coeffV1        ; (dword) { Bx*BV + Rx*RV }[4-7]

  404.     pmaddwd        m1, m4, coeffV2        ; (dword) { Gx*GV }[4-7]

  405.     pmaddwd        m5, coeffU1            ; (dword) { Bx*BU + Rx*RU }[4-7]

  406.     pmaddwd        m4, coeffU2            ; (dword) { Gx*GU }[4-7]

  407.     paddd          m3, m6                 ; += rgb_UVrnd

  408.     paddd          m5, m6                 ; += rgb_UVrnd

  409.     psrad          m0, 15

  410.     paddd          m1, m3                 ; (dword) { V[4-7] }

  411.     paddd          m4, m5                 ; (dword) { U[4-7] }

  412.     psrad          m2, 15

  413.     psrad          m4, 15

  414.     psrad          m1, 15

  415.     packssdw       m0, m4                 ; (word) { U[0-7] }

  416.     packssdw       m2, m1                 ; (word) { V[0-7] }

  417. %if mmsize == 8

  418.     packuswb       m0, m0                 ; (byte) { U[0-7] }

  419.     packuswb       m2, m2                 ; (byte) { V[0-7] }

  420.     movh   [dstUq+wq], m0

  421.     movh   [dstVq+wq], m2

  422. %else ; mmsize == 16

  423.     packuswb       m0, m2                 ; (byte) { U[0-7], V[0-7] }

  424.     movh   [dstUq+wq], m0

  425.     movhps [dstVq+wq], m0

  426. %endif ; mmsize == 8/16

  427.     add            wq, mmsize / 2

  428.     jl .loop

  429.     REP_RET

  430. %endif ; ARCH_X86_64 && %0 == 3

  431. %endmacro

  432. 

  433. ; %1 = nr. of XMM registers for rgb-to-Y func

  434. ; %2 = nr. of XMM registers for rgb-to-UV func

  435. %macro RGB32_FUNCS 2

  436. RGB32_TO_Y_FN %1, r, g, b, a

  437. RGB32_TO_Y_FN %1, b, g, r, a, rgba

  438. RGB32_TO_Y_FN %1, a, r, g, b, rgba

  439. RGB32_TO_Y_FN %1, a, b, g, r, rgba

  440. 

  441. RGB32_TO_UV_FN %2, r, g, b, a

  442. RGB32_TO_UV_FN %2, b, g, r, a, rgba

  443. RGB32_TO_UV_FN %2, a, r, g, b, rgba

  444. RGB32_TO_UV_FN %2, a, b, g, r, rgba

  445. %endmacro

  446. 

  447. %if ARCH_X86_32

  448. INIT_MMX mmx

  449. RGB32_FUNCS 0, 0

  450. %endif

  451. 

  452. INIT_XMM sse2

  453. RGB32_FUNCS 8, 12

  454. 

  455. INIT_XMM avx

  456. RGB32_FUNCS 8, 12

  457. 

  458. ;-----------------------------------------------------------------------------

  459. ; YUYV/UYVY/NV12/NV21 packed pixel shuffling.

  460. ;

  461. ; void <fmt>ToY_<opt>(uint8_t *dst, const uint8_t *src, int w);

  462. ; and

  463. ; void <fmt>toUV_<opt>(uint8_t *dstU, uint8_t *dstV, const uint8_t *src,

  464. ;                      const uint8_t *unused, int w);

  465. ;-----------------------------------------------------------------------------

  466. 

  467. ; %1 = a (aligned) or u (unaligned)

  468. ; %2 = yuyv or uyvy

  469. %macro LOOP_YUYV_TO_Y 2

  470. .loop_%1:

  471.     mov%1          m0, [srcq+wq*2]        ; (byte) { Y0, U0, Y1, V0, ... }

  472.     mov%1          m1, [srcq+wq*2+mmsize] ; (byte) { Y8, U4, Y9, V4, ... }

  473. %ifidn %2, yuyv

  474.     pand           m0, m2                 ; (word) { Y0, Y1, ..., Y7 }

  475.     pand           m1, m2                 ; (word) { Y8, Y9, ..., Y15 }

  476. %else ; uyvy

  477.     psrlw          m0, 8                  ; (word) { Y0, Y1, ..., Y7 }

  478.     psrlw          m1, 8                  ; (word) { Y8, Y9, ..., Y15 }

  479. %endif ; yuyv/uyvy

  480.     packuswb       m0, m1                 ; (byte) { Y0, ..., Y15 }

  481.     mova    [dstq+wq], m0

  482.     add            wq, mmsize

  483.     jl .loop_%1

  484.     REP_RET

  485. %endmacro

  486. 

  487. ; %1 = nr. of XMM registers

  488. ; %2 = yuyv or uyvy

  489. ; %3 = if specified, it means that unaligned and aligned code in loop

  490. ;      will be the same (i.e. YUYV+AVX), and thus we don't need to

  491. ;      split the loop in an aligned and unaligned case

  492. %macro YUYV_TO_Y_FN 2-3

  493. cglobal %2ToY, 3, 3, %1, dst, src, w

  494. %if ARCH_X86_64

  495.     movsxd         wq, wd

  496. %endif

  497.     add          dstq, wq

  498. %if mmsize == 16

  499.     test         srcq, 15

  500. %endif

  501.     lea          srcq, [srcq+wq*2]

  502. %ifidn %2, yuyv

  503.     pcmpeqb        m2, m2                 ; (byte) { 0xff } x 16

  504.     psrlw          m2, 8                  ; (word) { 0x00ff } x 8

  505. %endif ; yuyv

  506. %if mmsize == 16

  507.     jnz .loop_u_start

  508.     neg            wq

  509.     LOOP_YUYV_TO_Y  a, %2

  510. .loop_u_start:

  511.     neg            wq

  512.     LOOP_YUYV_TO_Y  u, %2

  513. %else ; mmsize == 8

  514.     neg            wq

  515.     LOOP_YUYV_TO_Y  a, %2

  516. %endif ; mmsize == 8/16

  517. %endmacro

  518. 

  519. ; %1 = a (aligned) or u (unaligned)

  520. ; %2 = yuyv or uyvy

  521. %macro LOOP_YUYV_TO_UV 2

  522. .loop_%1:

  523. %ifidn %2, yuyv

  524.     mov%1          m0, [srcq+wq*4]        ; (byte) { Y0, U0, Y1, V0, ... }

  525.     mov%1          m1, [srcq+wq*4+mmsize] ; (byte) { Y8, U4, Y9, V4, ... }

  526.     psrlw          m0, 8                  ; (word) { U0, V0, ..., U3, V3 }

  527.     psrlw          m1, 8                  ; (word) { U4, V4, ..., U7, V7 }

  528. %else ; uyvy

  529. %if cpuflag(avx)

  530.     vpand          m0, m2, [srcq+wq*4]        ; (word) { U0, V0, ..., U3, V3 }

  531.     vpand          m1, m2, [srcq+wq*4+mmsize] ; (word) { U4, V4, ..., U7, V7 }

  532. %else

  533.     mov%1          m0, [srcq+wq*4]        ; (byte) { Y0, U0, Y1, V0, ... }

  534.     mov%1          m1, [srcq+wq*4+mmsize] ; (byte) { Y8, U4, Y9, V4, ... }

  535.     pand           m0, m2                 ; (word) { U0, V0, ..., U3, V3 }

  536.     pand           m1, m2                 ; (word) { U4, V4, ..., U7, V7 }

  537. %endif

  538. %endif ; yuyv/uyvy

  539.     packuswb       m0, m1                 ; (byte) { U0, V0, ..., U7, V7 }

  540.     pand           m1, m0, m2             ; (word) { U0, U1, ..., U7 }

  541.     psrlw          m0, 8                  ; (word) { V0, V1, ..., V7 }

  542. %if mmsize == 16

  543.     packuswb       m1, m0                 ; (byte) { U0, ... U7, V1, ... V7 }

  544.     movh   [dstUq+wq], m1

  545.     movhps [dstVq+wq], m1

  546. %else ; mmsize == 8

  547.     packuswb       m1, m1                 ; (byte) { U0, ... U3 }

  548.     packuswb       m0, m0                 ; (byte) { V0, ... V3 }

  549.     movh   [dstUq+wq], m1

  550.     movh   [dstVq+wq], m0

  551. %endif ; mmsize == 8/16

  552.     add            wq, mmsize / 2

  553.     jl .loop_%1

  554.     REP_RET

  555. %endmacro

  556. 

  557. ; %1 = nr. of XMM registers

  558. ; %2 = yuyv or uyvy

  559. ; %3 = if specified, it means that unaligned and aligned code in loop

  560. ;      will be the same (i.e. UYVY+AVX), and thus we don't need to

  561. ;      split the loop in an aligned and unaligned case

  562. %macro YUYV_TO_UV_FN 2-3

  563. cglobal %2ToUV, 3, 4, %1, dstU, dstV, src, w

  564. %if ARCH_X86_64

  565.     movsxd         wq, dword r4m

  566. %else ; x86-32

  567.     mov            wq, r4m

  568. %endif

  569.     add         dstUq, wq

  570.     add         dstVq, wq

  571. %if mmsize == 16 && %0 == 2

  572.     test         srcq, 15

  573. %endif

  574.     lea          srcq, [srcq+wq*4]

  575.     pcmpeqb        m2, m2                 ; (byte) { 0xff } x 16

  576.     psrlw          m2, 8                  ; (word) { 0x00ff } x 8

  577.     ; NOTE: if uyvy+avx, u/a are identical

  578. %if mmsize == 16 && %0 == 2

  579.     jnz .loop_u_start

  580.     neg            wq

  581.     LOOP_YUYV_TO_UV a, %2

  582. .loop_u_start:

  583.     neg            wq

  584.     LOOP_YUYV_TO_UV u, %2

  585. %else ; mmsize == 8

  586.     neg            wq

  587.     LOOP_YUYV_TO_UV a, %2

  588. %endif ; mmsize == 8/16

  589. %endmacro

  590. 

  591. ; %1 = a (aligned) or u (unaligned)

  592. ; %2 = nv12 or nv21

  593. %macro LOOP_NVXX_TO_UV 2

  594. .loop_%1:

  595.     mov%1          m0, [srcq+wq*2]        ; (byte) { U0, V0, U1, V1, ... }

  596.     mov%1          m1, [srcq+wq*2+mmsize] ; (byte) { U8, V8, U9, V9, ... }

  597.     pand           m2, m0, m4             ; (word) { U0, U1, ..., U7 }

  598.     pand           m3, m1, m4             ; (word) { U8, U9, ..., U15 }

  599.     psrlw          m0, 8                  ; (word) { V0, V1, ..., V7 }

  600.     psrlw          m1, 8                  ; (word) { V8, V9, ..., V15 }

  601.     packuswb       m2, m3                 ; (byte) { U0, ..., U15 }

  602.     packuswb       m0, m1                 ; (byte) { V0, ..., V15 }

  603. %ifidn %2, nv12

  604.     mova   [dstUq+wq], m2

  605.     mova   [dstVq+wq], m0

  606. %else ; nv21

  607.     mova   [dstVq+wq], m2

  608.     mova   [dstUq+wq], m0

  609. %endif ; nv12/21

  610.     add            wq, mmsize

  611.     jl .loop_%1

  612.     REP_RET

  613. %endmacro

  614. 

  615. ; %1 = nr. of XMM registers

  616. ; %2 = nv12 or nv21

  617. %macro NVXX_TO_UV_FN 2

  618. cglobal %2ToUV, 3, 4, %1, dstU, dstV, src, w

  619. %if ARCH_X86_64

  620.     movsxd         wq, dword r4m

  621. %else ; x86-32

  622.     mov            wq, r4m

  623. %endif

  624.     add         dstUq, wq

  625.     add         dstVq, wq

  626. %if mmsize == 16

  627.     test         srcq, 15

  628. %endif

  629.     lea          srcq, [srcq+wq*2]

  630.     pcmpeqb        m4, m4                 ; (byte) { 0xff } x 16

  631.     psrlw          m4, 8                  ; (word) { 0x00ff } x 8

  632. %if mmsize == 16

  633.     jnz .loop_u_start

  634.     neg            wq

  635.     LOOP_NVXX_TO_UV a, %2

  636. .loop_u_start:

  637.     neg            wq

  638.     LOOP_NVXX_TO_UV u, %2

  639. %else ; mmsize == 8

  640.     neg            wq

  641.     LOOP_NVXX_TO_UV a, %2

  642. %endif ; mmsize == 8/16

  643. %endmacro

  644. 

  645. %if ARCH_X86_32

  646. INIT_MMX mmx

  647. YUYV_TO_Y_FN  0, yuyv

  648. YUYV_TO_Y_FN  0, uyvy

  649. YUYV_TO_UV_FN 0, yuyv

  650. YUYV_TO_UV_FN 0, uyvy

  651. NVXX_TO_UV_FN 0, nv12

  652. NVXX_TO_UV_FN 0, nv21

  653. %endif

  654. 

  655. INIT_XMM sse2

  656. YUYV_TO_Y_FN  3, yuyv

  657. YUYV_TO_Y_FN  2, uyvy

  658. YUYV_TO_UV_FN 3, yuyv

  659. YUYV_TO_UV_FN 3, uyvy

  660. NVXX_TO_UV_FN 5, nv12

  661. NVXX_TO_UV_FN 5, nv21

  662. 

  663. INIT_XMM avx

  664. ; in theory, we could write a yuy2-to-y using vpand (i.e. AVX), but

  665. ; that's not faster in practice

  666. YUYV_TO_UV_FN 3, yuyv

  667. YUYV_TO_UV_FN 3, uyvy, 1

  668. NVXX_TO_UV_FN 5, nv12

  669. NVXX_TO_UV_FN 5, nv21