d6136f65fe58eaa3be67d03d1b73fd2fb12c2f0c
[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  * MMX optimization by Nick Kurshev <nickols_k@mail.ru>
7  *
8  * This file is part of Libav.
9  *
10  * Libav is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * Libav is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with Libav; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24
25 #include "config.h"
26 #include "libavutil/cpu.h"
27 #include "libavutil/x86/asm.h"
28 #include "constants.h"
29 #include "dsputil_x86.h"
30
31 #if HAVE_INLINE_ASM
32
33 void ff_put_pixels_clamped_mmx(const int16_t *block, uint8_t *pixels,
34                                int line_size)
35 {
36     const int16_t *p;
37     uint8_t *pix;
38
39     /* read the pixels */
40     p   = block;
41     pix = pixels;
42     /* unrolled loop */
43     __asm__ volatile (
44         "movq      (%3), %%mm0          \n\t"
45         "movq     8(%3), %%mm1          \n\t"
46         "movq    16(%3), %%mm2          \n\t"
47         "movq    24(%3), %%mm3          \n\t"
48         "movq    32(%3), %%mm4          \n\t"
49         "movq    40(%3), %%mm5          \n\t"
50         "movq    48(%3), %%mm6          \n\t"
51         "movq    56(%3), %%mm7          \n\t"
52         "packuswb %%mm1, %%mm0          \n\t"
53         "packuswb %%mm3, %%mm2          \n\t"
54         "packuswb %%mm5, %%mm4          \n\t"
55         "packuswb %%mm7, %%mm6          \n\t"
56         "movq     %%mm0, (%0)           \n\t"
57         "movq     %%mm2, (%0, %1)       \n\t"
58         "movq     %%mm4, (%0, %1, 2)    \n\t"
59         "movq     %%mm6, (%0, %2)       \n\t"
60         :: "r" (pix), "r" ((x86_reg) line_size), "r" ((x86_reg) line_size * 3),
61            "r" (p)
62         : "memory");
63     pix += line_size * 4;
64     p   += 32;
65
66     // if here would be an exact copy of the code above
67     // compiler would generate some very strange code
68     // thus using "r"
69     __asm__ volatile (
70         "movq       (%3), %%mm0         \n\t"
71         "movq      8(%3), %%mm1         \n\t"
72         "movq     16(%3), %%mm2         \n\t"
73         "movq     24(%3), %%mm3         \n\t"
74         "movq     32(%3), %%mm4         \n\t"
75         "movq     40(%3), %%mm5         \n\t"
76         "movq     48(%3), %%mm6         \n\t"
77         "movq     56(%3), %%mm7         \n\t"
78         "packuswb  %%mm1, %%mm0         \n\t"
79         "packuswb  %%mm3, %%mm2         \n\t"
80         "packuswb  %%mm5, %%mm4         \n\t"
81         "packuswb  %%mm7, %%mm6         \n\t"
82         "movq      %%mm0, (%0)          \n\t"
83         "movq      %%mm2, (%0, %1)      \n\t"
84         "movq      %%mm4, (%0, %1, 2)   \n\t"
85         "movq      %%mm6, (%0, %2)      \n\t"
86         :: "r" (pix), "r" ((x86_reg) line_size), "r" ((x86_reg) line_size * 3),
87            "r" (p)
88         : "memory");
89 }
90
91 #define put_signed_pixels_clamped_mmx_half(off)             \
92     "movq          "#off"(%2), %%mm1        \n\t"           \
93     "movq     16 + "#off"(%2), %%mm2        \n\t"           \
94     "movq     32 + "#off"(%2), %%mm3        \n\t"           \
95     "movq     48 + "#off"(%2), %%mm4        \n\t"           \
96     "packsswb  8 + "#off"(%2), %%mm1        \n\t"           \
97     "packsswb 24 + "#off"(%2), %%mm2        \n\t"           \
98     "packsswb 40 + "#off"(%2), %%mm3        \n\t"           \
99     "packsswb 56 + "#off"(%2), %%mm4        \n\t"           \
100     "paddb              %%mm0, %%mm1        \n\t"           \
101     "paddb              %%mm0, %%mm2        \n\t"           \
102     "paddb              %%mm0, %%mm3        \n\t"           \
103     "paddb              %%mm0, %%mm4        \n\t"           \
104     "movq               %%mm1, (%0)         \n\t"           \
105     "movq               %%mm2, (%0, %3)     \n\t"           \
106     "movq               %%mm3, (%0, %3, 2)  \n\t"           \
107     "movq               %%mm4, (%0, %1)     \n\t"
108
109 void ff_put_signed_pixels_clamped_mmx(const int16_t *block, uint8_t *pixels,
110                                       int line_size)
111 {
112     x86_reg line_skip = line_size;
113     x86_reg line_skip3;
114
115     __asm__ volatile (
116         "movq "MANGLE(ff_pb_80)", %%mm0     \n\t"
117         "lea         (%3, %3, 2), %1        \n\t"
118         put_signed_pixels_clamped_mmx_half(0)
119         "lea         (%0, %3, 4), %0        \n\t"
120         put_signed_pixels_clamped_mmx_half(64)
121         : "+&r" (pixels), "=&r" (line_skip3)
122         : "r" (block), "r" (line_skip)
123         : "memory");
124 }
125
126 void ff_add_pixels_clamped_mmx(const int16_t *block, uint8_t *pixels,
127                                int line_size)
128 {
129     const int16_t *p;
130     uint8_t *pix;
131     int i;
132
133     /* read the pixels */
134     p   = block;
135     pix = pixels;
136     MOVQ_ZERO(mm7);
137     i = 4;
138     do {
139         __asm__ volatile (
140             "movq        (%2), %%mm0    \n\t"
141             "movq       8(%2), %%mm1    \n\t"
142             "movq      16(%2), %%mm2    \n\t"
143             "movq      24(%2), %%mm3    \n\t"
144             "movq          %0, %%mm4    \n\t"
145             "movq          %1, %%mm6    \n\t"
146             "movq       %%mm4, %%mm5    \n\t"
147             "punpcklbw  %%mm7, %%mm4    \n\t"
148             "punpckhbw  %%mm7, %%mm5    \n\t"
149             "paddsw     %%mm4, %%mm0    \n\t"
150             "paddsw     %%mm5, %%mm1    \n\t"
151             "movq       %%mm6, %%mm5    \n\t"
152             "punpcklbw  %%mm7, %%mm6    \n\t"
153             "punpckhbw  %%mm7, %%mm5    \n\t"
154             "paddsw     %%mm6, %%mm2    \n\t"
155             "paddsw     %%mm5, %%mm3    \n\t"
156             "packuswb   %%mm1, %%mm0    \n\t"
157             "packuswb   %%mm3, %%mm2    \n\t"
158             "movq       %%mm0, %0       \n\t"
159             "movq       %%mm2, %1       \n\t"
160             : "+m" (*pix), "+m" (*(pix + line_size))
161             : "r" (p)
162             : "memory");
163         pix += line_size * 2;
164         p   += 16;
165     } while (--i);
166 }
167
168 #define CLEAR_BLOCKS(name, n)                           \
169 void name(int16_t *blocks)                              \
170 {                                                       \
171     __asm__ volatile (                                  \
172         "pxor %%mm7, %%mm7              \n\t"           \
173         "mov     %1,        %%"REG_a"   \n\t"           \
174         "1:                             \n\t"           \
175         "movq %%mm7,   (%0, %%"REG_a")  \n\t"           \
176         "movq %%mm7,  8(%0, %%"REG_a")  \n\t"           \
177         "movq %%mm7, 16(%0, %%"REG_a")  \n\t"           \
178         "movq %%mm7, 24(%0, %%"REG_a")  \n\t"           \
179         "add    $32, %%"REG_a"          \n\t"           \
180         "js      1b                     \n\t"           \
181         :: "r"(((uint8_t *) blocks) + 128 * n),         \
182            "i"(-128 * n)                                \
183         : "%"REG_a);                                    \
184 }
185 CLEAR_BLOCKS(ff_clear_blocks_mmx, 6)
186 CLEAR_BLOCKS(ff_clear_block_mmx, 1)
187
188 void ff_clear_block_sse(int16_t *block)
189 {
190     __asm__ volatile (
191         "xorps  %%xmm0, %%xmm0          \n"
192         "movaps %%xmm0,    (%0)         \n"
193         "movaps %%xmm0,  16(%0)         \n"
194         "movaps %%xmm0,  32(%0)         \n"
195         "movaps %%xmm0,  48(%0)         \n"
196         "movaps %%xmm0,  64(%0)         \n"
197         "movaps %%xmm0,  80(%0)         \n"
198         "movaps %%xmm0,  96(%0)         \n"
199         "movaps %%xmm0, 112(%0)         \n"
200         :: "r" (block)
201         : "memory");
202 }
203
204 void ff_clear_blocks_sse(int16_t *blocks)
205 {
206     __asm__ volatile (
207         "xorps  %%xmm0, %%xmm0              \n"
208         "mov        %1,         %%"REG_a"   \n"
209         "1:                                 \n"
210         "movaps %%xmm0,    (%0, %%"REG_a")  \n"
211         "movaps %%xmm0,  16(%0, %%"REG_a")  \n"
212         "movaps %%xmm0,  32(%0, %%"REG_a")  \n"
213         "movaps %%xmm0,  48(%0, %%"REG_a")  \n"
214         "movaps %%xmm0,  64(%0, %%"REG_a")  \n"
215         "movaps %%xmm0,  80(%0, %%"REG_a")  \n"
216         "movaps %%xmm0,  96(%0, %%"REG_a")  \n"
217         "movaps %%xmm0, 112(%0, %%"REG_a")  \n"
218         "add      $128,         %%"REG_a"   \n"
219         "js         1b                      \n"
220         :: "r"(((uint8_t *) blocks) + 128 * 6), "i"(-128 * 6)
221         : "%"REG_a);
222 }
223
224 void ff_add_bytes_mmx(uint8_t *dst, uint8_t *src, int w)
225 {
226     x86_reg i = 0;
227
228     __asm__ volatile (
229         "jmp          2f                \n\t"
230         "1:                             \n\t"
231         "movq   (%1, %0), %%mm0         \n\t"
232         "movq   (%2, %0), %%mm1         \n\t"
233         "paddb     %%mm0, %%mm1         \n\t"
234         "movq      %%mm1, (%2, %0)      \n\t"
235         "movq  8(%1, %0), %%mm0         \n\t"
236         "movq  8(%2, %0), %%mm1         \n\t"
237         "paddb     %%mm0, %%mm1         \n\t"
238         "movq      %%mm1, 8(%2, %0)     \n\t"
239         "add         $16, %0            \n\t"
240         "2:                             \n\t"
241         "cmp          %3, %0            \n\t"
242         "js           1b                \n\t"
243         : "+r" (i)
244         : "r" (src), "r" (dst), "r" ((x86_reg) w - 15));
245
246     for (; i < w; i++)
247         dst[i + 0] += src[i + 0];
248 }
249
250 /* Draw the edges of width 'w' of an image of size width, height
251  * this MMX version can only handle w == 8 || w == 16. */
252 void ff_draw_edges_mmx(uint8_t *buf, int wrap, int width, int height,
253                        int w, int h, int sides)
254 {
255     uint8_t *ptr, *last_line;
256     int i;
257
258     last_line = buf + (height - 1) * wrap;
259     /* left and right */
260     ptr = buf;
261     if (w == 8) {
262         __asm__ volatile (
263             "1:                             \n\t"
264             "movd            (%0), %%mm0    \n\t"
265             "punpcklbw      %%mm0, %%mm0    \n\t"
266             "punpcklwd      %%mm0, %%mm0    \n\t"
267             "punpckldq      %%mm0, %%mm0    \n\t"
268             "movq           %%mm0, -8(%0)   \n\t"
269             "movq      -8(%0, %2), %%mm1    \n\t"
270             "punpckhbw      %%mm1, %%mm1    \n\t"
271             "punpckhwd      %%mm1, %%mm1    \n\t"
272             "punpckhdq      %%mm1, %%mm1    \n\t"
273             "movq           %%mm1, (%0, %2) \n\t"
274             "add               %1, %0       \n\t"
275             "cmp               %3, %0       \n\t"
276             "jb                1b           \n\t"
277             : "+r" (ptr)
278             : "r" ((x86_reg) wrap), "r" ((x86_reg) width),
279               "r" (ptr + wrap * height));
280     } else {
281         __asm__ volatile (
282             "1:                                 \n\t"
283             "movd            (%0), %%mm0        \n\t"
284             "punpcklbw      %%mm0, %%mm0        \n\t"
285             "punpcklwd      %%mm0, %%mm0        \n\t"
286             "punpckldq      %%mm0, %%mm0        \n\t"
287             "movq           %%mm0, -8(%0)       \n\t"
288             "movq           %%mm0, -16(%0)      \n\t"
289             "movq      -8(%0, %2), %%mm1        \n\t"
290             "punpckhbw      %%mm1, %%mm1        \n\t"
291             "punpckhwd      %%mm1, %%mm1        \n\t"
292             "punpckhdq      %%mm1, %%mm1        \n\t"
293             "movq           %%mm1,  (%0, %2)    \n\t"
294             "movq           %%mm1, 8(%0, %2)    \n\t"
295             "add               %1, %0           \n\t"
296             "cmp               %3, %0           \n\t"
297             "jb                1b               \n\t"
298             : "+r" (ptr)
299             : "r" ((x86_reg) wrap), "r" ((x86_reg) width),
300               "r" (ptr + wrap * height));
301     }
302
303     /* top and bottom (and hopefully also the corners) */
304     if (sides & EDGE_TOP) {
305         for (i = 0; i < h; i += 4) {
306             ptr = buf - (i + 1) * wrap - w;
307             __asm__ volatile (
308                 "1:                             \n\t"
309                 "movq (%1, %0), %%mm0           \n\t"
310                 "movq    %%mm0, (%0)            \n\t"
311                 "movq    %%mm0, (%0, %2)        \n\t"
312                 "movq    %%mm0, (%0, %2, 2)     \n\t"
313                 "movq    %%mm0, (%0, %3)        \n\t"
314                 "add        $8, %0              \n\t"
315                 "cmp        %4, %0              \n\t"
316                 "jb         1b                  \n\t"
317                 : "+r" (ptr)
318                 : "r" ((x86_reg) buf - (x86_reg) ptr - w),
319                   "r" ((x86_reg) - wrap), "r" ((x86_reg) - wrap * 3),
320                   "r" (ptr + width + 2 * w));
321         }
322     }
323
324     if (sides & EDGE_BOTTOM) {
325         for (i = 0; i < h; i += 4) {
326             ptr = last_line + (i + 1) * wrap - w;
327             __asm__ volatile (
328                 "1:                             \n\t"
329                 "movq (%1, %0), %%mm0           \n\t"
330                 "movq    %%mm0, (%0)            \n\t"
331                 "movq    %%mm0, (%0, %2)        \n\t"
332                 "movq    %%mm0, (%0, %2, 2)     \n\t"
333                 "movq    %%mm0, (%0, %3)        \n\t"
334                 "add        $8, %0              \n\t"
335                 "cmp        %4, %0              \n\t"
336                 "jb         1b                  \n\t"
337                 : "+r" (ptr)
338                 : "r" ((x86_reg) last_line - (x86_reg) ptr - w),
339                   "r" ((x86_reg) wrap), "r" ((x86_reg) wrap * 3),
340                   "r" (ptr + width + 2 * w));
341         }
342     }
343 }
344
345 void ff_gmc_mmx(uint8_t *dst, uint8_t *src,
346                 int stride, int h, int ox, int oy,
347                 int dxx, int dxy, int dyx, int dyy,
348                 int shift, int r, int width, int height)
349 {
350     const int w    = 8;
351     const int ix   = ox  >> (16 + shift);
352     const int iy   = oy  >> (16 + shift);
353     const int oxs  = ox  >> 4;
354     const int oys  = oy  >> 4;
355     const int dxxs = dxx >> 4;
356     const int dxys = dxy >> 4;
357     const int dyxs = dyx >> 4;
358     const int dyys = dyy >> 4;
359     const uint16_t r4[4]   = { r, r, r, r };
360     const uint16_t dxy4[4] = { dxys, dxys, dxys, dxys };
361     const uint16_t dyy4[4] = { dyys, dyys, dyys, dyys };
362     const uint64_t shift2  = 2 * shift;
363     int x, y;
364
365     const int dxw = (dxx - (1 << (16 + shift))) * (w - 1);
366     const int dyh = (dyy - (1 << (16 + shift))) * (h - 1);
367     const int dxh = dxy * (h - 1);
368     const int dyw = dyx * (w - 1);
369
370     if ( // non-constant fullpel offset (3% of blocks)
371         ((ox ^ (ox + dxw)) | (ox ^ (ox + dxh)) | (ox ^ (ox + dxw + dxh)) |
372          (oy ^ (oy + dyw)) | (oy ^ (oy + dyh)) | (oy ^ (oy + dyw + dyh))) >> (16 + shift) ||
373         // uses more than 16 bits of subpel mv (only at huge resolution)
374         (dxx | dxy | dyx | dyy) & 15 ||
375         (unsigned) ix >= width  - w ||
376         (unsigned) iy >= height - h) {
377         // FIXME could still use mmx for some of the rows
378         ff_gmc_c(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy,
379                  shift, r, width, height);
380         return;
381     }
382
383     src += ix + iy * stride;
384
385     __asm__ volatile (
386         "movd         %0, %%mm6         \n\t"
387         "pxor      %%mm7, %%mm7         \n\t"
388         "punpcklwd %%mm6, %%mm6         \n\t"
389         "punpcklwd %%mm6, %%mm6         \n\t"
390         :: "r" (1 << shift));
391
392     for (x = 0; x < w; x += 4) {
393         uint16_t dx4[4] = { oxs - dxys + dxxs * (x + 0),
394                             oxs - dxys + dxxs * (x + 1),
395                             oxs - dxys + dxxs * (x + 2),
396                             oxs - dxys + dxxs * (x + 3) };
397         uint16_t dy4[4] = { oys - dyys + dyxs * (x + 0),
398                             oys - dyys + dyxs * (x + 1),
399                             oys - dyys + dyxs * (x + 2),
400                             oys - dyys + dyxs * (x + 3) };
401
402         for (y = 0; y < h; y++) {
403             __asm__ volatile (
404                 "movq      %0, %%mm4    \n\t"
405                 "movq      %1, %%mm5    \n\t"
406                 "paddw     %2, %%mm4    \n\t"
407                 "paddw     %3, %%mm5    \n\t"
408                 "movq   %%mm4, %0       \n\t"
409                 "movq   %%mm5, %1       \n\t"
410                 "psrlw    $12, %%mm4    \n\t"
411                 "psrlw    $12, %%mm5    \n\t"
412                 : "+m" (*dx4), "+m" (*dy4)
413                 : "m" (*dxy4), "m" (*dyy4));
414
415             __asm__ volatile (
416                 "movq      %%mm6, %%mm2 \n\t"
417                 "movq      %%mm6, %%mm1 \n\t"
418                 "psubw     %%mm4, %%mm2 \n\t"
419                 "psubw     %%mm5, %%mm1 \n\t"
420                 "movq      %%mm2, %%mm0 \n\t"
421                 "movq      %%mm4, %%mm3 \n\t"
422                 "pmullw    %%mm1, %%mm0 \n\t" // (s - dx) * (s - dy)
423                 "pmullw    %%mm5, %%mm3 \n\t" // dx * dy
424                 "pmullw    %%mm5, %%mm2 \n\t" // (s - dx) * dy
425                 "pmullw    %%mm4, %%mm1 \n\t" // dx * (s - dy)
426
427                 "movd         %4, %%mm5 \n\t"
428                 "movd         %3, %%mm4 \n\t"
429                 "punpcklbw %%mm7, %%mm5 \n\t"
430                 "punpcklbw %%mm7, %%mm4 \n\t"
431                 "pmullw    %%mm5, %%mm3 \n\t" // src[1, 1] * dx * dy
432                 "pmullw    %%mm4, %%mm2 \n\t" // src[0, 1] * (s - dx) * dy
433
434                 "movd         %2, %%mm5 \n\t"
435                 "movd         %1, %%mm4 \n\t"
436                 "punpcklbw %%mm7, %%mm5 \n\t"
437                 "punpcklbw %%mm7, %%mm4 \n\t"
438                 "pmullw    %%mm5, %%mm1 \n\t" // src[1, 0] * dx * (s - dy)
439                 "pmullw    %%mm4, %%mm0 \n\t" // src[0, 0] * (s - dx) * (s - dy)
440                 "paddw        %5, %%mm1 \n\t"
441                 "paddw     %%mm3, %%mm2 \n\t"
442                 "paddw     %%mm1, %%mm0 \n\t"
443                 "paddw     %%mm2, %%mm0 \n\t"
444
445                 "psrlw        %6, %%mm0 \n\t"
446                 "packuswb  %%mm0, %%mm0 \n\t"
447                 "movd      %%mm0, %0    \n\t"
448
449                 : "=m" (dst[x + y * stride])
450                 : "m" (src[0]), "m" (src[1]),
451                   "m" (src[stride]), "m" (src[stride + 1]),
452                   "m" (*r4), "m" (shift2));
453             src += stride;
454         }
455         src += 4 - h * stride;
456     }
457 }
458
459 void ff_vector_clipf_sse(float *dst, const float *src,
460                          float min, float max, int len)
461 {
462     x86_reg i = (len - 16) * 4;
463     __asm__ volatile (
464         "movss          %3, %%xmm4      \n\t"
465         "movss          %4, %%xmm5      \n\t"
466         "shufps $0, %%xmm4, %%xmm4      \n\t"
467         "shufps $0, %%xmm5, %%xmm5      \n\t"
468         "1:                             \n\t"
469         "movaps   (%2, %0), %%xmm0      \n\t" // 3/1 on intel
470         "movaps 16(%2, %0), %%xmm1      \n\t"
471         "movaps 32(%2, %0), %%xmm2      \n\t"
472         "movaps 48(%2, %0), %%xmm3      \n\t"
473         "maxps      %%xmm4, %%xmm0      \n\t"
474         "maxps      %%xmm4, %%xmm1      \n\t"
475         "maxps      %%xmm4, %%xmm2      \n\t"
476         "maxps      %%xmm4, %%xmm3      \n\t"
477         "minps      %%xmm5, %%xmm0      \n\t"
478         "minps      %%xmm5, %%xmm1      \n\t"
479         "minps      %%xmm5, %%xmm2      \n\t"
480         "minps      %%xmm5, %%xmm3      \n\t"
481         "movaps     %%xmm0,   (%1, %0)  \n\t"
482         "movaps     %%xmm1, 16(%1, %0)  \n\t"
483         "movaps     %%xmm2, 32(%1, %0)  \n\t"
484         "movaps     %%xmm3, 48(%1, %0)  \n\t"
485         "sub           $64, %0          \n\t"
486         "jge            1b              \n\t"
487         : "+&r" (i)
488         : "r" (dst), "r" (src), "m" (min), "m" (max)
489         : "memory");
490 }
491
492 #endif /* HAVE_INLINE_ASM */