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

632 lines
24KB
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.  * This file is part of FFmpeg.

  7.  *

  8.  * FFmpeg is free software; you can redistribute it and/or

  9.  * modify it under the terms of the GNU Lesser General Public

  10.  * License as published by the Free Software Foundation; either

  11.  * version 2.1 of the License, or (at your option) any later version.

  12.  *

  13.  * FFmpeg is distributed in the hope that it will be useful,

  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  16.  * Lesser General Public License for more details.

  17.  *

  18.  * You should have received a copy of the GNU Lesser General Public

  19.  * License along with FFmpeg; if not, write to the Free Software

  20.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  21.  *

  22.  * MMX optimization by Nick Kurshev <nickols_k@mail.ru>

  23.  */

  24. 

  25. #include "config.h"

  26. #include "libavutil/avassert.h"

  27. #include "libavutil/cpu.h"

  28. #include "libavutil/x86/asm.h"

  29. #include "libavcodec/videodsp.h"

  30. #include "constants.h"

  31. #include "dsputil_x86.h"

  32. #include "diracdsp_mmx.h"

  33. 

  34. #if HAVE_INLINE_ASM

  35. 

  36. void ff_put_pixels_clamped_mmx(const int16_t *block, uint8_t *pixels,

  37.                                int line_size)

  38. {

  39.     const int16_t *p;

  40.     uint8_t *pix;

  41. 

  42.     /* read the pixels */

  43.     p   = block;

  44.     pix = pixels;

  45.     /* unrolled loop */

  46.     __asm__ volatile (

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

  48.         "movq     8(%3), %%mm1          \n\t"

  49.         "movq    16(%3), %%mm2          \n\t"

  50.         "movq    24(%3), %%mm3          \n\t"

  51.         "movq    32(%3), %%mm4          \n\t"

  52.         "movq    40(%3), %%mm5          \n\t"

  53.         "movq    48(%3), %%mm6          \n\t"

  54.         "movq    56(%3), %%mm7          \n\t"

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

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

  57.         "packuswb %%mm5, %%mm4          \n\t"

  58.         "packuswb %%mm7, %%mm6          \n\t"

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

  60.         "movq     %%mm2, (%0, %1)       \n\t"

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

  62.         "movq     %%mm6, (%0, %2)       \n\t"

  63.         :: "r" (pix), "r" ((x86_reg) line_size), "r" ((x86_reg) line_size * 3),

  64.            "r" (p)

  65.         : "memory");

  66.     pix += line_size * 4;

  67.     p   += 32;

  68. 

  69.     // if here would be an exact copy of the code above

  70.     // compiler would generate some very strange code

  71.     // thus using "r"

  72.     __asm__ volatile (

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

  74.         "movq      8(%3), %%mm1         \n\t"

  75.         "movq     16(%3), %%mm2         \n\t"

  76.         "movq     24(%3), %%mm3         \n\t"

  77.         "movq     32(%3), %%mm4         \n\t"

  78.         "movq     40(%3), %%mm5         \n\t"

  79.         "movq     48(%3), %%mm6         \n\t"

  80.         "movq     56(%3), %%mm7         \n\t"

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

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

  83.         "packuswb  %%mm5, %%mm4         \n\t"

  84.         "packuswb  %%mm7, %%mm6         \n\t"

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

  86.         "movq      %%mm2, (%0, %1)      \n\t"

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

  88.         "movq      %%mm6, (%0, %2)      \n\t"

  89.         :: "r" (pix), "r" ((x86_reg) line_size), "r" ((x86_reg) line_size * 3),

  90.            "r" (p)

  91.         : "memory");

  92. }

  93. 

  94. #define put_signed_pixels_clamped_mmx_half(off)             \

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  111. 

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

  113.                                       int line_size)

  114. {

  115.     x86_reg line_skip = line_size;

  116.     x86_reg line_skip3;

  117. 

  118.     __asm__ volatile (

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

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

  121.         put_signed_pixels_clamped_mmx_half(0)

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

  123.         put_signed_pixels_clamped_mmx_half(64)

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

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

  126.         : "memory");

  127. }

  128. 

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

  130.                                int line_size)

  131. {

  132.     const int16_t *p;

  133.     uint8_t *pix;

  134.     int i;

  135. 

  136.     /* read the pixels */

  137.     p   = block;

  138.     pix = pixels;

  139.     MOVQ_ZERO(mm7);

  140.     i = 4;

  141.     do {

  142.         __asm__ volatile (

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  164.             : "r" (p)

  165.             : "memory");

  166.         pix += line_size * 2;

  167.         p   += 16;

  168.     } while (--i);

  169. }

  170. 

  171. #define CLEAR_BLOCKS(name, n)                           \

  172. void name(int16_t *blocks)                              \

  173. {                                                       \

  174.     __asm__ volatile (                                  \

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

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

  177.         "1:                             \n\t"           \

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

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

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

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

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

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

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

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

  186.         : "%"REG_a);                                    \

  187. }

  188. CLEAR_BLOCKS(ff_clear_blocks_mmx, 6)

  189. CLEAR_BLOCKS(ff_clear_block_mmx, 1)

  190. 

  191. void ff_clear_block_sse(int16_t *block)

  192. {

  193.     __asm__ volatile (

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

  195.         "movaps %%xmm0,    (%0)         \n"

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

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

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

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

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

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

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

  203.         :: "r" (block)

  204.         : "memory");

  205. }

  206. 

  207. void ff_clear_blocks_sse(int16_t *blocks)

  208. {

  209.     __asm__ volatile (

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

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

  212.         "1:                                 \n"

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

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

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

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

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

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

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

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

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

  222.         "js         1b                      \n"

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

  224.         : "%"REG_a);

  225. }

  226. 

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

  228. {

  229.     x86_reg i = 0;

  230. 

  231.     __asm__ volatile (

  232.         "jmp          2f                \n\t"

  233.         "1:                             \n\t"

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

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

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

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

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

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

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

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

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

  243.         "2:                             \n\t"

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

  245.         "js           1b                \n\t"

  246.         : "+r" (i)

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

  248. 

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

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

  251. }

  252. 

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

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

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

  256.                        int w, int h, int sides)

  257. {

  258.     uint8_t *ptr, *last_line;

  259.     int i;

  260. 

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

  262.     /* left and right */

  263.     ptr = buf;

  264.     if (w == 8) {

  265.         __asm__ volatile (

  266.             "1:                             \n\t"

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

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

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

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

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

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

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

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

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

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

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

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

  279.             "jb                1b           \n\t"

  280.             : "+r" (ptr)

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

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

  283.     } else if (w == 16) {

  284.         __asm__ volatile (

  285.             "1:                                 \n\t"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  300.             "jb                1b               \n\t"

  301.             : "+r"(ptr)

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

  303.             );

  304.     } else {

  305.         av_assert1(w == 4);

  306.         __asm__ volatile (

  307.             "1:                             \n\t"

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

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

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

  311.             "movd           %%mm0, -4(%0)   \n\t"

  312.             "movd      -4(%0, %2), %%mm1    \n\t"

  313.             "punpcklbw      %%mm1, %%mm1    \n\t"

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

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

  316.             "movd           %%mm1, (%0, %2) \n\t"

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

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

  319.             "jb                1b           \n\t"

  320.             : "+r" (ptr)

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

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

  323.     }

  324. 

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

  326.     if (sides & EDGE_TOP) {

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

  328.             ptr = buf - (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) buf - (x86_reg) ptr - w),

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

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

  343.         }

  344.     }

  345. 

  346.     if (sides & EDGE_BOTTOM) {

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

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

  349.             __asm__ volatile (

  350.                 "1:                             \n\t"

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

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

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

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

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

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

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

  358.                 "jb         1b                  \n\t"

  359.                 : "+r" (ptr)

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

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

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

  363.         }

  364.     }

  365. }

  366. 

  367. typedef void emulated_edge_mc_func(uint8_t *dst, const uint8_t *src,

  368.                                    ptrdiff_t dst_stride,

  369.                                    ptrdiff_t src_linesize,

  370.                                    int block_w, int block_h,

  371.                                    int src_x, int src_y, int w, int h);

  372. 

  373. static av_always_inline void gmc(uint8_t *dst, uint8_t *src,

  374.                                  int stride, int h, int ox, int oy,

  375.                                  int dxx, int dxy, int dyx, int dyy,

  376.                                  int shift, int r, int width, int height,

  377.                                  emulated_edge_mc_func *emu_edge_fn)

  378. {

  379.     const int w    = 8;

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

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

  382.     const int oxs  = ox  >> 4;

  383.     const int oys  = oy  >> 4;

  384.     const int dxxs = dxx >> 4;

  385.     const int dxys = dxy >> 4;

  386.     const int dyxs = dyx >> 4;

  387.     const int dyys = dyy >> 4;

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

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

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

  391.     const uint64_t shift2  = 2 * shift;

  392. #define MAX_STRIDE 4096U

  393. #define MAX_H 8U

  394.     uint8_t edge_buf[(MAX_H + 1) * MAX_STRIDE];

  395.     int x, y;

  396. 

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

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

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

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

  401.     int need_emu  =  (unsigned) ix >= width  - w ||

  402.                      (unsigned) iy >= height - h;

  403. 

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

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

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

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

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

  409.         (need_emu && (h > MAX_H || stride > MAX_STRIDE))) {

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

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

  412.                  shift, r, width, height);

  413.         return;

  414.     }

  415. 

  416.     src += ix + iy * stride;

  417.     if (need_emu) {

  418.         emu_edge_fn(edge_buf, src, stride, stride, w + 1, h + 1, ix, iy, width, height);

  419.         src = edge_buf;

  420.     }

  421. 

  422.     __asm__ volatile (

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

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

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

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

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

  428. 

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

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

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

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

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

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

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

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

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

  438. 

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

  440.             __asm__ volatile (

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

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

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

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

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

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

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

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

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

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

  451. 

  452.             __asm__ volatile (

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

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

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

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

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

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

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

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

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

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

  463. 

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

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

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

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

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

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

  470. 

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

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

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

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

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

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

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

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

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

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

  481. 

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

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

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

  485. 

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

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

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

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

  490.             src += stride;

  491.         }

  492.         src += 4 - h * stride;

  493.     }

  494. }

  495. 

  496. #if CONFIG_VIDEODSP

  497. #if HAVE_YASM

  498. #if ARCH_X86_32

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

  500.                 int stride, int h, int ox, int oy,

  501.                 int dxx, int dxy, int dyx, int dyy,

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

  503. {

  504.     gmc(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy, shift, r,

  505.         width, height, &ff_emulated_edge_mc_8);

  506. }

  507. #endif

  508. void ff_gmc_sse(uint8_t *dst, uint8_t *src,

  509.                 int stride, int h, int ox, int oy,

  510.                 int dxx, int dxy, int dyx, int dyy,

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

  512. {

  513.     gmc(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy, shift, r,

  514.         width, height, &ff_emulated_edge_mc_8);

  515. }

  516. #else

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

  518.                 int stride, int h, int ox, int oy,

  519.                 int dxx, int dxy, int dyx, int dyy,

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

  521. {

  522.     gmc(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy, shift, r,

  523.         width, height, &ff_emulated_edge_mc_8);

  524. }

  525. #endif

  526. #endif

  527. 

  528. #if CONFIG_DIRAC_DECODER

  529. #define DIRAC_PIXOP(OPNAME2, OPNAME, EXT)\

  530. void ff_ ## OPNAME2 ## _dirac_pixels8_ ## EXT(uint8_t *dst, const uint8_t *src[5], int stride, int h)\

  531. {\

  532.     if (h&3)\

  533.         ff_ ## OPNAME2 ## _dirac_pixels8_c(dst, src, stride, h);\

  534.     else\

  535.         OPNAME ## _pixels8_ ## EXT(dst, src[0], stride, h);\

  536. }\

  537. void ff_ ## OPNAME2 ## _dirac_pixels16_ ## EXT(uint8_t *dst, const uint8_t *src[5], int stride, int h)\

  538. {\

  539.     if (h&3)\

  540.         ff_ ## OPNAME2 ## _dirac_pixels16_c(dst, src, stride, h);\

  541.     else\

  542.         OPNAME ## _pixels16_ ## EXT(dst, src[0], stride, h);\

  543. }\

  544. void ff_ ## OPNAME2 ## _dirac_pixels32_ ## EXT(uint8_t *dst, const uint8_t *src[5], int stride, int h)\

  545. {\

  546.     if (h&3) {\

  547.         ff_ ## OPNAME2 ## _dirac_pixels32_c(dst, src, stride, h);\

  548.     } else {\

  549.         OPNAME ## _pixels16_ ## EXT(dst   , src[0]   , stride, h);\

  550.         OPNAME ## _pixels16_ ## EXT(dst+16, src[0]+16, stride, h);\

  551.     }\

  552. }

  553. 

  554. #if HAVE_MMX_INLINE

  555. PIXELS16(static, ff_avg, , , _mmxext)

  556. DIRAC_PIXOP(put, ff_put, mmx)

  557. DIRAC_PIXOP(avg, ff_avg, mmx)

  558. #endif

  559. 

  560. #if HAVE_YASM

  561. DIRAC_PIXOP(avg, ff_avg, mmxext)

  562. 

  563. void ff_put_dirac_pixels16_sse2(uint8_t *dst, const uint8_t *src[5], int stride, int h)

  564. {

  565.     if (h&3)

  566.         ff_put_dirac_pixels16_c(dst, src, stride, h);

  567.     else

  568.     ff_put_pixels16_sse2(dst, src[0], stride, h);

  569. }

  570. void ff_avg_dirac_pixels16_sse2(uint8_t *dst, const uint8_t *src[5], int stride, int h)

  571. {

  572.     if (h&3)

  573.         ff_avg_dirac_pixels16_c(dst, src, stride, h);

  574.     else

  575.     ff_avg_pixels16_sse2(dst, src[0], stride, h);

  576. }

  577. void ff_put_dirac_pixels32_sse2(uint8_t *dst, const uint8_t *src[5], int stride, int h)

  578. {

  579.     if (h&3) {

  580.         ff_put_dirac_pixels32_c(dst, src, stride, h);

  581.     } else {

  582.     ff_put_pixels16_sse2(dst   , src[0]   , stride, h);

  583.     ff_put_pixels16_sse2(dst+16, src[0]+16, stride, h);

  584.     }

  585. }

  586. void ff_avg_dirac_pixels32_sse2(uint8_t *dst, const uint8_t *src[5], int stride, int h)

  587. {

  588.     if (h&3) {

  589.         ff_avg_dirac_pixels32_c(dst, src, stride, h);

  590.     } else {

  591.     ff_avg_pixels16_sse2(dst   , src[0]   , stride, h);

  592.     ff_avg_pixels16_sse2(dst+16, src[0]+16, stride, h);

  593.     }

  594. }

  595. #endif

  596. #endif

  597. 

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

  599.                          float min, float max, int len)

  600. {

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

  602.     __asm__ volatile (

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

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

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

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

  607.         "1:                             \n\t"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  625.         "jge            1b              \n\t"

  626.         : "+&r" (i)

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

  628.         : "memory");

  629. }

  630. 

  631. #endif /* HAVE_INLINE_ASM */