transform8x8.c

H.264编码实现

    mpr[jpos5][ipos5] =
    mpr[jpos7][ipos4] = (imgpel) ((P_H + P_J + 2*P_I + 2) >> 2);
    mpr[jpos3][ipos7] =
    mpr[jpos5][ipos6] =
    mpr[jpos7][ipos5] = (imgpel) ((P_I + P_K + 2*P_J + 2) >> 2);
    mpr[jpos5][ipos7] =
    mpr[jpos7][ipos6] = (imgpel) ((P_J + P_L + 2*P_K + 2) >> 2);
    mpr[jpos7][ipos7] = (imgpel) ((P_K + P_M + 2*P_L + 2) >> 2);
    break;


  case DIAG_DOWN_RIGHT_PRED:
    if ((!block_available_up)||(!block_available_left)||(!block_available_up_left))
      printf ("warning: Intra_8x8_Diagonal_Down_Right prediction mode not allowed at mb %d\n", (int) img->current_mb_nr);

    // Mode DIAG_DOWN_RIGHT_PRED
    mpr[jpos7][ipos0] = (imgpel) ((P_X + P_V + 2*(P_W) + 2) >> 2);
    mpr[jpos6][ipos0] =
    mpr[jpos7][ipos1] = (imgpel) ((P_W + P_U + 2*(P_V) + 2) >> 2);
    mpr[jpos5][ipos0] =
    mpr[jpos6][ipos1] =
    mpr[jpos7][ipos2] = (imgpel) ((P_V + P_T + 2*(P_U) + 2) >> 2);
    mpr[jpos4][ipos0] =
    mpr[jpos5][ipos1] =
    mpr[jpos6][ipos2] =
    mpr[jpos7][ipos3] = (imgpel) ((P_U + P_S + 2*(P_T) + 2) >> 2);
    mpr[jpos3][ipos0] =
    mpr[jpos4][ipos1] =
    mpr[jpos5][ipos2] =
    mpr[jpos6][ipos3] =
    mpr[jpos7][ipos4] = (imgpel) ((P_T + P_R + 2*(P_S) + 2) >> 2);
    mpr[jpos2][ipos0] =
    mpr[jpos3][ipos1] =
    mpr[jpos4][ipos2] =
    mpr[jpos5][ipos3] =
    mpr[jpos6][ipos4] =
    mpr[jpos7][ipos5] = (imgpel) ((P_S + P_Q + 2*(P_R) + 2) >> 2);
    mpr[jpos1][ipos0] =
    mpr[jpos2][ipos1] =
    mpr[jpos3][ipos2] =
    mpr[jpos4][ipos3] =
    mpr[jpos5][ipos4] =
    mpr[jpos6][ipos5] =
    mpr[jpos7][ipos6] = (imgpel) ((P_R + P_Z + 2*(P_Q) + 2) >> 2);
    mpr[jpos0][ipos0] =
    mpr[jpos1][ipos1] =
    mpr[jpos2][ipos2] =
    mpr[jpos3][ipos3] =
    mpr[jpos4][ipos4] =
    mpr[jpos5][ipos5] =
    mpr[jpos6][ipos6] =
    mpr[jpos7][ipos7] = (imgpel) ((P_Q + P_A + 2*(P_Z) + 2) >> 2);
    mpr[jpos0][ipos1] =
    mpr[jpos1][ipos2] =
    mpr[jpos2][ipos3] =
    mpr[jpos3][ipos4] =
    mpr[jpos4][ipos5] =
    mpr[jpos5][ipos6] =
    mpr[jpos6][ipos7] = (imgpel) ((P_Z + P_B + 2*(P_A) + 2) >> 2);
    mpr[jpos0][ipos2] =
    mpr[jpos1][ipos3] =
    mpr[jpos2][ipos4] =
    mpr[jpos3][ipos5] =
    mpr[jpos4][ipos6] =
    mpr[jpos5][ipos7] = (imgpel) ((P_A + P_C + 2*(P_B) + 2) >> 2);
    mpr[jpos0][ipos3] =
    mpr[jpos1][ipos4] =
    mpr[jpos2][ipos5] =
    mpr[jpos3][ipos6] =
    mpr[jpos4][ipos7] = (imgpel) ((P_B + P_D + 2*(P_C) + 2) >> 2);
    mpr[jpos0][ipos4] =
    mpr[jpos1][ipos5] =
    mpr[jpos2][ipos6] =
    mpr[jpos3][ipos7] = (imgpel) ((P_C + P_E + 2*(P_D) + 2) >> 2);
    mpr[jpos0][ipos5] =
    mpr[jpos1][ipos6] =
    mpr[jpos2][ipos7] = (imgpel) ((P_D + P_F + 2*(P_E) + 2) >> 2);
    mpr[jpos0][ipos6] =
    mpr[jpos1][ipos7] = (imgpel) ((P_E + P_G + 2*(P_F) + 2) >> 2);
    mpr[jpos0][ipos7] = (imgpel) ((P_F + P_H + 2*(P_G) + 2) >> 2);
    break;

  case  VERT_RIGHT_PRED:/* diagonal prediction -22.5 deg to horizontal plane */
    if ((!block_available_up)||(!block_available_left)||(!block_available_up_left))
      printf ("warning: Intra_8x8_Vertical_Right prediction mode not allowed at mb %d\n", (int) img->current_mb_nr);

    mpr[jpos0][ipos0] =
    mpr[jpos2][ipos1] =
    mpr[jpos4][ipos2] =
    mpr[jpos6][ipos3] = (imgpel) ((P_Z + P_A + 1) >> 1);
    mpr[jpos0][ipos1] =
    mpr[jpos2][ipos2] =
    mpr[jpos4][ipos3] =
    mpr[jpos6][ipos4] = (imgpel) ((P_A + P_B + 1) >> 1);
    mpr[jpos0][ipos2] =
    mpr[jpos2][ipos3] =
    mpr[jpos4][ipos4] =
    mpr[jpos6][ipos5] = (imgpel) ((P_B + P_C + 1) >> 1);
    mpr[jpos0][ipos3] =
    mpr[jpos2][ipos4] =
    mpr[jpos4][ipos5] =
    mpr[jpos6][ipos6] = (imgpel) ((P_C + P_D + 1) >> 1);
    mpr[jpos0][ipos4] =
    mpr[jpos2][ipos5] =
    mpr[jpos4][ipos6] =
    mpr[jpos6][ipos7] = (imgpel) ((P_D + P_E + 1) >> 1);
    mpr[jpos0][ipos5] =
    mpr[jpos2][ipos6] =
    mpr[jpos4][ipos7] = (imgpel) ((P_E + P_F + 1) >> 1);
    mpr[jpos0][ipos6] =
    mpr[jpos2][ipos7] = (imgpel) ((P_F + P_G + 1) >> 1);
    mpr[jpos0][ipos7] = (imgpel) ((P_G + P_H + 1) >> 1);
    mpr[jpos1][ipos0] =
    mpr[jpos3][ipos1] =
    mpr[jpos5][ipos2] =
    mpr[jpos7][ipos3] = (imgpel) ((P_Q + P_A + 2*P_Z + 2) >> 2);
    mpr[jpos1][ipos1] =
    mpr[jpos3][ipos2] =
    mpr[jpos5][ipos3] =
    mpr[jpos7][ipos4] = (imgpel) ((P_Z + P_B + 2*P_A + 2) >> 2);
    mpr[jpos1][ipos2] =
    mpr[jpos3][ipos3] =
    mpr[jpos5][ipos4] =
    mpr[jpos7][ipos5] = (imgpel) ((P_A + P_C + 2*P_B + 2) >> 2);
    mpr[jpos1][ipos3] =
    mpr[jpos3][ipos4] =
    mpr[jpos5][ipos5] =
    mpr[jpos7][ipos6] = (imgpel) ((P_B + P_D + 2*P_C + 2) >> 2);
    mpr[jpos1][ipos4] =
    mpr[jpos3][ipos5] =
    mpr[jpos5][ipos6] =
    mpr[jpos7][ipos7] = (imgpel) ((P_C + P_E + 2*P_D + 2) >> 2);
    mpr[jpos1][ipos5] =
    mpr[jpos3][ipos6] =
    mpr[jpos5][ipos7] = (imgpel) ((P_D + P_F + 2*P_E + 2) >> 2);
    mpr[jpos1][ipos6] =
    mpr[jpos3][ipos7] = (imgpel) ((P_E + P_G + 2*P_F + 2) >> 2);
    mpr[jpos1][ipos7] = (imgpel) ((P_F + P_H + 2*P_G + 2) >> 2);
    mpr[jpos2][ipos0] =
    mpr[jpos4][ipos1] =
    mpr[jpos6][ipos2] = (imgpel) ((P_R + P_Z + 2*P_Q + 2) >> 2);
    mpr[jpos3][ipos0] =
    mpr[jpos5][ipos1] =
    mpr[jpos7][ipos2] = (imgpel) ((P_S + P_Q + 2*P_R + 2) >> 2);
    mpr[jpos4][ipos0] =
    mpr[jpos6][ipos1] = (imgpel) ((P_T + P_R + 2*P_S + 2) >> 2);
    mpr[jpos5][ipos0] =
    mpr[jpos7][ipos1] = (imgpel) ((P_U + P_S + 2*P_T + 2) >> 2);
    mpr[jpos6][ipos0] = (imgpel) ((P_V + P_T + 2*P_U + 2) >> 2);
    mpr[jpos7][ipos0] = (imgpel) ((P_W + P_U + 2*P_V + 2) >> 2);
    break;

  case  HOR_DOWN_PRED:/* diagonal prediction -22.5 deg to horizontal plane */
    if ((!block_available_up)||(!block_available_left)||(!block_available_up_left))
      printf ("warning: Intra_8x8_Horizontal_Down prediction mode not allowed at mb %d\n", (int) img->current_mb_nr);

    mpr[jpos0][ipos0] =
    mpr[jpos1][ipos2] =
    mpr[jpos2][ipos4] =
    mpr[jpos3][ipos6] = (imgpel) ((P_Q + P_Z + 1) >> 1);
    mpr[jpos1][ipos0] =
    mpr[jpos2][ipos2] =
    mpr[jpos3][ipos4] =
    mpr[jpos4][ipos6] = (imgpel) ((P_R + P_Q + 1) >> 1);
    mpr[jpos2][ipos0] =
    mpr[jpos3][ipos2] =
    mpr[jpos4][ipos4] =
    mpr[jpos5][ipos6] = (imgpel) ((P_S + P_R + 1) >> 1);
    mpr[jpos3][ipos0] =
    mpr[jpos4][ipos2] =
    mpr[jpos5][ipos4] =
    mpr[jpos6][ipos6] = (imgpel) ((P_T + P_S + 1) >> 1);
    mpr[jpos4][ipos0] =
    mpr[jpos5][ipos2] =
    mpr[jpos6][ipos4] =
    mpr[jpos7][ipos6] = (imgpel) ((P_U + P_T + 1) >> 1);
    mpr[jpos5][ipos0] =
    mpr[jpos6][ipos2] =
    mpr[jpos7][ipos4] = (imgpel) ((P_V + P_U + 1) >> 1);
    mpr[jpos6][ipos0] =
    mpr[jpos7][ipos2] = (imgpel) ((P_W + P_V + 1) >> 1);
    mpr[jpos7][ipos0] = (imgpel) ((P_X + P_W + 1) >> 1);
    mpr[jpos0][ipos1] =
    mpr[jpos1][ipos3] =
    mpr[jpos2][ipos5] =
    mpr[jpos3][ipos7] = (imgpel) ((P_Q + P_A + 2*P_Z + 2) >> 2);
    mpr[jpos1][ipos1] =
    mpr[jpos2][ipos3] =
    mpr[jpos3][ipos5] =
    mpr[jpos4][ipos7] = (imgpel) ((P_Z + P_R + 2*P_Q + 2) >> 2);
    mpr[jpos2][ipos1] =
    mpr[jpos3][ipos3] =
    mpr[jpos4][ipos5] =
    mpr[jpos5][ipos7] = (imgpel) ((P_Q + P_S + 2*P_R + 2) >> 2);
    mpr[jpos3][ipos1] =
    mpr[jpos4][ipos3] =
    mpr[jpos5][ipos5] =
    mpr[jpos6][ipos7] = (imgpel) ((P_R + P_T + 2*P_S + 2) >> 2);
    mpr[jpos4][ipos1] =
    mpr[jpos5][ipos3] =
    mpr[jpos6][ipos5] =
    mpr[jpos7][ipos7] = (imgpel) ((P_S + P_U + 2*P_T + 2) >> 2);
    mpr[jpos5][ipos1] =
    mpr[jpos6][ipos3] =
    mpr[jpos7][ipos5] = (imgpel) ((P_T + P_V + 2*P_U + 2) >> 2);
    mpr[jpos6][ipos1] =
    mpr[jpos7][ipos3] = (imgpel) ((P_U + P_W + 2*P_V + 2) >> 2);
    mpr[jpos7][ipos1] = (imgpel) ((P_V + P_X + 2*P_W + 2) >> 2);
    mpr[jpos0][ipos2] =
    mpr[jpos1][ipos4] =
    mpr[jpos2][ipos6] = (imgpel) ((P_Z + P_B + 2*P_A + 2) >> 2);
    mpr[jpos0][ipos3] =
    mpr[jpos1][ipos5] =
    mpr[jpos2][ipos7] = (imgpel) ((P_A + P_C + 2*P_B + 2) >> 2);
    mpr[jpos0][ipos4] =
    mpr[jpos1][ipos6] = (imgpel) ((P_B + P_D + 2*P_C + 2) >> 2);
    mpr[jpos0][ipos5] =
    mpr[jpos1][ipos7] = (imgpel) ((P_C + P_E + 2*P_D + 2) >> 2);
    mpr[jpos0][ipos6] = (imgpel) ((P_D + P_F + 2*P_E + 2) >> 2);
    mpr[jpos0][ipos7] = (imgpel) ((P_E + P_G + 2*P_F + 2) >> 2);
    break;

  case  HOR_UP_PRED:/* diagonal prediction -22.5 deg to horizontal plane */
    if (!block_available_left)
      printf ("warning: Intra_8x8_Horizontal_Up prediction mode not allowed at mb %d\n", (int) img->current_mb_nr);

    mpr[jpos0][ipos0] = (imgpel) ((P_Q + P_R + 1) >> 1);
    mpr[jpos1][ipos0] =
    mpr[jpos0][ipos2] = (imgpel) ((P_R + P_S + 1) >> 1);
    mpr[jpos2][ipos0] =
    mpr[jpos1][ipos2] =
    mpr[jpos0][ipos4] = (imgpel) ((P_S + P_T + 1) >> 1);
    mpr[jpos3][ipos0] =
    mpr[jpos2][ipos2] =
    mpr[jpos1][ipos4] =
    mpr[jpos0][ipos6] = (imgpel) ((P_T + P_U + 1) >> 1);
    mpr[jpos4][ipos0] =
    mpr[jpos3][ipos2] =
    mpr[jpos2][ipos4] =
    mpr[jpos1][ipos6] = (imgpel) ((P_U + P_V + 1) >> 1);
    mpr[jpos5][ipos0] =
    mpr[jpos4][ipos2] =
    mpr[jpos3][ipos4] =
    mpr[jpos2][ipos6] = (imgpel) ((P_V + P_W + 1) >> 1);
    mpr[jpos6][ipos0] =
    mpr[jpos5][ipos2] =
    mpr[jpos4][ipos4] =
    mpr[jpos3][ipos6] = (imgpel) ((P_W + P_X + 1) >> 1);
    mpr[jpos4][ipos6] =
    mpr[jpos4][ipos7] =
    mpr[jpos5][ipos4] =
    mpr[jpos5][ipos5] =
    mpr[jpos5][ipos6] =
    mpr[jpos5][ipos7] =
    mpr[jpos6][ipos2] =
    mpr[jpos6][ipos3] =
    mpr[jpos6][ipos4] =
    mpr[jpos6][ipos5] =
    mpr[jpos6][ipos6] =
    mpr[jpos6][ipos7] =
    mpr[jpos7][ipos0] =
    mpr[jpos7][ipos1] =
    mpr[jpos7][ipos2] =
    mpr[jpos7][ipos3] =
    mpr[jpos7][ipos4] =
    mpr[jpos7][ipos5] =
    mpr[jpos7][ipos6] =
    mpr[jpos7][ipos7] = (imgpel) P_X;
    mpr[jpos6][ipos1] =
    mpr[jpos5][ipos3] =
    mpr[jpos4][ipos5] =
    mpr[jpos3][ipos7] = (imgpel) ((P_W + 3*P_X + 2) >> 2);
    mpr[jpos5][ipos1] =
    mpr[jpos4][ipos3] =
    mpr[jpos3][ipos5] =
    mpr[jpos2][ipos7] = (imgpel) ((P_X + P_V + 2*P_W + 2) >> 2);
    mpr[jpos4][ipos1] =
    mpr[jpos3][ipos3] =
    mpr[jpos2][ipos5] =
    mpr[jpos1][ipos7] = (imgpel) ((P_W + P_U + 2*P_V + 2) >> 2);
    mpr[jpos3][ipos1] =
    mpr[jpos2][ipos3] =
    mpr[jpos1][ipos5] =
    mpr[jpos0][ipos7] = (imgpel) ((P_V + P_T + 2*P_U + 2) >> 2);
    mpr[jpos2][ipos1] =
    mpr[jpos1][ipos3] =
    mpr[jpos0][ipos5] = (imgpel) ((P_U + P_S + 2*P_T + 2) >> 2);
    mpr[jpos1][ipos1] =
    mpr[jpos0][ipos3] = (imgpel) ((P_T + P_R + 2*P_S + 2) >> 2);
    mpr[jpos0][ipos1] = (imgpel) ((P_S + P_Q + 2*P_R + 2) >> 2);
    break;

  default:
    printf("Error: illegal intra_4x4 prediction mode: %d\n",predmode);
    return SEARCH_SYNC;
    break;
  }
  return DECODING_OK;
}



/*!
 *************************************************************************************
 * \brief
 *    Prefiltering for Intra8x8 prediction
 *************************************************************************************
 */
void LowPassForIntra8x8Pred(imgpel *PredPel, int block_up_left, int block_up, int block_left)
{
  int i;
  imgpel LoopArray[25];

  memcpy(&LoopArray[0], &PredPel[0], 25 * sizeof(imgpel));

  if(block_up_left)
  {
    if(block_up && block_left)
    {
      LoopArray[0] = (imgpel) ((P_Q + (P_Z<<1) + P_A +2)>>2);
    }
    else
    {
      if(block_up)
        LoopArray[0] = (imgpel) ((P_Z + (P_Z<<1) + P_A +2)>>2);
      else if (block_left)
        LoopArray[0] = (imgpel) ((P_Z + (P_Z<<1) + P_Q +2)>>2);
    }
  }
  
  if(block_up)
  {    
    if(block_up_left)
    {
      LoopArray[1] = (imgpel) ((PredPel[0] + (PredPel[1]<<1) + PredPel[2] + 2)>>2);
    }
    else
      LoopArray[1] = (imgpel) ((PredPel[1] + (PredPel[1]<<1) + PredPel[2] + 2)>>2);


    for(i = 2; i <16; i++)
    {
      LoopArray[i] = (imgpel) ((PredPel[i-1] + (PredPel[i]<<1) + PredPel[i+1] + 2)>>2);
    }
    LoopArray[16] = (imgpel) ((P_P + (P_P<<1) + P_O + 2)>>2);
  }


  if(block_left)
  {
    if(block_up_left)
      LoopArray[17] = (imgpel) ((P_Z + (P_Q<<1) + P_R + 2)>>2);
    else
      LoopArray[17] = (imgpel) ((P_Q + (P_Q<<1) + P_R + 2)>>2);

    for(i = 18; i <24; i++)
    {
      LoopArray[i] = (imgpel) ((PredPel[i-1] + (PredPel[i]<<1) + PredPel[i+1] + 2)>>2);
    }
    LoopArray[24] = (imgpel) ((P_W + (P_X<<1) + P_X + 2) >> 2);
  }

  memcpy(&PredPel[0], &LoopArray[0], 25 * sizeof(imgpel));
}



/*!
 ***********************************************************************
 * \brief
 *    Inverse 8x8 transformation
 ***********************************************************************
 */ 
void itrans8x8(ImageParameters *img, //!< image parameters
               Macroblock *currMB,
               ColorPlane pl,               
               int ioff,            //!< index to 4x4 block
               int joff)            //!<
{
  int i,j;
  Boolean lossless_qpprime = (Boolean) (currMB->qp_scaled[pl] == 0 && img->lossless_qpprime_flag==1);

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

  if(lossless_qpprime)
  {
    for( j = joff; j < joff + 8; j++)
    {
      for( i = ioff; i < ioff + 8; i++)
        m7[j][i] = iClip1(max_imgpel_value, (m7[j][i] + (long)mpr[j][i])); 
    }
  }
  else
  {
    inverse8x8(m7, m7, joff, ioff);
    for( j = joff; j < joff + 8; j++)
    {
      for( i = ioff; i < ioff + 8; i++)
        m7[j][i] = iClip1(max_imgpel_value, rshift_rnd_sf((m7[j][i] + ((long)mpr[j][i] << DQ_BITS_8)), DQ_BITS_8)); 
    }
  }
}