transform8x8.c

H264视频编解码程序

  currSE->value1 = (mostProbableMode == ipmode) ? -1 : ipmode < mostProbableMode ? ipmode : ipmode-1;

  //--- set position and type ---
  currSE->context = b8;
  currSE->type    = SE_INTRAPREDMODE;

  //--- set function pointer ----
  if (input->symbol_mode != UVLC)    
    currSE->writing = writeIntraPredMode_CABAC;

  //--- choose data partition ---
  if (img->type!=B_SLICE)
    dataPart = &(currSlice->partArr[partMap[SE_INTRAPREDMODE]]);
  else
    dataPart = &(currSlice->partArr[partMap[SE_BFRAME]]);

  //--- encode and update rate ---
  if (input->symbol_mode == UVLC)
    writeSyntaxElement_Intra4x4PredictionMode(currSE, dataPart);
  else
    dataPart->writeSyntaxElement (currSE, dataPart);

  rate = currSE->len;
  currSE++;
  currMB->currSEnr++;

  //===== RATE for LUMINANCE COEFFICIENTS =====

  if (input->symbol_mode == UVLC)
  {
    int b4;
    for(b4=0; b4<4; b4++)
      rate  += writeCoeff4x4_CAVLC (LUMA, b8, b4, 0);
  }
  else
  {
    rate  += writeLumaCoeff8x8_CABAC (b8, 1);
  }


  rdcost = (double)distortion + lambda*(double)rate;

  if(img->residue_transform_flag)
    return (double)rate;
  else
    return rdcost;
}


/*!
 ************************************************************************
 * \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:
 *    b8: Block position inside a macro block (0,1,2,3).
 *
 * \par Output:
 *    nonzero: 0 if no levels are nonzero.  1 if there are nonzero levels.  
 *    coeff_cost: Counter for nonzero coefficients, used to discard expensive levels.
 ************************************************************************
 */

#define MC(coeff) ((coeff)&3)

int dct_luma8x8(int b8,int *coeff_cost, int intra)
{
  int sign(int a,int b);

  int i,j,ilev,coeff_ctr;
  int level,scan_pos,run;
  int nonzero;
  int qp_per,qp_rem,q_bits;
  int dq_lshift = 0, dq_rshift = 0, dq_round = 0;

  int block_x = 8*(b8 & 0x01);
  int block_y = 8*(b8 >> 1);
  int*  ACLevel = img->cofAC[b8][0][0];
  int*  ACRun   = img->cofAC[b8][0][1];
  int m6[8][8];
  int a[8], b[8];
  int scan_poss[4],runs[4];
  int pix_x, pix_y, ipix_y;
  int **levelscale,**leveloffset;
  int **invlevelscale;
  int MCcoeff;
  Macroblock *currMB = &img->mb_data[img->current_mb_nr];
  short is_field_mode = (img->field_picture || ( img->MbaffFrameFlag && currMB->mb_field));

  Boolean lossless_qpprime = ((img->qp + img->bitdepth_luma_qp_scale)==0 && img->lossless_qpprime_flag==1);
  
  qp_per    = (img->qp + img->bitdepth_luma_qp_scale - MIN_QP)/6;
  qp_rem    = (img->qp + img->bitdepth_luma_qp_scale - MIN_QP)%6;
  q_bits    = Q_BITS_8+qp_per;
  levelscale    = LevelScale8x8Luma[intra][qp_rem];
  leveloffset   = LevelOffset8x8Luma[intra][qp_per];
  invlevelscale = InvLevelScale8x8Luma[intra][qp_rem];

  if (qp_per < 6)
  {
    dq_rshift = 6 - qp_per;
    dq_round  = 1<<(5-qp_per);
  }
  else
    dq_lshift = qp_per - 6;
    

  // horizontal transform
  if (!lossless_qpprime) 
  {
    for( i=0; i<8; i++)
    {
      a[0] = img->m7[i][0] + img->m7[i][7];
      a[1] = img->m7[i][1] + img->m7[i][6];
      a[2] = img->m7[i][2] + img->m7[i][5];
      a[3] = img->m7[i][3] + img->m7[i][4];
      
      b[0] = a[0] + a[3];
      b[1] = a[1] + a[2];
      b[2] = a[0] - a[3];
      b[3] = a[1] - a[2];
      
      a[4] = img->m7[i][0] - img->m7[i][7];
      a[5] = img->m7[i][1] - img->m7[i][6];
      a[6] = img->m7[i][2] - img->m7[i][5];
      a[7] = img->m7[i][3] - img->m7[i][4];
      
      b[4]= a[5] + a[6] + ((a[4]>>1) + a[4]);
      b[5]= a[4] - a[7] - ((a[6]>>1) + a[6]);
      b[6]= a[4] + a[7] - ((a[5]>>1) + a[5]);
      b[7]= a[5] - a[6] + ((a[7]>>1) + a[7]);
      
      m6[0][i] = b[0] + b[1];
      m6[2][i] = b[2] + (b[3]>>1);
      m6[4][i] = b[0] - b[1];
      m6[6][i] = (b[2]>>1) - b[3];
      m6[1][i] =   b[4] + (b[7]>>2);
      m6[3][i] =   b[5] + (b[6]>>2);
      m6[5][i] =   b[6] - (b[5]>>2);
      m6[7][i] = - b[7] + (b[4]>>2);
      
    }
    // vertical transform
    for( i=0; i<8; i++)
    {
      a[0] = m6[i][0] + m6[i][7];
      a[1] = m6[i][1] + m6[i][6];
      a[2] = m6[i][2] + m6[i][5];
      a[3] = m6[i][3] + m6[i][4];
      
      b[0] = a[0] + a[3];
      b[1] = a[1] + a[2];
      b[2] = a[0] - a[3];
      b[3] = a[1] - a[2];
      
      a[4] = m6[i][0] - m6[i][7];
      a[5] = m6[i][1] - m6[i][6];
      a[6] = m6[i][2] - m6[i][5];
      a[7] = m6[i][3] - m6[i][4];
      
      b[4]= a[5] + a[6] + ((a[4]>>1) + a[4]);
      b[5]= a[4] - a[7] - ((a[6]>>1) + a[6]);
      b[6]= a[4] + a[7] - ((a[5]>>1) + a[5]);
      b[7]= a[5] - a[6] + ((a[7]>>1) + a[7]);
      
      img->m7[0][i] = b[0] + b[1];
      img->m7[2][i] = b[2] + (b[3]>>1);
      img->m7[4][i] = b[0] - b[1];
      img->m7[6][i] = (b[2]>>1) - b[3];
      img->m7[1][i] =   b[4] + (b[7]>>2);
      img->m7[3][i] =   b[5] + (b[6]>>2);
      img->m7[5][i] =   b[6] - (b[5]>>2);
      img->m7[7][i] = - b[7] + (b[4]>>2);
    }
  }

  // Quant  
  nonzero=FALSE;
  
  run=-1;
  scan_pos=0;
  
  runs[0]=runs[1]=runs[2]=runs[3]=-1;
  scan_poss[0]=scan_poss[1]=scan_poss[2]=scan_poss[3]=0;
  
  for (coeff_ctr=0;coeff_ctr < 64;coeff_ctr++)
  {
    
    if (is_field_mode) 
    {  // Alternate scan for field coding
      i=FIELD_SCAN8x8[coeff_ctr][0];
      j=FIELD_SCAN8x8[coeff_ctr][1];
    }
    else 
    {
      i=SNGL_SCAN8x8[coeff_ctr][0];
      j=SNGL_SCAN8x8[coeff_ctr][1];
    }
    MCcoeff = MC(coeff_ctr);
    run++;
    ilev=0;
    
    runs[MCcoeff]++;
    
    if(lossless_qpprime)
      level = absm (img->m7[j][i]);
    else 
      level = (absm (img->m7[j][i]) * levelscale[i][j] + leveloffset[i][j]) >> q_bits;
  
    if (img->AdaptiveRounding)
    {
      if (lossless_qpprime || level == 0 )
      {
        img->fadjust8x8[intra][block_y+j][block_x+i] = 0;
      }
      else 
      {
        img->fadjust8x8[intra][block_y + j][block_x + i] = 
          (AdaptRndWeight * (absm (img->m7[j][i]) * levelscale[i][j] - (level << q_bits)) + (1<< (q_bits))) >> (q_bits + 1);       
      }
    }

    if (level != 0)
    {
      nonzero=TRUE;
      
      if (currMB->luma_transform_size_8x8_flag && input->symbol_mode == UVLC)
      {
        *coeff_cost += (level > 1 || lossless_qpprime) ? MAX_VALUE : COEFF_COST8x8[input->disthres][runs[MCcoeff]];

        img->cofAC[b8][MCcoeff][0][scan_poss[MCcoeff]] = sign(level,img->m7[j][i]);
        img->cofAC[b8][MCcoeff][1][scan_poss[MCcoeff]] = runs[MCcoeff];
        ++scan_poss[MCcoeff];
        runs[MCcoeff]=-1;
      }
      else
      {
        *coeff_cost += (level > 1 || lossless_qpprime) ? MAX_VALUE :COEFF_COST8x8[input->disthres][run];
        ACLevel[scan_pos] = sign(level,img->m7[j][i]);
        ACRun  [scan_pos] = run;
        ++scan_pos;
        run=-1;                     // reset zero level counter
      }      
      
      level = sign(level, img->m7[j][i]);
      if(lossless_qpprime)
      {
        ilev = level;
      }
      else 
      {
        if (qp_per>=6)
          ilev = level*invlevelscale[i][j]<<dq_lshift; // dequantization
        else
          ilev = (level*invlevelscale[i][j] + dq_round)>>dq_rshift; // dequantization
      }
    }
    if(!lossless_qpprime)
      img->m7[j][i] = ilev;
  }
  if (!currMB->luma_transform_size_8x8_flag || input->symbol_mode != UVLC)
    ACLevel[scan_pos] = 0;
  else
  {
    for(i=0; i<4; i++)
      img->cofAC[b8][i][0][scan_poss[i]] = 0;
  }
 
  
  //    Inverse Transform
  // horizontal inverse transform
  if (!lossless_qpprime)
  {
    for( i=0; i<8; i++)
    {
      a[0] = img->m7[i][0] + img->m7[i][4];
      a[4] = img->m7[i][0] - img->m7[i][4];
      a[2] = (img->m7[i][2]>>1) - img->m7[i][6];
      a[6] = img->m7[i][2] + (img->m7[i][6]>>1);
      
      b[0] = a[0] + a[6];
      b[2] = a[4] + a[2];
      b[4] = a[4] - a[2];
      b[6] = a[0] - a[6];
      
      a[1] = -img->m7[i][3] + img->m7[i][5] - img->m7[i][7] - (img->m7[i][7]>>1);
      a[3] =  img->m7[i][1] + img->m7[i][7] - img->m7[i][3] - (img->m7[i][3]>>1);
      a[5] = -img->m7[i][1] + img->m7[i][7] + img->m7[i][5] + (img->m7[i][5]>>1);
      a[7] =  img->m7[i][3] + img->m7[i][5] + img->m7[i][1] + (img->m7[i][1]>>1);
      
      b[1] = a[1] + (a[7]>>2);
      b[7] = -(a[1]>>2) + a[7];
      b[3] = a[3] + (a[5]>>2);
      b[5] = (a[3]>>2) - a[5];
      
      m6[0][i] = b[0] + b[7];
      m6[1][i] = b[2] + b[5];
      m6[2][i] = b[4] + b[3];
      m6[3][i] = b[6] + b[1];
      m6[4][i] = b[6] - b[1];
      m6[5][i] = b[4] - b[3];
      m6[6][i] = b[2] - b[5];
      m6[7][i] = b[0] - b[7];
    }
    
    // vertical inverse transform
    for( i=0; i<8; i++)
    {
      a[0] =  m6[i][0] + m6[i][4];
      a[4] =  m6[i][0] - m6[i][4];
      a[2] = (m6[i][2]>>1) - m6[i][6];
      a[6] =  m6[i][2] + (m6[i][6]>>1);
      
      b[0] = a[0] + a[6];
      b[2] = a[4] + a[2];
      b[4] = a[4] - a[2];
      b[6] = a[0] - a[6];
      
      a[1] = -m6[i][3] + m6[i][5] - m6[i][7] - (m6[i][7]>>1);
      a[3] =  m6[i][1] + m6[i][7] - m6[i][3] - (m6[i][3]>>1);
      a[5] = -m6[i][1] + m6[i][7] + m6[i][5] + (m6[i][5]>>1);
      a[7] =  m6[i][3] + m6[i][5] + m6[i][1] + (m6[i][1]>>1);
      
      b[1] =   a[1] + (a[7]>>2);
      b[7] = -(a[1]>>2) + a[7];
      b[3] =   a[3] + (a[5]>>2);
      b[5] =  (a[3]>>2) - a[5];
      
      img->m7[0][i] = b[0] + b[7];
      img->m7[1][i] = b[2] + b[5];
      img->m7[2][i] = b[4] + b[3];
      img->m7[3][i] = b[6] + b[1];
      img->m7[4][i] = b[6] - b[1];
      img->m7[5][i] = b[4] - b[3];
      img->m7[6][i] = b[2] - b[5];
      img->m7[7][i] = b[0] - b[7];
    }
  }
  
  if (!img->residue_transform_flag)
  {
    for( j=0; j<2*BLOCK_SIZE; j++)
    {
      pix_y = block_y+j;    
      ipix_y = img->pix_y + pix_y;
      for( i=0; i<2*BLOCK_SIZE; i++)
      {
        pix_x = block_x+i;
        if(lossless_qpprime)
          img->m7[j][i] = img->m7[j][i]+img->mpr[pix_y][block_x+i];
        else