transform8x8.c

H264视频编解码程序

 *     Starting point of current 8x8 block image posision
 *
 *  \par Output:
 *      none
 ************************************************************************
 */
void intrapred_luma8x8(int img_x,int img_y, int *left_available, int *up_available, int *all_available)
{
  int i,j;
  int s0;
  int PredPel[25];  // array of predictor pels
  imgpel **imgY = enc_picture->imgY;  // For MB level frame/field coding tools -- set default to imgY

  int ioff = (img_x & 15);
  int joff = (img_y & 15);
  int mb_nr=img->current_mb_nr;

  PixelPos pix_a[8];
  PixelPos pix_b, pix_c, pix_d;

  int block_available_up;
  int block_available_left;
  int block_available_up_left;
  int block_available_up_right;

  for (i=0;i<8;i++)
  {
    getNeighbour(mb_nr, ioff -1 , joff +i , 1, &pix_a[i]);
  }

  getNeighbour(mb_nr, ioff    , joff -1 , 1, &pix_b);
  getNeighbour(mb_nr, ioff +8 , joff -1 , 1, &pix_c);
  getNeighbour(mb_nr, ioff -1 , joff -1 , 1, &pix_d);
  
  pix_c.available = pix_c.available &&!(ioff == 8 && joff == 8);

  if (input->UseConstrainedIntraPred)
  {
    for (i=0, block_available_left=1; i<8;i++)
      block_available_left  &= pix_a[i].available ? img->intra_block[pix_a[i].mb_addr]: 0;
    block_available_up       = pix_b.available ? img->intra_block [pix_b.mb_addr] : 0;
    block_available_up_right = pix_c.available ? img->intra_block [pix_c.mb_addr] : 0;
    block_available_up_left  = pix_d.available ? img->intra_block [pix_d.mb_addr] : 0;
  }
  else
  {
    block_available_left     = pix_a[0].available;
    block_available_up       = pix_b.available;
    block_available_up_right = pix_c.available;
    block_available_up_left  = pix_d.available;
  }

  *left_available = block_available_left;
  *up_available   = block_available_up;
  *all_available  = block_available_up && block_available_left && block_available_up_left;

  i = (img_x & 15);
  j = (img_y & 15);

  // form predictor pels
  // form predictor pels
  if (block_available_up)
  {
    P_A = imgY[pix_b.pos_y][pix_b.pos_x+0];
    P_B = imgY[pix_b.pos_y][pix_b.pos_x+1];
    P_C = imgY[pix_b.pos_y][pix_b.pos_x+2];
    P_D = imgY[pix_b.pos_y][pix_b.pos_x+3];
    P_E = imgY[pix_b.pos_y][pix_b.pos_x+4];
    P_F = imgY[pix_b.pos_y][pix_b.pos_x+5];
    P_G = imgY[pix_b.pos_y][pix_b.pos_x+6];
    P_H = imgY[pix_b.pos_y][pix_b.pos_x+7];
  }
  else
  {
    P_A = P_B = P_C = P_D = P_E = P_F = P_G = P_H = img->dc_pred_value;
  }

  if (block_available_up_right)
  {
    P_I = imgY[pix_c.pos_y][pix_c.pos_x+0];
    P_J = imgY[pix_c.pos_y][pix_c.pos_x+1];
    P_K = imgY[pix_c.pos_y][pix_c.pos_x+2];
    P_L = imgY[pix_c.pos_y][pix_c.pos_x+3];
    P_M = imgY[pix_c.pos_y][pix_c.pos_x+4];
    P_N = imgY[pix_c.pos_y][pix_c.pos_x+5];
    P_O = imgY[pix_c.pos_y][pix_c.pos_x+6];
    P_P = imgY[pix_c.pos_y][pix_c.pos_x+7];

  }
  else
  {
    P_I = P_J = P_K = P_L = P_M = P_N = P_O = P_P = P_H;
  }

  if (block_available_left)
  {
    P_Q = imgY[pix_a[0].pos_y][pix_a[0].pos_x];
    P_R = imgY[pix_a[1].pos_y][pix_a[1].pos_x];
    P_S = imgY[pix_a[2].pos_y][pix_a[2].pos_x];
    P_T = imgY[pix_a[3].pos_y][pix_a[3].pos_x];
    P_U = imgY[pix_a[4].pos_y][pix_a[4].pos_x];
    P_V = imgY[pix_a[5].pos_y][pix_a[5].pos_x];
    P_W = imgY[pix_a[6].pos_y][pix_a[6].pos_x];
    P_X = imgY[pix_a[7].pos_y][pix_a[7].pos_x];
  }
  else
  {
    P_Q = P_R = P_S = P_T = P_U = P_V = P_W = P_X = img->dc_pred_value;
  }

  if (block_available_up_left)
  {
    P_Z = imgY[pix_d.pos_y][pix_d.pos_x];
  }
  else
  {
    P_Z = img->dc_pred_value;
  }

  for(i=0;i<9;i++)
    img->mprr_3[i][0][0]=-1;

  LowPassForIntra8x8Pred(&(P_Z), block_available_up_left, block_available_up, block_available_left);

  ///////////////////////////////
  // make DC prediction
  ///////////////////////////////
  s0 = 0;
  if (block_available_up && block_available_left)
  {   
    // no edge
    s0 = (P_A + P_B + P_C + P_D + P_E + P_F + P_G + P_H + P_Q + P_R + P_S + P_T + P_U + P_V + P_W + P_X + 8) >> 4;
  }
  else if (!block_available_up && block_available_left)
  {
    // upper edge
    s0 = (P_Q + P_R + P_S + P_T + P_U + P_V + P_W + P_X + 4) >> 3;             
  }
  else if (block_available_up && !block_available_left)
  {
    // left edge
    s0 = (P_A + P_B + P_C + P_D + P_E + P_F + P_G + P_H + 4) >> 3;             
  }
  else //if (!block_available_up && !block_available_left)
  {
    // top left corner, nothing to predict from
    s0 = img->dc_pred_value;                           
  }
  
  // store DC prediction
  for (j=0; j < 2*BLOCK_SIZE; j++)
  {
    for (i=0; i < 2*BLOCK_SIZE; i++)
    {
      img->mprr_3[DC_PRED][i][j] = s0;
    }
  }

  
  ///////////////////////////////
  // make horiz and vert prediction
  ///////////////////////////////

  for (i=0; i < 2*BLOCK_SIZE; i++)
  {
    img->mprr_3[VERT_PRED][0][i] = 
    img->mprr_3[VERT_PRED][1][i] = 
    img->mprr_3[VERT_PRED][2][i] = 
    img->mprr_3[VERT_PRED][3][i] = 
    img->mprr_3[VERT_PRED][4][i] = 
    img->mprr_3[VERT_PRED][5][i] = 
    img->mprr_3[VERT_PRED][6][i] = 
    img->mprr_3[VERT_PRED][7][i] = (&P_A)[i];
    img->mprr_3[HOR_PRED][i][0]  = 
    img->mprr_3[HOR_PRED][i][1]  = 
    img->mprr_3[HOR_PRED][i][2]  = 
    img->mprr_3[HOR_PRED][i][3]  = 
    img->mprr_3[HOR_PRED][i][4]  = 
    img->mprr_3[HOR_PRED][i][5]  = 
    img->mprr_3[HOR_PRED][i][6]  = 
    img->mprr_3[HOR_PRED][i][7]  = (&P_Q)[i];
  }

  if(!block_available_up)img->mprr_3[VERT_PRED][0][0]=-1;
  if(!block_available_left)img->mprr_3[HOR_PRED][0][0]=-1;

  ///////////////////////////////////
  // make diagonal down left prediction
  ///////////////////////////////////
  if (block_available_up) 
  {
    // Mode DIAG_DOWN_LEFT_PRED
    img->mprr_3[DIAG_DOWN_LEFT_PRED][0][0] = (P_A + P_C + 2*(P_B) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_LEFT_PRED][0][1] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][1][0] = (P_B + P_D + 2*(P_C) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_LEFT_PRED][0][2] =
    img->mprr_3[DIAG_DOWN_LEFT_PRED][1][1] =
    img->mprr_3[DIAG_DOWN_LEFT_PRED][2][0] = (P_C + P_E + 2*(P_D) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_LEFT_PRED][0][3] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][1][2] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][2][1] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][3][0] = (P_D + P_F + 2*(P_E) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_LEFT_PRED][0][4] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][1][3] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][2][2] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][3][1] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][4][0] = (P_E + P_G + 2*(P_F) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_LEFT_PRED][0][5] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][1][4] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][2][3] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][3][2] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][4][1] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][5][0] = (P_F + P_H + 2*(P_G) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_LEFT_PRED][0][6] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][1][5] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][2][4] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][3][3] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][4][2] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][5][1] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][6][0] = (P_G + P_I + 2*(P_H) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_LEFT_PRED][0][7] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][1][6] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][2][5] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][3][4] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][4][3] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][5][2] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][6][1] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][7][0] = (P_H + P_J + 2*(P_I) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_LEFT_PRED][1][7] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][2][6] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][3][5] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][4][4] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][5][3] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][6][2] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][7][1] = (P_I + P_K + 2*(P_J) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_LEFT_PRED][2][7] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][3][6] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][4][5] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][5][4] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][6][3] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][7][2] = (P_J + P_L + 2*(P_K) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_LEFT_PRED][3][7] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][4][6] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][5][5] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][6][4] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][7][3] = (P_K + P_M + 2*(P_L) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_LEFT_PRED][4][7] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][5][6] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][6][5] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][7][4] = (P_L + P_N + 2*(P_M) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_LEFT_PRED][5][7] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][6][6] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][7][5] = (P_M + P_O + 2*(P_N) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_LEFT_PRED][6][7] = 
    img->mprr_3[DIAG_DOWN_LEFT_PRED][7][6] = (P_N + P_P + 2*(P_O) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_LEFT_PRED][7][7] = (P_O + 3*(P_P) + 2) >> 2;

    ///////////////////////////////////
    // make vertical left prediction
    ///////////////////////////////////
    img->mprr_3[VERT_LEFT_PRED][0][0] = (P_A + P_B + 1) >> 1;
    img->mprr_3[VERT_LEFT_PRED][0][1] = 
    img->mprr_3[VERT_LEFT_PRED][2][0] = (P_B + P_C + 1) >> 1;
    img->mprr_3[VERT_LEFT_PRED][0][2] = 
    img->mprr_3[VERT_LEFT_PRED][2][1] = 
    img->mprr_3[VERT_LEFT_PRED][4][0] = (P_C + P_D + 1) >> 1;
    img->mprr_3[VERT_LEFT_PRED][0][3] = 
    img->mprr_3[VERT_LEFT_PRED][2][2] = 
    img->mprr_3[VERT_LEFT_PRED][4][1] = 
    img->mprr_3[VERT_LEFT_PRED][6][0] = (P_D + P_E + 1) >> 1;
    img->mprr_3[VERT_LEFT_PRED][0][4] = 
    img->mprr_3[VERT_LEFT_PRED][2][3] = 
    img->mprr_3[VERT_LEFT_PRED][4][2] = 
    img->mprr_3[VERT_LEFT_PRED][6][1] = (P_E + P_F + 1) >> 1;
    img->mprr_3[VERT_LEFT_PRED][0][5] = 
    img->mprr_3[VERT_LEFT_PRED][2][4] = 
    img->mprr_3[VERT_LEFT_PRED][4][3] = 
    img->mprr_3[VERT_LEFT_PRED][6][2] = (P_F + P_G + 1) >> 1;
    img->mprr_3[VERT_LEFT_PRED][0][6] = 
    img->mprr_3[VERT_LEFT_PRED][2][5] = 
    img->mprr_3[VERT_LEFT_PRED][4][4] = 
    img->mprr_3[VERT_LEFT_PRED][6][3] = (P_G + P_H + 1) >> 1;
    img->mprr_3[VERT_LEFT_PRED][0][7] = 
    img->mprr_3[VERT_LEFT_PRED][2][6] = 
    img->mprr_3[VERT_LEFT_PRED][4][5] = 
    img->mprr_3[VERT_LEFT_PRED][6][4] = (P_H + P_I + 1) >> 1;
    img->mprr_3[VERT_LEFT_PRED][2][7] = 
    img->mprr_3[VERT_LEFT_PRED][4][6] = 
    img->mprr_3[VERT_LEFT_PRED][6][5] = (P_I + P_J + 1) >> 1;
    img->mprr_3[VERT_LEFT_PRED][4][7] = 
    img->mprr_3[VERT_LEFT_PRED][6][6] = (P_J + P_K + 1) >> 1;
    img->mprr_3[VERT_LEFT_PRED][6][7] = (P_K + P_L + 1) >> 1;
    img->mprr_3[VERT_LEFT_PRED][1][0] = (P_A + P_C + 2*P_B + 2) >> 2;
    img->mprr_3[VERT_LEFT_PRED][1][1] = 
    img->mprr_3[VERT_LEFT_PRED][3][0] = (P_B + P_D + 2*P_C + 2) >> 2;
    img->mprr_3[VERT_LEFT_PRED][1][2] = 
    img->mprr_3[VERT_LEFT_PRED][3][1] = 
    img->mprr_3[VERT_LEFT_PRED][5][0] = (P_C + P_E + 2*P_D + 2) >> 2;
    img->mprr_3[VERT_LEFT_PRED][1][3] = 
    img->mprr_3[VERT_LEFT_PRED][3][2] = 
    img->mprr_3[VERT_LEFT_PRED][5][1] = 
    img->mprr_3[VERT_LEFT_PRED][7][0] = (P_D + P_F + 2*P_E + 2) >> 2;
    img->mprr_3[VERT_LEFT_PRED][1][4] = 
    img->mprr_3[VERT_LEFT_PRED][3][3] = 
    img->mprr_3[VERT_LEFT_PRED][5][2] = 
    img->mprr_3[VERT_LEFT_PRED][7][1] = (P_E + P_G + 2*P_F + 2) >> 2;
    img->mprr_3[VERT_LEFT_PRED][1][5] = 
    img->mprr_3[VERT_LEFT_PRED][3][4] = 
    img->mprr_3[VERT_LEFT_PRED][5][3] = 
    img->mprr_3[VERT_LEFT_PRED][7][2] = (P_F + P_H + 2*P_G + 2) >> 2;
    img->mprr_3[VERT_LEFT_PRED][1][6] = 
    img->mprr_3[VERT_LEFT_PRED][3][5] = 
    img->mprr_3[VERT_LEFT_PRED][5][4] = 
    img->mprr_3[VERT_LEFT_PRED][7][3] = (P_G + P_I + 2*P_H + 2) >> 2;
    img->mprr_3[VERT_LEFT_PRED][1][7] = 
    img->mprr_3[VERT_LEFT_PRED][3][6] = 
    img->mprr_3[VERT_LEFT_PRED][5][5] = 
    img->mprr_3[VERT_LEFT_PRED][7][4] = (P_H + P_J + 2*P_I + 2) >> 2;
    img->mprr_3[VERT_LEFT_PRED][3][7] = 
    img->mprr_3[VERT_LEFT_PRED][5][6] = 
    img->mprr_3[VERT_LEFT_PRED][7][5] = (P_I + P_K + 2*P_J + 2) >> 2;
    img->mprr_3[VERT_LEFT_PRED][5][7] = 
    img->mprr_3[VERT_LEFT_PRED][7][6] = (P_J + P_L + 2*P_K + 2) >> 2;
    img->mprr_3[VERT_LEFT_PRED][7][7] = (P_K + P_M + 2*P_L + 2) >> 2;
  }

  ///////////////////////////////////
  // make diagonal down right prediction
  ///////////////////////////////////
  if (block_available_up && block_available_left && block_available_up_left) 
  {
    // Mode DIAG_DOWN_RIGHT_PRED
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][7][0] = (P_X + P_V + 2*(P_W) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][6][0] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][7][1] = (P_W + P_U + 2*(P_V) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][5][0] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][6][1] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][7][2] = (P_V + P_T + 2*(P_U) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][4][0] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][5][1] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][6][2] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][7][3] = (P_U + P_S + 2*(P_T) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][3][0] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][4][1] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][5][2] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][6][3] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][7][4] = (P_T + P_R + 2*(P_S) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][2][0] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][3][1] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][4][2] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][5][3] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][6][4] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][7][5] = (P_S + P_Q + 2*(P_R) + 2) >> 2;
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][1][0] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][2][1] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][3][2] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][4][3] = 
    img->mprr_3[DIAG_DOWN_RIGHT_PRED][5][4] =