c574458a20639d90567627e99d105bd20d5d570f
[ffmpeg.git] / libavcodec / x86 / dsputil_mmx.c
1 /*
2  * MMX optimized DSP utils
3  * Copyright (c) 2000, 2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  *
22  * MMX optimization by Nick Kurshev <nickols_k@mail.ru>
23  */
24
25 #include "config.h"
26 #include "libavutil/avassert.h"
27 #include "libavutil/cpu.h"
28 #include "libavutil/x86/asm.h"
29 #include "libavcodec/pixels.h"
30 #include "libavcodec/videodsp.h"
31 #include "constants.h"
32 #include "diracdsp_mmx.h"
33 #include "dsputil_x86.h"
34 #include "fpel.h"
35 #include "inline_asm.h"
36
37 #if HAVE_INLINE_ASM
38
39 void ff_put_pixels_clamped_mmx(const int16_t *block, uint8_t *pixels,
40                                int line_size)
41 {
42     const int16_t *p;
43     uint8_t *pix;
44
45     /* read the pixels */
46     p   = block;
47     pix = pixels;
48     /* unrolled loop */
49     __asm__ volatile (
50         "movq      (%3), %%mm0          \n\t"
51         "movq     8(%3), %%mm1          \n\t"
52         "movq    16(%3), %%mm2          \n\t"
53         "movq    24(%3), %%mm3          \n\t"
54         "movq    32(%3), %%mm4          \n\t"
55         "movq    40(%3), %%mm5          \n\t"
56         "movq    48(%3), %%mm6          \n\t"
57         "movq    56(%3), %%mm7          \n\t"
58         "packuswb %%mm1, %%mm0          \n\t"
59         "packuswb %%mm3, %%mm2          \n\t"
60         "packuswb %%mm5, %%mm4          \n\t"
61         "packuswb %%mm7, %%mm6          \n\t"
62         "movq     %%mm0, (%0)           \n\t"
63         "movq     %%mm2, (%0, %1)       \n\t"
64         "movq     %%mm4, (%0, %1, 2)    \n\t"
65         "movq     %%mm6, (%0, %2)       \n\t"
66         :: "r" (pix), "r" ((x86_reg) line_size), "r" ((x86_reg) line_size * 3),
67            "r" (p)
68         : "memory");
69     pix += line_size * 4;
70     p   += 32;
71
72     // if here would be an exact copy of the code above
73     // compiler would generate some very strange code
74     // thus using "r"
75     __asm__ volatile (
76         "movq       (%3), %%mm0         \n\t"
77         "movq      8(%3), %%mm1         \n\t"
78         "movq     16(%3), %%mm2         \n\t"
79         "movq     24(%3), %%mm3         \n\t"
80         "movq     32(%3), %%mm4         \n\t"
81         "movq     40(%3), %%mm5         \n\t"
82         "movq     48(%3), %%mm6         \n\t"
83         "movq     56(%3), %%mm7         \n\t"
84         "packuswb  %%mm1, %%mm0         \n\t"
85         "packuswb  %%mm3, %%mm2         \n\t"
86         "packuswb  %%mm5, %%mm4         \n\t"
87         "packuswb  %%mm7, %%mm6         \n\t"
88         "movq      %%mm0, (%0)          \n\t"
89         "movq      %%mm2, (%0, %1)      \n\t"
90         "movq      %%mm4, (%0, %1, 2)   \n\t"
91         "movq      %%mm6, (%0, %2)      \n\t"
92         :: "r" (pix), "r" ((x86_reg) line_size), "r" ((x86_reg) line_size * 3),
93            "r" (p)
94         : "memory");
95 }
96
97 #define put_signed_pixels_clamped_mmx_half(off)             \
98     "movq          "#off"(%2), %%mm1        \n\t"           \
99     "movq     16 + "#off"(%2), %%mm2        \n\t"           \
100     "movq     32 + "#off"(%2), %%mm3        \n\t"           \
101     "movq     48 + "#off"(%2), %%mm4        \n\t"           \
102     "packsswb  8 + "#off"(%2), %%mm1        \n\t"           \
103     "packsswb 24 + "#off"(%2), %%mm2        \n\t"           \
104     "packsswb 40 + "#off"(%2), %%mm3        \n\t"           \
105     "packsswb 56 + "#off"(%2), %%mm4        \n\t"           \
106     "paddb              %%mm0, %%mm1        \n\t"           \
107     "paddb              %%mm0, %%mm2        \n\t"           \
108     "paddb              %%mm0, %%mm3        \n\t"           \
109     "paddb              %%mm0, %%mm4        \n\t"           \
110     "movq               %%mm1, (%0)         \n\t"           \
111     "movq               %%mm2, (%0, %3)     \n\t"           \
112     "movq               %%mm3, (%0, %3, 2)  \n\t"           \
113     "movq               %%mm4, (%0, %1)     \n\t"
114
115 void ff_put_signed_pixels_clamped_mmx(const int16_t *block, uint8_t *pixels,
116                                       int line_size)
117 {
118     x86_reg line_skip = line_size;
119     x86_reg line_skip3;
120
121     __asm__ volatile (
122         "movq "MANGLE(ff_pb_80)", %%mm0     \n\t"
123         "lea         (%3, %3, 2), %1        \n\t"
124         put_signed_pixels_clamped_mmx_half(0)
125         "lea         (%0, %3, 4), %0        \n\t"
126         put_signed_pixels_clamped_mmx_half(64)
127         : "+&r" (pixels), "=&r" (line_skip3)
128         : "r" (block), "r" (line_skip)
129           NAMED_CONSTRAINTS_ADD(ff_pb_80)
130         : "memory");
131 }
132
133 void ff_add_pixels_clamped_mmx(const int16_t *block, uint8_t *pixels,
134                                int line_size)
135 {
136     const int16_t *p;
137     uint8_t *pix;
138     int i;
139
140     /* read the pixels */
141     p   = block;
142     pix = pixels;
143     MOVQ_ZERO(mm7);
144     i = 4;
145     do {
146         __asm__ volatile (
147             "movq        (%2), %%mm0    \n\t"
148             "movq       8(%2), %%mm1    \n\t"
149             "movq      16(%2), %%mm2    \n\t"
150             "movq      24(%2), %%mm3    \n\t"
151             "movq          %0, %%mm4    \n\t"
152             "movq          %1, %%mm6    \n\t"
153             "movq       %%mm4, %%mm5    \n\t"
154             "punpcklbw  %%mm7, %%mm4    \n\t"
155             "punpckhbw  %%mm7, %%mm5    \n\t"
156             "paddsw     %%mm4, %%mm0    \n\t"
157             "paddsw     %%mm5, %%mm1    \n\t"
158             "movq       %%mm6, %%mm5    \n\t"
159             "punpcklbw  %%mm7, %%mm6    \n\t"
160             "punpckhbw  %%mm7, %%mm5    \n\t"
161             "paddsw     %%mm6, %%mm2    \n\t"
162             "paddsw     %%mm5, %%mm3    \n\t"
163             "packuswb   %%mm1, %%mm0    \n\t"
164             "packuswb   %%mm3, %%mm2    \n\t"
165             "movq       %%mm0, %0       \n\t"
166             "movq       %%mm2, %1       \n\t"
167             : "+m" (*pix), "+m" (*(pix + line_size))
168             : "r" (p)
169             : "memory");
170         pix += line_size * 2;
171         p   += 16;
172     } while (--i);
173 }
174
175 #define CLEAR_BLOCKS(name, n)                           \
176 void name(int16_t *blocks)                              \
177 {                                                       \
178     __asm__ volatile (                                  \
179         "pxor %%mm7, %%mm7              \n\t"           \
180         "mov     %1,        %%"REG_a"   \n\t"           \
181         "1:                             \n\t"           \
182         "movq %%mm7,   (%0, %%"REG_a")  \n\t"           \
183         "movq %%mm7,  8(%0, %%"REG_a")  \n\t"           \
184         "movq %%mm7, 16(%0, %%"REG_a")  \n\t"           \
185         "movq %%mm7, 24(%0, %%"REG_a")  \n\t"           \
186         "add    $32, %%"REG_a"          \n\t"           \
187         "js      1b                     \n\t"           \
188         :: "r"(((uint8_t *) blocks) + 128 * n),         \
189            "i"(-128 * n)                                \
190         : "%"REG_a);                                    \
191 }
192 CLEAR_BLOCKS(ff_clear_blocks_mmx, 6)
193 CLEAR_BLOCKS(ff_clear_block_mmx, 1)
194
195 void ff_clear_block_sse(int16_t *block)
196 {
197     __asm__ volatile (
198         "xorps  %%xmm0, %%xmm0          \n"
199         "movaps %%xmm0,    (%0)         \n"
200         "movaps %%xmm0,  16(%0)         \n"
201         "movaps %%xmm0,  32(%0)         \n"
202         "movaps %%xmm0,  48(%0)         \n"
203         "movaps %%xmm0,  64(%0)         \n"
204         "movaps %%xmm0,  80(%0)         \n"
205         "movaps %%xmm0,  96(%0)         \n"
206         "movaps %%xmm0, 112(%0)         \n"
207         :: "r" (block)
208         : "memory");
209 }
210
211 void ff_clear_blocks_sse(int16_t *blocks)
212 {
213     __asm__ volatile (
214         "xorps  %%xmm0, %%xmm0              \n"
215         "mov        %1,         %%"REG_a"   \n"
216         "1:                                 \n"
217         "movaps %%xmm0,    (%0, %%"REG_a")  \n"
218         "movaps %%xmm0,  16(%0, %%"REG_a")  \n"
219         "movaps %%xmm0,  32(%0, %%"REG_a")  \n"
220         "movaps %%xmm0,  48(%0, %%"REG_a")  \n"
221         "movaps %%xmm0,  64(%0, %%"REG_a")  \n"
222         "movaps %%xmm0,  80(%0, %%"REG_a")  \n"
223         "movaps %%xmm0,  96(%0, %%"REG_a")  \n"
224         "movaps %%xmm0, 112(%0, %%"REG_a")  \n"
225         "add      $128,         %%"REG_a"   \n"
226         "js         1b                      \n"
227         :: "r"(((uint8_t *) blocks) + 128 * 6), "i"(-128 * 6)
228         : "%"REG_a);
229 }
230
231 void ff_add_bytes_mmx(uint8_t *dst, uint8_t *src, int w)
232 {
233     x86_reg i = 0;
234
235     __asm__ volatile (
236         "jmp          2f                \n\t"
237         "1:                             \n\t"
238         "movq   (%1, %0), %%mm0         \n\t"
239         "movq   (%2, %0), %%mm1         \n\t"
240         "paddb     %%mm0, %%mm1         \n\t"
241         "movq      %%mm1, (%2, %0)      \n\t"
242         "movq  8(%1, %0), %%mm0         \n\t"
243         "movq  8(%2, %0), %%mm1         \n\t"
244         "paddb     %%mm0, %%mm1         \n\t"
245         "movq      %%mm1, 8(%2, %0)     \n\t"
246         "add         $16, %0            \n\t"
247         "2:                             \n\t"
248         "cmp          %3, %0            \n\t"
249         "js           1b                \n\t"
250         : "+r" (i)
251         : "r" (src), "r" (dst), "r" ((x86_reg) w - 15));
252
253     for (; i < w; i++)
254         dst[i + 0] += src[i + 0];
255 }
256
257 /* Draw the edges of width 'w' of an image of size width, height
258  * this MMX version can only handle w == 8 || w == 16. */
259 void ff_draw_edges_mmx(uint8_t *buf, int wrap, int width, int height,
260                        int w, int h, int sides)
261 {
262     uint8_t *ptr, *last_line;
263     int i;
264
265     last_line = buf + (height - 1) * wrap;
266     /* left and right */
267     ptr = buf;
268     if (w == 8) {
269         __asm__ volatile (
270             "1:                             \n\t"
271             "movd            (%0), %%mm0    \n\t"
272             "punpcklbw      %%mm0, %%mm0    \n\t"
273             "punpcklwd      %%mm0, %%mm0    \n\t"
274             "punpckldq      %%mm0, %%mm0    \n\t"
275             "movq           %%mm0, -8(%0)   \n\t"
276             "movq      -8(%0, %2), %%mm1    \n\t"
277             "punpckhbw      %%mm1, %%mm1    \n\t"
278             "punpckhwd      %%mm1, %%mm1    \n\t"
279             "punpckhdq      %%mm1, %%mm1    \n\t"
280             "movq           %%mm1, (%0, %2) \n\t"
281             "add               %1, %0       \n\t"
282             "cmp               %3, %0       \n\t"
283             "jb                1b           \n\t"
284             : "+r" (ptr)
285             : "r" ((x86_reg) wrap), "r" ((x86_reg) width),
286               "r" (ptr + wrap * height));
287     } else if (w == 16) {
288         __asm__ volatile (
289             "1:                                 \n\t"
290             "movd            (%0), %%mm0        \n\t"
291             "punpcklbw      %%mm0, %%mm0        \n\t"
292             "punpcklwd      %%mm0, %%mm0        \n\t"
293             "punpckldq      %%mm0, %%mm0        \n\t"
294             "movq           %%mm0, -8(%0)       \n\t"
295             "movq           %%mm0, -16(%0)      \n\t"
296             "movq      -8(%0, %2), %%mm1        \n\t"
297             "punpckhbw      %%mm1, %%mm1        \n\t"
298             "punpckhwd      %%mm1, %%mm1        \n\t"
299             "punpckhdq      %%mm1, %%mm1        \n\t"
300             "movq           %%mm1,  (%0, %2)    \n\t"
301             "movq           %%mm1, 8(%0, %2)    \n\t"
302             "add               %1, %0           \n\t"
303             "cmp               %3, %0           \n\t"
304             "jb                1b               \n\t"
305             : "+r"(ptr)
306             : "r"((x86_reg)wrap), "r"((x86_reg)width), "r"(ptr + wrap * height)
307             );
308     } else {
309         av_assert1(w == 4);
310         __asm__ volatile (
311             "1:                             \n\t"
312             "movd            (%0), %%mm0    \n\t"
313             "punpcklbw      %%mm0, %%mm0    \n\t"
314             "punpcklwd      %%mm0, %%mm0    \n\t"
315             "movd           %%mm0, -4(%0)   \n\t"
316             "movd      -4(%0, %2), %%mm1    \n\t"
317             "punpcklbw      %%mm1, %%mm1    \n\t"
318             "punpckhwd      %%mm1, %%mm1    \n\t"
319             "punpckhdq      %%mm1, %%mm1    \n\t"
320             "movd           %%mm1, (%0, %2) \n\t"
321             "add               %1, %0       \n\t"
322             "cmp               %3, %0       \n\t"
323             "jb                1b           \n\t"
324             : "+r" (ptr)
325             : "r" ((x86_reg) wrap), "r" ((x86_reg) width),
326               "r" (ptr + wrap * height));
327     }
328
329     /* top and bottom (and hopefully also the corners) */
330     if (sides & EDGE_TOP) {
331         for (i = 0; i < h; i += 4) {
332             ptr = buf - (i + 1) * wrap - w;
333             __asm__ volatile (
334                 "1:                             \n\t"
335                 "movq (%1, %0), %%mm0           \n\t"
336                 "movq    %%mm0, (%0)            \n\t"
337                 "movq    %%mm0, (%0, %2)        \n\t"
338                 "movq    %%mm0, (%0, %2, 2)     \n\t"
339                 "movq    %%mm0, (%0, %3)        \n\t"
340                 "add        $8, %0              \n\t"
341                 "cmp        %4, %0              \n\t"
342                 "jb         1b                  \n\t"
343                 : "+r" (ptr)
344                 : "r" ((x86_reg) buf - (x86_reg) ptr - w),
345                   "r" ((x86_reg) - wrap), "r" ((x86_reg) - wrap * 3),
346                   "r" (ptr + width + 2 * w));
347         }
348     }
349
350     if (sides & EDGE_BOTTOM) {
351         for (i = 0; i < h; i += 4) {
352             ptr = last_line + (i + 1) * wrap - w;
353             __asm__ volatile (
354                 "1:                             \n\t"
355                 "movq (%1, %0), %%mm0           \n\t"
356                 "movq    %%mm0, (%0)            \n\t"
357                 "movq    %%mm0, (%0, %2)        \n\t"
358                 "movq    %%mm0, (%0, %2, 2)     \n\t"
359                 "movq    %%mm0, (%0, %3)        \n\t"
360                 "add        $8, %0              \n\t"
361                 "cmp        %4, %0              \n\t"
362                 "jb         1b                  \n\t"
363                 : "+r" (ptr)
364                 : "r" ((x86_reg) last_line - (x86_reg) ptr - w),
365                   "r" ((x86_reg) wrap), "r" ((x86_reg) wrap * 3),
366                   "r" (ptr + width + 2 * w));
367         }
368     }
369 }
370
371 typedef void emulated_edge_mc_func(uint8_t *dst, const uint8_t *src,
372                                    ptrdiff_t dst_stride,
373                                    ptrdiff_t src_linesize,
374                                    int block_w, int block_h,
375                                    int src_x, int src_y, int w, int h);
376
377 static av_always_inline void gmc(uint8_t *dst, uint8_t *src,
378                                  int stride, int h, int ox, int oy,
379                                  int dxx, int dxy, int dyx, int dyy,
380                                  int shift, int r, int width, int height,
381                                  emulated_edge_mc_func *emu_edge_fn)
382 {
383     const int w    = 8;
384     const int ix   = ox  >> (16 + shift);
385     const int iy   = oy  >> (16 + shift);
386     const int oxs  = ox  >> 4;
387     const int oys  = oy  >> 4;
388     const int dxxs = dxx >> 4;
389     const int dxys = dxy >> 4;
390     const int dyxs = dyx >> 4;
391     const int dyys = dyy >> 4;
392     const uint16_t r4[4]   = { r, r, r, r };
393     const uint16_t dxy4[4] = { dxys, dxys, dxys, dxys };
394     const uint16_t dyy4[4] = { dyys, dyys, dyys, dyys };
395     const uint64_t shift2  = 2 * shift;
396 #define MAX_STRIDE 4096U
397 #define MAX_H 8U
398     uint8_t edge_buf[(MAX_H + 1) * MAX_STRIDE];
399     int x, y;
400
401     const int dxw = (dxx - (1 << (16 + shift))) * (w - 1);
402     const int dyh = (dyy - (1 << (16 + shift))) * (h - 1);
403     const int dxh = dxy * (h - 1);
404     const int dyw = dyx * (w - 1);
405     int need_emu  =  (unsigned) ix >= width  - w ||
406                      (unsigned) iy >= height - h;
407
408     if ( // non-constant fullpel offset (3% of blocks)
409         ((ox ^ (ox + dxw)) | (ox ^ (ox + dxh)) | (ox ^ (ox + dxw + dxh)) |
410          (oy ^ (oy + dyw)) | (oy ^ (oy + dyh)) | (oy ^ (oy + dyw + dyh))) >> (16 + shift) ||
411         // uses more than 16 bits of subpel mv (only at huge resolution)
412         (dxx | dxy | dyx | dyy) & 15 ||
413         (need_emu && (h > MAX_H || stride > MAX_STRIDE))) {
414         // FIXME could still use mmx for some of the rows
415         ff_gmc_c(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy,
416                  shift, r, width, height);
417         return;
418     }
419
420     src += ix + iy * stride;
421     if (need_emu) {
422         emu_edge_fn(edge_buf, src, stride, stride, w + 1, h + 1, ix, iy, width, height);
423         src = edge_buf;
424     }
425
426     __asm__ volatile (
427         "movd         %0, %%mm6         \n\t"
428         "pxor      %%mm7, %%mm7         \n\t"
429         "punpcklwd %%mm6, %%mm6         \n\t"
430         "punpcklwd %%mm6, %%mm6         \n\t"
431         :: "r" (1 << shift));
432
433     for (x = 0; x < w; x += 4) {
434         uint16_t dx4[4] = { oxs - dxys + dxxs * (x + 0),
435                             oxs - dxys + dxxs * (x + 1),
436                             oxs - dxys + dxxs * (x + 2),
437                             oxs - dxys + dxxs * (x + 3) };
438         uint16_t dy4[4] = { oys - dyys + dyxs * (x + 0),
439                             oys - dyys + dyxs * (x + 1),
440                             oys - dyys + dyxs * (x + 2),
441                             oys - dyys + dyxs * (x + 3) };
442
443         for (y = 0; y < h; y++) {
444             __asm__ volatile (
445                 "movq      %0, %%mm4    \n\t"
446                 "movq      %1, %%mm5    \n\t"
447                 "paddw     %2, %%mm4    \n\t"
448                 "paddw     %3, %%mm5    \n\t"
449                 "movq   %%mm4, %0       \n\t"
450                 "movq   %%mm5, %1       \n\t"
451                 "psrlw    $12, %%mm4    \n\t"
452                 "psrlw    $12, %%mm5    \n\t"
453                 : "+m" (*dx4), "+m" (*dy4)
454                 : "m" (*dxy4), "m" (*dyy4));
455
456             __asm__ volatile (
457                 "movq      %%mm6, %%mm2 \n\t"
458                 "movq      %%mm6, %%mm1 \n\t"
459                 "psubw     %%mm4, %%mm2 \n\t"
460                 "psubw     %%mm5, %%mm1 \n\t"
461                 "movq      %%mm2, %%mm0 \n\t"
462                 "movq      %%mm4, %%mm3 \n\t"
463                 "pmullw    %%mm1, %%mm0 \n\t" // (s - dx) * (s - dy)
464                 "pmullw    %%mm5, %%mm3 \n\t" // dx * dy
465                 "pmullw    %%mm5, %%mm2 \n\t" // (s - dx) * dy
466                 "pmullw    %%mm4, %%mm1 \n\t" // dx * (s - dy)
467
468                 "movd         %4, %%mm5 \n\t"
469                 "movd         %3, %%mm4 \n\t"
470                 "punpcklbw %%mm7, %%mm5 \n\t"
471                 "punpcklbw %%mm7, %%mm4 \n\t"
472                 "pmullw    %%mm5, %%mm3 \n\t" // src[1, 1] * dx * dy
473                 "pmullw    %%mm4, %%mm2 \n\t" // src[0, 1] * (s - dx) * dy
474
475                 "movd         %2, %%mm5 \n\t"
476                 "movd         %1, %%mm4 \n\t"
477                 "punpcklbw %%mm7, %%mm5 \n\t"
478                 "punpcklbw %%mm7, %%mm4 \n\t"
479                 "pmullw    %%mm5, %%mm1 \n\t" // src[1, 0] * dx * (s - dy)
480                 "pmullw    %%mm4, %%mm0 \n\t" // src[0, 0] * (s - dx) * (s - dy)
481                 "paddw        %5, %%mm1 \n\t"
482                 "paddw     %%mm3, %%mm2 \n\t"
483                 "paddw     %%mm1, %%mm0 \n\t"
484                 "paddw     %%mm2, %%mm0 \n\t"
485
486                 "psrlw        %6, %%mm0 \n\t"
487                 "packuswb  %%mm0, %%mm0 \n\t"
488                 "movd      %%mm0, %0    \n\t"
489
490                 : "=m" (dst[x + y * stride])
491                 : "m" (src[0]), "m" (src[1]),
492                   "m" (src[stride]), "m" (src[stride + 1]),
493                   "m" (*r4), "m" (shift2));
494             src += stride;
495         }
496         src += 4 - h * stride;
497     }
498 }
499
500 #if CONFIG_VIDEODSP
501 #if HAVE_YASM
502 #if ARCH_X86_32
503 void ff_gmc_mmx(uint8_t *dst, uint8_t *src,
504                 int stride, int h, int ox, int oy,
505                 int dxx, int dxy, int dyx, int dyy,
506                 int shift, int r, int width, int height)
507 {
508     gmc(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy, shift, r,
509         width, height, &ff_emulated_edge_mc_8);
510 }
511 #endif
512 void ff_gmc_sse(uint8_t *dst, uint8_t *src,
513                 int stride, int h, int ox, int oy,
514                 int dxx, int dxy, int dyx, int dyy,
515                 int shift, int r, int width, int height)
516 {
517     gmc(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy, shift, r,
518         width, height, &ff_emulated_edge_mc_8);
519 }
520 #else
521 void ff_gmc_mmx(uint8_t *dst, uint8_t *src,
522                 int stride, int h, int ox, int oy,
523                 int dxx, int dxy, int dyx, int dyy,
524                 int shift, int r, int width, int height)
525 {
526     gmc(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy, shift, r,
527         width, height, &ff_emulated_edge_mc_8);
528 }
529 #endif
530 #endif
531
532 #if CONFIG_DIRAC_DECODER
533 #define DIRAC_PIXOP(OPNAME2, OPNAME, EXT)\
534 void ff_ ## OPNAME2 ## _dirac_pixels8_ ## EXT(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
535 {\
536     if (h&3)\
537         ff_ ## OPNAME2 ## _dirac_pixels8_c(dst, src, stride, h);\
538     else\
539         OPNAME ## _pixels8_ ## EXT(dst, src[0], stride, h);\
540 }\
541 void ff_ ## OPNAME2 ## _dirac_pixels16_ ## EXT(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
542 {\
543     if (h&3)\
544         ff_ ## OPNAME2 ## _dirac_pixels16_c(dst, src, stride, h);\
545     else\
546         OPNAME ## _pixels16_ ## EXT(dst, src[0], stride, h);\
547 }\
548 void ff_ ## OPNAME2 ## _dirac_pixels32_ ## EXT(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
549 {\
550     if (h&3) {\
551         ff_ ## OPNAME2 ## _dirac_pixels32_c(dst, src, stride, h);\
552     } else {\
553         OPNAME ## _pixels16_ ## EXT(dst   , src[0]   , stride, h);\
554         OPNAME ## _pixels16_ ## EXT(dst+16, src[0]+16, stride, h);\
555     }\
556 }
557
558 #if HAVE_MMX_INLINE
559 CALL_2X_PIXELS(ff_avg_pixels16_mmxext, ff_avg_pixels8_mmxext, 8)
560 DIRAC_PIXOP(put, ff_put, mmx)
561 DIRAC_PIXOP(avg, ff_avg, mmx)
562 #endif
563
564 #if HAVE_YASM
565 DIRAC_PIXOP(avg, ff_avg, mmxext)
566
567 void ff_put_dirac_pixels16_sse2(uint8_t *dst, const uint8_t *src[5], int stride, int h)
568 {
569     if (h&3)
570         ff_put_dirac_pixels16_c(dst, src, stride, h);
571     else
572     ff_put_pixels16_sse2(dst, src[0], stride, h);
573 }
574 void ff_avg_dirac_pixels16_sse2(uint8_t *dst, const uint8_t *src[5], int stride, int h)
575 {
576     if (h&3)
577         ff_avg_dirac_pixels16_c(dst, src, stride, h);
578     else
579     ff_avg_pixels16_sse2(dst, src[0], stride, h);
580 }
581 void ff_put_dirac_pixels32_sse2(uint8_t *dst, const uint8_t *src[5], int stride, int h)
582 {
583     if (h&3) {
584         ff_put_dirac_pixels32_c(dst, src, stride, h);
585     } else {
586     ff_put_pixels16_sse2(dst   , src[0]   , stride, h);
587     ff_put_pixels16_sse2(dst+16, src[0]+16, stride, h);
588     }
589 }
590 void ff_avg_dirac_pixels32_sse2(uint8_t *dst, const uint8_t *src[5], int stride, int h)
591 {
592     if (h&3) {
593         ff_avg_dirac_pixels32_c(dst, src, stride, h);
594     } else {
595     ff_avg_pixels16_sse2(dst   , src[0]   , stride, h);
596     ff_avg_pixels16_sse2(dst+16, src[0]+16, stride, h);
597     }
598 }
599 #endif
600 #endif
601
602 void ff_vector_clipf_sse(float *dst, const float *src,
603                          float min, float max, int len)
604 {
605     x86_reg i = (len - 16) * 4;
606     __asm__ volatile (
607         "movss          %3, %%xmm4      \n\t"
608         "movss          %4, %%xmm5      \n\t"
609         "shufps $0, %%xmm4, %%xmm4      \n\t"
610         "shufps $0, %%xmm5, %%xmm5      \n\t"
611         "1:                             \n\t"
612         "movaps   (%2, %0), %%xmm0      \n\t" // 3/1 on intel
613         "movaps 16(%2, %0), %%xmm1      \n\t"
614         "movaps 32(%2, %0), %%xmm2      \n\t"
615         "movaps 48(%2, %0), %%xmm3      \n\t"
616         "maxps      %%xmm4, %%xmm0      \n\t"
617         "maxps      %%xmm4, %%xmm1      \n\t"
618         "maxps      %%xmm4, %%xmm2      \n\t"
619         "maxps      %%xmm4, %%xmm3      \n\t"
620         "minps      %%xmm5, %%xmm0      \n\t"
621         "minps      %%xmm5, %%xmm1      \n\t"
622         "minps      %%xmm5, %%xmm2      \n\t"
623         "minps      %%xmm5, %%xmm3      \n\t"
624         "movaps     %%xmm0,   (%1, %0)  \n\t"
625         "movaps     %%xmm1, 16(%1, %0)  \n\t"
626         "movaps     %%xmm2, 32(%1, %0)  \n\t"
627         "movaps     %%xmm3, 48(%1, %0)  \n\t"
628         "sub           $64, %0          \n\t"
629         "jge            1b              \n\t"
630         : "+&r" (i)
631         : "r" (dst), "r" (src), "m" (min), "m" (max)
632         : "memory");
633 }
634
635 #endif /* HAVE_INLINE_ASM */