falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
39979 Commits
32 Branches
1.1GB
Tree: 593886b5dd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '593886b5dd'
${ noResults }
FFmpeg/libavcodec/x86/dsputil_mmx.c

468 lines
18KB
Raw Blame History 

  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. /* Draw the edges of width 'w' of an image of size width, height

  226.  * this MMX version can only handle w == 8 || w == 16. */

  227. void ff_draw_edges_mmx(uint8_t *buf, int wrap, int width, int height,

  228.                        int w, int h, int sides)

  229. {

  230.     uint8_t *ptr, *last_line;

  231.     int i;

  232. 

  233.     last_line = buf + (height - 1) * wrap;

  234.     /* left and right */

  235.     ptr = buf;

  236.     if (w == 8) {

  237.         __asm__ volatile (

  238.             "1:                             \n\t"

  239.             "movd            (%0), %%mm0    \n\t"

  240.             "punpcklbw      %%mm0, %%mm0    \n\t"

  241.             "punpcklwd      %%mm0, %%mm0    \n\t"

  242.             "punpckldq      %%mm0, %%mm0    \n\t"

  243.             "movq           %%mm0, -8(%0)   \n\t"

  244.             "movq      -8(%0, %2), %%mm1    \n\t"

  245.             "punpckhbw      %%mm1, %%mm1    \n\t"

  246.             "punpckhwd      %%mm1, %%mm1    \n\t"

  247.             "punpckhdq      %%mm1, %%mm1    \n\t"

  248.             "movq           %%mm1, (%0, %2) \n\t"

  249.             "add               %1, %0       \n\t"

  250.             "cmp               %3, %0       \n\t"

  251.             "jb                1b           \n\t"

  252.             : "+r" (ptr)

  253.             : "r" ((x86_reg) wrap), "r" ((x86_reg) width),

  254.               "r" (ptr + wrap * height));

  255.     } else {

  256.         __asm__ volatile (

  257.             "1:                                 \n\t"

  258.             "movd            (%0), %%mm0        \n\t"

  259.             "punpcklbw      %%mm0, %%mm0        \n\t"

  260.             "punpcklwd      %%mm0, %%mm0        \n\t"

  261.             "punpckldq      %%mm0, %%mm0        \n\t"

  262.             "movq           %%mm0, -8(%0)       \n\t"

  263.             "movq           %%mm0, -16(%0)      \n\t"

  264.             "movq      -8(%0, %2), %%mm1        \n\t"

  265.             "punpckhbw      %%mm1, %%mm1        \n\t"

  266.             "punpckhwd      %%mm1, %%mm1        \n\t"

  267.             "punpckhdq      %%mm1, %%mm1        \n\t"

  268.             "movq           %%mm1,  (%0, %2)    \n\t"

  269.             "movq           %%mm1, 8(%0, %2)    \n\t"

  270.             "add               %1, %0           \n\t"

  271.             "cmp               %3, %0           \n\t"

  272.             "jb                1b               \n\t"

  273.             : "+r" (ptr)

  274.             : "r" ((x86_reg) wrap), "r" ((x86_reg) width),

  275.               "r" (ptr + wrap * height));

  276.     }

  277. 

  278.     /* top and bottom (and hopefully also the corners) */

  279.     if (sides & EDGE_TOP) {

  280.         for (i = 0; i < h; i += 4) {

  281.             ptr = buf - (i + 1) * wrap - w;

  282.             __asm__ volatile (

  283.                 "1:                             \n\t"

  284.                 "movq (%1, %0), %%mm0           \n\t"

  285.                 "movq    %%mm0, (%0)            \n\t"

  286.                 "movq    %%mm0, (%0, %2)        \n\t"

  287.                 "movq    %%mm0, (%0, %2, 2)     \n\t"

  288.                 "movq    %%mm0, (%0, %3)        \n\t"

  289.                 "add        $8, %0              \n\t"

  290.                 "cmp        %4, %0              \n\t"

  291.                 "jb         1b                  \n\t"

  292.                 : "+r" (ptr)

  293.                 : "r" ((x86_reg) buf - (x86_reg) ptr - w),

  294.                   "r" ((x86_reg) - wrap), "r" ((x86_reg) - wrap * 3),

  295.                   "r" (ptr + width + 2 * w));

  296.         }

  297.     }

  298. 

  299.     if (sides & EDGE_BOTTOM) {

  300.         for (i = 0; i < h; i += 4) {

  301.             ptr = last_line + (i + 1) * wrap - w;

  302.             __asm__ volatile (

  303.                 "1:                             \n\t"

  304.                 "movq (%1, %0), %%mm0           \n\t"

  305.                 "movq    %%mm0, (%0)            \n\t"

  306.                 "movq    %%mm0, (%0, %2)        \n\t"

  307.                 "movq    %%mm0, (%0, %2, 2)     \n\t"

  308.                 "movq    %%mm0, (%0, %3)        \n\t"

  309.                 "add        $8, %0              \n\t"

  310.                 "cmp        %4, %0              \n\t"

  311.                 "jb         1b                  \n\t"

  312.                 : "+r" (ptr)

  313.                 : "r" ((x86_reg) last_line - (x86_reg) ptr - w),

  314.                   "r" ((x86_reg) wrap), "r" ((x86_reg) wrap * 3),

  315.                   "r" (ptr + width + 2 * w));

  316.         }

  317.     }

  318. }

  319. 

  320. void ff_gmc_mmx(uint8_t *dst, uint8_t *src,

  321.                 int stride, int h, int ox, int oy,

  322.                 int dxx, int dxy, int dyx, int dyy,

  323.                 int shift, int r, int width, int height)

  324. {

  325.     const int w    = 8;

  326.     const int ix   = ox  >> (16 + shift);

  327.     const int iy   = oy  >> (16 + shift);

  328.     const int oxs  = ox  >> 4;

  329.     const int oys  = oy  >> 4;

  330.     const int dxxs = dxx >> 4;

  331.     const int dxys = dxy >> 4;

  332.     const int dyxs = dyx >> 4;

  333.     const int dyys = dyy >> 4;

  334.     const uint16_t r4[4]   = { r, r, r, r };

  335.     const uint16_t dxy4[4] = { dxys, dxys, dxys, dxys };

  336.     const uint16_t dyy4[4] = { dyys, dyys, dyys, dyys };

  337.     const uint64_t shift2  = 2 * shift;

  338.     int x, y;

  339. 

  340.     const int dxw = (dxx - (1 << (16 + shift))) * (w - 1);

  341.     const int dyh = (dyy - (1 << (16 + shift))) * (h - 1);

  342.     const int dxh = dxy * (h - 1);

  343.     const int dyw = dyx * (w - 1);

  344. 

  345.     if ( // non-constant fullpel offset (3% of blocks)

  346.         ((ox ^ (ox + dxw)) | (ox ^ (ox + dxh)) | (ox ^ (ox + dxw + dxh)) |

  347.          (oy ^ (oy + dyw)) | (oy ^ (oy + dyh)) | (oy ^ (oy + dyw + dyh))) >> (16 + shift) ||

  348.         // uses more than 16 bits of subpel mv (only at huge resolution)

  349.         (dxx | dxy | dyx | dyy) & 15 ||

  350.         (unsigned) ix >= width  - w ||

  351.         (unsigned) iy >= height - h) {

  352.         // FIXME could still use mmx for some of the rows

  353.         ff_gmc_c(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy,

  354.                  shift, r, width, height);

  355.         return;

  356.     }

  357. 

  358.     src += ix + iy * stride;

  359. 

  360.     __asm__ volatile (

  361.         "movd         %0, %%mm6         \n\t"

  362.         "pxor      %%mm7, %%mm7         \n\t"

  363.         "punpcklwd %%mm6, %%mm6         \n\t"

  364.         "punpcklwd %%mm6, %%mm6         \n\t"

  365.         :: "r" (1 << shift));

  366. 

  367.     for (x = 0; x < w; x += 4) {

  368.         uint16_t dx4[4] = { oxs - dxys + dxxs * (x + 0),

  369.                             oxs - dxys + dxxs * (x + 1),

  370.                             oxs - dxys + dxxs * (x + 2),

  371.                             oxs - dxys + dxxs * (x + 3) };

  372.         uint16_t dy4[4] = { oys - dyys + dyxs * (x + 0),

  373.                             oys - dyys + dyxs * (x + 1),

  374.                             oys - dyys + dyxs * (x + 2),

  375.                             oys - dyys + dyxs * (x + 3) };

  376. 

  377.         for (y = 0; y < h; y++) {

  378.             __asm__ volatile (

  379.                 "movq      %0, %%mm4    \n\t"

  380.                 "movq      %1, %%mm5    \n\t"

  381.                 "paddw     %2, %%mm4    \n\t"

  382.                 "paddw     %3, %%mm5    \n\t"

  383.                 "movq   %%mm4, %0       \n\t"

  384.                 "movq   %%mm5, %1       \n\t"

  385.                 "psrlw    $12, %%mm4    \n\t"

  386.                 "psrlw    $12, %%mm5    \n\t"

  387.                 : "+m" (*dx4), "+m" (*dy4)

  388.                 : "m" (*dxy4), "m" (*dyy4));

  389. 

  390.             __asm__ volatile (

  391.                 "movq      %%mm6, %%mm2 \n\t"

  392.                 "movq      %%mm6, %%mm1 \n\t"

  393.                 "psubw     %%mm4, %%mm2 \n\t"

  394.                 "psubw     %%mm5, %%mm1 \n\t"

  395.                 "movq      %%mm2, %%mm0 \n\t"

  396.                 "movq      %%mm4, %%mm3 \n\t"

  397.                 "pmullw    %%mm1, %%mm0 \n\t" // (s - dx) * (s - dy)

  398.                 "pmullw    %%mm5, %%mm3 \n\t" // dx * dy

  399.                 "pmullw    %%mm5, %%mm2 \n\t" // (s - dx) * dy

  400.                 "pmullw    %%mm4, %%mm1 \n\t" // dx * (s - dy)

  401. 

  402.                 "movd         %4, %%mm5 \n\t"

  403.                 "movd         %3, %%mm4 \n\t"

  404.                 "punpcklbw %%mm7, %%mm5 \n\t"

  405.                 "punpcklbw %%mm7, %%mm4 \n\t"

  406.                 "pmullw    %%mm5, %%mm3 \n\t" // src[1, 1] * dx * dy

  407.                 "pmullw    %%mm4, %%mm2 \n\t" // src[0, 1] * (s - dx) * dy

  408. 

  409.                 "movd         %2, %%mm5 \n\t"

  410.                 "movd         %1, %%mm4 \n\t"

  411.                 "punpcklbw %%mm7, %%mm5 \n\t"

  412.                 "punpcklbw %%mm7, %%mm4 \n\t"

  413.                 "pmullw    %%mm5, %%mm1 \n\t" // src[1, 0] * dx * (s - dy)

  414.                 "pmullw    %%mm4, %%mm0 \n\t" // src[0, 0] * (s - dx) * (s - dy)

  415.                 "paddw        %5, %%mm1 \n\t"

  416.                 "paddw     %%mm3, %%mm2 \n\t"

  417.                 "paddw     %%mm1, %%mm0 \n\t"

  418.                 "paddw     %%mm2, %%mm0 \n\t"

  419. 

  420.                 "psrlw        %6, %%mm0 \n\t"

  421.                 "packuswb  %%mm0, %%mm0 \n\t"

  422.                 "movd      %%mm0, %0    \n\t"

  423. 

  424.                 : "=m" (dst[x + y * stride])

  425.                 : "m" (src[0]), "m" (src[1]),

  426.                   "m" (src[stride]), "m" (src[stride + 1]),

  427.                   "m" (*r4), "m" (shift2));

  428.             src += stride;

  429.         }

  430.         src += 4 - h * stride;

  431.     }

  432. }

  433. 

  434. void ff_vector_clipf_sse(float *dst, const float *src,

  435.                          float min, float max, int len)

  436. {

  437.     x86_reg i = (len - 16) * 4;

  438.     __asm__ volatile (

  439.         "movss          %3, %%xmm4      \n\t"

  440.         "movss          %4, %%xmm5      \n\t"

  441.         "shufps $0, %%xmm4, %%xmm4      \n\t"

  442.         "shufps $0, %%xmm5, %%xmm5      \n\t"

  443.         "1:                             \n\t"

  444.         "movaps   (%2, %0), %%xmm0      \n\t" // 3/1 on intel

  445.         "movaps 16(%2, %0), %%xmm1      \n\t"

  446.         "movaps 32(%2, %0), %%xmm2      \n\t"

  447.         "movaps 48(%2, %0), %%xmm3      \n\t"

  448.         "maxps      %%xmm4, %%xmm0      \n\t"

  449.         "maxps      %%xmm4, %%xmm1      \n\t"

  450.         "maxps      %%xmm4, %%xmm2      \n\t"

  451.         "maxps      %%xmm4, %%xmm3      \n\t"

  452.         "minps      %%xmm5, %%xmm0      \n\t"

  453.         "minps      %%xmm5, %%xmm1      \n\t"

  454.         "minps      %%xmm5, %%xmm2      \n\t"

  455.         "minps      %%xmm5, %%xmm3      \n\t"

  456.         "movaps     %%xmm0,   (%1, %0)  \n\t"

  457.         "movaps     %%xmm1, 16(%1, %0)  \n\t"

  458.         "movaps     %%xmm2, 32(%1, %0)  \n\t"

  459.         "movaps     %%xmm3, 48(%1, %0)  \n\t"

  460.         "sub           $64, %0          \n\t"

  461.         "jge            1b              \n\t"

  462.         : "+&r" (i)

  463.         : "r" (dst), "r" (src), "m" (min), "m" (max)

  464.         : "memory");

  465. }

  466. 

  467. #endif /* HAVE_INLINE_ASM */