transform8x8.c

压缩JM12.3d的完整的全部C语言的代码文档,用于嵌入式系统的压缩编解码

  //--- set position and type ---
  se.context = b8;
  se.type    = SE_INTRAPREDMODE;

  //--- 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 ---
  writeIntraPredMode (&se, dataPart);
  /*
  if (input->symbol_mode == UVLC)
    writeIntraPredMode_CAVLC(currSE, dataPart);
  else
  {
    currSE->writing = writeIntraPredMode_CABAC;
    dataPart->writeSyntaxElement (currSE, dataPart);
  }
  */

  rate = se.len;

  //===== 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;

  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 i,j,ilev,coeff_ctr;
  int level,scan_pos,run;
  int nonzero;
  int qp_per,qp_rem,q_bits;

  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];

  Boolean lossless_qpprime = (Boolean) ((img->qp_scaled)==0 && img->lossless_qpprime_flag==1);
  const byte (*pos_scan)[2] = currMB->is_field_mode ? FIELD_SCAN8x8 : SNGL_SCAN8x8;

  qp_per    = qp_per_matrix[img->qp_scaled];
  qp_rem    = qp_rem_matrix[img->qp_scaled];
  q_bits    = Q_BITS_8 + qp_per;

  // select scaling parameters
  levelscale    = ptLevelScale8x8Luma[intra][qp_rem];
  invlevelscale = ptInvLevelScale8x8Luma[intra][qp_rem];
  leveloffset   = ptLevelOffset8x8Luma[intra][img->qp_scaled];

  // 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++)
    {

      i=pos_scan[coeff_ctr][0];
      j=pos_scan[coeff_ctr][1];

      MCcoeff = MC(coeff_ctr);
      run++;
      ilev=0;

      runs[MCcoeff]++;

      level = (iabs (img->m7[j][i]) * levelscale[j][i] + leveloffset[j][i]) >> q_bits;


      if (img->AdaptiveRounding)
      {
        img->fadjust8x8[intra][block_y + j][block_x + i] = ( level == 0 )
          ? 0
          : rshift_rnd_sf((AdaptRndWeight * (iabs (img->m7[j][i]) * levelscale[j][i] - (level << 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) ? MAX_VALUE : COEFF_COST8x8[input->disthres][runs[MCcoeff]];

          img->cofAC[b8][MCcoeff][0][scan_poss[MCcoeff]] = isignab(level,img->m7[j][i]);
          img->cofAC[b8][MCcoeff][1][scan_poss[MCcoeff]] = runs[MCcoeff];
          ++scan_poss[MCcoeff];
          ++scan_pos;
          runs[MCcoeff]=-1;
        }
        else
        {
          *coeff_cost += (level > 1) ? MAX_VALUE : COEFF_COST8x8[input->disthres][run];
          ACLevel[scan_pos] = isignab(level,img->m7[j][i]);
          ACRun  [scan_pos] = run;
          ++scan_pos;
          run=-1;                     // reset zero level counter
        }

        level = isignab(level, img->m7[j][i]);

        ilev = rshift_rnd_sf(level*invlevelscale[j][i]<<qp_per, 6); // dequantization
      }
      img->m7[j][i] = ilev;
    }
  }
  else
  {
    // 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++)
    {
      i=pos_scan[coeff_ctr][0];
      j=pos_scan[coeff_ctr][1];

      MCcoeff = MC(coeff_ctr);
      run++;
      ilev=0;

      runs[MCcoeff]++;

      level = iabs (img->m7[j][i]);

      if (img->AdaptiveRounding)
      {
        img->fadjust8x8[intra][block_y+j][block_x+i] = 0;
      }

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

        if (currMB->luma_transform_size_8x8_flag && input->symbol_mode == UVLC)
        {
          *coeff_cost += MAX_VALUE;

          img->cofAC[b8][MCcoeff][0][scan_poss[MCcoeff]] = isignab(level,img->m7[j][i]);
          img->cofAC[b8][MCcoeff][1][scan_poss[MCcoeff]] = runs[MCcoeff];
          ++scan_poss[MCcoeff];
          ++scan_pos;
          runs[MCcoeff]=-1;
        }
        else
        {
          *coeff_cost += MAX_VALUE;
          ACLevel[scan_pos] = isignab(level,img->m7[j][i]);
          ACRun  [scan_pos] = run;
          ++scan_pos;
          run=-1;                     // reset zero level counter
        }

        level = isignab(level, img->m7[j][i]);
        ilev = level;
      }
    }
  }

  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)
  {
    if (scan_pos)
    {
      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];
      }

      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;
          enc_picture->imgY[ipix_y][img->pix_x + pix_x] = iClip1( img->max_imgpel_value, rshift_rnd_sf((img->m7[j][i]+((long)img->mpr[pix_y][pix_x] << DQ_BITS_8)),DQ_BITS_8));
        }
      }
    }
    else // no transform coefficients
    {
      for( j=block_y; j< block_y + 2*BLOCK_SIZE; j++)
      {
        memcpy(&(enc_picture->imgY[img->pix_y + j][img->pix_x + block_x]),&(img->mpr[j][block_x]), 2*BLOCK_SIZE * sizeof(imgpel));
      }
    }
  }
  else
  {
    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;
        img->m7[j][i] = img->m7[j][i] + img->mpr[pix_y][block_x+i];
        enc_picture->imgY[ipix_y][img->pix_x + pix_x]= (imgpel) img->m7[j][i];
      }
    }
  }

  //  Decoded block moved to frame memory
  return nonzero;
}