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.
64632 Commits
32 Branches
303MB
Tree: 123649dd19
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '123649dd19'
${ noResults }
FFmpeg/libavcodec/x86/dsputilenc_mmx.c

405 lines
12KB
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 FFmpeg.

  9.  *

  10.  * FFmpeg 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.  * FFmpeg 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 FFmpeg; if not, write to the Free Software

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

  23.  */

  24. 

  25. #include "libavutil/attributes.h"

  26. #include "libavutil/cpu.h"

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

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

  29. #include "libavcodec/dsputil.h"

  30. #include "libavcodec/mpegvideo.h"

  31. #include "dsputil_x86.h"

  32. 

  33. int ff_sum_abs_dctelem_mmx(int16_t *block);

  34. int ff_sum_abs_dctelem_mmxext(int16_t *block);

  35. int ff_sum_abs_dctelem_sse2(int16_t *block);

  36. int ff_sum_abs_dctelem_ssse3(int16_t *block);

  37. int ff_sse8_mmx(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,

  38.                 int line_size, int h);

  39. int ff_sse16_mmx(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,

  40.                  int line_size, int h);

  41. int ff_sse16_sse2(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,

  42.                   int line_size, int h);

  43. int ff_hf_noise8_mmx(uint8_t *pix1, int lsize, int h);

  44. int ff_hf_noise16_mmx(uint8_t *pix1, int lsize, int h);

  45. 

  46. #define hadamard_func(cpu)                                              \

  47.     int ff_hadamard8_diff_ ## cpu(MpegEncContext *s, uint8_t *src1,     \

  48.                                   uint8_t *src2, int stride, int h);    \

  49.     int ff_hadamard8_diff16_ ## cpu(MpegEncContext *s, uint8_t *src1,   \

  50.                                     uint8_t *src2, int stride, int h);

  51. 

  52. hadamard_func(mmx)

  53. hadamard_func(mmxext)

  54. hadamard_func(sse2)

  55. hadamard_func(ssse3)

  56. 

  57. #if HAVE_YASM

  58. 

  59. static int nsse16_mmx(MpegEncContext *c, uint8_t *pix1, uint8_t *pix2,

  60.                       int line_size, int h)

  61. {

  62.     int score1, score2;

  63. 

  64.     if (c)

  65.         score1 = c->dsp.sse[0](c, pix1, pix2, line_size, h);

  66.     else

  67.         score1 = ff_sse16_mmx(c, pix1, pix2, line_size, h);

  68.     score2 = ff_hf_noise16_mmx(pix1, line_size, h) + ff_hf_noise8_mmx(pix1+8, line_size, h)

  69.            - ff_hf_noise16_mmx(pix2, line_size, h) - ff_hf_noise8_mmx(pix2+8, line_size, h);

  70. 

  71.     if (c)

  72.         return score1 + FFABS(score2) * c->avctx->nsse_weight;

  73.     else

  74.         return score1 + FFABS(score2) * 8;

  75. }

  76. 

  77. static int nsse8_mmx(MpegEncContext *c, uint8_t *pix1, uint8_t *pix2,

  78.                      int line_size, int h)

  79. {

  80.     int score1 = ff_sse8_mmx(c, pix1, pix2, line_size, h);

  81.     int score2 = ff_hf_noise8_mmx(pix1, line_size, h) -

  82.                  ff_hf_noise8_mmx(pix2, line_size, h);

  83. 

  84.     if (c)

  85.         return score1 + FFABS(score2) * c->avctx->nsse_weight;

  86.     else

  87.         return score1 + FFABS(score2) * 8;

  88. }

  89. 

  90. #endif /* HAVE_YASM */

  91. 

  92. #if HAVE_INLINE_ASM

  93. 

  94. static int vsad_intra16_mmx(MpegEncContext *v, uint8_t *pix, uint8_t *dummy,

  95.                             int line_size, int h)

  96. {

  97.     int tmp;

  98. 

  99.     av_assert2((((int) pix) & 7) == 0);

  100.     av_assert2((line_size & 7) == 0);

  101. 

  102. #define SUM(in0, in1, out0, out1)               \

  103.     "movq (%0), %%mm2\n"                        \

  104.     "movq 8(%0), %%mm3\n"                       \

  105.     "add %2,%0\n"                               \

  106.     "movq %%mm2, " #out0 "\n"                   \

  107.     "movq %%mm3, " #out1 "\n"                   \

  108.     "psubusb " #in0 ", %%mm2\n"                 \

  109.     "psubusb " #in1 ", %%mm3\n"                 \

  110.     "psubusb " #out0 ", " #in0 "\n"             \

  111.     "psubusb " #out1 ", " #in1 "\n"             \

  112.     "por %%mm2, " #in0 "\n"                     \

  113.     "por %%mm3, " #in1 "\n"                     \

  114.     "movq " #in0 ", %%mm2\n"                    \

  115.     "movq " #in1 ", %%mm3\n"                    \

  116.     "punpcklbw %%mm7, " #in0 "\n"               \

  117.     "punpcklbw %%mm7, " #in1 "\n"               \

  118.     "punpckhbw %%mm7, %%mm2\n"                  \

  119.     "punpckhbw %%mm7, %%mm3\n"                  \

  120.     "paddw " #in1 ", " #in0 "\n"                \

  121.     "paddw %%mm3, %%mm2\n"                      \

  122.     "paddw %%mm2, " #in0 "\n"                   \

  123.     "paddw " #in0 ", %%mm6\n"

  124. 

  125. 

  126.     __asm__ volatile (

  127.         "movl    %3, %%ecx\n"

  128.         "pxor %%mm6, %%mm6\n"

  129.         "pxor %%mm7, %%mm7\n"

  130.         "movq  (%0), %%mm0\n"

  131.         "movq 8(%0), %%mm1\n"

  132.         "add %2, %0\n"

  133.         "jmp 2f\n"

  134.         "1:\n"

  135. 

  136.         SUM(%%mm4, %%mm5, %%mm0, %%mm1)

  137.         "2:\n"

  138.         SUM(%%mm0, %%mm1, %%mm4, %%mm5)

  139. 

  140.         "subl $2, %%ecx\n"

  141.         "jnz 1b\n"

  142. 

  143.         "movq  %%mm6, %%mm0\n"

  144.         "psrlq $32,   %%mm6\n"

  145.         "paddw %%mm6, %%mm0\n"

  146.         "movq  %%mm0, %%mm6\n"

  147.         "psrlq $16,   %%mm0\n"

  148.         "paddw %%mm6, %%mm0\n"

  149.         "movd  %%mm0, %1\n"

  150.         : "+r" (pix), "=r" (tmp)

  151.         : "r" ((x86_reg) line_size), "m" (h)

  152.         : "%ecx");

  153. 

  154.     return tmp & 0xFFFF;

  155. }

  156. #undef SUM

  157. 

  158. static int vsad_intra16_mmxext(MpegEncContext *v, uint8_t *pix, uint8_t *dummy,

  159.                                int line_size, int h)

  160. {

  161.     int tmp;

  162. 

  163.     av_assert2((((int) pix) & 7) == 0);

  164.     av_assert2((line_size & 7) == 0);

  165. 

  166. #define SUM(in0, in1, out0, out1)               \

  167.     "movq (%0), " #out0 "\n"                    \

  168.     "movq 8(%0), " #out1 "\n"                   \

  169.     "add %2, %0\n"                              \

  170.     "psadbw " #out0 ", " #in0 "\n"              \

  171.     "psadbw " #out1 ", " #in1 "\n"              \

  172.     "paddw " #in1 ", " #in0 "\n"                \

  173.     "paddw " #in0 ", %%mm6\n"

  174. 

  175.     __asm__ volatile (

  176.         "movl %3, %%ecx\n"

  177.         "pxor %%mm6, %%mm6\n"

  178.         "pxor %%mm7, %%mm7\n"

  179.         "movq (%0), %%mm0\n"

  180.         "movq 8(%0), %%mm1\n"

  181.         "add %2, %0\n"

  182.         "jmp 2f\n"

  183.         "1:\n"

  184. 

  185.         SUM(%%mm4, %%mm5, %%mm0, %%mm1)

  186.         "2:\n"

  187.         SUM(%%mm0, %%mm1, %%mm4, %%mm5)

  188. 

  189.         "subl $2, %%ecx\n"

  190.         "jnz 1b\n"

  191. 

  192.         "movd %%mm6, %1\n"

  193.         : "+r" (pix), "=r" (tmp)

  194.         : "r" ((x86_reg) line_size), "m" (h)

  195.         : "%ecx");

  196. 

  197.     return tmp;

  198. }

  199. #undef SUM

  200. 

  201. static int vsad16_mmx(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,

  202.                       int line_size, int h)

  203. {

  204.     int tmp;

  205. 

  206.     av_assert2((((int) pix1) & 7) == 0);

  207.     av_assert2((((int) pix2) & 7) == 0);

  208.     av_assert2((line_size & 7) == 0);

  209. 

  210. #define SUM(in0, in1, out0, out1)       \

  211.     "movq (%0), %%mm2\n"                \

  212.     "movq (%1), " #out0 "\n"            \

  213.     "movq 8(%0), %%mm3\n"               \

  214.     "movq 8(%1), " #out1 "\n"           \

  215.     "add %3, %0\n"                      \

  216.     "add %3, %1\n"                      \

  217.     "psubb " #out0 ", %%mm2\n"          \

  218.     "psubb " #out1 ", %%mm3\n"          \

  219.     "pxor %%mm7, %%mm2\n"               \

  220.     "pxor %%mm7, %%mm3\n"               \

  221.     "movq %%mm2, " #out0 "\n"           \

  222.     "movq %%mm3, " #out1 "\n"           \

  223.     "psubusb " #in0 ", %%mm2\n"         \

  224.     "psubusb " #in1 ", %%mm3\n"         \

  225.     "psubusb " #out0 ", " #in0 "\n"     \

  226.     "psubusb " #out1 ", " #in1 "\n"     \

  227.     "por %%mm2, " #in0 "\n"             \

  228.     "por %%mm3, " #in1 "\n"             \

  229.     "movq " #in0 ", %%mm2\n"            \

  230.     "movq " #in1 ", %%mm3\n"            \

  231.     "punpcklbw %%mm7, " #in0 "\n"       \

  232.     "punpcklbw %%mm7, " #in1 "\n"       \

  233.     "punpckhbw %%mm7, %%mm2\n"          \

  234.     "punpckhbw %%mm7, %%mm3\n"          \

  235.     "paddw " #in1 ", " #in0 "\n"        \

  236.     "paddw %%mm3, %%mm2\n"              \

  237.     "paddw %%mm2, " #in0 "\n"           \

  238.     "paddw " #in0 ", %%mm6\n"

  239. 

  240. 

  241.     __asm__ volatile (

  242.         "movl %4, %%ecx\n"

  243.         "pxor %%mm6, %%mm6\n"

  244.         "pcmpeqw %%mm7, %%mm7\n"

  245.         "psllw $15, %%mm7\n"

  246.         "packsswb %%mm7, %%mm7\n"

  247.         "movq (%0), %%mm0\n"

  248.         "movq (%1), %%mm2\n"

  249.         "movq 8(%0), %%mm1\n"

  250.         "movq 8(%1), %%mm3\n"

  251.         "add %3, %0\n"

  252.         "add %3, %1\n"

  253.         "psubb %%mm2, %%mm0\n"

  254.         "psubb %%mm3, %%mm1\n"

  255.         "pxor %%mm7, %%mm0\n"

  256.         "pxor %%mm7, %%mm1\n"

  257.         "jmp 2f\n"

  258.         "1:\n"

  259. 

  260.         SUM(%%mm4, %%mm5, %%mm0, %%mm1)

  261.         "2:\n"

  262.         SUM(%%mm0, %%mm1, %%mm4, %%mm5)

  263. 

  264.         "subl $2, %%ecx\n"

  265.         "jnz 1b\n"

  266. 

  267.         "movq %%mm6, %%mm0\n"

  268.         "psrlq $32, %%mm6\n"

  269.         "paddw %%mm6, %%mm0\n"

  270.         "movq %%mm0, %%mm6\n"

  271.         "psrlq $16, %%mm0\n"

  272.         "paddw %%mm6, %%mm0\n"

  273.         "movd %%mm0, %2\n"

  274.         : "+r" (pix1), "+r" (pix2), "=r" (tmp)

  275.         : "r" ((x86_reg) line_size), "m" (h)

  276.         : "%ecx");

  277. 

  278.     return tmp & 0x7FFF;

  279. }

  280. #undef SUM

  281. 

  282. static int vsad16_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,

  283.                          int line_size, int h)

  284. {

  285.     int tmp;

  286. 

  287.     av_assert2((((int) pix1) & 7) == 0);

  288.     av_assert2((((int) pix2) & 7) == 0);

  289.     av_assert2((line_size & 7) == 0);

  290. 

  291. #define SUM(in0, in1, out0, out1)               \

  292.     "movq (%0), " #out0 "\n"                    \

  293.     "movq (%1), %%mm2\n"                        \

  294.     "movq 8(%0), " #out1 "\n"                   \

  295.     "movq 8(%1), %%mm3\n"                       \

  296.     "add %3, %0\n"                              \

  297.     "add %3, %1\n"                              \

  298.     "psubb %%mm2, " #out0 "\n"                  \

  299.     "psubb %%mm3, " #out1 "\n"                  \

  300.     "pxor %%mm7, " #out0 "\n"                   \

  301.     "pxor %%mm7, " #out1 "\n"                   \

  302.     "psadbw " #out0 ", " #in0 "\n"              \

  303.     "psadbw " #out1 ", " #in1 "\n"              \

  304.     "paddw " #in1 ", " #in0 "\n"                \

  305.     "paddw " #in0 ", %%mm6\n    "

  306. 

  307.     __asm__ volatile (

  308.         "movl %4, %%ecx\n"

  309.         "pxor %%mm6, %%mm6\n"

  310.         "pcmpeqw %%mm7, %%mm7\n"

  311.         "psllw $15, %%mm7\n"

  312.         "packsswb %%mm7, %%mm7\n"

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

  314.         "movq (%1), %%mm2\n"

  315.         "movq 8(%0), %%mm1\n"

  316.         "movq 8(%1), %%mm3\n"

  317.         "add %3, %0\n"

  318.         "add %3, %1\n"

  319.         "psubb %%mm2, %%mm0\n"

  320.         "psubb %%mm3, %%mm1\n"

  321.         "pxor %%mm7, %%mm0\n"

  322.         "pxor %%mm7, %%mm1\n"

  323.         "jmp 2f\n"

  324.         "1:\n"

  325. 

  326.         SUM(%%mm4, %%mm5, %%mm0, %%mm1)

  327.         "2:\n"

  328.         SUM(%%mm0, %%mm1, %%mm4, %%mm5)

  329. 

  330.         "subl $2, %%ecx\n"

  331.         "jnz 1b\n"

  332. 

  333.         "movd %%mm6, %2\n"

  334.         : "+r" (pix1), "+r" (pix2), "=r" (tmp)

  335.         : "r" ((x86_reg) line_size), "m" (h)

  336.         : "%ecx");

  337. 

  338.     return tmp;

  339. }

  340. #undef SUM

  341. 

  342. 

  343. #endif /* HAVE_INLINE_ASM */

  344. 

  345. av_cold void ff_dsputilenc_init_mmx(DSPContext *c, AVCodecContext *avctx)

  346. {

  347.     int cpu_flags = av_get_cpu_flags();

  348. 

  349. #if HAVE_INLINE_ASM

  350.     if (INLINE_MMX(cpu_flags)) {

  351.         c->vsad[4] = vsad_intra16_mmx;

  352. 

  353.         if (!(avctx->flags & CODEC_FLAG_BITEXACT)) {

  354.             c->vsad[0]      = vsad16_mmx;

  355.         }

  356.     }

  357. 

  358.     if (INLINE_MMXEXT(cpu_flags)) {

  359.         c->vsad[4]         = vsad_intra16_mmxext;

  360. 

  361.         if (!(avctx->flags & CODEC_FLAG_BITEXACT)) {

  362.             c->vsad[0] = vsad16_mmxext;

  363.         }

  364.     }

  365. #endif /* HAVE_INLINE_ASM */

  366. 

  367.     if (EXTERNAL_MMX(cpu_flags)) {

  368.         c->hadamard8_diff[0] = ff_hadamard8_diff16_mmx;

  369.         c->hadamard8_diff[1] = ff_hadamard8_diff_mmx;

  370.         c->sum_abs_dctelem   = ff_sum_abs_dctelem_mmx;

  371.         c->sse[0]            = ff_sse16_mmx;

  372.         c->sse[1]            = ff_sse8_mmx;

  373. #if HAVE_YASM

  374.         c->nsse[0]           = nsse16_mmx;

  375.         c->nsse[1]           = nsse8_mmx;

  376. #endif

  377.     }

  378. 

  379.     if (EXTERNAL_MMXEXT(cpu_flags)) {

  380.         c->hadamard8_diff[0] = ff_hadamard8_diff16_mmxext;

  381.         c->hadamard8_diff[1] = ff_hadamard8_diff_mmxext;

  382.         c->sum_abs_dctelem   = ff_sum_abs_dctelem_mmxext;

  383.     }

  384. 

  385.     if (EXTERNAL_SSE2(cpu_flags)) {

  386.         c->sse[0] = ff_sse16_sse2;

  387.         c->sum_abs_dctelem   = ff_sum_abs_dctelem_sse2;

  388. 

  389. #if HAVE_ALIGNED_STACK

  390.         c->hadamard8_diff[0] = ff_hadamard8_diff16_sse2;

  391.         c->hadamard8_diff[1] = ff_hadamard8_diff_sse2;

  392. #endif

  393.     }

  394. 

  395.     if (EXTERNAL_SSSE3(cpu_flags)) {

  396.         c->sum_abs_dctelem   = ff_sum_abs_dctelem_ssse3;

  397. #if HAVE_ALIGNED_STACK

  398.         c->hadamard8_diff[0] = ff_hadamard8_diff16_ssse3;

  399.         c->hadamard8_diff[1] = ff_hadamard8_diff_ssse3;

  400. #endif

  401.     }

  402. 

  403.     ff_dsputil_init_pix_mmx(c, avctx);

  404. }