| ; |
| ; Copyright (c) 2010 The VP8 project authors. All Rights Reserved. |
| ; |
| ; Use of this source code is governed by a BSD-style license and patent |
| ; grant that can be found in the LICENSE file in the root of the source |
| ; tree. All contributing project authors may be found in the AUTHORS |
| ; file in the root of the source tree. |
| ; |
| |
| |
| %include "vpx_ports/x86_abi_support.asm" |
| |
| |
| ;void vp8_loop_filter_horizontal_edge_sse2 |
| ;( |
| ; unsigned char *src_ptr, |
| ; int src_pixel_step, |
| ; const char *flimit, |
| ; const char *limit, |
| ; const char *thresh, |
| ; int count |
| ;) |
| global sym(vp8_loop_filter_horizontal_edge_sse2) |
| sym(vp8_loop_filter_horizontal_edge_sse2): |
| push rbp |
| mov rbp, rsp |
| SHADOW_ARGS_TO_STACK 6 |
| GET_GOT rbx |
| push rsi |
| push rdi |
| ; end prolog |
| |
| ALIGN_STACK 16, rax |
| sub rsp, 32 ; reserve 32 bytes |
| %define t0 [rsp + 0] ;__declspec(align(16)) char t0[16]; |
| %define t1 [rsp + 16] ;__declspec(align(16)) char t1[16]; |
| |
| mov rsi, arg(0) ;src_ptr |
| movsxd rax, dword ptr arg(1) ;src_pixel_step ; destination pitch? |
| |
| mov rdx, arg(3) ;limit |
| movdqa xmm7, XMMWORD PTR [rdx] |
| mov rdi, rsi ; rdi points to row +1 for indirect addressing |
| add rdi, rax |
| |
| ; calculate breakout conditions |
| movdqu xmm2, [rdi+2*rax] ; q3 |
| movdqu xmm1, [rsi+2*rax] ; q2 |
| movdqa xmm6, xmm1 ; q2 |
| psubusb xmm1, xmm2 ; q2-=q3 |
| psubusb xmm2, xmm6 ; q3-=q2 |
| por xmm1, xmm2 ; abs(q3-q2) |
| psubusb xmm1, xmm7 ; |
| |
| |
| movdqu xmm4, [rsi+rax] ; q1 |
| movdqa xmm3, xmm4 ; q1 |
| psubusb xmm4, xmm6 ; q1-=q2 |
| psubusb xmm6, xmm3 ; q2-=q1 |
| por xmm4, xmm6 ; abs(q2-q1) |
| |
| psubusb xmm4, xmm7 |
| por xmm1, xmm4 |
| |
| movdqu xmm4, [rsi] ; q0 |
| movdqa xmm0, xmm4 ; q0 |
| psubusb xmm4, xmm3 ; q0-=q1 |
| psubusb xmm3, xmm0 ; q1-=q0 |
| por xmm4, xmm3 ; abs(q0-q1) |
| movdqa t0, xmm4 ; save to t0 |
| psubusb xmm4, xmm7 |
| por xmm1, xmm4 |
| |
| neg rax ; negate pitch to deal with above border |
| movdqu xmm2, [rsi+4*rax] ; p3 |
| movdqu xmm4, [rdi+4*rax] ; p2 |
| movdqa xmm5, xmm4 ; p2 |
| psubusb xmm4, xmm2 ; p2-=p3 |
| psubusb xmm2, xmm5 ; p3-=p2 |
| por xmm4, xmm2 ; abs(p3 - p2) |
| psubusb xmm4, xmm7 |
| por xmm1, xmm4 |
| |
| |
| movdqu xmm4, [rsi+2*rax] ; p1 |
| movdqa xmm3, xmm4 ; p1 |
| psubusb xmm4, xmm5 ; p1-=p2 |
| psubusb xmm5, xmm3 ; p2-=p1 |
| por xmm4, xmm5 ; abs(p2 - p1) |
| psubusb xmm4, xmm7 |
| por xmm1, xmm4 |
| |
| movdqa xmm2, xmm3 ; p1 |
| |
| movdqu xmm4, [rsi+rax] ; p0 |
| movdqa xmm5, xmm4 ; p0 |
| psubusb xmm4, xmm3 ; p0-=p1 |
| psubusb xmm3, xmm5 ; p1-=p0 |
| por xmm4, xmm3 ; abs(p1 - p0) |
| movdqa t1, xmm4 ; save to t1 |
| psubusb xmm4, xmm7 |
| por xmm1, xmm4 |
| |
| movdqu xmm3, [rdi] ; q1 |
| movdqa xmm4, xmm3 ; q1 |
| psubusb xmm3, xmm2 ; q1-=p1 |
| psubusb xmm2, xmm4 ; p1-=q1 |
| por xmm2, xmm3 ; abs(p1-q1) |
| pand xmm2, [tfe GLOBAL] ; set lsb of each byte to zero |
| psrlw xmm2, 1 ; abs(p1-q1)/2 |
| |
| movdqa xmm6, xmm5 ; p0 |
| movdqu xmm3, [rsi] ; q0 |
| psubusb xmm5, xmm3 ; p0-=q0 |
| psubusb xmm3, xmm6 ; q0-=p0 |
| por xmm5, xmm3 ; abs(p0 - q0) |
| paddusb xmm5, xmm5 ; abs(p0-q0)*2 |
| paddusb xmm5, xmm2 ; abs (p0 - q0) *2 + abs(p1-q1)/2 |
| |
| mov rdx, arg(2) ;flimit ; get flimit |
| movdqa xmm2, [rdx] ; |
| |
| paddb xmm2, xmm2 ; flimit*2 (less than 255) |
| paddb xmm7, xmm2 ; flimit * 2 + limit (less than 255) |
| |
| psubusb xmm5, xmm7 ; abs (p0 - q0) *2 + abs(p1-q1)/2 > flimit * 2 + limit |
| por xmm1, xmm5 |
| pxor xmm5, xmm5 |
| pcmpeqb xmm1, xmm5 ; mask mm1 |
| |
| |
| ; calculate high edge variance |
| mov rdx, arg(4) ;thresh ; get thresh |
| movdqa xmm7, [rdx] ; |
| movdqa xmm4, t0 ; get abs (q1 - q0) |
| psubusb xmm4, xmm7 |
| movdqa xmm3, t1 ; get abs (p1 - p0) |
| psubusb xmm3, xmm7 |
| paddb xmm4, xmm3 ; abs(q1 - q0) > thresh || abs(p1 - p0) > thresh |
| pcmpeqb xmm4, xmm5 |
| pcmpeqb xmm5, xmm5 |
| pxor xmm4, xmm5 |
| |
| |
| ; start work on filters |
| movdqu xmm2, [rsi+2*rax] ; p1 |
| movdqu xmm7, [rdi] ; q1 |
| pxor xmm2, [t80 GLOBAL] ; p1 offset to convert to signed values |
| pxor xmm7, [t80 GLOBAL] ; q1 offset to convert to signed values |
| psubsb xmm2, xmm7 ; p1 - q1 |
| pand xmm2, xmm4 ; high var mask (hvm)(p1 - q1) |
| pxor xmm6, [t80 GLOBAL] ; offset to convert to signed values |
| pxor xmm0, [t80 GLOBAL] ; offset to convert to signed values |
| movdqa xmm3, xmm0 ; q0 |
| psubsb xmm0, xmm6 ; q0 - p0 |
| paddsb xmm2, xmm0 ; 1 * (q0 - p0) + hvm(p1 - q1) |
| paddsb xmm2, xmm0 ; 2 * (q0 - p0) + hvm(p1 - q1) |
| paddsb xmm2, xmm0 ; 3 * (q0 - p0) + hvm(p1 - q1) |
| pand xmm1, xmm2 ; mask filter values we don't care about |
| movdqa xmm2, xmm1 |
| paddsb xmm1, [t4 GLOBAL] ; 3* (q0 - p0) + hvm(p1 - q1) + 4 |
| paddsb xmm2, [t3 GLOBAL] ; 3* (q0 - p0) + hvm(p1 - q1) + 3 |
| |
| pxor xmm0, xmm0 ; |
| pxor xmm5, xmm5 |
| punpcklbw xmm0, xmm2 ; |
| punpckhbw xmm5, xmm2 ; |
| psraw xmm0, 11 ; |
| psraw xmm5, 11 |
| packsswb xmm0, xmm5 |
| movdqa xmm2, xmm0 ; (3* (q0 - p0) + hvm(p1 - q1) + 3) >> 3; |
| |
| pxor xmm0, xmm0 ; 0 |
| movdqa xmm5, xmm1 ; abcdefgh |
| punpcklbw xmm0, xmm1 ; e0f0g0h0 |
| psraw xmm0, 11 ; sign extended shift right by 3 |
| pxor xmm1, xmm1 ; 0 |
| punpckhbw xmm1, xmm5 ; a0b0c0d0 |
| psraw xmm1, 11 ; sign extended shift right by 3 |
| movdqa xmm5, xmm0 ; save results |
| |
| packsswb xmm0, xmm1 ; (3* (q0 - p0) + hvm(p1 - q1) + 4) >>3 |
| paddsw xmm5, [ones GLOBAL] |
| paddsw xmm1, [ones GLOBAL] |
| psraw xmm5, 1 ; partial shifted one more time for 2nd tap |
| psraw xmm1, 1 ; partial shifted one more time for 2nd tap |
| packsswb xmm5, xmm1 ; (3* (q0 - p0) + hvm(p1 - q1) + 4) >>4 |
| pandn xmm4, xmm5 ; high edge variance additive |
| |
| paddsb xmm6, xmm2 ; p0+= p0 add |
| pxor xmm6, [t80 GLOBAL] ; unoffset |
| movdqu [rsi+rax], xmm6 ; write back |
| |
| movdqu xmm6, [rsi+2*rax] ; p1 |
| pxor xmm6, [t80 GLOBAL] ; reoffset |
| paddsb xmm6, xmm4 ; p1+= p1 add |
| pxor xmm6, [t80 GLOBAL] ; unoffset |
| movdqu [rsi+2*rax], xmm6 ; write back |
| |
| psubsb xmm3, xmm0 ; q0-= q0 add |
| pxor xmm3, [t80 GLOBAL] ; unoffset |
| movdqu [rsi], xmm3 ; write back |
| |
| psubsb xmm7, xmm4 ; q1-= q1 add |
| pxor xmm7, [t80 GLOBAL] ; unoffset |
| movdqu [rdi], xmm7 ; write back |
| |
| add rsp, 32 |
| pop rsp |
| ; begin epilog |
| pop rdi |
| pop rsi |
| RESTORE_GOT |
| UNSHADOW_ARGS |
| pop rbp |
| ret |
| |
| |
| ;void vp8_loop_filter_vertical_edge_sse2 |
| ;( |
| ; unsigned char *src_ptr, |
| ; int src_pixel_step, |
| ; const char *flimit, |
| ; const char *limit, |
| ; const char *thresh, |
| ; int count |
| ;) |
| global sym(vp8_loop_filter_vertical_edge_sse2) |
| sym(vp8_loop_filter_vertical_edge_sse2): |
| push rbp |
| mov rbp, rsp |
| SHADOW_ARGS_TO_STACK 6 |
| GET_GOT rbx |
| push rsi |
| push rdi |
| ; end prolog |
| |
| ALIGN_STACK 16, rax |
| sub rsp, 96 ; reserve 96 bytes |
| %define t0 [rsp + 0] ;__declspec(align(16)) char t0[16]; |
| %define t1 [rsp + 16] ;__declspec(align(16)) char t1[16]; |
| %define srct [rsp + 32] ;__declspec(align(16)) char srct[64]; |
| |
| mov rsi, arg(0) ;src_ptr |
| movsxd rax, dword ptr arg(1) ;src_pixel_step ; destination pitch? |
| |
| lea rsi, [rsi + rax*4 - 4] |
| mov rdi, rsi ; rdi points to row +1 for indirect addressing |
| |
| add rdi, rax |
| lea rcx, [rdi + rax *8] |
| |
| ;transpose |
| movq xmm7, QWORD PTR [rsi+2*rax] ; 67 66 65 64 63 62 61 60 |
| movq xmm6, QWORD PTR [rdi+2*rax] ; 77 76 75 74 73 72 71 70 |
| |
| punpcklbw xmm7, xmm6 ; 77 67 76 66 75 65 74 64 73 63 72 62 71 61 70 60 |
| movq xmm5, QWORD PTR [rsi] ; 47 46 45 44 43 42 41 40 |
| |
| movq xmm4, QWORD PTR [rsi+rax] ; 57 56 55 54 53 52 51 50 |
| punpcklbw xmm5, xmm4 ; 57 47 56 46 55 45 54 44 53 43 52 42 51 41 50 40 |
| |
| movdqa xmm3, xmm5 ; 57 47 56 46 55 45 54 44 53 43 52 42 51 41 50 40 |
| punpckhwd xmm5, xmm7 ; 77 67 57 47 76 66 56 46 75 65 55 45 74 64 54 44 |
| |
| lea rsi, [rsi+ rax*8] |
| |
| punpcklwd xmm3, xmm7 ; 73 63 53 43 72 62 52 42 71 61 51 41 70 60 50 40 |
| movq xmm6, QWORD PTR [rsi + 2*rax] ; e7 e6 e5 e4 e3 e2 e1 e0 |
| |
| movq xmm7, QWORD PTR [rcx + 2*rax] ; f7 f6 f5 f4 f3 f2 f1 f0 |
| punpcklbw xmm6, xmm7 ; f7 e7 f6 e6 f5 e5 f4 e4 f3 e3 f2 e2 f1 e1 f0 e0 |
| |
| movq xmm4, QWORD PTR [rsi] ; c7 c6 c5 c4 c3 c2 c1 c0 |
| movq xmm7, QWORD PTR [rsi + rax] ; d7 d6 d5 d4 d3 d2 d1 d0 |
| |
| punpcklbw xmm4, xmm7 ; d7 c7 d6 c6 d5 c5 d4 c4 d3 c3 d2 c2 d1 c1 d0 c0 |
| movdqa xmm7, xmm4 ; d7 c7 d6 c6 d5 c5 d4 c4 d3 c3 d2 c2 d1 c1 d0 c0 |
| |
| punpckhwd xmm7, xmm6 ; f7 e7 d7 c7 f6 e6 d6 c6 f5 e5 d5 c5 f4 e4 d4 c4 |
| punpcklwd xmm4, xmm6 ; f3 e3 d3 c3 f2 e2 d2 c2 f1 e1 d1 c1 f0 e0 d0 c0 |
| |
| ; xmm3 xmm4, xmm5 xmm7 in use |
| neg rax |
| |
| lea rsi, [rsi+rax*8] |
| movq xmm6, QWORD PTR [rsi+rax*2] ; 27 26 25 24 23 22 21 20 |
| |
| movq xmm1, QWORD PTR [rsi+rax ] ; 37 36 35 34 33 32 31 30 |
| punpcklbw xmm6, xmm1 ; 37 27 36 26 35 25 34 24 33 23 32 22 31 21 30 20 |
| |
| movq xmm2, QWORD PTR [rsi+rax*4] ; 07 06 05 04 03 02 01 00 |
| movq xmm1, QWORD PTR [rdi+rax*4] ; 17 16 15 14 13 12 11 10 |
| |
| punpcklbw xmm2, xmm1 ; 17 07 16 06 15 05 14 04 13 03 12 02 11 01 10 00 |
| movdqa xmm0, xmm2 |
| |
| punpckhwd xmm2, xmm6 ; 37 27 17 07 36 26 16 06 35 25 15 05 34 24 14 04 |
| punpcklwd xmm0, xmm6 ; 33 23 13 03 32 22 12 02 31 21 11 01 30 20 10 00 |
| |
| movdqa xmm6, xmm2 |
| punpckldq xmm2, xmm5 ; 75 65 55 45 35 25 15 05 74 64 54 44 34 24 14 04 |
| |
| punpckhdq xmm6, xmm5 ; 77 67 57 47 37 27 17 07 76 66 56 46 36 26 16 06 |
| ;xmm0 xmm2 xmm3 xmm4, xmm6, xmm7 |
| |
| movdqa xmm5, xmm0 ; 33 23 13 03 32 22 12 02 31 21 11 01 30 20 10 00 |
| punpckhdq xmm5, xmm3 ; 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02 |
| |
| punpckldq xmm0, xmm3 ; 71 61 51 41 31 21 11 01 70 60 50 40 30 20 10 00 |
| lea rsi, [rcx+rax] |
| ; xmm1, xmm3 free |
| movq xmm1, QWORD PTR [rsi+rax*2] ; a7 a6 a5 a4 a3 a2 a1 a0 |
| movq xmm3, QWORD PTR [rsi+rax] ; b7 b6 b5 b4 b3 b2 b1 b0 |
| |
| punpcklbw xmm1, xmm3 ; |
| lea rdx, srct ; |
| |
| movdqa [rdx+16], xmm1 ; b7 a7 b6 a6 b5 a5 b4 a4 b3 a3 b2 a2 b1 a1 b0 a0 |
| movq xmm3, QWORD PTR [rsi+rax*4] ; 87 86 85 84 83 82 81 80 |
| |
| movq xmm1, QWORD PTR [rcx+rax*4] |
| punpcklbw xmm3, xmm1 ; 97 87 96 86 95 85 94 84 93 83 92 82 91 81 90 80 |
| |
| movdqa [rdx], xmm3 ; 97 87 96 86 95 85 94 84 93 83 92 82 91 81 90 80 |
| |
| punpckhwd xmm3, [rdx+16] ; b7 a7 97 87 b6 a6 96 86 b5 a5 95 85 b4 a4 94 84 |
| movdqa xmm1, xmm3 ; b7 a7 97 87 b6 a6 96 86 b5 a5 95 85 b4 a4 94 84 |
| |
| punpckhdq xmm1, xmm7 ; f7 e7 d7 c7 b7 a7 97 87 f6 e6 d6 c6 b6 a6 96 86 |
| punpckldq xmm3, xmm7 ; f5 e5 d5 c5 b5 a5 95 85 f4 e4 d4 c4 b4 a4 94 84 |
| |
| movdqa xmm7, xmm2 ; 75 65 55 45 35 25 15 05 74 64 54 44 34 24 14 04 |
| punpcklqdq xmm7, xmm3 ; f4 e4 d4 c4 b4 a4 94 84 74 64 54 44 34 24 14 04 |
| |
| punpckhqdq xmm2, xmm3 ; f5 e5 d5 c5 b5 a5 95 85 75 65 55 45 35 25 15 05 |
| movdqa [rdx+32], xmm7 ; save 4s |
| |
| movdqa [rdx+48], xmm2 ; save 5s |
| movdqa xmm7, xmm6 ; 77 67 57 47 37 27 17 07 76 66 56 46 36 26 16 06 |
| |
| punpckhqdq xmm7, xmm1 ; f7 e7 d7 c7 b7 a7 97 87 77 67 57 47 37 27 17 07 = q3 |
| punpcklqdq xmm6, xmm1 ; f6 e6 d6 c6 b6 a6 96 86 76 66 56 46 36 26 16 06 = q2 |
| |
| ; free 1, 3 xmm7-7s xmm6-6s, xmm2-5s |
| movq xmm1, QWORD PTR [rdx] ; 93 83 92 82 91 81 90 80 |
| movq xmm3, QWORD PTR [rdx+16] ; b3 a3 b2 a2 b1 a1 b0 a0 |
| |
| punpcklwd xmm1, xmm3 ; b3 a3 93 83 b2 a2 92 82 b1 a1 91 81 b0 a0 90 80 |
| movdqa xmm3, xmm1 ; b3 a3 93 83 b2 a2 92 82 b1 a1 91 81 b0 a0 90 80 |
| |
| punpckhdq xmm3, xmm4 ; f3 e3 d3 c3 b3 a3 93 83 f2 e2 d2 c2 b2 a2 92 82 |
| punpckldq xmm1, xmm4 ; f1 e1 d1 c1 b1 a1 91 81 f0 e0 d0 c0 b0 a0 90 80 |
| |
| movdqa xmm4, xmm5 ; 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02 |
| punpcklqdq xmm5, xmm3 ; f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02 |
| |
| punpckhqdq xmm4, xmm3 ; f3 e3 d3 c3 b3 a3 93 83 73 63 53 43 33 23 13 03 |
| movdqa [rdx], xmm5 ; save 2s |
| |
| movdqa [rdx+16], xmm4 ; save 3s |
| |
| movdqa xmm3, xmm6 ; |
| psubusb xmm3, xmm7 ; q3 - q2 |
| |
| psubusb xmm7, xmm6 ; q2 - q3 |
| por xmm7, xmm3 ; abs(q3-q2) |
| |
| movdqa xmm3, xmm2 ; q1 |
| psubusb xmm3, xmm6 ; q1 - q2 |
| |
| psubusb xmm6, xmm2 ; q2 - q1 |
| por xmm6, xmm3 ; abs(q2-q1) |
| |
| |
| movdqa xmm3, xmm0 ; 71 61 51 41 31 21 11 01 70 60 50 40 30 20 10 00 |
| punpcklqdq xmm0, xmm1 ; f0 e0 d0 c0 b0 a0 90 80 70 60 50 40 30 20 10 00 |
| |
| punpckhqdq xmm3, xmm1 ; f1 e1 d1 c1 b1 a1 91 81 71 61 51 41 31 21 11 01 |
| movdqa xmm1, xmm3 |
| |
| psubusb xmm3, xmm0 ; p2-p3 |
| psubusb xmm0, xmm1 ; p3-p2 |
| |
| por xmm0, xmm3 ; abs(p3-p2) |
| movdqa xmm3, xmm5 ; f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02 |
| |
| psubusb xmm3, xmm1 ; p1-p2 |
| psubusb xmm1, xmm5 ; p2-p1 |
| |
| por xmm1, xmm3 ; abs(p1-p2) |
| mov rdx, arg(3) ;limit |
| |
| movdqa xmm3, [rdx] ; limit |
| |
| psubusb xmm7, xmm3 |
| psubusb xmm0, xmm3 |
| |
| psubusb xmm1, xmm3 |
| psubusb xmm6, xmm3 |
| |
| por xmm7, xmm6 |
| por xmm0, xmm1 |
| |
| por xmm0, xmm7 ; abs(q3-q2) > limit || abs(p3-p2) > limit ||abs(p2-p1) > limit || abs(q2-q1) > limit |
| |
| movdqa xmm1, xmm5 ; p1 |
| |
| movdqa xmm7, xmm4 ; xmm4 xmm7 = p0 |
| |
| psubusb xmm7, xmm5 ; p0 - p1 |
| psubusb xmm5, xmm4 ; p1 - p0 |
| |
| por xmm5, xmm7 ; abs(p1-p0) |
| movdqa t0, xmm5 ; save abs(p1-p0) |
| |
| lea rdx, srct |
| psubusb xmm5, xmm3 |
| |
| por xmm0, xmm5 ; xmm0=mask |
| movdqa xmm5, [rdx+32] ; xmm5=q0 |
| |
| movdqa xmm7, [rdx+48] ; xmm7=q1 |
| movdqa xmm6, xmm5 ; mm6=q0 |
| |
| movdqa xmm2, xmm7 ; q1 |
| |
| psubusb xmm5, xmm7 ; q0-q1 |
| psubusb xmm7, xmm6 ; q1-q0 |
| |
| por xmm7, xmm5 ; abs(q1-q0) |
| movdqa t1, xmm7 ; save abs(q1-q0) |
| |
| psubusb xmm7, xmm3 |
| por xmm0, xmm7 ; mask |
| |
| movdqa xmm5, xmm2 ; q1 |
| psubusb xmm5, xmm1 ; q1-=p1 |
| psubusb xmm1, xmm2 ; p1-=q1 |
| por xmm5, xmm1 ; abs(p1-q1) |
| pand xmm5, [tfe GLOBAL] ; set lsb of each byte to zero |
| psrlw xmm5, 1 ; abs(p1-q1)/2 |
| |
| mov rdx, arg(2) ;flimit ; |
| movdqa xmm2, [rdx] ;flimit xmm2 |
| |
| movdqa xmm1, xmm4 ; xmm1=xmm4=p0 |
| |
| movdqa xmm7, xmm6 ; xmm7=xmm6=q0 |
| psubusb xmm1, xmm7 ; p0-q0 |
| |
| psubusb xmm7, xmm4 ; q0-p0 |
| por xmm1, xmm7 ; abs(q0-p0) |
| paddusb xmm1, xmm1 ; abs(q0-p0)*2 |
| paddusb xmm1, xmm5 ; abs (p0 - q0) *2 + abs(p1-q1)/2 |
| |
| paddb xmm2, xmm2 ; flimit*2 (less than 255) |
| paddb xmm3, xmm2 ; flimit * 2 + limit (less than 255) |
| |
| psubusb xmm1, xmm3 ; abs (p0 - q0) *2 + abs(p1-q1)/2 > flimit * 2 + limit |
| |
| por xmm1, xmm0; ; mask |
| |
| pxor xmm0, xmm0 |
| pcmpeqb xmm1, xmm0 |
| ; calculate high edge variance |
| mov rdx, arg(4) ;thresh ; get thresh |
| movdqa xmm7, [rdx] |
| |
| ; |
| movdqa xmm4, t0 ; get abs (q1 - q0) |
| psubusb xmm4, xmm7 |
| |
| movdqa xmm3, t1 ; get abs (p1 - p0) |
| psubusb xmm3, xmm7 |
| |
| por xmm4, xmm3 ; abs(q1 - q0) > thresh || abs(p1 - p0) > thresh |
| pcmpeqb xmm4, xmm0 |
| |
| pcmpeqb xmm0, xmm0 |
| pxor xmm4, xmm0 |
| |
| ; start work on filters |
| lea rdx, srct |
| |
| movdqa xmm2, [rdx] ; p1 |
| movdqa xmm7, [rdx+48] ; q1 |
| |
| movdqa xmm6, [rdx+16] ; p0 |
| movdqa xmm0, [rdx+32] ; q0 |
| |
| pxor xmm2, [t80 GLOBAL] ; p1 offset to convert to signed values |
| pxor xmm7, [t80 GLOBAL] ; q1 offset to convert to signed values |
| |
| psubsb xmm2, xmm7 ; p1 - q1 |
| pand xmm2, xmm4 ; high var mask (hvm)(p1 - q1) |
| |
| pxor xmm6, [t80 GLOBAL] ; offset to convert to signed values |
| pxor xmm0, [t80 GLOBAL] ; offset to convert to signed values |
| |
| movdqa xmm3, xmm0 ; q0 |
| psubsb xmm0, xmm6 ; q0 - p0 |
| |
| paddsb xmm2, xmm0 ; 1 * (q0 - p0) + hvm(p1 - q1) |
| paddsb xmm2, xmm0 ; 2 * (q0 - p0) + hvm(p1 - q1) |
| |
| paddsb xmm2, xmm0 ; 3 * (q0 - p0) + hvm(p1 - q1) |
| pand xmm1, xmm2 ; mask filter values we don't care about |
| |
| movdqa xmm2, xmm1 |
| paddsb xmm1, [t4 GLOBAL] ; 3* (q0 - p0) + hvm(p1 - q1) + 4 |
| |
| paddsb xmm2, [t3 GLOBAL] ; 3* (q0 - p0) + hvm(p1 - q1) + 3 |
| pxor xmm0, xmm0 ; |
| |
| pxor xmm5, xmm5 |
| punpcklbw xmm0, xmm2 ; |
| |
| punpckhbw xmm5, xmm2 ; |
| psraw xmm0, 11 ; |
| |
| psraw xmm5, 11 |
| packsswb xmm0, xmm5 |
| |
| movdqa xmm2, xmm0 ; (3* (q0 - p0) + hvm(p1 - q1) + 3) >> 3; |
| |
| pxor xmm0, xmm0 ; 0 |
| movdqa xmm5, xmm1 ; abcdefgh |
| |
| punpcklbw xmm0, xmm1 ; e0f0g0h0 |
| psraw xmm0, 11 ; sign extended shift right by 3 |
| |
| pxor xmm1, xmm1 ; 0 |
| punpckhbw xmm1, xmm5 ; a0b0c0d0 |
| |
| psraw xmm1, 11 ; sign extended shift right by 3 |
| movdqa xmm5, xmm0 ; save results |
| |
| packsswb xmm0, xmm1 ; (3* (q0 - p0) + hvm(p1 - q1) + 4) >>3 |
| paddsw xmm5, [ones GLOBAL] |
| |
| paddsw xmm1, [ones GLOBAL] |
| psraw xmm5, 1 ; partial shifted one more time for 2nd tap |
| |
| psraw xmm1, 1 ; partial shifted one more time for 2nd tap |
| packsswb xmm5, xmm1 ; (3* (q0 - p0) + hvm(p1 - q1) + 4) >>4 |
| |
| pandn xmm4, xmm5 ; high edge variance additive |
| |
| paddsb xmm6, xmm2 ; p0+= p0 add |
| pxor xmm6, [t80 GLOBAL] ; unoffset |
| |
| ; mm6=p0 ; |
| movdqa xmm1, [rdx] ; p1 |
| pxor xmm1, [t80 GLOBAL] ; reoffset |
| |
| paddsb xmm1, xmm4 ; p1+= p1 add |
| pxor xmm1, [t80 GLOBAL] ; unoffset |
| ; mm6 = p0 mm1 = p1 |
| |
| psubsb xmm3, xmm0 ; q0-= q0 add |
| pxor xmm3, [t80 GLOBAL] ; unoffset |
| |
| ; mm3 = q0 |
| psubsb xmm7, xmm4 ; q1-= q1 add |
| pxor xmm7, [t80 GLOBAL] ; unoffset |
| ; mm7 = q1 |
| |
| ; tranpose and write back |
| ; xmm1 = f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02 |
| ; xmm6 = f3 e3 d3 c3 b3 a3 93 83 73 63 53 43 33 23 13 03 |
| ; xmm3 = f4 e4 d4 c4 b4 a4 94 84 74 64 54 44 34 24 14 04 |
| ; xmm7 = f5 e5 d5 c5 b5 a5 95 85 75 65 55 45 35 25 15 05 |
| movdqa xmm2, xmm1 ; f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02 |
| punpcklbw xmm2, xmm6 ; 73 72 63 62 53 52 43 42 33 32 23 22 13 12 03 02 |
| |
| movdqa xmm4, xmm3 ; f4 e4 d4 c4 b4 a4 94 84 74 64 54 44 34 24 14 04 |
| punpckhbw xmm1, xmm6 ; f3 f2 e3 e2 d3 d2 c3 c2 b3 b2 a3 a2 93 92 83 82 |
| |
| punpcklbw xmm4, xmm7 ; 75 74 65 64 55 54 45 44 35 34 25 24 15 14 05 04 |
| punpckhbw xmm3, xmm7 ; f5 f4 e5 e4 d5 d4 c5 c4 b5 b4 a5 a4 95 94 85 84 |
| |
| movdqa xmm6, xmm2 ; 73 72 63 62 53 52 43 42 33 32 23 22 13 12 03 02 |
| punpcklwd xmm2, xmm4 ; 35 34 33 32 25 24 23 22 15 14 13 12 05 04 03 02 |
| |
| punpckhwd xmm6, xmm4 ; 75 74 73 72 65 64 63 62 55 54 53 52 45 44 43 42 |
| movdqa xmm5, xmm1 ; f3 f2 e3 e2 d3 d2 c3 c2 b3 b2 a3 a2 93 92 83 82 |
| |
| punpcklwd xmm1, xmm3 ; f5 f4 f3 f2 e5 e4 e3 e2 d5 d4 d3 d2 c5 c4 c3 c2 |
| punpckhwd xmm5, xmm3 ; b5 b4 b3 b2 a5 a4 a3 a2 95 94 93 92 85 84 83 82 |
| |
| ; xmm2 = 35 34 33 32 25 24 23 22 15 14 13 12 05 04 03 02 |
| ; xmm6 = 75 74 73 72 65 64 63 62 55 54 53 52 45 44 43 42 |
| ; xmm5 = f3 f2 e3 e2 d3 d2 c3 c2 b3 b2 a3 a2 93 92 83 82 |
| ; xmm1 = b5 b4 b3 b2 a5 a4 a3 a2 95 94 93 92 85 84 83 82 |
| lea rsi, [rsi+rax*8] |
| |
| movd [rsi+rax*4+2], xmm2 |
| psrldq xmm2, 4 |
| |
| movd [rdi+rax*4+2], xmm2 |
| psrldq xmm2, 4 |
| |
| movd [rsi+rax*2+2], xmm2 |
| psrldq xmm2, 4 |
| |
| movd [rdi+rax*2+2], xmm2 |
| movd [rsi+2], xmm6 |
| |
| psrldq xmm6, 4 |
| movd [rdi+2], xmm6 |
| |
| psrldq xmm6, 4 |
| neg rax |
| |
| movd [rdi+rax+2], xmm6 |
| psrldq xmm6, 4 |
| |
| movd [rdi+rax*2+2], xmm6 |
| lea rsi, [rsi+rax*8] |
| |
| neg rax |
| ;;;;;;;;;;;;;;;;;;;;/ |
| movd [rsi+rax*4+2], xmm1 |
| psrldq xmm1, 4 |
| |
| movd [rcx+rax*4+2], xmm1 |
| psrldq xmm1, 4 |
| |
| movd [rsi+rax*2+2], xmm1 |
| psrldq xmm1, 4 |
| |
| movd [rcx+rax*2+2], xmm1 |
| psrldq xmm1, 4 |
| |
| movd [rsi+2], xmm5 |
| psrldq xmm5, 4 |
| |
| movd [rcx+2], xmm5 |
| psrldq xmm5, 4 |
| |
| neg rax |
| movd [rcx+rax+2], xmm5 |
| |
| psrldq xmm5, 4 |
| movd [rcx+rax*2+2], xmm5 |
| |
| add rsp, 96 |
| pop rsp |
| ; begin epilog |
| pop rdi |
| pop rsi |
| RESTORE_GOT |
| UNSHADOW_ARGS |
| pop rbp |
| ret |
| |
| |
| ;void vp8_mbloop_filter_horizontal_edge_sse2 |
| ;( |
| ; unsigned char *src_ptr, |
| ; int src_pixel_step, |
| ; const char *flimit, |
| ; const char *limit, |
| ; const char *thresh, |
| ; int count |
| ;) |
| global sym(vp8_mbloop_filter_horizontal_edge_sse2) |
| sym(vp8_mbloop_filter_horizontal_edge_sse2): |
| push rbp |
| mov rbp, rsp |
| SHADOW_ARGS_TO_STACK 6 |
| GET_GOT rbx |
| push rsi |
| push rdi |
| ; end prolog |
| |
| ALIGN_STACK 16, rax |
| sub rsp, 32 ; reserve 32 bytes |
| %define t0 [rsp + 0] ;__declspec(align(16)) char t0[8]; |
| %define t1 [rsp + 16] ;__declspec(align(16)) char t1[8]; |
| |
| mov rsi, arg(0) ;src_ptr |
| movsxd rax, dword ptr arg(1) ;src_pixel_step ; destination pitch? |
| |
| mov rdx, arg(3) ;limit |
| movdqa xmm7, XMMWORD PTR [rdx] |
| |
| mov rdi, rsi ; rdi points to row +1 for indirect addressing |
| add rdi, rax |
| |
| ; calculate breakout conditions |
| movdqa xmm2, XMMWORD PTR [rdi+2*rax] ; q3 |
| movdqa xmm1, XMMWORD PTR [rsi+2*rax] ; q2 |
| |
| movdqa xmm6, xmm1 ; q2 |
| psubusb xmm1, xmm2 ; q2-=q3 |
| |
| |
| psubusb xmm2, xmm6 ; q3-=q2 |
| por xmm1, xmm2 ; abs(q3-q2) |
| |
| psubusb xmm1, xmm7 |
| |
| ; mm1 = abs(q3-q2), mm6 =q2, mm7 = limit |
| movdqa xmm4, XMMWORD PTR [rsi+rax] ; q1 |
| movdqa xmm3, xmm4 ; q1 |
| |
| psubusb xmm4, xmm6 ; q1-=q2 |
| psubusb xmm6, xmm3 ; q2-=q1 |
| |
| por xmm4, xmm6 ; abs(q2-q1) |
| psubusb xmm4, xmm7 |
| |
| por xmm1, xmm4 |
| ; mm1 = mask, mm3=q1, mm7 = limit |
| |
| movdqa xmm4, XMMWORD PTR [rsi] ; q0 |
| movdqa xmm0, xmm4 ; q0 |
| |
| psubusb xmm4, xmm3 ; q0-=q1 |
| psubusb xmm3, xmm0 ; q1-=q0 |
| |
| por xmm4, xmm3 ; abs(q0-q1) |
| movdqa t0, xmm4 ; save to t0 |
| |
| psubusb xmm4, xmm7 |
| por xmm1, xmm4 |
| |
| ; mm1 = mask, mm0=q0, mm7 = limit, t0 = abs(q0-q1) |
| neg rax ; negate pitch to deal with above border |
| |
| movdqa xmm2, XMMWORD PTR [rsi+4*rax] ; p3 |
| movdqa xmm4, XMMWORD PTR [rdi+4*rax] ; p2 |
| |
| movdqa xmm5, xmm4 ; p2 |
| psubusb xmm4, xmm2 ; p2-=p3 |
| |
| psubusb xmm2, xmm5 ; p3-=p2 |
| por xmm4, xmm2 ; abs(p3 - p2) |
| |
| psubusb xmm4, xmm7 |
| por xmm1, xmm4 |
| |
| ; mm1 = mask, mm0=q0, mm7 = limit, t0 = abs(q0-q1) |
| movdqa xmm4, XMMWORD PTR [rsi+2*rax] ; p1 |
| movdqa xmm3, xmm4 ; p1 |
| |
| psubusb xmm4, xmm5 ; p1-=p2 |
| psubusb xmm5, xmm3 ; p2-=p1 |
| |
| por xmm4, xmm5 ; abs(p2 - p1) |
| psubusb xmm4, xmm7 |
| |
| por xmm1, xmm4 |
| |
| movdqa xmm2, xmm3 ; p1 |
| |
| ; mm1 = mask, mm0=q0, mm7 = limit, t0 = abs(q0-q1) |
| movdqa xmm4, XMMWORD PTR [rsi+rax] ; p0 |
| movdqa xmm5, xmm4 ; p0 |
| |
| psubusb xmm4, xmm3 ; p0-=p1 |
| psubusb xmm3, xmm5 ; p1-=p0 |
| |
| por xmm4, xmm3 ; abs(p1 - p0) |
| movdqa t1, xmm4 ; save to t1 |
| |
| psubusb xmm4, xmm7 |
| por xmm1, xmm4 |
| |
| ; mm1 = mask, mm0=q0, mm7 = limit, t0 = abs(q0-q1) t1 = abs(p1-p0) |
| ; mm5 = p0 |
| movdqa xmm3, XMMWORD PTR [rdi] ; q1 |
| movdqa xmm4, xmm3 ; q1 |
| psubusb xmm3, xmm2 ; q1-=p1 |
| psubusb xmm2, xmm4 ; p1-=q1 |
| por xmm2, xmm3 ; abs(p1-q1) |
| pand xmm2, [tfe GLOBAL] ; set lsb of each byte to zero |
| psrlw xmm2, 1 ; abs(p1-q1)/2 |
| |
| movdqa xmm6, xmm5 ; p0 |
| movdqa xmm3, xmm0 ; q0 |
| |
| psubusb xmm5, xmm3 ; p0-=q0 |
| psubusb xmm3, xmm6 ; q0-=p0 |
| |
| por xmm5, xmm3 ; abs(p0 - q0) |
| paddusb xmm5, xmm5 ; abs(p0-q0)*2 |
| paddusb xmm5, xmm2 ; abs (p0 - q0) *2 + abs(p1-q1)/2 |
| |
| mov rdx, arg(2) ;flimit ; get flimit |
| movdqa xmm2, XMMWORD PTR [rdx] ; |
| paddb xmm2, xmm2 ; flimit*2 (less than 255) |
| paddb xmm7, xmm2 ; flimit * 2 + limit (less than 255) |
| |
| psubusb xmm5, xmm7 ; abs (p0 - q0) *2 + abs(p1-q1)/2 > flimit * 2 + limit |
| por xmm1, xmm5 |
| pxor xmm5, xmm5 |
| pcmpeqb xmm1, xmm5 ; mask mm1 |
| ; mm1 = mask, mm0=q0, mm7 = flimit, t0 = abs(q0-q1) t1 = abs(p1-p0) |
| ; mm6 = p0, |
| |
| ; calculate high edge variance |
| mov rdx, arg(4) ;thresh ; get thresh |
| movdqa xmm7, XMMWORD PTR [rdx] ; |
| |
| movdqa xmm4, t0 ; get abs (q1 - q0) |
| psubusb xmm4, xmm7 |
| |
| movdqa xmm3, t1 ; get abs (p1 - p0) |
| psubusb xmm3, xmm7 |
| |
| paddb xmm4, xmm3 ; abs(q1 - q0) > thresh || abs(p1 - p0) > thresh |
| pcmpeqb xmm4, xmm5 |
| |
| pcmpeqb xmm5, xmm5 |
| pxor xmm4, xmm5 |
| ; mm1 = mask, mm0=q0, mm7 = thresh, t0 = abs(q0-q1) t1 = abs(p1-p0) |
| ; mm6 = p0, mm4=hev |
| ; start work on filters |
| movdqa xmm2, XMMWORD PTR [rsi+2*rax] ; p1 |
| movdqa xmm7, XMMWORD PTR [rdi] ; q1 |
| |
| pxor xmm2, [t80 GLOBAL] ; p1 offset to convert to signed values |
| pxor xmm7, [t80 GLOBAL] ; q1 offset to convert to signed values |
| |
| psubsb xmm2, xmm7 ; p1 - q1 |
| pxor xmm6, [t80 GLOBAL] ; offset to convert to signed values |
| |
| pxor xmm0, [t80 GLOBAL] ; offset to convert to signed values |
| movdqa xmm3, xmm0 ; q0 |
| |
| psubsb xmm0, xmm6 ; q0 - p0 |
| paddsb xmm2, xmm0 ; 1 * (q0 - p0) + (p1 - q1) |
| |
| paddsb xmm2, xmm0 ; 2 * (q0 - p0) |
| paddsb xmm2, xmm0 ; 3 * (q0 - p0) + (p1 - q1) |
| |
| pand xmm1, xmm2 ; mask filter values we don't care about |
| ; mm1 = vp8_filter, mm4=hev, mm6=ps0, mm3=qs0 |
| movdqa xmm2, xmm1 ; vp8_filter |
| pand xmm2, xmm4; ; Filter2 = vp8_filter & hev |
| |
| |
| movdqa xmm5, xmm2 ; |
| paddsb xmm5, [t3 GLOBAL]; |
| |
| pxor xmm0, xmm0 ; 0 |
| pxor xmm7, xmm7 ; 0 |
| |
| punpcklbw xmm0, xmm5 ; e0f0g0h0 |
| psraw xmm0, 11 ; sign extended shift right by 3 |
| |
| punpckhbw xmm7, xmm5 ; a0b0c0d0 |
| psraw xmm7, 11 ; sign extended shift right by 3 |
| |
| packsswb xmm0, xmm7 ; Filter2 >>=3; |
| movdqa xmm5, xmm0 ; Filter2 |
| |
| paddsb xmm2, [t4 GLOBAL] ; vp8_signed_char_clamp(Filter2 + 4) |
| pxor xmm0, xmm0 ; 0 |
| |
| pxor xmm7, xmm7 ; 0 |
| punpcklbw xmm0, xmm2 ; e0f0g0h0 |
| |
| psraw xmm0, 11 ; sign extended shift right by 3 |
| punpckhbw xmm7, xmm2 ; a0b0c0d0 |
| |
| psraw xmm7, 11 ; sign extended shift right by 3 |
| packsswb xmm0, xmm7 ; Filter2 >>=3; |
| |
| ; mm0= filter2 mm1 = vp8_filter, mm3 =qs0 mm5=s mm4 =hev mm6=ps0 |
| psubsb xmm3, xmm0 ; qs0 =qs0 - filter1 |
| paddsb xmm6, xmm5 ; ps0 =ps0 + Fitler2 |
| |
| ; mm1=vp8_filter, mm3=qs0, mm4 =hev mm6=ps0 |
| ; vp8_filter &= ~hev; |
| ; Filter2 = vp8_filter; |
| pandn xmm4, xmm1 ; vp8_filter&=~hev |
| |
| |
| ; mm3=qs0, mm4=filter2, mm6=ps0 |
| |
| ; u = vp8_signed_char_clamp((63 + Filter2 * 27)>>7); |
| ; s = vp8_signed_char_clamp(qs0 - u); |
| ; *oq0 = s^0x80; |
| ; s = vp8_signed_char_clamp(ps0 + u); |
| ; *op0 = s^0x80; |
| pxor xmm0, xmm0 |
| pxor xmm1, xmm1 |
| |
| pxor xmm2, xmm2 |
| punpcklbw xmm1, xmm4 |
| |
| punpckhbw xmm2, xmm4 |
| pmulhw xmm1, [s27 GLOBAL] |
| |
| pmulhw xmm2, [s27 GLOBAL] |
| paddw xmm1, [s63 GLOBAL] |
| |
| paddw xmm2, [s63 GLOBAL] |
| psraw xmm1, 7 |
| |
| psraw xmm2, 7 |
| packsswb xmm1, xmm2 |
| |
| psubsb xmm3, xmm1 |
| paddsb xmm6, xmm1 |
| |
| pxor xmm3, [t80 GLOBAL] |
| pxor xmm6, [t80 GLOBAL] |
| |
| movdqa XMMWORD PTR [rsi+rax], xmm6 |
| movdqa XMMWORD PTR [rsi], xmm3 |
| |
| ; roughly 2/7th difference across boundary |
| ; u = vp8_signed_char_clamp((63 + Filter2 * 18)>>7); |
| ; s = vp8_signed_char_clamp(qs1 - u); |
| ; *oq1 = s^0x80; |
| ; s = vp8_signed_char_clamp(ps1 + u); |
| ; *op1 = s^0x80; |
| pxor xmm1, xmm1 |
| pxor xmm2, xmm2 |
| |
| punpcklbw xmm1, xmm4 |
| punpckhbw xmm2, xmm4 |
| |
| pmulhw xmm1, [s18 GLOBAL] |
| pmulhw xmm2, [s18 GLOBAL] |
| |
| paddw xmm1, [s63 GLOBAL] |
| paddw xmm2, [s63 GLOBAL] |
| |
| psraw xmm1, 7 |
| psraw xmm2, 7 |
| |
| packsswb xmm1, xmm2 |
| |
| movdqa xmm3, XMMWORD PTR [rdi] |
| movdqa xmm6, XMMWORD PTR [rsi+rax*2] ; p1 |
| |
| pxor xmm3, [t80 GLOBAL] |
| pxor xmm6, [t80 GLOBAL] |
| |
| paddsb xmm6, xmm1 |
| psubsb xmm3, xmm1 |
| |
| pxor xmm6, [t80 GLOBAL] |
| pxor xmm3, [t80 GLOBAL] |
| |
| movdqa XMMWORD PTR [rdi], xmm3 |
| movdqa XMMWORD PTR [rsi+rax*2],xmm6 |
| |
| ; roughly 1/7th difference across boundary |
| ; u = vp8_signed_char_clamp((63 + Filter2 * 9)>>7); |
| ; s = vp8_signed_char_clamp(qs2 - u); |
| ; *oq2 = s^0x80; |
| ; s = vp8_signed_char_clamp(ps2 + u); |
| ; *op2 = s^0x80; |
| pxor xmm1, xmm1 |
| pxor xmm2, xmm2 |
| |
| punpcklbw xmm1, xmm4 |
| punpckhbw xmm2, xmm4 |
| |
| pmulhw xmm1, [s9 GLOBAL] |
| pmulhw xmm2, [s9 GLOBAL] |
| |
| paddw xmm1, [s63 GLOBAL] |
| paddw xmm2, [s63 GLOBAL] |
| |
| psraw xmm1, 7 |
| psraw xmm2, 7 |
| |
| packsswb xmm1, xmm2 |
| |
| |
| movdqa xmm6, XMMWORD PTR [rdi+rax*4] |
| neg rax |
| |
| movdqa xmm3, XMMWORD PTR [rdi+rax ] |
| |
| pxor xmm6, [t80 GLOBAL] |
| pxor xmm3, [t80 GLOBAL] |
| |
| paddsb xmm6, xmm1 |
| psubsb xmm3, xmm1 |
| |
| pxor xmm6, [t80 GLOBAL] |
| pxor xmm3, [t80 GLOBAL] |
| |
| movdqa XMMWORD PTR [rdi+rax ], xmm3 |
| neg rax |
| |
| movdqa XMMWORD PTR [rdi+rax*4], xmm6 |
| |
| add rsp, 32 |
| pop rsp |
| ; begin epilog |
| pop rdi |
| pop rsi |
| RESTORE_GOT |
| UNSHADOW_ARGS |
| pop rbp |
| ret |
| |
| |
| ;void vp8_mbloop_filter_vertical_edge_sse2 |
| ;( |
| ; unsigned char *src_ptr, |
| ; int src_pixel_step, |
| ; const char *flimit, |
| ; const char *limit, |
| ; const char *thresh, |
| ; int count |
| ;) |
| global sym(vp8_mbloop_filter_vertical_edge_sse2) |
| sym(vp8_mbloop_filter_vertical_edge_sse2): |
| push rbp |
| mov rbp, rsp |
| SHADOW_ARGS_TO_STACK 6 |
| GET_GOT rbx |
| push rsi |
| push rdi |
| ; end prolog |
| |
| ALIGN_STACK 16, rax |
| sub rsp, 160 ; reserve 160 bytes |
| %define t0 [rsp + 0] ;__declspec(align(16)) char t0[16]; |
| %define t1 [rsp + 16] ;__declspec(align(16)) char t1[16]; |
| %define srct [rsp + 32] ;__declspec(align(16)) char srct[128]; |
| |
| |
| mov rsi, arg(0) ;src_ptr |
| movsxd rax, dword ptr arg(1) ;src_pixel_step ; destination pitch? |
| |
| lea rsi, [rsi + rax*4 - 4] |
| lea rdi, [rsi + rax] ; rdi points to row +1 for indirect addressing |
| |
| mov rcx, rax |
| neg rcx |
| |
| ; Transpose |
| movq xmm0, QWORD PTR [rdi+rax*2] ; xx xx xx xx xx xx xx xx 77 76 75 74 73 72 71 70 |
| movq xmm7, QWORD PTR [rsi+rax*2] ; xx xx xx xx xx xx xx xx 67 66 65 64 63 62 61 60 |
| |
| punpcklbw xmm7, xmm0 ; 77 67 76 66 75 65 74 64 73 63 72 62 71 61 70 60 |
| movq xmm0, QWORD PTR [rsi+rax] ; |
| |
| movq xmm5, QWORD PTR [rsi] ; |
| punpcklbw xmm5, xmm0 ; 57 47 56 46 55 45 54 44 53 43 52 42 51 41 50 40 |
| |
| movdqa xmm6, xmm5 ; 57 47 56 46 55 45 54 44 53 43 52 42 51 41 50 40 |
| punpcklwd xmm5, xmm7 ; 73 63 53 43 72 62 52 42 71 61 51 41 70 60 50 40 |
| |
| punpckhwd xmm6, xmm7 ; 77 67 57 47 76 66 56 46 75 65 55 45 74 64 54 44 |
| movq xmm7, QWORD PTR [rsi + rcx] ; xx xx xx xx xx xx xx xx 37 36 35 34 33 32 31 30 |
| |
| movq xmm0, QWORD PTR [rsi + rcx*2] ; xx xx xx xx xx xx xx xx 27 26 25 24 23 22 21 20 |
| punpcklbw xmm0, xmm7 ; 37 27 36 36 35 25 34 24 33 23 32 22 31 21 30 20 |
| |
| movq xmm4, QWORD PTR [rsi + rcx*4] ; xx xx xx xx xx xx xx xx 07 06 05 04 03 02 01 00 |
| movq xmm7, QWORD PTR [rdi + rcx*4] ; xx xx xx xx xx xx xx xx 17 16 15 14 13 12 11 10 |
| |
| punpcklbw xmm4, xmm7 ; 17 07 16 06 15 05 14 04 13 03 12 02 11 01 10 00 |
| movdqa xmm3, xmm4 ; 17 07 16 06 15 05 14 04 13 03 12 02 11 01 10 00 |
| |
| punpcklwd xmm3, xmm0 ; 33 23 13 03 32 22 12 02 31 21 11 01 30 20 10 00 |
| punpckhwd xmm4, xmm0 ; 37 27 17 07 36 26 16 06 35 25 15 05 34 24 14 04 |
| |
| movdqa xmm7, xmm4 ; 37 27 17 07 36 26 16 06 35 25 15 05 34 24 14 04 |
| movdqa xmm2, xmm3 ; 33 23 13 03 32 22 12 02 31 21 11 01 30 20 10 00 |
| |
| punpckhdq xmm7, xmm6 ; 77 67 57 47 37 27 17 07 76 66 56 46 36 26 16 06 |
| punpckldq xmm4, xmm6 ; 75 65 55 45 35 25 15 05 74 64 54 44 34 24 14 04 |
| |
| punpckhdq xmm3, xmm5 ; 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02 |
| punpckldq xmm2, xmm5 ; 71 61 51 41 31 21 11 01 70 60 50 40 30 20 10 00 |
| |
| movdqa t0, xmm2 ; save to free XMM2 |
| ;movdqa t1, xmm3 |
| |
| ; XMM3 XMM4 XMM7 in use |
| lea rsi, [rsi+rax*8] |
| lea rdi, [rdi+rax*8] |
| |
| movq xmm6, QWORD PTR [rdi+rax*2] ; xx xx xx xx xx xx xx xx f7 f6 f5 f4 f3 f2 f1 f0 |
| movq xmm5, QWORD PTR [rsi+rax*2] ; xx xx xx xx xx xx xx xx e7 e6 e5 e4 e3 e2 e1 e0 |
| |
| punpcklbw xmm5, xmm6 ; f7 e7 f6 e6 f5 e5 f4 e4 f3 e3 f2 e2 f1 e1 f0 e0 |
| movq xmm6, QWORD PTR [rsi+rax] ; xx xx xx xx xx xx xx xx d7 d6 d5 d4 d3 d2 d1 d0 |
| |
| movq xmm1, QWORD PTR [rsi] ; xx xx xx xx xx xx xx xx c7 c6 c5 c4 c3 c2 c1 c0 |
| punpcklbw xmm1, xmm6 ; d7 c7 d6 c6 d5 c5 d4 c4 d3 c3 d2 c2 d1 e1 d0 c0 |
| |
| movdqa xmm6, xmm1 ; |
| punpckhwd xmm6, xmm5 ; f7 e7 d7 c7 f6 e6 d6 c6 f5 e5 d5 c5 f4 e4 d4 c4 |
| |
| punpcklwd xmm1, xmm5 ; f3 e3 d3 c3 f2 e2 d2 c2 f1 e1 d1 c1 f0 e0 d0 c0 |
| movq xmm5, QWORD PTR [rsi+rcx] ; xx xx xx xx xx xx xx xx b7 b6 b5 b4 b3 b2 b1 b0 |
| |
| movq xmm0, QWORD PTR [rsi+rcx*2] ; xx xx xx xx xx xx xx xx a7 a6 a5 a4 a3 a2 a1 a0 |
| punpcklbw xmm0, xmm5 ; b7 a7 b6 a6 b5 a5 b4 a4 b3 a3 b2 a2 b1 a1 b0 a0 |
| |
| movq xmm2, QWORD PTR [rsi+rcx*4] ; xx xx xx xx xx xx xx xx 87 86 85 84 83 82 81 80 |
| movq xmm5, QWORD PTR [rdi+rcx*4] ; xx xx xx xx xx xx xx xx 97 96 95 94 93 92 91 90 |
| |
| punpcklbw xmm2, xmm5 ; 97 87 96 86 95 85 94 84 93 83 92 82 91 81 90 80 |
| movdqa xmm5, xmm2 ; 97 87 96 86 95 85 94 84 93 83 92 82 91 81 90 80 |
| |
| punpcklwd xmm5, xmm0 ; b3 a3 93 83 b2 a2 92 82 b1 a1 91 81 b0 a0 90 80 |
| punpckhwd xmm2, xmm0 ; b7 a7 97 87 b6 a6 96 86 b5 a5 95 85 b4 a4 94 84 |
| |
| movdqa xmm0, xmm5 |
| punpckldq xmm0, xmm1 ; f1 e1 d1 c1 b1 a1 91 81 f0 e0 d0 c0 b0 a0 90 80 |
| |
| |
| punpckhdq xmm5, xmm1 ; f3 e3 d3 c3 b3 a3 93 83 f2 e2 d2 c2 b2 a2 92 82 |
| movdqa xmm1, xmm2 ; b7 a7 97 87 b6 a6 96 86 b5 a5 95 85 b4 a4 94 84 |
| |
| punpckldq xmm1, xmm6 ; f5 e5 d5 c5 b5 a5 95 85 f4 e4 d4 c4 b4 a4 94 84 |
| punpckhdq xmm2, xmm6 ; f7 e7 d7 c7 b7 a7 97 87 f6 e6 d6 c6 b6 a6 96 86 |
| |
| movdqa xmm6, xmm7 ; 77 67 57 47 37 27 17 07 76 66 56 46 36 26 16 06 |
| punpcklqdq xmm6, xmm2 ; f6 e6 d6 c6 b6 a6 96 86 76 66 56 46 36 26 16 06 |
| |
| |
| lea rdx, srct |
| punpckhqdq xmm7, xmm2 ; f7 e7 d7 c7 b7 a7 97 87 77 67 57 47 37 27 17 07 |
| |
| movdqa [rdx+112], xmm7 ; save 7 |
| movdqa xmm2, xmm3 ; 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02 |
| |
| movdqa [rdx+96], xmm6 ; save 6 |
| punpcklqdq xmm2, xmm5 ; f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02 |
| |
| punpckhqdq xmm3, xmm5 ; f3 e3 d3 c3 b3 a3 93 83 73 63 53 43 33 23 13 03 |
| movdqa [rdx+32], xmm2 ; save 2 |
| |
| movdqa xmm5, xmm4 ; 75 65 55 45 35 25 15 05 74 64 54 44 34 24 14 04 |
| punpcklqdq xmm4, xmm1 ; f4 e4 d4 c4 b4 a4 94 84 74 64 54 44 34 24 14 04 |
| |
| movdqa [rdx+48], xmm3 ; save 3 |
| punpckhqdq xmm5, xmm1 ; f5 e5 d5 c5 b5 a5 95 85 75 65 55 45 35 25 15 05 |
| |
| movdqa [rdx+64], xmm4 ; save 4 |
| movdqa [rdx+80], xmm5 ; save 5 |
| |
| movdqa xmm1, t0 ; get |
| movdqa xmm2, xmm1 ; |
| |
| punpckhqdq xmm1, xmm0 ; f1 e1 d1 c1 b1 a1 91 81 71 61 51 41 31 21 11 01 |
| punpcklqdq xmm2, xmm0 ; f0 e0 d0 c0 b0 a0 90 80 70 60 50 40 30 20 10 00 |
| |
| movdqa [rdx+16], xmm1 |
| movdqa [rdx], xmm2 |
| |
| movdqa xmm0, xmm6 ; q2 |
| psubusb xmm0, xmm7 ; q2-q3 |
| |
| psubusb xmm7, xmm6 ; q3-q2 |
| por xmm7, xmm0 ; abs (q3-q2) |
| |
| movdqa xmm1, xmm5 ; q1 |
| psubusb xmm1, xmm6 ; q1-q2 |
| |
| psubusb xmm6, xmm5 ; q2-q1 |
| por xmm6, xmm1 ; abs (q2-q1) |
| |
| ;/* |
| ;movdqa xmm0, xmm4 ; q0 |
| ;psubusb xmm0 xmm5 ; q0-q1 |
| ; |
| ;pusbusb xmm5, xmm4 ; q1-q0 |
| ;por xmm5, xmm0 ; abs (q1-q0) |
| ;*/ |
| |
| movdqa xmm1, [rdx+16] ; p2 |
| movdqa xmm0, xmm1 |
| |
| psubusb xmm0, xmm2 ; p2 - p3; |
| psubusb xmm2, xmm1 ; p3 - p2; |
| |
| por xmm0, xmm2 ; abs(p2-p3) |
| |
| movdqa xmm2, [rdx+32] ; p1 |
| movdqa xmm5, xmm2 ; p1 |
| |
| psubusb xmm5, xmm1 ; p1-p2 |
| psubusb xmm1, xmm2 ; p2-p1 |
| |
| por xmm1, xmm5 ; abs(p2-p1) |
| mov rdx, arg(3) ;limit |
| |
| movdqa xmm4, [rdx] ; limit |
| psubusb xmm7, xmm4 ; |
| |
| |
| psubusb xmm0, xmm4 ; abs(p3-p2) > limit |
| psubusb xmm1, xmm4 ; abs(p2-p1) > limit |
| |
| psubusb xmm6, xmm4 ; abs(q2-q1) > limit |
| por xmm7, xmm6 ; or |
| |
| por xmm0, xmm1 ; |
| por xmm0, xmm7 ; abs(q3-q2) > limit || abs(p3-p2) > limit ||abs(p2-p1) > limit || abs(q2-q1) > limit |
| |
| movdqa xmm1, xmm2 ; p1 |
| |
| movdqa xmm7, xmm3 ; p0 |
| psubusb xmm7, xmm2 ; p0-p1 |
| |
| psubusb xmm2, xmm3 ; p1-p0 |
| por xmm2, xmm7 ; abs(p1-p0) |
| |
| movdqa t0, xmm2 ; save abs(p1-p0) |
| lea rdx, srct |
| |
| psubusb xmm2, xmm4 ; abs(p1-p0)>limit |
| por xmm0, xmm2 ; mask |
| |
| movdqa xmm5, [rdx+64] ; q0 |
| movdqa xmm7, [rdx+80] ; q1 |
| |
| movdqa xmm6, xmm5 ; q0 |
| movdqa xmm2, xmm7 ; q1 |
| psubusb xmm5, xmm7 ; q0-q1 |
| |
| psubusb xmm7, xmm6 ; q1-q0 |
| por xmm7, xmm5 ; abs(q1-q0) |
| |
| movdqa t1, xmm7 ; save abs(q1-q0) |
| psubusb xmm7, xmm4 ; abs(q1-q0)> limit |
| |
| por xmm0, xmm7 ; mask |
| |
| movdqa xmm5, xmm2 ; q1 |
| psubusb xmm5, xmm1 ; q1-=p1 |
| psubusb xmm1, xmm2 ; p1-=q1 |
| por xmm5, xmm1 ; abs(p1-q1) |
| pand xmm5, [tfe GLOBAL] ; set lsb of each byte to zero |
| psrlw xmm5, 1 ; abs(p1-q1)/2 |
| |
| mov rdx, arg(2) ;flimit ; |
| movdqa xmm2, [rdx] ; flimit |
| |
| movdqa xmm1, xmm3 ; p0 |
| movdqa xmm7, xmm6 ; q0 |
| psubusb xmm1, xmm7 ; p0-q0 |
| psubusb xmm7, xmm3 ; q0-p0 |
| por xmm1, xmm7 ; abs(q0-p0) |
| paddusb xmm1, xmm1 ; abs(q0-p0)*2 |
| paddusb xmm1, xmm5 ; abs (p0 - q0) *2 + abs(p1-q1)/2 |
| |
| paddb xmm2, xmm2 ; flimit*2 (less than 255) |
| paddb xmm4, xmm2 ; flimit * 2 + limit (less than 255) |
| |
| psubusb xmm1, xmm4 ; abs (p0 - q0) *2 + abs(p1-q1)/2 > flimit * 2 + limit |
| por xmm1, xmm0; ; mask |
| pxor xmm0, xmm0 |
| pcmpeqb xmm1, xmm0 |
| |
| ; calculate high edge variance |
| mov rdx, arg(4) ;thresh ; get thresh |
| movdqa xmm7, [rdx] |
| |
| movdqa xmm4, t0 ; get abs (q1 - q0) |
| psubusb xmm4, xmm7 ; abs(q1 - q0) > thresh |
| |
| movdqa xmm3, t1 ; get abs (p1 - p0) |
| psubusb xmm3, xmm7 ; abs(p1 - p0)> thresh |
| |
| por xmm4, xmm3 ; abs(q1 - q0) > thresh || abs(p1 - p0) > thresh |
| pcmpeqb xmm4, xmm0 |
| |
| pcmpeqb xmm0, xmm0 |
| pxor xmm4, xmm0 |
| |
| |
| ; start work on filters |
| lea rdx, srct |
| |
| ; start work on filters |
| movdqa xmm2, [rdx+32] ; p1 |
| movdqa xmm7, [rdx+80] ; q1 |
| |
| pxor xmm2, [t80 GLOBAL] ; p1 offset to convert to signed values |
| pxor xmm7, [t80 GLOBAL] ; q1 offset to convert to signed values |
| |
| psubsb xmm2, xmm7 ; p1 - q1 |
| movdqa xmm6, [rdx+48] ; p0 |
| |
| movdqa xmm0, [rdx+64] ; q0 |
| pxor xmm6, [t80 GLOBAL] ; offset to convert to signed values |
| |
| pxor xmm0, [t80 GLOBAL] ; offset to convert to signed values |
| movdqa xmm3, xmm0 ; q0 |
| |
| psubsb xmm0, xmm6 ; q0 - p0 |
| paddsb xmm2, xmm0 ; 1 * (q0 - p0) + (p1 - q1) |
| |
| paddsb xmm2, xmm0 ; 2 * (q0 - p0) |
| paddsb xmm2, xmm0 ; 3 * (q0 - p0)+ (p1 - q1) |
| |
| pand xmm1, xmm2 ; mask filter values we don't care about |
| |
| ; xmm1 = vp8_filter, xmm4=hev, xmm6=ps0, xmm3=qs0 |
| movdqa xmm2, xmm1 ; vp8_filter |
| pand xmm2, xmm4; ; Filter2 = vp8_filter & hev |
| |
| movdqa xmm5, xmm2 |
| paddsb xmm5, [t3 GLOBAL] |
| |
| pxor xmm0, xmm0 ; 0 |
| pxor xmm7, xmm7 ; 0 |
| |
| punpcklbw xmm0, xmm5 ; e0f0g0h0 |
| psraw xmm0, 11 ; sign extended shift right by 3 |
| |
| punpckhbw xmm7, xmm5 ; a0b0c0d0 |
| psraw xmm7, 11 ; sign extended shift right by 3 |
| |
| packsswb xmm0, xmm7 ; Filter2 >>=3; |
| movdqa xmm5, xmm0 ; Filter2 |
| |
| paddsb xmm2, [t4 GLOBAL] ; vp8_signed_char_clamp(Filter2 + 4) |
| pxor xmm0, xmm0 ; 0 |
| |
| pxor xmm7, xmm7 ; 0 |
| punpcklbw xmm0, xmm2 ; e0f0g0h0 |
| |
| psraw xmm0, 11 ; sign extended shift right by 3 |
| punpckhbw xmm7, xmm2 ; a0b0c0d0 |
| |
| psraw xmm7, 11 ; sign extended shift right by 3 |
| packsswb xmm0, xmm7 ; Filter2 >>=3; |
| |
| ; xmm0= filter2 xmm1 = vp8_filter, xmm3 =qs0 xmm5=s xmm4 =hev xmm6=ps0 |
| psubsb xmm3, xmm0 ; qs0 =qs0 - filter1 |
| paddsb xmm6, xmm5 ; ps0 =ps0 + Fitler2 |
| |
| |
| ; xmm1=vp8_filter, xmm3=qs0, xmm4 =hev xmm6=ps0 |
| ; vp8_filter &= ~hev; |
| ; Filter2 = vp8_filter; |
| pandn xmm4, xmm1 ; vp8_filter&=~hev |
| |
| ; xmm3=qs0, xmm4=filter2, xmm6=ps0 |
| ; u = vp8_signed_char_clamp((63 + Filter2 * 27)>>7); |
| ; s = vp8_signed_char_clamp(qs0 - u); |
| ; *oq0 = s^0x80; |
| ; s = vp8_signed_char_clamp(ps0 + u); |
| ; *op0 = s^0x80; |
| pxor xmm0, xmm0 |
| pxor xmm1, xmm1 |
| |
| pxor xmm2, xmm2 |
| punpcklbw xmm1, xmm4 |
| |
| punpckhbw xmm2, xmm4 |
| pmulhw xmm1, [s27 GLOBAL] |
| |
| pmulhw xmm2, [s27 GLOBAL] |
| paddw xmm1, [s63 GLOBAL] |
| |
| paddw xmm2, [s63 GLOBAL] |
| psraw xmm1, 7 |
| |
| psraw xmm2, 7 |
| packsswb xmm1, xmm2 |
| |
| psubsb xmm3, xmm1 |
| paddsb xmm6, xmm1 |
| |
| pxor xmm3, [t80 GLOBAL] |
| pxor xmm6, [t80 GLOBAL] |
| |
| movdqa [rdx+48], xmm6 |
| movdqa [rdx+64], xmm3 |
| |
| ; roughly 2/7th difference across boundary |
| ; u = vp8_signed_char_clamp((63 + Filter2 * 18)>>7); |
| ; s = vp8_signed_char_clamp(qs1 - u); |
| ; *oq1 = s^0x80; |
| ; s = vp8_signed_char_clamp(ps1 + u); |
| ; *op1 = s^0x80; |
| pxor xmm1, xmm1 |
| pxor xmm2, xmm2 |
| |
| punpcklbw xmm1, xmm4 |
| punpckhbw xmm2, xmm4 |
| |
| pmulhw xmm1, [s18 GLOBAL] |
| pmulhw xmm2, [s18 GLOBAL] |
| |
| paddw xmm1, [s63 GLOBAL] |
| paddw xmm2, [s63 GLOBAL] |
| |
| psraw xmm1, 7 |
| psraw xmm2, 7 |
| |
| packsswb xmm1, xmm2 |
| |
| movdqa xmm3, [rdx + 80] ;/q1 |
| movdqa xmm6, [rdx + 32] ; p1 |
| |
| pxor xmm3, [t80 GLOBAL] |
| pxor xmm6, [t80 GLOBAL] |
| |
| paddsb xmm6, xmm1 |
| psubsb xmm3, xmm1 |
| |
| pxor xmm6, [t80 GLOBAL] |
| pxor xmm3, [t80 GLOBAL] |
| |
| movdqa [rdx + 80], xmm3 |
| movdqa [rdx + 32], xmm6 |
| |
| |
| ; roughly 1/7th difference across boundary |
| ; u = vp8_signed_char_clamp((63 + Filter2 * 9)>>7); |
| ; s = vp8_signed_char_clamp(qs2 - u); |
| ; *oq2 = s^0x80; |
| ; s = vp8_signed_char_clamp(ps2 + u); |
| ; *op2 = s^0x80; |
| pxor xmm1, xmm1 |
| pxor xmm2, xmm2 |
| |
| punpcklbw xmm1, xmm4 |
| punpckhbw xmm2, xmm4 |
| |
| pmulhw xmm1, [s9 GLOBAL] |
| pmulhw xmm2, [s9 GLOBAL] |
| |
| paddw xmm1, [s63 GLOBAL] |
| paddw xmm2, [s63 GLOBAL] |
| |
| psraw xmm1, 7 |
| psraw xmm2, 7 |
| |
| packsswb xmm1, xmm2 |
| |
| movdqa xmm6, [rdx+16] |
| movdqa xmm3, [rdx+96] |
| |
| pxor xmm6, [t80 GLOBAL] |
| pxor xmm3, [t80 GLOBAL] |
| |
| paddsb xmm6, xmm1 |
| psubsb xmm3, xmm1 |
| |
| pxor xmm6, [t80 GLOBAL] ; xmm6 = f1 e1 d1 c1 b1 a1 91 81 71 61 51 41 31 21 11 01 |
| pxor xmm3, [t80 GLOBAL] ; xmm3 = f6 e6 d6 c6 b6 a6 96 86 76 66 56 46 36 26 15 06 |
| |
| |
| ; transpose and write back |
| movdqa xmm0, [rdx] ; f0 e0 d0 c0 b0 a0 90 80 70 60 50 40 30 20 10 00 |
| movdqa xmm1, xmm0 ; f0 e0 d0 c0 b0 a0 90 80 70 60 50 40 30 20 10 00 |
| |
| punpcklbw xmm0, xmm6 ; 71 70 61 60 51 50 41 40 31 30 21 20 11 10 01 00 |
| punpckhbw xmm1, xmm6 ; f1 f0 e1 e0 d1 d0 c1 c0 b1 b0 a1 a0 91 90 81 80 |
| |
| movdqa xmm2, [rdx+32] ; f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02 |
| movdqa xmm6, xmm2 ; f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02 |
| |
| punpcklbw xmm2, [rdx+48] ; 73 72 63 62 53 52 43 42 33 32 23 22 13 12 03 02 |
| punpckhbw xmm6, [rdx+48] ; f3 f2 e3 e2 d3 d2 c3 c2 b3 b2 a3 a2 93 92 83 82 |
| |
| movdqa xmm5, xmm0 ; 71 70 61 60 51 50 41 40 31 30 21 20 11 10 01 00 |
| punpcklwd xmm0, xmm2 ; 33 32 31 30 23 22 21 20 13 12 11 10 03 02 01 00 |
| |
| punpckhwd xmm5, xmm2 ; 73 72 71 70 63 62 61 60 53 52 51 50 43 42 41 40 |
| movdqa xmm4, xmm1 ; f1 f0 e1 e0 d1 d0 c1 c0 b1 b0 a1 a0 91 90 81 80 |
| |
| punpcklwd xmm1, xmm6 ; b3 b2 b1 b0 a3 a2 a1 a0 93 92 91 90 83 82 81 80 |
| punpckhwd xmm4, xmm6 ; f3 f2 f1 f0 e3 e2 e1 e0 d3 d2 d1 d0 c3 c2 c1 c0 |
| |
| movdqa xmm2, [rdx+64] ; f4 e4 d4 c4 b4 a4 94 84 74 64 54 44 34 24 14 04 |
| punpcklbw xmm2, [rdx+80] ; 75 74 65 64 55 54 45 44 35 34 25 24 15 14 05 04 |
| |
| movdqa xmm6, xmm3 ; f6 e6 d6 c6 b6 a6 96 86 76 66 56 46 36 26 16 06 |
| punpcklbw xmm6, [rdx+112] ; 77 76 67 66 57 56 47 46 37 36 27 26 17 16 07 06 |
| |
| movdqa xmm7, xmm2 ; 75 74 65 64 55 54 45 44 35 34 25 24 15 14 05 04 |
| punpcklwd xmm2, xmm6 ; 37 36 35 34 27 26 25 24 17 16 15 14 07 06 05 04 |
| |
| punpckhwd xmm7, xmm6 ; 77 76 75 74 67 66 65 64 57 56 55 54 47 46 45 44 |
| movdqa xmm6, xmm0 ; 33 32 31 30 23 22 21 20 13 12 11 10 03 02 01 00 |
| |
| punpckldq xmm0, xmm2 ; 17 16 15 14 13 12 11 10 07 06 05 04 03 02 01 00 |
| punpckhdq xmm6, xmm2 ; 37 36 35 34 33 32 31 30 27 26 25 24 23 22 21 20 |
| |
| lea rsi, [rsi+rcx*8] |
| lea rdi, [rdi+rcx*8] |
| |
| movq QWORD PTR [rsi+rcx*4], xmm0 |
| psrldq xmm0, 8 |
| |
| movq QWORD PTR [rsi+rcx*2], xmm6 |
| psrldq xmm6, 8 |
| |
| movq QWORD PTR [rdi+rcx*4], xmm0 |
| movq QWORD PTR [rsi+rcx], xmm6 |
| |
| movdqa xmm0, xmm5 ; 73 72 71 70 63 62 61 60 53 52 51 50 43 42 41 40 |
| punpckldq xmm0, xmm7 ; 57 56 55 54 53 52 51 50 47 46 45 44 43 42 41 40 |
| |
| punpckhdq xmm5, xmm7 ; 77 76 75 74 73 72 71 70 67 66 65 64 63 62 61 60 |
| |
| movq QWORD PTR [rsi], xmm0 |
| psrldq xmm0, 8 |
| |
| movq QWORD PTR [rsi+rax*2], xmm5 |
| psrldq xmm5, 8 |
| |
| movq QWORD PTR [rsi+rax], xmm0 |
| movq QWORD PTR [rdi+rax*2], xmm5 |
| |
| movdqa xmm2, [rdx+64] ; f4 e4 d4 c4 b4 a4 94 84 74 64 54 44 34 24 14 04 |
| punpckhbw xmm2, [rdx+80] ; f5 f4 e5 e4 d5 d4 c5 c4 b5 b4 a5 a4 95 94 85 84 |
| |
| punpckhbw xmm3, [rdx+112] ; f7 f6 e7 e6 d7 d6 c7 c6 b7 b6 a7 a6 97 96 87 86 |
| movdqa xmm0, xmm2 |
| |
| punpcklwd xmm0, xmm3 ; b7 b6 b4 b4 a7 a6 a5 a4 97 96 95 94 87 86 85 84 |
| punpckhwd xmm2, xmm3 ; f7 f6 f5 f4 e7 e6 e5 e4 d7 d6 d5 d4 c7 c6 c5 c4 |
| |
| movdqa xmm3, xmm1 ; b3 b2 b1 b0 a3 a2 a1 a0 93 92 91 90 83 82 81 80 |
| punpckldq xmm1, xmm0 ; 97 96 95 94 93 92 91 90 87 86 85 83 84 82 81 80 |
| |
| punpckhdq xmm3, xmm0 ; b7 b6 b5 b4 b3 b2 b1 b0 a7 a6 a5 a4 a3 a2 a1 a0 |
| |
| lea rsi, [rsi+rax*8] |
| lea rdi, [rdi+rax*8] |
| |
| movq QWORD PTR [rsi+rcx*4], xmm1 |
| psrldq xmm1, 8 |
| |
| movq QWORD PTR [rsi+rcx*2], xmm3 |
| psrldq xmm3, 8 |
| |
| movq QWORD PTR [rdi+rcx*4], xmm1 |
| movq QWORD PTR [rsi+rcx], xmm3 |
| |
| movdqa xmm1, xmm4 ; f3 f2 f1 f0 e3 e2 e1 e0 d3 d2 d1 d0 c3 c2 c1 c0 |
| punpckldq xmm1, xmm2 ; d7 d6 d5 d4 d3 d2 d1 d0 c7 c6 c5 c4 c3 c2 c1 c0 |
| |
| punpckhdq xmm4, xmm2 ; f7 f6 f4 f4 f3 f2 f1 f0 e7 e6 e5 e4 e3 e2 e1 e0 |
| movq QWORD PTR [rsi], xmm1 |
| |
| psrldq xmm1, 8 |
| |
| movq QWORD PTR [rsi+rax*2], xmm4 |
| psrldq xmm4, 8 |
| |
| movq QWORD PTR [rsi+rax], xmm1 |
| movq QWORD PTR [rdi+rax*2], xmm4 |
| |
| add rsp, 160 |
| pop rsp |
| ; begin epilog |
| pop rdi |
| pop rsi |
| RESTORE_GOT |
| UNSHADOW_ARGS |
| pop rbp |
| ret |
| |
| |
| ;void vp8_loop_filter_simple_horizontal_edge_sse2 |
| ;( |
| ; unsigned char *src_ptr, |
| ; int src_pixel_step, |
| ; const char *flimit, |
| ; const char *limit, |
| ; const char *thresh, |
| ; int count |
| ;) |
| global sym(vp8_loop_filter_simple_horizontal_edge_sse2) |
| sym(vp8_loop_filter_simple_horizontal_edge_sse2): |
| push rbp |
| mov rbp, rsp |
| SHADOW_ARGS_TO_STACK 6 |
| GET_GOT rbx |
| push rsi |
| push rdi |
| ; end prolog |
| |
| mov rsi, arg(0) ;src_ptr |
| movsxd rax, dword ptr arg(1) ;src_pixel_step ; destination pitch? |
| mov rdx, arg(2) ;flimit ; get flimit |
| movdqa xmm3, XMMWORD PTR [rdx] |
| mov rdx, arg(3) ;limit |
| movdqa xmm7, XMMWORD PTR [rdx] |
| |
| paddb xmm3, xmm3 ; flimit*2 (less than 255) |
| paddb xmm3, xmm7 ; flimit * 2 + limit (less than 255) |
| |
| mov rdi, rsi ; rdi points to row +1 for indirect addressing |
| add rdi, rax |
| neg rax |
| |
| ; calculate mask |
| movdqu xmm1, [rsi+2*rax] ; p1 |
| movdqu xmm0, [rdi] ; q1 |
| movdqa xmm2, xmm1 |
| movdqa xmm7, xmm0 |
| movdqa xmm4, xmm0 |
| psubusb xmm0, xmm1 ; q1-=p1 |
| psubusb xmm1, xmm4 ; p1-=q1 |
| por xmm1, xmm0 ; abs(p1-q1) |
| pand xmm1, [tfe GLOBAL] ; set lsb of each byte to zero |
| psrlw xmm1, 1 ; abs(p1-q1)/2 |
| |
| movdqu xmm5, [rsi+rax] ; p0 |
| movdqu xmm4, [rsi] ; q0 |
| movdqa xmm0, xmm4 ; q0 |
| movdqa xmm6, xmm5 ; p0 |
| psubusb xmm5, xmm4 ; p0-=q0 |
| psubusb xmm4, xmm6 ; q0-=p0 |
| por xmm5, xmm4 ; abs(p0 - q0) |
| paddusb xmm5, xmm5 ; abs(p0-q0)*2 |
| paddusb xmm5, xmm1 ; abs (p0 - q0) *2 + abs(p1-q1)/2 |
| |
| psubusb xmm5, xmm3 ; abs(p0 - q0) *2 + abs(p1-q1)/2 > flimit * 2 + limit |
| pxor xmm3, xmm3 |
| pcmpeqb xmm5, xmm3 |
| |
| ; start work on filters |
| pxor xmm2, [t80 GLOBAL] ; p1 offset to convert to signed values |
| pxor xmm7, [t80 GLOBAL] ; q1 offset to convert to signed values |
| psubsb xmm2, xmm7 ; p1 - q1 |
| |
| pxor xmm6, [t80 GLOBAL] ; offset to convert to signed values |
| pxor xmm0, [t80 GLOBAL] ; offset to convert to signed values |
| movdqa xmm3, xmm0 ; q0 |
| psubsb xmm0, xmm6 ; q0 - p0 |
| paddsb xmm2, xmm0 ; p1 - q1 + 1 * (q0 - p0) |
| paddsb xmm2, xmm0 ; p1 - q1 + 2 * (q0 - p0) |
| paddsb xmm2, xmm0 ; p1 - q1 + 3 * (q0 - p0) |
| pand xmm5, xmm2 ; mask filter values we don't care about |
| |
| ; do + 4 side |
| paddsb xmm5, [t4 GLOBAL] ; 3* (q0 - p0) + (p1 - q1) + 4 |
| |
| movdqa xmm0, xmm5 ; get a copy of filters |
| psllw xmm0, 8 ; shift left 8 |
| psraw xmm0, 3 ; arithmetic shift right 11 |
| psrlw xmm0, 8 |
| movdqa xmm1, xmm5 ; get a copy of filters |
| psraw xmm1, 11 ; arithmetic shift right 11 |
| psllw xmm1, 8 ; shift left 8 to put it back |
| |
| por xmm0, xmm1 ; put the two together to get result |
| |
| psubsb xmm3, xmm0 ; q0-= q0 add |
| pxor xmm3, [t80 GLOBAL] ; unoffset |
| movdqu [rsi], xmm3 ; write back |
| |
| ; now do +3 side |
| psubsb xmm5, [t1s GLOBAL] ; +3 instead of +4 |
| |
| movdqa xmm0, xmm5 ; get a copy of filters |
| psllw xmm0, 8 ; shift left 8 |
| psraw xmm0, 3 ; arithmetic shift right 11 |
| psrlw xmm0, 8 |
| psraw xmm5, 11 ; arithmetic shift right 11 |
| psllw xmm5, 8 ; shift left 8 to put it back |
| por xmm0, xmm5 ; put the two together to get result |
| |
| |
| paddsb xmm6, xmm0 ; p0+= p0 add |
| pxor xmm6, [t80 GLOBAL] ; unoffset |
| movdqu [rsi+rax], xmm6 ; write back |
| |
| ; begin epilog |
| pop rdi |
| pop rsi |
| RESTORE_GOT |
| UNSHADOW_ARGS |
| pop rbp |
| ret |
| |
| |
| ;void vp8_loop_filter_simple_vertical_edge_sse2 |
| ;( |
| ; unsigned char *src_ptr, |
| ; int src_pixel_step, |
| ; const char *flimit, |
| ; const char *limit, |
| ; const char *thresh, |
| ; int count |
| ;) |
| global sym(vp8_loop_filter_simple_vertical_edge_sse2) |
| sym(vp8_loop_filter_simple_vertical_edge_sse2): |
| push rbp ; save old base pointer value. |
| mov rbp, rsp ; set new base pointer value. |
| SHADOW_ARGS_TO_STACK 6 |
| GET_GOT rbx ; save callee-saved reg |
| push rsi |
| push rdi |
| ; end prolog |
| |
| ALIGN_STACK 16, rax |
| sub rsp, 32 ; reserve 32 bytes |
| %define t0 [rsp + 0] ;__declspec(align(16)) char t0[16]; |
| %define t1 [rsp + 16] ;__declspec(align(16)) char t1[16]; |
| |
| mov rsi, arg(0) ;src_ptr |
| movsxd rax, dword ptr arg(1) ;src_pixel_step ; destination pitch? |
| |
| lea rsi, [rsi - 2 ] |
| lea rdi, [rsi + rax] |
| lea rdx, [rsi + rax*4] |
| lea rcx, [rdx + rax] |
| |
| movdqu xmm0, [rsi] ; (high 96 bits unused) 03 02 01 00 |
| movdqu xmm1, [rdx] ; (high 96 bits unused) 43 42 41 40 |
| movdqu xmm2, [rdi] ; 13 12 11 10 |
| movdqu xmm3, [rcx] ; 53 52 51 50 |
| punpckldq xmm0, xmm1 ; (high 64 bits unused) 43 42 41 40 03 02 01 00 |
| punpckldq xmm2, xmm3 ; 53 52 51 50 13 12 11 10 |
| |
| movdqu xmm4, [rsi + rax*2] ; 23 22 21 20 |
| movdqu xmm5, [rdx + rax*2] ; 63 62 61 60 |
| movdqu xmm6, [rdi + rax*2] ; 33 32 31 30 |
| movdqu xmm7, [rcx + rax*2] ; 73 72 71 70 |
| punpckldq xmm4, xmm5 ; 63 62 61 60 23 22 21 20 |
| punpckldq xmm6, xmm7 ; 73 72 71 70 33 32 31 30 |
| |
| punpcklbw xmm0, xmm2 ; 53 43 52 42 51 41 50 40 13 03 12 02 11 01 10 00 |
| punpcklbw xmm4, xmm6 ; 73 63 72 62 71 61 70 60 33 23 32 22 31 21 30 20 |
| |
| movdqa xmm1, xmm0 |
| punpcklwd xmm0, xmm4 ; 33 23 13 03 32 22 12 02 31 21 11 01 30 20 10 00 |
| punpckhwd xmm1, xmm4 ; 73 63 53 43 72 62 52 42 71 61 51 41 70 60 50 40 |
| |
| movdqa xmm2, xmm0 |
| punpckldq xmm0, xmm1 ; 71 61 51 41 31 21 11 01 70 60 50 40 30 20 10 00 |
| punpckhdq xmm2, xmm1 ; 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02 |
| |
| movdqa t0, xmm0 ; save to t0 |
| movdqa t1, xmm2 ; save to t1 |
| |
| lea rsi, [rsi + rax*8] |
| lea rdi, [rsi + rax] |
| lea rdx, [rsi + rax*4] |
| lea rcx, [rdx + rax] |
| |
| movdqu xmm4, [rsi] ; 83 82 81 80 |
| movdqu xmm1, [rdx] ; c3 c2 c1 c0 |
| movdqu xmm6, [rdi] ; 93 92 91 90 |
| movdqu xmm3, [rcx] ; d3 d2 d1 d0 |
| punpckldq xmm4, xmm1 ; c3 c2 c1 c0 83 82 81 80 |
| punpckldq xmm6, xmm3 ; d3 d2 d1 d0 93 92 91 90 |
| |
| movdqu xmm0, [rsi + rax*2] ; a3 a2 a1 a0 |
| movdqu xmm5, [rdx + rax*2] ; e3 e2 e1 e0 |
| movdqu xmm2, [rdi + rax*2] ; b3 b2 b1 b0 |
| movdqu xmm7, [rcx + rax*2] ; f3 f2 f1 f0 |
| punpckldq xmm0, xmm5 ; e3 e2 e1 e0 a3 a2 a1 a0 |
| punpckldq xmm2, xmm7 ; f3 f2 f1 f0 b3 b2 b1 b0 |
| |
| punpcklbw xmm4, xmm6 ; d3 c3 d2 c2 d1 c1 d0 c0 93 83 92 82 91 81 90 80 |
| punpcklbw xmm0, xmm2 ; f3 e3 f2 e2 f1 e1 f0 e0 b3 a3 b2 a2 b1 a1 b0 a0 |
| |
| movdqa xmm1, xmm4 |
| punpcklwd xmm4, xmm0 ; b3 a3 93 83 b2 a2 92 82 b1 a1 91 81 b0 a0 90 80 |
| punpckhwd xmm1, xmm0 ; f3 e3 d3 c3 f2 e2 d2 c2 f1 e1 d1 c1 f0 e0 d0 c0 |
| |
| movdqa xmm6, xmm4 |
| punpckldq xmm4, xmm1 ; f1 e1 d1 c1 b1 a1 91 81 f0 e0 d0 c0 b0 a0 90 80 |
| punpckhdq xmm6, xmm1 ; f3 e3 d3 c3 b3 a3 93 83 f2 e2 d2 c2 b2 a2 92 82 |
| |
| movdqa xmm0, t0 ; 71 61 51 41 31 21 11 01 70 60 50 40 30 20 10 00 |
| movdqa xmm2, t1 ; 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02 |
| movdqa xmm1, xmm0 |
| movdqa xmm3, xmm2 |
| |
| punpcklqdq xmm0, xmm4 ; p1 f0 e0 d0 c0 b0 a0 90 80 70 60 50 40 30 20 10 00 |
| punpckhqdq xmm1, xmm4 ; p0 f1 e1 d1 c1 b1 a1 91 81 71 61 51 41 31 21 11 01 |
| punpcklqdq xmm2, xmm6 ; q0 f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02 |
| punpckhqdq xmm3, xmm6 ; q1 f3 e3 d3 c3 b3 a3 93 83 73 63 53 43 33 23 13 03 |
| |
| ; calculate mask |
| movdqa xmm6, xmm0 ; p1 |
| movdqa xmm7, xmm3 ; q1 |
| psubusb xmm7, xmm0 ; q1-=p1 |
| psubusb xmm6, xmm3 ; p1-=q1 |
| por xmm6, xmm7 ; abs(p1-q1) |
| pand xmm6, [tfe GLOBAL] ; set lsb of each byte to zero |
| psrlw xmm6, 1 ; abs(p1-q1)/2 |
| |
| movdqa xmm5, xmm1 ; p0 |
| movdqa xmm4, xmm2 ; q0 |
| psubusb xmm5, xmm2 ; p0-=q0 |
| psubusb xmm4, xmm1 ; q0-=p0 |
| por xmm5, xmm4 ; abs(p0 - q0) |
| paddusb xmm5, xmm5 ; abs(p0-q0)*2 |
| paddusb xmm5, xmm6 ; abs (p0 - q0) *2 + abs(p1-q1)/2 |
| |
| mov rdx, arg(2) ;flimit |
| movdqa xmm7, XMMWORD PTR [rdx] |
| mov rdx, arg(3) ; get limit |
| movdqa xmm6, XMMWORD PTR [rdx] |
| paddb xmm7, xmm7 ; flimit*2 (less than 255) |
| paddb xmm7, xmm6 ; flimit * 2 + limit (less than 255) |
| |
| psubusb xmm5, xmm7 ; abs(p0 - q0) *2 + abs(p1-q1)/2 > flimit * 2 + limit |
| pxor xmm7, xmm7 |
| pcmpeqb xmm5, xmm7 ; mm5 = mask |
| |
| ; start work on filters |
| movdqa t0, xmm0 |
| movdqa t1, xmm3 |
| |
| pxor xmm0, [t80 GLOBAL] ; p1 offset to convert to signed values |
| pxor xmm3, [t80 GLOBAL] ; q1 offset to convert to signed values |
| |
| psubsb xmm0, xmm3 ; p1 - q1 |
| movdqa xmm6, xmm1 ; p0 |
| |
| movdqa xmm7, xmm2 ; q0 |
| pxor xmm6, [t80 GLOBAL] ; offset to convert to signed values |
| |
| pxor xmm7, [t80 GLOBAL] ; offset to convert to signed values |
| movdqa xmm3, xmm7 ; offseted ; q0 |
| |
| psubsb xmm7, xmm6 ; q0 - p0 |
| paddsb xmm0, xmm7 ; p1 - q1 + 1 * (q0 - p0) |
| |
| paddsb xmm0, xmm7 ; p1 - q1 + 2 * (q0 - p0) |
| paddsb xmm0, xmm7 ; p1 - q1 + 3 * (q0 - p0) |
| |
| pand xmm5, xmm0 ; mask filter values we don't care about |
| |
| |
| paddsb xmm5, [t4 GLOBAL] ; 3* (q0 - p0) + (p1 - q1) + 4 |
| |
| movdqa xmm0, xmm5 ; get a copy of filters |
| psllw xmm0, 8 ; shift left 8 |
| |
| psraw xmm0, 3 ; arithmetic shift right 11 |
| psrlw xmm0, 8 |
| |
| movdqa xmm7, xmm5 ; get a copy of filters |
| psraw xmm7, 11 ; arithmetic shift right 11 |
| |
| psllw xmm7, 8 ; shift left 8 to put it back |
| por xmm0, xmm7 ; put the two together to get result |
| |
| psubsb xmm3, xmm0 ; q0-= q0sz add |
| pxor xmm3, [t80 GLOBAL] ; unoffset q0 |
| |
| ; now do +3 side |
| psubsb xmm5, [t1s GLOBAL] ; +3 instead of +4 |
| movdqa xmm0, xmm5 ; get a copy of filters |
| |
| psllw xmm0, 8 ; shift left 8 |
| psraw xmm0, 3 ; arithmetic shift right 11 |
| |
| psrlw xmm0, 8 |
| psraw xmm5, 11 ; arithmetic shift right 11 |
| |
| psllw xmm5, 8 ; shift left 8 to put it back |
| por xmm0, xmm5 ; put the two together to get result |
| |
| paddsb xmm6, xmm0 ; p0+= p0 add |
| pxor xmm6, [t80 GLOBAL] ; unoffset p0 |
| |
| movdqa xmm0, t0 ; p1 |
| movdqa xmm4, t1 ; q1 |
| |
| ; transpose back to write out |
| ; p1 f0 e0 d0 c0 b0 a0 90 80 70 60 50 40 30 20 10 00 |
| ; p0 f1 e1 d1 c1 b1 a1 91 81 71 61 51 41 31 21 11 01 |
| ; q0 f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02 |
| ; q1 f3 e3 d3 c3 b3 a3 93 83 73 63 53 43 33 23 13 03 |
| movdqa xmm1, xmm0 |
| punpcklbw xmm0, xmm6 ; 71 70 61 60 51 50 41 40 31 30 21 20 11 10 01 00 |
| punpckhbw xmm1, xmm6 ; f1 f0 e1 e0 d1 d0 c1 c0 b1 b0 a1 a0 91 90 81 80 |
| |
| movdqa xmm5, xmm3 |
| punpcklbw xmm3, xmm4 ; 73 72 63 62 53 52 43 42 33 32 23 22 13 12 03 02 |
| punpckhbw xmm5, xmm4 ; f3 f2 e3 e2 d3 d2 c3 c2 b3 b2 a3 a2 93 92 83 82 |
| |
| movdqa xmm2, xmm0 |
| punpcklwd xmm0, xmm3 ; 33 32 31 30 23 22 21 20 13 12 11 10 03 02 01 00 |
| punpckhwd xmm2, xmm3 ; 73 72 71 70 63 62 61 60 53 52 51 50 43 42 41 40 |
| |
| movdqa xmm3, xmm1 |
| punpcklwd xmm1, xmm5 ; b3 b2 b1 b0 a3 a2 a1 a0 93 92 91 90 83 82 81 80 |
| punpckhwd xmm3, xmm5 ; f3 f2 f1 f0 e3 e2 e1 e0 d3 d2 d1 d0 c3 c2 c1 c0 |
| |
| ; write out order: xmm0 xmm2 xmm1 xmm3 |
| lea rdx, [rsi + rax*4] |
| |
| movd [rsi], xmm1 ; write the second 8-line result |
| psrldq xmm1, 4 |
| movd [rdi], xmm1 |
| psrldq xmm1, 4 |
| movd [rsi + rax*2], xmm1 |
| psrldq xmm1, 4 |
| movd [rdi + rax*2], xmm1 |
| |
| movd [rdx], xmm3 |
| psrldq xmm3, 4 |
| movd [rcx], xmm3 |
| psrldq xmm3, 4 |
| movd [rdx + rax*2], xmm3 |
| psrldq xmm3, 4 |
| movd [rcx + rax*2], xmm3 |
| |
| neg rax |
| lea rsi, [rsi + rax*8] |
| neg rax |
| lea rdi, [rsi + rax] |
| lea rdx, [rsi + rax*4] |
| lea rcx, [rdx + rax] |
| |
| movd [rsi], xmm0 ; write the first 8-line result |
| psrldq xmm0, 4 |
| movd [rdi], xmm0 |
| psrldq xmm0, 4 |
| movd [rsi + rax*2], xmm0 |
| psrldq xmm0, 4 |
| movd [rdi + rax*2], xmm0 |
| |
| movd [rdx], xmm2 |
| psrldq xmm2, 4 |
| movd [rcx], xmm2 |
| psrldq xmm2, 4 |
| movd [rdx + rax*2], xmm2 |
| psrldq xmm2, 4 |
| movd [rcx + rax*2], xmm2 |
| |
| add rsp, 32 |
| pop rsp |
| ; begin epilog |
| pop rdi |
| pop rsi |
| RESTORE_GOT |
| UNSHADOW_ARGS |
| pop rbp |
| ret |
| |
| SECTION_RODATA |
| align 16 |
| tfe: |
| times 16 db 0xfe |
| align 16 |
| t80: |
| times 16 db 0x80 |
| align 16 |
| t1s: |
| times 16 db 0x01 |
| align 16 |
| t3: |
| times 16 db 0x03 |
| align 16 |
| t4: |
| times 16 db 0x04 |
| align 16 |
| ones: |
| times 8 dw 0x0001 |
| align 16 |
| s27: |
| times 8 dw 0x1b00 |
| align 16 |
| s18: |
| times 8 dw 0x1200 |
| align 16 |
| s9: |
| times 8 dw 0x0900 |
| align 16 |
| s63: |
| times 8 dw 0x003f |
