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.
509 Commits
32 Branches
325MB
Tree: ba6802debf
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ba6802debf'
${ noResults }
FFmpeg/libavcodec/i386/motion_est_mmx.c

363 lines
11KB
Raw Blame History 

  1. /*

  2.  * MMX optimized motion estimation

  3.  * Copyright (c) 2001 Gerard Lantau.

  4.  *

  5.  * This program is free software; you can redistribute it and/or modify

  6.  * it under the terms of the GNU General Public License as published by

  7.  * the Free Software Foundation; either version 2 of the License, or

  8.  * (at your option) any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

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

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * You should have received a copy of the GNU General Public License

  16.  * along with this program; if not, write to the Free Software

  17.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  18.  *

  19.  * mostly by Michael Niedermayer <michaelni@gmx.at>

  20.  */

  21. #include "../dsputil.h"

  22. 

  23. static const __attribute__ ((aligned(8))) UINT64 round_tab[3]={

  24. 0x0000000000000000,

  25. 0x0001000100010001,

  26. 0x0002000200020002,

  27. };

  28. 

  29. static inline void sad8_mmx(UINT8 *blk1, UINT8 *blk2, int stride, int h)

  30. {

  31.     int len= -(stride<<h);

  32.     asm volatile(

  33.         ".balign 16			\n\t"

  34.         "1:				\n\t"

  35.         "movq (%1, %%eax), %%mm0	\n\t"

  36.         "movq (%2, %%eax), %%mm2	\n\t"

  37.         "movq (%2, %%eax), %%mm4	\n\t"

  38.         "addl %3, %%eax			\n\t"

  39.         "psubusb %%mm0, %%mm2		\n\t"

  40.         "psubusb %%mm4, %%mm0		\n\t"

  41.         "movq (%1, %%eax), %%mm1	\n\t"

  42.         "movq (%2, %%eax), %%mm3	\n\t"

  43.         "movq (%2, %%eax), %%mm5	\n\t"

  44.         "psubusb %%mm1, %%mm3		\n\t"

  45.         "psubusb %%mm5, %%mm1		\n\t"

  46.         "por %%mm2, %%mm0		\n\t"

  47.         "por %%mm1, %%mm3		\n\t"

  48.         "movq %%mm0, %%mm1		\n\t"

  49.         "movq %%mm3, %%mm2		\n\t"

  50.         "punpcklbw %%mm7, %%mm0		\n\t"

  51.         "punpckhbw %%mm7, %%mm1		\n\t"

  52.         "punpcklbw %%mm7, %%mm3		\n\t"

  53.         "punpckhbw %%mm7, %%mm2		\n\t"

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

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

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

  57.         "paddw %%mm0, %%mm6		\n\t"

  58.         "addl %3, %%eax			\n\t"

  59.         " js 1b				\n\t"

  60.         : "+a" (len)

  61.         : "r" (blk1 - len), "r" (blk2 - len), "r" (stride)

  62.     );

  63. }

  64. 

  65. static inline void sad8_mmx2(UINT8 *blk1, UINT8 *blk2, int stride, int h)

  66. {

  67.     int len= -(stride<<h);

  68.     asm volatile(

  69.         ".balign 16			\n\t"

  70.         "1:				\n\t"

  71.         "movq (%1, %%eax), %%mm0	\n\t"

  72.         "movq (%2, %%eax), %%mm2	\n\t"

  73.         "psadbw %%mm2, %%mm0		\n\t"

  74.         "addl %3, %%eax			\n\t"

  75.         "movq (%1, %%eax), %%mm1	\n\t"

  76.         "movq (%2, %%eax), %%mm3	\n\t"

  77.         "psadbw %%mm1, %%mm3		\n\t"

  78.         "paddw %%mm3, %%mm0		\n\t"

  79.         "paddw %%mm0, %%mm6		\n\t"

  80.         "addl %3, %%eax			\n\t"

  81.         " js 1b				\n\t"

  82.         : "+a" (len)

  83.         : "r" (blk1 - len), "r" (blk2 - len), "r" (stride)

  84.     );

  85. }

  86. 

  87. static inline void sad8_2_mmx2(UINT8 *blk1a, UINT8 *blk1b, UINT8 *blk2, int stride, int h)

  88. {

  89.     int len= -(stride<<h);

  90.     asm volatile(

  91.         ".balign 16			\n\t"

  92.         "1:				\n\t"

  93.         "movq (%1, %%eax), %%mm0	\n\t"

  94.         "movq (%2, %%eax), %%mm2	\n\t"

  95.         "pavgb %%mm2, %%mm0		\n\t"

  96.         "movq (%3, %%eax), %%mm2	\n\t"

  97.         "psadbw %%mm2, %%mm0		\n\t"

  98.         "addl %4, %%eax			\n\t"

  99.         "movq (%1, %%eax), %%mm1	\n\t"

  100.         "movq (%2, %%eax), %%mm3	\n\t"

  101.         "pavgb %%mm1, %%mm3		\n\t"

  102.         "movq (%3, %%eax), %%mm1	\n\t"

  103.         "psadbw %%mm1, %%mm3		\n\t"

  104.         "paddw %%mm3, %%mm0		\n\t"

  105.         "paddw %%mm0, %%mm6		\n\t"

  106.         "addl %4, %%eax			\n\t"

  107.         " js 1b				\n\t"

  108.         : "+a" (len)

  109.         : "r" (blk1a - len), "r" (blk1b -len), "r" (blk2 - len), "r" (stride)

  110.     );

  111. }

  112. 

  113. static inline void sad8_4_mmx2(UINT8 *blk1, UINT8 *blk2, int stride, int h)

  114. { //FIXME reuse src

  115.     int len= -(stride<<h);

  116.     asm volatile(

  117.         ".balign 16			\n\t"

  118.         "1:				\n\t" 

  119.         "movq (%1, %%eax), %%mm0	\n\t"

  120.         "movq (%2, %%eax), %%mm2	\n\t"

  121.         "movq 1(%1, %%eax), %%mm1	\n\t"

  122.         "movq 1(%2, %%eax), %%mm3	\n\t"

  123.         "pavgb %%mm2, %%mm0		\n\t"

  124.         "pavgb %%mm1, %%mm3		\n\t"

  125.         "pavgb %%mm3, %%mm0		\n\t"

  126.         "movq (%3, %%eax), %%mm2	\n\t"

  127.         "psadbw %%mm2, %%mm0		\n\t"

  128.         "addl %4, %%eax			\n\t"

  129.         "movq (%1, %%eax), %%mm1	\n\t"

  130.         "movq (%2, %%eax), %%mm3	\n\t"

  131.         "movq 1(%1, %%eax), %%mm2	\n\t"

  132.         "movq 1(%2, %%eax), %%mm4	\n\t"

  133.         "pavgb %%mm3, %%mm1		\n\t"

  134.         "pavgb %%mm4, %%mm2		\n\t"

  135.         "pavgb %%mm1, %%mm2		\n\t"

  136.         "movq (%3, %%eax), %%mm1	\n\t"

  137.         "psadbw %%mm1, %%mm2		\n\t"

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

  139.         "paddw %%mm0, %%mm6		\n\t"

  140.         "addl %4, %%eax			\n\t"

  141.         " js 1b				\n\t"

  142.         : "+a" (len)

  143.         : "r" (blk1 - len), "r" (blk1 - len + stride), "r" (blk2 - len), "r" (stride)

  144.     );

  145. }

  146. 

  147. static inline void sad8_2_mmx(UINT8 *blk1a, UINT8 *blk1b, UINT8 *blk2, int stride, int h)

  148. {

  149.     int len= -(stride<<h);

  150.     asm volatile(

  151.         ".balign 16			\n\t"

  152.         "1:				\n\t"

  153.         "movq (%1, %%eax), %%mm0	\n\t"

  154.         "movq (%2, %%eax), %%mm1	\n\t"

  155.         "movq (%1, %%eax), %%mm2	\n\t"

  156.         "movq (%2, %%eax), %%mm3	\n\t"

  157.         "punpcklbw %%mm7, %%mm0		\n\t"

  158.         "punpcklbw %%mm7, %%mm1		\n\t"

  159.         "punpckhbw %%mm7, %%mm2		\n\t"

  160.         "punpckhbw %%mm7, %%mm3		\n\t"

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

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

  163.         "movq (%3, %%eax), %%mm4	\n\t" 

  164.         "movq (%3, %%eax), %%mm2	\n\t"

  165.         "paddw %%mm5, %%mm1		\n\t"

  166.         "paddw %%mm5, %%mm3		\n\t"

  167.         "psrlw $1, %%mm1		\n\t"

  168.         "psrlw $1, %%mm3		\n\t"

  169.         "packuswb %%mm3, %%mm1		\n\t"

  170.         "psubusb %%mm1, %%mm4		\n\t"

  171.         "psubusb %%mm2, %%mm1		\n\t"

  172.         "por %%mm4, %%mm1		\n\t"

  173.         "movq %%mm1, %%mm0		\n\t"

  174.         "punpcklbw %%mm7, %%mm0		\n\t"

  175.         "punpckhbw %%mm7, %%mm1		\n\t"

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

  177.         "paddw %%mm0, %%mm6		\n\t"

  178.         "addl %4, %%eax			\n\t"

  179.         " js 1b				\n\t"

  180.         : "+a" (len)

  181.         : "r" (blk1a - len), "r" (blk1b -len), "r" (blk2 - len), "r" (stride)

  182.     );

  183. }

  184. 

  185. static inline void sad8_4_mmx(UINT8 *blk1, UINT8 *blk2, int stride, int h)

  186. {

  187.     int len= -(stride<<h);

  188.     asm volatile(

  189.         ".balign 16			\n\t"

  190.         "1:				\n\t"

  191.         "movq (%1, %%eax), %%mm0	\n\t"

  192.         "movq (%2, %%eax), %%mm1	\n\t"

  193.         "movq %%mm0, %%mm4		\n\t"

  194.         "movq %%mm1, %%mm2		\n\t"

  195.         "punpcklbw %%mm7, %%mm0		\n\t"

  196.         "punpcklbw %%mm7, %%mm1		\n\t"

  197.         "punpckhbw %%mm7, %%mm4		\n\t"

  198.         "punpckhbw %%mm7, %%mm2		\n\t"

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

  200.         "paddw %%mm2, %%mm4		\n\t"

  201.         "movq 1(%1, %%eax), %%mm2	\n\t"

  202.         "movq 1(%2, %%eax), %%mm3	\n\t"

  203.         "movq %%mm2, %%mm1		\n\t"

  204.         "punpcklbw %%mm7, %%mm2		\n\t"

  205.         "punpckhbw %%mm7, %%mm1		\n\t"

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

  207.         "paddw %%mm4, %%mm1		\n\t"

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

  209.         "punpcklbw %%mm7, %%mm3		\n\t"

  210.         "punpckhbw %%mm7, %%mm4		\n\t"

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

  212.         "paddw %%mm4, %%mm1		\n\t"

  213.         "movq (%3, %%eax), %%mm3	\n\t" 

  214.         "movq (%3, %%eax), %%mm4	\n\t" 

  215.         "paddw %%mm5, %%mm2		\n\t"

  216.         "paddw %%mm5, %%mm1		\n\t"

  217.         "psrlw $2, %%mm2		\n\t"

  218.         "psrlw $2, %%mm1		\n\t"

  219.         "packuswb %%mm1, %%mm2		\n\t"

  220.         "psubusb %%mm2, %%mm3		\n\t"

  221.         "psubusb %%mm4, %%mm2		\n\t"

  222.         "por %%mm3, %%mm2		\n\t"

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

  224.         "punpcklbw %%mm7, %%mm0		\n\t"

  225.         "punpckhbw %%mm7, %%mm2		\n\t"

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

  227.         "paddw %%mm0, %%mm6		\n\t"

  228.         "addl %4, %%eax			\n\t"

  229.         " js 1b				\n\t"

  230.         : "+a" (len)

  231.         : "r" (blk1 - len), "r" (blk1 -len + stride), "r" (blk2 - len), "r" (stride)

  232.     );

  233. }

  234. 

  235. static inline int sum_mmx()

  236. {

  237.     int ret;

  238.     asm volatile(

  239.         "movq %%mm6, %%mm0		\n\t"

  240.         "psrlq $32, %%mm6		\n\t"

  241.         "paddw %%mm0, %%mm6		\n\t"

  242.         "movq %%mm6, %%mm0		\n\t"

  243.         "psrlq $16, %%mm6		\n\t"

  244.         "paddw %%mm0, %%mm6		\n\t"

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

  246.         : "=r" (ret)

  247.     );

  248.     return ret&0xFFFF;

  249. }

  250. 

  251. static inline int sum_mmx2()

  252. {

  253.     int ret;

  254.     asm volatile(

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

  256.         : "=r" (ret)

  257.     );

  258.     return ret;

  259. }

  260. 

  261. #define PIX_SAD(suf)\

  262. int pix_abs8x8_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\

  263. {\

  264.     asm volatile("pxor %%mm7, %%mm7		\n\t"\

  265.                  "pxor %%mm6, %%mm6		\n\t":);\

  266. \

  267.     sad8_ ## suf(blk1, blk2, stride, 3);\

  268. \

  269.     return sum_ ## suf();\

  270. }\

  271. \

  272. int pix_abs8x8_x2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\

  273. {\

  274.     asm volatile("pxor %%mm7, %%mm7		\n\t"\

  275.                  "pxor %%mm6, %%mm6		\n\t"\

  276.                  "movq %0, %%mm5		\n\t"\

  277.                  :: "m"(round_tab[1]) \

  278.                  );\

  279. \

  280.     sad8_2_ ## suf(blk1, blk2+1, blk2, stride, 3);\

  281. \

  282.     return sum_ ## suf();\

  283. }\

  284. \

  285. int pix_abs8x8_y2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\

  286. {\

  287.     asm volatile("pxor %%mm7, %%mm7		\n\t"\

  288.                  "pxor %%mm6, %%mm6		\n\t"\

  289.                  "movq %0, %%mm5		\n\t"\

  290.                  :: "m"(round_tab[1]) \

  291.                  );\

  292. \

  293.     sad8_2_ ## suf(blk1, blk1+stride, blk2, stride, 3);\

  294. \

  295.     return sum_ ## suf();\

  296. }\

  297. \

  298. int pix_abs8x8_xy2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\

  299. {\

  300.     asm volatile("pxor %%mm7, %%mm7		\n\t"\

  301.                  "pxor %%mm6, %%mm6		\n\t"\

  302.                  "movq %0, %%mm5		\n\t"\

  303.                  :: "m"(round_tab[2]) \

  304.                  );\

  305. \

  306.     sad8_4_ ## suf(blk1, blk2, stride, 3);\

  307. \

  308.     return sum_ ## suf();\

  309. }\

  310. \

  311. int pix_abs16x16_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\

  312. {\

  313.     asm volatile("pxor %%mm7, %%mm7		\n\t"\

  314.                  "pxor %%mm6, %%mm6		\n\t":);\

  315. \

  316.     sad8_ ## suf(blk1  , blk2  , stride, 4);\

  317.     sad8_ ## suf(blk1+8, blk2+8, stride, 4);\

  318. \

  319.     return sum_ ## suf();\

  320. }\

  321. int pix_abs16x16_x2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\

  322. {\

  323.     asm volatile("pxor %%mm7, %%mm7		\n\t"\

  324.                  "pxor %%mm6, %%mm6		\n\t"\

  325.                  "movq %0, %%mm5		\n\t"\

  326.                  :: "m"(round_tab[1]) \

  327.                  );\

  328. \

  329.     sad8_2_ ## suf(blk1  , blk1+1, blk2  , stride, 4);\

  330.     sad8_2_ ## suf(blk1+8, blk1+9, blk2+8, stride, 4);\

  331. \

  332.     return sum_ ## suf();\

  333. }\

  334. int pix_abs16x16_y2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\

  335. {\

  336.     asm volatile("pxor %%mm7, %%mm7		\n\t"\

  337.                  "pxor %%mm6, %%mm6		\n\t"\

  338.                  "movq %0, %%mm5		\n\t"\

  339.                  :: "m"(round_tab[1]) \

  340.                  );\

  341. \

  342.     sad8_2_ ## suf(blk1  , blk1+stride,  blk2  , stride, 4);\

  343.     sad8_2_ ## suf(blk1+8, blk1+stride+8,blk2+8, stride, 4);\

  344. \

  345.     return sum_ ## suf();\

  346. }\

  347. int pix_abs16x16_xy2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\

  348. {\

  349.     asm volatile("pxor %%mm7, %%mm7		\n\t"\

  350.                  "pxor %%mm6, %%mm6		\n\t"\

  351.                  "movq %0, %%mm5		\n\t"\

  352.                  :: "m"(round_tab[2]) \

  353.                  );\

  354. \

  355.     sad8_4_ ## suf(blk1  , blk2  , stride, 4);\

  356.     sad8_4_ ## suf(blk1+8, blk2+8, stride, 4);\

  357. \

  358.     return sum_ ## suf();\

  359. }\

  360. 

  361. PIX_SAD(mmx)

  362. PIX_SAD(mmx2)