block.c

JM 11.0 KTA 2.1 Source Code

  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 = (Boolean)((currMB->qp + img->bitdepth_luma_qp_scale)==0 && img->lossless_qpprime_flag==1);
  int **levelscale,**leveloffset;
  int **invlevelscale;
#ifdef USE_INTRA_MDDT
   byte pos_scan[16][2];
#else
  const byte (*pos_scan)[2] = is_field_mode ? FIELD_SCAN : SNGL_SCAN;
#endif

#ifdef RDO_Q
  levelDataStruct levelData[16];
#ifdef  INTERNAL_BIT_DEPTH_INCREASE
  double  lambda_md=0, normFact=pow(2,(2*DQ_BITS+19))*(1<<(2*img->BitDepthIncrease));
#else
  double  lambda_md=0, normFact=pow(2,(2*DQ_BITS+19));
#endif
  double err;
  int lowerInt, levelTrellis[16], kStart=0, kStop=0, noCoeff, estBits;
#endif
#ifdef USE_INTRA_MDDT
  if(input->UseIntraMDDT && intra && !img->residue_transform_flag && !is_field_mode)
  {
    for(i = 0; i < 16; i++)
    {
      pos_scan[i][0] = img->scanOrder4x4[ipmode][i][0];
      pos_scan[i][1] = img->scanOrder4x4[ipmode][i][1];
    }
  }
  else if(!is_field_mode)
  {
    for(i = 0; i < 16; i++)
    {
      pos_scan[i][0] = SNGL_SCAN[i][0];
      pos_scan[i][1] = SNGL_SCAN[i][1];
    }
  }
  else
  {
    for(i = 0; i < 16; i++)
    {
      pos_scan[i][0] = FIELD_SCAN[i][0];
      pos_scan[i][1] = FIELD_SCAN[i][1];
    }
  }
#endif

  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;

#ifdef RDO_Q
  if(input->UseRDO_Q)
  {
    if ((img->type==B_SLICE) && img->nal_reference_idc)
    {
      lambda_md = img->lambda_md[5][img->masterQP];  }
    else
    {
      lambda_md = img->lambda_md[img->type][img->masterQP];
    }
  }
#endif

#ifdef ADAPTIVE_QUANTIZATION
  if(img->slice_fractional_quant_flag)
  {
    levelscale    = LevelScale4x4Luma_IAQMS[img->mb_iaqms_idx][intra][qp_rem];
    invlevelscale = InvLevelScale4x4Luma_IAQMS[img->mb_iaqms_idx][intra][qp_rem];
  }
  else
  {
    levelscale    = LevelScale4x4Luma[intra][qp_rem];
    invlevelscale = InvLevelScale4x4Luma[intra][qp_rem];
  }
  leveloffset   = LevelOffset4x4Luma[intra][qp_per];
#else
  levelscale    = LevelScale4x4Luma[intra][qp_rem];
  leveloffset   = LevelOffset4x4Luma[intra][qp_per];
  invlevelscale = InvLevelScale4x4Luma[intra][qp_rem];
#endif

  //  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;
#ifdef RDO_Q
//#ifdef TREL_CAVLC
  if(input->UseRDO_Q && active_pps->entropy_coding_mode_flag == UVLC)
    TrellisCAVLC4x4(m4, q_bits, qp_rem, levelscale, leveloffset, levelTrellis, LUMA, b8, b4, 16, lambda_md);
//#endif
  if(input->UseRDO_Q && active_pps->entropy_coding_mode_flag == CABAC)
  {
    noCoeff=0;
    for (coeff_ctr=0;coeff_ctr < 16;coeff_ctr++)
    {
      i=pos_scan[coeff_ctr][0];
      j=pos_scan[coeff_ctr][1];

      levelData[coeff_ctr].levelDouble = absm(m4[j][i] * levelscale[i][j]);
      level = (int)(levelData[coeff_ctr].levelDouble >> q_bits);
      lowerInt=(((int)levelData[coeff_ctr].levelDouble - (level << q_bits)) < (1 <<( q_bits - 1)))? 1: 0;

      levelData[coeff_ctr].level[0]=0;
      if (level==0 && lowerInt==1)
      {
        levelData[coeff_ctr].noLevels=1;
      }
      else if (level==0 && lowerInt==0)
      {
        levelData[coeff_ctr].level[1] = level+1;
        levelData[coeff_ctr].noLevels=2;
        kStop=coeff_ctr;
        noCoeff++;
      }
      else if (level>0 && lowerInt==1)
      {
        levelData[coeff_ctr].level[1] = level;
        levelData[coeff_ctr].noLevels=2;
        kStop=coeff_ctr;
        noCoeff++;
      }
      else
      {
        levelData[coeff_ctr].level[1] = level;
        levelData[coeff_ctr].level[2] = level+1;
        levelData[coeff_ctr].noLevels=3;
        kStop=coeff_ctr;
        kStart=coeff_ctr;
        noCoeff++;
      }

      for (ii=0; ii<levelData[coeff_ctr].noLevels; ii++)
      {
        err=(double)(levelData[coeff_ctr].level[ii]<<q_bits)-(double)levelData[coeff_ctr].levelDouble;
        levelData[coeff_ctr].errLevel[ii]=(err*err*(double)estErr4x4[qp_rem][i][j])/normFact; 
      }
    }

    estBits=est_write_and_store_CBP_block_bit(currMB, LUMA_4x4);
    est_writeRunLevel_CABAC(levelData, levelTrellis, LUMA_4x4, lambda_md, kStart, kStop, noCoeff, estBits);
  }
#endif

  for (coeff_ctr=0;coeff_ctr < 16;coeff_ctr++)
  {

    i=pos_scan[coeff_ctr][0];
    j=pos_scan[coeff_ctr][1];
    
    run++;
    ilev=0;

#ifdef RDO_Q
  if(input->UseRDO_Q)    
    level = levelTrellis[coeff_ctr];
  else
  {
    if(lossless_qpprime)
      level = absm (img->m7[j][i]);
    else
      level = (absm (m4[j][i]) * levelscale[i][j] + leveloffset[i][j]) >> q_bits;
  }
#else
    if(lossless_qpprime)
      level = absm (img->m7[j][i]);
    else
      level = (absm (m4[j][i]) * levelscale[i][j] + leveloffset[i][j]) >> q_bits;
#endif

    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   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 = (Boolean)((currMB->qp + img->bitdepth_luma_qp_scale)==0 && img->lossless_qpprime_flag==1);
#ifdef RDO_Q
  levelDataStruct levelData[16];
  double  lambda_md=0;
#ifdef  INTERNAL_BIT_DEPTH_INCREASE
  double normFact = pow(2, (2 * DQ_BITS + 19))*(1<<(2*img->BitDepthIncrease));
#else
  double normFact = pow(2, (2 * DQ_BITS + 19));
#endif
  double err;
  int lowerInt, levelTrellis[16], k, kStart, kStop, noCoeff, estBits;
#endif

  qp_per    = qp_per_matrix[(currMB->qpc[uv] + img->bitdepth_chroma_qp_scale)];
  qp_rem    = qp_rem_matrix[(currMB->qpc[uv] + img->bitdepth_chroma_qp_scale)];

  q_bits    = Q_BITS+qp_per;

#ifdef RDO_Q
  //if (input->successive_Bframe>0)
  if(input->UseRDO_Q)
  {
    if ((img->type==B_SLICE) && img->nal_reference_idc)
    {
      lambda_md = img->lambda_md[5][img->masterQP];  
    }
    else
    {
      if (input->successive_Bframe==0 && img->type != B_SLICE)
      {