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.
38363 Commits
32 Branches
1.0GB
Tree: 15748773bf
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '15748773bf'
${ noResults }
FFmpeg/libavcodec/x86/dsputil_mmx.c

499 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. 

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

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

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

  255.                        int w, int h, int sides)

  256. {

  257.     uint8_t *ptr, *last_line;

  258.     int i;

  259. 

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

  261.     /* left and right */

  262.     ptr = buf;

  263.     if (w == 8) {

  264.         __asm__ volatile (

  265.             "1:                             \n\t"

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

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

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

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

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

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

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

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

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

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

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

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

  278.             "jb                1b           \n\t"

  279.             : "+r"(ptr)

  280.             : "r"((x86_reg)wrap), "r"((x86_reg)width), "r"(ptr + wrap * height)

  281.             );

  282.     } else {

  283.         __asm__ volatile (

  284.             "1:                                 \n\t"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  299.             "jb                1b               \n\t"

  300.             : "+r"(ptr)

  301.             : "r"((x86_reg)wrap), "r"((x86_reg)width), "r"(ptr + wrap * height)

  302.             );

  303.     }

  304. 

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

  306.     if (sides & EDGE_TOP) {

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

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

  309.             __asm__ volatile (

  310.                 "1:                             \n\t"

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

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

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

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

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

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

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

  318.                 "jb         1b                  \n\t"

  319.                 : "+r"(ptr)

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

  321.                   "r"((x86_reg) -wrap * 3), "r"(ptr + width + 2 * w)

  322.                 );

  323.         }

  324.     }

  325. 

  326.     if (sides & EDGE_BOTTOM) {

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

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

  329.             __asm__ volatile (

  330.                 "1:                             \n\t"

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

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

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

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

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

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

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

  338.                 "jb         1b                  \n\t"

  339.                 : "+r"(ptr)

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

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

  342.                   "r"(ptr + width + 2 * w)

  343.                 );

  344.         }

  345.     }

  346. }

  347. 

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

  349.                 int stride, int h, int ox, int oy,

  350.                 int dxx, int dxy, int dyx, int dyy,

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

  352. {

  353.     const int w    = 8;

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

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

  356.     const int oxs  = ox  >> 4;

  357.     const int oys  = oy  >> 4;

  358.     const int dxxs = dxx >> 4;

  359.     const int dxys = dxy >> 4;

  360.     const int dyxs = dyx >> 4;

  361.     const int dyys = dyy >> 4;

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

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

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

  365.     const uint64_t shift2 = 2 * shift;

  366.     int x, y;

  367. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  381.                  shift, r, width, height);

  382.         return;

  383.     }

  384. 

  385.     src += ix + iy * stride;

  386. 

  387.     __asm__ volatile (

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

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

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

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

  392.         :: "r"(1<<shift)

  393.     );

  394. 

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

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

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

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

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

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

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

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

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

  404. 

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

  406.             __asm__ volatile (

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

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

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

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

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

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

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

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

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

  416.                 : "m"(*dxy4), "m"(*dyy4)

  417.             );

  418. 

  419.             __asm__ volatile (

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

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

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

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

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

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

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

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

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

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

  430. 

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

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

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

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

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

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

  437. 

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

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

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

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

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

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

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

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

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

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

  448. 

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

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

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

  452. 

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

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

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

  456.                   "m"(*r4), "m"(shift2)

  457.             );

  458.             src += stride;

  459.         }

  460.         src += 4 - h * stride;

  461.     }

  462. }

  463. 

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

  465.                          float min, float max, int len)

  466. {

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

  468.     __asm__ volatile (

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

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

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

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

  473.         "1:                             \n\t"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  491.         "jge            1b              \n\t"

  492.         : "+&r"(i)

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

  494.         : "memory"

  495.     );

  496. }

  497. 

  498. #endif /* HAVE_INLINE_ASM */