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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
reconstruct.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：39k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

reconstruct.c：源码内容
  1. #include "mpeg3video.h"
  2. #include <stdio.h>
  4. #ifdef HAVE_MMX
  6. #ifdef HAVE_3Dnow
  7. static inline void recva_mmx(unsigned char *s, unsigned char *d, int lx, int lx2, int h)
  8. {
  9. __asm__(
  10. ".align 8n"
  11. "1:"
  12.     "movq (%1), %%mm0n"      /* 8 s */
  13.     "movq 8(%1), %%mm1n"      /* 8 s */
  14.     "movq (%4), %%mm2n"      /* 8 s +lx */
  15.     "movq 8(%4), %%mm3n"      /* 8 s +lx **/
  17. "pavgusb %%mm2,  %%mm0n"
  18. "addl %3, %1n"
  19. "pavgusb %%mm3,  %%mm1n"
  21.     "movq (%2), %%mm2n"      /* 8 d */
  22.     "movq 8(%2), %%mm3n"      /* 8 d */
  23. "pavgusb %%mm2,  %%mm0n"
  24. "addl %3, %4n"
  25. "pavgusb %%mm3,  %%mm1n"
  27. "movq %%mm0, (%2)n"
  28. "movq %%mm1, 8(%2)n"
  29. "addl %3, %2n"
  30. "loop 1bn"
  31.       :
  32.       : "c" (h), "r" (s), "r" (d), "r" (lx2), "r" (s +lx)
  33. );
  34. }
  36. static inline void recvac_mmx(unsigned char *s, unsigned char *d, int lx,int lx2, int h)
  37. {
  38. __asm__(
  39. ".align 8n"
  40. "1:"
  41.     "movq (%1), %%mm0n"      /* 8 s */
  42.     "movq (%4), %%mm2n"      /* 8 s +lx */
  43. "addl %3, %1n"
  44. "pavgusb %%mm2,  %%mm0n"
  45.     "movq (%2), %%mm3n"      /* 8 d */
  46. "addl %3, %4n"
  47. "pavgusb %%mm3,  %%mm0n"
  48. "movq %%mm0, (%2)n"
  49. "addl %3, %2n"
  50. "loop 1bn"
  51.       :
  52.       : "c" (h), "r" (s), "r" (d), "r" (lx2), "r" (s +lx)
  53. );
  54. }
  56. static inline void rech_mmx(unsigned char *s, unsigned char *d, int lx2, int h)
  57. {
  58. __asm__ (
  59. ".align 8n"
  60. "1:"
  61.     "movq (%1), %%mm0n"      /* 8 s */
  62.     "movq 8(%1), %%mm1n"      /* 8 s */
  63.     "movq 1(%1), %%mm2n"      /* 8 s */
  64.     "movq 9(%1), %%mm3n"      /* 8 s */
  66. "pavgusb  %%mm2,  %%mm0n"
  67. "addl %3, %1n"
  68. "pavgusb  %%mm3,  %%mm1n"
  70. "movq %%mm0, (%2)n"
  71. "movq %%mm1, 8(%2)n"
  72. "addl %3, %2n"
  73. "loop 1bn"
  74.       :
  75.       : "c" (h), "r" (s), "r" (d), "r" (lx2)
  76. );
  77. }
  79. static inline void rechc_mmx(unsigned char *s, unsigned char *d, int lx2, int h)
  80. {
  81. __asm__ (
  82. ".align 8n"
  83. "1:"
  84.     "movq (%1), %%mm0n"      /* 8 s */
  85.     "movq 1(%1), %%mm2n"      /* 8 s +1 */
  86. "addl %3, %1n"
  87. "pavgusb  %%mm2,  %%mm0n"
  88. "movq %%mm0, (%2)n"
  89. "addl %3, %2n"
  90. "loop 1bn"
  91.       :
  92.       : "c" (h), "r" (s), "r" (d), "r" (lx2)
  93. );
  94. }
  96. static inline void recha_mmx(unsigned char *s, unsigned char *d,int lx2, int h)
  97. {
  98. __asm__ (
  99. ".align 8n"
  100. "1:"
  101.     "movq (%1), %%mm0n"      /* 8 s */
  102.     "movq 8(%1), %%mm1n"      /* 8 s */
  103.     "movq 1(%1), %%mm2n"      /* 8 s */
  104.     "movq 9(%1), %%mm3n"      /* 8 s */
  106. "pavgusb  %%mm2,  %%mm0n"
  107. "addl %3, %1n"
  108. "pavgusb  %%mm3,  %%mm1n"
  110.     "movq (%2), %%mm2n"      /* 8 d */
  111.     "movq 8(%2), %%mm3n"      /* 8 d */
  112. "pavgusb  %%mm2,  %%mm0n"
  113. "pavgusb  %%mm3,  %%mm1n"
  115. "movq %%mm0, (%2)n"
  116. "movq %%mm1, 8(%2)n"
  117. "addl %3, %2n"
  118. "loop 1bn"
  119.       :
  120.       : "c" (h), "r" (s), "r" (d), "r" (lx2)
  121. );
  122. }
  124. static inline void rechac_mmx(unsigned char *s,unsigned char  *d, int lx2, int h)
  125. {
  126. __asm__ (
  127. ".align 8n"
  128. "1:"
  129.     "movq (%1), %%mm0n"      /* 8 s */
  130.     "movq 1(%1), %%mm2n"      /* 8 s */
  132. "addl %3, %1n"
  133. "pavgusb  %%mm2,  %%mm0n"
  135.     "movq (%2), %%mm1n"      /* 8 d */
  136. "pavgusb  %%mm1,  %%mm0n"
  138. "movq %%mm0, (%2)n"
  139. "addl %3, %2n"
  140. "loop 1bn"
  141.       :
  142.       : "c" (h), "r" (s), "r" (d), "r" (lx2)
  143. );
  144. }
  146. static inline void rec4_mmx(unsigned char *s, unsigned char *d, int lx, int lx2, int h)
  147. {
  148. __asm__ __volatile__(
  149.     "movq (%1), %%mm0n"  /* 8 s */
  150.     "movq 8(%1), %%mm1n"  /* 8 s */
  151.     "movq 1(%1), %%mm2n"  /* 8 s +1*/
  152.     "movq 9(%1), %%mm3n"  /* 8 s +1*/
  153. ".align 8n"
  154. "1:"
  155.     "movq (%4), %%mm4n"  /* 8 s+lx */
  156. "pavgusb  %%mm2,  %%mm0n"
  157.     "movq 8(%4), %%mm5n"  /* 8 s+lx */
  158. "pavgusb  %%mm3,  %%mm1n"
  160.     "movq 1(%4), %%mm6n"  /* 8 s+lx +1*/
  161. "pavgusb  %%mm4,  %%mm0n"
  162.     "movq 9(%4), %%mm7n"  /* 8 s+lx +1*/
  163. "pavgusb  %%mm5,  %%mm1n"
  165. "pavgusb  %%mm6,  %%mm0n"
  166. "addl %3, %4n"
  167. "pavgusb  %%mm7,  %%mm1n"
  168. "movq %%mm0, (%2)n"
  169. "movq %%mm6, %%mm2n"
  170. "movq %%mm7, %%mm3n"
  171. "movq %%mm1, 8(%2)n"
  172. "movq %%mm4, %%mm0n"
  173. "movq %%mm5, %%mm1n"
  174. "addl %3, %2n"
  175. "loop 1bn"
  176.        :
  177. : "c" (h), "r" (s), "r" (d), "r" (lx2), "r" (s +lx)
  178. );
  179. }
  181. static inline void rec4c_mmx(unsigned char *s, unsigned char *d, int lx, int lx2, int h)
  182. {
  183. __asm__ __volatile__(
  184.     "movq (%1), %%mm0n"  /* 8 s */
  185.     "movq 1(%1), %%mm2n"  /* 8 s +1*/
  186. ".align 8n"
  187. "1:"
  188.     "movq (%4), %%mm4n"  /* 8 s+lx */
  189. "pavgusb  %%mm2,  %%mm0n"
  191.     "movq 1(%4), %%mm6n"  /* 8 s+lx +1*/
  192. "pavgusb  %%mm4,  %%mm0n"
  194. "addl %3, %4n"
  195. "pavgusb  %%mm6,  %%mm0n"
  196. "movq %%mm0, (%2)n"
  197. "movq %%mm6, %%mm2n"
  198. "movq %%mm4, %%mm0n"
  199. "addl %3, %2n"
  200. "loop 1bn"
  201.        :
  202. : "c" (h), "r" (s), "r" (d), "r" (lx2), "r" (s +lx)
  203. );
  204. }
  206. static inline void rec4a_mmx(unsigned char *s, unsigned char *d, int lx, int lx2, int h)
  207. {
  208. __asm__ __volatile__(
  209.     "movq (%1), %%mm0n"  /* 8 s */
  210.     "movq 8(%1), %%mm1n"  /* 8 s */
  211.     "movq 1(%1), %%mm2n"  /* 8 s +1*/
  212.     "movq 9(%1), %%mm3n"  /* 8 s +1*/
  213. ".align 8n"
  214. "1:"
  215.     "movq (%4), %%mm4n"  /* 8 s+lx */
  216. "pavgusb  %%mm2,  %%mm0n"
  217.     "movq 8(%4), %%mm5n"  /* 8 s+lx */
  218. "pavgusb  %%mm3,  %%mm1n"
  220.     "movq 1(%4), %%mm6n"  /* 8 s+lx +1*/
  221. "pavgusb  %%mm4,  %%mm0n"
  222.     "movq 9(%4), %%mm7n"  /* 8 s+lx +1*/
  223. "pavgusb  %%mm5,  %%mm1n"
  224. "movq (%2), %%mm2n"
  225. "pavgusb  %%mm6,  %%mm0n"
  226. "movq 8(%2), %%mm3n"
  228. "pavgusb  %%mm2,  %%mm0n"
  229. "addl %3, %4n"
  230. "pavgusb  %%mm3,  %%mm1n"
  231. "movq %%mm0, (%2)n"
  233. "pavgusb  %%mm7,  %%mm1n"
  234. "movq %%mm6, %%mm2n"
  235. "movq %%mm7, %%mm3n"
  236. "movq %%mm1, 8(%2)n"
  237. "movq %%mm4, %%mm0n"
  238. "movq %%mm5, %%mm1n"
  239. "addl %3, %2n"
  240. "loop 1bn"
  241.        :
  242. : "c" (h), "r" (s), "r" (d), "r" (lx2), "r" (s +lx)
  243. );
  244. }
  246. static inline void rec4ac_mmx(unsigned char *s, unsigned char  *d, int lx, int lx2, int h)
  247. {
  248. __asm__ __volatile__(
  249.     "movq (%1), %%mm0n"  /* 8 s */
  250.     "movq 1(%1), %%mm2n"  /* 8 s +1*/
  251. ".align 8n"
  252. "1:"
  253.     "movq (%4), %%mm4n"  /* 8 s+lx */
  254. "pavgusb  %%mm2,  %%mm0n"
  256.     "movq 1(%4), %%mm6n"  /* 8 s+lx +1*/
  257. "pavgusb  %%mm4,  %%mm0n"
  258. "movq (%2), %%mm1n"  /* 8 d */
  259. "pavgusb  %%mm6,  %%mm0n"
  260. "addl %3, %4n"
  261. "pavgusb  %%mm1,  %%mm0n"
  262. "movq %%mm6, %%mm2n"
  263. "movq %%mm0, (%2)n"
  264. "movq %%mm4, %%mm0n"
  265. "addl %3, %2n"
  266. "loop 1bn"
  267.        :
  268. : "c" (h), "r" (s), "r" (d), "r" (lx2), "r" (s +lx)
  269. );
  270. }
  272. #else  // HAVE_3DNOW
  273. static long long ADD_1 = 0x0101010101010101LL;
  274. static long long MASK_AND = 0x7f7f7f7f7f7f7f7fLL;
  275. #endif
  277. static inline void rec_mmx(unsigned char *s, unsigned char *d, int lx2, int h)
  278. {
  279. __asm__ __volatile__(
  280. ".align 8n"
  281. "1:t"
  282. "movq ( %1 ),      %%mm0n" /* 8 s */
  283.     "movq 8( %1 ),     %%mm2n" /* 16 s */
  284.     "movq %%mm0,   ( %2 )n"   
  285. "addl %3, %1n"
  286.     "movq %%mm2,   8( %2 )n"   
  287. "decl %0n"
  288.     "leal (%2, %3), %2n"
  289.   "jnz    1b"            
  290. : 
  291. : "c" (h), "r" (s), "r" (d), "r" (lx2)
  292. );   
  293. }
  296. static inline void recc_mmx(unsigned char *s, unsigned char *d, int lx2, int h)
  297. {
  298. __asm__ __volatile__(
  299. ".align 8n"
  300.     "1:t"
  301.      "movq ( %1 ),     %%mm0n"
  302.        "addl %3,      %1n"
  303.        "movq %%mm0,     ( %2 )n"   
  304. "decl %0n"
  305.        "leal (%2, %3), %2n"
  306.     "jnz    1b"            
  307. : 
  308. : "c" (h), "r" (s), "r" (d), "r" (lx2)
  309. );   
  310. }
  313. static inline void reca_mmx(unsigned char *s, unsigned char  *d, int lx2, int h)
  314. {
  315. #ifdef HAVE_3Dnow
  316. __asm__ (
  317. ".align 8n"
  318. "1:"
  319.     "movq (%1), %%mm0n"      /* 8 s */
  320. "movq (%2), %%mm2n"      /* 8 d */
  321.     "movq 8(%1), %%mm1n"      /* 8 s */
  322.     "movq 8(%2), %%mm3n"      /* 8 d */
  323. "pavgusb  %%mm2,  %%mm0n"
  324. "addl %3, %1n"
  325. "pavgusb  %%mm3,  %%mm1n"
  327. "movq %%mm0, (%2)n"
  328. "movq %%mm1, 8(%2)n"
  329. "addl %3, %2n"
  330. "loop 1bn"
  331. :
  332. : "c" (h), "r" (s), "r" (d), "r" (lx2)
  333. );
  334. #else   /* No 3dnow */
  335. __asm__ (
  336.    "movq      MASK_AND,  %%mm5n"
  337.    "movq      ADD_1,  %%mm6n"
  338. "1:t"
  339.    "movq        (%1),%%mm0n"        /* Load 16 pixels from each row */
  340.    "movq        (%2),%%mm1n"
  341.    "movq       8(%1),%%mm2n"
  342.    "movq       8(%2),%%mm3n"
  343.    "psrlw $1,%%mm0n"           /* Shift pixels down */
  344.    "psrlw     $1,%%mm1n"
  345.    "pand     %%mm5,%%mm0n"        /* Zero out significant bit */
  346.    "psrlw     $1,%%mm2n"
  347.    "pand     %%mm5,%%mm1n"
  348.    "psrlw     $1,%%mm3n"
  349.    "pand     %%mm5,%%mm2n"
  350.    "paddusb    %%mm1,%%mm0n"        /* Add pixels */
  351.    "pand     %%mm5,%%mm3n"
  352.    "paddusb    %%mm3,%%mm2n"
  353.    "paddusb    %%mm6,%%mm0n"        /* Add 1 to results */
  354.    "paddusb    %%mm6,%%mm2n"
  355.    "movq       %%mm0,(%2)n"
  356.    "addl       %3,%1n"
  357.    "movq     %%mm2, 8(%2)n"
  358.    "decl       %0n"
  359.    "leal (%2, %3), %2n"
  360.    "jnz        1bn"
  361. :
  362. : "c" (h), "r" (s), "r" (d), "r" (lx2)
  363. );
  364. #endif
  365. }
  368. static inline void recac_mmx(unsigned char *s, unsigned char *d, int lx2, int h)
  369. {
  370. #ifdef HAVE_3Dnow
  371. __asm__ (
  372. ".align 8n"
  373. "1:"
  374.     "movq (%1), %%mm0n"      /* 8 s */
  375.     "movq (%2), %%mm2n"      /* 8 d */
  376. "pavgusb  %%mm2,  %%mm0n"
  377. "addl %3, %1n"
  378. "movq %%mm0, (%2)n"
  379. "addl %3, %2n"
  380. "loop 1bn"
  381. :
  382. : "c" (h), "r" (s), "r" (d), "r" (lx2)
  383. );
  384. #else /* No 3dnow */
  385. __asm__ (
  386.    "movq      MASK_AND,  %%mm5n"
  387.    "movq      ADD_1,  %%mm6n"
  388. "1:t"
  389.    "movq       (%1),%%mm0n"
  390.    "movq       (%2),%%mm1n"
  391.    "psrlw $1,%%mm0n"
  392.    "psrlw     $1,%%mm1n"
  393.    "pand     %%mm5,%%mm0n"
  394.    "pand     %%mm5,%%mm1n"
  395.    "paddusb    %%mm1,%%mm0n"
  396.    "paddusb    %%mm6,%%mm0n"
  397.    "addl       %3,%1n"
  398.    "movq       %%mm0,(%2)n"
  399.    "decl       %0n"
  400.    "leal (%2, %3), %2n"
  401.    "jnz        1bn"
  402. :
  403. : "c" (h), "r" (s), "r" (d), "r" (lx2)
  404. );
  405. #endif
  406. }
  409. static inline void recv_mmx(unsigned char *s, unsigned char *d, int lx, int lx2, int h)
  410. {
  411. #ifdef HAVE_3Dnow
  412. __asm__(
  413. ".align 8n"
  414. "1:"
  415.     "movq (%1), %%mm0n"      /* 8 s */
  416.     "movq (%4), %%mm2n"      /* 8 s +lx */
  417.     "movq 8(%1), %%mm1n"      /* 8 s */
  418.     "movq 8(%4), %%mm3n"      /* 8 s +lx **/
  420. "pavgusb %%mm2,  %%mm0n"
  421. "addl %3, %1n"
  422. "pavgusb %%mm3,  %%mm1n"
  424. "movq %%mm0, (%2)n"
  425. "addl %3, %4n"
  426. "movq %%mm1, 8(%2)n"
  427. "addl %3, %2n"
  428. "loop 1bn"
  429.       :
  430.       : "c" (h), "r" (s), "r" (d), "r" (lx2), "r" (s +lx)
  431. );
  432. #else
  433. __asm__ (
  434.    "movq      MASK_AND,  %%mm5n"
  435.    "movq      ADD_1,  %%mm6n"
  436. "1:t"
  437.     "movq (%1), %%mm0n"      /* 8 s */
  438.     "movq (%4), %%mm1n"      /* 8 s +lx */
  439.     "movq 8(%1), %%mm2n"      /* 8 s */
  440.     "movq 8(%4), %%mm3n"      /* 8 s +lx **/
  441.    "psrlw      $1,%%mm0n"
  442.    "psrlw      $1,%%mm1n"
  443.    "pand       %%mm5,%%mm0n"
  444.    "psrlw      $1,%%mm2n"
  445.    "pand       %%mm5,%%mm1n"
  446.    "psrlw      $1,%%mm3n"
  447.    "pand       %%mm5,%%mm2n"
  448.    "paddusb    %%mm1,%%mm0n"
  449.    "pand       %%mm5,%%mm3n"
  450.    "paddusb    %%mm3,%%mm2n"
  451.    "paddusb    %%mm6,%%mm0n"
  452.    "paddusb    %%mm6,%%mm2n"
  453.    "movq       %%mm0,(%2)n"
  454.    "addl       %3,%1n"
  455.    "movq     %%mm2, 8(%2)n"
  456.    "addl       %3,%4n"
  457.    "decl       %0n"
  458.    "leal (%2, %3), %2n"
  459.    "jnz        1bn"
  460.       :
  461.       : "c" (h), "r" (s), "r" (d), "r" (lx2), "r" (s +lx)
  462. );
  463. #endif
  464. }
  467. static inline void recvc_mmx(unsigned char *s, unsigned char *d, int lx, int lx2, int h)
  468. {
  469. #ifdef HAVE_3Dnow
  470. __asm__(
  471. ".align 8n"
  472. "1:"
  473.     "movq (%1), %%mm0n"      /* 8 s */
  474.     "movq (%4), %%mm2n"      /* 8 s +lx */
  475. "addl %3, %1n"
  476. "pavgusb %%mm2,  %%mm0n"
  477. "addl %3, %4n"
  478. "movq %%mm0, (%2)n"
  479. "addl %3, %2n"
  480. "loop 1bn"
  481.       :
  482.       : "c" (h), "r" (s), "r" (d), "r" (lx2), "r" (s +lx)
  483. );
  484. #else
  485. __asm__ (
  486.    "movq      MASK_AND,  %%mm5n"
  487.    "movq      ADD_1,  %%mm6n"
  488. "1:t"
  489.     "movq (%1), %%mm0n"      /* 8 s */
  490.     "movq (%4), %%mm1n"      /* 8 s +lx */
  491.    "psrlw      $1,%%mm0n"
  492.    "psrlw      $1,%%mm1n"
  493.    "pand       %%mm5,%%mm0n"
  494.    "pand       %%mm5,%%mm1n"
  495.    "paddusb    %%mm1,%%mm0n"
  496.    "addl       %3,%1n"
  497.    "paddusb    %%mm6,%%mm0n"
  498.    "addl       %3,%4n"
  499.    "movq       %%mm0,(%2)n"
  500.    "decl       %0n"
  501.    "leal (%2, %3), %2n"
  502.    "jnz        1bn"
  503.       :
  504.       : "c" (h), "r" (s), "r" (d), "r" (lx2), "r" (s +lx)
  505. );
  506. #endif
  507. }
  509. #endif  // HAVE_MMX
  511. static __inline void rec(unsigned char *s, unsigned char *d, int lx2, int h)
  512. {
  513. int j;
  514. for(j = 0; j < h; j++, s += lx2, d += lx2)
  515. {
  516.      d[0] = s[0]; d[1] = s[1]; d[2] = s[2]; d[3] = s[3];
  517.      d[4] = s[4]; d[5] = s[5]; d[6] = s[6]; d[7] = s[7];
  518.      d[8] = s[8]; d[9] = s[9]; d[10] = s[10]; d[11] = s[11];
  519.      d[12] = s[12]; d[13] = s[13]; d[14] = s[14]; d[15] = s[15];
  520. }
  521. }
  525. static __inline void recc(unsigned char *s, unsigned char *d, int lx2, int h)
  526. {
  527. int j;
  528. for(j = 0; j < h; j++, s += lx2, d += lx2)
  529. {
  530.      d[0] = s[0]; d[1] = s[1]; d[2] = s[2]; d[3] = s[3];
  531.      d[4] = s[4]; d[5] = s[5]; d[6] = s[6]; d[7] = s[7];
  532. }
  533. }
  535. static __inline void reca(unsigned char *s, unsigned char  *d, int lx2, int h)
  536. {
  537. int j;
  538. for(j = 0; j < h; j++, s +=lx2, d +=lx2)
  539. {
  540.      d[0] = (unsigned int)(d[0] + s[0] + 1) >> 1;
  541.      d[1] = (unsigned int)(d[1] + s[1] + 1) >> 1;
  542.      d[2] = (unsigned int)(d[2] + s[2] + 1) >> 1;
  543.      d[3] = (unsigned int)(d[3] + s[3] + 1) >> 1;
  544.      d[4] = (unsigned int)(d[4] + s[4] + 1) >> 1;
  545.      d[5] = (unsigned int)(d[5] + s[5] + 1) >> 1;
  546.      d[6] = (unsigned int)(d[6] + s[6] + 1) >> 1;
  547.      d[7] = (unsigned int)(d[7] + s[7] + 1) >> 1;
  548.      d[8] = (unsigned int)(d[8] + s[8] + 1) >> 1;
  549.      d[9] = (unsigned int)(d[9] + s[9] + 1) >> 1;
  550.      d[10] = (unsigned int)(d[10] + s[10] + 1) >> 1;
  551.      d[11] = (unsigned int)(d[11] + s[11] + 1) >> 1;
  552.      d[12] = (unsigned int)(d[12] + s[12] + 1) >> 1;
  553.      d[13] = (unsigned int)(d[13] + s[13] + 1) >> 1;
  554.      d[14] = (unsigned int)(d[14] + s[14] + 1) >> 1;
  555.      d[15] = (unsigned int)(d[15] + s[15] + 1) >> 1;
  556. }
  557. }
  559. static __inline void recac(unsigned char *s, unsigned char *d, int lx2, int h)
  560. {
  561. int j;
  562. for(j = 0; j < h; j++, s += lx2, d += lx2)
  563. {
  564.      d[0] = (unsigned int)(d[0] + s[0] + 1)>>1;
  565.      d[1] = (unsigned int)(d[1] + s[1] + 1)>>1;
  566.      d[2] = (unsigned int)(d[2] + s[2] + 1)>>1;
  567.      d[3] = (unsigned int)(d[3] + s[3] + 1)>>1;
  568.      d[4] = (unsigned int)(d[4] + s[4] + 1)>>1;
  569.      d[5] = (unsigned int)(d[5] + s[5] + 1)>>1;
  570.      d[6] = (unsigned int)(d[6] + s[6] + 1)>>1;
  571.      d[7] = (unsigned int)(d[7] + s[7] + 1)>>1;
  572. }
  573. }
  575. static __inline void reconstruct_recv(unsigned char *s, unsigned char *d, int lx, int lx2, int h)
  576. {
  577. unsigned char *dp,*sp,*sp2;
  578. int j;
  579. sp = s;
  580. sp2 = s + lx;
  581. dp = d;
  582. for(j = 0; j < h; j++)
  583. {
  584.      dp[0] = (unsigned int)(sp[0] + sp2[0] + 1) >> 1;
  585.      dp[1] = (unsigned int)(sp[1] + sp2[1] + 1) >> 1;
  586.      dp[2] = (unsigned int)(sp[2] + sp2[2] + 1) >> 1;
  587.      dp[3] = (unsigned int)(sp[3] + sp2[3] + 1) >> 1;
  588.      dp[4] = (unsigned int)(sp[4] + sp2[4] + 1) >> 1;
  589.      dp[5] = (unsigned int)(sp[5] + sp2[5] + 1) >> 1;
  590.      dp[6] = (unsigned int)(sp[6] + sp2[6] + 1) >> 1;
  591.      dp[7] = (unsigned int)(sp[7] + sp2[7] + 1) >> 1;
  592.      dp[8] = (unsigned int)(sp[8] + sp2[8] + 1) >> 1;
  593.      dp[9] = (unsigned int)(sp[9] + sp2[9] + 1) >> 1;
  594.      dp[10] = (unsigned int)(sp[10] + sp2[10] + 1) >> 1;
  595.      dp[11] = (unsigned int)(sp[11] + sp2[11] + 1) >> 1;
  596.      dp[12] = (unsigned int)(sp[12] + sp2[12] + 1) >> 1;
  597.      dp[13] = (unsigned int)(sp[13] + sp2[13] + 1) >> 1;
  598.      dp[14] = (unsigned int)(sp[14] + sp2[14] + 1) >> 1;
  599.      dp[15] = (unsigned int)(sp[15] + sp2[15] + 1) >> 1;
  600.      sp+= lx2;
  601.      sp2+= lx2;
  602.      dp+= lx2;
  603. }
  604. }
  606. static __inline void recvc(unsigned char *s, unsigned char *d, int lx, int lx2, int h)
  607. {
  608. unsigned char *dp,*sp,*sp2;
  609. int j;
  611. sp = s;
  612. sp2 = s+lx;
  613. dp = d;
  614. for(j = 0; j < h; j++)
  615. {
  616.      dp[0] = (unsigned int)(sp[0]+sp2[0]+1)>>1;
  617.      dp[1] = (unsigned int)(sp[1]+sp2[1]+1)>>1;
  618.      dp[2] = (unsigned int)(sp[2]+sp2[2]+1)>>1;
  619.      dp[3] = (unsigned int)(sp[3]+sp2[3]+1)>>1;
  620.      dp[4] = (unsigned int)(sp[4]+sp2[4]+1)>>1;
  621.      dp[5] = (unsigned int)(sp[5]+sp2[5]+1)>>1;
  622.      dp[6] = (unsigned int)(sp[6]+sp2[6]+1)>>1;
  623.      dp[7] = (unsigned int)(sp[7]+sp2[7]+1)>>1;
  624.      sp+= lx2;
  625.      sp2+= lx2;
  626.      dp+= lx2;
  627. }
  628. }
  631. static __inline void recva(unsigned char *s, unsigned char *d, int lx, int lx2, int h)
  632. {
  633. unsigned char *dp,*sp,*sp2;
  634. int j;
  636. sp = s;
  637. sp2 = s+lx;
  638. dp = d;
  639. for (j=0; j<h; j++){
  640.      dp[0] = (dp[0] + ((unsigned int)(sp[0]+sp2[0]+1)>>1) + 1)>>1;
  641.      dp[1] = (dp[1] + ((unsigned int)(sp[1]+sp2[1]+1)>>1) + 1)>>1;
  642.      dp[2] = (dp[2] + ((unsigned int)(sp[2]+sp2[2]+1)>>1) + 1)>>1;
  643.      dp[3] = (dp[3] + ((unsigned int)(sp[3]+sp2[3]+1)>>1) + 1)>>1;
  644.      dp[4] = (dp[4] + ((unsigned int)(sp[4]+sp2[4]+1)>>1) + 1)>>1;
  645.      dp[5] = (dp[5] + ((unsigned int)(sp[5]+sp2[5]+1)>>1) + 1)>>1;
  646.      dp[6] = (dp[6] + ((unsigned int)(sp[6]+sp2[6]+1)>>1) + 1)>>1;
  647.      dp[7] = (dp[7] + ((unsigned int)(sp[7]+sp2[7]+1)>>1) + 1)>>1;
  648.      dp[8] = (dp[8] + ((unsigned int)(sp[8]+sp2[8]+1)>>1) + 1)>>1;
  649.      dp[9] = (dp[9] + ((unsigned int)(sp[9]+sp2[9]+1)>>1) + 1)>>1;
  650.      dp[10] = (dp[10] + ((unsigned int)(sp[10]+sp2[10]+1)>>1) + 1)>>1;
  651.      dp[11] = (dp[11] + ((unsigned int)(sp[11]+sp2[11]+1)>>1) + 1)>>1;
  652.      dp[12] = (dp[12] + ((unsigned int)(sp[12]+sp2[12]+1)>>1) + 1)>>1;
  653.      dp[13] = (dp[13] + ((unsigned int)(sp[13]+sp2[13]+1)>>1) + 1)>>1;
  654.      dp[14] = (dp[14] + ((unsigned int)(sp[14]+sp2[14]+1)>>1) + 1)>>1;
  655.      dp[15] = (dp[15] + ((unsigned int)(sp[15]+sp2[15]+1)>>1) + 1)>>1;
  656.      sp+= lx2;
  657.      sp2+= lx2;
  658.      dp+= lx2;
  659. }
  660. }
  663. static __inline void recvac(unsigned char *s, unsigned char *d, int lx,int lx2, int h){
  664.   unsigned char *dp,*sp,*sp2;
  665. int j;
  667.   sp = s;
  668.   sp2 = s+lx;
  669.   dp = d;
  670.   for (j=0; j<h; j++){
  671.     dp[0] = (dp[0] + ((unsigned int)(sp[0]+sp2[0]+1)>>1) + 1)>>1;
  672.     dp[1] = (dp[1] + ((unsigned int)(sp[1]+sp2[1]+1)>>1) + 1)>>1;
  673.     dp[2] = (dp[2] + ((unsigned int)(sp[2]+sp2[2]+1)>>1) + 1)>>1;
  674.     dp[3] = (dp[3] + ((unsigned int)(sp[3]+sp2[3]+1)>>1) + 1)>>1;
  675.     dp[4] = (dp[4] + ((unsigned int)(sp[4]+sp2[4]+1)>>1) + 1)>>1;
  676.     dp[5] = (dp[5] + ((unsigned int)(sp[5]+sp2[5]+1)>>1) + 1)>>1;
  677.     dp[6] = (dp[6] + ((unsigned int)(sp[6]+sp2[6]+1)>>1) + 1)>>1;
  678.     dp[7] = (dp[7] + ((unsigned int)(sp[7]+sp2[7]+1)>>1) + 1)>>1;
  679.     sp+= lx2;
  680.     sp2+= lx2;
  681.     dp+= lx2;
  682.   }
  683. }
  686. static __inline void rech(unsigned char *s, unsigned char *d, int lx2, int h){
  687.   unsigned char *dp,*sp;
  688.   unsigned int s1,s2;
  689. int j;
  691.   sp = s;
  692.   dp = d;
  693.   for (j=0; j<h; j++){
  694.     s1=sp[0];
  695.     dp[0] = (unsigned int)(s1+(s2=sp[1])+1)>>1;
  696.     dp[1] = (unsigned int)(s2+(s1=sp[2])+1)>>1;
  697.     dp[2] = (unsigned int)(s1+(s2=sp[3])+1)>>1;
  698.     dp[3] = (unsigned int)(s2+(s1=sp[4])+1)>>1;
  699.     dp[4] = (unsigned int)(s1+(s2=sp[5])+1)>>1;
  700.     dp[5] = (unsigned int)(s2+(s1=sp[6])+1)>>1;
  701.     dp[6] = (unsigned int)(s1+(s2=sp[7])+1)>>1;
  702.     dp[7] = (unsigned int)(s2+(s1=sp[8])+1)>>1;
  703.     dp[8] = (unsigned int)(s1+(s2=sp[9])+1)>>1;
  704.     dp[9] = (unsigned int)(s2+(s1=sp[10])+1)>>1;
  705.     dp[10] = (unsigned int)(s1+(s2=sp[11])+1)>>1;
  706.     dp[11] = (unsigned int)(s2+(s1=sp[12])+1)>>1;
  707.     dp[12] = (unsigned int)(s1+(s2=sp[13])+1)>>1;
  708.     dp[13] = (unsigned int)(s2+(s1=sp[14])+1)>>1;
  709.     dp[14] = (unsigned int)(s1+(s2=sp[15])+1)>>1;
  710.     dp[15] = (unsigned int)(s2+sp[16]+1)>>1;
  711.     sp+= lx2;
  712.     dp+= lx2;
  713.   }
  714. }
  717. static __inline void rechc(unsigned char *s,unsigned char *d, int lx2, int h){
  718.   unsigned char *dp,*sp;
  719.   unsigned int s1,s2;
  720. int j;
  722.   sp = s;
  723.   dp = d;
  724.   for (j=0; j<h; j++){
  725.     s1=sp[0];
  726.     dp[0] = (unsigned int)(s1+(s2=sp[1])+1)>>1;
  727.     dp[1] = (unsigned int)(s2+(s1=sp[2])+1)>>1;
  728.     dp[2] = (unsigned int)(s1+(s2=sp[3])+1)>>1;
  729.     dp[3] = (unsigned int)(s2+(s1=sp[4])+1)>>1;
  730.     dp[4] = (unsigned int)(s1+(s2=sp[5])+1)>>1;
  731.     dp[5] = (unsigned int)(s2+(s1=sp[6])+1)>>1;
  732.     dp[6] = (unsigned int)(s1+(s2=sp[7])+1)>>1;
  733.     dp[7] = (unsigned int)(s2+sp[8]+1)>>1;
  734.     sp+= lx2;
  735.     dp+= lx2;
  736.   }
  737. }
  739. static __inline void recha(unsigned char *s, unsigned char *d,int lx2, int h)
  740. {
  741. unsigned char *dp,*sp;
  742. unsigned int s1,s2;
  743. int j;
  745. sp = s;
  746. dp = d;
  747. for (j = 0; j < h; j++)
  748. {
  749.      s1 = sp[0];
  750.      dp[0] = (dp[0] + ((unsigned int)(s1 + (s2 = sp[1]) + 1) >> 1) + 1) >> 1;
  751.      dp[1] = (dp[1] + ((unsigned int)(s2 + (s1 = sp[2]) + 1) >> 1) + 1) >> 1;
  752.      dp[2] = (dp[2] + ((unsigned int)(s1 + (s2 = sp[3]) + 1) >> 1) + 1) >> 1;
  753.      dp[3] = (dp[3] + ((unsigned int)(s2 + (s1 = sp[4]) + 1) >> 1) + 1) >> 1;
  754.      dp[4] = (dp[4] + ((unsigned int)(s1 + (s2 = sp[5]) + 1) >> 1) + 1) >> 1;
  755.      dp[5] = (dp[5] + ((unsigned int)(s2 + (s1 = sp[6]) + 1) >> 1) + 1) >> 1;
  756.      dp[6] = (dp[6] + ((unsigned int)(s1 + (s2 = sp[7]) + 1) >> 1) + 1) >> 1;
  757.      dp[7] = (dp[7] + ((unsigned int)(s2 + (s1 = sp[8]) + 1) >> 1) + 1) >> 1;
  758.      dp[8] = (dp[8] + ((unsigned int)(s1 + (s2 = sp[9]) + 1) >> 1) + 1) >> 1;
  759.      dp[9] = (dp[9] + ((unsigned int)(s2 + (s1 = sp[10]) + 1) >> 1) + 1) >> 1;
  760.      dp[10] = (dp[10] + ((unsigned int)(s1 + (s2 = sp[11]) + 1) >> 1) + 1) >> 1;
  761.      dp[11] = (dp[11] + ((unsigned int)(s2 + (s1 = sp[12]) + 1) >> 1) + 1) >> 1;
  762.      dp[12] = (dp[12] + ((unsigned int)(s1 + (s2 = sp[13]) + 1) >> 1) + 1) >> 1;
  763.      dp[13] = (dp[13] + ((unsigned int)(s2 + (s1 = sp[14]) + 1) >> 1) + 1) >> 1;
  764.      dp[14] = (dp[14] + ((unsigned int)(s1 + (s2 = sp[15]) + 1) >> 1) + 1) >> 1;
  765.      dp[15] = (dp[15] + ((unsigned int)(s2 + sp[16] + 1) >> 1) + 1) >> 1;
  766.      sp += lx2;
  767.      dp += lx2;
  768. }
  769. }
  772. static __inline void rechac(unsigned char *s,unsigned char  *d, int lx2, int h)
  773. {
  774. unsigned char *dp,*sp;
  775. unsigned int s1,s2;
  776. int j;
  778. sp = s;
  779. dp = d;
  780. for(j = 0; j < h; j++)
  781. {
  782.      s1 = sp[0];
  783.      dp[0] = (dp[0] + ((unsigned int)(s1 + (s2 = sp[1]) + 1) >> 1) + 1) >> 1;
  784.      dp[1] = (dp[1] + ((unsigned int)(s2 + (s1 = sp[2]) + 1) >> 1) + 1) >> 1;
  785.      dp[2] = (dp[2] + ((unsigned int)(s1 + (s2 = sp[3]) + 1) >> 1) + 1) >> 1;
  786.      dp[3] = (dp[3] + ((unsigned int)(s2 + (s1 = sp[4]) + 1) >> 1) + 1) >> 1;
  787.      dp[4] = (dp[4] + ((unsigned int)(s1 + (s2 = sp[5]) + 1) >> 1) + 1) >> 1;
  788.      dp[5] = (dp[5] + ((unsigned int)(s2 + (s1 = sp[6]) + 1) >> 1) + 1) >> 1;
  789.      dp[6] = (dp[6] + ((unsigned int)(s1 + (s2 = sp[7]) + 1) >> 1) + 1) >> 1;
  790.      dp[7] = (dp[7] + ((unsigned int)(s2 + sp[8] + 1) >> 1) + 1) >> 1;
  791.      sp += lx2;
  792.      dp += lx2;
  793. }
  794. }
  797. static __inline void rec4(unsigned char *s, unsigned char *d, int lx, int lx2, int h)
  798. {
  799.   unsigned char *dp,*sp,*sp2;
  800.   unsigned int s1,s2,s3,s4;
  801. int j;
  803.   sp = s;
  804.   sp2 = s+lx;
  805.   dp = d;
  806.   for (j=0; j<h; j++){
  807.     s1=sp[0]; s3=sp2[0];
  808.     dp[0] = (unsigned int)(s1+(s2=sp[1])+s3+(s4=sp2[1])+2)>>2;
  809.     dp[1] = (unsigned int)(s2+(s1=sp[2])+s4+(s3=sp2[2])+2)>>2;
  810.     dp[2] = (unsigned int)(s1+(s2=sp[3])+s3+(s4=sp2[3])+2)>>2;
  811.     dp[3] = (unsigned int)(s2+(s1=sp[4])+s4+(s3=sp2[4])+2)>>2;
  812.     dp[4] = (unsigned int)(s1+(s2=sp[5])+s3+(s4=sp2[5])+2)>>2;
  813.     dp[5] = (unsigned int)(s2+(s1=sp[6])+s4+(s3=sp2[6])+2)>>2;
  814.     dp[6] = (unsigned int)(s1+(s2=sp[7])+s3+(s4=sp2[7])+2)>>2;
  815.     dp[7] = (unsigned int)(s2+(s1=sp[8])+s4+(s3=sp2[8])+2)>>2;
  816.     dp[8] = (unsigned int)(s1+(s2=sp[9])+s3+(s4=sp2[9])+2)>>2;
  817.     dp[9] = (unsigned int)(s2+(s1=sp[10])+s4+(s3=sp2[10])+2)>>2;
  818.     dp[10] = (unsigned int)(s1+(s2=sp[11])+s3+(s4=sp2[11])+2)>>2;
  819.     dp[11] = (unsigned int)(s2+(s1=sp[12])+s4+(s3=sp2[12])+2)>>2;
  820.     dp[12] = (unsigned int)(s1+(s2=sp[13])+s3+(s4=sp2[13])+2)>>2;
  821.     dp[13] = (unsigned int)(s2+(s1=sp[14])+s4+(s3=sp2[14])+2)>>2;
  822.     dp[14] = (unsigned int)(s1+(s2=sp[15])+s3+(s4=sp2[15])+2)>>2;
  823.     dp[15] = (unsigned int)(s2+sp[16]+s4+sp2[16]+2)>>2;
  824.     sp+= lx2;
  825.     sp2+= lx2;
  826.     dp+= lx2;
  827.   }
  828. }
  831. static __inline void rec4c(unsigned char *s,unsigned char *d, int lx, int lx2, int h)
  832. {
  833.   unsigned char *dp,*sp,*sp2;
  834.   unsigned int s1,s2,s3,s4;
  835. int j;
  837.   sp = s;
  838.   sp2 = s+lx;
  839.   dp = d;
  840.   for (j=0; j<h; j++){
  841.     s1=sp[0]; s3=sp2[0];
  842.     dp[0] = (unsigned int)(s1+(s2=sp[1])+s3+(s4=sp2[1])+2)>>2;
  843.     dp[1] = (unsigned int)(s2+(s1=sp[2])+s4+(s3=sp2[2])+2)>>2;
  844.     dp[2] = (unsigned int)(s1+(s2=sp[3])+s3+(s4=sp2[3])+2)>>2;
  845.     dp[3] = (unsigned int)(s2+(s1=sp[4])+s4+(s3=sp2[4])+2)>>2;
  846.     dp[4] = (unsigned int)(s1+(s2=sp[5])+s3+(s4=sp2[5])+2)>>2;
  847.     dp[5] = (unsigned int)(s2+(s1=sp[6])+s4+(s3=sp2[6])+2)>>2;
  848.     dp[6] = (unsigned int)(s1+(s2=sp[7])+s3+(s4=sp2[7])+2)>>2;
  849.     dp[7] = (unsigned int)(s2+sp[8]+s4+sp2[8]+2)>>2;
  850.     sp+= lx2;
  851.     sp2+= lx2;
  852.     dp+= lx2;
  853.   }
  854. }
  857. static __inline void rec4a(unsigned char *s,unsigned char *d, int lx, int lx2, int h)
  858. {
  859.   unsigned char *dp=d, *sp=s, *sp2=s+lx;
  860.   unsigned int s1, s2, s3, s4;
  861. int j;
  863. /*
  864.   sp = s;
  865.   sp2 = s+lx;
  866.   dp = d;
  867. */
  868.   for (j=0; j<h; j++){
  869.     s1=sp[0]; s3=sp2[0];
  870.     dp[0] = (dp[0] + ((unsigned int)(s1+(s2=sp[1])+s3+(s4=sp2[1])+2)>>2) + 1)>>1;
  871.     dp[1] = (dp[1] + ((unsigned int)(s2+(s1=sp[2])+s4+(s3=sp2[2])+2)>>2) + 1)>>1;
  872.     dp[2] = (dp[2] + ((unsigned int)(s1+(s2=sp[3])+s3+(s4=sp2[3])+2)>>2) + 1)>>1;
  873.     dp[3] = (dp[3] + ((unsigned int)(s2+(s1=sp[4])+s4+(s3=sp2[4])+2)>>2) + 1)>>1;
  874.     dp[4] = (dp[4] + ((unsigned int)(s1+(s2=sp[5])+s3+(s4=sp2[5])+2)>>2) + 1)>>1;
  875.     dp[5] = (dp[5] + ((unsigned int)(s2+(s1=sp[6])+s4+(s3=sp2[6])+2)>>2) + 1)>>1;
  876.     dp[6] = (dp[6] + ((unsigned int)(s1+(s2=sp[7])+s3+(s4=sp2[7])+2)>>2) + 1)>>1;
  877.     dp[7] = (dp[7] + ((unsigned int)(s2+(s1=sp[8])+s4+(s3=sp2[8])+2)>>2) + 1)>>1;
  878.     dp[8] = (dp[8] + ((unsigned int)(s1+(s2=sp[9])+s3+(s4=sp2[9])+2)>>2) + 1)>>1;
  879.     dp[9] = (dp[9] + ((unsigned int)(s2+(s1=sp[10])+s4+(s3=sp2[10])+2)>>2) + 1)>>1;
  880.     dp[10] = (dp[10] + ((unsigned int)(s1+(s2=sp[11])+s3+(s4=sp2[11])+2)>>2) + 1)>>1;
  881.     dp[11] = (dp[11] + ((unsigned int)(s2+(s1=sp[12])+s4+(s3=sp2[12])+2)>>2) + 1)>>1;
  882.     dp[12] = (dp[12] + ((unsigned int)(s1+(s2=sp[13])+s3+(s4=sp2[13])+2)>>2) + 1)>>1;
  883.     dp[13] = (dp[13] + ((unsigned int)(s2+(s1=sp[14])+s4+(s3=sp2[14])+2)>>2) + 1)>>1;
  884.     dp[14] = (dp[14] + ((unsigned int)(s1+(s2=sp[15])+s3+(s4=sp2[15])+2)>>2) + 1)>>1;
  885.     dp[15] = (dp[15] + ((unsigned int)(s2+sp[16]+s4+sp2[16]+2)>>2) + 1)>>1;
  886.     sp+= lx2;
  887.     sp2+= lx2;
  888.     dp+= lx2;
  889.   }
  890. }
  893. static __inline void rec4ac(unsigned char *s,unsigned char  *d, int lx, int lx2, int h)
  894. {
  895.   unsigned char *dp=d, *sp=s, *sp2=s+lx;
  896.   unsigned int s1,s2,s3,s4;
  897. int j;
  899. /*
  900.   sp = s;
  901.   sp2 = s+lx;
  902.   dp = d;
  903. */
  904. for (j=0; j<h; j++)
  905. {
  906.      s1=sp[0]; s3=sp2[0];
  907.      dp[0] = (dp[0] + ((unsigned int)(s1+(s2=sp[1])+s3+(s4=sp2[1])+2)>>2) + 1)>>1;
  908.      dp[1] = (dp[1] + ((unsigned int)(s2+(s1=sp[2])+s4+(s3=sp2[2])+2)>>2) + 1)>>1;
  909.      dp[2] = (dp[2] + ((unsigned int)(s1+(s2=sp[3])+s3+(s4=sp2[3])+2)>>2) + 1)>>1;
  910.      dp[3] = (dp[3] + ((unsigned int)(s2+(s1=sp[4])+s4+(s3=sp2[4])+2)>>2) + 1)>>1;
  911.      dp[4] = (dp[4] + ((unsigned int)(s1+(s2=sp[5])+s3+(s4=sp2[5])+2)>>2) + 1)>>1;
  912.      dp[5] = (dp[5] + ((unsigned int)(s2+(s1=sp[6])+s4+(s3=sp2[6])+2)>>2) + 1)>>1;
  913.      dp[6] = (dp[6] + ((unsigned int)(s1+(s2=sp[7])+s3+(s4=sp2[7])+2)>>2) + 1)>>1;
  914.      dp[7] = (dp[7] + ((unsigned int)(s2+sp[8]+s4+sp2[8]+2)>>2) + 1)>>1;
  915.      sp+= lx2;
  916.      sp2+= lx2;
  917.      dp+= lx2;
  918. }
  919. }
  921. static __inline
  922. void recon_comp(mpeg3video_t *video, 
  923. unsigned char *src, 
  924. unsigned char *dst, 
  925. int lx, 
  926. int lx2,
  927. int w, 
  928. int h, 
  929. int x, 
  930. int y, 
  931. int dx, 
  932. int dy, 
  933. int addflag)
  934. {
  935. int switcher;
  936. unsigned char *s, *d;
  938. /* half pel scaling */
  939. switcher = (dx & 1) << 3 | (dy & 1) << 2 | w;
  940. if(addflag) switcher |= 2; 
  941. /* origins */
  942. s = src + lx * (y + (dy >> 1)) + x + (dx >> 1);
  943. d = dst + lx * y + x;
  945. // Accelerated functions
  946. #ifdef HAVE_MMX
  947. if(video->have_mmx)
  948. {
  949. switch(switcher)
  950. {
  951. case 0x3:  reca_mmx(s, d, lx2, h);       break;
  952. case 0x2: recac_mmx(s, d, lx2, h);      break;
  953. case 0x1: rec_mmx(s, d, lx2, h);        break;
  954. case 0x0: recc_mmx(s, d, lx2, h);       break;
  955. case 0x7:   recva_mmx(s, d, lx, lx2, h);  break;
  956. case 0x6:   recvac_mmx(s, d, lx, lx2, h); break;
  957. case 0x5: recv_mmx(s, d, lx, lx2, h);   break;
  958. case 0x4: recvc_mmx(s, d, lx, lx2, h);  break;
  959. case 0x9: rech_mmx(s, d, lx2, h);       break;
  960. case 0x8:   rechc_mmx(s, d, lx2, h);      break;
  961. }
  962. }
  963. else
  964. #endif
  965. {
  966. switch(switcher)
  967. {
  968. case 0x3:  reca(s, d, lx2, h);       break;
  969. case 0x2: recac(s, d, lx2, h);      break;
  970. case 0x1: rec(s, d, lx2, h);        break;
  971. case 0x0: recc(s, d, lx2, h);       break;
  972. case 0x7:   recva(s, d, lx, lx2, h);  break;
  973. case 0x6:   recvac(s, d, lx, lx2, h); break;
  974. case 0x5: reconstruct_recv(s, d, lx, lx2, h);   break;
  975. case 0x4: recvc(s, d, lx, lx2, h);  break;
  976. case 0x9: rech(s, d, lx2, h);       break;
  977. case 0x8:   rechc(s, d, lx2, h);      break;
  978. }
  979. }
  981. // Unaccelerated functions
  982. switch(switcher) 
  983. {
  984. case 0xb:  recha(s, d, lx2, h);      break;
  985. case 0xa: rechac(s, d, lx2, h);     break;
  986. case 0xf:  rec4a(s, d, lx, lx2, h);  break;
  987. case 0xe: rec4ac(s, d, lx, lx2, h); break;
  988. case 0xd: rec4(s, d, lx, lx2, h);   break;
  989. case 0xc: rec4c(s, d, lx, lx2, h);  break;
  990.  }
  991. }
  993. /*
  994. unsigned char *src[]; * prediction source buffer *
  995. int sfield;           * prediction source field number (0 or 1) *
  996. unsigned char *dst[]; * prediction destination buffer *
  997. int dfield;           * prediction destination field number (0 or 1)*
  998. int lx,lx2;           * horizontal offsets *
  999. int w,h;              * prediction block/sub-block width, height *
  1000. int x,y;              * pixel co-ordinates of top-left sample in current MB *
  1001. int dx,dy;            * horizontal, vertical motion vector *
  1002. int addflag;          * add prediction error to prediction ? *
  1003. */
  1004. static void recon(mpeg3video_t *video, 
  1005. unsigned char *src[], 
  1006. int sfield, 
  1007.     unsigned char *dst[], 
  1008. int dfield, 
  1009. int lx,
  1010. int lx2,
  1011.     int w, 
  1012. int h, 
  1013. int x, 
  1014. int y, 
  1015. int dx, 
  1016. int dy, 
  1017. int addflag)
  1018. {
  1020. /* Y */
  1021. recon_comp(video, (src[0] + (sfield ? (lx2 >> 1) : 0)), 
  1022.        dst[0] + (dfield ? (lx2 >> 1) : 0),
  1023.            lx, lx2, w, h, x, y, dx, dy, addflag);
  1025. if(video->chroma_format != CHROMA444)
  1026. {
  1027.        lx >>= 1; 
  1028. dx /= 2; 
  1029. lx2 >>= 1; 
  1030. w = 0; 
  1031. x >>= 1; 
  1032. }
  1034. if(video->chroma_format == CHROMA420)
  1035. {
  1036.        h >>= 1; 
  1037. dy /= 2; 
  1038. y >>= 1; 
  1039. }
  1041. /* Cb */
  1042. recon_comp(video, (src[1] + (sfield ? (lx2 >> 1) : 0)), 
  1043.        dst[1] + (dfield ? (lx2 >> 1) : 0),
  1044.        lx, lx2, w, h, x, y, dx, dy, addflag);
  1046. /* Cr */
  1047. recon_comp(video, (src[2] + (sfield ? (lx2 >> 1) : 0)),
  1048.        dst[2] + (dfield ? (lx2 >> 1) : 0),
  1049.            lx, lx2, w, h, x, y, dx, dy, addflag);
  1050. }
  1052. #define WIDTH 1
  1054. int mpeg3video_reconstruct(mpeg3video_t *video, 
  1055. int bx, 
  1056. int by, 
  1057. int mb_type, 
  1058. int motion_type,
  1059. int PMV[2][2][2], 
  1060. int mv_field_sel[2][2], 
  1061. int dmvector[2], 
  1062. int stwtype)
  1063. {
  1064. int currentfield;
  1065. unsigned char **predframe;
  1066. int DMV[2][2];
  1067. int stwtop, stwbot;
  1069. stwtop = stwtype % 3; /* 0:temporal, 1 : (spat+temp) / 2, 2 : spatial */
  1070. stwbot = stwtype / 3;
  1072. if((mb_type & MB_FORWARD) || (video->pict_type == P_TYPE))
  1073. {
  1074.      if(video->pict_struct == FRAME_PICTURE)
  1075. {
  1076.      if((motion_type == MC_FRAME) || !(mb_type & MB_FORWARD))
  1077. {
  1078. /* frame-based prediction */
  1079. {
  1080.          if(stwtop < 2)
  1081.          recon(video, video->oldrefframe, 0, video->newframe, 0,
  1082.               video->coded_picture_width, video->coded_picture_width << 1, WIDTH, 8, bx, by,
  1083.                 PMV[0][0][0], PMV[0][0][1], stwtop);
  1085.          if(stwbot < 2)
  1086.          recon(video, video->oldrefframe, 1, video->newframe, 1,
  1087.              video->coded_picture_width, video->coded_picture_width << 1, WIDTH, 8, bx, by,
  1088.              PMV[0][0][0], PMV[0][0][1], stwbot);
  1089.         }
  1090.      }
  1091.      else if(motion_type == MC_FIELD) /* field-based prediction */
  1092.      {
  1093. /* top field prediction */
  1094.          if(stwtop < 2)
  1095.          recon(video, video->oldrefframe, mv_field_sel[0][0], video->newframe, 0,
  1096.              video->coded_picture_width << 1, video->coded_picture_width << 1, WIDTH, 8, bx, by >> 1,
  1097.              PMV[0][0][0], PMV[0][0][1] >> 1, stwtop);
  1099. /* bottom field prediction */
  1100.          if(stwbot < 2)
  1101.          recon(video, video->oldrefframe, mv_field_sel[1][0], video->newframe, 1,
  1102.              video->coded_picture_width << 1, video->coded_picture_width << 1, WIDTH, 8, bx, by >> 1, 
  1103.              PMV[1][0][0], PMV[1][0][1] >> 1, stwbot);
  1104.      }
  1105.      else if(motion_type == MC_DMV)
  1106. { 
  1107. /* dual prime prediction */
  1108. /* calculate derived motion vectors */
  1109.          mpeg3video_calc_dmv(video, 
  1110. DMV,
  1111. dmvector,
  1112. PMV[0][0][0],
  1113. PMV[0][0][1] >> 1);
  1115.          if(stwtop < 2)
  1116. {
  1117. /* predict top field from top field */
  1118.          recon(video, video->oldrefframe, 0, video->newframe, 0, 
  1119.              video->coded_picture_width << 1, video->coded_picture_width << 1, WIDTH, 8, bx, by>>1, 
  1120.              PMV[0][0][0], PMV[0][0][1] >> 1, 0);
  1122. /* predict and add to top field from bottom field */
  1123.          recon(video, video->oldrefframe, 1, video->newframe, 0, 
  1124.              video->coded_picture_width << 1, video->coded_picture_width << 1, WIDTH, 8, bx, by>>1, 
  1125.              DMV[0][0], DMV[0][1], 1);
  1126.          }
  1128.          if(stwbot < 2)
  1129.          {
  1130. /* predict bottom field from bottom field */
  1131.          recon(video, video->oldrefframe, 1, video->newframe, 1, 
  1132.              video->coded_picture_width << 1, video->coded_picture_width << 1, WIDTH, 8, bx, by>>1, 
  1133.              PMV[0][0][0], PMV[0][0][1]>>1, 0);
  1135. /* predict and add to bottom field from top field */
  1136.          recon(video, video->oldrefframe, 0, video->newframe, 1, 
  1137.              video->coded_picture_width << 1, video->coded_picture_width<<1, WIDTH, 8, bx, by>>1, 
  1138.              DMV[1][0], DMV[1][1], 1);
  1139.          }
  1140.      }
  1141.         else
  1142. /* invalid motion_type */
  1143. /*         fprintf(stderr, "reconstruct: invalid motion_typen"); */
  1144. ;
  1145.      }
  1146.        else 
  1147.        {
  1148. /* TOP_FIELD or BOTTOM_FIELD */
  1149. /* field picture */
  1150.      currentfield = (video->pict_struct == BOTTOM_FIELD);
  1152. /* determine which frame to use for prediction */
  1153.      if((video->pict_type == P_TYPE) && video->secondfield
  1154.             && (currentfield != mv_field_sel[0][0]))
  1155.          predframe = video->refframe; /* same frame */
  1156.      else
  1157.            predframe = video->oldrefframe; /* previous frame */
  1159.      if((motion_type == MC_FIELD) || !(mb_type & MB_FORWARD))
  1160.      {
  1161. /* field-based prediction */
  1162.          if(stwtop < 2)
  1163.          recon(video, predframe,mv_field_sel[0][0],video->newframe,0,
  1164.              video->coded_picture_width << 1,video->coded_picture_width << 1,WIDTH,16,bx,by,
  1165.              PMV[0][0][0],PMV[0][0][1],stwtop);
  1166.      }
  1167.      else 
  1168. if(motion_type == MC_16X8)
  1169.      {
  1170.          if(stwtop < 2)
  1171.          {
  1172.          recon(video, predframe, mv_field_sel[0][0], video->newframe, 0, 
  1173.              video->coded_picture_width << 1, video->coded_picture_width << 1, WIDTH, 8, bx, by, 
  1174.              PMV[0][0][0], PMV[0][0][1], stwtop);
  1176.          /* determine which frame to use for lower half prediction */
  1177.          if((video->pict_type==P_TYPE) && video->secondfield
  1178.                 && (currentfield!=mv_field_sel[1][0]))
  1179.                predframe = video->refframe; /* same frame */
  1180.          else
  1181.                predframe = video->oldrefframe; /* previous frame */
  1183.          recon(video, predframe, mv_field_sel[1][0], video->newframe, 0, 
  1184.              video->coded_picture_width << 1, video->coded_picture_width << 1, WIDTH, 8, bx, by+8, 
  1185.              PMV[1][0][0], PMV[1][0][1], stwtop);
  1186.          }
  1187.      }
  1188.      else 
  1189. if(motion_type == MC_DMV) /* dual prime prediction */
  1190.      {
  1191.          if(video->secondfield)
  1192.             predframe = video->refframe; /* same frame */
  1193.          else
  1194.             predframe = video->oldrefframe; /* previous frame */
  1196. /* calculate derived motion vectors */
  1197.          mpeg3video_calc_dmv(video, 
  1198. DMV,
  1199. dmvector,
  1200. PMV[0][0][0],
  1201. PMV[0][0][1]);
  1203. /* predict from field of same parity */
  1204.          recon(video, video->oldrefframe, currentfield, video->newframe, 0, 
  1205.          video->coded_picture_width << 1, video->coded_picture_width << 1, WIDTH, 16, bx, by, 
  1206.          PMV[0][0][0], PMV[0][0][1], 0);
  1208. /* predict from field of opposite parity */
  1209.          recon(video, predframe, !currentfield, video->newframe, 0, 
  1210.          video->coded_picture_width << 1, video->coded_picture_width << 1, WIDTH, 16, bx, by, 
  1211.          DMV[0][0], DMV[0][1], 1);
  1212.      }
  1213.      else
  1214. /* invalid motion_type */
  1215. /*           fprintf(stderr, "reconstruct: invalid motion_typen"); */
  1216. ;
  1217. }
  1218.        stwtop = stwbot = 1;
  1219. }
  1221. if(mb_type & MB_BACKWARD)
  1222. {
  1223.      if(video->pict_struct == FRAME_PICTURE)
  1224.      {
  1225.      if(motion_type == MC_FRAME)
  1226.      {
  1227. /* frame-based prediction */
  1228.          if(stwtop < 2)
  1229.          recon(video, video->refframe, 0, video->newframe, 0, 
  1230.              video->coded_picture_width, video->coded_picture_width << 1, WIDTH, 8, bx, by, 
  1231.              PMV[0][1][0], PMV[0][1][1], stwtop);
  1233.          if(stwbot < 2)
  1234.          recon(video, video->refframe, 1, video->newframe, 1, 
  1235. video->coded_picture_width, video->coded_picture_width << 1, WIDTH, 8, bx, by, 
  1236. PMV[0][1][0], PMV[0][1][1], stwbot);
  1237.      }
  1238.      else 
  1239. {           
  1240. /* field-based prediction */
  1241. /* top field prediction */
  1242. if(stwtop < 2)
  1243. {
  1244. recon(video, video->refframe, mv_field_sel[0][1], video->newframe, 0,
  1245. (video->coded_picture_width << 1), (video->coded_picture_width<<1), WIDTH, 8, bx, (by >> 1),
  1246. PMV[0][1][0], (PMV[0][1][1] >> 1), stwtop);
  1247. }
  1249. /* bottom field prediction */
  1250.          if(stwbot < 2)
  1251. {
  1252.          recon(video, video->refframe, mv_field_sel[1][1], video->newframe, 1, (video->coded_picture_width << 1),
  1253. (video->coded_picture_width << 1), WIDTH, 8, bx, (by>>1),
  1254. PMV[1][1][0], (PMV[1][1][1]>>1), stwbot);
  1255. }
  1256.      }
  1257.      }
  1258.      else 
  1259. {
  1260. /* TOP_FIELD or BOTTOM_FIELD */
  1261. /* field picture */
  1262.      if(motion_type == MC_FIELD)
  1263. {
  1264. /* field-based prediction */
  1265.          recon(video, video->refframe, mv_field_sel[0][1], video->newframe, 0, 
  1266.      video->coded_picture_width << 1, video->coded_picture_width << 1, WIDTH, 16, bx, by, 
  1267.      PMV[0][1][0], PMV[0][1][1], stwtop);
  1268.      }
  1269.      else if(motion_type==MC_16X8)
  1270.      {
  1271.          recon(video, video->refframe, mv_field_sel[0][1], video->newframe, 0, 
  1272.          video->coded_picture_width << 1, video->coded_picture_width << 1, WIDTH, 8, bx, by, 
  1273.          PMV[0][1][0], PMV[0][1][1], stwtop);
  1275.          recon(video, video->refframe, mv_field_sel[1][1], video->newframe, 0, 
  1276.          video->coded_picture_width << 1, video->coded_picture_width << 1, WIDTH, 8, bx, by+8, 
  1277.          PMV[1][1][0], PMV[1][1][1], stwtop);
  1278.      }
  1279.      else
  1280. /* invalid motion_type */
  1281. /*           fprintf(stderr, "reconstruct: invalid motion_typen"); */
  1282. ;
  1283.      }
  1284. } /* mb_type & MB_BACKWARD */
  1285. return 0;
  1286. }