transform8x8.c

h.264 影像壓縮 必須在 .net 的環境 下操作

  }
  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_comp[pl];
  }

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

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

//img->mpr[y][x]
  switch(predmode)
  {
  case DC_PRED:
    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_comp[pl];
    }
    for(j = joff; j < joff + BLOCK_SIZE_8x8; j++)
      for(i = ioff; i < ioff + BLOCK_SIZE_8x8; i++)
        mpr[j][i] = (imgpel) s0;
    break;

  case VERT_PRED:
    if (!block_available_up)
      printf ("warning: Intra_8x8_Vertical prediction mode not allowed at mb %d\n",img->current_mb_nr);

    for (i=0; i < BLOCK_SIZE_8x8; i++)
    {
      ipos = i+ioff;
      mpr[jpos0][ipos] =
      mpr[jpos1][ipos] =
      mpr[jpos2][ipos] =
      mpr[jpos3][ipos] =
      mpr[jpos4][ipos] =
      mpr[jpos5][ipos] =
      mpr[jpos6][ipos] =
      mpr[jpos7][ipos] = (imgpel) (&P_A)[i];
    }
    break;
  case HOR_PRED:
    if (!block_available_left)
      printf ("warning: Intra_8x8_Horizontal prediction mode not allowed at mb %d\n",img->current_mb_nr);

    for (j=0; j < BLOCK_SIZE_8x8; j++)
    {
      jpos = j + joff;
      mpr[jpos][ipos0]  =
      mpr[jpos][ipos1]  =
      mpr[jpos][ipos2]  =
      mpr[jpos][ipos3]  =
      mpr[jpos][ipos4]  =
      mpr[jpos][ipos5]  =
      mpr[jpos][ipos6]  =
      mpr[jpos][ipos7]  = (imgpel) (&P_Q)[j];
    }
    break;

  case DIAG_DOWN_LEFT_PRED:
    if (!block_available_up)
      printf ("warning: Intra_8x8_Diagonal_Down_Left prediction mode not allowed at mb %d\n",img->current_mb_nr);
    // Mode DIAG_DOWN_LEFT_PRED
    mpr[jpos0][ipos0] = (imgpel) ((P_A + P_C + 2*(P_B) + 2) >> 2);
    mpr[jpos1][ipos0] =
    mpr[jpos0][ipos1] = (imgpel) ((P_B + P_D + 2*(P_C) + 2) >> 2);
    mpr[jpos2][ipos0] =
    mpr[jpos1][ipos1] =
    mpr[jpos0][ipos2] = (imgpel) ((P_C + P_E + 2*(P_D) + 2) >> 2);
    mpr[jpos3][ipos0] =
    mpr[jpos2][ipos1] =
    mpr[jpos1][ipos2] =
    mpr[jpos0][ipos3] = (imgpel) ((P_D + P_F + 2*(P_E) + 2) >> 2);
    mpr[jpos4][ipos0] =
    mpr[jpos3][ipos1] =
    mpr[jpos2][ipos2] =
    mpr[jpos1][ipos3] =
    mpr[jpos0][ipos4] = (imgpel) ((P_E + P_G + 2*(P_F) + 2) >> 2);
    mpr[jpos5][ipos0] =
    mpr[jpos4][ipos1] =
    mpr[jpos3][ipos2] =
    mpr[jpos2][ipos3] =
    mpr[jpos1][ipos4] =
    mpr[jpos0][ipos5] = (imgpel) ((P_F + P_H + 2*(P_G) + 2) >> 2);
    mpr[jpos6][ipos0] =
    mpr[jpos5][ipos1] =
    mpr[jpos4][ipos2] =
    mpr[jpos3][ipos3] =
    mpr[jpos2][ipos4] =
    mpr[jpos1][ipos5] =
    mpr[jpos0][ipos6] = (imgpel) ((P_G + P_I + 2*(P_H) + 2) >> 2);
    mpr[jpos7][ipos0] =
    mpr[jpos6][ipos1] =
    mpr[jpos5][ipos2] =
    mpr[jpos4][ipos3] =
    mpr[jpos3][ipos4] =
    mpr[jpos2][ipos5] =
    mpr[jpos1][ipos6] =
    mpr[jpos0][ipos7] = (imgpel) ((P_H + P_J + 2*(P_I) + 2) >> 2);
    mpr[jpos7][ipos1] =
    mpr[jpos6][ipos2] =
    mpr[jpos5][ipos3] =
    mpr[jpos4][ipos4] =
    mpr[jpos3][ipos5] =
    mpr[jpos2][ipos6] =
    mpr[jpos1][ipos7] = (imgpel) ((P_I + P_K + 2*(P_J) + 2) >> 2);
    mpr[jpos7][ipos2] =
    mpr[jpos6][ipos3] =
    mpr[jpos5][ipos4] =
    mpr[jpos4][ipos5] =
    mpr[jpos3][ipos6] =
    mpr[jpos2][ipos7] = (imgpel) ((P_J + P_L + 2*(P_K) + 2) >> 2);
    mpr[jpos7][ipos3] =
    mpr[jpos6][ipos4] =
    mpr[jpos5][ipos5] =
    mpr[jpos4][ipos6] =
    mpr[jpos3][ipos7] = (imgpel) ((P_K + P_M + 2*(P_L) + 2) >> 2);
    mpr[jpos7][ipos4] =
    mpr[jpos6][ipos5] =
    mpr[jpos5][ipos6] =
    mpr[jpos4][ipos7] = (imgpel) ((P_L + P_N + 2*(P_M) + 2) >> 2);
    mpr[jpos7][ipos5] =
    mpr[jpos6][ipos6] =
    mpr[jpos5][ipos7] = (imgpel) ((P_M + P_O + 2*(P_N) + 2) >> 2);
    mpr[jpos7][ipos6] =
    mpr[jpos6][ipos7] = (imgpel) ((P_N + P_P + 2*(P_O) + 2) >> 2);
    mpr[jpos7][ipos7] = (imgpel) ((P_O + 3*(P_P) + 2) >> 2);
    break;

  case VERT_LEFT_PRED:
    if (!block_available_up)
      printf ("warning: Intra_4x4_Vertical_Left prediction mode not allowed at mb %d\n",img->current_mb_nr);

    mpr[jpos0][ipos0] = (imgpel) ((P_A + P_B + 1) >> 1);
    mpr[jpos0][ipos1] =
    mpr[jpos2][ipos0] = (imgpel) ((P_B + P_C + 1) >> 1);
    mpr[jpos0][ipos2] =
    mpr[jpos2][ipos1] =
    mpr[jpos4][ipos0] = (imgpel) ((P_C + P_D + 1) >> 1);
    mpr[jpos0][ipos3] =
    mpr[jpos2][ipos2] =
    mpr[jpos4][ipos1] =
    mpr[jpos6][ipos0] = (imgpel) ((P_D + P_E + 1) >> 1);
    mpr[jpos0][ipos4] =
    mpr[jpos2][ipos3] =
    mpr[jpos4][ipos2] =
    mpr[jpos6][ipos1] = (imgpel) ((P_E + P_F + 1) >> 1);
    mpr[jpos0][ipos5] =
    mpr[jpos2][ipos4] =
    mpr[jpos4][ipos3] =
    mpr[jpos6][ipos2] = (imgpel) ((P_F + P_G + 1) >> 1);
    mpr[jpos0][ipos6] =
    mpr[jpos2][ipos5] =
    mpr[jpos4][ipos4] =
    mpr[jpos6][ipos3] = (imgpel) ((P_G + P_H + 1) >> 1);
    mpr[jpos0][ipos7] =
    mpr[jpos2][ipos6] =
    mpr[jpos4][ipos5] =
    mpr[jpos6][ipos4] = (imgpel) ((P_H + P_I + 1) >> 1);
    mpr[jpos2][ipos7] =
    mpr[jpos4][ipos6] =
    mpr[jpos6][ipos5] = (imgpel) ((P_I + P_J + 1) >> 1);
    mpr[jpos4][ipos7] =
    mpr[jpos6][ipos6] = (imgpel) ((P_J + P_K + 1) >> 1);
    mpr[jpos6][ipos7] = (imgpel) ((P_K + P_L + 1) >> 1);
    mpr[jpos1][ipos0] = (imgpel) ((P_A + P_C + 2*P_B + 2) >> 2);
    mpr[jpos1][ipos1] =
    mpr[jpos3][ipos0] = (imgpel) ((P_B + P_D + 2*P_C + 2) >> 2);
    mpr[jpos1][ipos2] =
    mpr[jpos3][ipos1] =
    mpr[jpos5][ipos0] = (imgpel) ((P_C + P_E + 2*P_D + 2) >> 2);
    mpr[jpos1][ipos3] =
    mpr[jpos3][ipos2] =
    mpr[jpos5][ipos1] =
    mpr[jpos7][ipos0] = (imgpel) ((P_D + P_F + 2*P_E + 2) >> 2);
    mpr[jpos1][ipos4] =
    mpr[jpos3][ipos3] =
    mpr[jpos5][ipos2] =
    mpr[jpos7][ipos1] = (imgpel) ((P_E + P_G + 2*P_F + 2) >> 2);
    mpr[jpos1][ipos5] =
    mpr[jpos3][ipos4] =
    mpr[jpos5][ipos3] =
    mpr[jpos7][ipos2] = (imgpel) ((P_F + P_H + 2*P_G + 2) >> 2);
    mpr[jpos1][ipos6] =
    mpr[jpos3][ipos5] =
    mpr[jpos5][ipos4] =
    mpr[jpos7][ipos3] = (imgpel) ((P_G + P_I + 2*P_H + 2) >> 2);
    mpr[jpos1][ipos7] =
    mpr[jpos3][ipos6] =
    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",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",img->current_mb_nr);

    mpr[jpos0][ipos0] =
    mpr[jpos2][ipos1] =
    mpr[jpos4][ipos2] =