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.
39727 Commits
32 Branches
552MB
Tree: b718b24bbe
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b718b24bbe'
${ noResults }
FFmpeg/libavcodec/x86/dsputil_mmx.c

494 lines
19KB
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. 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 */