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