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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
Recon.cpp
资源名称：meeting_video_system.rar　[点击查看]
上传用户：panstart
上传日期：2022-04-12
资源大小：199k
文件大小：22k
源码类别：

IP电话/视频会议

开发平台：

C++ Builder

Recon.cpp：源码内容
  1. ////////////////////////////////////////////////////////////////////////////
  2. //
  3. //
  4. //    Project     : VideoNet version 1.1.
  5. //    Description : Peer to Peer Video Conferencing over the LAN.
  6. //   Author      : Nagareshwar Y Talekar ( nsry2002@yahoo.co.in)
  7. //    Date        : 15-6-2004.
  8. //
  9. //    This is the modified version of tmndecode (H.263 decoder) 
  10. //    written by Karl & Robert.It was in ANSI C. I have converted into C++
  11. //    so that it can be integrated into any windows application. I have 
  12. //    removed some of the files which had display and file storing 
  13. //    functions.I have removed the unnecessary code and also added some
  14. //    new files..
  15. //   Original library dealt with files. Input & Output , both were files.
  16. //    I have done some major changes so that it can be used for real time 
  17. //    decoding process. Now one can use this library for decoding H263 frames. 
  18. //
  19. //
  20. //    File description : 
  21. //    Name    :Recon.cpp
  22. //
  23. /////////////////////////////////////////////////////////////////////////////
  25. /************************************************************************
  26.  *
  27.  *  recon.c, motion compensation routines for tmndecode (H.263 decoder)
  28.  *  Copyright (C) 1996  Telenor R&D, Norway
  29.  *        Karl Olav Lillevold <Karl.Lillevold@nta.no>
  30.  *
  31.  *  This program is free software; you can redistribute it and/or modify
  32.  *  it under the terms of the GNU General Public License as published by
  33.  *  the Free Software Foundation; either version 2 of the License, or
  34.  *  (at your option) any later version.
  35.  *
  36.  *  This program is distributed in the hope that it will be useful,
  37.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  38.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  39.  *  GNU General Public License for more details.
  40.  *
  41.  *  You should have received a copy of the GNU General Public License
  42.  *  along with this program; if not, write to the Free Software
  43.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  44.  *
  45.  *  Karl Olav Lillevold               <Karl.Lillevold@nta.no>
  46.  *  Telenor Research and Development
  47.  *  P.O.Box 83                        tel.:   +47 63 84 84 00
  48.  *  N-2007 Kjeller, Norway            fax.:   +47 63 81 00 76
  49.  *
  50.  *  Robert Danielsen                  e-mail: Robert.Danielsen@nta.no
  51.  *  Telenor Research and Development  www:    http://www.nta.no/brukere/DVC/
  52.  *  P.O.Box 83                        tel.:   +47 63 84 84 00
  53.  *  N-2007 Kjeller, Norway            fax.:   +47 63 81 00 76
  54.  *  
  55.  ************************************************************************/
  57. /*
  58.  * based on mpeg2decode, (C) 1994, MPEG Software Simulation Group
  59.  * and mpeg2play, (C) 1994 Stefan Eckart
  60.  *                         <stefan@lis.e-technik.tu-muenchen.de>
  61.  *
  62.  */
  63. #include "Recon.h"
  66. void reconstruct(int bx,int by,int P,int bdx,int bdy)
  67. {
  68.   int w,h,lx,lx2,dx,dy,xp,yp,comp,sum;
  69.   int x,y,mode,xvec,yvec;
  70.   unsigned char *src[3];
  72.   x = bx/16+1; y = by/16+1;
  73.   lx = coded_picture_width;
  75.   if (mv_outside_frame) {
  76.     lx2 = coded_picture_width + 64;
  77.     src[0] = edgeframe[0];
  78.     src[1] = edgeframe[1];
  79.     src[2] = edgeframe[2];
  80.   }
  81.   else {
  82.     lx2 = coded_picture_width;
  83.     src[0] = oldrefframe[0];
  84.     src[1] = oldrefframe[1];
  85.     src[2] = oldrefframe[2];
  86.   }
  88.   mode = modemap[y][x];
  90.   if (P) {
  91.     /* P prediction */
  92.     if (adv_pred_mode) {
  93.       w = 8; h = 8;
  94.       /* Y*/
  95.       for (comp = 0; comp < 4; comp++) {
  96.         xp = bx + ((comp&1)<<3);
  97.         yp = by + ((comp&2)<<2);
  98.         recon_comp_obmc(src[0],newframe[0], lx,lx2,comp,w,h,xp,yp);
  99.       }
  100.       if (mode == MODE_INTER4V) {
  102.         sum = MV[0][1][y][x]+MV[0][2][y][x]+ MV[0][3][y][x]+MV[0][4][y][x];
  103.         dx = sign(sum)*(roundtab[abs(sum)%16] + (abs(sum)/16)*2);
  105.         sum = MV[1][1][y][x]+MV[1][2][y][x]+ MV[1][3][y][x]+MV[1][4][y][x];
  106.         dy = sign(sum)*(roundtab[abs(sum)%16] + (abs(sum)/16)*2);
  108.       }
  109.       else {
  110.         dx = MV[0][0][y][x];
  111.         dy = MV[1][0][y][x];
  112.         /* chroma rounding */
  113.         dx = ( dx % 4 == 0 ? dx >> 1 : (dx>>1)|1 );
  114.         dy = ( dy % 4 == 0 ? dy >> 1 : (dy>>1)|1 );
  115.       }
  116.       lx>>=1;bx>>=1; lx2>>=1; 
  117.       by>>=1;
  118.       /* Chroma */
  119.       recon_comp(src[1],newframe[1], lx,lx2,w,h,bx,by,dx,dy,1);
  120.       recon_comp(src[2],newframe[2], lx,lx2,w,h,bx,by,dx,dy,2);
  121.     }
  122.     else { /* normal prediction mode */
  123.       /* P prediction */
  124.       w = 16; h = 16;
  125.       dx = MV[0][0][y][x];
  126.       dy = MV[1][0][y][x];
  127.       
  128.       /* Y */
  129.       recon_comp(src[0],newframe[0], lx,lx2,w,h,bx,by,dx,dy,0);
  130.       
  131.       lx>>=1; w>>=1; bx>>=1; lx2>>=1; 
  132.       h>>=1; by>>=1;  
  133.       /* chroma rounding */
  134.       dx = ( dx % 4 == 0 ? dx >> 1 : (dx>>1)|1 );
  135.       dy = ( dy % 4 == 0 ? dy >> 1 : (dy>>1)|1 );
  137.       /* Chroma */
  138.       recon_comp(src[1],newframe[1], lx,lx2,w,h,bx,by,dx,dy,1);
  139.       recon_comp(src[2],newframe[2], lx,lx2,w,h,bx,by,dx,dy,2);
  140.     }
  141.   }
  143.   else {
  144.     /* B forward prediction */
  145.     if (adv_pred_mode) {
  146.       if (mode == MODE_INTER4V) {
  147.         w = 8; h = 8;
  148.         /* Y*/
  149.         xvec = yvec = 0;
  150.         for (comp = 0; comp < 4; comp++) {
  151.           xvec += dx = (trb)*MV[0][comp+1][y][x]/trd + bdx;
  152.           yvec += dy = (trb)*MV[1][comp+1][y][x]/trd + bdy;
  153.           xp = bx + ((comp&1)<<3);
  154.           yp = by + ((comp&2)<<2);
  155.           recon_comp(src[0],bframe[0], lx,lx2,w,h,xp,yp,dx,dy,0);
  156.         }
  158.         /* chroma rounding (table 16/H.263) */
  159.         dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2);
  160.         dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2);
  162.         lx>>=1;bx>>=1; lx2>>=1;
  163.         by>>=1;
  164.         /* Chroma */
  165.         recon_comp(src[1],bframe[1], lx,lx2,w,h,bx,by,dx,dy,1);
  166.         recon_comp(src[2],bframe[2], lx,lx2,w,h,bx,by,dx,dy,2);
  167.       }
  168.       else {  /* adv_pred_mode but 16x16 vector */
  169.         w = 16; h = 16;
  171.         dx = (trb)*MV[0][0][y][x]/trd + bdx;
  172.         dy = (trb)*MV[1][0][y][x]/trd + bdy;
  173.         /* Y */
  174.         recon_comp(src[0],bframe[0], lx,lx2,w,h,bx,by,dx,dy,0);
  175.         
  176.         lx>>=1; w>>=1; bx>>=1; lx2>>=1;
  177.         h>>=1; by>>=1;  
  179.         xvec = 4*dx;
  180.         yvec = 4*dy;
  182.         /* chroma rounding (table 16/H.263) */
  183.         dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2);
  184.         dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2);
  186.         /* Chroma */
  187.         recon_comp(src[1],bframe[1], lx,lx2,w,h,bx,by,dx,dy,1);
  188.         recon_comp(src[2],bframe[2], lx,lx2,w,h,bx,by,dx,dy,2);
  189.       }
  190.     }
  191.     else { /* normal B forward prediction */
  193.       w = 16; h = 16;
  194.       dx = (trb)*MV[0][0][y][x]/trd + bdx;
  195.       dy = (trb)*MV[1][0][y][x]/trd + bdy;
  196.       /* Y */
  197.       recon_comp(src[0],bframe[0], lx,lx2,w,h,bx,by,dx,dy,0);
  199.       lx>>=1; w>>=1; bx>>=1; lx2>>=1;
  200.       h>>=1; by>>=1;  
  202.       xvec = 4*dx;
  203.       yvec = 4*dy;
  205.       /* chroma rounding (table 16/H.263) */ 
  206.       dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2);
  207.       dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2);
  209.       /* Chroma */
  210.       recon_comp(src[1],bframe[1], lx,lx2,w,h,bx,by,dx,dy,1);
  211.       recon_comp(src[2],bframe[2], lx,lx2,w,h,bx,by,dx,dy,2);
  212.     }
  213.   }
  214. }
  219. static void recon_comp(unsigned char* src,unsigned char* dst,int lx,int lx2,int w,int h,int x,int y,int dx,int dy,int chroma)
  220. {
  221.   int xint, xh, yint, yh;
  222.   unsigned char *s, *d;
  224.   xint = dx>>1;
  225.   xh = dx & 1;
  226.   yint = dy>>1;
  227.   yh = dy & 1;
  229.   /* origins */
  230.   s = src + lx2*(y+yint) + x + xint;
  231.   d = dst + lx*y + x;
  233.   if (!xh && !yh)
  234.     if (w!=8)
  235.       rec(s,d,lx,lx2,h);
  236.     else
  237.       recc(s,d,lx,lx2,h);
  238.   else if (!xh && yh)
  239.     if (w!=8)
  240.       recv(s,d,lx,lx2,h);
  241.     else 
  242.       recvc(s,d,lx,lx2,h);
  243.   else if (xh && !yh)
  244.     if (w!=8)
  245.       rech(s,d,lx,lx2,h);
  246.     else
  247.       rechc(s,d,lx,lx2,h);
  248.   else /* if (xh && yh) */
  249.     if (w!=8)
  250.       rec4(s,d,lx,lx2,h);
  251.     else
  252.       rec4c(s,d,lx,lx2,h);
  253. }
  255. static void rec(unsigned char* s,unsigned char* d,int lx,int lx2,int h)
  256. {
  257.   int j;
  259.   for (j=0; j<h; j++)
  260.   {
  261.     d[0] = s[0];
  262.     d[1] = s[1];
  263.     d[2] = s[2];
  264.     d[3] = s[3];
  265.     d[4] = s[4];
  266.     d[5] = s[5];
  267.     d[6] = s[6];
  268.     d[7] = s[7];
  269.     d[8] = s[8];
  270.     d[9] = s[9];
  271.     d[10] = s[10];
  272.     d[11] = s[11];
  273.     d[12] = s[12];
  274.     d[13] = s[13];
  275.     d[14] = s[14];
  276.     d[15] = s[15];
  277.     s+= lx2;
  278.     d+= lx;
  279.   }
  280. }
  282. static void recc(unsigned char* s,unsigned char* d,int lx,int lx2,int h)
  283. {
  284.   int j;
  286.   for (j=0; j<h; j++)
  287.   {
  288.     d[0] = s[0];
  289.     d[1] = s[1];
  290.     d[2] = s[2];
  291.     d[3] = s[3];
  292.     d[4] = s[4];
  293.     d[5] = s[5];
  294.     d[6] = s[6];
  295.     d[7] = s[7];
  296.     s+= lx2;
  297.     d+= lx;
  298.   }
  299. }
  301. static void reco(unsigned char* s,int *d,int lx,int lx2,int addflag,int c,int xa,int xb,int ya,int yb)
  302. {
  303.   int i,j;
  304.   int *om;
  306.   om = &OM[c][ya][0];
  308.   if (!addflag) {
  309.     for (j = ya; j < yb; j++) {
  310.       for (i = xa; i < xb; i++) {
  311.         d[i] = s[i] * om[i];
  312.       }
  313.       s+= lx2;
  314.       d+= lx;
  315.       om+= 8;
  316.     }
  317.   }
  318.   else {
  319.     for (j = ya; j < yb; j++) {
  320.       for (i = xa; i < xb; i++) {
  321.         d[i] += s[i] * om[i];
  322.       }
  323.       s+= lx2;
  324.       d+= lx;
  325.       om+= 8;
  326.     }
  327.   }
  328. }
  330. static void rech(unsigned char* s,unsigned char* d,int lx,int lx2,int h)
  331. {
  332.   unsigned char *dp,*sp;
  333.   int j;
  334.   unsigned int s1,s2;
  336.   sp = s;
  337.   dp = d;
  338.   for (j=0; j<h; j++)
  339.   {
  340.     s1=sp[0];
  341.     dp[0] = (unsigned int)(s1+(s2=sp[1])+1)>>1;
  342.     dp[1] = (unsigned int)(s2+(s1=sp[2])+1)>>1;
  343.     dp[2] = (unsigned int)(s1+(s2=sp[3])+1)>>1;
  344.     dp[3] = (unsigned int)(s2+(s1=sp[4])+1)>>1;
  345.     dp[4] = (unsigned int)(s1+(s2=sp[5])+1)>>1;
  346.     dp[5] = (unsigned int)(s2+(s1=sp[6])+1)>>1;
  347.     dp[6] = (unsigned int)(s1+(s2=sp[7])+1)>>1;
  348.     dp[7] = (unsigned int)(s2+(s1=sp[8])+1)>>1;
  349.     dp[8] = (unsigned int)(s1+(s2=sp[9])+1)>>1;
  350.     dp[9] = (unsigned int)(s2+(s1=sp[10])+1)>>1;
  351.     dp[10] = (unsigned int)(s1+(s2=sp[11])+1)>>1;
  352.     dp[11] = (unsigned int)(s2+(s1=sp[12])+1)>>1;
  353.     dp[12] = (unsigned int)(s1+(s2=sp[13])+1)>>1;
  354.     dp[13] = (unsigned int)(s2+(s1=sp[14])+1)>>1;
  355.     dp[14] = (unsigned int)(s1+(s2=sp[15])+1)>>1;
  356.     dp[15] = (unsigned int)(s2+sp[16]+1)>>1;
  357.     sp+= lx2;
  358.     dp+= lx;
  359.   }
  360. }
  362. static void rechc(unsigned char* s,unsigned char* d,int lx,int lx2,int h)
  363. {
  364.   unsigned char *dp,*sp;
  365.   int j;
  366.   unsigned int s1,s2;
  368.   sp = s;
  369.   dp = d;
  370.   for (j=0; j<h; j++)
  371.   {
  372.     s1=sp[0];
  373.     dp[0] = (unsigned int)(s1+(s2=sp[1])+1)>>1;
  374.     dp[1] = (unsigned int)(s2+(s1=sp[2])+1)>>1;
  375.     dp[2] = (unsigned int)(s1+(s2=sp[3])+1)>>1;
  376.     dp[3] = (unsigned int)(s2+(s1=sp[4])+1)>>1;
  377.     dp[4] = (unsigned int)(s1+(s2=sp[5])+1)>>1;
  378.     dp[5] = (unsigned int)(s2+(s1=sp[6])+1)>>1;
  379.     dp[6] = (unsigned int)(s1+(s2=sp[7])+1)>>1;
  380.     dp[7] = (unsigned int)(s2+sp[8]+1)>>1;
  381.     sp+= lx2;
  382.     dp+= lx;
  383.   }
  384. }
  386. static void recho(unsigned char* s,int *d,int lx,int lx2,int addflag,int c,int xa,int xb,int ya,int yb)
  387. {
  388.   int *dp,*om;
  389.   unsigned char *sp;
  390.   int i,j;
  392.   sp = s;
  393.   dp = d;
  394.   om = &OM[c][ya][0];
  396.   if (!addflag) {
  397.     for (j = ya; j < yb; j++) {
  398.       for (i = xa; i < xb; i++) {
  399.         dp[i] = (((unsigned int)(sp[i] + sp[i+1]+1))>>1)*om[i];
  400.       }
  401.       sp+= lx2;
  402.       dp+= lx;
  403.       om+= 8;
  404.     }
  405.   }
  406.   else {
  407.     for (j = ya; j < yb; j++) {
  408.       for (i = xa; i < xb; i++) {
  409.         dp[i] += (((unsigned int)(sp[i] + sp[i+1]+1))>>1)*OM[c][j][i];
  410.       }
  411.       sp+= lx2;
  412.       dp+= lx;
  413.       om+= 8;
  414.     }
  415.   }
  416. }
  418. static void recv(unsigned char* s,unsigned char* d,int lx,int lx2,int h)
  419. {
  420.   unsigned char *dp,*sp,*sp2;
  421.   int j;
  423.   sp = s;
  424.   sp2 = s+lx2;
  425.   dp = d;
  426.   for (j=0; j<h; j++)
  427.   {
  428.     dp[0] = (unsigned int)(sp[0]+sp2[0]+1)>>1;
  429.     dp[1] = (unsigned int)(sp[1]+sp2[1]+1)>>1;
  430.     dp[2] = (unsigned int)(sp[2]+sp2[2]+1)>>1;
  431.     dp[3] = (unsigned int)(sp[3]+sp2[3]+1)>>1;
  432.     dp[4] = (unsigned int)(sp[4]+sp2[4]+1)>>1;
  433.     dp[5] = (unsigned int)(sp[5]+sp2[5]+1)>>1;
  434.     dp[6] = (unsigned int)(sp[6]+sp2[6]+1)>>1;
  435.     dp[7] = (unsigned int)(sp[7]+sp2[7]+1)>>1;
  436.     dp[8] = (unsigned int)(sp[8]+sp2[8]+1)>>1;
  437.     dp[9] = (unsigned int)(sp[9]+sp2[9]+1)>>1;
  438.     dp[10] = (unsigned int)(sp[10]+sp2[10]+1)>>1;
  439.     dp[11] = (unsigned int)(sp[11]+sp2[11]+1)>>1;
  440.     dp[12] = (unsigned int)(sp[12]+sp2[12]+1)>>1;
  441.     dp[13] = (unsigned int)(sp[13]+sp2[13]+1)>>1;
  442.     dp[14] = (unsigned int)(sp[14]+sp2[14]+1)>>1;
  443.     dp[15] = (unsigned int)(sp[15]+sp2[15]+1)>>1;
  444.     sp+= lx2;
  445.     sp2+= lx2;
  446.     dp+= lx;
  447.   }
  448. }
  450. static void recvc(unsigned char* s,unsigned char* d,int lx,int lx2,int h)
  451. {
  452.   unsigned char *dp,*sp,*sp2;
  453.   int j;
  455.   sp = s;
  456.   sp2 = s+lx2;
  457.   dp = d;
  459.   for (j=0; j<h; j++)
  460.   {
  461.     dp[0] = (unsigned int)(sp[0]+sp2[0]+1)>>1;
  462.     dp[1] = (unsigned int)(sp[1]+sp2[1]+1)>>1;
  463.     dp[2] = (unsigned int)(sp[2]+sp2[2]+1)>>1;
  464.     dp[3] = (unsigned int)(sp[3]+sp2[3]+1)>>1;
  465.     dp[4] = (unsigned int)(sp[4]+sp2[4]+1)>>1;
  466.     dp[5] = (unsigned int)(sp[5]+sp2[5]+1)>>1;
  467.     dp[6] = (unsigned int)(sp[6]+sp2[6]+1)>>1;
  468.     dp[7] = (unsigned int)(sp[7]+sp2[7]+1)>>1;
  469.     sp+= lx2;
  470.     sp2+= lx2;
  471.     dp+= lx;
  472.   }
  473. }
  475. static void recvo(unsigned char* s,int *d,int lx,int lx2,int addflag,int c,int xa,int xb,int ya,int yb)
  476. {
  477.   int *dp,*om;
  478.   unsigned char *sp,*sp2;
  479.   int i,j;
  481.   sp = s;
  482.   sp2 = s+lx2;
  483.   dp = d;
  484.   om = &OM[c][ya][0];
  486.   if (!addflag) {
  487.     for (j = ya; j < yb; j++) {
  488.       for (i = xa; i < xb; i++) {
  489.         dp[i] = (((unsigned int)(sp[i] + sp2[i]+1))>>1)*om[i];
  490.       }
  491.       sp+= lx2;
  492.       sp2+= lx2;
  493.       dp+= lx;
  494.       om+= 8;
  495.     }
  496.   }
  497.   else {
  498.     for (j = ya; j < yb; j++) {
  499.       for (i = xa; i < xb; i++) {
  500.         dp[i] += (((unsigned int)(sp[i] + sp2[i]+1))>>1)*om[i];
  501.       }
  502.       sp+= lx2;
  503.       sp2+= lx2;
  504.       dp+= lx;
  505.       om+= 8;
  506.     }
  507.   }
  508. }
  510. static void rec4(unsigned char* s,unsigned char* d,int lx,int lx2,int h)
  511. {
  512.   unsigned char *dp,*sp,*sp2;
  513.   int j;
  514.   unsigned int s1,s2,s3,s4;
  516.   sp = s;
  517.   sp2 = s+lx2;
  518.   dp = d;
  519.   for (j=0; j<h; j++)
  520.   {
  521.     s1=sp[0]; s3=sp2[0];
  522.     dp[0] = (unsigned int)(s1+(s2=sp[1])+s3+(s4=sp2[1])+2)>>2;
  523.     dp[1] = (unsigned int)(s2+(s1=sp[2])+s4+(s3=sp2[2])+2)>>2;
  524.     dp[2] = (unsigned int)(s1+(s2=sp[3])+s3+(s4=sp2[3])+2)>>2;
  525.     dp[3] = (unsigned int)(s2+(s1=sp[4])+s4+(s3=sp2[4])+2)>>2;
  526.     dp[4] = (unsigned int)(s1+(s2=sp[5])+s3+(s4=sp2[5])+2)>>2;
  527.     dp[5] = (unsigned int)(s2+(s1=sp[6])+s4+(s3=sp2[6])+2)>>2;
  528.     dp[6] = (unsigned int)(s1+(s2=sp[7])+s3+(s4=sp2[7])+2)>>2;
  529.     dp[7] = (unsigned int)(s2+(s1=sp[8])+s4+(s3=sp2[8])+2)>>2;
  530.     dp[8] = (unsigned int)(s1+(s2=sp[9])+s3+(s4=sp2[9])+2)>>2;
  531.     dp[9] = (unsigned int)(s2+(s1=sp[10])+s4+(s3=sp2[10])+2)>>2;
  532.     dp[10] = (unsigned int)(s1+(s2=sp[11])+s3+(s4=sp2[11])+2)>>2;
  533.     dp[11] = (unsigned int)(s2+(s1=sp[12])+s4+(s3=sp2[12])+2)>>2;
  534.     dp[12] = (unsigned int)(s1+(s2=sp[13])+s3+(s4=sp2[13])+2)>>2;
  535.     dp[13] = (unsigned int)(s2+(s1=sp[14])+s4+(s3=sp2[14])+2)>>2;
  536.     dp[14] = (unsigned int)(s1+(s2=sp[15])+s3+(s4=sp2[15])+2)>>2;
  537.     dp[15] = (unsigned int)(s2+sp[16]+s4+sp2[16]+2)>>2;
  538.     sp+= lx2;
  539.     sp2+= lx2;
  540.     dp+= lx;
  541.   }
  542. }
  544. static void rec4c(unsigned char *s ,unsigned char *d,int lx,int lx2,int h)
  545. {
  546.   unsigned char *dp,*sp,*sp2;
  547.   int j;
  548.   unsigned int s1,s2,s3,s4;
  550.   sp = s;
  551.   sp2 = s+lx2;
  552.   dp = d;
  553.   for (j=0; j<h; j++)
  554.   {
  555.     s1=sp[0]; s3=sp2[0];
  556.     dp[0] = (unsigned int)(s1+(s2=sp[1])+s3+(s4=sp2[1])+2)>>2;
  557.     dp[1] = (unsigned int)(s2+(s1=sp[2])+s4+(s3=sp2[2])+2)>>2;
  558.     dp[2] = (unsigned int)(s1+(s2=sp[3])+s3+(s4=sp2[3])+2)>>2;
  559.     dp[3] = (unsigned int)(s2+(s1=sp[4])+s4+(s3=sp2[4])+2)>>2;
  560.     dp[4] = (unsigned int)(s1+(s2=sp[5])+s3+(s4=sp2[5])+2)>>2;
  561.     dp[5] = (unsigned int)(s2+(s1=sp[6])+s4+(s3=sp2[6])+2)>>2;
  562.     dp[6] = (unsigned int)(s1+(s2=sp[7])+s3+(s4=sp2[7])+2)>>2;
  563.     dp[7] = (unsigned int)(s2+sp[8]+s4+sp2[8]+2)>>2;
  564.     sp+= lx2;
  565.     sp2+= lx2;
  566.     dp+= lx;
  567.   }
  568. }
  570. static void rec4o(unsigned char* s,int *d,int lx,int lx2,int addflag,int c,int xa,int xb,int ya,int yb)
  571. {
  572.   int *dp,*om;
  573.   unsigned char *sp,*sp2;
  574.   int i,j;
  576.   sp = s;
  577.   sp2 = s+lx2;
  578.   dp = d;
  579.   om = &OM[c][ya][0];
  581.   if (!addflag) {
  582.     for (j = ya; j < yb; j++) {
  583.       for (i = xa; i < xb; i++) {
  584.         dp[i] = (((unsigned int)(sp[i]+sp2[i]+sp[i+1]+sp2[i+1]+2))>>2)*om[i];
  585.       }
  586.       sp+= lx2;
  587.       sp2+= lx2;
  588.       dp+= lx;
  589.       om+= 8;
  590.     }
  591.   }
  592.   else {
  593.     for (j = ya; j < yb; j++) {
  594.       for (i = xa; i < xb; i++) {
  595.         dp[i] += (((unsigned int)(sp[i]+sp2[i]+sp[i+1]+sp2[i+1]+2))>>2)*om[i];
  596.       }
  597.       sp+= lx2;
  598.       sp2+= lx2;
  599.       dp+= lx;
  600.       om += 8;
  601.     }
  602.   }
  603. }
  605. static void recon_comp_obmc(unsigned char* src,unsigned char* dst,int lx,int lx2,int comp,int w,int h,int x,int y)
  606. {
  607.   int j,k;
  608.   int xmb,ymb;
  609.   int c8,t8,l8,r8;
  610.   int ti8,li8,ri8;
  611.   int xit,xib,xir,xil;
  612.   int yit,yib,yir,yil;
  613.   int vect,vecb,vecr,vecl;
  614.   int nx[5],ny[5],xint[5],yint[5],xh[5],yh[5];
  615.   int p[64],*pd;
  616.   unsigned char *d,*s[5];
  618.   xmb = (x>>4)+1;
  619.   ymb = (y>>4)+1;
  621.   c8  = (modemap[ymb][xmb] == MODE_INTER4V ? 1 : 0);
  623.   t8  = (modemap[ymb-1][xmb] == MODE_INTER4V ? 1 : 0);
  624.   ti8 = (modemap[ymb-1][xmb] == MODE_INTRA ? 1 : 0);
  625.   ti8 = (modemap[ymb-1][xmb] == MODE_INTRA_Q ? 1 : ti8);
  627.   l8  = (modemap[ymb][xmb-1] == MODE_INTER4V ? 1 : 0);
  628.   li8 = (modemap[ymb][xmb-1] == MODE_INTRA ? 1 : 0);
  629.   li8 = (modemap[ymb][xmb-1] == MODE_INTRA_Q ? 1 : li8);
  630.   
  631.   r8  = (modemap[ymb][xmb+1] == MODE_INTER4V ? 1 : 0);
  632.   ri8 = (modemap[ymb][xmb+1] == MODE_INTRA ? 1 : 0);
  633.   ri8 = (modemap[ymb][xmb+1] == MODE_INTRA_Q ? 1 : ri8);
  635.   if (pb_frame) {
  636.     ti8 = li8 = ri8 = 0;
  637.   }
  639.   switch (comp+1) {
  641.   case 1:
  642.     vect = (ti8 ? (c8 ? 1 : 0) : (t8 ? 3 : 0)); 
  643.     yit  = (ti8 ? ymb : ymb - 1); 
  644.     xit = xmb;
  646.     vecb = (c8 ? 3 : 0) ; yib = ymb; xib = xmb;
  648.     vecl = (li8 ? (c8 ? 1 : 0) : (l8 ? 2 : 0)); 
  649.     yil = ymb; 
  650.     xil = (li8 ? xmb : xmb-1);
  652.     vecr = (c8 ? 2 : 0) ; yir = ymb; xir = xmb;
  654.     /* edge handling */
  655.     if (ymb == 1) {
  656.       yit = ymb;
  657.       vect = (c8 ? 1 : 0);
  658.     }
  659.     if (xmb == 1) {
  660.       xil = xmb;
  661.       vecl = (c8 ? 1 : 0);
  662.     }
  663.     break;
  664.   
  665.   case 2:
  666.     vect = (ti8 ? (c8 ? 2 : 0) : (t8 ? 4 : 0)); 
  667.     yit = (ti8 ? ymb : ymb-1); 
  668.     xit = xmb;
  670.     vecb = (c8 ? 4 : 0) ; yib = ymb; xib = xmb;
  671.     vecl = (c8 ? 1 : 0) ; yil = ymb; xil = xmb;
  673.     vecr = (ri8 ? (c8 ? 2 : 0) : (r8 ? 1 : 0)); 
  674.     yir = ymb; 
  675.     xir = (ri8 ? xmb : xmb+1);
  677.     /* edge handling */
  678.     if (ymb == 1) {
  679.       yit = ymb;
  680.       vect = (c8 ? 2 : 0);
  681.     }
  682.     if (xmb == mb_width) {
  683.       xir = xmb;
  684.       vecr = (c8 ? 2 : 0);
  685.     }
  686.     break;
  688.   case 3:
  689.     vect = (c8 ? 1 : 0) ; yit = ymb  ; xit = xmb;
  690.     vecb = (c8 ? 3 : 0) ; yib = ymb  ; xib = xmb;
  691.       
  692.     vecl = (li8 ? (c8 ? 3 : 0) : (l8 ? 4 : 0)); 
  693.     yil = ymb;  
  694.     xil = (li8 ? xmb : xmb-1);
  695.     
  696.     vecr = (c8 ? 4 : 0) ; yir = ymb  ; xir = xmb;
  698.     /* edge handling */
  699.     if (xmb == 1) {
  700.       xil = xmb;
  701.       vecl = (c8 ? 3 : 0);
  702.     }
  703.     break;
  705.   case 4:
  706.     vect = (c8 ? 2 : 0) ; yit = ymb  ; xit = xmb;
  707.     vecb = (c8 ? 4 : 0) ; yib = ymb  ; xib = xmb;
  708.     vecl = (c8 ? 3 : 0) ; yil = ymb  ; xil = xmb;
  710.     vecr = (ri8 ? (c8 ? 4 : 0) : (r8 ? 3 : 0)); 
  711.     yir = ymb; 
  712.     xir = (ri8 ? xmb : xmb+1);
  714.     /* edge handling */
  715.     if (xmb == mb_width) {
  716.       xir = xmb;
  717.       vecr = (c8 ? 4 : 0);
  718.     }
  719.     break;
  721.   default:
  722.     if(trace)
  723. fputs("Illegal block number in recon_comp_obmc (recon.c)n",dlog);
  724.     return;
  725.     break;
  726.   }
  728.   nx[0] = MV[0][c8 ? comp + 1 : 0][ymb][xmb];
  729.   ny[0] = MV[1][c8 ? comp + 1 : 0][ymb][xmb];
  730.   
  731.   nx[1] = MV[0][vect][yit][xit]; ny[1] = MV[1][vect][yit][xit];
  732.   nx[2] = MV[0][vecb][yib][xib]; ny[2] = MV[1][vecb][yib][xib];
  733.   nx[3] = MV[0][vecr][yir][xir]; ny[3] = MV[1][vecr][yir][xir];
  734.   nx[4] = MV[0][vecl][yil][xil]; ny[4] = MV[1][vecl][yil][xil];
  736.   for (k = 0; k < 5; k++) {
  737.     xint[k] = nx[k]>>1;
  738.     xh[k] = nx[k] & 1;
  739.     yint[k] = ny[k]>>1;
  740.     yh[k] = ny[k] & 1;
  741.     s[k] = src + lx2*(y+yint[k]) + x + xint[k];
  742.   }
  743.   
  744.   d = dst + lx*y + x;
  746.   if (!xh[0] && !yh[0])
  747.     reco(s[0],&p[0],8,lx2,0,0,0,8,0,8);
  748.   else if (!xh[0] && yh[0])
  749.     recvo(s[0],&p[0],8,lx2,0,0,0,8,0,8);
  750.   else if (xh[0] && !yh[0])
  751.     recho(s[0],&p[0],8,lx2,0,0,0,8,0,8);
  752.   else /* if (xh[] && yh[]) */
  753.     rec4o(s[0],&p[0],8,lx2,0,0,0,8,0,8);
  755.   if (!xh[1] && !yh[1])
  756.     reco(s[1],&p[0],8,lx2,1,1,0,8,0,4);
  757.   else if (!xh[1] && yh[1])
  758.     recvo(s[1],&p[0],8,lx2,1,1,0,8,0,4);
  759.   else if (xh[1] && !yh[1])
  760.     recho(s[1],&p[0],8,lx2,1,1,0,8,0,4);
  761.   else /* if (xh[] && yh[]) */
  762.     rec4o(s[1],&p[0],8,lx2,1,1,0,8,0,4);
  764.   if (!xh[2] && !yh[2])
  765.     reco(s[2]+(lx2<<2),&p[32],8,lx2,1,2,0,8,4,8);
  766.   else if (!xh[2] && yh[2])
  767.     recvo(s[2]+(lx2<<2),&p[32],8,lx2,1,2,0,8,4,8);
  768.   else if (xh[2] && !yh[2])
  769.     recho(s[2]+(lx2<<2),&p[32],8,lx2,1,2,0,8,4,8);
  770.   else /* if (xh[] && yh[]) */
  771.     rec4o(s[2]+(lx2<<2),&p[32],8,lx2,1,2,0,8,4,8);
  773.   if (!xh[3] && !yh[3])
  774.     reco(s[3],&p[0],8,lx2,1,3,4,8,0,8);
  775.   else if (!xh[3] && yh[3])
  776.     recvo(s[3],&p[0],8,lx2,1,3,4,8,0,8);
  777.   else if (xh[3] && !yh[3])
  778.     recho(s[3],&p[0],8,lx2,1,3,4,8,0,8);
  779.   else /* if (xh[] && yh[]) */
  780.     rec4o(s[3],&p[0],8,lx2,1,3,4,8,0,8);
  782.   if (!xh[4] && !yh[4])
  783.     reco(s[4],&p[0],8,lx2,1,4,0,4,0,8);
  784.   else if (!xh[4] && yh[4])
  785.     recvo(s[4],&p[0],8,lx2,1,4,0,4,0,8);
  786.   else if (xh[4] && !yh[4])
  787.     recho(s[4],&p[0],8,lx2,1,4,0,4,0,8);
  788.   else /* if (xh[] && yh[]) */
  789.     rec4o(s[4],&p[0],8,lx2,1,4,0,4,0,8);
  791.   pd = &p[0];
  792.   for (j = 0; j < 8; j++) {
  793.     d[0] = (pd[0] + 4 )>>3;
  794.     d[1] = (pd[1] + 4 )>>3;
  795.     d[2] = (pd[2] + 4 )>>3;
  796.     d[3] = (pd[3] + 4 )>>3;
  797.     d[4] = (pd[4] + 4 )>>3;
  798.     d[5] = (pd[5] + 4 )>>3;
  799.     d[6] = (pd[6] + 4 )>>3;
  800.     d[7] = (pd[7] + 4 )>>3;
  801.     d += lx;
  802.     pd += 8;
  803.   }
  805. }