1 ;******************************************************************************
2 ;* Core video DSP functions
3 ;* Copyright (c) 2012 Ronald S. Bultje <rsbultje@gmail.com>
5 ;* This file is part of FFmpeg.
7 ;* FFmpeg 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.
12 ;* FFmpeg 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.
17 ;* You should have received a copy of the GNU Lesser General Public
18 ;* License along with FFmpeg; if not, write to the Free Software
19 ;* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 ;******************************************************************************
22 %include "libavutil/x86/x86util.asm"
26 ; extern 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);
30 ; The actual function itself is below. It basically wraps a very simple
34 ; jump to the slow loop functions
36 ; jump to the fast loop functions
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
43 %macro EMU_EDGE_FUNC 0
46 cglobal emu_edge_core, 6, 9, 1
47 mov r8, r5 ; save block_h
50 cglobal emu_edge_core, 2, 7, 0
55 ; start with vertical extend (top/bottom) and body pixel copy
57 sub w_reg, r6m ; w = start_x - end_x
65 jg .slow_v_extend_loop
67 mov r2, r2m ; linesize
69 sal w_reg, 7 ; w * 128
71 lea rax, [.emuedge_v_extend_1 - (.emuedge_v_extend_2 - .emuedge_v_extend_1)]
74 lea w_reg, [.emuedge_v_extend_1 - (.emuedge_v_extend_2 - .emuedge_v_extend_1)+w_reg]
76 call w_reg ; fast top extend, body copy and bottom extend
79 ; horizontal extend (left/right)
80 mov w_reg, r6m ; start_x
83 mov r3, r0 ; backup of buf+block_h*linesize
86 mov r0m, r0 ; backup of buf+block_h*linesize
92 jg .slow_left_extend_loop
95 ; FIXME we can do a if size == 1 here if that makes any speed difference, test me
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
101 lea rax, [.emuedge_extend_left_2]
104 lea w_reg, [.emuedge_extend_left_2+w_reg]
108 ; now r3(64)/r0(32)=buf,r2=linesize,r8/r5=block_h,r6/r3=val, r7/r6=end_x, r1=block_w
114 mov w_reg, r7m ; end_x
115 mov r1, r8m ; block_w
118 jz .h_extend_end ; if (end_x == block_w) goto h_extend_end
120 jg .slow_right_extend_loop
122 ; FIXME we can do a if size == 1 here if that makes any speed difference, test me
126 lea rax, [.emuedge_extend_right_2]
129 lea r1, [.emuedge_extend_right_2+r1]
155 %define stack_offset 0x14
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
183 movups xmm %+ %%sxidx, [r1+%%src_off]
184 %assign %%src_off %%src_off+16
185 %assign %%sxidx %%sxidx+1
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
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
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
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
215 mov valw2, [r1+%%src_off]
217 mov valw3, [r1+%%src_off]
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
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
232 movups [r0+%%dst_off], xmm %+ %%dxidx
233 %assign %%dst_off %%dst_off+16
234 %assign %%dxidx %%dxidx+1
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
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
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
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
264 mov [r0+%%dst_off], valw2
266 mov [r0+%%dst_off], valw3
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
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
284 .emuedge_v_extend_ %+ %%n:
285 ; extend pixels above body
287 test r3 , r3 ; if (!start_y)
288 jz .emuedge_copy_body_ %+ %%n %+ _loop ; goto body
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
301 %endif ; ARCH_X86_64/32
302 jnz .emuedge_extend_top_ %+ %%n %+ _loop ; } while (--start_y)
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
311 jnz .emuedge_copy_body_ %+ %%n %+ _loop ; } while (--end_y)
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
322 jnz .emuedge_extend_bottom_ %+ %%n %+ _loop ; } while (--block_h)
324 .emuedge_v_extend_end_ %+ %%n:
329 %endif ; ARCH_X86_64/32
332 %endmacro VERTICAL_EXTEND
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
342 %macro READ_V_PIXEL 2
356 %macro WRITE_V_PIXEL 2
359 movq [%2+%%dst_off], mm0
360 %assign %%dst_off %%dst_off+8
364 movd [%2+%%dst_off], mm0
366 mov [%2+%%dst_off] , valw
367 mov [%2+%%dst_off+2], valw
369 %assign %%dst_off %%dst_off+4
372 mov [%2+%%dst_off], valw
376 ; r0=buf+block_h*linesize, r1=start_x, r2=linesize, r5=block_h, r6/r3=val
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
386 jnz .emuedge_extend_left_ %+ %%n ; } while (--block_h)
391 %endif ; ARCH_X86_64/32
394 %endmacro ; LEFT_EXTEND
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
401 .emuedge_extend_right_ %+ %%n: ; do {
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
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
412 %endif ; ARCH_X86_64/32
413 jnz .emuedge_extend_right_ %+ %%n ; } while (--block_h)
418 %endif ; ARCH_X86_64/32
423 %define stack_offset 0x10
425 %endmacro ; RIGHT_EXTEND
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
459 V_COPY_NPX %1, mm0, movq, 8, 0xFFFFFFF8
461 V_COPY_NPX %1, xmm0, movups, 16, 0xFFFFFFF0
464 V_COPY_NPX %1, rax , mov, 8
467 V_COPY_NPX %1, mm0, movq, 8
468 %endif ; ARCH_X86_64/32
470 V_COPY_NPX %1, vald, mov, 4
471 V_COPY_NPX %1, valw, mov, 2
472 V_COPY_NPX %1, vall, mov, 1
482 %macro SLOW_V_EXTEND 0
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
487 push r8 ; save old value of block_h
490 jz .do_body_copy ; if (!start_y) goto do_body_copy
495 je .do_body_copy ; if (!start_y) goto do_body_copy
496 V_COPY_ROW top, dword r3m
503 pop r8 ; restore old value of block_h
510 jz .skip_bottom_extend
512 V_COPY_ROW bottom, r5
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
525 READ_V_PIXEL 8, [r0+w_reg]
526 .left_extend_8px_loop:
530 jle .left_extend_8px_loop
533 jge .left_extend_loop_end
534 .left_extend_2px_loop:
538 jl .left_extend_2px_loop
539 .left_extend_loop_end:
541 jnz .slow_left_extend_loop
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
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
566 jge .right_extend_8px_loop
569 je .right_extend_loop_end
570 .right_extend_2px_loop:
572 mov [buf_reg+r1], valw
574 jg .right_extend_2px_loop
575 .right_extend_loop_end:
577 jnz .slow_right_extend_loop
598 cglobal prefetch, 3, 3, 0, buf, stride, h
608 PREFETCH_FN prefetcht0