Merge remote-tracking branch 'qatar/master'
[ffmpeg.git] / libavcodec / x86 / dsputil_yasm.asm
1 ;******************************************************************************
2 ;* MMX optimized DSP utils
3 ;* Copyright (c) 2008 Loren Merritt
4 ;*
5 ;* This file is part of FFmpeg.
6 ;*
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.
11 ;*
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.
16 ;*
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 ;******************************************************************************
21
22 %include "libavutil/x86/x86inc.asm"
23 %include "x86util.asm"
24
25 SECTION_RODATA
26 pb_f: times 16 db 15
27 pb_zzzzzzzz77777777: times 8 db -1
28 pb_7: times 8 db 7
29 pb_zzzz3333zzzzbbbb: db -1,-1,-1,-1,3,3,3,3,-1,-1,-1,-1,11,11,11,11
30 pb_zz11zz55zz99zzdd: db -1,-1,1,1,-1,-1,5,5,-1,-1,9,9,-1,-1,13,13
31 pb_revwords: db 14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1
32 pd_16384: times 4 dd 16384
33
34 SECTION_TEXT
35
36 %macro SCALARPRODUCT 1
37 ; int scalarproduct_int16(int16_t *v1, int16_t *v2, int order, int shift)
38 cglobal scalarproduct_int16_%1, 3,3,4, v1, v2, order, shift
39     shl orderq, 1
40     add v1q, orderq
41     add v2q, orderq
42     neg orderq
43     movd    m3, shiftm
44     pxor    m2, m2
45 .loop:
46     movu    m0, [v1q + orderq]
47     movu    m1, [v1q + orderq + mmsize]
48     pmaddwd m0, [v2q + orderq]
49     pmaddwd m1, [v2q + orderq + mmsize]
50     paddd   m2, m0
51     paddd   m2, m1
52     add     orderq, mmsize*2
53     jl .loop
54 %if mmsize == 16
55     movhlps m0, m2
56     paddd   m2, m0
57     psrad   m2, m3
58     pshuflw m0, m2, 0x4e
59 %else
60     psrad   m2, m3
61     pshufw  m0, m2, 0x4e
62 %endif
63     paddd   m2, m0
64     movd   eax, m2
65     RET
66
67 ; int scalarproduct_and_madd_int16(int16_t *v1, int16_t *v2, int16_t *v3, int order, int mul)
68 cglobal scalarproduct_and_madd_int16_%1, 4,4,8, v1, v2, v3, order, mul
69     shl orderq, 1
70     movd    m7, mulm
71 %if mmsize == 16
72     pshuflw m7, m7, 0
73     punpcklqdq m7, m7
74 %else
75     pshufw  m7, m7, 0
76 %endif
77     pxor    m6, m6
78     add v1q, orderq
79     add v2q, orderq
80     add v3q, orderq
81     neg orderq
82 .loop:
83     movu    m0, [v2q + orderq]
84     movu    m1, [v2q + orderq + mmsize]
85     mova    m4, [v1q + orderq]
86     mova    m5, [v1q + orderq + mmsize]
87     movu    m2, [v3q + orderq]
88     movu    m3, [v3q + orderq + mmsize]
89     pmaddwd m0, m4
90     pmaddwd m1, m5
91     pmullw  m2, m7
92     pmullw  m3, m7
93     paddd   m6, m0
94     paddd   m6, m1
95     paddw   m2, m4
96     paddw   m3, m5
97     mova    [v1q + orderq], m2
98     mova    [v1q + orderq + mmsize], m3
99     add     orderq, mmsize*2
100     jl .loop
101 %if mmsize == 16
102     movhlps m0, m6
103     paddd   m6, m0
104     pshuflw m0, m6, 0x4e
105 %else
106     pshufw  m0, m6, 0x4e
107 %endif
108     paddd   m6, m0
109     movd   eax, m6
110     RET
111 %endmacro
112
113 INIT_MMX
114 SCALARPRODUCT mmx2
115 INIT_XMM
116 SCALARPRODUCT sse2
117
118 %macro SCALARPRODUCT_LOOP 1
119 align 16
120 .loop%1:
121     sub     orderq, mmsize*2
122 %if %1
123     mova    m1, m4
124     mova    m4, [v2q + orderq]
125     mova    m0, [v2q + orderq + mmsize]
126     palignr m1, m0, %1
127     palignr m0, m4, %1
128     mova    m3, m5
129     mova    m5, [v3q + orderq]
130     mova    m2, [v3q + orderq + mmsize]
131     palignr m3, m2, %1
132     palignr m2, m5, %1
133 %else
134     mova    m0, [v2q + orderq]
135     mova    m1, [v2q + orderq + mmsize]
136     mova    m2, [v3q + orderq]
137     mova    m3, [v3q + orderq + mmsize]
138 %endif
139     %define t0  [v1q + orderq]
140     %define t1  [v1q + orderq + mmsize]
141 %ifdef ARCH_X86_64
142     mova    m8, t0
143     mova    m9, t1
144     %define t0  m8
145     %define t1  m9
146 %endif
147     pmaddwd m0, t0
148     pmaddwd m1, t1
149     pmullw  m2, m7
150     pmullw  m3, m7
151     paddw   m2, t0
152     paddw   m3, t1
153     paddd   m6, m0
154     paddd   m6, m1
155     mova    [v1q + orderq], m2
156     mova    [v1q + orderq + mmsize], m3
157     jg .loop%1
158 %if %1
159     jmp .end
160 %endif
161 %endmacro
162
163 ; int scalarproduct_and_madd_int16(int16_t *v1, int16_t *v2, int16_t *v3, int order, int mul)
164 cglobal scalarproduct_and_madd_int16_ssse3, 4,5,10, v1, v2, v3, order, mul
165     shl orderq, 1
166     movd    m7, mulm
167     pshuflw m7, m7, 0
168     punpcklqdq m7, m7
169     pxor    m6, m6
170     mov    r4d, v2d
171     and    r4d, 15
172     and    v2q, ~15
173     and    v3q, ~15
174     mova    m4, [v2q + orderq]
175     mova    m5, [v3q + orderq]
176     ; linear is faster than branch tree or jump table, because the branches taken are cyclic (i.e. predictable)
177     cmp    r4d, 0
178     je .loop0
179     cmp    r4d, 2
180     je .loop2
181     cmp    r4d, 4
182     je .loop4
183     cmp    r4d, 6
184     je .loop6
185     cmp    r4d, 8
186     je .loop8
187     cmp    r4d, 10
188     je .loop10
189     cmp    r4d, 12
190     je .loop12
191 SCALARPRODUCT_LOOP 14
192 SCALARPRODUCT_LOOP 12
193 SCALARPRODUCT_LOOP 10
194 SCALARPRODUCT_LOOP 8
195 SCALARPRODUCT_LOOP 6
196 SCALARPRODUCT_LOOP 4
197 SCALARPRODUCT_LOOP 2
198 SCALARPRODUCT_LOOP 0
199 .end:
200     movhlps m0, m6
201     paddd   m6, m0
202     pshuflw m0, m6, 0x4e
203     paddd   m6, m0
204     movd   eax, m6
205     RET
206
207
208 ;-----------------------------------------------------------------------------
209 ; void ff_apply_window_int16(int16_t *output, const int16_t *input,
210 ;                            const int16_t *window, unsigned int len)
211 ;-----------------------------------------------------------------------------
212
213 %macro REVERSE_WORDS_MMXEXT 1-2
214     pshufw   %1, %1, 0x1B
215 %endmacro
216
217 %macro REVERSE_WORDS_SSE2 1-2
218     pshuflw  %1, %1, 0x1B
219     pshufhw  %1, %1, 0x1B
220     pshufd   %1, %1, 0x4E
221 %endmacro
222
223 %macro REVERSE_WORDS_SSSE3 2
224     pshufb  %1, %2
225 %endmacro
226
227 ; dst = (dst * src) >> 15
228 ; pmulhw cuts off the bottom bit, so we have to lshift by 1 and add it back
229 ; in from the pmullw result.
230 %macro MUL16FIXED_MMXEXT 3 ; dst, src, temp
231     mova    %3, %1
232     pmulhw  %1, %2
233     pmullw  %3, %2
234     psrlw   %3, 15
235     psllw   %1, 1
236     por     %1, %3
237 %endmacro
238
239 ; dst = ((dst * src) + (1<<14)) >> 15
240 %macro MUL16FIXED_SSSE3 3 ; dst, src, unused
241     pmulhrsw   %1, %2
242 %endmacro
243
244 %macro APPLY_WINDOW_INT16 3 ; %1=instruction set, %2=mmxext/sse2 bit exact version, %3=has_ssse3
245 cglobal apply_window_int16_%1, 4,5,6, output, input, window, offset, offset2
246     lea     offset2q, [offsetq-mmsize]
247 %if %2
248     mova          m5, [pd_16384]
249 %elifidn %1, ssse3
250     mova          m5, [pb_revwords]
251     ALIGN 16
252 %endif
253 .loop:
254 %if %2
255     ; This version expands 16-bit to 32-bit, multiplies by the window,
256     ; adds 16384 for rounding, right shifts 15, then repacks back to words to
257     ; save to the output. The window is reversed for the second half.
258     mova          m3, [windowq+offset2q]
259     mova          m4, [ inputq+offset2q]
260     pxor          m0, m0
261     punpcklwd     m0, m3
262     punpcklwd     m1, m4
263     pmaddwd       m0, m1
264     paddd         m0, m5
265     psrad         m0, 15
266     pxor          m2, m2
267     punpckhwd     m2, m3
268     punpckhwd     m1, m4
269     pmaddwd       m2, m1
270     paddd         m2, m5
271     psrad         m2, 15
272     packssdw      m0, m2
273     mova  [outputq+offset2q], m0
274     REVERSE_WORDS m3
275     mova          m4, [ inputq+offsetq]
276     pxor          m0, m0
277     punpcklwd     m0, m3
278     punpcklwd     m1, m4
279     pmaddwd       m0, m1
280     paddd         m0, m5
281     psrad         m0, 15
282     pxor          m2, m2
283     punpckhwd     m2, m3
284     punpckhwd     m1, m4
285     pmaddwd       m2, m1
286     paddd         m2, m5
287     psrad         m2, 15
288     packssdw      m0, m2
289     mova  [outputq+offsetq], m0
290 %elif %3
291     ; This version does the 16x16->16 multiplication in-place without expanding
292     ; to 32-bit. The ssse3 version is bit-identical.
293     mova          m0, [windowq+offset2q]
294     mova          m1, [ inputq+offset2q]
295     pmulhrsw      m1, m0
296     REVERSE_WORDS m0, m5
297     pmulhrsw      m0, [ inputq+offsetq ]
298     mova  [outputq+offset2q], m1
299     mova  [outputq+offsetq ], m0
300 %else
301     ; This version does the 16x16->16 multiplication in-place without expanding
302     ; to 32-bit. The mmxext and sse2 versions do not use rounding, and
303     ; therefore are not bit-identical to the C version.
304     mova          m0, [windowq+offset2q]
305     mova          m1, [ inputq+offset2q]
306     mova          m2, [ inputq+offsetq ]
307     MUL16FIXED    m1, m0, m3
308     REVERSE_WORDS m0
309     MUL16FIXED    m2, m0, m3
310     mova  [outputq+offset2q], m1
311     mova  [outputq+offsetq ], m2
312 %endif
313     add      offsetd, mmsize
314     sub     offset2d, mmsize
315     jae .loop
316     REP_RET
317 %endmacro
318
319 INIT_MMX
320 %define REVERSE_WORDS REVERSE_WORDS_MMXEXT
321 %define MUL16FIXED MUL16FIXED_MMXEXT
322 APPLY_WINDOW_INT16 mmxext,     0, 0
323 APPLY_WINDOW_INT16 mmxext_ba,  1, 0
324 INIT_XMM
325 %define REVERSE_WORDS REVERSE_WORDS_SSE2
326 APPLY_WINDOW_INT16 sse2,       0, 0
327 APPLY_WINDOW_INT16 sse2_ba,    1, 0
328 APPLY_WINDOW_INT16 ssse3_atom, 0, 1
329 %define REVERSE_WORDS REVERSE_WORDS_SSSE3
330 APPLY_WINDOW_INT16 ssse3,      0, 1
331
332
333 ; void add_hfyu_median_prediction_mmx2(uint8_t *dst, const uint8_t *top, const uint8_t *diff, int w, int *left, int *left_top)
334 cglobal add_hfyu_median_prediction_mmx2, 6,6,0, dst, top, diff, w, left, left_top
335     movq    mm0, [topq]
336     movq    mm2, mm0
337     movd    mm4, [left_topq]
338     psllq   mm2, 8
339     movq    mm1, mm0
340     por     mm4, mm2
341     movd    mm3, [leftq]
342     psubb   mm0, mm4 ; t-tl
343     add    dstq, wq
344     add    topq, wq
345     add   diffq, wq
346     neg      wq
347     jmp .skip
348 .loop:
349     movq    mm4, [topq+wq]
350     movq    mm0, mm4
351     psllq   mm4, 8
352     por     mm4, mm1
353     movq    mm1, mm0 ; t
354     psubb   mm0, mm4 ; t-tl
355 .skip:
356     movq    mm2, [diffq+wq]
357 %assign i 0
358 %rep 8
359     movq    mm4, mm0
360     paddb   mm4, mm3 ; t-tl+l
361     movq    mm5, mm3
362     pmaxub  mm3, mm1
363     pminub  mm5, mm1
364     pminub  mm3, mm4
365     pmaxub  mm3, mm5 ; median
366     paddb   mm3, mm2 ; +residual
367 %if i==0
368     movq    mm7, mm3
369     psllq   mm7, 56
370 %else
371     movq    mm6, mm3
372     psrlq   mm7, 8
373     psllq   mm6, 56
374     por     mm7, mm6
375 %endif
376 %if i<7
377     psrlq   mm0, 8
378     psrlq   mm1, 8
379     psrlq   mm2, 8
380 %endif
381 %assign i i+1
382 %endrep
383     movq [dstq+wq], mm7
384     add      wq, 8
385     jl .loop
386     movzx   r2d, byte [dstq-1]
387     mov [leftq], r2d
388     movzx   r2d, byte [topq-1]
389     mov [left_topq], r2d
390     RET
391
392
393 %macro ADD_HFYU_LEFT_LOOP 1 ; %1 = is_aligned
394     add     srcq, wq
395     add     dstq, wq
396     neg     wq
397 %%.loop:
398     mova    m1, [srcq+wq]
399     mova    m2, m1
400     psllw   m1, 8
401     paddb   m1, m2
402     mova    m2, m1
403     pshufb  m1, m3
404     paddb   m1, m2
405     pshufb  m0, m5
406     mova    m2, m1
407     pshufb  m1, m4
408     paddb   m1, m2
409 %if mmsize == 16
410     mova    m2, m1
411     pshufb  m1, m6
412     paddb   m1, m2
413 %endif
414     paddb   m0, m1
415 %if %1
416     mova    [dstq+wq], m0
417 %else
418     movq    [dstq+wq], m0
419     movhps  [dstq+wq+8], m0
420 %endif
421     add     wq, mmsize
422     jl %%.loop
423     mov     eax, mmsize-1
424     sub     eax, wd
425     movd    m1, eax
426     pshufb  m0, m1
427     movd    eax, m0
428     RET
429 %endmacro
430
431 ; int add_hfyu_left_prediction(uint8_t *dst, const uint8_t *src, int w, int left)
432 INIT_MMX
433 cglobal add_hfyu_left_prediction_ssse3, 3,3,7, dst, src, w, left
434 .skip_prologue:
435     mova    m5, [pb_7]
436     mova    m4, [pb_zzzz3333zzzzbbbb]
437     mova    m3, [pb_zz11zz55zz99zzdd]
438     movd    m0, leftm
439     psllq   m0, 56
440     ADD_HFYU_LEFT_LOOP 1
441
442 INIT_XMM
443 cglobal add_hfyu_left_prediction_sse4, 3,3,7, dst, src, w, left
444     mova    m5, [pb_f]
445     mova    m6, [pb_zzzzzzzz77777777]
446     mova    m4, [pb_zzzz3333zzzzbbbb]
447     mova    m3, [pb_zz11zz55zz99zzdd]
448     movd    m0, leftm
449     pslldq  m0, 15
450     test    srcq, 15
451     jnz add_hfyu_left_prediction_ssse3.skip_prologue
452     test    dstq, 15
453     jnz .unaligned
454     ADD_HFYU_LEFT_LOOP 1
455 .unaligned:
456     ADD_HFYU_LEFT_LOOP 0
457
458
459 ; float scalarproduct_float_sse(const float *v1, const float *v2, int len)
460 cglobal scalarproduct_float_sse, 3,3,2, v1, v2, offset
461     neg offsetq
462     shl offsetq, 2
463     sub v1q, offsetq
464     sub v2q, offsetq
465     xorps xmm0, xmm0
466     .loop:
467         movaps   xmm1, [v1q+offsetq]
468         mulps    xmm1, [v2q+offsetq]
469         addps    xmm0, xmm1
470         add      offsetq, 16
471         js       .loop
472     movhlps xmm1, xmm0
473     addps   xmm0, xmm1
474     movss   xmm1, xmm0
475     shufps  xmm0, xmm0, 1
476     addss   xmm0, xmm1
477 %ifndef ARCH_X86_64
478     movd    r0m,  xmm0
479     fld     dword r0m
480 %endif
481     RET
482
483 ; extern void ff_emu_edge_core(uint8_t *buf, const uint8_t *src, x86_reg linesize,
484 ;                              x86_reg start_y, x86_reg end_y, x86_reg block_h,
485 ;                              x86_reg start_x, x86_reg end_x, x86_reg block_w);
486 ;
487 ; The actual function itself is below. It basically wraps a very simple
488 ; w = end_x - start_x
489 ; if (w) {
490 ;   if (w > 22) {
491 ;     jump to the slow loop functions
492 ;   } else {
493 ;     jump to the fast loop functions
494 ;   }
495 ; }
496 ;
497 ; ... and then the same for left/right extend also. See below for loop
498 ; function implementations. Fast are fixed-width, slow is variable-width
499
500 %macro EMU_EDGE_FUNC 1
501 %ifdef ARCH_X86_64
502 %define w_reg r10
503 cglobal emu_edge_core_%1, 6, 7, 1
504     mov        r11, r5          ; save block_h
505 %else
506 %define w_reg r6
507 cglobal emu_edge_core_%1, 2, 7, 0
508     mov         r4, r4m         ; end_y
509     mov         r5, r5m         ; block_h
510 %endif
511
512     ; start with vertical extend (top/bottom) and body pixel copy
513     mov      w_reg, r7m
514     sub      w_reg, r6m         ; w = start_x - end_x
515     sub         r5, r4
516 %ifdef ARCH_X86_64
517     sub         r4, r3
518 %else
519     sub         r4, dword r3m
520 %endif
521     cmp      w_reg, 22
522     jg .slow_v_extend_loop
523 %ifdef ARCH_X86_32
524     mov         r2, r2m         ; linesize
525 %endif
526     sal      w_reg, 7           ; w * 128
527 %ifdef PIC
528     lea        rax, [.emuedge_v_extend_1 - (.emuedge_v_extend_2 - .emuedge_v_extend_1)]
529     add      w_reg, rax
530 %else
531     lea      w_reg, [.emuedge_v_extend_1 - (.emuedge_v_extend_2 - .emuedge_v_extend_1)+w_reg]
532 %endif
533     call     w_reg              ; fast top extend, body copy and bottom extend
534 .v_extend_end:
535
536     ; horizontal extend (left/right)
537     mov      w_reg, r6m         ; start_x
538     sub         r0, w_reg
539 %ifdef ARCH_X86_64
540     mov         r3, r0          ; backup of buf+block_h*linesize
541     mov         r5, r11
542 %else
543     mov        r0m, r0          ; backup of buf+block_h*linesize
544     mov         r5, r5m
545 %endif
546     test     w_reg, w_reg
547     jz .right_extend
548     cmp      w_reg, 22
549     jg .slow_left_extend_loop
550     mov         r1, w_reg
551     dec      w_reg
552     ; FIXME we can do a if size == 1 here if that makes any speed difference, test me
553     sar      w_reg, 1
554     sal      w_reg, 6
555     ; r0=buf+block_h*linesize,r10(64)/r6(32)=start_x offset for funcs
556     ; r6(rax)/r3(ebx)=val,r2=linesize,r1=start_x,r5=block_h
557 %ifdef PIC
558     lea        rax, [.emuedge_extend_left_2]
559     add      w_reg, rax
560 %else
561     lea      w_reg, [.emuedge_extend_left_2+w_reg]
562 %endif
563     call     w_reg
564
565     ; now r3(64)/r0(32)=buf,r2=linesize,r11/r5=block_h,r6/r3=val, r10/r6=end_x, r1=block_w
566 .right_extend:
567 %ifdef ARCH_X86_32
568     mov         r0, r0m
569     mov         r5, r5m
570 %endif
571     mov      w_reg, r7m         ; end_x
572     mov         r1, r8m         ; block_w
573     mov         r4, r1
574     sub         r1, w_reg
575     jz .h_extend_end            ; if (end_x == block_w) goto h_extend_end
576     cmp         r1, 22
577     jg .slow_right_extend_loop
578     dec         r1
579     ; FIXME we can do a if size == 1 here if that makes any speed difference, test me
580     sar         r1, 1
581     sal         r1, 6
582 %ifdef PIC
583     lea        rax, [.emuedge_extend_right_2]
584     add         r1, rax
585 %else
586     lea         r1, [.emuedge_extend_right_2+r1]
587 %endif
588     call        r1
589 .h_extend_end:
590     RET
591
592 %ifdef ARCH_X86_64
593 %define vall  al
594 %define valh  ah
595 %define valw  ax
596 %define valw2 r10w
597 %define valw3 r3w
598 %ifdef WIN64
599 %define valw4 r4w
600 %else ; unix64
601 %define valw4 r3w
602 %endif
603 %define vald eax
604 %else
605 %define vall  bl
606 %define valh  bh
607 %define valw  bx
608 %define valw2 r6w
609 %define valw3 valw2
610 %define valw4 valw3
611 %define vald ebx
612 %define stack_offset 0x14
613 %endif
614
615 %endmacro
616
617 ; macro to read/write a horizontal number of pixels (%2) to/from registers
618 ; on x86-64, - fills xmm0-15 for consecutive sets of 16 pixels
619 ;            - if (%2 & 15 == 8) fills the last 8 bytes into rax
620 ;            - else if (%2 & 8)  fills 8 bytes into mm0
621 ;            - if (%2 & 7 == 4)  fills the last 4 bytes into rax
622 ;            - else if (%2 & 4)  fills 4 bytes into mm0-1
623 ;            - if (%2 & 3 == 3)  fills 2 bytes into r10/r3, and 1 into eax
624 ;              (note that we're using r3 for body/bottom because it's a shorter
625 ;               opcode, and then the loop fits in 128 bytes)
626 ;            - else              fills remaining bytes into rax
627 ; on x86-32, - fills mm0-7 for consecutive sets of 8 pixels
628 ;            - if (%2 & 7 == 4)  fills 4 bytes into ebx
629 ;            - else if (%2 & 4)  fills 4 bytes into mm0-7
630 ;            - if (%2 & 3 == 3)  fills 2 bytes into r6, and 1 into ebx
631 ;            - else              fills remaining bytes into ebx
632 ; writing data out is in the same way
633 %macro READ_NUM_BYTES 3
634 %assign %%src_off 0 ; offset in source buffer
635 %assign %%smidx   0 ; mmx register idx
636 %assign %%sxidx   0 ; xmm register idx
637
638 %ifnidn %3, mmx
639 %rep %2/16
640     movdqu xmm %+ %%sxidx, [r1+%%src_off]
641 %assign %%src_off %%src_off+16
642 %assign %%sxidx   %%sxidx+1
643 %endrep ; %2/16
644 %endif ; !mmx
645
646 %ifdef ARCH_X86_64
647 %if (%2-%%src_off) == 8
648     mov           rax, [r1+%%src_off]
649 %assign %%src_off %%src_off+8
650 %endif ; (%2-%%src_off) == 8
651 %endif ; x86-64
652
653 %rep (%2-%%src_off)/8
654     movq    mm %+ %%smidx, [r1+%%src_off]
655 %assign %%src_off %%src_off+8
656 %assign %%smidx   %%smidx+1
657 %endrep ; (%2-%%dst_off)/8
658
659 %if (%2-%%src_off) == 4
660     mov          vald, [r1+%%src_off]
661 %elif (%2-%%src_off) & 4
662     movd    mm %+ %%smidx, [r1+%%src_off]
663 %assign %%src_off %%src_off+4
664 %endif ; (%2-%%src_off) ==/& 4
665
666 %if (%2-%%src_off) == 1
667     mov          vall, [r1+%%src_off]
668 %elif (%2-%%src_off) == 2
669     mov          valw, [r1+%%src_off]
670 %elif (%2-%%src_off) == 3
671 %ifidn %1, top
672     mov         valw2, [r1+%%src_off]
673 %elifidn %1, body
674     mov         valw3, [r1+%%src_off]
675 %elifidn %1, bottom
676     mov         valw4, [r1+%%src_off]
677 %endif ; %1 ==/!= top
678     mov          vall, [r1+%%src_off+2]
679 %endif ; (%2-%%src_off) == 1/2/3
680 %endmacro ; READ_NUM_BYTES
681
682 %macro WRITE_NUM_BYTES 3
683 %assign %%dst_off 0 ; offset in destination buffer
684 %assign %%dmidx   0 ; mmx register idx
685 %assign %%dxidx   0 ; xmm register idx
686
687 %ifnidn %3, mmx
688 %rep %2/16
689     movdqu [r0+%%dst_off], xmm %+ %%dxidx
690 %assign %%dst_off %%dst_off+16
691 %assign %%dxidx   %%dxidx+1
692 %endrep ; %2/16
693 %endif
694
695 %ifdef ARCH_X86_64
696 %if (%2-%%dst_off) == 8
697     mov    [r0+%%dst_off], rax
698 %assign %%dst_off %%dst_off+8
699 %endif ; (%2-%%dst_off) == 8
700 %endif ; x86-64
701
702 %rep (%2-%%dst_off)/8
703     movq   [r0+%%dst_off], mm %+ %%dmidx
704 %assign %%dst_off %%dst_off+8
705 %assign %%dmidx   %%dmidx+1
706 %endrep ; (%2-%%dst_off)/8
707
708 %if (%2-%%dst_off) == 4
709     mov    [r0+%%dst_off], vald
710 %elif (%2-%%dst_off) & 4
711     movd   [r0+%%dst_off], mm %+ %%dmidx
712 %assign %%dst_off %%dst_off+4
713 %endif ; (%2-%%dst_off) ==/& 4
714
715 %if (%2-%%dst_off) == 1
716     mov    [r0+%%dst_off], vall
717 %elif (%2-%%dst_off) == 2
718     mov    [r0+%%dst_off], valw
719 %elif (%2-%%dst_off) == 3
720 %ifidn %1, top
721     mov    [r0+%%dst_off], valw2
722 %elifidn %1, body
723     mov    [r0+%%dst_off], valw3
724 %elifidn %1, bottom
725     mov    [r0+%%dst_off], valw4
726 %endif ; %1 ==/!= top
727     mov  [r0+%%dst_off+2], vall
728 %endif ; (%2-%%dst_off) == 1/2/3
729 %endmacro ; WRITE_NUM_BYTES
730
731 ; vertical top/bottom extend and body copy fast loops
732 ; these are function pointers to set-width line copy functions, i.e.
733 ; they read a fixed number of pixels into set registers, and write
734 ; those out into the destination buffer
735 ; r0=buf,r1=src,r2=linesize,r3(64)/r3m(32)=start_x,r4=end_y,r5=block_h
736 ; r6(eax/64)/r3(ebx/32)=val_reg
737 %macro VERTICAL_EXTEND 1
738 %assign %%n 1
739 %rep 22
740 ALIGN 128
741 .emuedge_v_extend_ %+ %%n:
742     ; extend pixels above body
743 %ifdef ARCH_X86_64
744     test           r3 , r3                   ; if (!start_y)
745     jz .emuedge_copy_body_ %+ %%n %+ _loop   ;   goto body
746 %else ; ARCH_X86_32
747     cmp      dword r3m, 0
748     je .emuedge_copy_body_ %+ %%n %+ _loop
749 %endif ; ARCH_X86_64/32
750     READ_NUM_BYTES  top,    %%n, %1          ; read bytes
751 .emuedge_extend_top_ %+ %%n %+ _loop:        ; do {
752     WRITE_NUM_BYTES top,    %%n, %1          ;   write bytes
753     add            r0 , r2                   ;   dst += linesize
754 %ifdef ARCH_X86_64
755     dec            r3d
756 %else ; ARCH_X86_32
757     dec      dword r3m
758 %endif ; ARCH_X86_64/32
759     jnz .emuedge_extend_top_ %+ %%n %+ _loop ; } while (--start_y)
760
761     ; copy body pixels
762 .emuedge_copy_body_ %+ %%n %+ _loop:         ; do {
763     READ_NUM_BYTES  body,   %%n, %1          ;   read bytes
764     WRITE_NUM_BYTES body,   %%n, %1          ;   write bytes
765     add            r0 , r2                   ;   dst += linesize
766     add            r1 , r2                   ;   src += linesize
767     dec            r4d
768     jnz .emuedge_copy_body_ %+ %%n %+ _loop  ; } while (--end_y)
769
770     ; copy bottom pixels
771     test           r5 , r5                   ; if (!block_h)
772     jz .emuedge_v_extend_end_ %+ %%n         ;   goto end
773     sub            r1 , r2                   ; src -= linesize
774     READ_NUM_BYTES  bottom, %%n, %1          ; read bytes
775 .emuedge_extend_bottom_ %+ %%n %+ _loop:     ; do {
776     WRITE_NUM_BYTES bottom, %%n, %1          ;   write bytes
777     add            r0 , r2                   ;   dst += linesize
778     dec            r5d
779     jnz .emuedge_extend_bottom_ %+ %%n %+ _loop ; } while (--block_h)
780
781 .emuedge_v_extend_end_ %+ %%n:
782 %ifdef ARCH_X86_64
783     ret
784 %else ; ARCH_X86_32
785     rep ret
786 %endif ; ARCH_X86_64/32
787 %assign %%n %%n+1
788 %endrep
789 %endmacro VERTICAL_EXTEND
790
791 ; left/right (horizontal) fast extend functions
792 ; these are essentially identical to the vertical extend ones above,
793 ; just left/right separated because number of pixels to extend is
794 ; obviously not the same on both sides.
795 ; for reading, pixels are placed in eax (x86-64) or ebx (x86-64) in the
796 ; lowest two bytes of the register (so val*0x0101), and are splatted
797 ; into each byte of mm0 as well if n_pixels >= 8
798
799 %macro READ_V_PIXEL 3
800     mov        vall, %2
801     mov        valh, vall
802 %if %1 >= 8
803     movd        mm0, vald
804 %ifidn %3, mmx
805     punpcklwd   mm0, mm0
806     punpckldq   mm0, mm0
807 %else ; !mmx
808     pshufw      mm0, mm0, 0
809 %endif ; mmx
810 %endif ; %1 >= 8
811 %endmacro
812
813 %macro WRITE_V_PIXEL 2
814 %assign %%dst_off 0
815 %rep %1/8
816     movq [%2+%%dst_off], mm0
817 %assign %%dst_off %%dst_off+8
818 %endrep
819 %if %1 & 4
820 %if %1 >= 8
821     movd [%2+%%dst_off], mm0
822 %else ; %1 < 8
823     mov  [%2+%%dst_off]  , valw
824     mov  [%2+%%dst_off+2], valw
825 %endif ; %1 >=/< 8
826 %assign %%dst_off %%dst_off+4
827 %endif ; %1 & 4
828 %if %1&2
829     mov  [%2+%%dst_off], valw
830 %endif ; %1 & 2
831 %endmacro
832
833 ; r0=buf+block_h*linesize, r1=start_x, r2=linesize, r5=block_h, r6/r3=val
834 %macro LEFT_EXTEND 1
835 %assign %%n 2
836 %rep 11
837 ALIGN 64
838 .emuedge_extend_left_ %+ %%n:          ; do {
839     sub         r0, r2                 ;   dst -= linesize
840     READ_V_PIXEL  %%n, [r0+r1], %1     ;   read pixels
841     WRITE_V_PIXEL %%n, r0              ;   write pixels
842     dec         r5
843     jnz .emuedge_extend_left_ %+ %%n   ; } while (--block_h)
844 %ifdef ARCH_X86_64
845     ret
846 %else ; ARCH_X86_32
847     rep ret
848 %endif ; ARCH_X86_64/32
849 %assign %%n %%n+2
850 %endrep
851 %endmacro ; LEFT_EXTEND
852
853 ; r3/r0=buf+block_h*linesize, r2=linesize, r11/r5=block_h, r0/r6=end_x, r6/r3=val
854 %macro RIGHT_EXTEND 1
855 %assign %%n 2
856 %rep 11
857 ALIGN 64
858 .emuedge_extend_right_ %+ %%n:          ; do {
859 %ifdef ARCH_X86_64
860     sub        r3, r2                   ;   dst -= linesize
861     READ_V_PIXEL  %%n, [r3+w_reg-1], %1 ;   read pixels
862     WRITE_V_PIXEL %%n, r3+r4-%%n        ;   write pixels
863     dec       r11
864 %else ; ARCH_X86_32
865     sub        r0, r2                   ;   dst -= linesize
866     READ_V_PIXEL  %%n, [r0+w_reg-1], %1 ;   read pixels
867     WRITE_V_PIXEL %%n, r0+r4-%%n        ;   write pixels
868     dec     r5
869 %endif ; ARCH_X86_64/32
870     jnz .emuedge_extend_right_ %+ %%n   ; } while (--block_h)
871 %ifdef ARCH_X86_64
872     ret
873 %else ; ARCH_X86_32
874     rep ret
875 %endif ; ARCH_X86_64/32
876 %assign %%n %%n+2
877 %endrep
878
879 %ifdef ARCH_X86_32
880 %define stack_offset 0x10
881 %endif
882 %endmacro ; RIGHT_EXTEND
883
884 ; below follow the "slow" copy/extend functions, these act on a non-fixed
885 ; width specified in a register, and run a loop to copy the full amount
886 ; of bytes. They are optimized for copying of large amounts of pixels per
887 ; line, so they unconditionally splat data into mm registers to copy 8
888 ; bytes per loop iteration. It could be considered to use xmm for x86-64
889 ; also, but I haven't optimized this as much (i.e. FIXME)
890 %macro V_COPY_NPX 4-5
891 %if %0 == 4
892     test     w_reg, %4
893     jz .%1_skip_%4_px
894 %else ; %0 == 5
895 .%1_%4_px_loop:
896 %endif
897     %3          %2, [r1+cnt_reg]
898     %3 [r0+cnt_reg], %2
899     add    cnt_reg, %4
900 %if %0 == 5
901     sub      w_reg, %4
902     test     w_reg, %5
903     jnz .%1_%4_px_loop
904 %endif
905 .%1_skip_%4_px:
906 %endmacro
907
908 %macro V_COPY_ROW 3
909 %ifidn %1, bottom
910     sub         r1, linesize
911 %endif
912 .%1_copy_loop:
913     xor    cnt_reg, cnt_reg
914 %ifidn %3, mmx
915 %define linesize r2m
916     V_COPY_NPX %1,  mm0, movq,    8, 0xFFFFFFF8
917 %else ; !mmx
918     V_COPY_NPX %1, xmm0, movdqu, 16, 0xFFFFFFF0
919 %ifdef ARCH_X86_64
920 %define linesize r2
921     V_COPY_NPX %1, rax , mov,     8
922 %else ; ARCH_X86_32
923 %define linesize r2m
924     V_COPY_NPX %1,  mm0, movq,    8
925 %endif ; ARCH_X86_64/32
926 %endif ; mmx
927     V_COPY_NPX %1, vald, mov,     4
928     V_COPY_NPX %1, valw, mov,     2
929     V_COPY_NPX %1, vall, mov,     1
930     mov      w_reg, cnt_reg
931 %ifidn %1, body
932     add         r1, linesize
933 %endif
934     add         r0, linesize
935     dec         %2
936     jnz .%1_copy_loop
937 %endmacro
938
939 %macro SLOW_V_EXTEND 1
940 .slow_v_extend_loop:
941 ; r0=buf,r1=src,r2(64)/r2m(32)=linesize,r3(64)/r3m(32)=start_x,r4=end_y,r5=block_h
942 ; r11(64)/r3(later-64)/r2(32)=cnt_reg,r6(64)/r3(32)=val_reg,r10(64)/r6(32)=w=end_x-start_x
943 %ifdef ARCH_X86_64
944     push       r11              ; save old value of block_h
945     test        r3, r3
946 %define cnt_reg r11
947     jz .do_body_copy            ; if (!start_y) goto do_body_copy
948     V_COPY_ROW top, r3, %1
949 %else
950     cmp  dword r3m, 0
951 %define cnt_reg r2
952     je .do_body_copy            ; if (!start_y) goto do_body_copy
953     V_COPY_ROW top, dword r3m, %1
954 %endif
955
956 .do_body_copy:
957     V_COPY_ROW body, r4, %1
958
959 %ifdef ARCH_X86_64
960     pop        r11              ; restore old value of block_h
961 %define cnt_reg r3
962 %endif
963     test        r5, r5
964 %ifdef ARCH_X86_64
965     jz .v_extend_end
966 %else
967     jz .skip_bottom_extend
968 %endif
969     V_COPY_ROW bottom, r5, %1
970 %ifdef ARCH_X86_32
971 .skip_bottom_extend:
972     mov         r2, r2m
973 %endif
974     jmp .v_extend_end
975 %endmacro
976
977 %macro SLOW_LEFT_EXTEND 1
978 .slow_left_extend_loop:
979 ; r0=buf+block_h*linesize,r2=linesize,r6(64)/r3(32)=val,r5=block_h,r4=cntr,r10/r6=start_x
980     mov         r4, 8
981     sub         r0, linesize
982     READ_V_PIXEL 8, [r0+w_reg], %1
983 .left_extend_8px_loop:
984     movq [r0+r4-8], mm0
985     add         r4, 8
986     cmp         r4, w_reg
987     jle .left_extend_8px_loop
988     sub         r4, 8
989     cmp         r4, w_reg
990     jge .left_extend_loop_end
991 .left_extend_2px_loop:
992     mov    [r0+r4], valw
993     add         r4, 2
994     cmp         r4, w_reg
995     jl .left_extend_2px_loop
996 .left_extend_loop_end:
997     dec         r5
998     jnz .slow_left_extend_loop
999 %ifdef ARCH_X86_32
1000     mov         r2, r2m
1001 %endif
1002     jmp .right_extend
1003 %endmacro
1004
1005 %macro SLOW_RIGHT_EXTEND 1
1006 .slow_right_extend_loop:
1007 ; r3(64)/r0(32)=buf+block_h*linesize,r2=linesize,r4=block_w,r11(64)/r5(32)=block_h,
1008 ; r10(64)/r6(32)=end_x,r6/r3=val,r1=cntr
1009 %ifdef ARCH_X86_64
1010 %define buf_reg r3
1011 %define bh_reg r11
1012 %else
1013 %define buf_reg r0
1014 %define bh_reg r5
1015 %endif
1016     lea         r1, [r4-8]
1017     sub    buf_reg, linesize
1018     READ_V_PIXEL 8, [buf_reg+w_reg-1], %1
1019 .right_extend_8px_loop:
1020     movq [buf_reg+r1], mm0
1021     sub         r1, 8
1022     cmp         r1, w_reg
1023     jge .right_extend_8px_loop
1024     add         r1, 8
1025     cmp         r1, w_reg
1026     je .right_extend_loop_end
1027 .right_extend_2px_loop:
1028     sub         r1, 2
1029     mov [buf_reg+r1], valw
1030     cmp         r1, w_reg
1031     jg .right_extend_2px_loop
1032 .right_extend_loop_end:
1033     dec         bh_reg
1034     jnz .slow_right_extend_loop
1035     jmp .h_extend_end
1036 %endmacro
1037
1038 %macro emu_edge 1
1039 EMU_EDGE_FUNC     %1
1040 VERTICAL_EXTEND   %1
1041 LEFT_EXTEND       %1
1042 RIGHT_EXTEND      %1
1043 SLOW_V_EXTEND     %1
1044 SLOW_LEFT_EXTEND  %1
1045 SLOW_RIGHT_EXTEND %1
1046 %endmacro
1047
1048 emu_edge sse
1049 %ifdef ARCH_X86_32
1050 emu_edge mmx
1051 %endif
1052
1053 ;-----------------------------------------------------------------------------
1054 ; void ff_vector_clip_int32(int32_t *dst, const int32_t *src, int32_t min,
1055 ;                           int32_t max, unsigned int len)
1056 ;-----------------------------------------------------------------------------
1057
1058 ; %1 = number of xmm registers used
1059 ; %2 = number of inline load/process/store loops per asm loop
1060 ; %3 = process 4*mmsize (%3=0) or 8*mmsize (%3=1) bytes per loop
1061 ; %4 = CLIPD function takes min/max as float instead of int (CLIPD_SSE2)
1062 ; %5 = suffix
1063 %macro VECTOR_CLIP_INT32 4-5
1064 cglobal vector_clip_int32%5, 5,5,%2, dst, src, min, max, len
1065 %if %4
1066     cvtsi2ss  m4, minm
1067     cvtsi2ss  m5, maxm
1068 %else
1069     movd      m4, minm
1070     movd      m5, maxm
1071 %endif
1072     SPLATD    m4
1073     SPLATD    m5
1074 .loop:
1075 %assign %%i 1
1076 %rep %2
1077     mova      m0,  [srcq+mmsize*0*%%i]
1078     mova      m1,  [srcq+mmsize*1*%%i]
1079     mova      m2,  [srcq+mmsize*2*%%i]
1080     mova      m3,  [srcq+mmsize*3*%%i]
1081 %if %3
1082     mova      m7,  [srcq+mmsize*4*%%i]
1083     mova      m8,  [srcq+mmsize*5*%%i]
1084     mova      m9,  [srcq+mmsize*6*%%i]
1085     mova      m10, [srcq+mmsize*7*%%i]
1086 %endif
1087     CLIPD  m0,  m4, m5, m6
1088     CLIPD  m1,  m4, m5, m6
1089     CLIPD  m2,  m4, m5, m6
1090     CLIPD  m3,  m4, m5, m6
1091 %if %3
1092     CLIPD  m7,  m4, m5, m6
1093     CLIPD  m8,  m4, m5, m6
1094     CLIPD  m9,  m4, m5, m6
1095     CLIPD  m10, m4, m5, m6
1096 %endif
1097     mova  [dstq+mmsize*0*%%i], m0
1098     mova  [dstq+mmsize*1*%%i], m1
1099     mova  [dstq+mmsize*2*%%i], m2
1100     mova  [dstq+mmsize*3*%%i], m3
1101 %if %3
1102     mova  [dstq+mmsize*4*%%i], m7
1103     mova  [dstq+mmsize*5*%%i], m8
1104     mova  [dstq+mmsize*6*%%i], m9
1105     mova  [dstq+mmsize*7*%%i], m10
1106 %endif
1107 %assign %%i %%i+1
1108 %endrep
1109     add     srcq, mmsize*4*(%2+%3)
1110     add     dstq, mmsize*4*(%2+%3)
1111     sub     lend, mmsize*(%2+%3)
1112     jg .loop
1113     REP_RET
1114 %endmacro
1115
1116 INIT_MMX mmx
1117 %define SPLATD SPLATD_MMX
1118 %define CLIPD CLIPD_MMX
1119 VECTOR_CLIP_INT32 0, 1, 0, 0
1120 INIT_XMM sse2
1121 %define SPLATD SPLATD_SSE2
1122 VECTOR_CLIP_INT32 6, 1, 0, 0, _int
1123 %define CLIPD CLIPD_SSE2
1124 VECTOR_CLIP_INT32 6, 2, 0, 1
1125 INIT_XMM sse4
1126 %define CLIPD CLIPD_SSE41
1127 %ifdef m8
1128 VECTOR_CLIP_INT32 11, 1, 1, 0
1129 %else
1130 VECTOR_CLIP_INT32 6, 1, 0, 0
1131 %endif
1132
1133 ;-----------------------------------------------------------------------------
1134 ; void ff_butterflies_float_interleave(float *dst, const float *src0,
1135 ;                                      const float *src1, int len);
1136 ;-----------------------------------------------------------------------------
1137
1138 %macro BUTTERFLIES_FLOAT_INTERLEAVE 0
1139 cglobal butterflies_float_interleave, 4,4,3, dst, src0, src1, len
1140 %ifdef ARCH_X86_64
1141     movsxd    lenq, lend
1142 %endif
1143     test      lenq, lenq
1144     jz .end
1145     shl       lenq, 2
1146     lea      src0q, [src0q +   lenq]
1147     lea      src1q, [src1q +   lenq]
1148     lea       dstq, [ dstq + 2*lenq]
1149     neg       lenq
1150 .loop:
1151     mova        m0, [src0q + lenq]
1152     mova        m1, [src1q + lenq]
1153     subps       m2, m0, m1
1154     addps       m0, m0, m1
1155     unpcklps    m1, m0, m2
1156     unpckhps    m0, m0, m2
1157 %if cpuflag(avx)
1158     vextractf128 [dstq + 2*lenq     ], m1, 0
1159     vextractf128 [dstq + 2*lenq + 16], m0, 0
1160     vextractf128 [dstq + 2*lenq + 32], m1, 1
1161     vextractf128 [dstq + 2*lenq + 48], m0, 1
1162 %else
1163     mova [dstq + 2*lenq         ], m1
1164     mova [dstq + 2*lenq + mmsize], m0
1165 %endif
1166     add       lenq, mmsize
1167     jl .loop
1168 %if mmsize == 32
1169     vzeroupper
1170     RET
1171 %endif
1172 .end:
1173     REP_RET
1174 %endmacro
1175
1176 INIT_XMM sse
1177 BUTTERFLIES_FLOAT_INTERLEAVE
1178 INIT_YMM avx
1179 BUTTERFLIES_FLOAT_INTERLEAVE