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

676 lines
40KB
Raw Blame History 

  1. /*

  2.  * Copyright (c) 2000, 2001 Fabrice Bellard

  3.  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>

  4.  *

  5.  * This file is part of FFmpeg.

  6.  *

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

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

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

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

  11.  *

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

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

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

  15.  * Lesser General Public License for more details.

  16.  *

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

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

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

  20.  */

  21. 

  22. #include "config.h"

  23. #include "libavutil/attributes.h"

  24. #include "libavutil/cpu.h"

  25. #include "libavutil/internal.h"

  26. #include "libavutil/x86/cpu.h"

  27. #include "libavcodec/avcodec.h"

  28. #include "libavcodec/dsputil.h"

  29. #include "libavcodec/pixels.h"

  30. #include "libavcodec/simple_idct.h"

  31. #include "libavcodec/version.h"

  32. #include "dsputil_x86.h"

  33. #include "fpel.h"

  34. #include "idct_xvid.h"

  35. 

  36. void ff_put_pixels8_l2_mmxext(uint8_t *dst, uint8_t *src1, uint8_t *src2,

  37.                               int dstStride, int src1Stride, int h);

  38. void ff_put_no_rnd_pixels8_l2_mmxext(uint8_t *dst, uint8_t *src1,

  39.                                      uint8_t *src2, int dstStride,

  40.                                      int src1Stride, int h);

  41. void ff_avg_pixels8_l2_mmxext(uint8_t *dst, uint8_t *src1, uint8_t *src2,

  42.                               int dstStride, int src1Stride, int h);

  43. void ff_put_pixels16_l2_mmxext(uint8_t *dst, uint8_t *src1, uint8_t *src2,

  44.                                int dstStride, int src1Stride, int h);

  45. void ff_avg_pixels16_l2_mmxext(uint8_t *dst, uint8_t *src1, uint8_t *src2,

  46.                                int dstStride, int src1Stride, int h);

  47. void ff_put_no_rnd_pixels16_l2_mmxext(uint8_t *dst, uint8_t *src1, uint8_t *src2,

  48.                                       int dstStride, int src1Stride, int h);

  49. void ff_put_mpeg4_qpel16_h_lowpass_mmxext(uint8_t *dst, uint8_t *src,

  50.                                           int dstStride, int srcStride, int h);

  51. void ff_avg_mpeg4_qpel16_h_lowpass_mmxext(uint8_t *dst, uint8_t *src,

  52.                                           int dstStride, int srcStride, int h);

  53. void ff_put_no_rnd_mpeg4_qpel16_h_lowpass_mmxext(uint8_t *dst, uint8_t *src,

  54.                                                  int dstStride, int srcStride,

  55.                                                  int h);

  56. void ff_put_mpeg4_qpel8_h_lowpass_mmxext(uint8_t *dst, uint8_t *src,

  57.                                          int dstStride, int srcStride, int h);

  58. void ff_avg_mpeg4_qpel8_h_lowpass_mmxext(uint8_t *dst, uint8_t *src,

  59.                                          int dstStride, int srcStride, int h);

  60. void ff_put_no_rnd_mpeg4_qpel8_h_lowpass_mmxext(uint8_t *dst, uint8_t *src,

  61.                                                 int dstStride, int srcStride,

  62.                                                 int h);

  63. void ff_put_mpeg4_qpel16_v_lowpass_mmxext(uint8_t *dst, uint8_t *src,

  64.                                           int dstStride, int srcStride);

  65. void ff_avg_mpeg4_qpel16_v_lowpass_mmxext(uint8_t *dst, uint8_t *src,

  66.                                           int dstStride, int srcStride);

  67. void ff_put_no_rnd_mpeg4_qpel16_v_lowpass_mmxext(uint8_t *dst, uint8_t *src,

  68.                                                  int dstStride, int srcStride);

  69. void ff_put_mpeg4_qpel8_v_lowpass_mmxext(uint8_t *dst, uint8_t *src,

  70.                                          int dstStride, int srcStride);

  71. void ff_avg_mpeg4_qpel8_v_lowpass_mmxext(uint8_t *dst, uint8_t *src,

  72.                                          int dstStride, int srcStride);

  73. void ff_put_no_rnd_mpeg4_qpel8_v_lowpass_mmxext(uint8_t *dst, uint8_t *src,

  74.                                                 int dstStride, int srcStride);

  75. #define ff_put_no_rnd_pixels16_mmxext ff_put_pixels16_mmx

  76. #define ff_put_no_rnd_pixels8_mmxext ff_put_pixels8_mmx

  77. 

  78. int32_t ff_scalarproduct_int16_mmxext(const int16_t *v1, const int16_t *v2,

  79.                                       int order);

  80. int32_t ff_scalarproduct_int16_sse2(const int16_t *v1, const int16_t *v2,

  81.                                     int order);

  82. int32_t ff_scalarproduct_and_madd_int16_mmxext(int16_t *v1, const int16_t *v2,

  83.                                                const int16_t *v3,

  84.                                                int order, int mul);

  85. int32_t ff_scalarproduct_and_madd_int16_sse2(int16_t *v1, const int16_t *v2,

  86.                                              const int16_t *v3,

  87.                                              int order, int mul);

  88. int32_t ff_scalarproduct_and_madd_int16_ssse3(int16_t *v1, const int16_t *v2,

  89.                                               const int16_t *v3,

  90.                                               int order, int mul);

  91. 

  92. void ff_bswap32_buf_ssse3(uint32_t *dst, const uint32_t *src, int w);

  93. void ff_bswap32_buf_sse2(uint32_t *dst, const uint32_t *src, int w);

  94. 

  95. void ff_vector_clip_int32_mmx(int32_t *dst, const int32_t *src,

  96.                               int32_t min, int32_t max, unsigned int len);

  97. void ff_vector_clip_int32_sse2(int32_t *dst, const int32_t *src,

  98.                                int32_t min, int32_t max, unsigned int len);

  99. void ff_vector_clip_int32_int_sse2(int32_t *dst, const int32_t *src,

  100.                                    int32_t min, int32_t max, unsigned int len);

  101. void ff_vector_clip_int32_sse4(int32_t *dst, const int32_t *src,

  102.                                int32_t min, int32_t max, unsigned int len);

  103. 

  104. #if HAVE_YASM

  105. 

  106. #define ff_put_pixels16_mmxext ff_put_pixels16_mmx

  107. #define ff_put_pixels8_mmxext  ff_put_pixels8_mmx

  108. 

  109. #define QPEL_OP(OPNAME, RND, MMX)                                       \

  110. static void OPNAME ## qpel8_mc00_ ## MMX(uint8_t *dst, uint8_t *src,    \

  111.                                          ptrdiff_t stride)              \

  112. {                                                                       \

  113.     ff_ ## OPNAME ## pixels8_ ## MMX(dst, src, stride, 8);              \

  114. }                                                                       \

  115.                                                                         \

  116. static void OPNAME ## qpel8_mc10_ ## MMX(uint8_t *dst, uint8_t *src,    \

  117.                                          ptrdiff_t stride)              \

  118. {                                                                       \

  119.     uint64_t temp[8];                                                   \

  120.     uint8_t *const half = (uint8_t *) temp;                             \

  121.     ff_put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(half, src, 8,        \

  122.                                                    stride, 8);          \

  123.     ff_ ## OPNAME ## pixels8_l2_ ## MMX(dst, src, half,                 \

  124.                                         stride, stride, 8);             \

  125. }                                                                       \

  126.                                                                         \

  127. static void OPNAME ## qpel8_mc20_ ## MMX(uint8_t *dst, uint8_t *src,    \

  128.                                          ptrdiff_t stride)              \

  129. {                                                                       \

  130.     ff_ ## OPNAME ## mpeg4_qpel8_h_lowpass_ ## MMX(dst, src, stride,    \

  131.                                                    stride, 8);          \

  132. }                                                                       \

  133.                                                                         \

  134. static void OPNAME ## qpel8_mc30_ ## MMX(uint8_t *dst, uint8_t *src,    \

  135.                                          ptrdiff_t stride)              \

  136. {                                                                       \

  137.     uint64_t temp[8];                                                   \

  138.     uint8_t *const half = (uint8_t *) temp;                             \

  139.     ff_put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(half, src, 8,        \

  140.                                                    stride, 8);          \

  141.     ff_ ## OPNAME ## pixels8_l2_ ## MMX(dst, src + 1, half, stride,     \

  142.                                         stride, 8);                     \

  143. }                                                                       \

  144.                                                                         \

  145. static void OPNAME ## qpel8_mc01_ ## MMX(uint8_t *dst, uint8_t *src,    \

  146.                                          ptrdiff_t stride)              \

  147. {                                                                       \

  148.     uint64_t temp[8];                                                   \

  149.     uint8_t *const half = (uint8_t *) temp;                             \

  150.     ff_put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(half, src,           \

  151.                                                    8, stride);          \

  152.     ff_ ## OPNAME ## pixels8_l2_ ## MMX(dst, src, half,                 \

  153.                                         stride, stride, 8);             \

  154. }                                                                       \

  155.                                                                         \

  156. static void OPNAME ## qpel8_mc02_ ## MMX(uint8_t *dst, uint8_t *src,    \

  157.                                          ptrdiff_t stride)              \

  158. {                                                                       \

  159.     ff_ ## OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, src,            \

  160.                                                    stride, stride);     \

  161. }                                                                       \

  162.                                                                         \

  163. static void OPNAME ## qpel8_mc03_ ## MMX(uint8_t *dst, uint8_t *src,    \

  164.                                          ptrdiff_t stride)              \

  165. {                                                                       \

  166.     uint64_t temp[8];                                                   \

  167.     uint8_t *const half = (uint8_t *) temp;                             \

  168.     ff_put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(half, src,           \

  169.                                                    8, stride);          \

  170.     ff_ ## OPNAME ## pixels8_l2_ ## MMX(dst, src + stride, half, stride,\

  171.                                         stride, 8);                     \

  172. }                                                                       \

  173.                                                                         \

  174. static void OPNAME ## qpel8_mc11_ ## MMX(uint8_t *dst, uint8_t *src,    \

  175.                                          ptrdiff_t stride)              \

  176. {                                                                       \

  177.     uint64_t half[8 + 9];                                               \

  178.     uint8_t *const halfH  = (uint8_t *) half + 64;                      \

  179.     uint8_t *const halfHV = (uint8_t *) half;                           \

  180.     ff_put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8,       \

  181.                                                    stride, 9);          \

  182.     ff_put ## RND ## pixels8_l2_ ## MMX(halfH, src, halfH, 8,           \

  183.                                         stride, 9);                     \

  184.     ff_put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\

  185.     ff_ ## OPNAME ## pixels8_l2_ ## MMX(dst, halfH, halfHV,             \

  186.                                         stride, 8, 8);                  \

  187. }                                                                       \

  188.                                                                         \

  189. static void OPNAME ## qpel8_mc31_ ## MMX(uint8_t *dst, uint8_t *src,    \

  190.                                          ptrdiff_t stride)              \

  191. {                                                                       \

  192.     uint64_t half[8 + 9];                                               \

  193.     uint8_t *const halfH  = (uint8_t *) half + 64;                      \

  194.     uint8_t *const halfHV = (uint8_t *) half;                           \

  195.     ff_put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8,       \

  196.                                                    stride, 9);          \

  197.     ff_put ## RND ## pixels8_l2_ ## MMX(halfH, src + 1, halfH, 8,       \

  198.                                         stride, 9);                     \

  199.     ff_put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\

  200.     ff_ ## OPNAME ## pixels8_l2_ ## MMX(dst, halfH, halfHV,             \

  201.                                         stride, 8, 8);                  \

  202. }                                                                       \

  203.                                                                         \

  204. static void OPNAME ## qpel8_mc13_ ## MMX(uint8_t *dst, uint8_t *src,    \

  205.                                          ptrdiff_t stride)              \

  206. {                                                                       \

  207.     uint64_t half[8 + 9];                                               \

  208.     uint8_t *const halfH  = (uint8_t *) half + 64;                      \

  209.     uint8_t *const halfHV = (uint8_t *) half;                           \

  210.     ff_put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8,       \

  211.                                                    stride, 9);          \

  212.     ff_put ## RND ## pixels8_l2_ ## MMX(halfH, src, halfH, 8,           \

  213.                                         stride, 9);                     \

  214.     ff_put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\

  215.     ff_ ## OPNAME ## pixels8_l2_ ## MMX(dst, halfH + 8, halfHV,         \

  216.                                         stride, 8, 8);                  \

  217. }                                                                       \

  218.                                                                         \

  219. static void OPNAME ## qpel8_mc33_ ## MMX(uint8_t *dst, uint8_t *src,    \

  220.                                          ptrdiff_t stride)              \

  221. {                                                                       \

  222.     uint64_t half[8 + 9];                                               \

  223.     uint8_t *const halfH  = (uint8_t *) half + 64;                      \

  224.     uint8_t *const halfHV = (uint8_t *) half;                           \

  225.     ff_put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8,       \

  226.                                                    stride, 9);          \

  227.     ff_put ## RND ## pixels8_l2_ ## MMX(halfH, src + 1, halfH, 8,       \

  228.                                         stride, 9);                     \

  229.     ff_put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\

  230.     ff_ ## OPNAME ## pixels8_l2_ ## MMX(dst, halfH + 8, halfHV,         \

  231.                                         stride, 8, 8);                  \

  232. }                                                                       \

  233.                                                                         \

  234. static void OPNAME ## qpel8_mc21_ ## MMX(uint8_t *dst, uint8_t *src,    \

  235.                                          ptrdiff_t stride)              \

  236. {                                                                       \

  237.     uint64_t half[8 + 9];                                               \

  238.     uint8_t *const halfH  = (uint8_t *) half + 64;                      \

  239.     uint8_t *const halfHV = (uint8_t *) half;                           \

  240.     ff_put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8,       \

  241.                                                    stride, 9);          \

  242.     ff_put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\

  243.     ff_ ## OPNAME ## pixels8_l2_ ## MMX(dst, halfH, halfHV,             \

  244.                                         stride, 8, 8);                  \

  245. }                                                                       \

  246.                                                                         \

  247. static void OPNAME ## qpel8_mc23_ ## MMX(uint8_t *dst, uint8_t *src,    \

  248.                                          ptrdiff_t stride)              \

  249. {                                                                       \

  250.     uint64_t half[8 + 9];                                               \

  251.     uint8_t *const halfH  = (uint8_t *) half + 64;                      \

  252.     uint8_t *const halfHV = (uint8_t *) half;                           \

  253.     ff_put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8,       \

  254.                                                    stride, 9);          \

  255.     ff_put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\

  256.     ff_ ## OPNAME ## pixels8_l2_ ## MMX(dst, halfH + 8, halfHV,         \

  257.                                         stride, 8, 8);                  \

  258. }                                                                       \

  259.                                                                         \

  260. static void OPNAME ## qpel8_mc12_ ## MMX(uint8_t *dst, uint8_t *src,    \

  261.                                          ptrdiff_t stride)              \

  262. {                                                                       \

  263.     uint64_t half[8 + 9];                                               \

  264.     uint8_t *const halfH = (uint8_t *) half;                            \

  265.     ff_put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8,       \

  266.                                                    stride, 9);          \

  267.     ff_put ## RND ## pixels8_l2_ ## MMX(halfH, src, halfH,              \

  268.                                         8, stride, 9);                  \

  269.     ff_ ## OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH,          \

  270.                                                    stride, 8);          \

  271. }                                                                       \

  272.                                                                         \

  273. static void OPNAME ## qpel8_mc32_ ## MMX(uint8_t *dst, uint8_t *src,    \

  274.                                          ptrdiff_t stride)              \

  275. {                                                                       \

  276.     uint64_t half[8 + 9];                                               \

  277.     uint8_t *const halfH = (uint8_t *) half;                            \

  278.     ff_put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8,       \

  279.                                                    stride, 9);          \

  280.     ff_put ## RND ## pixels8_l2_ ## MMX(halfH, src + 1, halfH, 8,       \

  281.                                         stride, 9);                     \

  282.     ff_ ## OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH,          \

  283.                                                    stride, 8);          \

  284. }                                                                       \

  285.                                                                         \

  286. static void OPNAME ## qpel8_mc22_ ## MMX(uint8_t *dst, uint8_t *src,    \

  287.                                          ptrdiff_t stride)              \

  288. {                                                                       \

  289.     uint64_t half[9];                                                   \

  290.     uint8_t *const halfH = (uint8_t *) half;                            \

  291.     ff_put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8,       \

  292.                                                    stride, 9);          \

  293.     ff_ ## OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH,          \

  294.                                                    stride, 8);          \

  295. }                                                                       \

  296.                                                                         \

  297. static void OPNAME ## qpel16_mc00_ ## MMX(uint8_t *dst, uint8_t *src,   \

  298.                                           ptrdiff_t stride)             \

  299. {                                                                       \

  300.     ff_ ## OPNAME ## pixels16_ ## MMX(dst, src, stride, 16);            \

  301. }                                                                       \

  302.                                                                         \

  303. static void OPNAME ## qpel16_mc10_ ## MMX(uint8_t *dst, uint8_t *src,   \

  304.                                           ptrdiff_t stride)             \

  305. {                                                                       \

  306.     uint64_t temp[32];                                                  \

  307.     uint8_t *const half = (uint8_t *) temp;                             \

  308.     ff_put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(half, src, 16,      \

  309.                                                     stride, 16);        \

  310.     ff_ ## OPNAME ## pixels16_l2_ ## MMX(dst, src, half, stride,        \

  311.                                          stride, 16);                   \

  312. }                                                                       \

  313.                                                                         \

  314. static void OPNAME ## qpel16_mc20_ ## MMX(uint8_t *dst, uint8_t *src,   \

  315.                                           ptrdiff_t stride)             \

  316. {                                                                       \

  317.     ff_ ## OPNAME ## mpeg4_qpel16_h_lowpass_ ## MMX(dst, src,           \

  318.                                                     stride, stride, 16);\

  319. }                                                                       \

  320.                                                                         \

  321. static void OPNAME ## qpel16_mc30_ ## MMX(uint8_t *dst, uint8_t *src,   \

  322.                                           ptrdiff_t stride)             \

  323. {                                                                       \

  324.     uint64_t temp[32];                                                  \

  325.     uint8_t *const half = (uint8_t*) temp;                              \

  326.     ff_put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(half, src, 16,      \

  327.                                                     stride, 16);        \

  328.     ff_ ## OPNAME ## pixels16_l2_ ## MMX(dst, src + 1, half,            \

  329.                                          stride, stride, 16);           \

  330. }                                                                       \

  331.                                                                         \

  332. static void OPNAME ## qpel16_mc01_ ## MMX(uint8_t *dst, uint8_t *src,   \

  333.                                           ptrdiff_t stride)             \

  334. {                                                                       \

  335.     uint64_t temp[32];                                                  \

  336.     uint8_t *const half = (uint8_t *) temp;                             \

  337.     ff_put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(half, src, 16,      \

  338.                                                     stride);            \

  339.     ff_ ## OPNAME ## pixels16_l2_ ## MMX(dst, src, half, stride,        \

  340.                                          stride, 16);                   \

  341. }                                                                       \

  342.                                                                         \

  343. static void OPNAME ## qpel16_mc02_ ## MMX(uint8_t *dst, uint8_t *src,   \

  344.                                           ptrdiff_t stride)             \

  345. {                                                                       \

  346.     ff_ ## OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, src,           \

  347.                                                     stride, stride);    \

  348. }                                                                       \

  349.                                                                         \

  350. static void OPNAME ## qpel16_mc03_ ## MMX(uint8_t *dst, uint8_t *src,   \

  351.                                           ptrdiff_t stride)             \

  352. {                                                                       \

  353.     uint64_t temp[32];                                                  \

  354.     uint8_t *const half = (uint8_t *) temp;                             \

  355.     ff_put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(half, src, 16,      \

  356.                                                     stride);            \

  357.     ff_ ## OPNAME ## pixels16_l2_ ## MMX(dst, src+stride, half,         \

  358.                                          stride, stride, 16);           \

  359. }                                                                       \

  360.                                                                         \

  361. static void OPNAME ## qpel16_mc11_ ## MMX(uint8_t *dst, uint8_t *src,   \

  362.                                           ptrdiff_t stride)             \

  363. {                                                                       \

  364.     uint64_t half[16 * 2 + 17 * 2];                                     \

  365.     uint8_t *const halfH  = (uint8_t *) half + 256;                     \

  366.     uint8_t *const halfHV = (uint8_t *) half;                           \

  367.     ff_put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16,     \

  368.                                                     stride, 17);        \

  369.     ff_put ## RND ## pixels16_l2_ ## MMX(halfH, src, halfH, 16,         \

  370.                                          stride, 17);                   \

  371.     ff_put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH,      \

  372.                                                     16, 16);            \

  373.     ff_ ## OPNAME ## pixels16_l2_ ## MMX(dst, halfH, halfHV,            \

  374.                                          stride, 16, 16);               \

  375. }                                                                       \

  376.                                                                         \

  377. static void OPNAME ## qpel16_mc31_ ## MMX(uint8_t *dst, uint8_t *src,   \

  378.                                           ptrdiff_t stride)             \

  379. {                                                                       \

  380.     uint64_t half[16 * 2 + 17 * 2];                                     \

  381.     uint8_t *const halfH  = (uint8_t *) half + 256;                     \

  382.     uint8_t *const halfHV = (uint8_t *) half;                           \

  383.     ff_put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16,     \

  384.                                                     stride, 17);        \

  385.     ff_put ## RND ## pixels16_l2_ ## MMX(halfH, src + 1, halfH, 16,     \

  386.                                          stride, 17);                   \

  387.     ff_put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH,      \

  388.                                                     16, 16);            \

  389.     ff_ ## OPNAME ## pixels16_l2_ ## MMX(dst, halfH, halfHV,            \

  390.                                          stride, 16, 16);               \

  391. }                                                                       \

  392.                                                                         \

  393. static void OPNAME ## qpel16_mc13_ ## MMX(uint8_t *dst, uint8_t *src,   \

  394.                                           ptrdiff_t stride)             \

  395. {                                                                       \

  396.     uint64_t half[16 * 2 + 17 * 2];                                     \

  397.     uint8_t *const halfH  = (uint8_t *) half + 256;                     \

  398.     uint8_t *const halfHV = (uint8_t *) half;                           \

  399.     ff_put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16,     \

  400.                                                     stride, 17);        \

  401.     ff_put ## RND ## pixels16_l2_ ## MMX(halfH, src, halfH, 16,         \

  402.                                          stride, 17);                   \

  403.     ff_put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH,      \

  404.                                                     16, 16);            \

  405.     ff_ ## OPNAME ## pixels16_l2_ ## MMX(dst, halfH + 16, halfHV,       \

  406.                                          stride, 16, 16);               \

  407. }                                                                       \

  408.                                                                         \

  409. static void OPNAME ## qpel16_mc33_ ## MMX(uint8_t *dst, uint8_t *src,   \

  410.                                           ptrdiff_t stride)             \

  411. {                                                                       \

  412.     uint64_t half[16 * 2 + 17 * 2];                                     \

  413.     uint8_t *const halfH  = (uint8_t *) half + 256;                     \

  414.     uint8_t *const halfHV = (uint8_t *) half;                           \

  415.     ff_put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16,     \

  416.                                                     stride, 17);        \

  417.     ff_put ## RND ## pixels16_l2_ ## MMX(halfH, src + 1, halfH, 16,     \

  418.                                          stride, 17);                   \

  419.     ff_put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH,      \

  420.                                                     16, 16);            \

  421.     ff_ ## OPNAME ## pixels16_l2_ ## MMX(dst, halfH + 16, halfHV,       \

  422.                                          stride, 16, 16);               \

  423. }                                                                       \

  424.                                                                         \

  425. static void OPNAME ## qpel16_mc21_ ## MMX(uint8_t *dst, uint8_t *src,   \

  426.                                           ptrdiff_t stride)             \

  427. {                                                                       \

  428.     uint64_t half[16 * 2 + 17 * 2];                                     \

  429.     uint8_t *const halfH  = (uint8_t *) half + 256;                     \

  430.     uint8_t *const halfHV = (uint8_t *) half;                           \

  431.     ff_put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16,     \

  432.                                                     stride, 17);        \

  433.     ff_put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH,      \

  434.                                                     16, 16);            \

  435.     ff_ ## OPNAME ## pixels16_l2_ ## MMX(dst, halfH, halfHV,            \

  436.                                          stride, 16, 16);               \

  437. }                                                                       \

  438.                                                                         \

  439. static void OPNAME ## qpel16_mc23_ ## MMX(uint8_t *dst, uint8_t *src,   \

  440.                                           ptrdiff_t stride)             \

  441. {                                                                       \

  442.     uint64_t half[16 * 2 + 17 * 2];                                     \

  443.     uint8_t *const halfH  = (uint8_t *) half + 256;                     \

  444.     uint8_t *const halfHV = (uint8_t *) half;                           \

  445.     ff_put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16,     \

  446.                                                     stride, 17);        \

  447.     ff_put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH,      \

  448.                                                     16, 16);            \

  449.     ff_ ## OPNAME ## pixels16_l2_ ## MMX(dst, halfH + 16, halfHV,       \

  450.                                          stride, 16, 16);               \

  451. }                                                                       \

  452.                                                                         \

  453. static void OPNAME ## qpel16_mc12_ ## MMX(uint8_t *dst, uint8_t *src,   \

  454.                                           ptrdiff_t stride)             \

  455. {                                                                       \

  456.     uint64_t half[17 * 2];                                              \

  457.     uint8_t *const halfH = (uint8_t *) half;                            \

  458.     ff_put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16,     \

  459.                                                     stride, 17);        \

  460.     ff_put ## RND ## pixels16_l2_ ## MMX(halfH, src, halfH, 16,         \

  461.                                          stride, 17);                   \

  462.     ff_ ## OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, halfH,         \

  463.                                                     stride, 16);        \

  464. }                                                                       \

  465.                                                                         \

  466. static void OPNAME ## qpel16_mc32_ ## MMX(uint8_t *dst, uint8_t *src,   \

  467.                                           ptrdiff_t stride)             \

  468. {                                                                       \

  469.     uint64_t half[17 * 2];                                              \

  470.     uint8_t *const halfH = (uint8_t *) half;                            \

  471.     ff_put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16,     \

  472.                                                     stride, 17);        \

  473.     ff_put ## RND ## pixels16_l2_ ## MMX(halfH, src + 1, halfH, 16,     \

  474.                                          stride, 17);                   \

  475.     ff_ ## OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, halfH,         \

  476.                                                     stride, 16);        \

  477. }                                                                       \

  478.                                                                         \

  479. static void OPNAME ## qpel16_mc22_ ## MMX(uint8_t *dst, uint8_t *src,   \

  480.                                           ptrdiff_t stride)             \

  481. {                                                                       \

  482.     uint64_t half[17 * 2];                                              \

  483.     uint8_t *const halfH = (uint8_t *) half;                            \

  484.     ff_put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16,     \

  485.                                                     stride, 17);        \

  486.     ff_ ## OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, halfH,         \

  487.                                                     stride, 16);        \

  488. }

  489. 

  490. QPEL_OP(put_,        _,        mmxext)

  491. QPEL_OP(avg_,        _,        mmxext)

  492. QPEL_OP(put_no_rnd_, _no_rnd_, mmxext)

  493. 

  494. #endif /* HAVE_YASM */

  495. 

  496. #define SET_QPEL_FUNCS(PFX, IDX, SIZE, CPU, PREFIX)                          \

  497. do {                                                                         \

  498.     c->PFX ## _pixels_tab[IDX][ 0] = PREFIX ## PFX ## SIZE ## _mc00_ ## CPU; \

  499.     c->PFX ## _pixels_tab[IDX][ 1] = PREFIX ## PFX ## SIZE ## _mc10_ ## CPU; \

  500.     c->PFX ## _pixels_tab[IDX][ 2] = PREFIX ## PFX ## SIZE ## _mc20_ ## CPU; \

  501.     c->PFX ## _pixels_tab[IDX][ 3] = PREFIX ## PFX ## SIZE ## _mc30_ ## CPU; \

  502.     c->PFX ## _pixels_tab[IDX][ 4] = PREFIX ## PFX ## SIZE ## _mc01_ ## CPU; \

  503.     c->PFX ## _pixels_tab[IDX][ 5] = PREFIX ## PFX ## SIZE ## _mc11_ ## CPU; \

  504.     c->PFX ## _pixels_tab[IDX][ 6] = PREFIX ## PFX ## SIZE ## _mc21_ ## CPU; \

  505.     c->PFX ## _pixels_tab[IDX][ 7] = PREFIX ## PFX ## SIZE ## _mc31_ ## CPU; \

  506.     c->PFX ## _pixels_tab[IDX][ 8] = PREFIX ## PFX ## SIZE ## _mc02_ ## CPU; \

  507.     c->PFX ## _pixels_tab[IDX][ 9] = PREFIX ## PFX ## SIZE ## _mc12_ ## CPU; \

  508.     c->PFX ## _pixels_tab[IDX][10] = PREFIX ## PFX ## SIZE ## _mc22_ ## CPU; \

  509.     c->PFX ## _pixels_tab[IDX][11] = PREFIX ## PFX ## SIZE ## _mc32_ ## CPU; \

  510.     c->PFX ## _pixels_tab[IDX][12] = PREFIX ## PFX ## SIZE ## _mc03_ ## CPU; \

  511.     c->PFX ## _pixels_tab[IDX][13] = PREFIX ## PFX ## SIZE ## _mc13_ ## CPU; \

  512.     c->PFX ## _pixels_tab[IDX][14] = PREFIX ## PFX ## SIZE ## _mc23_ ## CPU; \

  513.     c->PFX ## _pixels_tab[IDX][15] = PREFIX ## PFX ## SIZE ## _mc33_ ## CPU; \

  514. } while (0)

  515. 

  516. static av_cold void dsputil_init_mmx(DSPContext *c, AVCodecContext *avctx,

  517.                                      int cpu_flags, unsigned high_bit_depth)

  518. {

  519. #if HAVE_MMX_INLINE

  520.     c->put_pixels_clamped        = ff_put_pixels_clamped_mmx;

  521.     c->add_pixels_clamped        = ff_add_pixels_clamped_mmx;

  522. 

  523.     if (!high_bit_depth) {

  524.         c->draw_edges   = ff_draw_edges_mmx;

  525.     }

  526. 

  527. #if CONFIG_VIDEODSP && (ARCH_X86_32 || !HAVE_YASM)

  528.     c->gmc = ff_gmc_mmx;

  529. #endif

  530. #endif /* HAVE_MMX_INLINE */

  531. 

  532. #if HAVE_MMX_EXTERNAL

  533.     if (!high_bit_depth) {

  534.         c->clear_block  = ff_clear_block_mmx;

  535.         c->clear_blocks = ff_clear_blocks_mmx;

  536.     }

  537.     c->vector_clip_int32 = ff_vector_clip_int32_mmx;

  538.     c->put_signed_pixels_clamped = ff_put_signed_pixels_clamped_mmx;

  539. #endif /* HAVE_MMX_EXTERNAL */

  540. }

  541. 

  542. static av_cold void dsputil_init_mmxext(DSPContext *c, AVCodecContext *avctx,

  543.                                         int cpu_flags, unsigned high_bit_depth)

  544. {

  545. #if HAVE_MMXEXT_INLINE

  546.     if (!high_bit_depth && avctx->idct_algo == FF_IDCT_XVIDMMX && avctx->lowres == 0) {

  547.         c->idct_put = ff_idct_xvid_mmxext_put;

  548.         c->idct_add = ff_idct_xvid_mmxext_add;

  549.         c->idct     = ff_idct_xvid_mmxext;

  550.     }

  551. #endif /* HAVE_MMXEXT_INLINE */

  552. 

  553. #if HAVE_MMXEXT_EXTERNAL

  554.     SET_QPEL_FUNCS(avg_qpel,        0, 16, mmxext, );

  555.     SET_QPEL_FUNCS(avg_qpel,        1,  8, mmxext, );

  556. 

  557.     SET_QPEL_FUNCS(put_qpel,        0, 16, mmxext, );

  558.     SET_QPEL_FUNCS(put_qpel,        1,  8, mmxext, );

  559.     SET_QPEL_FUNCS(put_no_rnd_qpel, 0, 16, mmxext, );

  560.     SET_QPEL_FUNCS(put_no_rnd_qpel, 1,  8, mmxext, );

  561. 

  562.     c->scalarproduct_int16          = ff_scalarproduct_int16_mmxext;

  563.     c->scalarproduct_and_madd_int16 = ff_scalarproduct_and_madd_int16_mmxext;

  564. #endif /* HAVE_MMXEXT_EXTERNAL */

  565. }

  566. 

  567. static av_cold void dsputil_init_sse(DSPContext *c, AVCodecContext *avctx,

  568.                                      int cpu_flags, unsigned high_bit_depth)

  569. {

  570. #if HAVE_YASM

  571. #if HAVE_SSE_EXTERNAL

  572.     c->vector_clipf = ff_vector_clipf_sse;

  573. 

  574.     /* XvMCCreateBlocks() may not allocate 16-byte aligned blocks */

  575.     if (CONFIG_XVMC && avctx->hwaccel && avctx->hwaccel->decode_mb)

  576.         return;

  577. 

  578.     if (!high_bit_depth) {

  579.         c->clear_block  = ff_clear_block_sse;

  580.         c->clear_blocks = ff_clear_blocks_sse;

  581.     }

  582. #endif

  583. #if HAVE_INLINE_ASM && CONFIG_VIDEODSP

  584.     c->gmc = ff_gmc_sse;

  585. #endif

  586. #endif /* HAVE_YASM */

  587. }

  588. 

  589. static av_cold void dsputil_init_sse2(DSPContext *c, AVCodecContext *avctx,

  590.                                       int cpu_flags, unsigned high_bit_depth)

  591. {

  592. #if HAVE_SSE2_INLINE

  593.     if (!high_bit_depth && avctx->idct_algo == FF_IDCT_XVIDMMX && avctx->lowres == 0) {

  594.         c->idct_put              = ff_idct_xvid_sse2_put;

  595.         c->idct_add              = ff_idct_xvid_sse2_add;

  596.         c->idct                  = ff_idct_xvid_sse2;

  597.         c->idct_permutation_type = FF_SSE2_IDCT_PERM;

  598.     }

  599. #endif /* HAVE_SSE2_INLINE */

  600. 

  601. #if HAVE_SSE2_EXTERNAL

  602.     c->scalarproduct_int16          = ff_scalarproduct_int16_sse2;

  603.     c->scalarproduct_and_madd_int16 = ff_scalarproduct_and_madd_int16_sse2;

  604.     if (cpu_flags & AV_CPU_FLAG_ATOM) {

  605.         c->vector_clip_int32 = ff_vector_clip_int32_int_sse2;

  606.     } else {

  607.         c->vector_clip_int32 = ff_vector_clip_int32_sse2;

  608.     }

  609.     c->bswap_buf = ff_bswap32_buf_sse2;

  610.     c->put_signed_pixels_clamped = ff_put_signed_pixels_clamped_sse2;

  611. #endif /* HAVE_SSE2_EXTERNAL */

  612. }

  613. 

  614. static av_cold void dsputil_init_ssse3(DSPContext *c, AVCodecContext *avctx,

  615.                                        int cpu_flags, unsigned high_bit_depth)

  616. {

  617. #if HAVE_SSSE3_EXTERNAL

  618.     if (!(cpu_flags & (AV_CPU_FLAG_SSE42 | AV_CPU_FLAG_3DNOW))) // cachesplit

  619.         c->scalarproduct_and_madd_int16 = ff_scalarproduct_and_madd_int16_ssse3;

  620.     c->bswap_buf = ff_bswap32_buf_ssse3;

  621. #endif /* HAVE_SSSE3_EXTERNAL */

  622. }

  623. 

  624. static av_cold void dsputil_init_sse4(DSPContext *c, AVCodecContext *avctx,

  625.                                       int cpu_flags, unsigned high_bit_depth)

  626. {

  627. #if HAVE_SSE4_EXTERNAL

  628.     c->vector_clip_int32 = ff_vector_clip_int32_sse4;

  629. #endif /* HAVE_SSE4_EXTERNAL */

  630. }

  631. 

  632. av_cold void ff_dsputil_init_x86(DSPContext *c, AVCodecContext *avctx,

  633.                                  unsigned high_bit_depth)

  634. {

  635.     int cpu_flags = av_get_cpu_flags();

  636. 

  637.     if (X86_MMX(cpu_flags)) {

  638. #if HAVE_INLINE_ASM

  639.         const int idct_algo = avctx->idct_algo;

  640. 

  641.         if (avctx->lowres == 0 && !high_bit_depth) {

  642.             if (idct_algo == FF_IDCT_AUTO || idct_algo == FF_IDCT_SIMPLEMMX) {

  643.                 c->idct_put              = ff_simple_idct_put_mmx;

  644.                 c->idct_add              = ff_simple_idct_add_mmx;

  645.                 c->idct                  = ff_simple_idct_mmx;

  646.                 c->idct_permutation_type = FF_SIMPLE_IDCT_PERM;

  647.             } else if (idct_algo == FF_IDCT_XVIDMMX) {

  648.                 c->idct_put              = ff_idct_xvid_mmx_put;

  649.                 c->idct_add              = ff_idct_xvid_mmx_add;

  650.                 c->idct                  = ff_idct_xvid_mmx;

  651.             }

  652.         }

  653. #endif /* HAVE_INLINE_ASM */

  654. 

  655.         dsputil_init_mmx(c, avctx, cpu_flags, high_bit_depth);

  656.     }

  657. 

  658.     if (X86_MMXEXT(cpu_flags))

  659.         dsputil_init_mmxext(c, avctx, cpu_flags, high_bit_depth);

  660. 

  661.     if (X86_SSE(cpu_flags))

  662.         dsputil_init_sse(c, avctx, cpu_flags, high_bit_depth);

  663. 

  664.     if (X86_SSE2(cpu_flags))

  665.         dsputil_init_sse2(c, avctx, cpu_flags, high_bit_depth);

  666. 

  667.     if (EXTERNAL_SSSE3(cpu_flags))

  668.         dsputil_init_ssse3(c, avctx, cpu_flags, high_bit_depth);

  669. 

  670.     if (EXTERNAL_SSE4(cpu_flags))

  671.         dsputil_init_sse4(c, avctx, cpu_flags, high_bit_depth);

  672. 

  673.     if (CONFIG_ENCODERS)

  674.         ff_dsputilenc_init_mmx(c, avctx, high_bit_depth);

  675. }