block.c

H264视频编解码程序

  }
  return ac_coef;
}


/*!
************************************************************************
* \brief
*    The routine performs transform,quantization,inverse transform, adds the diff.
*    to the prediction and writes the result to the decoded luma frame. Includes the
*    RD constrained quantization also.
*
* \par Input:
*    block_x,block_y: Block position inside a macro block (0,4,8,12).
*
* \par Output_
*    nonzero: 0 if no levels are nonzero.  1 if there are nonzero levels.             \n
*    coeff_cost: Counter for nonzero coefficients, used to discard expensive levels.
************************************************************************
*/
int dct_luma(int block_x,int block_y,int *coeff_cost, int intra)
{
  int sign(int a,int b);

  int i,j,ilev, m4[4][4], m5[4],m6[4],coeff_ctr;
  int ii;
  //int qp_const;
  int level,scan_pos,run;
  int nonzero;
  int qp_per,qp_rem,q_bits;

  int   pos_x   = block_x >> BLOCK_SHIFT;
  int   pos_y   = block_y >> BLOCK_SHIFT;
  int   b8      = 2*(pos_y >> 1) + (pos_x >> 1);
  int   b4      = 2*(pos_y & 0x01) + (pos_x & 0x01);
  int*  ACLevel = img->cofAC[b8][b4][0];
  int*  ACRun   = img->cofAC[b8][b4][1];
  int   pix_y, pix_x;

  Macroblock *currMB = &img->mb_data[img->current_mb_nr];
  short is_field_mode = (img->field_picture || ( img->MbaffFrameFlag && currMB->mb_field));

  Boolean lossless_qpprime = ((currMB->qp + img->bitdepth_luma_qp_scale)==0 && img->lossless_qpprime_flag==1);
  int **levelscale,**leveloffset;
  int **invlevelscale;
  const byte (*pos_scan)[2] = is_field_mode ? FIELD_SCAN : SNGL_SCAN;


  qp_per    = (currMB->qp + img->bitdepth_luma_qp_scale - MIN_QP)/6; 
  qp_rem    = (currMB->qp + img->bitdepth_luma_qp_scale - MIN_QP)%6; 
  q_bits    = Q_BITS+qp_per;

  levelscale    = LevelScale4x4Luma[intra][qp_rem];
  leveloffset   = LevelOffset4x4Luma[intra][qp_per];
  invlevelscale = InvLevelScale4x4Luma[intra][qp_rem];

  //  Horizontal transform
  if (!lossless_qpprime)
  {
    for (j=0; j < BLOCK_SIZE; j++)
    {
      m5[0] = img->m7[j][0]+img->m7[j][3];
      m5[1] = img->m7[j][1]+img->m7[j][2];
      m5[2] = img->m7[j][1]-img->m7[j][2];
      m5[3] = img->m7[j][0]-img->m7[j][3];
      
      m4[j][0] = m5[0]   + m5[1];
      m4[j][2] = m5[0]   - m5[1];
      m4[j][1] = m5[3]*2 + m5[2];
      m4[j][3] = m5[3]   - m5[2]*2;
    }
    
    //  Vertical transform
    for (i=0; i < BLOCK_SIZE; i++)
    {    
      m5[0] = m4[0][i] + m4[3][i];
      m5[1] = m4[1][i] + m4[2][i];
      m5[2] = m4[1][i] - m4[2][i];
      m5[3] = m4[0][i] - m4[3][i];
      
      m4[0][i] = m5[0]   + m5[1];
      m4[2][i] = m5[0]   - m5[1];
      m4[1][i] = m5[3]*2 + m5[2];
      m4[3][i] = m5[3]   - m5[2]*2;
    }
  }
  // Quant

  nonzero=FALSE;

  run=-1;
  scan_pos=0;
  
  for (coeff_ctr=0;coeff_ctr < 16;coeff_ctr++)
  {

    i=pos_scan[coeff_ctr][0];
    j=pos_scan[coeff_ctr][1];
    
    run++;
    ilev=0;
    
    if(lossless_qpprime)
      level = absm (img->m7[j][i]);
    else
      level = (absm (m4[j][i]) * levelscale[i][j] + leveloffset[i][j]) >> q_bits;

    if (img->AdaptiveRounding)
    {
      if (lossless_qpprime || level == 0 )
      {
        img->fadjust4x4[intra][block_y+j][block_x+i] = 0;
      }
      else 
      {
        img->fadjust4x4[intra][block_y+j][block_x+i] = 
          (AdaptRndWeight * (absm(m4[j][i]) * levelscale[i][j] - (level << q_bits)) + (1<< (q_bits))) >> (q_bits + 1);         
      }
    }

    if (level != 0)
    {
      nonzero=TRUE;

      *coeff_cost += (level > 1 || lossless_qpprime) ? MAX_VALUE : COEFF_COST[input->disthres][run];

      if(lossless_qpprime)
        ACLevel[scan_pos] = sign(level,img->m7[j][i]);
      else
        ACLevel[scan_pos] = sign(level,m4[j][i]);

      ACRun  [scan_pos] = run;
      ++scan_pos;
      run=-1;                     // reset zero level counter

      level=sign(level, m4[j][i]);

      if(lossless_qpprime)
      {
        ilev=level;
      }
#if 0
      else if(qp_per<4)
      {
        ilev=(level*invlevelscale[i][j]+(1<<(3-qp_per)))>>(4-qp_per);
      }
      else
      {
        ilev=(level*invlevelscale[i][j])<<(qp_per-4);
      }
#else
      else
      {
        ilev=((((level*invlevelscale[i][j])<< qp_per) + 8 ) >> 4);
      }
#endif
    }
    if(!lossless_qpprime)
      m4[j][i]=ilev;
  }

  ACLevel[scan_pos] = 0;  
  
  //     IDCT.
  //     horizontal

  if (!lossless_qpprime)
  {
    for (j=0; j < BLOCK_SIZE; j++)
    {
      m6[0]=(m4[j][0]     +  m4[j][2]);
      m6[1]=(m4[j][0]     -  m4[j][2]);
      m6[2]=(m4[j][1]>>1) -  m4[j][3];
      m6[3]= m4[j][1]     + (m4[j][3]>>1);
      
      m4[j][0] = m6[0] + m6[3];
      m4[j][1] = m6[1] + m6[2];
      m4[j][2] = m6[1] - m6[2];
      m4[j][3] = m6[0] - m6[3];
    }
    
    //  vertical
    for (i=0; i < BLOCK_SIZE; i++)
    {
      
      m6[0]=(m4[0][i]     +  m4[2][i]);
      m6[1]=(m4[0][i]     -  m4[2][i]);
      m6[2]=(m4[1][i]>>1) -  m4[3][i];
      m6[3]= m4[1][i]     + (m4[3][i]>>1);
      
      ii = i + block_x;
      
      if (!img->residue_transform_flag)
      {
        img->m7[0][i] = min(img->max_imgpel_value,max(0,(m6[0]+m6[3]+((long)img->mpr[0 + block_y][ii] << DQ_BITS)+DQ_ROUND)>>DQ_BITS));
        img->m7[1][i] = min(img->max_imgpel_value,max(0,(m6[1]+m6[2]+((long)img->mpr[1 + block_y][ii] << DQ_BITS)+DQ_ROUND)>>DQ_BITS));
        img->m7[2][i] = min(img->max_imgpel_value,max(0,(m6[1]-m6[2]+((long)img->mpr[2 + block_y][ii] << DQ_BITS)+DQ_ROUND)>>DQ_BITS));
        img->m7[3][i] = min(img->max_imgpel_value,max(0,(m6[0]-m6[3]+((long)img->mpr[3 + block_y][ii] << DQ_BITS)+DQ_ROUND)>>DQ_BITS));
      } 
      else 
      {
        if(lossless_qpprime)
        {
          img->m7[0][i] = m6[0]+m6[3];
          img->m7[1][i] = m6[1]+m6[2];
          img->m7[2][i] = m6[1]-m6[2];
          img->m7[3][i] = m6[0]-m6[3];
        }
        else
        {
          img->m7[0][i] =(m6[0]+m6[3]+DQ_ROUND)>>DQ_BITS;
          img->m7[1][i] =(m6[1]+m6[2]+DQ_ROUND)>>DQ_BITS;
          img->m7[2][i] =(m6[1]-m6[2]+DQ_ROUND)>>DQ_BITS;
          img->m7[3][i] =(m6[0]-m6[3]+DQ_ROUND)>>DQ_BITS;
        }
      }
    }
  }
  //  Decoded block moved to frame memory
  if (!img->residue_transform_flag)
  {
    if(lossless_qpprime)
    {
      for (j=0; j < BLOCK_SIZE; j++)
      {
        pix_y = img->pix_y+block_y+j;
        for (i=0; i < BLOCK_SIZE; i++)
        {
         enc_picture->imgY[pix_y][img->pix_x+block_x+i]=img->m7[j][i]+img->mpr[j+block_y][i+block_x];
        }
      }
    }
    else
    {
      for (j=0; j < BLOCK_SIZE; j++)
      {
        pix_y = img->pix_y+block_y+j;
        pix_x = img->pix_x+block_x;
        for (i=0; i < BLOCK_SIZE; i++)
        {
          enc_picture->imgY[pix_y][pix_x + i]=img->m7[j][i];
        }
      }
    }
    
  }
  return nonzero;
}


/*!
 ************************************************************************
 * \brief
 *    Transform,quantization,inverse transform for chroma.
 *    The main reason why this is done in a separate routine is the
 *    additional 2x2 transform of DC-coeffs. This routine is called
 *    ones for each of the chroma components.
 *
 * \par Input:
 *    uv    : Make difference between the U and V chroma component  \n
 *    cr_cbp: chroma coded block pattern
 *
 * \par Output:
 *    cr_cbp: Updated chroma coded block pattern.
 ************************************************************************
 */
int dct_chroma(int uv,int cr_cbp)
{
  int i,j,i1,j2,ilev,n2,n1,j1,mb_y,coeff_ctr,level ,scan_pos,run;
  int m1[BLOCK_SIZE],m5[BLOCK_SIZE],m6[BLOCK_SIZE];
  int coeff_cost;
  int cr_cbp_tmp;
  int DCcoded=0 ;
  Macroblock *currMB = &img->mb_data[img->current_mb_nr];
 
  int qp_per,qp_rem,q_bits;
  int qp_c;

  int   b4;
  int*  DCLevel = img->cofDC[uv+1][0];
  int*  DCRun   = img->cofDC[uv+1][1];
  int*  ACLevel;
  int*  ACRun;
  int   intra = IS_INTRA (currMB);
  int   uv_scale = uv*(img->num_blk8x8_uv >> 1);

  //FRExt
  int64 cbpblk_pattern[4]={0, 0xf0000, 0xff0000, 0xffff0000};
  int yuv = img->yuv_format;
  int b8;
  int m3[4][4];
  int m4[4][4];
  int qp_per_dc = 0;
  int qp_rem_dc = 0;
  int q_bits_422 = 0;	
  int ***levelscale, ***leveloffset;
  int ***invlevelscale;
  short pix_c_x, pix_c_y;
  short is_field_mode = (img->field_picture || ( img->MbaffFrameFlag && currMB->mb_field));
  const byte (*pos_scan)[2] = is_field_mode ? FIELD_SCAN : SNGL_SCAN;

  Boolean lossless_qpprime = ((currMB->qp + img->bitdepth_luma_qp_scale)==0 && img->lossless_qpprime_flag==1);

  qp_c      = currMB->qp + img->chroma_qp_offset[uv];
  qp_c      = Clip3(-img->bitdepth_chroma_qp_scale,51,qp_c);
  qp_c      = (qp_c < 0)? qp_c : QP_SCALE_CR[qp_c - MIN_QP];


  qp_per    = qp_per_matrix[(qp_c + img->bitdepth_chroma_qp_scale)];
  qp_rem    = qp_rem_matrix[(qp_c + img->bitdepth_chroma_qp_scale)];

  q_bits    = Q_BITS+qp_per;

  levelscale = LevelScale4x4Chroma[uv][intra];
  leveloffset = LevelOffset4x4Chroma[uv][intra];
  invlevelscale = InvLevelScale4x4Chroma[uv][intra];

  if (img->yuv_format == YUV422)
  {
    //for YUV422 only
    qp_per_dc = (qp_c + 3 + img->bitdepth_chroma_qp_scale)/6;
    qp_rem_dc = (qp_c + 3 + img->bitdepth_chroma_qp_scale)%6;
    
    q_bits_422 = Q_BITS+qp_per_dc;  
  }

  
  //============= dct transform ===============	
  for (n2=0; n2 < img->mb_cr_size_y; n2 += BLOCK_SIZE)
  {
    for (n1=0; n1 < img->mb_cr_size_x; n1 += BLOCK_SIZE)
    {

      //  Horizontal transform.
      for (j=0; j < BLOCK_SIZE && !lossless_qpprime; j++)
      {
        mb_y=n2+j;
        
        m5[0]=img->m7[mb_y][n1  ]+img->m7[mb_y][n1+3];
        m5[1]=img->m7[mb_y][n1+1]+img->m7[mb_y][n1+2];
        m5[2]=img->m7[mb_y][n1+1]-img->m7[mb_y][n1+2];
        m5[3]=img->m7[mb_y][n1  ]-img->m7[mb_y][n1+3];
        
        img->m7[mb_y][n1  ] = (m5[0]   + m5[1]);
        img->m7[mb_y][n1+2] = (m5[0]   - m5[1]);
        img->m7[mb_y][n1+1] =  m5[3]*2 + m5[2];
        img->m7[mb_y][n1+3] =  m5[3]   - m5[2]*2;
      }

      //  Vertical transform.

      for (i=0; i < BLOCK_SIZE && !lossless_qpprime; i++)
      {
        j1=n1+i;
        m5[0] = img->m7[n2  ][j1] + img->m7[n2+3][j1];
        m5[1] = img->m7[n2+1][j1] + img->m7[n2+2][j1];
        m5[2] = img->m7[n2+1][j1] - img->m7[n2+2][j1];
        m5[3] = img->m7[n2  ][j1] - img->m7[n2+3][j1];

        img->m7[n2+0][j1] = (m5[0]   + m5[1]);
        img->m7[n2+2][j1] = (m5[0]   - m5[1]);
        img->m7[n2+1][j1] =  m5[3]*2 + m5[2];
        img->m7[n2+3][j1] =  m5[3]   - m5[2]*2;
      }
    }
  }
  
  if (yuv == YUV420)
  {
    //================== CHROMA DC YUV420 ===================
    //     2X2 transform of DC coeffs.
    if(lossless_qpprime)
    {
      m1[0]=img->m7[0][0];
      m1[1]=img->m7[0][4];
      m1[2]=img->m7[4][0];
      m1[3]=img->m7[4][4];
    }
    else 
    {
      m1[0]=(img->m7[0][0] + img->m7[0][4] + img->m7[4][0] + img->m7[4][4]);
      m1[1]=(img->m7[0][0] - img->m7[0][4] + img->m7[4][0] - img->m7[4][4]);
      m1[2]=(img->m7[0][0] + img->m7[0][4] - img->m7[4][0] - img->m7[4][4]);
      m1[3]=(img->m7[0][0] - img->m7[0][4] - img->m7[4][0] + img->m7[4][4]);
    }
    
    //     Quant of chroma 2X2 coeffs.
    run=-1;
    scan_pos=0;
    
    for (coeff_ctr=0; coeff_ctr < 4; coeff_ctr++)
    {
      run++;
      ilev=0;
      
      if(lossless_qpprime)
        level =absm(m1[coeff_ctr]);
      else 
        level =(absm(m1[coeff_ctr]) * levelscale[qp_rem][0][0] + (leveloffset[qp_per][0][0]<<1)) >> (q_bits+1);
      
      if (input->symbol_mode == UVLC && img->qp < 4) 
      {
        if (level > CAVLC_LEVEL_LIMIT) 
          level = CAVLC_LEVEL_LIMIT;
      }
      
      if (level  != 0)
      {
        currMB->cbp_blk |= 0xf0000 << (uv << 2) ;    // if one of the 2x2-DC levels is != 0 set the
        cr_cbp=max(1,cr_cbp);                     // coded-bit all 4 4x4 blocks (bit 16-19 or 20-23)
        DCcoded = 1 ;
        DCLevel[scan_pos] = sign(level ,m1[coeff_ctr]);
        DCRun  [scan_pos] = run;
        scan_pos++;
        run=-1;
        
        ilev=sign(level, m1[coeff_ctr]);
      }
      if(!lossless_qpprime)
        m1[coeff_ctr]=ilev;
    }
    DCLevel[scan_pos] = 0;
    
    //  Inverse transform of 2x2 DC levels
    if(!lossless_qpprime)
    {
      m5[0]=(m1[0] + m1[1] + m1[2] + m1[3]);
      m5[1]=(m1[0] - m1[1] + m1[2] - m1[3]);
      m5[2]=(m1[0] + m1[1] - m1[2] - m1[3]);
      m5[3]=(m1[0] - m1[1] - m1[2] + m1[3]);
      if(qp_per<5)
      {
        for(i=0; i<4; i++)
          m1[i]=(m5[i] * invlevelscale[qp_rem][0][0])>>(5-qp_per);
      }
      else
      {