x86: dsputil: Rename dsputil_mmx.h --> dsputil_x86.h
[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), "r"(p)
87         : "memory");
88 }
89
90 #define put_signed_pixels_clamped_mmx_half(off)             \
91     "movq          "#off"(%2), %%mm1        \n\t"           \
92     "movq     16 + "#off"(%2), %%mm2        \n\t"           \
93     "movq     32 + "#off"(%2), %%mm3        \n\t"           \
94     "movq     48 + "#off"(%2), %%mm4        \n\t"           \
95     "packsswb  8 + "#off"(%2), %%mm1        \n\t"           \
96     "packsswb 24 + "#off"(%2), %%mm2        \n\t"           \
97     "packsswb 40 + "#off"(%2), %%mm3        \n\t"           \
98     "packsswb 56 + "#off"(%2), %%mm4        \n\t"           \
99     "paddb              %%mm0, %%mm1        \n\t"           \
100     "paddb              %%mm0, %%mm2        \n\t"           \
101     "paddb              %%mm0, %%mm3        \n\t"           \
102     "paddb              %%mm0, %%mm4        \n\t"           \
103     "movq               %%mm1, (%0)         \n\t"           \
104     "movq               %%mm2, (%0, %3)     \n\t"           \
105     "movq               %%mm3, (%0, %3, 2)  \n\t"           \
106     "movq               %%mm4, (%0, %1)     \n\t"
107
108 void ff_put_signed_pixels_clamped_mmx(const int16_t *block, uint8_t *pixels,
109                                       int line_size)
110 {
111     x86_reg line_skip = line_size;
112     x86_reg line_skip3;
113
114     __asm__ volatile (
115         "movq "MANGLE(ff_pb_80)", %%mm0     \n\t"
116         "lea         (%3, %3, 2), %1        \n\t"
117         put_signed_pixels_clamped_mmx_half(0)
118         "lea         (%0, %3, 4), %0        \n\t"
119         put_signed_pixels_clamped_mmx_half(64)
120         : "+&r"(pixels), "=&r"(line_skip3)
121         : "r"(block), "r"(line_skip)
122         : "memory");
123 }
124
125 void ff_add_pixels_clamped_mmx(const int16_t *block, uint8_t *pixels,
126                                int line_size)
127 {
128     const int16_t *p;
129     uint8_t *pix;
130     int i;
131
132     /* read the pixels */
133     p   = block;
134     pix = pixels;
135     MOVQ_ZERO(mm7);
136     i = 4;
137     do {
138         __asm__ volatile (
139             "movq        (%2), %%mm0    \n\t"
140             "movq       8(%2), %%mm1    \n\t"
141             "movq      16(%2), %%mm2    \n\t"
142             "movq      24(%2), %%mm3    \n\t"
143             "movq          %0, %%mm4    \n\t"
144             "movq          %1, %%mm6    \n\t"
145             "movq       %%mm4, %%mm5    \n\t"
146             "punpcklbw  %%mm7, %%mm4    \n\t"
147             "punpckhbw  %%mm7, %%mm5    \n\t"
148             "paddsw     %%mm4, %%mm0    \n\t"
149             "paddsw     %%mm5, %%mm1    \n\t"
150             "movq       %%mm6, %%mm5    \n\t"
151             "punpcklbw  %%mm7, %%mm6    \n\t"
152             "punpckhbw  %%mm7, %%mm5    \n\t"
153             "paddsw     %%mm6, %%mm2    \n\t"
154             "paddsw     %%mm5, %%mm3    \n\t"
155             "packuswb   %%mm1, %%mm0    \n\t"
156             "packuswb   %%mm3, %%mm2    \n\t"
157             "movq       %%mm0, %0       \n\t"
158             "movq       %%mm2, %1       \n\t"
159             : "+m"(*pix), "+m"(*(pix + line_size))
160             : "r"(p)
161             : "memory");
162         pix += line_size * 2;
163         p   += 16;
164     } while (--i);
165 }
166
167 #define CLEAR_BLOCKS(name, n)                           \
168 void name(int16_t *blocks)                              \
169 {                                                       \
170     __asm__ volatile (                                  \
171         "pxor %%mm7, %%mm7              \n\t"           \
172         "mov     %1,        %%"REG_a"   \n\t"           \
173         "1:                             \n\t"           \
174         "movq %%mm7,   (%0, %%"REG_a")  \n\t"           \
175         "movq %%mm7,  8(%0, %%"REG_a")  \n\t"           \
176         "movq %%mm7, 16(%0, %%"REG_a")  \n\t"           \
177         "movq %%mm7, 24(%0, %%"REG_a")  \n\t"           \
178         "add    $32, %%"REG_a"          \n\t"           \
179         "js      1b                     \n\t"           \
180         :: "r"(((uint8_t *)blocks) + 128 * n),          \
181            "i"(-128 * n)                                \
182         : "%"REG_a                                      \
183         );                                              \
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
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),
222            "i"(-128 * 6)
223         : "%"REG_a
224     );
225 }
226
227 void ff_add_bytes_mmx(uint8_t *dst, uint8_t *src, int w)
228 {
229     x86_reg i = 0;
230     __asm__ volatile (
231         "jmp          2f                \n\t"
232         "1:                             \n\t"
233         "movq   (%1, %0), %%mm0         \n\t"
234         "movq   (%2, %0), %%mm1         \n\t"
235         "paddb     %%mm0, %%mm1         \n\t"
236         "movq      %%mm1, (%2, %0)      \n\t"
237         "movq  8(%1, %0), %%mm0         \n\t"
238         "movq  8(%2, %0), %%mm1         \n\t"
239         "paddb     %%mm0, %%mm1         \n\t"
240         "movq      %%mm1, 8(%2, %0)     \n\t"
241         "add         $16, %0            \n\t"
242         "2:                             \n\t"
243         "cmp          %3, %0            \n\t"
244         "js           1b                \n\t"
245         : "+r"(i)
246         : "r"(src), "r"(dst), "r"((x86_reg)w - 15)
247     );
248     for ( ; i < w; i++)
249         dst[i + 0] += src[i + 0];
250 }
251
252 #if HAVE_7REGS
253 void ff_add_hfyu_median_prediction_cmov(uint8_t *dst, const uint8_t *top,
254                                         const uint8_t *diff, int w,
255                                         int *left, int *left_top)
256 {
257     x86_reg w2 = -w;
258     x86_reg x;
259     int l  = *left     & 0xff;
260     int tl = *left_top & 0xff;
261     int t;
262     __asm__ volatile (
263         "mov          %7, %3            \n"
264         "1:                             \n"
265         "movzbl (%3, %4), %2            \n"
266         "mov          %2, %k3           \n"
267         "sub         %b1, %b3           \n"
268         "add         %b0, %b3           \n"
269         "mov          %2, %1            \n"
270         "cmp          %0, %2            \n"
271         "cmovg        %0, %2            \n"
272         "cmovg        %1, %0            \n"
273         "cmp         %k3, %0            \n"
274         "cmovg       %k3, %0            \n"
275         "mov          %7, %3            \n"
276         "cmp          %2, %0            \n"
277         "cmovl        %2, %0            \n"
278         "add    (%6, %4), %b0           \n"
279         "mov         %b0, (%5, %4)      \n"
280         "inc          %4                \n"
281         "jl           1b                \n"
282         : "+&q"(l), "+&q"(tl), "=&r"(t), "=&q"(x), "+&r"(w2)
283         : "r"(dst + w), "r"(diff + w), "rm"(top + w)
284     );
285     *left     = l;
286     *left_top = tl;
287 }
288 #endif
289
290 /* Draw the edges of width 'w' of an image of size width, height
291  * this MMX version can only handle w == 8 || w == 16. */
292 void ff_draw_edges_mmx(uint8_t *buf, int wrap, int width, int height,
293                        int w, int h, int sides)
294 {
295     uint8_t *ptr, *last_line;
296     int i;
297
298     last_line = buf + (height - 1) * wrap;
299     /* left and right */
300     ptr = buf;
301     if (w == 8) {
302         __asm__ volatile (
303             "1:                             \n\t"
304             "movd            (%0), %%mm0    \n\t"
305             "punpcklbw      %%mm0, %%mm0    \n\t"
306             "punpcklwd      %%mm0, %%mm0    \n\t"
307             "punpckldq      %%mm0, %%mm0    \n\t"
308             "movq           %%mm0, -8(%0)   \n\t"
309             "movq      -8(%0, %2), %%mm1    \n\t"
310             "punpckhbw      %%mm1, %%mm1    \n\t"
311             "punpckhwd      %%mm1, %%mm1    \n\t"
312             "punpckhdq      %%mm1, %%mm1    \n\t"
313             "movq           %%mm1, (%0, %2) \n\t"
314             "add               %1, %0       \n\t"
315             "cmp               %3, %0       \n\t"
316             "jb                1b           \n\t"
317             : "+r"(ptr)
318             : "r"((x86_reg)wrap), "r"((x86_reg)width), "r"(ptr + wrap * height)
319             );
320     } else {
321         __asm__ volatile (
322             "1:                                 \n\t"
323             "movd            (%0), %%mm0        \n\t"
324             "punpcklbw      %%mm0, %%mm0        \n\t"
325             "punpcklwd      %%mm0, %%mm0        \n\t"
326             "punpckldq      %%mm0, %%mm0        \n\t"
327             "movq           %%mm0, -8(%0)       \n\t"
328             "movq           %%mm0, -16(%0)      \n\t"
329             "movq      -8(%0, %2), %%mm1        \n\t"
330             "punpckhbw      %%mm1, %%mm1        \n\t"
331             "punpckhwd      %%mm1, %%mm1        \n\t"
332             "punpckhdq      %%mm1, %%mm1        \n\t"
333             "movq           %%mm1,  (%0, %2)    \n\t"
334             "movq           %%mm1, 8(%0, %2)    \n\t"
335             "add               %1, %0           \n\t"
336             "cmp               %3, %0           \n\t"
337             "jb                1b               \n\t"
338             : "+r"(ptr)
339             : "r"((x86_reg)wrap), "r"((x86_reg)width), "r"(ptr + wrap * height)
340             );
341     }
342
343     /* top and bottom (and hopefully also the corners) */
344     if (sides & EDGE_TOP) {
345         for (i = 0; i < h; i += 4) {
346             ptr = buf - (i + 1) * wrap - w;
347             __asm__ volatile (
348                 "1:                             \n\t"
349                 "movq (%1, %0), %%mm0           \n\t"
350                 "movq    %%mm0, (%0)            \n\t"
351                 "movq    %%mm0, (%0, %2)        \n\t"
352                 "movq    %%mm0, (%0, %2, 2)     \n\t"
353                 "movq    %%mm0, (%0, %3)        \n\t"
354                 "add        $8, %0              \n\t"
355                 "cmp        %4, %0              \n\t"
356                 "jb         1b                  \n\t"
357                 : "+r"(ptr)
358                 : "r"((x86_reg)buf - (x86_reg)ptr - w), "r"((x86_reg) -wrap),
359                   "r"((x86_reg) -wrap * 3), "r"(ptr + width + 2 * w)
360                 );
361         }
362     }
363
364     if (sides & EDGE_BOTTOM) {
365         for (i = 0; i < h; i += 4) {
366             ptr = last_line + (i + 1) * wrap - w;
367             __asm__ volatile (
368                 "1:                             \n\t"
369                 "movq (%1, %0), %%mm0           \n\t"
370                 "movq    %%mm0, (%0)            \n\t"
371                 "movq    %%mm0, (%0, %2)        \n\t"
372                 "movq    %%mm0, (%0, %2, 2)     \n\t"
373                 "movq    %%mm0, (%0, %3)        \n\t"
374                 "add        $8, %0              \n\t"
375                 "cmp        %4, %0              \n\t"
376                 "jb         1b                  \n\t"
377                 : "+r"(ptr)
378                 : "r"((x86_reg)last_line - (x86_reg)ptr - w),
379                   "r"((x86_reg)wrap), "r"((x86_reg)wrap * 3),
380                   "r"(ptr + width + 2 * w)
381                 );
382         }
383     }
384 }
385
386 void ff_gmc_mmx(uint8_t *dst, uint8_t *src,
387                 int stride, int h, int ox, int oy,
388                 int dxx, int dxy, int dyx, int dyy,
389                 int shift, int r, int width, int height)
390 {
391     const int w    = 8;
392     const int ix   = ox  >> (16 + shift);
393     const int iy   = oy  >> (16 + shift);
394     const int oxs  = ox  >> 4;
395     const int oys  = oy  >> 4;
396     const int dxxs = dxx >> 4;
397     const int dxys = dxy >> 4;
398     const int dyxs = dyx >> 4;
399     const int dyys = dyy >> 4;
400     const uint16_t r4[4]   = { r, r, r, r };
401     const uint16_t dxy4[4] = { dxys, dxys, dxys, dxys };
402     const uint16_t dyy4[4] = { dyys, dyys, dyys, dyys };
403     const uint64_t shift2 = 2 * shift;
404     int x, y;
405
406     const int dxw = (dxx - (1 << (16 + shift))) * (w - 1);
407     const int dyh = (dyy - (1 << (16 + shift))) * (h - 1);
408     const int dxh = dxy * (h - 1);
409     const int dyw = dyx * (w - 1);
410     if ( // non-constant fullpel offset (3% of blocks)
411         ((ox ^ (ox + dxw)) | (ox ^ (ox + dxh)) | (ox ^ (ox + dxw + dxh)) |
412          (oy ^ (oy + dyw)) | (oy ^ (oy + dyh)) | (oy ^ (oy + dyw + dyh))) >> (16 + shift)
413         // uses more than 16 bits of subpel mv (only at huge resolution)
414         || (dxx | dxy | dyx | dyy) & 15 ||
415         (unsigned)ix >= width  - w ||
416         (unsigned)iy >= height - h) {
417         // FIXME could still use mmx for some of the rows
418         ff_gmc_c(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy,
419                  shift, r, width, height);
420         return;
421     }
422
423     src += ix + iy * stride;
424
425     __asm__ volatile (
426         "movd         %0, %%mm6         \n\t"
427         "pxor      %%mm7, %%mm7         \n\t"
428         "punpcklwd %%mm6, %%mm6         \n\t"
429         "punpcklwd %%mm6, %%mm6         \n\t"
430         :: "r"(1<<shift)
431     );
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
457             __asm__ volatile (
458                 "movq      %%mm6, %%mm2 \n\t"
459                 "movq      %%mm6, %%mm1 \n\t"
460                 "psubw     %%mm4, %%mm2 \n\t"
461                 "psubw     %%mm5, %%mm1 \n\t"
462                 "movq      %%mm2, %%mm0 \n\t"
463                 "movq      %%mm4, %%mm3 \n\t"
464                 "pmullw    %%mm1, %%mm0 \n\t" // (s - dx) * (s - dy)
465                 "pmullw    %%mm5, %%mm3 \n\t" // dx * dy
466                 "pmullw    %%mm5, %%mm2 \n\t" // (s - dx) * dy
467                 "pmullw    %%mm4, %%mm1 \n\t" // dx * (s - dy)
468
469                 "movd         %4, %%mm5 \n\t"
470                 "movd         %3, %%mm4 \n\t"
471                 "punpcklbw %%mm7, %%mm5 \n\t"
472                 "punpcklbw %%mm7, %%mm4 \n\t"
473                 "pmullw    %%mm5, %%mm3 \n\t" // src[1, 1] * dx * dy
474                 "pmullw    %%mm4, %%mm2 \n\t" // src[0, 1] * (s - dx) * dy
475
476                 "movd         %2, %%mm5 \n\t"
477                 "movd         %1, %%mm4 \n\t"
478                 "punpcklbw %%mm7, %%mm5 \n\t"
479                 "punpcklbw %%mm7, %%mm4 \n\t"
480                 "pmullw    %%mm5, %%mm1 \n\t" // src[1, 0] * dx * (s - dy)
481                 "pmullw    %%mm4, %%mm0 \n\t" // src[0, 0] * (s - dx) * (s - dy)
482                 "paddw        %5, %%mm1 \n\t"
483                 "paddw     %%mm3, %%mm2 \n\t"
484                 "paddw     %%mm1, %%mm0 \n\t"
485                 "paddw     %%mm2, %%mm0 \n\t"
486
487                 "psrlw        %6, %%mm0 \n\t"
488                 "packuswb  %%mm0, %%mm0 \n\t"
489                 "movd      %%mm0, %0    \n\t"
490
491                 : "=m"(dst[x + y * stride])
492                 : "m"(src[0]), "m"(src[1]),
493                   "m"(src[stride]), "m"(src[stride + 1]),
494                   "m"(*r4), "m"(shift2)
495             );
496             src += stride;
497         }
498         src += 4 - h * stride;
499     }
500 }
501
502 void ff_vector_clipf_sse(float *dst, const float *src,
503                          float min, float max, int len)
504 {
505     x86_reg i = (len - 16) * 4;
506     __asm__ volatile (
507         "movss          %3, %%xmm4      \n\t"
508         "movss          %4, %%xmm5      \n\t"
509         "shufps $0, %%xmm4, %%xmm4      \n\t"
510         "shufps $0, %%xmm5, %%xmm5      \n\t"
511         "1:                             \n\t"
512         "movaps   (%2, %0), %%xmm0      \n\t" // 3/1 on intel
513         "movaps 16(%2, %0), %%xmm1      \n\t"
514         "movaps 32(%2, %0), %%xmm2      \n\t"
515         "movaps 48(%2, %0), %%xmm3      \n\t"
516         "maxps      %%xmm4, %%xmm0      \n\t"
517         "maxps      %%xmm4, %%xmm1      \n\t"
518         "maxps      %%xmm4, %%xmm2      \n\t"
519         "maxps      %%xmm4, %%xmm3      \n\t"
520         "minps      %%xmm5, %%xmm0      \n\t"
521         "minps      %%xmm5, %%xmm1      \n\t"
522         "minps      %%xmm5, %%xmm2      \n\t"
523         "minps      %%xmm5, %%xmm3      \n\t"
524         "movaps     %%xmm0,   (%1, %0)  \n\t"
525         "movaps     %%xmm1, 16(%1, %0)  \n\t"
526         "movaps     %%xmm2, 32(%1, %0)  \n\t"
527         "movaps     %%xmm3, 48(%1, %0)  \n\t"
528         "sub           $64, %0          \n\t"
529         "jge            1b              \n\t"
530         : "+&r"(i)
531         : "r"(dst), "r"(src), "m"(min), "m"(max)
532         : "memory"
533     );
534 }
535
536 #endif /* HAVE_INLINE_ASM */