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

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

IP电话/视频会议

开发平台：

C++ Builder

GetPic.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    : GetPic.cpp
  22. //
  23. /////////////////////////////////////////////////////////////////////////////
  27. /************************************************************************
  28.  *
  29.  *  getpic.c, picture decoding for tmndecode (H.263 decoder)
  30.  *  Copyright (C) 1996  Telenor R&D, Norway
  31.  *        Karl Olav Lillevold <Karl.Lillevold@nta.no>
  32.  *
  33.  *  This program is free software; you can redistribute it and/or modify
  34.  *  it under the terms of the GNU General Public License as published by
  35.  *  the Free Software Foundation; either version 2 of the License, or
  36.  *  (at your option) any later version.
  37.  *
  38.  *  This program is distributed in the hope that it will be useful,
  39.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  40.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  41.  *  GNU General Public License for more details.
  42.  *
  43.  *  You should have received a copy of the GNU General Public License
  44.  *  along with this program; if not, write to the Free Software
  45.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  46.  *
  47.  *  Karl Olav Lillevold               <Karl.Lillevold@nta.no>
  48.  *  Telenor Research and Development
  49.  *  P.O.Box 83                        tel.:   +47 63 84 84 00
  50.  *  N-2007 Kjeller, Norway            fax.:   +47 63 81 00 76
  51.  *
  52.  *  Robert Danielsen                  e-mail: Robert.Danielsen@nta.no
  53.  *  Telenor Research and Development  www:    http://www.nta.no/brukere/DVC/
  54.  *  P.O.Box 83                        tel.:   +47 63 84 84 00
  55.  *  N-2007 Kjeller, Norway            fax.:   +47 63 81 00 76
  56.  *  
  57.  ************************************************************************/
  59. /*
  60.  * modified by Wayne Ellis BT Labs to run Annex E Arithmetic Decoding
  61.  *           <ellis_w_wayne@bt-web.bt.co.uk>
  62.  *
  63.  * based on mpeg2decode, (C) 1994, MPEG Software Simulation Group
  64.  * and mpeg2play, (C) 1994 Stefan Eckart
  65.  *                         <stefan@lis.e-technik.tu-muenchen.de>
  66.  */
  71. #include "GetPic.h"
  73. /* decode one frame or field picture */
  75. void getpicture(int *framenum)
  76. {
  77.   int i;
  78.   unsigned char *tmp;
  80.   for (i=0; i<3; i++) {
  81.     tmp = oldrefframe[i];
  82.     oldrefframe[i] = refframe[i];
  83.     refframe[i] = tmp;
  84.     newframe[i] = refframe[i];
  85.   }
  87.   if (mv_outside_frame && *framenum > 0) {
  88.     make_edge_image(oldrefframe[0],edgeframe[0],coded_picture_width,
  89.             coded_picture_height,32);
  90.     make_edge_image(oldrefframe[1],edgeframe[1],chrom_width, chrom_height,16);
  91.     make_edge_image(oldrefframe[2],edgeframe[2],chrom_width, chrom_height,16);
  92.   }
  93.   getMBs(*framenum);
  95.   if (pb_frame) {
  96.     if (expand && outtype == T_X11) {
  97.       interpolate_image(bframe[0], exnewframe[0],
  98.         coded_picture_width, coded_picture_height);
  99.       interpolate_image(bframe[1], exnewframe[1], chrom_width, chrom_height);
  100.       interpolate_image(bframe[2], exnewframe[2], chrom_width, chrom_height);
  101.       
  102.       storeframe(exnewframe, *framenum);
  103.     }
  104.     else
  105.       storeframe(bframe,*framenum);
  107.     *framenum += pb_frame;
  109.   }
  111.   if (expand && outtype == T_X11) {
  112.     interpolate_image(newframe[0], exnewframe[0],
  113.               coded_picture_width, coded_picture_height);
  114.     interpolate_image(newframe[1], exnewframe[1], chrom_width, chrom_height);
  115.     interpolate_image(newframe[2], exnewframe[2], chrom_width, chrom_height);
  117.     storeframe(exnewframe, *framenum);
  118.   }
  119.   else
  120.     storeframe(newframe,*framenum);
  123. }
  126. /**
  127. *   Store the pointer to Y, U , V frames...
  128. *  
  129. */
  130. void storeframe(unsigned char *src[],int frame)
  131. {
  132.   
  133.   yp=src[0]; // Y component
  134.   up=src[1];        // U component
  135.   vp=src[2];        // V component
  137. }
  140. /* decode all macroblocks of the current picture */
  142. static void getMBs(int framenum)
  143. {
  144.   int comp;
  145.   int MBA, MBAmax;
  146.   int bx, by;
  148.   int COD=0,MCBPC, CBPY, CBP=0, CBPB=0, MODB=0, Mode=0, DQUANT;
  149.   int COD_index, CBPY_index, MODB_index, DQUANT_index, MCBPC_index;
  150.   int INTRADC_index, YCBPB_index, UVCBPB_index, mvdbx_index, mvdby_index;
  151.   int mvx, mvy, mvy_index, mvx_index, pmv0, pmv1, xpos, ypos, gob, i,k;
  152.   int mvdbx=0, mvdby=0, pmvdbx, pmvdby, gfid, YCBPB, UVCBPB, gobheader_read;
  153.   int startmv,stopmv,offset,bsize,last_done=0,pCBP=0,pCBPB=0,pCOD=0;
  154.   int DQ_tab[4] = {-1,-2,1,2};
  155.   short *bp;
  157.   /* number of macroblocks per picture */
  158.   MBAmax = mb_width*mb_height;
  160.   MBA = 0; /* macroblock address */
  161.   newgob = 0;
  163.   /* mark MV's above the picture */
  164.   for (i = 1; i < mb_width+1; i++) {
  165.     for (k = 0; k < 5; k++) {
  166.       MV[0][k][0][i] = NO_VEC;
  167.       MV[1][k][0][i] = NO_VEC;
  168.     }
  169.     modemap[0][i] = MODE_INTRA;
  170.   }
  171.   /* zero MV's on the sides of the picture */
  172.   for (i = 0; i < mb_height+1; i++) {
  173.     for (k = 0; k < 5; k++) {
  174.       MV[0][k][i][0] = 0;
  175.       MV[1][k][i][0] = 0;
  176.       MV[0][k][i][mb_width+1] = 0;
  177.       MV[1][k][i][mb_width+1] = 0;
  178.     }
  179.     modemap[i][0] = MODE_INTRA;
  180.     modemap[i][mb_width+1] = MODE_INTRA;
  181.   }
  183.   fault = 0;
  184.   gobheader_read = 0;
  185.   
  186.   for (;;) {
  188.     //if (trace)
  189.     //  printf("frame %d, MB %dn",framenum,MBA);
  190.   resync:
  192.     /* This version of the decoder does not resync on every possible
  193.        error, and it does not do all possible error checks. It is not
  194.        difficult to make it much more error robust, but I do not think
  195.        it is necessary to include this in the freely available
  196.        version. */
  198.     if (fault) {
  199.         if(trace)
  200. fputs("Warning: A Fault Condition Has Occurred - Resyncing n",dlog);
  201.       startcode();  /* sync on new startcode */
  202.       fault = 0;
  203.     }
  205.     if (!(showbits(22)>>6)) { /* startcode */
  207.       startcode();  
  208.       /* in case of byte aligned start code, ie. PSTUF, GSTUF or ESTUF
  209.          is used */
  210.       
  211.       if (showbits(22) == (32|SE_CODE)) { /* end of sequence */
  212.         if (!(syntax_arith_coding && MBA < MBAmax)) {
  213.           return;
  214.         }
  215.       }
  216.       else if ((showbits(22) == PSC<<5) ) { /* new picture */
  217.         if (!(syntax_arith_coding && MBA < MBAmax)) {
  218.           return;
  219.         }
  220.       }
  221.       else {
  222.         if (!(syntax_arith_coding && MBA%mb_width)) {
  224.           if (syntax_arith_coding) {   /* SAC hack to finish GOBs which   */
  225.             gob = (showbits(22) & 31); /* end with MBs coded with no bits */
  226.             if (gob * mb_width != MBA) 
  227.               goto finish_gob;
  228.           }
  230.           gob = getheader() - 1;
  231.           if (gob > mb_height) {
  232.             if (!quiet)
  233.               fputs("GN out of rangen",dlog);
  234.             return;
  235.           }
  236.           
  237.           /* GFID is not allowed to change unless PTYPE in picture header 
  238.              changes */
  239.           gfid = getbits(2);
  240.           /* NB: in error-prone environments the decoder can use this
  241.              value to determine whether a picture header where the PTYPE
  242.              has changed, has been lost */
  243.           
  244.           quant = getbits(5);
  245.           //if (trace)
  246.           //  printf("GQUANT: %dn", quant);
  247.           xpos = 0;
  248.           ypos = gob;
  249.           MBA = ypos * mb_width;
  250.           
  251.           newgob = 1;
  252.           gobheader_read = 1;
  253.           if (syntax_arith_coding) 
  254.             decoder_reset(); /* init. arithmetic decoder buffer after gob */
  255.         }
  256.       }
  257.     }
  259.   finish_gob:  /* SAC specific label */
  261.     if (!gobheader_read) {
  262.       xpos = MBA%mb_width;
  263.       ypos = MBA/mb_width;
  264.       if (xpos == 0 && ypos > 0)
  265.         newgob = 0;
  266.     }
  267.     else 
  268.       gobheader_read = 0;
  270.     if (MBA>=MBAmax) 
  271.       return; /* all macroblocks decoded */
  273.   read_cod:
  274.     if (syntax_arith_coding) { 
  275.       if (pict_type == PCT_INTER) {
  276.         COD_index = decode_a_symbol(cumf_COD);
  277.         COD = codtab[COD_index];
  278.         if (trace) {
  279.           fputs("Arithmetic Decoding Debug n",dlog);
  280.           //printf("COD Index: %d COD: %d n", COD_index, COD);
  281.         }
  282.       }
  283.       else
  284.         COD = 0;  /* COD not used in I-pictures, set to zero */
  285.     }
  286.     else {
  287.       if (pict_type == PCT_INTER) 
  288.         COD = showbits(1);
  289.       else
  290.         COD = 0; /* Intra picture -> not skipped */
  291.     }
  293.     if (!COD) {  /* COD == 0 --> not skipped */    
  295.       if (syntax_arith_coding)  {
  296.         if (pict_type == PCT_INTER) {
  297.           MCBPC_index = decode_a_symbol(cumf_MCBPC);
  298.           MCBPC = mcbpctab[MCBPC_index];
  299.         }
  300.         else {
  301.           MCBPC_index = decode_a_symbol(cumf_MCBPC_intra);
  302.           MCBPC = mcbpc_intratab[MCBPC_index];
  303.         }
  304.         //if (trace) 
  305.         //  printf("MCBPC Index: %d MCBPC: %d n",MCBPC_index, MCBPC);
  306.       }
  308.       else {
  309.         if (pict_type == PCT_INTER)
  310.           flushbits(1); /* flush COD bit */
  311.         if (pict_type == PCT_INTRA) 
  312.           MCBPC = getMCBPCintra();
  313.         else
  314.           MCBPC = getMCBPC();
  315.       }
  317.       if (fault) goto resync;
  318.       
  319.       if (MCBPC == 255) { /* stuffing */
  320.         goto read_cod;   /* read next COD without advancing MB count */
  321.       }
  323.       else {             /* normal MB data */
  325.         Mode = MCBPC & 7;
  327.         /* MODB and CBPB */
  328.         if (pb_frame) {
  329.           CBPB = 0;
  330.           if (syntax_arith_coding)  {
  331.             MODB_index = decode_a_symbol(cumf_MODB);
  332.             MODB = modb_tab[MODB_index];
  333.           }
  334.           else 
  335.             MODB = getMODB();
  336.           //if (trace)
  337.            // printf("MODB: %dn", MODB);
  338.           if (MODB == PBMODE_CBPB_MVDB) {
  339.             if (syntax_arith_coding)  {
  340.               for(i=0; i<4; i++) {
  341.         YCBPB_index = decode_a_symbol(cumf_YCBPB);
  342.         YCBPB = ycbpb_tab[YCBPB_index];
  343.         CBPB |= (YCBPB << (6-1-i));
  344.               }
  345.  
  346.               for(i=4; i<6; i++) {
  347.         UVCBPB_index = decode_a_symbol(cumf_UVCBPB);
  348.         UVCBPB = uvcbpb_tab[UVCBPB_index];
  349.         CBPB |= (UVCBPB << (6-1-i));
  350.               }
  351.             }
  352.             else
  353.               CBPB = getbits(6);
  354.             //if (trace)
  355.             //  printf("CBPB = %dn",CBPB);
  356.           }
  357.         }
  359.         if (syntax_arith_coding) {
  361.           if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) { /* Intra */
  362.             CBPY_index = decode_a_symbol(cumf_CBPY_intra);
  363.             CBPY = cbpy_intratab[CBPY_index];
  364.           }
  365.           else {
  366.             CBPY_index = decode_a_symbol(cumf_CBPY);
  367.             CBPY = cbpytab[CBPY_index];
  368.         
  369.           }
  370.          // if (trace)
  371.          //   printf("CBPY Index: %d CBPY %d n",CBPY_index, CBPY);
  373.         }
  374.         else 
  375.           CBPY = getCBPY();
  376.  
  377.         /* Decode Mode and CBP */
  378.         
  379.         
  380.         if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
  381.           {/* Intra */
  382.             if (!syntax_arith_coding)
  383.               CBPY = CBPY^15;        /* needed in huffman coding only */
  384.           }
  386.         CBP = (CBPY << 2) | (MCBPC >> 4);
  387.       }
  389.       if (Mode == MODE_INTER4V && !adv_pred_mode) 
  390.         if (!quiet)
  391.           fputs("8x8 vectors not allowed in normal prediction moden",dlog);
  392.           /* Could set fault-flag and resync */
  395.       if (Mode == MODE_INTER_Q || Mode == MODE_INTRA_Q) {
  396.         /* Read DQUANT if necessary */
  398.         if (syntax_arith_coding) {
  399.           DQUANT_index = decode_a_symbol(cumf_DQUANT);
  400.           DQUANT = dquanttab[DQUANT_index] - 2; 
  401.           quant +=DQUANT;
  402.           //if (trace)
  403.             //printf("DQUANT Index: %d DQUANT %d n",DQUANT_index, DQUANT);
  404.         }
  405.         else {
  406.           DQUANT = getbits(2);
  407.           quant += DQ_tab[DQUANT];
  408.           if (trace) {
  409.             fputs("DQUANT (",dlog);
  410.             printbits(DQUANT,2,2);
  411.             //printf("): %d = %dn",DQUANT,DQ_tab[DQUANT]);
  412.           }
  413.         }
  415.         if (quant > 31 || quant < 1) {
  416.           if (!quiet)
  417.             fputs("Quantizer out of range: clippingn",dlog);
  418.           quant = mmax(1,mmin(31,quant));
  419.           /* could set fault-flag and resync here */
  420.         }
  421.       }
  423.       /* motion vectors */
  424.       if (Mode == MODE_INTER || Mode == MODE_INTER_Q || 
  425.           Mode == MODE_INTER4V || pb_frame) {
  427.         if (Mode == MODE_INTER4V) { startmv = 1; stopmv = 4;}
  428.         else { startmv = 0; stopmv = 0;}
  430.         for (k = startmv; k <= stopmv; k++) {
  431.           if (syntax_arith_coding) {
  432.             mvx_index = decode_a_symbol(cumf_MVD);
  433.             mvx = mvdtab[mvx_index];
  434.             mvy_index = decode_a_symbol(cumf_MVD);
  435.             mvy = mvdtab[mvy_index];
  436.             //if (trace)
  437.             //  printf("mvx_index: %d mvy_index: %d n", mvy_index, mvx_index);
  438.           }
  439.           else {
  440.             mvx = getTMNMV();
  441.             mvy = getTMNMV();
  442.           }
  444.           pmv0 = find_pmv(xpos,ypos,k,0);
  445.           pmv1 = find_pmv(xpos,ypos,k,1);
  446.           mvx = motion_decode(mvx, pmv0);
  447.           mvy = motion_decode(mvy, pmv1);
  448.          /* if (trace) {
  449.             printf("mvx: %dn", mvx);
  450.             printf("mvy: %dn", mvy);
  451.           }
  452.   */
  453.           /* Check mv's to prevent seg.faults when error rate is high */
  454.           if (!mv_outside_frame) {
  455.             bsize = k ? 8 : 16;
  456.             offset = k ? (((k-1)&1)<<3) : 0;
  457.             /* checking only integer component */
  458.             if ((xpos<<4) + (mvx/2) + offset < 0 ||
  459.         (xpos<<4) + (mvx/2) + offset > (mb_width<<4) - bsize) {
  460.               if (!quiet)
  461.               fputs("mvx out of range: searching for syncn",dlog);
  462.               fault = 1;
  463.             }
  464.             offset = k ? (((k-1)&2)<<2) : 0;
  465.             if ((ypos<<4) + (mvy/2) + offset < 0 ||
  466.         (ypos<<4) + (mvy/2) + offset > (mb_height<<4) - bsize) {
  467.               if (!quiet)
  468.               fputs("mvy out of range: searching for syncn",dlog);
  469.               fault = 1;
  470.             }
  471.           }
  472.           MV[0][k][ypos+1][xpos+1] = mvx;
  473.           MV[1][k][ypos+1][xpos+1] = mvy;
  474.         }
  476.         /* PB frame delta vectors */
  478.         if (pb_frame) {
  479.           if (MODB == PBMODE_MVDB || MODB == PBMODE_CBPB_MVDB) {
  480.             if (syntax_arith_coding) {
  481.               mvdbx_index = decode_a_symbol(cumf_MVD);
  482.               mvdbx = mvdtab[mvdbx_index];
  483.               
  484.               mvdby_index = decode_a_symbol(cumf_MVD);
  485.               mvdby = mvdtab[mvdby_index];
  486.             }
  487.             else {
  488.               mvdbx = getTMNMV();
  489.               mvdby = getTMNMV();
  490.             }
  493.             mvdbx = motion_decode(mvdbx, 0);
  494.             mvdby = motion_decode(mvdby, 0);
  495.             /* This will not work if the PB deltas are so large they
  496.                require the second colums of the motion vector VLC
  497.                table to be used.  To fix this it is necessary to
  498.                calculate the MV predictor for the PB delta: TRB*MV/TRD
  499.                here, and use this as the second parameter to
  500.                motion_decode(). The B vector itself will then be
  501.                returned from motion_decode(). This will have to be
  502.                changed to the PB delta again, since it is the PB delta
  503.                which is used later in this program. I don't think PB
  504.                deltas outside the range mentioned above is useful, but
  505.                you never know... */
  507.             /*if (trace) {
  508.               printf("MVDB x: %dn", mvdbx);
  509.               printf("MVDB y: %dn", mvdby);
  510.             }
  511.           
  512. */
  513. }
  514.           else {
  515.             mvdbx = 0; 
  516.             mvdby = 0;
  517.           }
  518.         }
  519.       }
  521.       if (fault) goto resync;
  523.     }
  524.     else { /* COD == 1 --> skipped MB */
  525.       if (MBA>=MBAmax)
  526.         return; /* all macroblocks decoded */
  527.       if (!syntax_arith_coding)
  528.         if (pict_type == PCT_INTER)
  529.           flushbits(1);
  531.       Mode = MODE_INTER;
  532.       
  533.       /* Reset CBP */
  534.       CBP = CBPB = 0;
  536.       /* reset motion vectors */
  537.       MV[0][0][ypos+1][xpos+1] = 0;
  538.       MV[1][0][ypos+1][xpos+1] = 0;
  539.       mvdbx = 0;
  540.       mvdby = 0;
  541.     }
  543.     /* Store Mode*/
  544.     modemap[ypos+1][xpos+1] = Mode;
  546.     if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) 
  547.       if (!pb_frame)
  548.         MV[0][0][ypos+1][xpos+1]=MV[1][0][ypos+1][xpos+1] = 0;
  551.   reconstruct_mb:
  553.     /* pixel coordinates of top left corner of current macroblock */
  554.     /* one delayed because of OBMC */
  555.     if (xpos > 0) {
  556.       bx = 16*(xpos-1);
  557.       by = 16*ypos;
  558.     }
  559.     else {
  560.       bx = coded_picture_width-16;
  561.       by = 16*(ypos-1);
  562.     }
  564.     if (MBA > 0) {
  566.       Mode = modemap[by/16+1][bx/16+1];
  568.       /* forward motion compensation for B-frame */
  569.       if (pb_frame)
  570.         reconstruct(bx,by,0,pmvdbx,pmvdby);
  571.       
  572.       /* motion compensation for P-frame */
  573.       if (Mode == MODE_INTER || Mode == MODE_INTER_Q || Mode == MODE_INTER4V)
  574.         reconstruct(bx,by,1,0,0);
  576.       /* copy or add block data into P-picture */
  577.       for (comp=0; comp<blk_cnt; comp++) {
  578.         /* inverse DCT */
  579.         if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) {
  580.           if (refidct)
  581.             idctref(ld->block[comp]);
  582.           else
  583.             idct(ld->block[comp]);
  584.           addblock(comp,bx,by,0);
  585.         }
  586.         else if ( (pCBP & (1<<(blk_cnt-1-comp))) ) {
  587.           /* No need to to do this for blocks with no coeffs */
  588.           if (refidct)
  589.             idctref(ld->block[comp]);
  590.           else
  591.             idct(ld->block[comp]);
  592.           addblock(comp,bx,by,1);
  593.         }
  594.       }
  595.       
  596.       
  597.       if (pb_frame) {
  598.         /* add block data into B-picture */
  599.         for (comp = 6; comp<blk_cnt+6; comp++) {
  600.           if (!pCOD || adv_pred_mode)
  601.             reconblock_b(comp-6,bx,by,Mode,pmvdbx,pmvdby);
  602.           if ( (pCBPB & (1<<(blk_cnt-1-comp%6))) ) {
  603.             if (refidct)
  604.               idctref(ld->block[comp]);
  605.             else
  606.               idct(ld->block[comp]);
  607.             addblock(comp,bx,by,1);
  608.           }
  609.         }
  610.       }
  611.       
  612.     } /* end if (MBA > 0) */
  614.     if (!COD) {
  616.       Mode = modemap[ypos+1][xpos+1];
  618.       /* decode blocks */
  619.       for (comp=0; comp<blk_cnt; comp++) {
  621.         clearblock(comp);
  622.         if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) { /* Intra */
  623.           bp = ld->block[comp];
  624.           if(syntax_arith_coding) {
  625.             INTRADC_index = decode_a_symbol(cumf_INTRADC);
  626.             bp[0] = intradctab[INTRADC_index];
  627.             //if (trace)
  628.             //  printf("INTRADC Index: %d INTRADC: %d n", INTRADC_index, bp[0]);
  629.           }
  630.           else {
  631.             bp[0] = getbits(8);
  632.             /*if (trace) {
  633.               printf("DC[%d]: (",comp);
  634.               printbits((int)bp[0],8,8);
  635.               printf("): %dn",(int)bp[0]);
  636.             }
  637. */ 
  639. }
  641.           if (bp[0] == 128)
  642.             if (!quiet)
  643.               fputs("Illegal DC-coeff: 1000000n",dlog);
  644.           if (bp[0] == 255)  /* Spec. in H.26P, not in TMN4 */
  645.             bp[0] = 128;
  646.           bp[0] *= 8; /* Iquant */
  647.           if ( (CBP & (1<<(blk_cnt-1-comp))) ) {
  648.             if (!syntax_arith_coding)
  649.               getblock(comp,0);
  650.             else 
  651.               get_sac_block(comp,0);
  652.           }
  653.         }
  654.         else { /* Inter */
  655.           if ( (CBP & (1<<(blk_cnt-1-comp))) ) {
  656.             if (!syntax_arith_coding)
  657.               getblock(comp,1);
  658.             else
  659.               get_sac_block(comp,1);
  660.           }
  662.         }
  663.         if (fault) goto resync;
  664.       }
  666.       /* Decode B blocks */
  667.       if (pb_frame) {
  668.         for (comp=6; comp<blk_cnt+6; comp++) {
  669.           clearblock(comp);
  670.           if ( (CBPB & (1<<(blk_cnt-1-comp%6))) ) {
  671.             if (!syntax_arith_coding)
  672.               getblock(comp,1);
  673.             else
  674.               get_sac_block(comp,1);
  675.           }
  676.           if (fault) goto resync;
  677.         }
  678.       }
  679.           
  680.     }
  682.     /* advance to next macroblock */
  683.     MBA++;
  685.     pCBP = CBP; pCBPB = CBPB; pCOD = COD;
  686.     pmvdbx = mvdbx; pmvdby = mvdby;
  687.     fflush(stdout);
  689.     if (MBA >= MBAmax && !last_done) {
  690.       COD = 1;
  691.       xpos = 0;
  692.       ypos++;
  693.       last_done = 1;
  694.       goto reconstruct_mb;
  695.     }
  697.   }
  698. }
  700. /* set block to zero */
  702. static void clearblock(int comp)
  703. {
  704.   int *bp;
  705.   int i;
  707.   bp = (int *)ld->block[comp];
  709.   for (i=0; i<8; i++)
  710.   {
  711.     bp[0] = bp[1] = bp[2] = bp[3] = 0;
  712.     bp += 4;
  713.   }
  714. }
  717. /* move/add 8x8-Block from block[comp] to refframe or bframe */
  719. static void addblock(int comp,int bx,int by,int addflag)
  720. {
  721.   int cc,i, iincr, P = 1;
  722.   unsigned char *rfp;
  723.   short *bp;
  725.   bp = ld->block[comp];
  727.   if (comp >= 6) {
  728.     /* This is a component for B-frame forward prediction */
  729.     P = 0;
  730.     addflag = 1;
  731.     comp -= 6;
  732.   }
  734.   cc = (comp<4) ? 0 : (comp&1)+1; /* color component index */
  736.   if (cc==0) {
  737.     /* luminance */
  738.     
  739.     /* frame DCT coding */
  740.     if (P)
  741.       rfp = newframe[0]
  742.         + coded_picture_width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
  743.     else
  744.       rfp = bframe[0]
  745.         + coded_picture_width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
  746.     iincr = coded_picture_width;
  747.   }
  748.   else {
  749.     /* chrominance */
  751.     /* scale coordinates */
  752.     bx >>= 1;
  753.     by >>= 1;
  754.     /* frame DCT coding */
  755.     if (P)
  756.       rfp = newframe[cc] + chrom_width*by + bx;
  757.     else
  758.       rfp = bframe[cc] + chrom_width*by + bx;
  759.     iincr = chrom_width;
  760.   }
  763.   if (addflag) {
  764.     for (i=0; i<8; i++) {
  765.       rfp[0] = clp[bp[0]+rfp[0]];
  766.       rfp[1] = clp[bp[1]+rfp[1]];
  767.       rfp[2] = clp[bp[2]+rfp[2]];
  768.       rfp[3] = clp[bp[3]+rfp[3]];
  769.       rfp[4] = clp[bp[4]+rfp[4]];
  770.       rfp[5] = clp[bp[5]+rfp[5]];
  771.       rfp[6] = clp[bp[6]+rfp[6]];
  772.       rfp[7] = clp[bp[7]+rfp[7]];
  773.       bp += 8;
  774.       rfp+= iincr;
  775.     }
  776.   }
  777.   else  {
  778.     for (i=0; i<8; i++) {
  779.       rfp[0] = clp[bp[0]];
  780.       rfp[1] = clp[bp[1]];
  781.       rfp[2] = clp[bp[2]];
  782.       rfp[3] = clp[bp[3]];
  783.       rfp[4] = clp[bp[4]];
  784.       rfp[5] = clp[bp[5]];
  785.       rfp[6] = clp[bp[6]];
  786.       rfp[7] = clp[bp[7]];
  787.       bp += 8;
  788.       rfp += iincr;
  789.     }
  790.   }
  791. }
  793. /* bidirectionally reconstruct 8x8-Block from block[comp] to bframe */
  795. static void reconblock_b(int comp,int bx,int by,int mode,int bdx,int bdy)
  796. {
  797.   int cc,i,j,k, ii;
  798.   unsigned char *bfr, *ffr;
  799.   int BMVx, BMVy;
  800.   int xa,xb,ya,yb,x,y,xvec,yvec,mvx,mvy;
  801.   int xint,xhalf,yint,yhalf,pel;
  803.   x = bx/16+1;y=by/16+1;
  805.   if (mode == MODE_INTER4V) {
  806.     if (comp < 4) {
  807.       /* luma */
  808.       mvx = MV[0][comp+1][y][x];
  809.       mvy = MV[1][comp+1][y][x];
  810.       BMVx = (bdx == 0 ? (trb-trd)* mvx/trd : trb * mvx/trd + bdx - mvx);
  811.       BMVy = (bdy == 0 ? (trb-trd)* mvy/trd : trb * mvy/trd + bdy - mvy);
  812.     }
  813.     else {
  814.       /* chroma */
  815.       xvec = yvec = 0;
  816.       for (k = 1; k <= 4; k++) {
  817.         mvx = MV[0][k][y][x];
  818.         mvy = MV[1][k][y][x];
  819.         xvec += (bdx == 0 ? (trb-trd)* mvx/trd : trb * mvx/trd + bdx - mvx);
  820.         yvec += (bdy == 0 ? (trb-trd)* mvy/trd : trb * mvy/trd + bdy - mvy);
  821.       }
  822.       
  823.       /* chroma rounding (table 16/H.263) */
  824.       BMVx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2);
  825.       BMVy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2);
  826.     }
  827.   }
  828.   else {
  829.     if (comp < 4) {
  830.       /* luma */
  831.       mvx = MV[0][0][y][x];
  832.       mvy = MV[1][0][y][x];
  833.       BMVx = (bdx == 0 ? (trb-trd)* mvx/trd : trb * mvx/trd + bdx - mvx);
  834.       BMVy = (bdy == 0 ? (trb-trd)* mvy/trd : trb * mvy/trd + bdy - mvy);
  835.     }
  836.     else {
  837.       /* chroma */
  838.       mvx = MV[0][0][y][x];
  839.       mvy = MV[1][0][y][x];
  840.       xvec = (bdx == 0 ? (trb-trd)* mvx/trd : trb * mvx/trd + bdx - mvx);
  841.       yvec = (bdy == 0 ? (trb-trd)* mvy/trd : trb * mvy/trd + bdy - mvy);
  842.       xvec *= 4;
  843.       yvec *= 4;
  844.       
  845.       /* chroma rounding (table 16/H.263) */
  846.       BMVx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2);
  847.       BMVy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2);
  848.     }
  849.   }
  851.   cc = (comp<4) ? 0 : (comp&1)+1; /* color component index */
  853.   if (cc==0) {
  854.     /* luminance */
  855.     find_bidir_limits(BMVx,&xa,&xb,comp&1);
  856.     find_bidir_limits(BMVy,&ya,&yb,(comp&2)>>1);
  857.     bfr = bframe[0] +
  858.       coded_picture_width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
  859.     ffr = newframe[0] +
  860.       coded_picture_width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
  861.     ii = coded_picture_width;
  862.   }
  863.   else {
  864.     /* chrominance */
  865.     /* scale coordinates and vectors*/
  866.     bx >>= 1;
  867.     by >>= 1;
  869.     find_bidir_chroma_limits(BMVx,&xa,&xb);
  870.     find_bidir_chroma_limits(BMVy,&ya,&yb);
  872.     bfr = bframe[cc]      + chrom_width*(by+((comp&2)<<2)) + bx + (comp&8);
  873.     ffr = newframe[cc]    + chrom_width*(by+((comp&2)<<2)) + bx + (comp&8);
  874.     ii = chrom_width;
  875.   }
  877.   xint = BMVx>>1;
  878.   xhalf = BMVx - 2*xint;
  879.   yint = BMVy>>1;
  880.   yhalf = BMVy - 2*yint;
  882.   ffr += xint + (yint+ya)*ii;
  883.   bfr += ya*ii;
  884.   
  885.   if (!xhalf && !yhalf) {
  886.     for (j = ya; j < yb; j++) {
  887.       for (i = xa; i < xb; i++) {
  888.         pel = ffr[i];
  889.         bfr[i] = ((unsigned int)(pel + bfr[i]))>>1;
  890.       }
  891.       bfr += ii;
  892.       ffr += ii;
  893.     }
  894.   }
  895.   else if (xhalf && !yhalf) {
  896.     for (j = ya; j < yb; j++) {
  897.       for (i = xa; i < xb; i++) {
  898.         pel = ((unsigned int)(ffr[i]+ffr[i+1]+1))>>1;
  899.         bfr[i] = ((unsigned int)(pel + bfr[i]))>>1;
  900.       }
  901.       bfr += ii;
  902.       ffr += ii;
  903.     }
  904.   }
  905.   else if (!xhalf && yhalf) {
  906.     for (j = ya; j < yb; j++) {
  907.       for (i = xa; i < xb; i++) {
  908.         pel = ((unsigned int)(ffr[i]+ffr[ii+i]+1))>>1;
  909.         bfr[i] = ((unsigned int)(pel + bfr[i]))>>1;
  910.       }
  911.       bfr += ii;
  912.       ffr += ii;
  913.     }
  914.   }
  915.   else { /* if (xhalf && yhalf) */
  916.     for (j = ya; j < yb; j++) {
  917.       for (i = xa; i < xb; i++) {
  918.         pel = ((unsigned int)(ffr[i]+ffr[i+1]+ffr[ii+i]+ffr[ii+i+1]+2))>>2;
  919.         bfr[i] = ((unsigned int)(pel + bfr[i]))>>1;
  920.       }
  921.       bfr += ii;
  922.       ffr += ii;
  923.     }
  924.   }
  925.   return;
  926. }
  928. int motion_decode(int vec,int pmv)
  929. {
  930.   if (vec > 31) vec -= 64;
  931.   vec += pmv;
  932.   if (!long_vectors) {
  933.     if (vec > 31)
  934.       vec -= 64;
  935.     if (vec < -32)
  936.       vec += 64;
  937.   }
  938.   else {
  939.     if (pmv < -31 && vec < -63)
  940.       vec += 64;
  941.     if (pmv > 32 && vec > 63)
  942.       vec -= 64;
  943.   }
  944.   return vec;
  945. }
  948. int find_pmv(int x,int  y,int  block,int comp)
  949. {
  950.   int p1,p2,p3;
  951.   int xin1,xin2,xin3;
  952.   int yin1,yin2,yin3;
  953.   int vec1,vec2,vec3;
  954.   int l8,o8,or8;
  956.   x++;y++;
  958.   l8 = (modemap[y][x-1] == MODE_INTER4V ? 1 : 0);
  959.   o8 =  (modemap[y-1][x] == MODE_INTER4V ? 1 : 0);
  960.   or8 = (modemap[y-1][x+1] == MODE_INTER4V ? 1 : 0);
  962.   switch (block) {
  963.   case 0: 
  964.     vec1 = (l8 ? 2 : 0) ; yin1 = y  ; xin1 = x-1;
  965.     vec2 = (o8 ? 3 : 0) ; yin2 = y-1; xin2 = x;
  966.     vec3 = (or8? 3 : 0) ; yin3 = y-1; xin3 = x+1;
  967.     break;
  968.   case 1:
  969.     vec1 = (l8 ? 2 : 0) ; yin1 = y  ; xin1 = x-1;
  970.     vec2 = (o8 ? 3 : 0) ; yin2 = y-1; xin2 = x;
  971.     vec3 = (or8? 3 : 0) ; yin3 = y-1; xin3 = x+1;
  972.     break;
  973.   case 2:
  974.     vec1 = 1            ; yin1 = y  ; xin1 = x;
  975.     vec2 = (o8 ? 4 : 0) ; yin2 = y-1; xin2 = x;
  976.     vec3 = (or8? 3 : 0) ; yin3 = y-1; xin3 = x+1;
  977.     break;
  978.   case 3:
  979.     vec1 = (l8 ? 4 : 0) ; yin1 = y  ; xin1 = x-1;
  980.     vec2 = 1            ; yin2 = y  ; xin2 = x;
  981.     vec3 = 2            ; yin3 = y  ; xin3 = x;
  982.     break;
  983.   case 4:
  984.     vec1 = 3            ; yin1 = y  ; xin1 = x;
  985.     vec2 = 1            ; yin2 = y  ; xin2 = x;
  986.     vec3 = 2            ; yin3 = y  ; xin3 = x;
  987.     break;
  988.   default:
  989.     if(trace)
  990. fputs("Illegal block number in find_pmv (getpic.c)n",dlog);
  991.     return 1;
  992.     break;
  993.   }
  994.   p1 = MV[comp][vec1][yin1][xin1];
  995.   p2 = MV[comp][vec2][yin2][xin2];
  996.   p3 = MV[comp][vec3][yin3][xin3];
  998.   if (newgob && (block == 0 || block == 1 || block == 2))
  999.     p2 = NO_VEC;
  1001.   if (p2 == NO_VEC) { p2 = p3 = p1; }
  1003.   return p1+p2+p3 - mmax(p1,mmax(p2,p3)) - mmin(p1,mmin(p2,p3));
  1004. }
  1008. void find_bidir_limits(int vec, int *start, int *stop, int nhv)
  1009. {
  1010.   /* limits taken from C loop in section G5 in H.263 */
  1011.   *start = mmax(0,(-vec+1)/2 - nhv*8);
  1012.   *stop = mmin(7,15-(vec+1)/2 - nhv*8);
  1014.   (*stop)++; /* I use < and not <= in the loop */
  1015. }
  1017. void find_bidir_chroma_limits(int vec, int *start,int * stop)
  1018. {
  1020.   /* limits taken from C loop in section G5 in H.263 */
  1021.   *start = mmax(0,(-vec+1)/2);
  1022.   *stop = mmin(7,7-(vec+1)/2);
  1024.   (*stop)++; /* I use < and not <= in the loop */
  1025.   return;
  1026. }
  1028. void make_edge_image(unsigned char *src,unsigned char *dst,int width,int height,int edge)
  1029. {
  1030.   int i,j;
  1031.   unsigned char *p1,*p2,*p3,*p4;
  1032.   unsigned char *o1,*o2,*o3,*o4;
  1034.   /* center image */
  1035.   p1 = dst;
  1036.   o1 = src;
  1037.   for (j = 0; j < height;j++) {
  1038.     for (i = 0; i < width; i++) {
  1039.       *(p1 + i) = *(o1 + i);
  1040.     }
  1041.     p1 += width + (edge<<1);
  1042.     o1 += width;
  1043.   }
  1045.   /* left and right edges */
  1046.   p1 = dst-1;
  1047.   o1 = src;
  1048.   for (j = 0; j < height;j++) {
  1049.     for (i = 0; i < edge; i++) {
  1050.       *(p1 - i) = *o1;
  1051.       *(p1 + width + i + 1) = *(o1 + width - 1);
  1052.     }
  1053.     p1 += width + (edge<<1);
  1054.     o1 += width;
  1055.   }    
  1056.     
  1057.   /* top and bottom edges */
  1058.   p1 = dst;
  1059.   p2 = dst + (width + (edge<<1))*(height-1);
  1060.   o1 = src;
  1061.   o2 = src + width*(height-1);
  1062.   for (j = 0; j < edge;j++) {
  1063.     p1 = p1 - (width + (edge<<1));
  1064.     p2 = p2 + (width + (edge<<1));
  1065.     for (i = 0; i < width; i++) {
  1066.       *(p1 + i) = *(o1 + i);
  1067.       *(p2 + i) = *(o2 + i);
  1068.     }
  1069.   }    
  1071.   /* corners */
  1072.   p1 = dst - (width+(edge<<1)) - 1;
  1073.   p2 = p1 + width + 1;
  1074.   p3 = dst + (width+(edge<<1))*(height)-1;
  1075.   p4 = p3 + width + 1;
  1077.   o1 = src;
  1078.   o2 = o1 + width - 1;
  1079.   o3 = src + width*(height-1);
  1080.   o4 = o3 + width - 1;
  1081.   for (j = 0; j < edge; j++) {
  1082.     for (i = 0; i < edge; i++) {
  1083.       *(p1 - i) = *o1;
  1084.       *(p2 + i) = *o2;
  1085.       *(p3 - i) = *o3;
  1086.       *(p4 + i) = *o4; 
  1087.     }
  1088.     p1 = p1 - (width + (edge<<1));
  1089.     p2 = p2 - (width + (edge<<1));
  1090.     p3 = p3 + width + (edge<<1);
  1091.     p4 = p4 + width + (edge<<1);
  1092.   }
  1094. }
  1096.   
  1097. void interpolate_image(unsigned char *in, unsigned char *out,int  width,int height)
  1098. /* only used for displayed interpolated frames, not reconstructed ones */
  1099. {
  1101.   int x,xx,y,w2;
  1103.   unsigned char *pp,*ii;
  1105.   w2 = 2*width;
  1107.   /* Horizontally */
  1108.   pp = out;
  1109.   ii = in;
  1110.   for (y = 0; y < height-1; y++) {
  1111.     for (x = 0,xx=0; x < width-1; x++,xx+=2) {
  1112.       *(pp + xx) = *(ii + x);
  1113.       *(pp + xx+1) = ((unsigned int)(*(ii + x)  + *(ii + x + 1)))>>1;
  1114.       *(pp + w2 + xx) = ((unsigned int)(*(ii + x) + *(ii + x + width)))>>1;
  1115.       *(pp + w2 + xx+1) = ((unsigned int)(*(ii + x) + *(ii + x + 1) + 
  1116.            *(ii + x + width) + *(ii + x + width + 1)))>>2;
  1117.       
  1118.     }
  1119.     *(pp + w2 - 2) = *(ii + width - 1);
  1120.     *(pp + w2 - 1) = *(ii + width - 1);
  1121.     *(pp + w2 + w2 - 2) = *(ii + width + width - 1);
  1122.     *(pp + w2 + w2 - 1) = *(ii + width + width - 1);
  1123.     pp += w2<<1;
  1124.     ii += width;
  1125.   }
  1127.   /* last lines */
  1128.   for (x = 0,xx=0; x < width-1; x++,xx+=2) {
  1129.     *(pp+ xx) = *(ii + x);    
  1130.     *(pp+ xx+1) = ((unsigned int)(*(ii + x) + *(ii + x + 1) + 1))>>1;
  1131.     *(pp+ w2+ xx) = *(ii + x);    
  1132.     *(pp+ w2+ xx+1) = ((unsigned int)(*(ii + x) + *(ii + x + 1) + 1))>>1;
  1133.   }
  1134.   
  1135.   /* bottom right corner pels */
  1136.   *(pp + (width<<1) - 2) = *(ii + width -1);
  1137.   *(pp + (width<<1) - 1) = *(ii + width -1);
  1138.   *(pp + (width<<2) - 2) = *(ii + width -1);
  1139.   *(pp + (width<<2) - 1) = *(ii + width -1);
  1141.   return;
  1142. }
  1143.