block.c

H.264编码实现

  PixelPos left[17];    //!< pixel positions p(-1, -1..15)

  int up_avail, left_avail, left_up_avail;

  s1=s2=0;

  for (i=0;i<17;i++)
  {
    getNeighbour(currMB, -1 ,  i-1 , img->mb_size[IS_LUMA], &left[i]);
  }
  getNeighbour(currMB, 0     ,  -1 , img->mb_size[IS_LUMA], &up);

  if (!active_pps->constrained_intra_pred_flag)
  {
    up_avail   = up.available;
    left_avail = left[1].available;
    left_up_avail = left[0].available;
  }
  else
  {
    up_avail      = up.available ? img->intra_block[up.mb_addr] : 0;
    for (i=1, left_avail=1; i<17;i++)
      left_avail  &= left[i].available ? img->intra_block[left[i].mb_addr]: 0;
    left_up_avail = left[0].available ? img->intra_block[left[0].mb_addr]: 0;
  }

  switch (predmode)
  {
  case VERT_PRED_16:                       // vertical prediction from block above
    if (!up_avail)
      error ("invalid 16x16 intra pred Mode VERT_PRED_16",500);
    for(j=0;j<MB_BLOCK_SIZE;j++)
      memcpy(img->mb_pred[pl][j], &(imgY[up.pos_y][up.pos_x]), MB_BLOCK_SIZE * sizeof(imgpel));
    break;
  case HOR_PRED_16:                        // horizontal prediction from left block
    if (!left_avail)
      error ("invalid 16x16 intra pred Mode HOR_PRED_16",500);
    for(j = 0; j < MB_BLOCK_SIZE; j++)
    {
      prediction = imgY[left[j+1].pos_y][left[j+1].pos_x];
      for(i=0;i<MB_BLOCK_SIZE;i++)
        mpr[j][i]= prediction; // store predicted 16x16 block
    }
    break;
  case DC_PRED_16:                         // DC prediction
    s1=s2=0;
    for (i = 0; i < MB_BLOCK_SIZE; i++)
    {
      if (up_avail)
        s1 += imgY[up.pos_y][up.pos_x+i];    // sum hor pix
      if (left_avail)
        s2 += imgY[left[i + 1].pos_y][left[i + 1].pos_x];    // sum vert pix
    }
    if (up_avail && left_avail)
      s0 = (s1 + s2 + 16)>>5;       // no edge
    if (!up_avail && left_avail)
      s0 = (s2 + 8)>>4;              // upper edge
    if (up_avail && !left_avail)
      s0 = (s1 + 8)>>4;              // left edge
    if (!up_avail && !left_avail)
      s0 = img->dc_pred_value_comp[pl];                            // top left corner, nothing to predict from

    for(j = 0; j < MB_BLOCK_SIZE; j++)
      for(i = 0; i < MB_BLOCK_SIZE; i++)
      {
        mpr[j][i]=(imgpel) s0;
      }

    break;
  case PLANE_16:// 16 bit integer plan pred
    if (!up_avail || !left_up_avail  || !left_avail)
      error ("invalid 16x16 intra pred Mode PLANE_16",500);

    ih=0;
    iv=0;

    mpr_line = &imgY[up.pos_y][up.pos_x+7];
    for (i = 1; i < 8; i++)
    {
      ih += i*(mpr_line[i] - mpr_line[-i]);
      iv += i*(imgY[left[8+i].pos_y][left[8+i].pos_x] - imgY[left[8-i].pos_y][left[8-i].pos_x]);
    }

    ih += 8*(mpr_line[8] - imgY[left[0].pos_y][left[0].pos_x]);
    iv += 8*(imgY[left[16].pos_y][left[16].pos_x] - imgY[left[0].pos_y][left[0].pos_x]);

    ib=(5*ih+32)>>6;
    ic=(5*iv+32)>>6;

    iaa=16*(mpr_line[8] + imgY[left[16].pos_y][left[16].pos_x]);
    for (j=0;j< MB_BLOCK_SIZE;j++)
    {
      for (i=0;i< MB_BLOCK_SIZE;i++)
      {
        mpr[j][i]=(imgpel) iClip1(max_imgpel_value,((iaa+(i-7)*ib +(j-7)*ic + 16)>>5));
      }
    }// store plane prediction
    break;

  default:
    {                                    // indication of fault in bitstream,exit
      printf("illegal 16x16 intra prediction mode input: %d\n",predmode);
      return SEARCH_SYNC;
    }
  }

  return DECODING_OK;
}

/*!
 ************************************************************************
 * \brief
 *    Chroma Intra prediction. Note that many operations can be moved
 *    outside since they are repeated for both components for no reason.
 ************************************************************************
 */

void intrapred_chroma(ImageParameters *img, Macroblock *currMB, int uv)
{
  int i,j, ii, jj;

  imgpel **imgUV = dec_picture->imgUV[uv];
  imgpel (*mpr)[16] = img->mb_pred[uv + 1];
  int     max_imgpel_value = img->max_imgpel_value_comp[uv + 1];
  
  int ih, iv, ib, ic, iaa;

  int        b8, b4;
  int        yuv = dec_picture->chroma_format_idc - 1;
  int        blk_x, blk_y;
  int        pred;
  static int block_pos[3][4][4]= //[yuv][b8][b4]
  {
    { {0, 1, 2, 3},{0, 0, 0, 0},{0, 0, 0, 0},{0, 0, 0, 0}},
    { {0, 1, 2, 3},{2, 3, 2, 3},{0, 0, 0, 0},{0, 0, 0, 0}},
    { {0, 1, 2, 3},{1, 1, 3, 3},{2, 3, 2, 3},{3, 3, 3, 3}}
  };

  PixelPos up;        //!< pixel position  p(0,-1)
  PixelPos left[17];  //!< pixel positions p(-1, -1..16)

  int up_avail, left_avail[2], left_up_avail;

  int cr_MB_x = img->mb_cr_size_x;
  int cr_MB_y = img->mb_cr_size_y;
  int cr_MB_y2 = (cr_MB_y >> 1);
  int cr_MB_x2 = (cr_MB_x >> 1);

  for (i=0; i < cr_MB_y + 1 ; i++)
  {
    getNeighbour(currMB, -1, i-1, img->mb_size[IS_CHROMA], &left[i]);
  }

  getNeighbour(currMB, 0, -1, img->mb_size[IS_CHROMA], &up);

  if (!active_pps->constrained_intra_pred_flag)
  {
    up_avail      = up.available;
    left_avail[0] = left_avail[1] = left[1].available;
    left_up_avail = left[0].available;
  }
  else
  {
    up_avail = up.available ? img->intra_block[up.mb_addr] : 0;
    for (i=0, left_avail[0] = 1; i < cr_MB_y2;i++)
      left_avail[0]  &= left[i + 1].available ? img->intra_block[left[i + 1].mb_addr]: 0;
    for (i = cr_MB_y2, left_avail[1] = 1; i<cr_MB_y;i++)
      left_avail[1]  &= left[i + 1].available ? img->intra_block[left[i + 1].mb_addr]: 0;
    left_up_avail = left[0].available ? img->intra_block[left[0].mb_addr]: 0;
  }

  switch (currMB->c_ipred_mode)
  {
  case DC_PRED_8:
    // DC prediction
    // Note that unlike what is stated in many presentations and papers, this mode does not operate
    // the same way as I_16x16 DC prediction.
    for(b8 = 0; b8 < (img->num_uv_blocks) ;b8++)
    {
      for (b4 = 0; b4 < 4; b4++)
      {
        blk_y = subblk_offset_y[yuv][b8][b4];
        blk_x = subblk_offset_x[yuv][b8][b4];

        pred = img->dc_pred_value_comp[1];

        //===== get prediction value =====
        switch (block_pos[yuv][b8][b4])
        {
        case 0:  //===== TOP LEFT =====
          intra_chroma_DC_all   (imgUV, up_avail, left_avail[0], up, left, blk_x, blk_y + 1, &pred);
          break;
        case 1: //===== TOP RIGHT =====
          intra_chroma_DC_single(imgUV, up_avail, left_avail[0], up, left, blk_x, blk_y + 1, &pred, 1);
          break;
        case 2: //===== BOTTOM LEFT =====
          intra_chroma_DC_single(imgUV, up_avail, left_avail[1], up, left, blk_x, blk_y + 1, &pred, 0);
          break;
        case 3: //===== BOTTOM RIGHT =====
          intra_chroma_DC_all   (imgUV, up_avail, left_avail[1], up, left, blk_x, blk_y + 1, &pred);          
          break;
        }
        
        for (jj = blk_y; jj < blk_y + BLOCK_SIZE; jj++)
          for (ii = blk_x; ii < blk_x + BLOCK_SIZE; ii++)
          {
            mpr[jj][ii]=(imgpel) pred;
          }
      }
    }
    break;
  case HOR_PRED_8:
    // Horizontal Prediction
    if (!left_avail[0] || !left_avail[1])
      error("unexpected HOR_PRED_8 chroma intra prediction mode",-1);

    for (j = 0; j < cr_MB_y; j++)
    {
      pred = imgUV[left[1 + j].pos_y][left[1 + j].pos_x];
      for (i = 0; i < cr_MB_x; i++)
        mpr[j][i]=(imgpel) pred;
    }

    break;
  case VERT_PRED_8:
    // Vertical Prediction
    if (!up_avail)
      error("unexpected VERT_PRED_8 chroma intra prediction mode",-1);

    for (j = 0; j < cr_MB_y; j++)
    {
      memcpy(&(mpr[j][0]), &(imgUV[up.pos_y][up.pos_x]), cr_MB_x * sizeof(imgpel));
    }
    break;
  case PLANE_8:
    // plane prediction
    if (!left_up_avail || !left_avail[0] || !left_avail[1] || !up_avail)
      error("unexpected PLANE_8 chroma intra prediction mode",-1);
    else
    {
      imgpel *upPred = &imgUV[up.pos_y][up.pos_x];

      ih = cr_MB_x2 * (upPred[cr_MB_x - 1] - imgUV[left[0].pos_y][left[0].pos_x]);
      for (i = 0; i < cr_MB_x2 - 1; i++)
        ih += (i + 1) * (upPred[cr_MB_x2 + i] - upPred[cr_MB_x2 - 2 - i]);

      iv = cr_MB_y2 * (imgUV[left[cr_MB_y].pos_y][left[cr_MB_y].pos_x] - imgUV[left[0].pos_y][left[0].pos_x]);
      for (i = 0; i < cr_MB_y2 - 1; i++)
        iv += (i + 1)*(imgUV[left[cr_MB_y2 + 1 + i].pos_y][left[cr_MB_y2 + 1 + i].pos_x] -
        imgUV[left[cr_MB_y2 - 1 - i].pos_y][left[cr_MB_y2 - 1 - i].pos_x]);

      ib= ((cr_MB_x == 8 ? 17 : 5) * ih + 2 * cr_MB_x)>>(cr_MB_x == 8 ? 5 : 6);
      ic= ((cr_MB_y == 8 ? 17 : 5) * iv + 2 * cr_MB_y)>>(cr_MB_y == 8 ? 5 : 6);

      iaa=16*(imgUV[left[cr_MB_y].pos_y][left[cr_MB_y].pos_x] + upPred[cr_MB_x-1]);

      for (j = 0; j < cr_MB_y; j++)
        for (i = 0; i < cr_MB_x; i++)
          mpr[j][i]=(imgpel) iClip1(max_imgpel_value, ((iaa + (i - cr_MB_x2 + 1) * ib + (j - cr_MB_y2 + 1) * ic + 16) >> 5));  }
    break;
  default:
    error("illegal chroma intra prediction mode", 600);
    break;
  }
}

/*!
 ***********************************************************************
 * \brief
 *    Inverse 4x4 transformation, transforms cof to m7
 ***********************************************************************
 */
void itrans4x4(ImageParameters *img, //!< image parameters
               ColorPlane pl,              
               int ioff,            //!< index to 4x4 block
               int joff)            //!<
{
  static int i,j;

  int max_imgpel_value = img->max_imgpel_value_comp[pl];

  imgpel (*mpr)[MB_BLOCK_SIZE] = img->mb_pred[pl];
  int    (*m7) [MB_BLOCK_SIZE] = img->mb_rres[pl];

  inverse4x4(img->cof[pl],m7,joff,ioff);

  for (j = joff; j < joff + BLOCK_SIZE; j++)
  {
    for (i = ioff; i < ioff + BLOCK_SIZE; i++)
    {      
      m7[j][i] = iClip1(max_imgpel_value, rshift_rnd_sf((m7[j][i] + ((long)mpr[j][i] << DQ_BITS)), DQ_BITS));
    }
  }
}

/*!
 ***********************************************************************
 * \brief
 *    Inverse 4x4 lossless_qpprime transformation, transforms cof to m7
 ***********************************************************************
 */
void itrans4x4_ls(ImageParameters *img, //!< image parameters
                  ColorPlane pl,        //!< Color plane (for 4:4:4)                  
                  int ioff,             //!< index to 4x4 block
                  int joff)             //!<
{
  static int i,j;

  int max_imgpel_value = img->max_imgpel_value_comp[pl];

  imgpel (*mpr)[16] = img->mb_pred[pl];
  int    ( *m7)[16] = img->mb_rres [pl];

  inverse4x4(img->cof[pl],m7,joff,ioff);

  for (j = joff; j < joff + BLOCK_SIZE; j++)
  {
    for (i = ioff; i < ioff + BLOCK_SIZE; i++)
    {      
      m7[j][i] = iClip1(max_imgpel_value, rshift_rnd_sf((m7[j][i] + ((long)mpr[j][i] << DQ_BITS)), DQ_BITS));
    }
  }
}

/*!
************************************************************************
* \brief
*    Inverse residual DPCM for Intra lossless coding
*
* \par Input:
*    ioff_x,joff_y: Block position inside a macro block (0,4,8,12).
************************************************************************
*/  //For residual DPCM
void Inv_Residual_trans_4x4(ImageParameters *img, //!< image parameters
                            ColorPlane pl,                            
                            int ioff,            //!< index to 4x4 block
                            int joff)
{
  int i,j;
  int temp[4][4];
  imgpel (*mpr)[MB_BLOCK_SIZE] = img->mb_pred[pl];
  int    (*m7) [MB_BLOCK_SIZE] = img->mb_rres[pl];
  int    (*cof)[MB_BLOCK_SIZE] = img->cof[pl];

  if(ipmode_DPCM==VERT_PRED)
  {
    for(i=0; i<4; i++)
    {
      temp[0][i] = cof[joff + 0][ioff + i];
      temp[1][i] = cof[joff + 1][ioff + i] + temp[0][i];
      temp[2][i] = cof[joff + 2][ioff + i] + temp[1][i];
      temp[3][i] = cof[joff + 3][ioff + i] + temp[2][i];
    }
    for(i=0; i<4; i++)
    {
      m7[joff    ][ioff + i]=temp[0][i];
      m7[joff + 1][ioff + i]=temp[1][i];
      m7[joff + 2][ioff + i]=temp[2][i];
      m7[joff + 3][ioff + i]=temp[3][i];
    }
  }
  else if(ipmode_DPCM==HOR_PRED)
  {
    for(j=0; j<4; j++)
    {
      temp[j][0] = cof[joff + j][ioff    ];
      temp[j][1] = cof[joff + j][ioff + 1] + temp[j][0];
      temp[j][2] = cof[joff + j][ioff + 2] + temp[j][1];
      temp[j][3] = cof[joff + j][ioff + 3] + temp[j][2];
    }
    for(j=0; j<4; j++)
    {
      m7[joff + j][ioff    ]=temp[j][0];
      m7[joff + j][ioff + 1]=temp[j][1];
      m7[joff + j][ioff + 2]=temp[j][2];
      m7[joff + j][ioff + 3]=temp[j][3];
    }
  }
  else
  {
    for (j = 0; j < BLOCK_SIZE; j++)
      for (i = 0; i < BLOCK_SIZE; i++)
        m7[joff+j][ioff+i] = cof[joff+j][ioff+i];
  }
  for (j = 0; j < BLOCK_SIZE; j++)
    for (i = 0; i < BLOCK_SIZE; i++)
      m7[joff+j][ioff+i] +=  (long)mpr[joff+j][ioff+i];

}

/*!
************************************************************************
* \brief
*    Inverse residual DPCM for Intra lossless coding
*
* \par Input:
*    ioff_x,joff_y: Block position inside a macro block (0,8).
************************************************************************
*/
//For residual DPCM
void Inv_Residual_trans_8x8(ImageParameters *img, Macroblock *currMB, ColorPlane pl, int ioff,int joff)
{
  int i, j;
  int temp[8][8];
  imgpel (*mpr)[16] = img->mb_pred[pl];
  int    (*m7) [16] = img->mb_rres[pl];
  

  if(ipmode_DPCM==VERT_PRED)
    {
      for(i=0; i<8; i++)
      {
        temp[0][i] = m7[joff + 0][ioff + i];
        temp[1][i] = m7[joff + 1][ioff + i] + temp[0][i];
        temp[2][i] = m7[joff + 2][ioff + i] + temp[1][i];
        temp[3][i] = m7[joff + 3][ioff + i] + temp[2][i];
        temp[4][i] = m7[joff + 4][ioff + i] + temp[3][i];
        temp[5][i] = m7[joff + 5][ioff + i] + temp[4][i];
        temp[6][i] = m7[joff + 6][ioff + i] + temp[5][i];
        temp[7][i] = m7[joff + 7][ioff + i] + temp[6][i];
      }
      for(i=0; i<8; i++)
      {
        m7[joff  ][ioff+i]=temp[0][i];
        m7[joff+1][ioff+i]=temp[1][i];
        m7[joff+2][ioff+i]=temp[2][i];
        m7[joff+3][ioff+i]=temp[3][i];
        m7[joff+4][ioff+i]=temp[4][i];
        m7[joff+5][ioff+i]=temp[5][i];
        m7[joff+6][ioff+i]=temp[6][i];
        m7[joff+7][ioff+i]=temp[7][i];
      }
    }
    else if(ipmode_DPCM==HOR_PRED)//HOR_PRED