macroblock.c

davinci avs.......................................................

      refframe = refFrArr        [pgImage->block4_y+j0][pgImage->block4_x+i0];
      
      for (j=j0; j<j0+step_v0; j+=step_v)
        for (i=i0; i<i0+step_h0; i+=step_h)
        {
          j4 = pgImage->block4_y+j;
          i4 = pgImage->block4_x+i;
          
          // first make mv-prediction
          SetMotionVectorPredictor (pmv, pmv+1, refframe, i, j, 4*step_h, 4*step_v, 0);//Lou 1016
          
          for (k=0; k < 2; k++) 
          {
#if TRACE
            snprintf(currSE.tracestring, TRACESTRING_SIZE, "FMVD (pred %d)",pmv[k]);
#endif
            currSE.value2 =  k ; // identifies the component; only used for context determination
            read_UVLC(&currSE);
             
            
            if ( pgImage->half_pixel_mv_flag == 0 )  // 1/4 accuracy
            {
              curr_mvd = currSE.value1; 
            }
            else
            {
              curr_mvd = (currSE.value1 << 1); 
            }
            
            
            vec=(curr_mvd)+pmv[k];           /* find motion vector */
            
            for(ii=0;ii<step_h;ii++)
              for(jj=0;jj<step_v;jj++)
              {
                pgImage->mv[i4+ii+BLOCK_SIZE][j4+jj][k]=vec;
                
                /* bistream conformance check */
                if (stat_parameter->min_mv[k] >= pgImage->mv[i4+ii+BLOCK_SIZE][j4+jj][k])
                  stat_parameter->min_mv[k] = pgImage->mv[i4+ii+BLOCK_SIZE][j4+jj][k];

                if (stat_parameter->max_mv[k] <= pgImage->mv[i4+ii+BLOCK_SIZE][j4+jj][k])
                  stat_parameter->max_mv[k] = pgImage->mv[i4+ii+BLOCK_SIZE][j4+jj][k];
              }
              
              /* store (oversampled) mvd */
              for (l=0; l < step_v; l++) 
                for (m=0; m < step_h; m++)  
                  pgcurrMB->mvd[j+l][i+m][k] =  curr_mvd;
            
     
            

          }
        }
    }		
}

/*! 
 *************************************************************************************
 * \brief 
 *     Get coded block pattern and coefficients (run/level) from the NAL
 *************************************************************************************
 */
void read_luma_chroma_coeffs()
{
  int mb_nr = pgImage->current_mb_nr; //GBimg->current_mb_nr;
  int b8, b4;
   
  // luma coefficients
  for(b8=0; b8<4; b8++)
  {
    if (pgcurrMB->cbp&(1<<b8))
    {
      for(b4=0; b4<4; b4++)
      {
        if (pgcurrMB->cbp_4x4[b8]&(1<<b4)) // dongjie //WJP FOR CBP4X4
          readLumaCoeff_4x4_UVLC(b8, b4);      //qwang 2004-3-16
      }
    }
  }        
  
  /* chroma coeffients */
  if ((pgcurrMB->cbp>>4)&1)
  {
    for(b4=0; b4<4; b4++)
    {
      if (pgcurrMB->cbp_4x4[4]&(1<<b4)) // dongjie //WJP FOR CBP4X4
        readChromaCoeff_4x4_UVLC(4, b4);       //qwang 2004-3-16
    }
  }
  
  if ((pgcurrMB->cbp>>4)&2)
  {
    // dongjie read cbp_4x4 from bitstream
    //pgcurrMB->cbp_4x4 = u_v(4, "cbp_4x4");//WJP FOR CBP4X4
    // end
    for(b4=0; b4<4; b4++)
    {
      if (pgcurrMB->cbp_4x4[5]&(1<<b4)) // dongjie
        readChromaCoeff_4x4_UVLC(5, b4);       //qwang 2004-3-16
    }
  }
}

/*! 
 *************************************************************************************
 * \brief 
 *     read macroblock type
 *************************************************************************************
 */
void read_mb_type()
{
	 int len;
   int inf;
 
   if(pgImage->type == I_IMG) 
   {
     pgcurrMB->mb_type = I4MB;
     pgcurrMB->I_MODE = u_v(1,"Intra Mb mode");//WJP FOR I_DIRECT
   } 
   else 
   {
     //skip run coding
     if(pgImage->skip_mode_flag)
     {
       
       if(pgImage->cod_counter == -1)  //
       {			 
         len =  GetVLCSymbol (&inf);
         mapping_ue(len,inf,&pgImage->cod_counter);	 
#if TRACE
         tracebits("mb_skip_run", len, inf, pgImage->cod_counter);
#endif
       }
       
       if (pgImage->cod_counter == 0)
       {
         len =  GetVLCSymbol (&inf);
         mapping_ue(len,inf,&pgcurrMB->mb_type);
         
#if TRACE
       tracebits("MB Type", len, inf, pgcurrMB->mb_type);
#endif
         pgcurrMB->mb_type++;
         pgImage->cod_counter--;
         
       } 
       else
       {
         pgImage->cod_counter--;
         pgcurrMB->mb_type = 0;  // !! skip mode shenyanfei 
       }
     }
     else
     {
       len =  GetVLCSymbol (&inf);
       mapping_ue(len,inf,&pgcurrMB->mb_type);
       
#if TRACE
       tracebits("mb_type", len, inf, pgcurrMB->mb_type);
#endif
     }
     
     //====== READ 8x8 SUB-PARTITION MODES (modes of 8x8 blocks) and Intra VBST block modes ======
     if (IS_P8x8 (pgcurrMB))
     {
       pgcurrMB->mb_type=P8x8;
     }

     else if(pgcurrMB->mb_type>=I4MB) /* I4MB = 5 */
     {
       pgcurrMB->cbp=NCBP[pgcurrMB->mb_type-5][0];
       pgcurrMB->mb_type = I4MB;
     }  //JX 05-4-1
   }

  /* bistream conformance check -- zhan ma */
  stat_parameter->mb_type[pgcurrMB->mb_type] = 1;
}

/*! 
 *************************************************************************************
 * \brief 
 *     read_CBP_dquant
 *************************************************************************************
 */
void read_CBP_dquant()
{
  int len;
  int inf;
  int i;
		
  if(pgImage->type==I_IMG) // qhg
  {
    len =  GetVLCSymbol (&inf);
    read_cbp_intra(len,inf,&pgcurrMB->cbp);	 
#if TRACE
    tracebits("Coded_Block_Pattern", len, inf, pgcurrMB->cbp);
#endif
  }
  else if(IS_INTER(pgcurrMB)) // qhg
  {
    len =  GetVLCSymbol (&inf);
    read_cbp_inter(len,inf,&pgcurrMB->cbp);	 
#if TRACE
    tracebits("Coded_Block_Pattern", len, inf, pgcurrMB->cbp);
#endif
  }
  
  //WJP FOR CBP4X4
  for(i=0;i<6;i++)
  {
    if(pgcurrMB->cbp & (1<<i))
      pgcurrMB->cbp_4x4[i] = u_v(4, "cbp_4x4");
  }
  //WJP END
  
  // Delta quant only if nonzero coeffs
  if ((!fixed_slice_qp_flag) && pgcurrMB->cbp !=0)
  {
    len =  GetVLCSymbol (&inf);
    mapping_se(len,inf,&pgcurrMB->delta_quant);	 

#if TRACE
    tracebits("Delta quant", len, inf, pgcurrMB->delta_quant);
#endif
    pgcurrMB->qp= (previous_qp-MIN_QP+pgcurrMB->delta_quant+(MAX_QP-MIN_QP+1))% (MAX_QP-MIN_QP+1)+MIN_QP; // zhan ma 0714
  }
  else
    pgcurrMB->delta_quant = 0;

}

/*! 
 *************************************************************************************
 * \brief :  
 *    macorblock decoding process including 
 *************************************************************************************
 */					 
int decode_one_macroblock()    
{ 
  int bx,by;
  int tmp_block[4][4];
  int i=0,j=0,ii=0,jj=0,i1=0,j1=0,j4=0,i4=0;
  int js0=0,js1=0,js2=0,js3=0,jf=0;
  int uv;
  int vec1_x=0,vec1_y=0,vec2_x=0,vec2_y=0;
  int k;
  int ioff,joff;
  int tmp;
  int b8, b4;   // needed for ABT
  int ii0,jj0,ii1,jj1,if1,jf1,if0,jf0;
  int mv_mul,f1,f2,f3,f4;
  int chroma_offset =0;


  const byte decode_block_scan[16] = {0,1,4,5,2,3,6,7,8,9,12,13,10,11,14,15};  /* block relative coordinate mapping */
  
  int refframe; // = pgcurrMB->ref_frame;
  //int fw_ref_idx;
  int*** mv_array;
  //int  b8_s=0,b8_e=4,incr_y=1,off_y=0,even_y=4,add_y=0;
  
  int mb_nr             = pgImage->current_mb_nr;
  int mb_width          = pgImage->width/MB_BLOCK_SIZE;
  int mb_available_up   = (pgImage->mb_y == 0) ? 0 : (mb_data[mb_nr].slice_nr == mb_data[mb_nr-mb_width].slice_nr);
  int mb_available_left = (pgImage->mb_x == 0) ? 0 : (mb_data[mb_nr].slice_nr == mb_data[mb_nr-1].slice_nr);
  
#ifdef _ISOLATED_REGION_
  if (iREGenable)
  {
    if (pgImage->type == P_IMG)
    {
      if (mb_available_up != 0)
      {
        if (iREGmap[pgImage->mb_y - 1][pgImage->mb_x] != 2)
          mb_available_up = 0;       
      }
      
      if (mb_available_left != 0)
      {
        if (iREGmap[pgImage->mb_y][pgImage->mb_x - 1] != 2)
          mb_available_left = 0;
      }
    }
  }
#endif // _ISOLATED_REGION_
  
  mv_mul=4;
  f1=8;
  f2=7;
  
  f3=f1*f1;
  f4=f3/2;
  
  //f4=f4;
  // luma decoding **************************************************
  for (b8=0; b8<BLOCK_SIZE; b8++)
  {
	  for (b4 = 0; b4 < BLOCK_SIZE; b4 ++)  //zhangnan
	  {
		  k = b8*4 + b4;
		  i = (decode_block_scan[k] & 3);
		  j = ((decode_block_scan[k] >> 2) & 3);
		  
		  ioff=i*4;
		  i4=pgImage->block4_x+i;
		  
		  joff=j*4;
		  j4=pgImage->block4_y+j;   /* locate the 4x4 block position of a macroblock */
		  
      /*Get Predictive Sample*/
		  if (pgcurrMB->mb_type != I4MB)
		  {//===== FORWARD PREDICTION =====
			  refframe = refFrArr[j4][i4];
			  //fw_ref_idx = refframe;
			  mv_array = pgImage->mv;
			  
			  vec1_x = i4*4*mv_mul + mv_array[i4+BLOCK_SIZE][j4][0];     /* obtain absolute MV coordinate */
			  vec1_y = j4*4*mv_mul + mv_array[i4+BLOCK_SIZE][j4][1];

	     //fprintf(p_trace,"@INTER_MV (x,y) (%d,%d)\n" , vec1_x,vec1_y); MAZHAN
			//--- INTER PREDICTION ---
			//Get the block from reference frame with MVP
				get_block(vec1_x, vec1_y, tmp_block,reference_frame[refframe][0]);
			  
			  for(ii=0;ii<BLOCK_SIZE;ii++)
				  for(jj=0;jj<BLOCK_SIZE;jj++) 
				  {
					  pgcurrMB->pred_sample[b8][b4][ii][jj] = tmp_block[ii][jj]; //vld
				  }
		  }
		  else
		  {			
			  //--- INTRA PREDICTION ---
			  tmp = intrapred(b8, b4, ioff, joff, i4, j4);
			  
			  if ( tmp == SEARCH_SYNC)  /* make 4x4 prediction block mpr from given prediction pgImage->mb_mode */
				  return SEARCH_SYNC;      
		  }
		  
		  Get_residual(b8,b4);
      /* inverse transform */
			Dequant_B4(pgcurrMB->qp, b8, b4);  //zhangnan
			Inv_Transform_B4 (b8,b4);
			Recon_B4(b8, b4);
	  } //!< end of b4-loop
  }

  
  // chroma decoding *******************************************************
    if(IS_INTRA(pgcurrMB))
    {
      for (b4=0;b4<4;b4++)
      {
        intrapred_chroma_4x4(pgImage->mb_x,pgImage->mb_y,b4,pgcurrMB->c_ipred_mode);
        bx = (b4 &1)<<2;
        by = (b4>>1)<<2;
        for (uv=0; uv<2;uv++)
        {
          Get_residual(4+uv,b4);
          /* inverse transform */
          Dequant_B4(pgcurrMB->qp, 4+uv, b4);
          Inv_Transform_B4 (4+uv,b4);
          Recon_B4(4+uv, b4);
        }
      }

    }
    else
    { //--- FORWARD PREDICTION ---
        for(uv =0;uv<2;uv++)
        {
            for (j=4;j<6;j++)
            {
                joff = (j-4)*4;
                j4 = pgImage->pix_c_y + joff;
                for (i=0;i<2;i++)
                {
                    ioff = i*4;
                    i4 = pgImage->pix_c_x + ioff;
                    mv_array = pgImage->mv;
                    for(jj=0;jj<4;jj++)
                    {
                        jf=(j4+jj)/2;
                        for(ii=0;ii<4;ii++)
                        {
                            if1=(i4+ii)/2;
                            refframe = refFrArr[jf][if1];
                           // fw_ref_idx = refFrArr[jf][if1];
                            chroma_offset = 0;
                            i1=(pgImage->pix_c_x+ii+ioff)*f1+mv_array[if1+4][jf][0];
                            j1=(pgImage->pix_c_y+jj+joff)*f1+mv_array[if1+4][jf][1];
                            j1 += chroma_offset;
                            ii0=max (0, min (i1/f1, pgImage->width_cr-1));
                            jj0=max (0, min (j1/f1, pgImage->height_cr-1));
                            ii1=max (0, min ((i1+f2)/f1, pgImage->width_cr-1));
                            jj1=max (0, min ((j1+f2)/f1, pgImage->height_cr-1));				
                            if1=(i1 & f2);
                            jf1=(j1 & f2);
                            if0=f1-if1;
                            jf0=f1-jf1;
                            pgcurrMB->pred_sample[4+uv][(j-4)*2+i][ii][jj]=
                                (if0*jf0*reference_frame[refframe][uv+1][jj0][ii0]
                                +if1*jf0*reference_frame[refframe][uv+1][jj0][ii1]
                                +if0*jf1*reference_frame[refframe][uv+1][jj1][ii0]
                                +if1*jf1*reference_frame[refframe][uv+1][jj1][ii1]+f4)/f3;
                        } //end for ii
                    }// end for jj
                } // end for i
            }// end for j
            for(b4=0; b4<4; b4++)
            {
                Get_residual(4+uv,b4);
                /* inverse transform */
                Dequant_B4(pgcurrMB->qp, 4+uv, b4);
                Inv_Transform_B4 (4+uv,b4);
                Recon_B4(4+uv, b4);
            }

        }// end for uv
    } // end for   if(IS_INTRA(pgcurrMB))
  
   
#if TRACE
  trace_mb_data(pgcurrMB);
#endif

  return 0;
}