getpic.c

h.263+ vc++商业源代码

	    }
	    offset = k ? (((k-1)&2)<<2) : 0;
	    if ((ypos<<4) + (mvy/2) + offset < 0 ||
		(ypos<<4) + (mvy/2) + offset > (mb_height<<4) - bsize) {
	       fault = 1;
	    }
	  }
	  if( xpos < -1 ) xpos = -1 ;
	  if( ypos < -1 ) ypos = -1 ;
	  if( xpos >  MBC_MAX ) xpos = MBC_MAX ;
	  if( ypos >= MBR_MAX ) ypos = MBR_MAX-1 ;
	  dMV[0][k][ypos+1][xpos+1] = mvx;
	  dMV[1][k][ypos+1][xpos+1] = mvy;
	}

	/* PB frame delta vectors */

	if (pb_frame) {
	  if (MODB == PBMODE_MVDB || MODB == PBMODE_CBPB_MVDB) {
	    if (syntax_arith_coding) {
	      mvdbx_index = decode_a_symbol(cumf_MVD);
  		  if(mvdbx_index<0)mvdbx_index=0;
 		  if(mvdbx_index>=64)mvdbx_index=63;
	      mvdbx = mvdtab[mvdbx_index];
	      
	      mvdby_index = decode_a_symbol(cumf_MVD);
  		  if(mvdby_index<0)mvdby_index=0;
		  if(mvdby_index>=64)mvdby_index=63;
	      mvdby = mvdtab[mvdby_index];
	    }
	    else {
	      mvdbx = getTMNMV();
	      mvdby = getTMNMV();
	    }


	    mvdbx = motion_decode(mvdbx, 0);
	    mvdby = motion_decode(mvdby, 0);
	    /* This will not work if the PB deltas are so large they
	       require the second colums of the motion vector VLC
	       table to be used.  To fix this it is necessary to
	       calculate the MV predictor for the PB delta: TRB*MV/TRD
	       here, and use this as the second parameter to
	       motion_decode(). The B vector itself will then be
	       returned from motion_decode(). This will have to be
	       changed to the PB delta again, since it is the PB delta
	       which is used later in this program. I don't think PB
	       deltas outside the range mentioned above is useful, but
	       you never know... */

	    
	  }
	  else {
	    mvdbx = 0; 
	    mvdby = 0;
	  }
	}
      }

      if (fault) goto resync;

    }
    else { /* COD == 1 --> skipped MB */
      if (MBA>=MBAmax)
	return; /* all macroblocks decoded */
      if (!syntax_arith_coding)
	if (pict_type == PCT_INTER)
	  flushbits(1);

      Mode = MODE_INTER;
      
      /* Reset CBP */
      CBP = CBPB = 0;

      /* reset motion vectors */
	  if( xpos < -1 ) xpos = -1 ;
	  if( ypos < -1 ) ypos = -1 ;
	  if( xpos >  MBC_MAX ) xpos = MBC_MAX ;
	  if( ypos >= MBR_MAX ) ypos = MBR_MAX-1 ;
      dMV[0][0][ypos+1][xpos+1] = 0;
      dMV[1][0][ypos+1][xpos+1] = 0;
      mvdbx = 0;
      mvdby = 0;
    }

    /* Store Mode*/
  if( xpos < -1 ) xpos = -1 ;
  if( ypos < -1 ) ypos = -1 ;
  if( xpos >  MBC_MAX ) xpos = MBC_MAX ;
  if( ypos >= MBR_MAX ) ypos = MBR_MAX-1 ;

    modemap[ypos+1][xpos+1] = Mode;

    if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) 
      if (!pb_frame)
	dMV[0][0][ypos+1][xpos+1]=dMV[1][0][ypos+1][xpos+1] = 0;


  reconstruct_mb:

    /* pixel coordinates of top left corner of current macroblock */
    /* one delayed because of OBMC */
    if (xpos > 0) {
      bx = 16*(xpos-1);
      by = 16*ypos;
    }
    else {
      bx = coded_picture_width-16;
      by = 16*(ypos-1);
    }

    if (MBA > 0) {

      Mode = modemap[by/16+1][bx/16+1];

      /* forward motion compensation for B-frame */
      if (pb_frame)
	reconstruct(bx,by,0,pmvdbx,pmvdby);
      
      /* motion compensation for P-frame */
      if (Mode == MODE_INTER || Mode == MODE_INTER_Q || Mode == MODE_INTER4V)
	reconstruct(bx,by,1,0,0);

      /* copy or add block data into P-picture */
      for (comp=0; comp<blk_cnt; comp++) {
	/* inverse DCT */
	if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) {
	    didct(ld->block[comp]);
	  addblock(comp,bx,by,0);
	}
	else if ( (pCBP & (1<<(blk_cnt-1-comp))) ) {
	  /* No need to to do this for blocks with no coeffs */
	    didct(ld->block[comp]);
	  addblock(comp,bx,by,1);
	}
      }
      
      
      if (pb_frame) {
	/* add block data into B-picture */
	for (comp = 6; comp<blk_cnt+6; comp++) {
	  if (!pCOD || adv_pred_mode)
	    reconblock_b(comp-6,bx,by,Mode,pmvdbx,pmvdby);
	  if ( (pCBPB & (1<<(blk_cnt-1-comp%6))) ) {
	      didct(ld->block[comp]);
	    addblock(comp,bx,by,1);
	  }
	}
      }
      
    } /* end if (MBA > 0) */

    if (!COD) {
	  if( xpos < -1 ) xpos = -1 ;
	  if( ypos < -1 ) ypos = -1 ;
	  if( xpos >  MBC_MAX ) xpos = MBC_MAX ;
	  if( ypos >= MBR_MAX ) ypos = MBR_MAX-1 ;


      Mode = modemap[ypos+1][xpos+1];

      /* decode blocks */
      for (comp=0; comp<blk_cnt; comp++) {

		  clearblock(comp);
		  if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) { /* Intra */
			 bp = ld->block[comp];
			if(syntax_arith_coding) {
				INTRADC_index = decode_a_symbol(cumf_INTRADC);
				if(INTRADC_index <0)INTRADC_index =0;
				if(INTRADC_index >=254)INTRADC_index =253;
				bp[0] = intradctab[INTRADC_index];
			}
			else 
				bp[0] = getbits(8);

			if (bp[0] == 128)
				fault = 1 ;
		    if (bp[0] == 255)  /* Spec. in H.26P, not in TMN4 */
				bp[0] = 128;
			 bp[0] *= 8; /* Iquant */
			 if ( (CBP & (1<<(blk_cnt-1-comp))) ) {
				if (!syntax_arith_coding)
				  getblock(comp,0);
				else 
				  get_sac_block(comp,0);
			 }
		  }
		  else { /* Inter */
			if ( (CBP & (1<<(blk_cnt-1-comp))) ) {
				if (!syntax_arith_coding)
					getblock(comp,1);
				else
					get_sac_block(comp,1);
			}	
		  }
		if (fault) 	goto resync;
      }

      /* Decode B blocks */
      if (pb_frame) {
		for (comp=6; comp<blk_cnt+6; comp++) {
		  clearblock(comp);
		  if ( (CBPB & (1<<(blk_cnt-1-comp%6))) ) {
			if (!syntax_arith_coding)
			  getblock(comp,1);
			else
			  get_sac_block(comp,1);
		  }
		  if (fault)  goto resync;
		}
      }
	  
    }

    /* advance to next macroblock */
    MBA++;

    pCBP = CBP; pCBPB = CBPB; pCOD = COD;
    pmvdbx = mvdbx; pmvdby = mvdby;
    fflush(stdout);

    if (MBA >= MBAmax && !last_done) {
      COD = 1;
      xpos = 0;
      ypos++;
      last_done = 1;
      goto reconstruct_mb;
    }

  }
}

/* set block to zero */

static void clearblock(comp)
int comp;
{
  int *bp;
  int i;
  if(comp < 0) comp = 0 ;		// deng : should comment it ??
  if(comp >= 12 ) comp = 11 ;	// deng : should comment it ??
  	
  bp = (int *)ld->block[comp];

  for (i=0; i<8; i++)
  {
    bp[0] = bp[1] = bp[2] = bp[3] = 0;
    bp += 4;
  }
}


/* move/add 8x8-Block from block[comp] to refframe or bframe */

// deng 
static void ___addblock(comp,bx,by,addflag)
int comp,bx,by,addflag;
{
  int cc,i, iincr, P = 1;
  unsigned char *rfp;
  int index = 0 ;
  short *bp;
  if(comp < 0) comp = 0 ;
  if(comp >= 12 ) comp = 11 ;
  
  bp = ld->block[comp];

  if (comp >= 6) {
    /* This is a component for B-frame forward prediction */
    P = 0;
    addflag = 1;
    comp -= 6;
  }

  cc = (comp<4) ? 0 : (comp&1)+1; /* color component index */

  if (cc==0) {
    /* luminance */
    
    /* frame DCT coding */
    if (P)
      rfp = newframe[0]
	+ coded_picture_width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
    else
      rfp = bframe[0]
	+ coded_picture_width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
    iincr = coded_picture_width;
  }
  else {
    /* chrominance */

    /* scale coordinates */
    bx >>= 1;
    by >>= 1;
    /* frame DCT coding */
    if (P)
      rfp = newframe[cc] + chrom_width*by + bx;
    else
      rfp = bframe[cc] + chrom_width*by + bx;
    iincr = chrom_width;
  }


  if (addflag) {
    for (i=0; i<8; i++) {
	  index =bp[0]+rfp[0] ;
	  if(index < -384 ) index = -384;
      if(index >= 640) index = 639 ; 
	  rfp[0] = clp[index];
	  index =bp[1]+rfp[1] ;
	  if(index < -384 ) index = -384;
      if(index >= 640) index = 639 ; 

     rfp[1] = clp[index];
	  index =bp[2]+rfp[2] ;
	  if(index < -384 ) index = -384;
     if(index >= 640) index = 639 ; 

      rfp[2] = clp[index];
	  index =bp[3]+rfp[3] ;
	  if(index < -384 ) index = -384;
      if(index >= 640) index = 639 ; 
      
	  rfp[3] = clp[index];
	  index =bp[4]+rfp[4] ;
	  if(index < -384 ) index = -384;
      if(index >= 640) index = 639 ; 
	  
	  rfp[4] = clp[index];
	  index =bp[5]+rfp[5] ;
	  if(index < -384 ) index = -384;
      if(index >= 640) index = 639 ; 
	  
	  rfp[5] = clp[index];
	  index =bp[6]+rfp[6] ;
	  if(index < -384 ) index = -384;
      if(index >= 640) index = 639 ; 
	  
	  rfp[6] = clp[index];
	  index =bp[7]+rfp[7] ;
	  if(index < -384 ) index = -384;
      if(index >= 640) index = 639 ; 
	  
	  rfp[7] = clp[index];
      bp += 8;
      rfp+= iincr;
    }
  }
  else  {
    for (i=0; i<8; i++) {
	  index =bp[0] ;
	  if(index < -384 ) index = -384;
      if(index >= 640) index = 639 ; 
      
      rfp[0] = clp[index];
	  index =bp[1] ;
	  if(index < -384 ) index = -384;
      if(index >= 640) index = 639 ; 
	  
	  rfp[1] = clp[index];
	  index =bp[2] ;
	  if(index < -384 ) index = -384;
      if(index >= 640) index = 639 ; 
	  
	  rfp[2] = clp[index];
	  index =bp[3] ;
	  if(index < -384 ) index = -384;
      if(index >= 640) index = 639 ; 
	  
	  rfp[3] = clp[index];
	  index =bp[4] ;
	  if(index < -384 ) index = -384;
      if(index >= 640) index = 639 ; 
	  
	  rfp[4] = clp[index];
	  index =bp[5] ;
	  if(index < -384 ) index = -384;
      if(index >= 640) index = 639 ; 
	  
	  rfp[5] = clp[index];
	  index =bp[6] ;
	  if(index < -384 ) index = -384;
      if(index >= 640) index = 639 ; 
	  
	  rfp[6] = clp[index];
	  index =bp[7] ;
	  if(index < -384 ) index = -384;
     if(index >= 640) index = 639 ; 
	  
	  rfp[7] = clp[index];
      bp += 8;
      rfp += iincr;
    }
  }
}
// deng: modify
static void addblock(comp,bx,by,addflag)
int comp,bx,by,addflag;
{
  int cc,i, iincr, P = 1;
  unsigned char *rfp;
  short *bp;

  bp = ld->block[comp];

  if (comp >= 6) {
    /* This is a component for B-frame forward prediction */
    P = 0;
    addflag = 1;
    comp -= 6;
  }

  cc = (comp<4) ? 0 : (comp&1)+1; /* color component index */

  if (cc==0) {
    /* luminance */
    
    /* frame DCT coding */
    if (P)
      rfp = newframe[0]
        + coded_picture_width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
    else
      rfp = bframe[0]
        + coded_picture_width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
    iincr = coded_picture_width;
  }
  else {
    /* chrominance */