34f007f8d23cc9529d63e309e108ff438b16300e
[ffmpeg.git] / libavcodec / x86 / videodsp.asm
1 ;******************************************************************************
2 ;* Core video DSP functions
3 ;* Copyright (c) 2012 Ronald S. Bultje <rsbultje@gmail.com>
4 ;*
5 ;* This file is part of Libav.
6 ;*
7 ;* Libav is free software; you can redistribute it and/or
8 ;* modify it under the terms of the GNU Lesser General Public
9 ;* License as published by the Free Software Foundation; either
10 ;* version 2.1 of the License, or (at your option) any later version.
11 ;*
12 ;* Libav is distributed in the hope that it will be useful,
13 ;* but WITHOUT ANY WARRANTY; without even the implied warranty of
14 ;* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 ;* Lesser General Public License for more details.
16 ;*
17 ;* You should have received a copy of the GNU Lesser General Public
18 ;* License along with Libav; if not, write to the Free Software
19 ;* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 ;******************************************************************************
21
22 %include "libavutil/x86/x86util.asm"
23
24 SECTION .text
25
26 ; void ff_emu_edge_core(uint8_t *buf, const uint8_t *src, x86_reg linesize,
27 ;                       x86_reg start_y, x86_reg end_y, x86_reg block_h,
28 ;                       x86_reg start_x, x86_reg end_x, x86_reg block_w);
29 ;
30 ; The actual function itself is below. It basically wraps a very simple
31 ; w = end_x - start_x
32 ; if (w) {
33 ;   if (w > 22) {
34 ;     jump to the slow loop functions
35 ;   } else {
36 ;     jump to the fast loop functions
37 ;   }
38 ; }
39 ;
40 ; ... and then the same for left/right extend also. See below for loop
41 ; function implementations. Fast are fixed-width, slow is variable-width
42
43 %macro EMU_EDGE_FUNC 0
44 %if ARCH_X86_64
45 %define w_reg r7
46 cglobal emu_edge_core, 6, 9, 1
47     mov         r8, r5          ; save block_h
48 %else
49 %define w_reg r6
50 cglobal emu_edge_core, 2, 7, 0
51     mov         r4, r4m         ; end_y
52     mov         r5, r5m         ; block_h
53 %endif
54
55     ; start with vertical extend (top/bottom) and body pixel copy
56     mov      w_reg, r7m
57     sub      w_reg, r6m         ; w = start_x - end_x
58     sub         r5, r4
59 %if ARCH_X86_64
60     sub         r4, r3
61 %else
62     sub         r4, dword r3m
63 %endif
64     cmp      w_reg, 22
65     jg .slow_v_extend_loop
66 %if ARCH_X86_32
67     mov         r2, r2m         ; linesize
68 %endif
69     sal      w_reg, 7           ; w * 128
70 %ifdef PIC
71     lea        rax, [.emuedge_v_extend_1 - (.emuedge_v_extend_2 - .emuedge_v_extend_1)]
72     add      w_reg, rax
73 %else
74     lea      w_reg, [.emuedge_v_extend_1 - (.emuedge_v_extend_2 - .emuedge_v_extend_1)+w_reg]
75 %endif
76     call     w_reg              ; fast top extend, body copy and bottom extend
77 .v_extend_end:
78
79     ; horizontal extend (left/right)
80     mov      w_reg, r6m         ; start_x
81     sub         r0, w_reg
82 %if ARCH_X86_64
83     mov         r3, r0          ; backup of buf+block_h*linesize
84     mov         r5, r8
85 %else
86     mov        r0m, r0          ; backup of buf+block_h*linesize
87     mov         r5, r5m
88 %endif
89     test     w_reg, w_reg
90     jz .right_extend
91     cmp      w_reg, 22
92     jg .slow_left_extend_loop
93     mov         r1, w_reg
94     dec      w_reg
95     ; FIXME we can do a if size == 1 here if that makes any speed difference, test me
96     sar      w_reg, 1
97     sal      w_reg, 6
98     ; r0=buf+block_h*linesize,r7(64)/r6(32)=start_x offset for funcs
99     ; r6(rax)/r3(ebx)=val,r2=linesize,r1=start_x,r5=block_h
100 %ifdef PIC
101     lea        rax, [.emuedge_extend_left_2]
102     add      w_reg, rax
103 %else
104     lea      w_reg, [.emuedge_extend_left_2+w_reg]
105 %endif
106     call     w_reg
107
108     ; now r3(64)/r0(32)=buf,r2=linesize,r8/r5=block_h,r6/r3=val, r7/r6=end_x, r1=block_w
109 .right_extend:
110 %if ARCH_X86_32
111     mov         r0, r0m
112     mov         r5, r5m
113 %endif
114     mov      w_reg, r7m         ; end_x
115     mov         r1, r8m         ; block_w
116     mov         r4, r1
117     sub         r1, w_reg
118     jz .h_extend_end            ; if (end_x == block_w) goto h_extend_end
119     cmp         r1, 22
120     jg .slow_right_extend_loop
121     dec         r1
122     ; FIXME we can do a if size == 1 here if that makes any speed difference, test me
123     sar         r1, 1
124     sal         r1, 6
125 %ifdef PIC
126     lea        rax, [.emuedge_extend_right_2]
127     add         r1, rax
128 %else
129     lea         r1, [.emuedge_extend_right_2+r1]
130 %endif
131     call        r1
132 .h_extend_end:
133     RET
134
135 %if ARCH_X86_64
136 %define vall  al
137 %define valh  ah
138 %define valw  ax
139 %define valw2 r7w
140 %define valw3 r3w
141 %if WIN64
142 %define valw4 r7w
143 %else ; unix64
144 %define valw4 r3w
145 %endif
146 %define vald eax
147 %else
148 %define vall  bl
149 %define valh  bh
150 %define valw  bx
151 %define valw2 r6w
152 %define valw3 valw2
153 %define valw4 valw3
154 %define vald ebx
155 %define stack_offset 0x14
156 %endif
157
158 %endmacro
159
160 ; macro to read/write a horizontal number of pixels (%2) to/from registers
161 ; on x86-64, - fills xmm0-15 for consecutive sets of 16 pixels
162 ;            - if (%2 & 15 == 8) fills the last 8 bytes into rax
163 ;            - else if (%2 & 8)  fills 8 bytes into mm0
164 ;            - if (%2 & 7 == 4)  fills the last 4 bytes into rax
165 ;            - else if (%2 & 4)  fills 4 bytes into mm0-1
166 ;            - if (%2 & 3 == 3)  fills 2 bytes into r7/r3, and 1 into eax
167 ;              (note that we're using r3 for body/bottom because it's a shorter
168 ;               opcode, and then the loop fits in 128 bytes)
169 ;            - else              fills remaining bytes into rax
170 ; on x86-32, - fills mm0-7 for consecutive sets of 8 pixels
171 ;            - if (%2 & 7 == 4)  fills 4 bytes into ebx
172 ;            - else if (%2 & 4)  fills 4 bytes into mm0-7
173 ;            - if (%2 & 3 == 3)  fills 2 bytes into r6, and 1 into ebx
174 ;            - else              fills remaining bytes into ebx
175 ; writing data out is in the same way
176 %macro READ_NUM_BYTES 2
177 %assign %%src_off 0 ; offset in source buffer
178 %assign %%smidx   0 ; mmx register idx
179 %assign %%sxidx   0 ; xmm register idx
180
181 %if cpuflag(sse)
182 %rep %2/16
183     movups xmm %+ %%sxidx, [r1+%%src_off]
184 %assign %%src_off %%src_off+16
185 %assign %%sxidx   %%sxidx+1
186 %endrep ; %2/16
187 %endif
188
189 %if ARCH_X86_64
190 %if (%2-%%src_off) == 8
191     mov           rax, [r1+%%src_off]
192 %assign %%src_off %%src_off+8
193 %endif ; (%2-%%src_off) == 8
194 %endif ; x86-64
195
196 %rep (%2-%%src_off)/8
197     movq    mm %+ %%smidx, [r1+%%src_off]
198 %assign %%src_off %%src_off+8
199 %assign %%smidx   %%smidx+1
200 %endrep ; (%2-%%dst_off)/8
201
202 %if (%2-%%src_off) == 4
203     mov          vald, [r1+%%src_off]
204 %elif (%2-%%src_off) & 4
205     movd    mm %+ %%smidx, [r1+%%src_off]
206 %assign %%src_off %%src_off+4
207 %endif ; (%2-%%src_off) ==/& 4
208
209 %if (%2-%%src_off) == 1
210     mov          vall, [r1+%%src_off]
211 %elif (%2-%%src_off) == 2
212     mov          valw, [r1+%%src_off]
213 %elif (%2-%%src_off) == 3
214 %ifidn %1, top
215     mov         valw2, [r1+%%src_off]
216 %elifidn %1, body
217     mov         valw3, [r1+%%src_off]
218 %elifidn %1, bottom
219     mov         valw4, [r1+%%src_off]
220 %endif ; %1 ==/!= top
221     mov          vall, [r1+%%src_off+2]
222 %endif ; (%2-%%src_off) == 1/2/3
223 %endmacro ; READ_NUM_BYTES
224
225 %macro WRITE_NUM_BYTES 2
226 %assign %%dst_off 0 ; offset in destination buffer
227 %assign %%dmidx   0 ; mmx register idx
228 %assign %%dxidx   0 ; xmm register idx
229
230 %if cpuflag(sse)
231 %rep %2/16
232     movups [r0+%%dst_off], xmm %+ %%dxidx
233 %assign %%dst_off %%dst_off+16
234 %assign %%dxidx   %%dxidx+1
235 %endrep ; %2/16
236 %endif
237
238 %if ARCH_X86_64
239 %if (%2-%%dst_off) == 8
240     mov    [r0+%%dst_off], rax
241 %assign %%dst_off %%dst_off+8
242 %endif ; (%2-%%dst_off) == 8
243 %endif ; x86-64
244
245 %rep (%2-%%dst_off)/8
246     movq   [r0+%%dst_off], mm %+ %%dmidx
247 %assign %%dst_off %%dst_off+8
248 %assign %%dmidx   %%dmidx+1
249 %endrep ; (%2-%%dst_off)/8
250
251 %if (%2-%%dst_off) == 4
252     mov    [r0+%%dst_off], vald
253 %elif (%2-%%dst_off) & 4
254     movd   [r0+%%dst_off], mm %+ %%dmidx
255 %assign %%dst_off %%dst_off+4
256 %endif ; (%2-%%dst_off) ==/& 4
257
258 %if (%2-%%dst_off) == 1
259     mov    [r0+%%dst_off], vall
260 %elif (%2-%%dst_off) == 2
261     mov    [r0+%%dst_off], valw
262 %elif (%2-%%dst_off) == 3
263 %ifidn %1, top
264     mov    [r0+%%dst_off], valw2
265 %elifidn %1, body
266     mov    [r0+%%dst_off], valw3
267 %elifidn %1, bottom
268     mov    [r0+%%dst_off], valw4
269 %endif ; %1 ==/!= top
270     mov  [r0+%%dst_off+2], vall
271 %endif ; (%2-%%dst_off) == 1/2/3
272 %endmacro ; WRITE_NUM_BYTES
273
274 ; vertical top/bottom extend and body copy fast loops
275 ; these are function pointers to set-width line copy functions, i.e.
276 ; they read a fixed number of pixels into set registers, and write
277 ; those out into the destination buffer
278 ; r0=buf,r1=src,r2=linesize,r3(64)/r3m(32)=start_x,r4=end_y,r5=block_h
279 ; r6(eax/64)/r3(ebx/32)=val_reg
280 %macro VERTICAL_EXTEND 0
281 %assign %%n 1
282 %rep 22
283 ALIGN 128
284 .emuedge_v_extend_ %+ %%n:
285     ; extend pixels above body
286 %if ARCH_X86_64
287     test           r3 , r3                   ; if (!start_y)
288     jz .emuedge_copy_body_ %+ %%n %+ _loop   ;   goto body
289 %else ; ARCH_X86_32
290     cmp      dword r3m, 0
291     je .emuedge_copy_body_ %+ %%n %+ _loop
292 %endif ; ARCH_X86_64/32
293     READ_NUM_BYTES  top,    %%n              ; read bytes
294 .emuedge_extend_top_ %+ %%n %+ _loop:        ; do {
295     WRITE_NUM_BYTES top,    %%n              ;   write bytes
296     add            r0 , r2                   ;   dst += linesize
297 %if ARCH_X86_64
298     dec            r3d
299 %else ; ARCH_X86_32
300     dec      dword r3m
301 %endif ; ARCH_X86_64/32
302     jnz .emuedge_extend_top_ %+ %%n %+ _loop ; } while (--start_y)
303
304     ; copy body pixels
305 .emuedge_copy_body_ %+ %%n %+ _loop:         ; do {
306     READ_NUM_BYTES  body,   %%n              ;   read bytes
307     WRITE_NUM_BYTES body,   %%n              ;   write bytes
308     add            r0 , r2                   ;   dst += linesize
309     add            r1 , r2                   ;   src += linesize
310     dec            r4d
311     jnz .emuedge_copy_body_ %+ %%n %+ _loop  ; } while (--end_y)
312
313     ; copy bottom pixels
314     test           r5 , r5                   ; if (!block_h)
315     jz .emuedge_v_extend_end_ %+ %%n         ;   goto end
316     sub            r1 , r2                   ; src -= linesize
317     READ_NUM_BYTES  bottom, %%n              ; read bytes
318 .emuedge_extend_bottom_ %+ %%n %+ _loop:     ; do {
319     WRITE_NUM_BYTES bottom, %%n              ;   write bytes
320     add            r0 , r2                   ;   dst += linesize
321     dec            r5d
322     jnz .emuedge_extend_bottom_ %+ %%n %+ _loop ; } while (--block_h)
323
324 .emuedge_v_extend_end_ %+ %%n:
325 %if ARCH_X86_64
326     ret
327 %else ; ARCH_X86_32
328     rep ret
329 %endif ; ARCH_X86_64/32
330 %assign %%n %%n+1
331 %endrep
332 %endmacro VERTICAL_EXTEND
333
334 ; left/right (horizontal) fast extend functions
335 ; these are essentially identical to the vertical extend ones above,
336 ; just left/right separated because number of pixels to extend is
337 ; obviously not the same on both sides.
338 ; for reading, pixels are placed in eax (x86-64) or ebx (x86-64) in the
339 ; lowest two bytes of the register (so val*0x0101), and are splatted
340 ; into each byte of mm0 as well if n_pixels >= 8
341
342 %macro READ_V_PIXEL 2
343     mov        vall, %2
344     mov        valh, vall
345 %if %1 >= 8
346     movd        mm0, vald
347 %if cpuflag(mmxext)
348     pshufw      mm0, mm0, 0
349 %else ; mmx
350     punpcklwd   mm0, mm0
351     punpckldq   mm0, mm0
352 %endif ; sse
353 %endif ; %1 >= 8
354 %endmacro
355
356 %macro WRITE_V_PIXEL 2
357 %assign %%dst_off 0
358 %rep %1/8
359     movq [%2+%%dst_off], mm0
360 %assign %%dst_off %%dst_off+8
361 %endrep
362 %if %1 & 4
363 %if %1 >= 8
364     movd [%2+%%dst_off], mm0
365 %else ; %1 < 8
366     mov  [%2+%%dst_off]  , valw
367     mov  [%2+%%dst_off+2], valw
368 %endif ; %1 >=/< 8
369 %assign %%dst_off %%dst_off+4
370 %endif ; %1 & 4
371 %if %1&2
372     mov  [%2+%%dst_off], valw
373 %endif ; %1 & 2
374 %endmacro
375
376 ; r0=buf+block_h*linesize, r1=start_x, r2=linesize, r5=block_h, r6/r3=val
377 %macro LEFT_EXTEND 0
378 %assign %%n 2
379 %rep 11
380 ALIGN 64
381 .emuedge_extend_left_ %+ %%n:          ; do {
382     sub         r0, r2                 ;   dst -= linesize
383     READ_V_PIXEL  %%n, [r0+r1]         ;   read pixels
384     WRITE_V_PIXEL %%n, r0              ;   write pixels
385     dec         r5
386     jnz .emuedge_extend_left_ %+ %%n   ; } while (--block_h)
387 %if ARCH_X86_64
388     ret
389 %else ; ARCH_X86_32
390     rep ret
391 %endif ; ARCH_X86_64/32
392 %assign %%n %%n+2
393 %endrep
394 %endmacro ; LEFT_EXTEND
395
396 ; r3/r0=buf+block_h*linesize, r2=linesize, r8/r5=block_h, r0/r6=end_x, r6/r3=val
397 %macro RIGHT_EXTEND 0
398 %assign %%n 2
399 %rep 11
400 ALIGN 64
401 .emuedge_extend_right_ %+ %%n:          ; do {
402 %if ARCH_X86_64
403     sub        r3, r2                   ;   dst -= linesize
404     READ_V_PIXEL  %%n, [r3+w_reg-1]     ;   read pixels
405     WRITE_V_PIXEL %%n, r3+r4-%%n        ;   write pixels
406     dec       r8
407 %else ; ARCH_X86_32
408     sub        r0, r2                   ;   dst -= linesize
409     READ_V_PIXEL  %%n, [r0+w_reg-1]     ;   read pixels
410     WRITE_V_PIXEL %%n, r0+r4-%%n        ;   write pixels
411     dec     r5
412 %endif ; ARCH_X86_64/32
413     jnz .emuedge_extend_right_ %+ %%n   ; } while (--block_h)
414 %if ARCH_X86_64
415     ret
416 %else ; ARCH_X86_32
417     rep ret
418 %endif ; ARCH_X86_64/32
419 %assign %%n %%n+2
420 %endrep
421
422 %if ARCH_X86_32
423 %define stack_offset 0x10
424 %endif
425 %endmacro ; RIGHT_EXTEND
426
427 ; below follow the "slow" copy/extend functions, these act on a non-fixed
428 ; width specified in a register, and run a loop to copy the full amount
429 ; of bytes. They are optimized for copying of large amounts of pixels per
430 ; line, so they unconditionally splat data into mm registers to copy 8
431 ; bytes per loop iteration. It could be considered to use xmm for x86-64
432 ; also, but I haven't optimized this as much (i.e. FIXME)
433 %macro V_COPY_NPX 4-5
434 %if %0 == 4
435     test     w_reg, %4
436     jz .%1_skip_%4_px
437 %else ; %0 == 5
438 .%1_%4_px_loop:
439 %endif
440     %3          %2, [r1+cnt_reg]
441     %3 [r0+cnt_reg], %2
442     add    cnt_reg, %4
443 %if %0 == 5
444     sub      w_reg, %4
445     test     w_reg, %5
446     jnz .%1_%4_px_loop
447 %endif
448 .%1_skip_%4_px:
449 %endmacro
450
451 %macro V_COPY_ROW 2
452 %ifidn %1, bottom
453     sub         r1, linesize
454 %endif
455 .%1_copy_loop:
456     xor    cnt_reg, cnt_reg
457 %if notcpuflag(sse)
458 %define linesize r2m
459     V_COPY_NPX %1,  mm0, movq,    8, 0xFFFFFFF8
460 %else ; sse
461     V_COPY_NPX %1, xmm0, movups, 16, 0xFFFFFFF0
462 %if ARCH_X86_64
463 %define linesize r2
464     V_COPY_NPX %1, rax , mov,     8
465 %else ; ARCH_X86_32
466 %define linesize r2m
467     V_COPY_NPX %1,  mm0, movq,    8
468 %endif ; ARCH_X86_64/32
469 %endif ; sse
470     V_COPY_NPX %1, vald, mov,     4
471     V_COPY_NPX %1, valw, mov,     2
472     V_COPY_NPX %1, vall, mov,     1
473     mov      w_reg, cnt_reg
474 %ifidn %1, body
475     add         r1, linesize
476 %endif
477     add         r0, linesize
478     dec         %2
479     jnz .%1_copy_loop
480 %endmacro
481
482 %macro SLOW_V_EXTEND 0
483 .slow_v_extend_loop:
484 ; r0=buf,r1=src,r2(64)/r2m(32)=linesize,r3(64)/r3m(32)=start_x,r4=end_y,r5=block_h
485 ; r8(64)/r3(later-64)/r2(32)=cnt_reg,r6(64)/r3(32)=val_reg,r7(64)/r6(32)=w=end_x-start_x
486 %if ARCH_X86_64
487     push        r8              ; save old value of block_h
488     test        r3, r3
489 %define cnt_reg r8
490     jz .do_body_copy            ; if (!start_y) goto do_body_copy
491     V_COPY_ROW top, r3
492 %else
493     cmp  dword r3m, 0
494 %define cnt_reg r2
495     je .do_body_copy            ; if (!start_y) goto do_body_copy
496     V_COPY_ROW top, dword r3m
497 %endif
498
499 .do_body_copy:
500     V_COPY_ROW body, r4
501
502 %if ARCH_X86_64
503     pop         r8              ; restore old value of block_h
504 %define cnt_reg r3
505 %endif
506     test        r5, r5
507 %if ARCH_X86_64
508     jz .v_extend_end
509 %else
510     jz .skip_bottom_extend
511 %endif
512     V_COPY_ROW bottom, r5
513 %if ARCH_X86_32
514 .skip_bottom_extend:
515     mov         r2, r2m
516 %endif
517     jmp .v_extend_end
518 %endmacro
519
520 %macro SLOW_LEFT_EXTEND 0
521 .slow_left_extend_loop:
522 ; r0=buf+block_h*linesize,r2=linesize,r6(64)/r3(32)=val,r5=block_h,r4=cntr,r7/r6=start_x
523     mov         r4, 8
524     sub         r0, linesize
525     READ_V_PIXEL 8, [r0+w_reg]
526 .left_extend_8px_loop:
527     movq [r0+r4-8], mm0
528     add         r4, 8
529     cmp         r4, w_reg
530     jle .left_extend_8px_loop
531     sub         r4, 8
532     cmp         r4, w_reg
533     jge .left_extend_loop_end
534 .left_extend_2px_loop:
535     mov    [r0+r4], valw
536     add         r4, 2
537     cmp         r4, w_reg
538     jl .left_extend_2px_loop
539 .left_extend_loop_end:
540     dec         r5
541     jnz .slow_left_extend_loop
542 %if ARCH_X86_32
543     mov         r2, r2m
544 %endif
545     jmp .right_extend
546 %endmacro
547
548 %macro SLOW_RIGHT_EXTEND 0
549 .slow_right_extend_loop:
550 ; r3(64)/r0(32)=buf+block_h*linesize,r2=linesize,r4=block_w,r8(64)/r5(32)=block_h,
551 ; r7(64)/r6(32)=end_x,r6/r3=val,r1=cntr
552 %if ARCH_X86_64
553 %define buf_reg r3
554 %define bh_reg r8
555 %else
556 %define buf_reg r0
557 %define bh_reg r5
558 %endif
559     lea         r1, [r4-8]
560     sub    buf_reg, linesize
561     READ_V_PIXEL 8, [buf_reg+w_reg-1]
562 .right_extend_8px_loop:
563     movq [buf_reg+r1], mm0
564     sub         r1, 8
565     cmp         r1, w_reg
566     jge .right_extend_8px_loop
567     add         r1, 8
568     cmp         r1, w_reg
569     je .right_extend_loop_end
570 .right_extend_2px_loop:
571     sub         r1, 2
572     mov [buf_reg+r1], valw
573     cmp         r1, w_reg
574     jg .right_extend_2px_loop
575 .right_extend_loop_end:
576     dec         bh_reg
577     jnz .slow_right_extend_loop
578     jmp .h_extend_end
579 %endmacro
580
581 %macro emu_edge 1
582 INIT_XMM %1
583 EMU_EDGE_FUNC
584 VERTICAL_EXTEND
585 LEFT_EXTEND
586 RIGHT_EXTEND
587 SLOW_V_EXTEND
588 SLOW_LEFT_EXTEND
589 SLOW_RIGHT_EXTEND
590 %endmacro
591
592 emu_edge sse
593 %if ARCH_X86_32
594 emu_edge mmx
595 %endif
596
597 %macro PREFETCH_FN 1
598 cglobal prefetch, 3, 3, 0, buf, stride, h
599 .loop:
600     %1      [bufq]
601     add      bufq, strideq
602     dec        hd
603     jg .loop
604     REP_RET
605 %endmacro
606
607 INIT_MMX mmxext
608 PREFETCH_FN prefetcht0
609 %if ARCH_X86_32
610 INIT_MMX 3dnow
611 PREFETCH_FN prefetch
612 %endif