b_frame.c

Mobile IP VCEG的信道模拟程序

	if (img->imod==INTRA_MB_NEW)
		intrapred_luma_2( img, currMB->intra_pred_modes[0]);

	for(j=0;j<MB_BLOCK_SIZE/BLOCK_SIZE;j++)
	{
		joff=j*4;
		j4=img->block_y+j;
		for(i=0;i<MB_BLOCK_SIZE/BLOCK_SIZE;i++)
		{
  		ioff=i*4;
			i4=img->block_x+i;
			if(img->imod==INTRA_MB_OLD)
			{
				if (intrapred(img,ioff,joff,i4,j4)==SEARCH_SYNC)  /* make 4x4 prediction block mpr from given prediction img->mb_mode */
				return SEARCH_SYNC;                   /* bit error */
			}

			////////////////////////////////////
			// Forward MC using img->fw_MV
			////////////////////////////////////
			else if(img->imod==B_Forward)
			{
				for(ii=0;ii<BLOCK_SIZE;ii++)
				{
					vec2_x=(i4*4+ii)*mv_mul;
					vec1_x=vec2_x+img->fw_mv[i4+BLOCK_SIZE][j4][0];
					for(jj=0;jj<MB_BLOCK_SIZE/BLOCK_SIZE;jj++)
					{
						vec2_y=(j4*4+jj)*mv_mul;
						vec1_y=vec2_y+img->fw_mv[i4+BLOCK_SIZE][j4][1];
						// direct interpolation:
						img->mpr[ii+ioff][jj+joff]=get_pixel(ref_frame_fw,vec1_x,vec1_y,img);
					}
				}
			}

			////////////////////////////////////
			// Backward MC using img->bw_MV
			////////////////////////////////////
			else if(img->imod==B_Backward)
			{
				for(ii=0;ii<BLOCK_SIZE;ii++)
				{
					vec2_x=(i4*4+ii)*mv_mul;
					vec1_x=vec2_x+img->bw_mv[i4+BLOCK_SIZE][j4][0];
					for(jj=0;jj<MB_BLOCK_SIZE/BLOCK_SIZE;jj++)
					{
						vec2_y=(j4*4+jj)*mv_mul;
						vec1_y=vec2_y+img->bw_mv[i4+BLOCK_SIZE][j4][1];
						// direct interpolation:
						img->mpr[ii+ioff][jj+joff]=get_pixel(ref_frame_bw,vec1_x,vec1_y,img);
					}
				}
			}

			////////////////////////////////////
			// Bidirect MC using img->fw_MV, bw_MV
			////////////////////////////////////
			else if(img->imod==B_Bidirect)
			{
				for(ii=0;ii<BLOCK_SIZE;ii++)
				{
					vec2_x=(i4*4+ii)*mv_mul;
					vec1_x=vec2_x+img->fw_mv[i4+BLOCK_SIZE][j4][0];
					vec1_xx=vec2_x+img->bw_mv[i4+BLOCK_SIZE][j4][0];
					for(jj=0;jj<MB_BLOCK_SIZE/BLOCK_SIZE;jj++)
					{
						vec2_y=(j4*4+jj)*mv_mul;
						vec1_y=vec2_y+img->fw_mv[i4+BLOCK_SIZE][j4][1];
						vec1_yy=vec2_y+img->bw_mv[i4+BLOCK_SIZE][j4][1];
						// direct interpolation:
						img->mpr[ii+ioff][jj+joff]=(int)((get_pixel(ref_frame_fw,vec1_x,vec1_y,img)+
              											  get_pixel(ref_frame_bw,vec1_xx,vec1_yy,img))/2.+.5);
					}
				}
			}

			////////////////////////////////////
			// Direct MC using img->mv
			////////////////////////////////////
			else if(img->imod==B_Direct)
			{
				// next P is intra mode
				if(refFrArr[j4][i4]==-1)
				{
					for(hv=0; hv<2; hv++) 
					{
						img->dfMV[i4+BLOCK_SIZE][j4][hv]=img->dbMV[i4+BLOCK_SIZE][j4][hv]=0;
					}
                    ref_frame = (img->number -1+ img->buf_cycle)% img->buf_cycle;
				}
				// next P is skip or inter mode
				else 
				{
#ifdef _ADAPT_LAST_GROUP_
				  refP_tr = last_P_no[refFrArr[j4][i4]];
#else
				  refP_tr = nextP_tr-((refFrArr[j4][i4]+1)*P_interval);
#endif
				  TRb = img->tr-refP_tr;
				  TRp = nextP_tr-refP_tr;

				  img->dfMV[i4+BLOCK_SIZE][j4][0]=TRb*img->mv[i4+BLOCK_SIZE][j4][0]/TRp;
				  img->dfMV[i4+BLOCK_SIZE][j4][1]=TRb*img->mv[i4+BLOCK_SIZE][j4][1]/TRp;
				  img->dbMV[i4+BLOCK_SIZE][j4][0]=(TRb-TRp)*img->mv[i4+BLOCK_SIZE][j4][0]/TRp;
				  img->dbMV[i4+BLOCK_SIZE][j4][1]=(TRb-TRp)*img->mv[i4+BLOCK_SIZE][j4][1]/TRp;
				  ref_frame=(img->number - 1 - refFrArr[j4][i4] + img->buf_cycle)%img->buf_cycle;
				}

				for(ii=0;ii<BLOCK_SIZE;ii++)
				{
					vec2_x=(i4*4+ii)*mv_mul;

					vec1_x=vec2_x+img->dfMV[i4+BLOCK_SIZE][j4][0];
					vec1_xx=vec2_x+img->dbMV[i4+BLOCK_SIZE][j4][0];				
					for(jj=0;jj<MB_BLOCK_SIZE/BLOCK_SIZE;jj++)
					{
						vec2_y=(j4*4+jj)*mv_mul;

						vec1_y=vec2_y+img->dfMV[i4+BLOCK_SIZE][j4][1];
						vec1_yy=vec2_y+img->dbMV[i4+BLOCK_SIZE][j4][1];
						// LG :  direct residual coding
						// Wedi: direct interpolation
						img->mpr[ii+ioff][jj+joff]= (int)((get_pixel(ref_frame,vec1_x,vec1_y,img)
                                             +get_pixel(ref_frame_bw,vec1_xx,vec1_yy,img))/2.+.5);
					}
				}
			}

			itrans(img,ioff,joff,i,j);      /* use DCT transform and make 4x4 block m7 from prediction block mpr */

			for(ii=0;ii<BLOCK_SIZE;ii++)
			{
				for(jj=0;jj<BLOCK_SIZE;jj++)
				{
					imgY[j4*BLOCK_SIZE+jj][i4*BLOCK_SIZE+ii]=img->m7[ii][jj]; /* contruct picture from 4x4 blocks*/
				}
			}
		}
	}



 
#if POS
	imgY[img->block_y*BLOCK_SIZE][img->block_x*BLOCK_SIZE]= color;
#endif

	/**********************************
	 *    chroma                      *
	 *********************************/
	for(uv=0;uv<2;uv++)
	{
		if (img->imod==INTRA_MB_OLD || img->imod==INTRA_MB_NEW)/* intra mode */
		{
			js0=0;
			js1=0;
			js2=0;
			js3=0;
			for(i=0;i<4;i++)
			{
				if(mb_available_up)
				{
					js0=js0+imgUV[uv][img->pix_c_y-1][img->pix_c_x+i];
					js1=js1+imgUV[uv][img->pix_c_y-1][img->pix_c_x+i+4];
				}
				if(mb_available_left)
				{
					js2=js2+imgUV[uv][img->pix_c_y+i][img->pix_c_x-1];
					js3=js3+imgUV[uv][img->pix_c_y+i+4][img->pix_c_x-1];
				}
			}
			if(mb_available_up && mb_available_left)
			{
				js[0][0]=(js0+js2+4)/8;
				js[1][0]=(js1+2)/4;
				js[0][1]=(js3+2)/4;
				js[1][1]=(js1+js3+4)/8;
			}
			if(mb_available_up && !mb_available_left)
			{
				js[0][0]=(js0+2)/4;
				js[1][0]=(js1+2)/4;
				js[0][1]=(js0+2)/4;
				js[1][1]=(js1+2)/4;
			}
			if(mb_available_left && !mb_available_up)
			{
				js[0][0]=(js2+2)/4;
				js[1][0]=(js2+2)/4;
				js[0][1]=(js3+2)/4;
				js[1][1]=(js3+2)/4;
			}
			if(!mb_available_up && !mb_available_left)
			{
				js[0][0]=128;
				js[1][0]=128;
				js[0][1]=128;
				js[1][1]=128;
			}
		}

		for (j=4;j<6;j++)
		{
			joff=(j-4)*4;
			j4=img->pix_c_y+joff;
			for(i=0;i<2;i++)
			{
				ioff=i*4;
				i4=img->pix_c_x+ioff;
				/* make pred */
				if(img->imod==INTRA_MB_OLD|| img->imod==INTRA_MB_NEW)/* intra */
				{
					for(ii=0;ii<4;ii++)
						for(jj=0;jj<4;jj++)
						{
							img->mpr[ii+ioff][jj+joff]=js[i][j-4];
						}
				}
				////////////////////////////////////
				// Forward Reconstruction
				////////////////////////////////////
				else if(img->imod==B_Forward)
				{
					for(jj=0;jj<4;jj++)
					{
						jf=(j4+jj)/2;
						for(ii=0;ii<4;ii++)
						{
							if1=(i4+ii)/2;
							i1=(img->pix_c_x+ii+ioff)*f1+img->fw_mv[if1+4][jf][0];
							j1=(img->pix_c_y+jj+joff)*f1+img->fw_mv[if1+4][jf][1];
#ifndef UMV
							ii0=i1/f1;
							jj0=j1/f1;
							ii1=(i1+f2)/f1;
							jj1=(j1+f2)/f1;
#endif
#ifdef UMV
							ii0=max (0, min (i1/f1, img->width_cr-1));
							jj0=max (0, min (j1/f1, img->height_cr-1));
							ii1=max (0, min ((i1+f2)/f1, img->width_cr-1));
							jj1=max (0, min ((j1+f2)/f1, img->height_cr-1));
#endif


							if1=(i1 & f2);
							jf1=(j1 & f2);
							if0=f1-if1;
							jf0=f1-jf1;
							img->mpr[ii+ioff][jj+joff]=(if0*jf0*mcef[ref_frame_fw][uv][jj0][ii0]+
							                            if1*jf0*mcef[ref_frame_fw][uv][jj0][ii1]+
							                            if0*jf1*mcef[ref_frame_fw][uv][jj1][ii0]+
							                            if1*jf1*mcef[ref_frame_fw][uv][jj1][ii1]+f4)/f3;
						}
					}
				}
				////////////////////////////////////
				// Backward Reconstruction
				////////////////////////////////////
				else if(img->imod==B_Backward)
				{
					for(jj=0;jj<4;jj++)
					{
						jf=(j4+jj)/2;
						for(ii=0;ii<4;ii++)
						{
							if1=(i4+ii)/2;
							i1=(img->pix_c_x+ii+ioff)*f1+img->bw_mv[if1+4][jf][0];
							j1=(img->pix_c_y+jj+joff)*f1+img->bw_mv[if1+4][jf][1];

#ifndef UMV
							ii0=i1/f1;
							jj0=j1/f1;
							ii1=(i1+f2)/f1;
							jj1=(j1+f2)/f1;
#endif
#ifdef UMV
							ii0=max (0, min (i1/f1, img->width_cr-1));
							jj0=max (0, min (j1/f1, img->height_cr-1));
							ii1=max (0, min ((i1+f2)/f1, img->width_cr-1));
							jj1=max (0, min ((j1+f2)/f1, img->height_cr-1));
#endif

							if1=(i1 & f2);
							jf1=(j1 & f2);
							if0=f1-if1;
							jf0=f1-jf1;

							img->mpr[ii+ioff][jj+joff]=(if0*jf0*mcef[ref_frame_bw][uv][jj0][ii0]+
							                            if1*jf0*mcef[ref_frame_bw][uv][jj0][ii1]+
							                            if0*jf1*mcef[ref_frame_bw][uv][jj1][ii0]+
							                            if1*jf1*mcef[ref_frame_bw][uv][jj1][ii1]+f4)/f3;
						}
					}
				}
				////////////////////////////////////
				// Bidirect Reconstruction
				////////////////////////////////////
				else if(img->imod==B_Bidirect)
				{
					for(jj=0;jj<4;jj++)
					{
						jf=(j4+jj)/2;
						for(ii=0;ii<4;ii++)
						{
							ifx=(i4+ii)/2;
							i1=(img->pix_c_x+ii+ioff)*f1+img->fw_mv[ifx+4][jf][0];
							j1=(img->pix_c_y+jj+joff)*f1+img->fw_mv[ifx+4][jf][1];
#ifndef UMV
							ii0=i1/f1;
							jj0=j1/f1;
							ii1=(i1+f2)/f1;
							jj1=(j1+f2)/f1;
#endif
#ifdef UMV
							ii0=max (0, min (i1/f1, img->width_cr-1));
							jj0=max (0, min (j1/f1, img->height_cr-1));
							ii1=max (0, min ((i1+f2)/f1, img->width_cr-1));
							jj1=max (0, min ((j1+f2)/f1, img->height_cr-1));
#endif
							if1=(i1 & f2);
							jf1=(j1 & f2);
							if0=f1-if1;
							jf0=f1-jf1;

							fw_pred=(if0*jf0*mcef[ref_frame_fw][uv][jj0][ii0]+
							         if1*jf0*mcef[ref_frame_fw][uv][jj0][ii1]+
							         if0*jf1*mcef[ref_frame_fw][uv][jj1][ii0]+
							         if1*jf1*mcef[ref_frame_fw][uv][jj1][ii1]+f4)/f3;

							i1=(img->pix_c_x+ii+ioff)*f1+img->bw_mv[ifx+4][jf][0];
							j1=(img->pix_c_y+jj+joff)*f1+img->bw_mv[ifx+4][jf][1];
#ifndef UMV
							ii0=i1/f1;
							jj0=j1/f1;
							ii1=(i1+f2)/f1;
							jj1=(j1+f2)/f1;
#endif
#ifdef UMV
							ii0=max (0, min (i1/f1, img->width_cr-1));
							jj0=max (0, min (j1/f1, img->height_cr-1));
							ii1=max (0, min ((i1+f2)/f1, img->width_cr-1));
							jj1=max (0, min ((j1+f2)/f1, img->height_cr-1));
#endif
							if1=(i1 & f2);
							jf1=(j1 & f2);
							if0=f1-if1;
							jf0=f1-jf1;
							bw_pred=(if0*jf0*mcef[ref_frame_bw][uv][jj0][ii0]+
							         if1*jf0*mcef[ref_frame_bw][uv][jj0][ii1]+
							         if0*jf1*mcef[ref_frame_bw][uv][jj1][ii0]+
							         if1*jf1*mcef[ref_frame_bw][uv][jj1][ii1]+f4)/f3;

							img->mpr[ii+ioff][jj+joff]=(int)((fw_pred+bw_pred)/2.+.5);
						}
					}
				}
				////////////////////////////////////
				// Direct Reconstruction
				////////////////////////////////////
				else if(img->imod==B_Direct)
				{
					for(jj=0;jj<4;jj++)
					{
						jf=(j4+jj)/2;
						for(ii=0;ii<4;ii++)
						{
							ifx=(i4+ii)/2;

							i1=(img->pix_c_x+ii+ioff)*f1+img->dfMV[ifx+4][jf][0];
							j1=(img->pix_c_y+jj+joff)*f1+img->dfMV[ifx+4][jf][1];

#ifndef UMV
							ii0=i1/f1;
							jj0=j1/f1;
							ii1=(i1+f2)/f1;
							jj1=(j1+f2)/f1;
#endif
#ifdef UMV
							ii0=max (0, min (i1/f1, img->width_cr-1));
							jj0=max (0, min (j1/f1, img->height_cr-1));
							ii1=max (0, min ((i1+f2)/f1, img->width_cr-1));
							jj1=max (0, min ((j1+f2)/f1, img->height_cr-1));
#endif
							if1=(i1 & f2);
							jf1=(j1 & f2);
							if0=f1-if1;
							jf0=f1-jf1;

							if(refFrArr[jf][ifx]==-1)
								ref_frame=(img->number-1)%img->buf_cycle;
							else 
      					        ref_frame=(img->number - 1 - refFrArr[jf][ifx] + img->buf_cycle)%img->buf_cycle;

							fw_pred=(if0*jf0*mcef[ref_frame][uv][jj0][ii0]+
							         if1*jf0*mcef[ref_frame][uv][jj0][ii1]+
							         if0*jf1*mcef[ref_frame][uv][jj1][ii0]+
							         if1*jf1*mcef[ref_frame][uv][jj1][ii1]+f4)/f3;


							i1=(img->pix_c_x+ii+ioff)*f1+img->dbMV[ifx+4][jf][0];
							j1=(img->pix_c_y+jj+joff)*f1+img->dbMV[ifx+4][jf][1];
#ifndef UMV
							ii0=i1/f1;
							jj0=j1/f1;
							ii1=(i1+f2)/f1;
							jj1=(j1+f2)/f1;
#endif
#ifdef UMV
							ii0=max (0, min (i1/f1, img->width_cr-1));
							jj0=max (0, min (j1/f1, img->height_cr-1));
							ii1=max (0, min ((i1+f2)/f1, img->width_cr-1));
							jj1=max (0, min ((j1+f2)/f1, img->height_cr-1));
#endif
							if1=(i1 & f2);
							jf1=(j1 & f2);
							if0=f1-if1;
							jf0=f1-jf1;

							bw_pred=(if0*jf0*mcef[ref_frame_bw][uv][jj0][ii0]+
							         if1*jf0*mcef[ref_frame_bw][uv][jj0][ii1]+
							         if0*jf1*mcef[ref_frame_bw][uv][jj1][ii0]+
							         if1*jf1*mcef[ref_frame_bw][uv][jj1][ii1]+f4)/f3;
							// LG : direct residual coding
							img->mpr[ii+ioff][jj+joff]=(int)((fw_pred+bw_pred)/2.+.5);
						}
					}
				}

				itrans(img,ioff,joff,2*uv+i,j);
				for(ii=0;ii<4;ii++)
					for(jj=0;jj<4;jj++)
					{
						imgUV[uv][j4+jj][i4+ii]=img->m7[ii][jj];
					}
			} // for(i=0;i<2;i++)
		} // for (j=4;j<6;j++)
	} // for(uv=0;uv<2;uv++)


#if POS
	imgUV[0][img->pix_c_y][img->pix_c_x]= color;
	imgUV[1][img->pix_c_y][img->pix_c_x]= color;
#endif

    SetLoopfilterStrength_B(img);
	return DECODING_OK;
}