开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
motion_est_mmx.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：13k
源码类别：

Windows CE

开发平台：

C/C++

motion_est_mmx.c：源码内容
  1. /*
  2.  * MMX optimized motion estimation
  3.  * Copyright (c) 2001 Fabrice Bellard.
  4.  * Copyright (c) 2002-2004 Michael Niedermayer
  5.  *
  6.  * This library is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Lesser General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2 of the License, or (at your option) any later version.
  10.  *
  11.  * This library is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public
  17.  * License along with this library; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.  *
  20.  * mostly by Michael Niedermayer <michaelni@gmx.at>
  21.  */
  22. #include "../dsputil.h"
  23. #include "mmx.h"
  25. static const __attribute__ ((aligned(8))) uint64_t round_tab[3]={
  26. 0x0000000000000000ULL,
  27. 0x0001000100010001ULL,
  28. 0x0002000200020002ULL,
  29. };
  31. static attribute_used __attribute__ ((aligned(8))) uint64_t bone= 0x0101010101010101LL;
  33. static inline void sad8_1_mmx(uint8_t *blk1, uint8_t *blk2, int stride, int h)
  34. {
  35.     long len= -(stride*h);
  36.     asm volatile(
  37.         ".balign 16 nt"
  38.         "1: nt"
  39.         "movq (%1, %%"REG_a"), %%mm0 nt"
  40.         "movq (%2, %%"REG_a"), %%mm2 nt"
  41.         "movq (%2, %%"REG_a"), %%mm4 nt"
  42.         "add %3, %%"REG_a" nt"
  43.         "psubusb %%mm0, %%mm2 nt"
  44.         "psubusb %%mm4, %%mm0 nt"
  45.         "movq (%1, %%"REG_a"), %%mm1 nt"
  46.         "movq (%2, %%"REG_a"), %%mm3 nt"
  47.         "movq (%2, %%"REG_a"), %%mm5 nt"
  48.         "psubusb %%mm1, %%mm3 nt"
  49.         "psubusb %%mm5, %%mm1 nt"
  50.         "por %%mm2, %%mm0 nt"
  51.         "por %%mm1, %%mm3 nt"
  52.         "movq %%mm0, %%mm1 nt"
  53.         "movq %%mm3, %%mm2 nt"
  54.         "punpcklbw %%mm7, %%mm0 nt"
  55.         "punpckhbw %%mm7, %%mm1 nt"
  56.         "punpcklbw %%mm7, %%mm3 nt"
  57.         "punpckhbw %%mm7, %%mm2 nt"
  58.         "paddw %%mm1, %%mm0 nt"
  59.         "paddw %%mm3, %%mm2 nt"
  60.         "paddw %%mm2, %%mm0 nt"
  61.         "paddw %%mm0, %%mm6 nt"
  62.         "add %3, %%"REG_a" nt"
  63.         " js 1b nt"
  64.         : "+a" (len)
  65.         : "r" (blk1 - len), "r" (blk2 - len), "r" ((long)stride)
  66.     );
  67. }
  69. static inline void sad8_1_mmx2(uint8_t *blk1, uint8_t *blk2, int stride, int h)
  70. {
  71.     long len= -(stride*h);
  72.     asm volatile(
  73.         ".balign 16 nt"
  74.         "1: nt"
  75.         "movq (%1, %%"REG_a"), %%mm0 nt"
  76.         "movq (%2, %%"REG_a"), %%mm2 nt"
  77.         "psadbw %%mm2, %%mm0 nt"
  78.         "add %3, %%"REG_a" nt"
  79.         "movq (%1, %%"REG_a"), %%mm1 nt"
  80.         "movq (%2, %%"REG_a"), %%mm3 nt"
  81.         "psadbw %%mm1, %%mm3 nt"
  82.         "paddw %%mm3, %%mm0 nt"
  83.         "paddw %%mm0, %%mm6 nt"
  84.         "add %3, %%"REG_a" nt"
  85.         " js 1b nt"
  86.         : "+a" (len)
  87.         : "r" (blk1 - len), "r" (blk2 - len), "r" ((long)stride)
  88.     );
  89. }
  91. static inline void sad8_2_mmx2(uint8_t *blk1a, uint8_t *blk1b, uint8_t *blk2, int stride, int h)
  92. {
  93.     long len= -(stride*h);
  94.     asm volatile(
  95.         ".balign 16 nt"
  96.         "1: nt"
  97.         "movq (%1, %%"REG_a"), %%mm0 nt"
  98.         "movq (%2, %%"REG_a"), %%mm2 nt"
  99.         "pavgb %%mm2, %%mm0 nt"
  100.         "movq (%3, %%"REG_a"), %%mm2 nt"
  101.         "psadbw %%mm2, %%mm0 nt"
  102.         "add %4, %%"REG_a" nt"
  103.         "movq (%1, %%"REG_a"), %%mm1 nt"
  104.         "movq (%2, %%"REG_a"), %%mm3 nt"
  105.         "pavgb %%mm1, %%mm3 nt"
  106.         "movq (%3, %%"REG_a"), %%mm1 nt"
  107.         "psadbw %%mm1, %%mm3 nt"
  108.         "paddw %%mm3, %%mm0 nt"
  109.         "paddw %%mm0, %%mm6 nt"
  110.         "add %4, %%"REG_a" nt"
  111.         " js 1b nt"
  112.         : "+a" (len)
  113.         : "r" (blk1a - len), "r" (blk1b -len), "r" (blk2 - len), "r" ((long)stride)
  114.     );
  115. }
  117. static inline void sad8_4_mmx2(uint8_t *blk1, uint8_t *blk2, int stride, int h)
  118. { //FIXME reuse src
  119.     long len= -(stride*h);
  120.     asm volatile(
  121.         ".balign 16 nt"
  122.         "movq "MANGLE(bone)", %%mm5 nt"
  123.         "1: nt"
  124.         "movq (%1, %%"REG_a"), %%mm0 nt"
  125.         "movq (%2, %%"REG_a"), %%mm2 nt"
  126.         "movq 1(%1, %%"REG_a"), %%mm1 nt"
  127.         "movq 1(%2, %%"REG_a"), %%mm3 nt"
  128.         "pavgb %%mm2, %%mm0 nt"
  129.         "pavgb %%mm1, %%mm3 nt"
  130.         "psubusb %%mm5, %%mm3 nt"
  131.         "pavgb %%mm3, %%mm0 nt"
  132.         "movq (%3, %%"REG_a"), %%mm2 nt"
  133.         "psadbw %%mm2, %%mm0 nt"
  134.         "add %4, %%"REG_a" nt"
  135.         "movq (%1, %%"REG_a"), %%mm1 nt"
  136.         "movq (%2, %%"REG_a"), %%mm3 nt"
  137.         "movq 1(%1, %%"REG_a"), %%mm2 nt"
  138.         "movq 1(%2, %%"REG_a"), %%mm4 nt"
  139.         "pavgb %%mm3, %%mm1 nt"
  140.         "pavgb %%mm4, %%mm2 nt"
  141.         "psubusb %%mm5, %%mm2 nt"
  142.         "pavgb %%mm1, %%mm2 nt"
  143.         "movq (%3, %%"REG_a"), %%mm1 nt"
  144.         "psadbw %%mm1, %%mm2 nt"
  145.         "paddw %%mm2, %%mm0 nt"
  146.         "paddw %%mm0, %%mm6 nt"
  147.         "add %4, %%"REG_a" nt"
  148.         " js 1b nt"
  149.         : "+a" (len)
  150.         : "r" (blk1 - len), "r" (blk1 - len + stride), "r" (blk2 - len), "r" ((long)stride)
  151.     );
  152. }
  154. static inline void sad8_2_mmx(uint8_t *blk1a, uint8_t *blk1b, uint8_t *blk2, int stride, int h)
  155. {
  156.     long len= -(stride*h);
  157.     asm volatile(
  158.         ".balign 16 nt"
  159.         "1: nt"
  160.         "movq (%1, %%"REG_a"), %%mm0 nt"
  161.         "movq (%2, %%"REG_a"), %%mm1 nt"
  162.         "movq (%1, %%"REG_a"), %%mm2 nt"
  163.         "movq (%2, %%"REG_a"), %%mm3 nt"
  164.         "punpcklbw %%mm7, %%mm0 nt"
  165.         "punpcklbw %%mm7, %%mm1 nt"
  166.         "punpckhbw %%mm7, %%mm2 nt"
  167.         "punpckhbw %%mm7, %%mm3 nt"
  168.         "paddw %%mm0, %%mm1 nt"
  169.         "paddw %%mm2, %%mm3 nt"
  170.         "movq (%3, %%"REG_a"), %%mm4 nt"
  171.         "movq (%3, %%"REG_a"), %%mm2 nt"
  172.         "paddw %%mm5, %%mm1 nt"
  173.         "paddw %%mm5, %%mm3 nt"
  174.         "psrlw $1, %%mm1 nt"
  175.         "psrlw $1, %%mm3 nt"
  176.         "packuswb %%mm3, %%mm1 nt"
  177.         "psubusb %%mm1, %%mm4 nt"
  178.         "psubusb %%mm2, %%mm1 nt"
  179.         "por %%mm4, %%mm1 nt"
  180.         "movq %%mm1, %%mm0 nt"
  181.         "punpcklbw %%mm7, %%mm0 nt"
  182.         "punpckhbw %%mm7, %%mm1 nt"
  183.         "paddw %%mm1, %%mm0 nt"
  184.         "paddw %%mm0, %%mm6 nt"
  185.         "add %4, %%"REG_a" nt"
  186.         " js 1b nt"
  187.         : "+a" (len)
  188.         : "r" (blk1a - len), "r" (blk1b -len), "r" (blk2 - len), "r" ((long)stride)
  189.     );
  190. }
  192. static inline void sad8_4_mmx(uint8_t *blk1, uint8_t *blk2, int stride, int h)
  193. {
  194.     long len= -(stride*h);
  195.     asm volatile(
  196.         ".balign 16 nt"
  197.         "1: nt"
  198.         "movq (%1, %%"REG_a"), %%mm0 nt"
  199.         "movq (%2, %%"REG_a"), %%mm1 nt"
  200.         "movq %%mm0, %%mm4 nt"
  201.         "movq %%mm1, %%mm2 nt"
  202.         "punpcklbw %%mm7, %%mm0 nt"
  203.         "punpcklbw %%mm7, %%mm1 nt"
  204.         "punpckhbw %%mm7, %%mm4 nt"
  205.         "punpckhbw %%mm7, %%mm2 nt"
  206.         "paddw %%mm1, %%mm0 nt"
  207.         "paddw %%mm2, %%mm4 nt"
  208.         "movq 1(%1, %%"REG_a"), %%mm2 nt"
  209.         "movq 1(%2, %%"REG_a"), %%mm3 nt"
  210.         "movq %%mm2, %%mm1 nt"
  211.         "punpcklbw %%mm7, %%mm2 nt"
  212.         "punpckhbw %%mm7, %%mm1 nt"
  213.         "paddw %%mm0, %%mm2 nt"
  214.         "paddw %%mm4, %%mm1 nt"
  215.         "movq %%mm3, %%mm4 nt"
  216.         "punpcklbw %%mm7, %%mm3 nt"
  217.         "punpckhbw %%mm7, %%mm4 nt"
  218.         "paddw %%mm3, %%mm2 nt"
  219.         "paddw %%mm4, %%mm1 nt"
  220.         "movq (%3, %%"REG_a"), %%mm3 nt"
  221.         "movq (%3, %%"REG_a"), %%mm4 nt"
  222.         "paddw %%mm5, %%mm2 nt"
  223.         "paddw %%mm5, %%mm1 nt"
  224.         "psrlw $2, %%mm2 nt"
  225.         "psrlw $2, %%mm1 nt"
  226.         "packuswb %%mm1, %%mm2 nt"
  227.         "psubusb %%mm2, %%mm3 nt"
  228.         "psubusb %%mm4, %%mm2 nt"
  229.         "por %%mm3, %%mm2 nt"
  230.         "movq %%mm2, %%mm0 nt"
  231.         "punpcklbw %%mm7, %%mm0 nt"
  232.         "punpckhbw %%mm7, %%mm2 nt"
  233.         "paddw %%mm2, %%mm0 nt"
  234.         "paddw %%mm0, %%mm6 nt"
  235.         "add %4, %%"REG_a" nt"
  236.         " js 1b nt"
  237.         : "+a" (len)
  238.         : "r" (blk1 - len), "r" (blk1 -len + stride), "r" (blk2 - len), "r" ((long)stride)
  239.     );
  240. }
  242. static inline int sum_mmx(void)
  243. {
  244.     int ret;
  245.     asm volatile(
  246.         "movq %%mm6, %%mm0 nt"
  247.         "psrlq $32, %%mm6 nt"
  248.         "paddw %%mm0, %%mm6 nt"
  249.         "movq %%mm6, %%mm0 nt"
  250.         "psrlq $16, %%mm6 nt"
  251.         "paddw %%mm0, %%mm6 nt"
  252.         "movd %%mm6, %0 nt"
  253.         : "=r" (ret)
  254.     );
  255.     return ret&0xFFFF;
  256. }
  258. static inline int sum_mmx2(void)
  259. {
  260.     int ret;
  261.     asm volatile(
  262.         "movd %%mm6, %0 nt"
  263.         : "=r" (ret)
  264.     );
  265.     return ret;
  266. }
  269. #define PIX_SAD(suf)
  270. static int sad8_ ## suf(void *v, uint8_t *blk2, uint8_t *blk1, int stride, int h)
  271. {
  272.     assert(h==8);
  273.     asm volatile("pxor %%mm7, %%mm7 nt"
  274.                  "pxor %%mm6, %%mm6 nt":);
  276.     sad8_1_ ## suf(blk1, blk2, stride, 8);
  278.     return sum_ ## suf();
  279. }
  280. static int sad8_x2_ ## suf(void *v, uint8_t *blk2, uint8_t *blk1, int stride, int h)
  281. {
  282.     assert(h==8);
  283.     asm volatile("pxor %%mm7, %%mm7 nt"
  284.                  "pxor %%mm6, %%mm6 nt"
  285.                  "movq %0, %%mm5 nt"
  286.                  :: "m"(round_tab[1]) 
  287.                  );
  289.     sad8_2_ ## suf(blk1, blk1+1, blk2, stride, 8);
  291.     return sum_ ## suf();
  292. }
  294. static int sad8_y2_ ## suf(void *v, uint8_t *blk2, uint8_t *blk1, int stride, int h)
  295. {
  296.     assert(h==8);
  297.     asm volatile("pxor %%mm7, %%mm7 nt"
  298.                  "pxor %%mm6, %%mm6 nt"
  299.                  "movq %0, %%mm5 nt"
  300.                  :: "m"(round_tab[1]) 
  301.                  );
  303.     sad8_2_ ## suf(blk1, blk1+stride, blk2, stride, 8);
  305.     return sum_ ## suf();
  306. }
  308. static int sad8_xy2_ ## suf(void *v, uint8_t *blk2, uint8_t *blk1, int stride, int h)
  309. {
  310.     assert(h==8);
  311.     asm volatile("pxor %%mm7, %%mm7 nt"
  312.                  "pxor %%mm6, %%mm6 nt"
  313.                  "movq %0, %%mm5 nt"
  314.                  :: "m"(round_tab[2]) 
  315.                  );
  317.     sad8_4_ ## suf(blk1, blk2, stride, 8);
  319.     return sum_ ## suf();
  320. }
  322. static int sad16_ ## suf(void *v, uint8_t *blk2, uint8_t *blk1, int stride, int h)
  323. {
  324.     asm volatile("pxor %%mm7, %%mm7 nt"
  325.                  "pxor %%mm6, %%mm6 nt":);
  327.     sad8_1_ ## suf(blk1  , blk2  , stride, h);
  328.     sad8_1_ ## suf(blk1+8, blk2+8, stride, h);
  330.     return sum_ ## suf();
  331. }
  332. static int sad16_x2_ ## suf(void *v, uint8_t *blk2, uint8_t *blk1, int stride, int h)
  333. {
  334.     asm volatile("pxor %%mm7, %%mm7 nt"
  335.                  "pxor %%mm6, %%mm6 nt"
  336.                  "movq %0, %%mm5 nt"
  337.                  :: "m"(round_tab[1]) 
  338.                  );
  340.     sad8_2_ ## suf(blk1  , blk1+1, blk2  , stride, h);
  341.     sad8_2_ ## suf(blk1+8, blk1+9, blk2+8, stride, h);
  343.     return sum_ ## suf();
  344. }
  345. static int sad16_y2_ ## suf(void *v, uint8_t *blk2, uint8_t *blk1, int stride, int h)
  346. {
  347.     asm volatile("pxor %%mm7, %%mm7 nt"
  348.                  "pxor %%mm6, %%mm6 nt"
  349.                  "movq %0, %%mm5 nt"
  350.                  :: "m"(round_tab[1]) 
  351.                  );
  353.     sad8_2_ ## suf(blk1  , blk1+stride,  blk2  , stride, h);
  354.     sad8_2_ ## suf(blk1+8, blk1+stride+8,blk2+8, stride, h);
  356.     return sum_ ## suf();
  357. }
  358. static int sad16_xy2_ ## suf(void *v, uint8_t *blk2, uint8_t *blk1, int stride, int h)
  359. {
  360.     asm volatile("pxor %%mm7, %%mm7 nt"
  361.                  "pxor %%mm6, %%mm6 nt"
  362.                  "movq %0, %%mm5 nt"
  363.                  :: "m"(round_tab[2]) 
  364.                  );
  366.     sad8_4_ ## suf(blk1  , blk2  , stride, h);
  367.     sad8_4_ ## suf(blk1+8, blk2+8, stride, h);
  369.     return sum_ ## suf();
  370. }
  372. PIX_SAD(mmx)
  373. PIX_SAD(mmx2)
  375. void dsputil_init_pix_mmx(DSPContext* c, AVCodecContext *avctx)
  376. {
  377.     if (mm_flags & MM_MMX) {
  378.         c->pix_abs[0][0] = sad16_mmx;
  379.         c->pix_abs[0][1] = sad16_x2_mmx;
  380.         c->pix_abs[0][2] = sad16_y2_mmx;
  381.         c->pix_abs[0][3] = sad16_xy2_mmx;
  382.         c->pix_abs[1][0] = sad8_mmx;
  383.         c->pix_abs[1][1] = sad8_x2_mmx;
  384.         c->pix_abs[1][2] = sad8_y2_mmx;
  385.         c->pix_abs[1][3] = sad8_xy2_mmx;
  387. c->sad[0]= sad16_mmx;
  388.         c->sad[1]= sad8_mmx;
  389.     }
  390.     if (mm_flags & MM_MMXEXT) {
  391. c->pix_abs[0][0] = sad16_mmx2;
  392. c->pix_abs[1][0] = sad8_mmx2;
  394. c->sad[0]= sad16_mmx2;
  395. c->sad[1]= sad8_mmx2;
  396.         
  397.         if(!(avctx->flags & CODEC_FLAG_BITEXACT)){
  398.             c->pix_abs[0][1] = sad16_x2_mmx2;
  399.             c->pix_abs[0][2] = sad16_y2_mmx2;
  400.             c->pix_abs[0][3] = sad16_xy2_mmx2;
  401.             c->pix_abs[1][1] = sad8_x2_mmx2;
  402.             c->pix_abs[1][2] = sad8_y2_mmx2;
  403.             c->pix_abs[1][3] = sad8_xy2_mmx2;
  404.         }
  405.     }
  406. }