block.c

avs源代码

          
          if(icoef == 0) break;
          
          if(symbol2D>=CODE2D_ESCAPE_SYMBOL)   
          {
			  // changed by dj
			  currSE->type = SE_LUM_AC_INTER;
			  currSE->golomb_grad = 1;  
			  currSE->golomb_maxlevels = 11; 
			  escape_level_diff = abs(level)-((run>MaxRun[0][tablenum])?1:RefAbsLevel[tablenum][run]);
			  currSE->value1 = escape_level_diff;
			  
			  writeSyntaxElement_GOLOMB(currSE,currBitStream);
			  bitCount[BITS_COEFF_Y_MB]+=currSE->len;
			  no_bits+=currSE->len;
			  currSE++;// proceed to next SE
			  currMB->currSEnr++;
			  // end 
          }

          if(abs(level) > incVlc_intra[tablenum])   //qwang 11.29
          {
              if(abs(level) <= 2)
                tablenum = abs(level);
              else if(abs(level) <= 4)
                tablenum = 3;
              else if(abs(level) <= 7) 
                tablenum = 4;
              else if(abs(level) <= 10)
                tablenum = 5;
              else
                tablenum = 6;
          }
        }
      }
	  else //!intra
    {
      tablenum = 0;
      for(icoef; icoef>=0; icoef--)
      {
        if(icoef == 0)   //EOB
        {
          level = 0;
          run   = 0;
        }
        else
        {
          level = ACLevel[icoef-1];
          run   = ACRun[icoef-1];
        }
        
        symbol2D=CODE2D_ESCAPE_SYMBOL;        //symbol for out-of-table
        if(level>-27 && level<27 && run<26)
        {
          if(tablenum == 0)
            //symbol2D = AVS_2DVLC_INTER[tablenum][run][abs(level)-1];
            symbol2D = AVS_2DVLC_table_inter[tablenum][run][abs(level)-1];     //qwang 11.29
          else
            //symbol2D = AVS_2DVLC_INTER[tablenum][run][abs(level)];
            symbol2D = AVS_2DVLC_table_inter[tablenum][run][abs(level)];       //qwang 11.29
          if(symbol2D >= 0 && level < 0)
            symbol2D++;
          if(symbol2D < 0)
//	      symbol2D = (CODE2D_ESCAPE_SYMBOL + (run<<1) + ((level>0)?0:1)); // added by dj
              symbol2D = (CODE2D_ESCAPE_SYMBOL + (run<<1) + ((level>0)?1:0)); //jlzheng 7.20
		}
		// added by dj
		else
		{
//			symbol2D = (CODE2D_ESCAPE_SYMBOL + (run<<1) + ((level>0)?0:1));
			symbol2D = (CODE2D_ESCAPE_SYMBOL + (run<<1) + ((level>0)?1:0)); //jlzheng 7.20
		}
		//end
        
        currSE->type = SE_LUM_AC_INTER;
        currSE->value1=symbol2D;
        currSE->value2=0;

        currSE->golomb_grad = VLC_Golomb_Order[1][tablenum][0];         //qwang 11.29
        currSE->golomb_maxlevels = VLC_Golomb_Order[1][tablenum][1];    //qwang 11.29

        writeSyntaxElement_GOLOMB(currSE,currBitStream);
        bitCount[BITS_COEFF_Y_MB]+=currSE->len;
        no_bits+=currSE->len;
        currSE++;// proceed to next SE
        currMB->currSEnr++;
        
        if(icoef == 0) break;
        
        if(symbol2D>=CODE2D_ESCAPE_SYMBOL)   
        {
			// changed by dj
            currSE->type = SE_LUM_AC_INTER;
            currSE->golomb_grad = 0;  
            currSE->golomb_maxlevels = 11; 
            escape_level_diff = abs(level)-((run>MaxRun[1][tablenum])?1:RefAbsLevel[tablenum+7][run]);
            currSE->value1 = escape_level_diff;
            
            writeSyntaxElement_GOLOMB(currSE,currBitStream);
            bitCount[BITS_COEFF_Y_MB]+=currSE->len;
            no_bits+=currSE->len;
            currSE++;// proceed to next SE
            currMB->currSEnr++;
			// end 
        }

        if(abs(level) > incVlc_inter[tablenum])   //qwang 11.29
        {
            if(abs(level) <= 3)
              tablenum = abs(level);
            else if(abs(level) <= 6)
              tablenum = 4;
            else if(abs(level) <= 9) 
              tablenum = 5;
            else
              tablenum = 6;
        }
      }
      
    }// inter

    }//loop for iblk
  }//if ( cbp & (1<<b8) )
	
  return no_bits;
}

/*
*************************************************************************
* Function:Write chroma coefficients of one 8x8 block
* Input:
* Output:
* Return: 
* Attention:
*************************************************************************
*/


int writeChromaCoeffAVS_B8(int b8,int intra)
{
  int no_bits        = 0;
  int mb_nr          = img->current_mb_nr;
  Macroblock *currMB = &img->mb_data[mb_nr];
  const int cbp      = currMB->cbp;
  int *bitCount      = currMB->bitcounter;
  SyntaxElement *currSE = &img->MB_SyntaxElements[currMB->currSEnr];
  const char (*AVS_2DVLC_table_chroma)[26][27];   //qwang 11.29

  int inumblk;                    /* number of blocks per CBP*/
  int inumcoeff;                  /* number of coeffs per block */
  int iblk;                       /* current block */
  int icoef;                      /* current coefficient */
  int ipos;                       /* current position in cof_AVS */
  int run, level;
  int i,j;
  
  int b4;
  int* ACLevel;
  int* ACRun;

  int tablenum;   //add by qwang
  //int incVlc_chroma[] = {0,1,2,4,3000};   //add by qwang
  static const int incVlc_chroma[5] = { 0,1,2,4,3000};   //qwang 11.29

  int symbol2D;
  int escape_level_diff; // added by dj
	
  static const int blk_table[4] = {0,-1,-1,-1};
  static const int blkmode2ctx [4] = {LUMA_8x8, LUMA_8x4, LUMA_4x8, LUMA_4x4};
	
  inumblk   = 1;
  inumcoeff = 65; // all positions + EOB

  AVS_2DVLC_table_chroma = AVS_2DVLC_CHROMA;


  if ( cbp & (1<<b8) )
  {
    //code all symbols
    for (iblk=0; iblk<1; iblk++)
    {
      i=0;        // =b4
      j=(i&~1)<<1; //off_x
      i=(i&1)<<2;  //off_y
      if( (i<0) || (i>=8) || (j<0) || (j>=8) )
        continue;        //used in AVS Intra RDopt. code one one subblock.
			
      b4 = blk_table[iblk];
      level = 1; // get inside loop
      ipos  = 0;
      ACLevel = img->cofAC[b8][b4][0];
      ACRun   = img->cofAC[b8][b4][1];
		
      for(icoef=0;icoef<inumcoeff;icoef++) //count coeffs
      {
        if(!ACLevel[icoef])
          break;
      }
	
      tablenum = 0;
      for(icoef; icoef>=0; icoef--)
      {
        if(icoef == 0)   //EOB
        {
          level = 0;
          run   = 0;
        }
        else
        {
          level = ACLevel[icoef-1];
          run   = ACRun[icoef-1];
        }
        
        symbol2D=CODE2D_ESCAPE_SYMBOL;        //symbol for out-of-table
        if(level>-27 && level<27 && run<26)
        {
          if(tablenum == 0)
            //symbol2D = AVS_2DVLC_CHROMA[tablenum][run][abs(level)-1];
            symbol2D = AVS_2DVLC_table_chroma[tablenum][run][abs(level)-1];    //qwang 11.29
          else
            //symbol2D = AVS_2DVLC_CHROMA[tablenum][run][abs(level)];
            symbol2D = AVS_2DVLC_table_chroma[tablenum][run][abs(level)];      //qwang 11.29
          if(symbol2D >= 0 && level < 0)
            symbol2D++;
          if(symbol2D < 0)
              symbol2D = (CODE2D_ESCAPE_SYMBOL + (run<<1) + ((level>0)?1:0)); //jlzheng 7.20
		}
		// added by dj
		else
		{
			symbol2D = (CODE2D_ESCAPE_SYMBOL + (run<<1) + ((level>0)?1:0)); //jlzheng 7.20
		}
		//end
        
        currSE->type = SE_LUM_AC_INTER;
        currSE->value1=symbol2D;
        currSE->value2=0;
        currSE->golomb_grad = VLC_Golomb_Order[2][tablenum][0];         //qwang 11.29
        currSE->golomb_maxlevels = VLC_Golomb_Order[2][tablenum][1];    //qwang 11.29
        
        writeSyntaxElement_GOLOMB(currSE,currBitStream);
        bitCount[BITS_COEFF_UV_MB]+=currSE->len;
        no_bits+=currSE->len;
        currSE++;// proceed to next SE
        currMB->currSEnr++;
        
        if(icoef == 0) break;
        
        if(symbol2D>=CODE2D_ESCAPE_SYMBOL)   //???? select the optimal kth_Golomb code
        {
			// changed by dj
            currSE->type = SE_LUM_AC_INTER;
            currSE->golomb_grad = 0;  
            currSE->golomb_maxlevels = 11; 
            escape_level_diff = abs(level)-((run>MaxRun[2][tablenum])?1:RefAbsLevel[tablenum+14][run]);
            currSE->value1 = escape_level_diff;
            
            writeSyntaxElement_GOLOMB(currSE,currBitStream);
            bitCount[BITS_COEFF_Y_MB]+=currSE->len;
            no_bits+=currSE->len;
            currSE++;// proceed to next SE
            currMB->currSEnr++;
			// end 
        }
				
        if(abs(level) > incVlc_chroma[tablenum])   //qwang 11.29
        {
            if(abs(level) <= 2)
              tablenum = abs(level);
            else if(abs(level) <= 4)
              tablenum = 3;
            else
              tablenum = 4;
        }
		}
			
	 }  //loop for iblk
  }//if ( cbp & (1<<b8) )
	
  return no_bits;
}

/*
*************************************************************************
* Function:
		Make Intra prediction for all 9 modes for 8*8,
        img_x and img_y are pixels offsets in the picture.
* Input:
* Output:
* Return: 
* Attention:
*************************************************************************
*/


void intrapred_luma_AVS(int img_x,int img_y)
{
  unsigned char edgepixels[40];
  int x,y,last_pix,new_pix;
  int b8_x,b8_y;
  int i;
  int block_available_up,block_available_up_right;
  int block_available_left,block_available_left_down;
  int bs_x=8;
  int bs_y=8;
  int MBRowSize = img->width / MB_BLOCK_SIZE;/*lgp*/
  int off_up=1,incr_y=1,off_y=0;/*lgp*/
  const int mb_nr    = img->current_mb_nr;    /*oliver*/
  Macroblock *currMB = &img->mb_data[mb_nr];  /*oliver*/
  int mb_left_available = (img_x >= MB_BLOCK_SIZE)?currMB->slice_nr == img->mb_data[mb_nr-1].slice_nr:0;  /*oliver*/
  int mb_up_available = (img_y >= MB_BLOCK_SIZE)?currMB->slice_nr == img->mb_data[mb_nr-MBRowSize].slice_nr:0;  /*oliver*/
  int mb_up_right_available; 
  int mb_left_down_available;
  
  
  if((img->mb_y==0)||(img->mb_x==img->width/MB_BLOCK_SIZE-1))
  mb_up_right_available =1;
  else if((img_y-img->pix_y)>0)
  mb_up_right_available =(img_x-img->pix_x)>0? (currMB->slice_nr == img->mb_data[mb_nr+1].slice_nr):1;  /*oliver*/
   else
  mb_up_right_available =((img_x-img->pix_x)>0? (currMB->slice_nr == img->mb_data[mb_nr-MBRowSize+1].slice_nr):(currMB->slice_nr== img->mb_data[mb_nr-MBRowSize].slice_nr));  /*oliver*/

  
  if((img->mb_x==0)||(img->mb_y==img->height/MB_BLOCK_SIZE-1))
  mb_left_down_available = 1;
  else if(img_x-img->pix_x>0)
  mb_left_down_available =(img_y-img->pix_y)>0? (currMB->slice_nr == img->mb_data[mb_nr+MBRowSize].slice_nr):1;  /*oliver*/
  else
  mb_left_down_available =((img_y-img->pix_y)>0? (currMB->slice_nr == img->mb_data[mb_nr+MBRowSize-1].slice_nr):(currMB->slice_nr == img->mb_data[mb_nr-1].slice_nr));  /*oliver*/
 
  
  
  b8_x=img_x>>3;
  b8_y=img_y>>3;
  
  //check block up
  
  block_available_up=( b8_y-1>=0 && (mb_up_available||(img_y/8)%2));
  
  //check block up right
  block_available_up_right=( b8_x+1<(img->width>>3) && b8_y-1>=0 && mb_up_right_available);
  
  //check block left
  block_available_left=( b8_x - 1 >=0 && (mb_left_available || (img_x/8)%2));
  
  //check block left down
  block_available_left_down=( b8_x - 1>=0 && b8_y + 1 < (img->height>>3) && mb_left_down_available);
	if( ((img_x/8)%2)  && ((img_y/8)%2))
		block_available_up_right=0;
		
	if( ((img_x/8)%2)  || ((img_y/8)%2))
		block_available_left_down=0;

  //get prediciton pixels
  if(block_available_up)
  {
    for(x=0;x<bs_x;x++)
      EP[x+1]=imgY[img_y-/*1*/off_up/*lgp*/][img_x+x];
    
    if(block_available_up_right)
    {
      for(x=0;x<bs_x;x++)
        EP[1+x+bs_x]=imgY[img_y-/*1*/off_up/*lgp*/][img_x+bs_x+x];
      for(;x<bs_y;x++)
        EP[1+x+bs_x]=imgY[img_y-/*1*/off_up/*lgp*/][img_x+bs_x+bs_x-1];
    }
    else
    {
      for(x=0;x<bs_y;x++)
        EP[1+x+bs_x]=EP[bs_x];
    }

    for(;x<bs_y+2;x++)
      EP[1+x+bs_x]=EP[bs_x+x];
    
    EP[0]=imgY[img_y-/*1*/off_up/*lgp*/][img_x];
  }
  if(block_available_left)
  {
    for(y=0;y<bs_y;y++)
      EP[-1-y]=imgY[img_y+/*y*/incr_y*y-off_y][img_x-1];

    if(block_available_left_down)
    {
      for(y=0;y<bs_y;y++)
        EP[-1-y-bs_y]=imgY[img_y+bs_y+y][img_x-1];
      for(;y<bs_x;y++)
        EP[-1-y-bs_y]=imgY[img_y+bs_y+bs_y-1][img_x-1];
    }
    else
    {
      for(y=0;y<bs_x;y++)
        EP[-1-y-bs_y]=EP[-bs_y];
    }

    for(;y<bs_x+2;y++)
      EP[-1-y-bs_y]=EP[-y-bs_y];

    EP[0]=imgY[img_y-off_y/*lgp*/][img_x-1];
  }
  if(block_available_up&&block_available_left)
    EP[0]=imgY[img_y-/*1*/off_y-off_up/*lgp*/][img_x-1];
  
  //lowpass (Those emlements that are not needed will not disturb)
  last_pix=EP[-(bs_x+bs_y)];
  for(i=-(bs_x+bs_y);i<=(bs_x+bs_y);i++)
  {
    new_pix=( last_pix + (EP[i]<<1) + EP[i+1] + 2 )>>2;
    last_pix=EP[i];
    EP[i]=(unsigned char)new_pix;
  }
  for(i=0;i<9;i++)
    img->mprr[i][0][0]=-1;
  // 0 DC
  if(!block_available_up && !block_available_left)
    for(y=0UL;y<bs_y;y++)
      for(x=0UL;x<bs_x;x++)
        img->mprr[DC_PRED][y][x]=128UL;

  if(block_available_up && !block_available_left)
    for(y=0UL;y<bs_y;y++)
      for(x=0UL;x<bs_x;x++)
        img->mprr[DC_PRED][y][x]=EP[1+x];

  if(!block_available_up && block_available_left)
    for(y=0UL;y<bs_y;y++)
      for(x=0UL;x<bs_x;x++)
        img->mprr[DC_PRED][y][x]=EP[-1-y];

  
  if(block_available_up && block_available_left)
    for(y=0UL;y<bs_y;y++)
      for(x=0UL;x<bs_x;x++)
        img->mprr[DC_PRED][y][x]=(EP[1+x]+EP[-1-y])>>1;
 
  // 1 vertical
  if(block_available_up)
    for(y=0UL;y<bs_y;y++)
      for(x=0UL;x<bs_x;x++)
        img->mprr[VERT_PRED][y][x]=imgY[img_y-1][img_x+x];
      
  // 2 horizontal
  if(block_available_left)
    for(y=0UL;y<bs_y;y++)
      for(x=0UL;x<bs_x;x++)
        img->mprr[HOR_PRED][y][x]=imgY[img_y+y][img_x-1];

  // 3 down-right
  if(block_available_left&&block_available_up)
    for(y=0UL;y<bs_y;y++)
      for(x=0UL;x<bs_x;x++)
        img->mprr[DOWN_RIGHT_PRED][y][x]=EP[x-y];

  // 4 up-right bidirectional
  if(block_available_left&&block_available_up)
    for(y=0UL;y<bs_y;y++)
      for(x=0UL;x<bs_x;x++)
        img->mprr[DOWN_LEFT_PRED][y][x]=(EP[2+x+y]+EP[-2-(x+y)])>>1;

}