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

493 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),

  87.            "r" (p)

  88.         : "memory");

  89. }

  90. 

  91. #define put_signed_pixels_clamped_mmx_half(off)             \

  92.     "movq          "#off"(%2), %%mm1        \n\t"           \

  93.     "movq     16 + "#off"(%2), %%mm2        \n\t"           \

  94.     "movq     32 + "#off"(%2), %%mm3        \n\t"           \

  95.     "movq     48 + "#off"(%2), %%mm4        \n\t"           \

  96.     "packsswb  8 + "#off"(%2), %%mm1        \n\t"           \

  97.     "packsswb 24 + "#off"(%2), %%mm2        \n\t"           \

  98.     "packsswb 40 + "#off"(%2), %%mm3        \n\t"           \

  99.     "packsswb 56 + "#off"(%2), %%mm4        \n\t"           \

  100.     "paddb              %%mm0, %%mm1        \n\t"           \

  101.     "paddb              %%mm0, %%mm2        \n\t"           \

  102.     "paddb              %%mm0, %%mm3        \n\t"           \

  103.     "paddb              %%mm0, %%mm4        \n\t"           \

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

  105.     "movq               %%mm2, (%0, %3)     \n\t"           \

  106.     "movq               %%mm3, (%0, %3, 2)  \n\t"           \

  107.     "movq               %%mm4, (%0, %1)     \n\t"

  108. 

  109. void ff_put_signed_pixels_clamped_mmx(const int16_t *block, uint8_t *pixels,

  110.                                       int line_size)

  111. {

  112.     x86_reg line_skip = line_size;

  113.     x86_reg line_skip3;

  114. 

  115.     __asm__ volatile (

  116.         "movq "MANGLE(ff_pb_80)", %%mm0     \n\t"

  117.         "lea         (%3, %3, 2), %1        \n\t"

  118.         put_signed_pixels_clamped_mmx_half(0)

  119.         "lea         (%0, %3, 4), %0        \n\t"

  120.         put_signed_pixels_clamped_mmx_half(64)

  121.         : "+&r" (pixels), "=&r" (line_skip3)

  122.         : "r" (block), "r" (line_skip)

  123.         : "memory");

  124. }

  125. 

  126. void ff_add_pixels_clamped_mmx(const int16_t *block, uint8_t *pixels,

  127.                                int line_size)

  128. {

  129.     const int16_t *p;

  130.     uint8_t *pix;

  131.     int i;

  132. 

  133.     /* read the pixels */

  134.     p   = block;

  135.     pix = pixels;

  136.     MOVQ_ZERO(mm7);

  137.     i = 4;

  138.     do {

  139.         __asm__ volatile (

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

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

  142.             "movq      16(%2), %%mm2    \n\t"

  143.             "movq      24(%2), %%mm3    \n\t"

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

  145.             "movq          %1, %%mm6    \n\t"

  146.             "movq       %%mm4, %%mm5    \n\t"

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

  148.             "punpckhbw  %%mm7, %%mm5    \n\t"

  149.             "paddsw     %%mm4, %%mm0    \n\t"

  150.             "paddsw     %%mm5, %%mm1    \n\t"

  151.             "movq       %%mm6, %%mm5    \n\t"

  152.             "punpcklbw  %%mm7, %%mm6    \n\t"

  153.             "punpckhbw  %%mm7, %%mm5    \n\t"

  154.             "paddsw     %%mm6, %%mm2    \n\t"

  155.             "paddsw     %%mm5, %%mm3    \n\t"

  156.             "packuswb   %%mm1, %%mm0    \n\t"

  157.             "packuswb   %%mm3, %%mm2    \n\t"

  158.             "movq       %%mm0, %0       \n\t"

  159.             "movq       %%mm2, %1       \n\t"

  160.             : "+m" (*pix), "+m" (*(pix + line_size))

  161.             : "r" (p)

  162.             : "memory");

  163.         pix += line_size * 2;

  164.         p   += 16;

  165.     } while (--i);

  166. }

  167. 

  168. #define CLEAR_BLOCKS(name, n)                           \

  169. void name(int16_t *blocks)                              \

  170. {                                                       \

  171.     __asm__ volatile (                                  \

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

  173.         "mov     %1,        %%"REG_a"   \n\t"           \

  174.         "1:                             \n\t"           \

  175.         "movq %%mm7,   (%0, %%"REG_a")  \n\t"           \

  176.         "movq %%mm7,  8(%0, %%"REG_a")  \n\t"           \

  177.         "movq %%mm7, 16(%0, %%"REG_a")  \n\t"           \

  178.         "movq %%mm7, 24(%0, %%"REG_a")  \n\t"           \

  179.         "add    $32, %%"REG_a"          \n\t"           \

  180.         "js      1b                     \n\t"           \

  181.         :: "r"(((uint8_t *) blocks) + 128 * n),         \

  182.            "i"(-128 * n)                                \

  183.         : "%"REG_a);                                    \

  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. void ff_clear_blocks_sse(int16_t *blocks)

  205. {

  206.     __asm__ volatile (

  207.         "xorps  %%xmm0, %%xmm0              \n"

  208.         "mov        %1,         %%"REG_a"   \n"

  209.         "1:                                 \n"

  210.         "movaps %%xmm0,    (%0, %%"REG_a")  \n"

  211.         "movaps %%xmm0,  16(%0, %%"REG_a")  \n"

  212.         "movaps %%xmm0,  32(%0, %%"REG_a")  \n"

  213.         "movaps %%xmm0,  48(%0, %%"REG_a")  \n"

  214.         "movaps %%xmm0,  64(%0, %%"REG_a")  \n"

  215.         "movaps %%xmm0,  80(%0, %%"REG_a")  \n"

  216.         "movaps %%xmm0,  96(%0, %%"REG_a")  \n"

  217.         "movaps %%xmm0, 112(%0, %%"REG_a")  \n"

  218.         "add      $128,         %%"REG_a"   \n"

  219.         "js         1b                      \n"

  220.         :: "r"(((uint8_t *) blocks) + 128 * 6), "i"(-128 * 6)

  221.         : "%"REG_a);

  222. }

  223. 

  224. void ff_add_bytes_mmx(uint8_t *dst, uint8_t *src, int w)

  225. {

  226.     x86_reg i = 0;

  227. 

  228.     __asm__ volatile (

  229.         "jmp          2f                \n\t"

  230.         "1:                             \n\t"

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

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

  233.         "paddb     %%mm0, %%mm1         \n\t"

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

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

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

  237.         "paddb     %%mm0, %%mm1         \n\t"

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

  239.         "add         $16, %0            \n\t"

  240.         "2:                             \n\t"

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

  242.         "js           1b                \n\t"

  243.         : "+r" (i)

  244.         : "r" (src), "r" (dst), "r" ((x86_reg) w - 15));

  245. 

  246.     for (; i < w; i++)

  247.         dst[i + 0] += src[i + 0];

  248. }

  249. 

  250. /* Draw the edges of width 'w' of an image of size width, height

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

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

  253.                        int w, int h, int sides)

  254. {

  255.     uint8_t *ptr, *last_line;

  256.     int i;

  257. 

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

  259.     /* left and right */

  260.     ptr = buf;

  261.     if (w == 8) {

  262.         __asm__ volatile (

  263.             "1:                             \n\t"

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

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

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

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

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

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

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

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

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

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

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

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

  276.             "jb                1b           \n\t"

  277.             : "+r" (ptr)

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

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

  280.     } else {

  281.         __asm__ volatile (

  282.             "1:                                 \n\t"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  297.             "jb                1b               \n\t"

  298.             : "+r" (ptr)

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

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

  301.     }

  302. 

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

  304.     if (sides & EDGE_TOP) {

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

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

  307.             __asm__ volatile (

  308.                 "1:                             \n\t"

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

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

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

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

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

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

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

  316.                 "jb         1b                  \n\t"

  317.                 : "+r" (ptr)

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

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

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

  321.         }

  322.     }

  323. 

  324.     if (sides & EDGE_BOTTOM) {

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

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

  327.             __asm__ volatile (

  328.                 "1:                             \n\t"

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

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

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

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

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

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

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

  336.                 "jb         1b                  \n\t"

  337.                 : "+r" (ptr)

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

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

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

  341.         }

  342.     }

  343. }

  344. 

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

  346.                 int stride, int h, int ox, int oy,

  347.                 int dxx, int dxy, int dyx, int dyy,

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

  349. {

  350.     const int w    = 8;

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

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

  353.     const int oxs  = ox  >> 4;

  354.     const int oys  = oy  >> 4;

  355.     const int dxxs = dxx >> 4;

  356.     const int dxys = dxy >> 4;

  357.     const int dyxs = dyx >> 4;

  358.     const int dyys = dyy >> 4;

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

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

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

  362.     const uint64_t shift2  = 2 * shift;

  363.     int x, y;

  364. 

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

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

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

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

  369. 

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

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

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

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

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

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

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

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

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

  379.                  shift, r, width, height);

  380.         return;

  381.     }

  382. 

  383.     src += ix + iy * stride;

  384. 

  385.     __asm__ volatile (

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

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

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

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

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

  391. 

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

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

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

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

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

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

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

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

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

  401. 

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

  403.             __asm__ volatile (

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

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

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

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

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

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

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

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

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

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

  414. 

  415.             __asm__ volatile (

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

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

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

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

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

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

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

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

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

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

  426. 

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

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

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

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

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

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

  433. 

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

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

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

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

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

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

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

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

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

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

  444. 

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

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

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

  448. 

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

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

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

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

  453.             src += stride;

  454.         }

  455.         src += 4 - h * stride;

  456.     }

  457. }

  458. 

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

  460.                          float min, float max, int len)

  461. {

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

  463.     __asm__ volatile (

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

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

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

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

  468.         "1:                             \n\t"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  486.         "jge            1b              \n\t"

  487.         : "+&r" (i)

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

  489.         : "memory");

  490. }

  491. 

  492. #endif /* HAVE_INLINE_ASM */