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

457 lines
14KB
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/dct.h"

  30. #include "libavcodec/dsputil.h"

  31. #include "libavcodec/mpegvideo.h"

  32. #include "dsputil_x86.h"

  33. 

  34. void ff_get_pixels_mmx(int16_t *block, const uint8_t *pixels, int line_size);

  35. void ff_get_pixels_sse2(int16_t *block, const uint8_t *pixels, int line_size);

  36. void ff_diff_pixels_mmx(int16_t *block, const uint8_t *s1, const uint8_t *s2,

  37.                         int stride);

  38. void ff_diff_pixels_sse2(int16_t *block, const uint8_t *s1, const uint8_t *s2,

  39.                          int stride);

  40. int ff_pix_sum16_mmx(uint8_t *pix, int line_size);

  41. int ff_pix_sum16_sse2(uint8_t *pix, int line_size);

  42. int ff_pix_sum16_xop(uint8_t *pix, int line_size);

  43. int ff_pix_norm1_mmx(uint8_t *pix, int line_size);

  44. int ff_pix_norm1_sse2(uint8_t *pix, int line_size);

  45. int ff_sum_abs_dctelem_mmx(int16_t *block);

  46. int ff_sum_abs_dctelem_mmxext(int16_t *block);

  47. int ff_sum_abs_dctelem_sse2(int16_t *block);

  48. int ff_sum_abs_dctelem_ssse3(int16_t *block);

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

  50.                 int line_size, int h);

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

  52.                  int line_size, int h);

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

  54.                   int line_size, int h);

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

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

  57. 

  58. #define hadamard_func(cpu)                                              \

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

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

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

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

  63. 

  64. hadamard_func(mmx)

  65. hadamard_func(mmxext)

  66. hadamard_func(sse2)

  67. hadamard_func(ssse3)

  68. 

  69. #if HAVE_YASM

  70. 

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

  72.                       int line_size, int h)

  73. {

  74.     int score1, score2;

  75. 

  76.     if (c)

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

  78.     else

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

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

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

  82. 

  83.     if (c)

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

  85.     else

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

  87. }

  88. 

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

  90.                      int line_size, int h)

  91. {

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

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

  94.                  ff_hf_noise8_mmx(pix2, line_size, h);

  95. 

  96.     if (c)

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

  98.     else

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

  100. }

  101. 

  102. #endif /* HAVE_YASM */

  103. 

  104. #if HAVE_INLINE_ASM

  105. 

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

  107.                             int line_size, int h)

  108. {

  109.     int tmp;

  110. 

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

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

  113. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  136. 

  137. 

  138.     __asm__ volatile (

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

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

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

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

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

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

  145.         "jmp 2f\n"

  146.         "1:\n"

  147. 

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

  149.         "2:\n"

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

  151. 

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

  153.         "jnz 1b\n"

  154. 

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

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

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

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

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

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

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

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

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

  164.         : "%ecx");

  165. 

  166.     return tmp & 0xFFFF;

  167. }

  168. #undef SUM

  169. 

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

  171.                                int line_size, int h)

  172. {

  173.     int tmp;

  174. 

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

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

  177. 

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

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

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

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

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

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

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

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

  186. 

  187.     __asm__ volatile (

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

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

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

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

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

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

  194.         "jmp 2f\n"

  195.         "1:\n"

  196. 

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

  198.         "2:\n"

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

  200. 

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

  202.         "jnz 1b\n"

  203. 

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

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

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

  207.         : "%ecx");

  208. 

  209.     return tmp;

  210. }

  211. #undef SUM

  212. 

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

  214.                       int line_size, int h)

  215. {

  216.     int tmp;

  217. 

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

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

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

  221. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  251. 

  252. 

  253.     __asm__ volatile (

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  269.         "jmp 2f\n"

  270.         "1:\n"

  271. 

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

  273.         "2:\n"

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

  275. 

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

  277.         "jnz 1b\n"

  278. 

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

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

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

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

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

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

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

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

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

  288.         : "%ecx");

  289. 

  290.     return tmp & 0x7FFF;

  291. }

  292. #undef SUM

  293. 

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

  295.                          int line_size, int h)

  296. {

  297.     int tmp;

  298. 

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

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

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

  302. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  318. 

  319.     __asm__ volatile (

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  335.         "jmp 2f\n"

  336.         "1:\n"

  337. 

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

  339.         "2:\n"

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

  341. 

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

  343.         "jnz 1b\n"

  344. 

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

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

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

  348.         : "%ecx");

  349. 

  350.     return tmp;

  351. }

  352. #undef SUM

  353. 

  354. 

  355. #endif /* HAVE_INLINE_ASM */

  356. 

  357. av_cold void ff_dsputilenc_init_mmx(DSPContext *c, AVCodecContext *avctx,

  358.                                     unsigned high_bit_depth)

  359. {

  360.     int cpu_flags = av_get_cpu_flags();

  361.     const int dct_algo = avctx->dct_algo;

  362. 

  363.     if (EXTERNAL_MMX(cpu_flags)) {

  364.         if (!high_bit_depth)

  365.             c->get_pixels = ff_get_pixels_mmx;

  366.         c->diff_pixels = ff_diff_pixels_mmx;

  367.         c->pix_sum     = ff_pix_sum16_mmx;

  368.         c->pix_norm1   = ff_pix_norm1_mmx;

  369.     }

  370. 

  371.     if (EXTERNAL_SSE2(cpu_flags))

  372.         if (!high_bit_depth)

  373.             c->get_pixels = ff_get_pixels_sse2;

  374. 

  375. #if HAVE_INLINE_ASM

  376.     if (INLINE_MMX(cpu_flags)) {

  377.         if (!high_bit_depth &&

  378.             (dct_algo == FF_DCT_AUTO || dct_algo == FF_DCT_MMX))

  379.             c->fdct = ff_fdct_mmx;

  380. 

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

  382. 

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

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

  385.         }

  386.     }

  387. 

  388.     if (INLINE_MMXEXT(cpu_flags)) {

  389.         if (!high_bit_depth &&

  390.             (dct_algo == FF_DCT_AUTO || dct_algo == FF_DCT_MMX))

  391.             c->fdct = ff_fdct_mmxext;

  392. 

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

  394. 

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

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

  397.         }

  398.     }

  399. 

  400.     if (INLINE_SSE2(cpu_flags)) {

  401.         if (!high_bit_depth &&

  402.             (dct_algo == FF_DCT_AUTO || dct_algo == FF_DCT_MMX))

  403.             c->fdct = ff_fdct_sse2;

  404.     }

  405. 

  406. #if HAVE_SSSE3_INLINE

  407.     if (INLINE_SSSE3(cpu_flags)) {

  408.     }

  409. #endif

  410. #endif /* HAVE_INLINE_ASM */

  411. 

  412.     if (EXTERNAL_MMX(cpu_flags)) {

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

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

  415.         c->sum_abs_dctelem   = ff_sum_abs_dctelem_mmx;

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

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

  418. #if HAVE_YASM

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

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

  421. #endif

  422.     }

  423. 

  424.     if (EXTERNAL_MMXEXT(cpu_flags)) {

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

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

  427.         c->sum_abs_dctelem   = ff_sum_abs_dctelem_mmxext;

  428.     }

  429. 

  430.     if (EXTERNAL_SSE2(cpu_flags)) {

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

  432.         c->sum_abs_dctelem   = ff_sum_abs_dctelem_sse2;

  433.         c->diff_pixels = ff_diff_pixels_sse2;

  434.         c->pix_sum     = ff_pix_sum16_sse2;

  435.         c->pix_norm1   = ff_pix_norm1_sse2;

  436. 

  437. #if HAVE_ALIGNED_STACK

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

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

  440. #endif

  441.     }

  442. 

  443.     if (EXTERNAL_SSSE3(cpu_flags)) {

  444.         c->sum_abs_dctelem   = ff_sum_abs_dctelem_ssse3;

  445. #if HAVE_ALIGNED_STACK

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

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

  448. #endif

  449.     }

  450. 

  451.     if (EXTERNAL_XOP(cpu_flags)) {

  452.         c->pix_sum           = ff_pix_sum16_xop;

  453.     }

  454. 

  455.     ff_dsputil_init_pix_mmx(c, avctx);

  456. }