block.c

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

      for (j=0;j<BLOCK_SIZE;j++)
      {
        memcpy(&M1[jj*BLOCK_SIZE + j][ii*BLOCK_SIZE], M0[jj][ii][j], BLOCK_SIZE * sizeof(int));
      }
  }

  if(lossless_qpprime)
  {
    if(img->type!=SP_SLICE)
    {
      for (j=0;j<16;j++)
      {
        jj = img->pix_y+j;
        for (i=0;i<16;i++)
          enc_picture->imgY[jj][img->pix_x+i]=(imgpel)(M1[j][i]+img->mprr_2[new_intra_mode][j][i]);
      }
    }
    else
    {
      for (j = 0; j < MB_BLOCK_SIZE; j++)
      {
        jj = img->pix_y+j;
        for (i = 0; i < MB_BLOCK_SIZE ; i++)
        {
          enc_picture->imgY[jj][img->pix_x+i]=(imgpel)(M1[j][i]+img->mprr_2[new_intra_mode][j][i]);
          lrec[jj][img->pix_x+i] = -16; //signals an I16 block in the SP frame
        }
      }
    }
  }
  else
  {
    if(img->type!=SP_SLICE)
    {
      for (j=0;j<16;j++)
      {
        jj = img->pix_y+j;
        for (i=0;i<16;i++)
          enc_picture->imgY[jj][img->pix_x+i] =
          iClip1( img->max_imgpel_value, rshift_rnd_sf((M1[j][i]+((long)img->mprr_2[new_intra_mode][j][i]<<DQ_BITS)),DQ_BITS));
      }
    }
    else
    {
      for (j=0;j<16;j++)
      {
        jj = img->pix_y+j;
        for (i=0;i<16;i++)
        {
          enc_picture->imgY[jj][img->pix_x+i] =
            iClip1( img->max_imgpel_value, rshift_rnd_sf((M1[j][i]+((long)img->mprr_2[new_intra_mode][j][i]<<DQ_BITS)),DQ_BITS));
          lrec[jj][img->pix_x+i]=-16; //signals an I16 block in the SP frame
        }
      }
    }
  }

  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 i,j, ilev, coeff_ctr;
  static int m4[4][4], m5[4], m6[4];
  int level,scan_pos = 0,run = -1;
  int nonzero = FALSE;
  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];
  int   qp = currMB->qp + img->bitdepth_luma_qp_scale - MIN_QP;
  Boolean lossless_qpprime = (Boolean) (qp == 0 && img->lossless_qpprime_flag==1);

  int **levelscale,**leveloffset;
  int **invlevelscale;

  const byte (*pos_scan)[2] = currMB->is_field_mode ? FIELD_SCAN : SNGL_SCAN;

  qp_per = qp_per_matrix[qp];
  qp_rem = qp_rem_matrix[qp];
  q_bits = Q_BITS + qp_per;

  // select scaling parameters
  levelscale    = ptLevelScale4x4Luma[intra][qp_rem];
  invlevelscale = ptInvLevelScale4x4Luma[intra][qp_rem];
  leveloffset   = ptLevelOffset4x4Luma[intra][qp];

  if (!lossless_qpprime)
  {
    //  Horizontal transform
    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]<<1) + m5[2];
      m4[j][3] = m5[3]   - (m5[2]<<1);
    }

    //  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]<<1) + m5[2];
      m4[3][i] = m5[3]   - (m5[2]<<1);
    }

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

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

      run++;
      ilev=0;

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

      if (img->AdaptiveRounding)
      {
        img->fadjust4x4[intra][block_y+j][block_x+i] = (level == 0)
          ? 0
          : rshift_rnd_sf((AdaptRndWeight * (iabs(m4[j][i]) * levelscale[j][i] - (level << q_bits))), q_bits + 1);
      }

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

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

        ACLevel[scan_pos] = isignab(level,m4[j][i]);

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

        level = isignab(level, m4[j][i]);
        ilev  = rshift_rnd_sf(((level*invlevelscale[j][i])<< qp_per), 4);
      }
      m4[j][i]=ilev;
    }

    ACLevel[scan_pos] = 0;

    if (scan_pos)
    {
      //     IDCT.
      //     horizontal
      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);

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

      // generate final block
      for (j=0; j < BLOCK_SIZE; j++)
      {        
        for (i=0; i < BLOCK_SIZE; i++)
        {
          enc_picture->imgY[img->pix_y + block_y + j][img->pix_x + block_x + i]     
          = iClip1( img->max_imgpel_value, rshift_rnd_sf((img->m7[j][i]+((long)img->mpr[block_y + j][block_x + i] << DQ_BITS)),DQ_BITS));
        }
      }

    }
    else // no transformed residual;
    {
      for (j=block_y; j < block_y + BLOCK_SIZE; j++)
      {
        memcpy(&(enc_picture->imgY[img->pix_y + j][img->pix_x + block_x]),&(img->mpr[j][block_x]), BLOCK_SIZE * sizeof(imgpel));
      }
    }
  }
  else // Lossless qpprime code
  {
    for (coeff_ctr=0;coeff_ctr < 16;coeff_ctr++)
    {
      i=pos_scan[coeff_ctr][0];
      j=pos_scan[coeff_ctr][1];

      run++;
      ilev=0;

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

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

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

        *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, m4[j][i]);

        ilev=level;
      }
    }
    ACLevel[scan_pos] = 0;

    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]+img->mpr[j+block_y][i+block_x];
      }
    }
  }

  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
 *    once 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;
  static 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
  static const int64 cbpblk_pattern[4]={0, 0xf0000, 0xff0000, 0xffff0000};
  int yuv = img->yuv_format;
  int b8;
  static int m3[4][4];
  static 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;
  const byte (*pos_scan)[2] = currMB->is_field_mode ? FIELD_SCAN : SNGL_SCAN;
  int cur_qp = currMB->qpc[uv] + img->bitdepth_chroma_qp_scale;
  int cur_qp_dc = currMB->qpc[uv] + 3 + img->bitdepth_chroma_qp_scale;

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

  qp_per = qp_per_matrix[cur_qp];
  qp_rem = qp_rem_matrix[cur_qp];
  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_per_matrix[cur_qp_dc];
    qp_rem_dc = qp_rem_matrix[cur_qp_dc];

    q_bits_422 = Q_BITS + qp_per_dc;
  }


  //============= dct transform ===============
  if (!lossless_qpprime)
  {
    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; 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]<<1) + m5[2];
          img->m7[mb_y][n1+3] =  m5[3]   - (m5[2]<<1);
        }

        //  Vertical transform.
        for (i=0; i < BLOCK_SIZE; 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  ][j1] = (m5[0]     + m5[1]);
          img->m7[n2+2][j1] = (m5[0]     - m5[1]);
          img->m7[n2+1][j1] = (m5[3]<<1) + m5[2];
          img->m7[n2+3][j1] =  m5[3]     - (m5[2]<<1);
        }
      }
    }
  }

  if (yuv == YUV420)
  {
    //================== CHROMA DC YUV420 ===================
    //     2X2 transform of DC coeffs.
    run=-1;
    scan_pos=0;
    if(!lossless_qpprime)
    {
      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.
      for (coeff_ctr=0; coeff_ctr < 4; coeff_ctr++)
      {
        run++;
        ilev=0;

        level =(iabs(m1[coeff_ctr]) * levelscale[qp_rem][0][0] + (leveloffset[cur_qp][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=imax(1,cr_cbp);                     // coded-bit all 4 4x4 blocks (bit 16-19 or 20-23)
          DCcoded = 1 ;
          DCLevel[scan_pos] = isignab(level ,m1[coeff_ctr]);
          DCRun  [scan_pos] = run;
          scan_pos++;
          run=-1;

          ilev=isignab(level, m1[coeff_ctr]);
        }
        m1[coeff_ctr]=ilev;
      }

      DCLevel[scan_pos] = 0;
      //  Inverse transform of 2x2 DC levels
      m5[0]=(m1[0] + m1[1] + m1[2] + m1[3]);
      m5[1]=(m1[0] - m1[1] + m1[2] - m1[3]);