b_frame.c

Mobile IP VCEG的信道模拟程序

/****************************************************************
 *
 *  File b_frame.c :	B picture Decoding 
 *
 *	Main contributor and Contact Information
 *
 *      Byeong-Moon Jeon			<[e-mail]>
 *      Yoon-Seong Soh				<[e-mail]>
 *      LG Electronics Inc., Digital Media Research Lab.
 *      16 Woomyeon-Dong, Seocho-Gu, Seoul, 137-724, Korea
 *
 *  Changes:
 *      Thomas Wedi					<[e-mail]>
 *
 *****************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#include "global.h"
#include "b_frame.h"
#include "elements.h"

#define POS 0


/************************************************************************
*
*  Name :       SetLoopfilterStrength_B()
*
*  Description: Set the filter strength for a macroblock of a B-frame
*
************************************************************************/
void SetLoopfilterStrength_B(struct img_par *img)
{
	int i,j;
	int ii,jj;
	int i3,j3,mvDiffX,mvDiffY;
	

    if (img->imod == INTRA_MB_OLD || img->imod == INTRA_MB_NEW)
    {
      for (i=0;i<4;i++)
		  {
			  ii=img->block_x+i;
			  i3=ii/2;
			  for (j=0;j<4;j++)
			  {
				  jj=img->block_y+j;
				  j3=jj/2;
				  loopb[ii+1][jj+1]=3;
				  loopb[ii  ][jj+1]=max(loopb[ii  ][jj+1],2);
				  loopb[ii+1][jj  ]=max(loopb[ii+1][jj  ],2);
				  loopb[ii+2][jj+1]=max(loopb[ii+2][jj+1],2);
				  loopb[ii+1][jj+2]=max(loopb[ii+1][jj+2],2);

				  loopc[i3+1][j3+1]=2;
				  loopc[i3  ][j3+1]=max(loopc[i3  ][j3+1],1);
				  loopc[i3+1][j3  ]=max(loopc[i3+1][j3  ],1);
				  loopc[i3+2][j3+1]=max(loopc[i3+2][j3+1],1);
				  loopc[i3+1][j3+2]=max(loopc[i3+1][j3+2],1);
			  }
		  }
    }


    if (img->imod==B_Forward || img->imod==B_Bidirect) /* inter one direction */
    {
        for (i=0;i<4;i++)
        {
            ii=img->block_x+i;
            i3=ii/2;
            for (j=0;j<4;j++)
            {
                jj=img->block_y+j;
                j3=jj/2;
        
                mvDiffX = img->fw_mv[ii+4][jj][0] - img->fw_mv[ii-1+4][jj][0];
                mvDiffY = img->fw_mv[ii+4][jj][1] - img->fw_mv[ii-1+4][jj][1];

                if((mvDiffX*mvDiffX >= 16 || mvDiffY*mvDiffY >= 16) && ii > 0)
                { 
                    loopb[ii  ][jj+1]=max(loopb[ii  ][jj+1],1);
                    loopb[ii+1][jj+1]=max(loopb[ii+1][jj+1],1); 
                    loopc[i3  ][j3+1]=max(loopc[i3  ][j3+1],1);
                    loopc[i3+1][j3+1]=max(loopc[i3+1][j3+1],1);
                }

                if (jj >0)
                {
                    mvDiffX = img->fw_mv[ii+4][jj][0] - img->fw_mv[ii+4][jj-1][0];
                    mvDiffY = img->fw_mv[ii+4][jj][1] - img->fw_mv[ii+4][jj-1][1];

                    if((mvDiffX*mvDiffX >= 16 || mvDiffY*mvDiffY >= 16) && jj > 0)
                    {
                        loopb[ii+1][jj  ]=max(loopb[ii+1][jj  ],1);
                        loopb[ii+1][jj+1]=max(loopb[ii+1][jj+1],1);
                        loopc[i3+1][j3  ]=max(loopc[i3+1][j3  ],1);
                        loopc[i3+1][j3+1]=max(loopc[i3+1][j3+1],1);
                    }
                }
            }
        }
    }



    if(img->imod==B_Backward || img->imod==B_Bidirect) /* inter other direction */
    {
        for (i=0;i<4;i++)
        {
            ii=img->block_x+i;
            i3=ii/2;
            for (j=0;j<4;j++)
            {
                jj=img->block_y+j;
                j3=jj/2;
        
                mvDiffX = img->bw_mv[ii+4][jj][0] - img->bw_mv[ii-1+4][jj][0];
                mvDiffY = img->bw_mv[ii+4][jj][1] - img->bw_mv[ii-1+4][jj][1];

                if((mvDiffX*mvDiffX >= 16 || mvDiffY*mvDiffY >= 16) && ii > 0)
                { 
                    loopb[ii  ][jj+1]=max(loopb[ii  ][jj+1],1);
                    loopb[ii+1][jj+1]=max(loopb[ii+1][jj+1],1); 
                    loopc[i3  ][j3+1]=max(loopc[i3  ][j3+1],1);
                    loopc[i3+1][j3+1]=max(loopc[i3+1][j3+1],1);                    
                }
                    
                if (jj > 0)
                {
                    mvDiffX = img->bw_mv[ii+4][jj][0] - img->bw_mv[ii+4][jj-1][0];
                    mvDiffY = img->bw_mv[ii+4][jj][1] - img->bw_mv[ii+4][jj-1][1];

                    if((mvDiffX*mvDiffX >= 16 || mvDiffY*mvDiffY >= 16) && jj > 0)
                    {
                        loopb[ii+1][jj  ]=max(loopb[ii+1][jj  ],1);
                        loopb[ii+1][jj+1]=max(loopb[ii+1][jj+1],1);
                        loopc[i3+1][j3  ]=max(loopc[i3+1][j3  ],1);
                        loopc[i3+1][j3+1]=max(loopc[i3+1][j3+1],1);
                    }
                }
            }
        }
    }

    if(img->imod==B_Direct)
    {
        for(j=0;j<MB_BLOCK_SIZE/BLOCK_SIZE;j++)
	    {
		    jj=img->block_y+j;
		    for(i=0;i<MB_BLOCK_SIZE/BLOCK_SIZE;i++)
		    {
			    ii=img->block_x+i;
        	    i3=ii/2;
				j3=jj/2;

				mvDiffX = img->dfMV[ii+4][jj][0] - img->dfMV[ii-1+4][jj][0];
				mvDiffY = img->dfMV[ii+4][jj][1] - img->dfMV[ii-1+4][jj][1];
				if((mvDiffX*mvDiffX >= 16 || mvDiffY*mvDiffY >= 16) && ii > 0)
				{ 
					loopb[ii  ][jj+1]=max(loopb[ii  ][jj+1],1);
					loopb[ii+1][jj+1]=max(loopb[ii+1][jj+1],1); 
					loopc[i3  ][j3+1]=max(loopc[i3  ][j3+1],1);
					loopc[i3+1][j3+1]=max(loopc[i3+1][j3+1],1);                    
				}

			    if (jj > 0)
				{

					mvDiffX = img->dfMV[ii+4][jj][0] - img->dfMV[ii+4][jj-1][0];
					mvDiffY = img->dfMV[ii+4][jj][1] - img->dfMV[ii+4][jj-1][1];
					if((mvDiffX*mvDiffX >= 16 || mvDiffY*mvDiffY >= 16) && jj > 0)
					{
						loopb[ii+1][jj  ]=max(loopb[ii+1][jj  ],1);
						loopb[ii+1][jj+1]=max(loopb[ii+1][jj+1],1);
						loopc[i3+1][j3  ]=max(loopc[i3+1][j3  ],1);
						loopc[i3+1][j3+1]=max(loopc[i3+1][j3+1],1);
					}
				}		

				mvDiffX = img->dbMV[ii+4][jj][0] - img->dbMV[ii-1+4][jj][0];
				mvDiffY = img->dbMV[ii+4][jj][1] - img->dbMV[ii-1+4][jj][1];
				if((mvDiffX*mvDiffX >= 16 || mvDiffY*mvDiffY >= 16) && ii > 0)
				{ 
					loopb[ii  ][jj+1]=max(loopb[ii  ][jj+1],1);
					loopb[ii+1][jj+1]=max(loopb[ii+1][jj+1],1); 
					loopc[i3  ][j3+1]=max(loopc[i3  ][j3+1],1);
					loopc[i3+1][j3+1]=max(loopc[i3+1][j3+1],1);                    
		        }
				if (jj > 0)
				{

					mvDiffX = img->dbMV[ii+4][jj][0] - img->dbMV[ii+4][jj-1][0];
					mvDiffY = img->dbMV[ii+4][jj][1] - img->dbMV[ii+4][jj-1][1];
					if((mvDiffX*mvDiffX >= 16 || mvDiffY*mvDiffY >= 16) && jj > 0)
					{
						loopb[ii+1][jj  ]=max(loopb[ii+1][jj  ],1);
						loopb[ii+1][jj+1]=max(loopb[ii+1][jj+1],1);
						loopc[i3+1][j3  ]=max(loopc[i3+1][j3  ],1);
						loopc[i3+1][j3+1]=max(loopc[i3+1][j3+1],1);
					}
				}
            }
        }
    }
}

/*!
 *	\fn		write_prev_Pframe()
 *	\brief	Write previous decoded P frame to output file
 */
void write_prev_Pframe(struct img_par *img,	FILE *p_out)
{
	int i,j;

	for(i=0;i<img->height;i++)
		for(j=0;j<img->width;j++)
			fputc(imgY_prev[i][j],p_out);

	for(i=0;i<img->height_cr;i++)
		for(j=0;j<img->width_cr;j++)
			fputc(imgUV_prev[0][i][j],p_out);

	for(i=0;i<img->height_cr;i++)
		for(j=0;j<img->width_cr;j++)
			fputc(imgUV_prev[1][i][j],p_out);
}



/*!
 *	\fn		copy_Pframe()
 *	\brief	Copy decoded P frame to temporary image array
 */
void copy_Pframe(struct img_par *img,	int postfilter)
{
  int i,j;

  /*
   * the mmin, mmax macros are taken out, because it makes no sense due to limited range of data type
   */

  if(postfilter)
    {
      for(i=0;i<img->height;i++)
	for(j=0;j<img->width;j++)
	  {
	    //imgY_prev[i][j] = (byte)mmin(MAX_PIX_VAL,mmax(MIN_PIX_VAL,imgY_pf[i][j]));
	    imgY_prev[i][j] = imgY_pf[i][j];
	  }
      for(i=0;i<img->height_cr;i++)
	for(j=0;j<img->width_cr;j++)
	  {
	    //imgUV_prev[0][i][j] = (byte)mmin(MAX_PIX_VAL,mmax(MIN_PIX_VAL,imgUV_pf[0][i][j]));
	    imgUV_prev[0][i][j] = imgUV_pf[0][i][j];
	  }
      for(i=0;i<img->height_cr;i++)
	for(j=0;j<img->width_cr;j++)
	  {
	    //imgUV_prev[1][i][j] = (byte)mmin(MAX_PIX_VAL,mmax(MIN_PIX_VAL,imgUV_pf[1][i][j]));
	    imgUV_prev[1][i][j] = imgUV_pf[1][i][j];
	  }
    }
  else
    {
      for(i=0;i<img->height;i++)
	for(j=0;j<img->width;j++)
	  {
	    //imgY_prev[i][j] = (byte)mmin(MAX_PIX_VAL,mmax(MIN_PIX_VAL,imgY[i][j]));
	    imgY_prev[i][j] = imgY[i][j];
	  }
      for(i=0;i<img->height_cr;i++)
	for(j=0;j<img->width_cr;j++)
	  {
	    //imgUV_prev[0][i][j] = (byte)mmin(MAX_PIX_VAL,mmax(MIN_PIX_VAL,imgUV[0][i][j]));
	    imgUV_prev[0][i][j] = imgUV[0][i][j];
	  }
      for(i=0;i<img->height_cr;i++)
	for(j=0;j<img->width_cr;j++)
	  {
	    //imgUV_prev[1][i][j] = (byte)mmin(MAX_PIX_VAL,mmax(MIN_PIX_VAL,imgUV[1][i][j]));
	    imgUV_prev[1][i][j] = imgUV[1][i][j];
	  }
    }
}




/************************************************************************
*
*  Name :       init_macroblock_Bframe()
*
*  Description: init macroblock B frames
*
************************************************************************/
void init_macroblock_Bframe(struct img_par *img)
{
	int i,j;
	int fw_predframe_no=0;
    Macroblock *currMB = &img->mb_data[img->current_mb_nr];

    currMB->ref_frame = img->frame_cycle;
    currMB->predframe_no = 0;


	// reset vectors and pred. modes
	for (i=0;i<BLOCK_SIZE;i++)
	{                           
		for(j=0;j<BLOCK_SIZE;j++)
		{
			img->fw_mv[img->block_x+i+4][img->block_y+j][0]=img->fw_mv[img->block_x+i+4][img->block_y+j][1]=0;
			img->bw_mv[img->block_x+i+4][img->block_y+j][0]=img->bw_mv[img->block_x+i+4][img->block_y+j][1]=0;
			img->dfMV[img->block_x+i+4][img->block_y+j][0]=img->dfMV[img->block_x+i+4][img->block_y+j][1]=0;
			img->dbMV[img->block_x+i+4][img->block_y+j][0]=img->dbMV[img->block_x+i+4][img->block_y+j][1]=0;
			img->ipredmode[img->block_x+i+1][img->block_y+j+1] = 0;
		}
	}

	// Set the reference frame information for motion vector prediction 
	if (img->imod==INTRA_MB_OLD || img->imod==INTRA_MB_NEW)
	{
		for (j = 0;j < BLOCK_SIZE;j++)
		{
			for (i = 0;i < BLOCK_SIZE;i++)
			{
				img->fw_refFrArr[img->block_y+j][img->block_x+i] = 
				img->bw_refFrArr[img->block_y+j][img->block_x+i] = -1;
			}
		}
	}
	else if(img->imod == B_Forward)
	{
		for (j = 0;j < BLOCK_SIZE;j++)
		{
			for (i = 0;i < BLOCK_SIZE;i++)
			{
				img->fw_refFrArr[img->block_y+j][img->block_x+i] = fw_predframe_no; // previous P
				img->bw_refFrArr[img->block_y+j][img->block_x+i] = -1;
			}
		}
	}
	else if(img->imod == B_Backward)
	{
		for (j = 0;j < BLOCK_SIZE;j++)
		{
			for (i = 0;i < BLOCK_SIZE;i++)
			{
				img->fw_refFrArr[img->block_y+j][img->block_x+i] = -1;
				img->bw_refFrArr[img->block_y+j][img->block_x+i] = 0; // next P
			}
		}
	}
	else if(img->imod == B_Bidirect)
	{
		for (j = 0;j < BLOCK_SIZE;j++)
		{
			for (i = 0;i < BLOCK_SIZE;i++)
			{
				img->fw_refFrArr[img->block_y+j][img->block_x+i] = fw_predframe_no; // previous P
				img->bw_refFrArr[img->block_y+j][img->block_x+i] = 0; // next P
			}
		}
	}
	else if(img->imod == B_Direct)
	{
		for (j = 0;j < BLOCK_SIZE;j++)
		{
			for (i = 0;i < BLOCK_SIZE;i++)
			{
				img->fw_refFrArr[img->block_y+j][img->block_x+i] = -1; // previous P
				img->bw_refFrArr[img->block_y+j][img->block_x+i] = -1; // next P
			}
		}
	}
}

/************************************************************************
*
*  Name :       readMotionInfoFromNAL_Bframe()
*
*  Description: Get for a given MB of a B picture the reference frame 
*			    parameter and the motion vectors from the NAL 
*
************************************************************************/
void readMotionInfoFromNAL_Bframe(struct img_par *img,struct inp_par *inp)
{
	int i,j,ii,jj,ie,j4,i4,k,pred_vec=0;
	int vec;
	int ref_frame;
	int fw_predframe_no=0, bw_predframe_no;     /* frame number which current MB is predicted from */
	int fw_blocktype=0, bw_blocktype=0, blocktype=0;
    int l,m;

	/* keep track of neighbouring macroblocks available for prediction */
	int mb_nr = img->current_mb_nr;
	int mb_width = img->width/16;
	int mb_available_up = (img->mb_y == 0) ? 0 : (img->slice_numbers[mb_nr] == img->slice_numbers[mb_nr-mb_width]);
	int mb_available_left = (img->mb_x == 0) ? 0 : (img->slice_numbers[mb_nr] == img->slice_numbers[mb_nr-1]);
	int mb_available_upleft  = (img->mb_x == 0 || img->mb_y == 0) ? 0 : (img->slice_numbers[mb_nr] == img->slice_numbers[mb_nr-mb_width-1]);
	int mb_available_upright = (img->mb_x >= mb_width-1 || img->mb_y == 0) ? 0 : (img->slice_numbers[mb_nr] == img->slice_numbers[mb_nr-mb_width+1]);

	/* keep track of neighbouring blocks available for motion vector prediction */
	int block_available_up, block_available_left, block_available_upright, block_available_upleft;
	int mv_a, mv_b, mv_c, mv_d;
	int mvPredType, rFrameL, rFrameU, rFrameUR;

	SyntaxElement THEcurrSE;
	SyntaxElement *currSE = &THEcurrSE;

    Macroblock *currMB = &img->mb_data[img->current_mb_nr];
	Slice *currSlice = img->currentSlice;
	DataPartition *dp;
	int *partMap = assignSE2partition[inp->partition_mode];

	bw_predframe_no=0;


	///////////////////////////////////////////////////////////////
	// find fw_predfame_no 
	///////////////////////////////////////////////////////////////
	if(img->imod==B_Forward || img->imod==B_Bidirect)
	{
		if(img->type==B_IMG_MULT)
		{

#if TRACE
			sprintf(currSE->tracestring, "B_fw_Reference frame no  ");
#endif				
			currSE->type = SE_REFFRAME;
			dp = &(currSlice->partArr[partMap[SE_BFRAME]]);

			if (inp->symbol_mode == UVLC)
				currSE->mapping = linfo;
			else
		    currSE->reading = readRefFrameFromBuffer_CABAC;

			dp->readSyntaxElement(	currSE, img, inp, dp);
			fw_predframe_no = currSE->value1;


			if (fw_predframe_no > img->buf_cycle)
			{
				set_ec_flag(SE_REFFRAME);
				fw_predframe_no = 1;
			}

			ref_frame=(img->frame_cycle+img->buf_cycle-fw_predframe_no) % img->buf_cycle;

			if (ref_frame > img->number)