cr_now += Global::cpels;    cr_prev += Global::cpels;#endif  }  return;}/********************************************************************** * *	Name:		InterpolateImage *	Description:    Interpolates a complete image for easier half *                      pel prediction *	
 *	Input:	        pointer to image structure
 *	Returns:        pointer to interpolated image
 *	Side effects:   allocates memory to interpolated image
 * *	Date: 950207 	Author: Karl.Lillevold@nta.no *            960207    Author: Roalt aalmoes ***********************************************************************/void InterpolateImage(unsigned int *image, unsigned int *ipol_image, 			       int width, int height){  /* If anyone has better ideas to optimize this code, be my guest!     note: assembly or some advanced bitshifts routine might do the trick...*/  register unsigned int *ii, *oo,     *ii_new,     *ii_new_line2,     *oo_prev,     *oo_prev_line2;    register int i,j;  register unsigned int pix1,pix2,pix3,pix4;  ii = ipol_image;  oo = image;  oo_prev = image;  oo_prev_line2 = image + width;  ii_new = ipol_image;  ii_new_line2 = ipol_image + (width<<1);  /* main image */  for (j = 0; j < height-1; j++) {				/* get Pix1 and Pix3, because they are				   not known the first time */    pix1 = *oo_prev;    pix3 = *oo_prev_line2;    for (i = 0; i  < width-1; i++) {				/* Pix1 Pix2				   Pix3 Pix4 */      /* Pix2 and Pix4 are used here for first time */      pix2 = *(oo_prev + 1);      pix4 = *(oo_prev_line2 + 1);      *(ii_new) = pix1;					/* X.							   ..*/      *(ii_new + 1) = (pix1 + pix2 + 1)>>1; 		/* *X							   .. */      *ii_new_line2 = (pix1 + pix3 + 1)>>1; 		/* *.						           X. */      *(ii_new_line2 + 1) = (pix1 + pix2 + pix3 + pix4 + 2)>>2;            oo_prev++; oo_prev_line2++; ii_new += 2; ii_new_line2 += 2;            pix1 = pix2;      pix3 = pix4;		/* Pix1 Pix2=Pix1' Pix2' */				/* Pix3 Pix4=Pix3' Pix4' */    }        /* One but last column */    *(ii_new++) = pix1;	    *(ii_new++) = pix3;        /* Last column -On the Edge - */    *(ii_new_line2++) = (pix1 + pix3 + 1 ) >>1;    *(ii_new_line2++) = (pix1 + pix3 + 1 ) >>1;    ii_new += (width<<1);	/* ii_new now on old position ii_new_line2,so				   one interpolated screen line must be added*/    ii_new_line2 += (width<<1);	/* In fact, ii_new_line here has same value				   as ii_new */    oo_prev += 1; /* Remember, loop is done one time less! */    oo_prev_line2 += 1;      }  /* last lines */  pix1 = *oo_prev;  for (i = 0; i < width-1; i++) {    pix2 = *(oo_prev + 1);    *ii_new = *ii_new_line2 = pix1;    *(ii_new + 1) = *(ii_new_line2 + 1) = (pix1 + pix2 + 1)>>1;    ii_new += 2;    ii_new_line2 += 2;    oo_prev += 1;    pix1 = pix2;			/* Pix1 Pix2=Pix1' Pix2' */  }    /* bottom right corner Global::pels */  *(ii_new) = pix1;  *(ii_new + 1) = pix1;  *(ii_new_line2) = pix1;  *(ii_new_line2+1) = pix1;  return;}/********************************************************************** * *	Name:		FullMotionEstimatePicture *	Description:    Finds integer and half pel motion estimation *	 *	Input:	       current image, previous image, interpolated *                     reconstructed previous image, seek_dist, *                     motion vector array *	Returns:        *	Side effects: allocates memory for MV structure * *	Date: 960418	Author: Roatlt * ***********************************************************************/void FullMotionEstimatePicture(unsigned int *curr, unsigned int *prev, 			       unsigned int *prev_ipol, int seek_dist, 			       MotionVector *MV_ptr,			       int advanced_method,			       int *EncodeThisBlock){  int i,j;  MotionVector *current_MV;  for(j = 0; j < Global::mbr; j++) {   for(i = 0; i < Global::mbc; i++) {     current_MV = MV_ptr + j*Global::mbc + i;     if(advanced_method && !*(EncodeThisBlock + j*Global::mbc + i) ) {	       current_MV->x = current_MV->y = current_MV->x_half = 	 current_MV->y_half = 0;       current_MV->Mode = MODE_SKIP;      } else {			/* EncodeThisBlock */       	FullMotionEstimation(curr, prev_ipol, seek_dist, current_MV, 			     i*MB_SIZE, j*MB_SIZE);		current_MV->Mode = ChooseMode(curr,i*MB_SIZE,j*MB_SIZE,				      current_MV->min_error);	if(current_MV->Mode == MODE_INTRA) 	  ZeroVec(current_MV);      }    }  }}void CodeInterH263(CParam *params, Bits *bits){  MotionVector *MV;	  MotionVector ZERO = {0,0,0,0,0};  MB_Structure *recon_data_P;   MB_Structure *diff;  int *qcoeff_P;  unsigned int *new_recon=NULL;  unsigned int *prev_recon;  int Mode;    int CBP, CBPB=0;  int newgob;  int i,j;  Global::search_p_frames = params->search_method;  MV =(struct motionvector*) malloc(sizeof(MotionVector)*Global::mbc*Global::mbr);  new_recon =(unsigned int*) malloc(Global::sizeof_frame);  prev_recon = params->recon;  /* buffer control vars */    ZeroBits(bits);  /* Interpolate luminance from reconstr. picture */  InterpolateImage(prev_recon,params->interpolated_lum,Global::pels,Global::lines);  FullMotionEstimatePicture( params->data,			     prev_recon, 			    params->interpolated_lum, 			    params->half_pixel_searchwindow,MV,			    params->advanced_method, params->EncodeThisBlock);    /* Calculate MV for each MB */  /* ENCODE TO H.263 STREAM */    for ( j = 0; j < Global::mbr; j++) {    newgob = 0;    if (j == 0) {      Global::pic->QUANT = params->Q_inter;      Global::pic->picture_coding_type = PCT_INTER;      bits->header += CountBitsPicture(Global::pic);    }    else if (Global::pic->use_gobsync && j%Global::pic->use_gobsync == 0) {      bits->header += CountBitsSlice(j,params->Q_inter); /* insert gob sync */      newgob = 1;    }    for ( i = 0; i < Global::mbc; i++) {      /* This means: For every macroblock (i,j) do ... */      /* We have 4 different situations:
         1) !EncodeThisBlock: this means that the
	    macroblock in not encoded
         2) EncodeThisBlock: This means that the MB is 	    encoded by using the predicted motion vector.         3) EncodeThisBlock: However, the approx of the	    motion vector was so bad, that INTRA coding is more	    appropiate here ...	 4) EncodeThisBlock: The approx is so good that            the coefficients are all zero (after quant.) and are not		    send.      */	/* This means: For every macroblock (i,j) do ... */        Global::pic->DQUANT = 0;	Mode = MV[j*Global::mbc + i].Mode;	/* Determine position of MB */	Global::pic->MB = i + j * Global::mbc;	if(Mode == MODE_SKIP) {	  /* SITUATION 1 */	  Mode = MODE_INTRA;	/* This might be done "better" in the future*/	  MV[j*Global::mbc + i].Mode = Mode;	  ZeroVec(&(MV[j*Global::mbc + i])); 	  CBP = CBPB = 0; 	  /* Now send code for "skip this MB" */	  CountBitsMB(Mode,1,CBP,CBPB,Global::pic,bits);   	  ReconCopyImage(i,j,new_recon,prev_recon);	} else { /* Encode this block */	  if (Mode == MODE_INTER) {	    /* SITUATION 2 */	    /* Predict P-MB */	    diff = Predict_P(params->data,
			     prev_recon,
			     params->interpolated_lum,i*MB_SIZE,
			     j*MB_SIZE,MV);	  } else {	    /* SITUATION 3 */	    /* Create MB_Structure diff that contains coefficients that must be	       sent to the other end */		    diff = (MB_Structure *)malloc(sizeof(MB_Structure));	    FillLumBlock(i*MB_SIZE, j*MB_SIZE, params->data, diff); 	    /* Copy curr->lum to diff for macroblock (i,j) */	    FillChromBlock(i*MB_SIZE, j*MB_SIZE, params->data, diff);	    /* Equiv. for curr->Cb and curr->Cr */	  }	  /* P or INTRA Macroblock */	  /*  diff -> DCT -> QUANTIZED -> qcoeff_P */	  qcoeff_P = MB_EncodeAndFindCBP(diff, params->Q_inter, Mode,&CBP);		  /*   CBP = FindCBP(qcoeff_P, Mode, 64); -> Not required anymore */	  /* All encoded, now calculate decoded image	     for comparison in next frame */	  /* Do DECODING */	  if (CBP == 0 && (Mode == MODE_INTER) ) {				/* SITUATION 4 */	    ZeroMBlock(diff);	  } else {	    /*  qcoeff_P -> Dequantized -> IDCT -> diff */	    MB_Decode(qcoeff_P, diff, params->Q_inter, Mode);	  }	  recon_data_P = MB_Recon_P(prev_recon, 				    params->interpolated_lum,diff, 				    i*MB_SIZE,j*MB_SIZE,MV);	  Clip(recon_data_P);	  free(diff);	  /* Do bitstream encoding */		  if((CBP==0) && (EqualVec(&(MV[j*Global::mbc+i]),&ZERO)) &&	     (Mode == MODE_INTER) ) {	    /* Skipped MB : both CBP and CBPB are zero, 16x16 vector is zero,	       PB delta vector is zero and Mode = MODE_INTER */	    /* Now send code for "skip this MB" */	    CountBitsMB(Mode,1,CBP,CBPB,Global::pic,bits);	  } else {	    /* Normal MB */	    /* VLC */	    CountBitsMB(Mode,0,CBP,CBPB,Global::pic,bits);	    if (Mode == MODE_INTER) {	      bits->no_inter++;	      CountBitsVectors(MV, bits, i, j, Mode, newgob, Global::pic);
	    } else {
	      /* MODE_INTRA */	      bits->no_intra++;	    }	    /* Only encode coefficient if they are nonzero or Mode is INTRA*/
	    
	    if (CBP || Mode == MODE_INTRA)
	      CountBitsCoeff(qcoeff_P, Mode, CBP, bits, 64);	   	  } /* End skip/not skip macroblock encoding */	  ReconImage(i,j,recon_data_P,new_recon);	  free(recon_data_P);	  free(qcoeff_P);		}      /* End advanced */           } /* End for i */  } /* End for j */  Global::pic->QP_mean = params->Q_inter;    free(prev_recon);  params->recon = new_recon;  AddBitsPicture(bits);  free(MV);  return;}