git.sesse.net Git - ffmpeg/blob - 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 ; 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);
  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