intrapred.c

Nokia H.264/AVC Encoder/Decoder Usage Manual

    J = reco[1 * picWidth - 1];
    K = reco[2 * picWidth - 1];
    L = reco[3 * picWidth - 1];
  }
  else
    I = J = K = L = 128;

  /* DC PREDICTION */
  
  if (upMode != IPR_MODE_NA && leftMode != IPR_MODE_NA)
    dc = (A+B+C+D+I+J+K+L+4)>>3;
  else if (upMode != IPR_MODE_NA)
    dc = (A+B+C+D+2)>>2;
  else if (leftMode != IPR_MODE_NA)
    dc = (I+J+K+L+2)>>2;
  else
    dc = 128;

  intTerm = (dc << 24) + (dc << 16) + (dc << 8) + dc;
  *(int *) & predBlk[IPR_MODE_DC][0][0] = intTerm;
  *(int *) & predBlk[IPR_MODE_DC][1][0] = intTerm;
  *(int *) & predBlk[IPR_MODE_DC][2][0] = intTerm;
  *(int *) & predBlk[IPR_MODE_DC][3][0] = intTerm;
  
  modeAvail[IPR_MODE_DC] = 1;
  modeAvail[IPR_MODE_VERT] = modeAvail[IPR_MODE_DIAG_DOWN_LEFT] = 
    modeAvail[IPR_MODE_VERT_LEFT] = (upMode != IPR_MODE_NA);

  modeAvail[IPR_MODE_DIAG_DOWN_RIGHT] = modeAvail[IPR_MODE_VERT_RIGHT] = 
    modeAvail[IPR_MODE_HOR_DOWN] = ((leftMode + upMode) < IPR_MODE_NA) && (cornersAvail & 1);

  if (upMode != IPR_MODE_NA) {

    /* VERTICAL PREDICTION */

#ifdef LITTLE_ENDIAN
    intTerm = (D << 24) + (C << 16) + (B << 8) + A;
#else
    intTerm = (A << 24) + (B << 16) + (C << 8) + D;
#endif
  
    // predBlk is (u_int8 *) 16x16, addressed in integers, jump by 4 elements
    *(int *) & predBlk[IPR_MODE_VERT][0][0] = intTerm;
    *(int *) & predBlk[IPR_MODE_VERT][1][0] = intTerm;
    *(int *) & predBlk[IPR_MODE_VERT][2][0] = intTerm;
    *(int *) & predBlk[IPR_MODE_VERT][3][0] = intTerm;

    /* DIAGONAL DOWN/LEFT PREDICTION */

    predBlk[IPR_MODE_DIAG_DOWN_LEFT][0][0] = (u_int8) ((A+2*B+C+2) >> 2);
    predBlk[IPR_MODE_DIAG_DOWN_LEFT][0][1] = 
    predBlk[IPR_MODE_DIAG_DOWN_LEFT][1][0] = (u_int8) ((B+2*C+D+2) >> 2);
    predBlk[IPR_MODE_DIAG_DOWN_LEFT][0][2] =
    predBlk[IPR_MODE_DIAG_DOWN_LEFT][1][1] =
    predBlk[IPR_MODE_DIAG_DOWN_LEFT][2][0] = (u_int8) ((C+2*D+E+2) >> 2);
    predBlk[IPR_MODE_DIAG_DOWN_LEFT][0][3] = 
    predBlk[IPR_MODE_DIAG_DOWN_LEFT][1][2] = 
    predBlk[IPR_MODE_DIAG_DOWN_LEFT][2][1] = 
    predBlk[IPR_MODE_DIAG_DOWN_LEFT][3][0] = (u_int8) ((D+2*E+F+2) >> 2);
    predBlk[IPR_MODE_DIAG_DOWN_LEFT][1][3] = 
    predBlk[IPR_MODE_DIAG_DOWN_LEFT][2][2] = 
    predBlk[IPR_MODE_DIAG_DOWN_LEFT][3][1] = (u_int8) ((E+2*F+G+2) >> 2);
    predBlk[IPR_MODE_DIAG_DOWN_LEFT][2][3] = 
    predBlk[IPR_MODE_DIAG_DOWN_LEFT][3][2] = (u_int8) ((F+2*G+H+2) >> 2);
    predBlk[IPR_MODE_DIAG_DOWN_LEFT][3][3] = (u_int8) ((G+3*H+2) >> 2);

    /* VERTICAL-LEFT PREDICTION */

    predBlk[IPR_MODE_VERT_LEFT][0][0] = (u_int8) ((A+B+1) >> 1);
    predBlk[IPR_MODE_VERT_LEFT][0][1] = 
    predBlk[IPR_MODE_VERT_LEFT][2][0] = (u_int8) ((B+C+1) >> 1);
    predBlk[IPR_MODE_VERT_LEFT][0][2] = 
    predBlk[IPR_MODE_VERT_LEFT][2][1] = (u_int8) ((C+D+1) >> 1);
    predBlk[IPR_MODE_VERT_LEFT][0][3] = 
    predBlk[IPR_MODE_VERT_LEFT][2][2] = (u_int8) ((D+E+1) >> 1);
    predBlk[IPR_MODE_VERT_LEFT][2][3] = (u_int8) ((E+F+1) >> 1);
    predBlk[IPR_MODE_VERT_LEFT][1][0] = (u_int8) ((A+2*B+C+2) >> 2);
    predBlk[IPR_MODE_VERT_LEFT][1][1] = 
    predBlk[IPR_MODE_VERT_LEFT][3][0] = (u_int8) ((B+2*C+D+2) >> 2);
    predBlk[IPR_MODE_VERT_LEFT][1][2] = 
    predBlk[IPR_MODE_VERT_LEFT][3][1] = (u_int8) ((C+2*D+E+2) >> 2);
    predBlk[IPR_MODE_VERT_LEFT][1][3] = 
    predBlk[IPR_MODE_VERT_LEFT][3][2] = (u_int8) ((D+2*E+F+2) >> 2);
    predBlk[IPR_MODE_VERT_LEFT][3][3] = (u_int8) ((E+2*F+G+2) >> 2);
  }

  modeAvail[IPR_MODE_HOR] = modeAvail[IPR_MODE_HOR_UP] = 
    (leftMode != IPR_MODE_NA);

  if (leftMode != IPR_MODE_NA) {
    /* HORIZONTAL PREDICTION */
    *(int *) & predBlk[IPR_MODE_HOR][0][0] = (I << 24) + (I << 16) + (I << 8) + I;
    *(int *) & predBlk[IPR_MODE_HOR][1][0] = (J << 24) + (J << 16) + (J << 8) + J;
    *(int *) & predBlk[IPR_MODE_HOR][2][0] = (K << 24) + (K << 16) + (K << 8) + K;
    *(int *) & predBlk[IPR_MODE_HOR][3][0] = (L << 24) + (L << 16) + (L << 8) + L;

    /* HORIZONTAL-UP PREDICTION */
    *(int *) & predBlk[IPR_MODE_HOR_UP][3][0] = (L << 24) + (L << 16) + (L << 8) + L;

    predBlk[IPR_MODE_HOR_UP][0][0] = (u_int8) ((I+J+1) >> 1);
    predBlk[IPR_MODE_HOR_UP][0][1] = (u_int8) ((I+2*J+K+2) >> 2);
    predBlk[IPR_MODE_HOR_UP][0][2] = 
    predBlk[IPR_MODE_HOR_UP][1][0] = (u_int8) ((J+K+1) >> 1);
    predBlk[IPR_MODE_HOR_UP][0][3] = 
    predBlk[IPR_MODE_HOR_UP][1][1] = (u_int8) ((J+2*K+L+2) >> 2);
    predBlk[IPR_MODE_HOR_UP][1][2] = 
    predBlk[IPR_MODE_HOR_UP][2][0] = (u_int8) ((K+L+1) >> 1);
    predBlk[IPR_MODE_HOR_UP][1][3] = 
    predBlk[IPR_MODE_HOR_UP][2][1] = (u_int8) ((K+2*L+L+2) >> 2);
    predBlk[IPR_MODE_HOR_UP][2][2] = 
    predBlk[IPR_MODE_HOR_UP][2][3] = (u_int8) L;
  }

  if (modeAvail[IPR_MODE_DIAG_DOWN_RIGHT]) {

    /* DIAGONAL DOWN/RIGHT PREDICTION */

    predBlk[IPR_MODE_DIAG_DOWN_RIGHT][3][0] = (u_int8) ((L+2*K+J+2) >> 2);
    predBlk[IPR_MODE_DIAG_DOWN_RIGHT][2][0] =
    predBlk[IPR_MODE_DIAG_DOWN_RIGHT][3][1] = (u_int8) ((K+2*J+I+2) >> 2);
    predBlk[IPR_MODE_DIAG_DOWN_RIGHT][1][0] =
    predBlk[IPR_MODE_DIAG_DOWN_RIGHT][2][1] =
    predBlk[IPR_MODE_DIAG_DOWN_RIGHT][3][2] = (u_int8) ((J+2*I+X+2) >> 2);
    predBlk[IPR_MODE_DIAG_DOWN_RIGHT][0][0] =
    predBlk[IPR_MODE_DIAG_DOWN_RIGHT][1][1] =
    predBlk[IPR_MODE_DIAG_DOWN_RIGHT][2][2] =
    predBlk[IPR_MODE_DIAG_DOWN_RIGHT][3][3] = (u_int8) ((I+2*X+A+2) >> 2);
    predBlk[IPR_MODE_DIAG_DOWN_RIGHT][0][1] =
    predBlk[IPR_MODE_DIAG_DOWN_RIGHT][1][2] =
    predBlk[IPR_MODE_DIAG_DOWN_RIGHT][2][3] = (u_int8) ((X+2*A+B+2) >> 2);
    predBlk[IPR_MODE_DIAG_DOWN_RIGHT][0][2] =
    predBlk[IPR_MODE_DIAG_DOWN_RIGHT][1][3] = (u_int8) ((A+2*B+C+2) >> 2);
    predBlk[IPR_MODE_DIAG_DOWN_RIGHT][0][3] = (u_int8) ((B+2*C+D+2) >> 2);
    
    /* VERTICAL-RIGHT PREDICTION */
  
    predBlk[IPR_MODE_VERT_RIGHT][0][0] = 
    predBlk[IPR_MODE_VERT_RIGHT][2][1] = (u_int8) ((X+A+1) >> 1);
    predBlk[IPR_MODE_VERT_RIGHT][0][1] = 
    predBlk[IPR_MODE_VERT_RIGHT][2][2] = (u_int8) ((A+B+1) >> 1);
    predBlk[IPR_MODE_VERT_RIGHT][0][2] = 
    predBlk[IPR_MODE_VERT_RIGHT][2][3] = (u_int8) ((B+C+1) >> 1);
    predBlk[IPR_MODE_VERT_RIGHT][0][3] = (u_int8) ((C+D+1) >> 1);
    predBlk[IPR_MODE_VERT_RIGHT][1][0] = 
    predBlk[IPR_MODE_VERT_RIGHT][3][1] = (u_int8) ((I+2*X+A+2) >> 2);
    predBlk[IPR_MODE_VERT_RIGHT][1][1] = 
    predBlk[IPR_MODE_VERT_RIGHT][3][2] = (u_int8) ((X+2*A+B+2) >> 2);
    predBlk[IPR_MODE_VERT_RIGHT][1][2] = 
    predBlk[IPR_MODE_VERT_RIGHT][3][3] = (u_int8) ((A+2*B+C+2) >> 2);
    predBlk[IPR_MODE_VERT_RIGHT][1][3] = (u_int8) ((B+2*C+D+2) >> 2);
    predBlk[IPR_MODE_VERT_RIGHT][2][0] = (u_int8) ((X+2*I+J+2) >> 2);
    predBlk[IPR_MODE_VERT_RIGHT][3][0] = (u_int8) ((I+2*J+K+2) >> 2);

    /* HORIZONTAL-DOWN PREDICTION */

    predBlk[IPR_MODE_HOR_DOWN][0][0] = 
    predBlk[IPR_MODE_HOR_DOWN][1][2] = (u_int8) ((X+I+1) >> 1);
    predBlk[IPR_MODE_HOR_DOWN][0][1] = 
    predBlk[IPR_MODE_HOR_DOWN][1][3] = (u_int8) ((I+2*X+A+2) >> 2);
    predBlk[IPR_MODE_HOR_DOWN][0][2] = (u_int8) ((X+2*A+B+2) >> 2);
    predBlk[IPR_MODE_HOR_DOWN][0][3] = (u_int8) ((A+2*B+C+2) >> 2);
    predBlk[IPR_MODE_HOR_DOWN][1][0] = 
    predBlk[IPR_MODE_HOR_DOWN][2][2] = (u_int8) ((I+J+1) >> 1);
    predBlk[IPR_MODE_HOR_DOWN][1][1] = 
    predBlk[IPR_MODE_HOR_DOWN][2][3] = (u_int8) ((X+2*I+J+2) >> 2);
    predBlk[IPR_MODE_HOR_DOWN][2][0] = 
    predBlk[IPR_MODE_HOR_DOWN][3][2] = (u_int8) ((J+K+1) >> 1);
    predBlk[IPR_MODE_HOR_DOWN][2][1] = 
    predBlk[IPR_MODE_HOR_DOWN][3][3] = (u_int8) ((I+2*J+K+2) >> 2);
    predBlk[IPR_MODE_HOR_DOWN][3][0] = (u_int8) ((K+L+1) >> 1);
    predBlk[IPR_MODE_HOR_DOWN][3][1] = (u_int8) ((J+2*K+L+2) >> 2);
  }
}


/*
 *
 * iprGetPredChroma:
 *
 * Parameters:
 *      predBlk               Storage for predicted pixels
 *      modeAvail             Will contains flags indicating available
 *                            modes for current macroblock
 *      recoU                 Reconstructed U pixels in the macroblock
 *      recoV                 Reconstructed V pixels in the macroblock
 *      width                 Horizontal size of the frame
 *      mbAvailMap            Availability of neighboring macroblocks
 *
 * Function:
 *      Make 8x8 chroma intra prediction for given macroblock.
 *
 * Returns:
 *      -
 *
 */
void iprGetPredChroma(u_int8 pred[IPR_CHROMA_NUM_MODES][MBK_SIZE/2][2*(MBK_SIZE/2)],
                      int    *modeAvail, 
                      u_int8 *recoU, 
                      u_int8 *recoV, 
                      int    width,
                      int    mbAvailMap[4])
{
  int comp;
  u_int8 *recoPic;
  int S0, S1, S2, S3;
  int A, B, C, D;
  int H, V, a, b, c;
  int i, j;

  /*
   * DC prediction
   */


  for (comp = 0; comp < MBK_SIZE; comp+=MBK_SIZE/2) {

    recoPic = comp == 0 ? recoU : recoV;

    S0 = S1 = S2 = S3 = 0;

    if (mbAvailMap[0]) {
      for (i = 0; i < 4; i++) {
        S2 += recoPic[      i * width - 1];
        S3 += recoPic[(4 + i) * width - 1];
      }
    }
    if (mbAvailMap[1]) {
      for (i = 0; i < 4; i++) {
        S0 += recoPic[-width + i];
        S1 += recoPic[-width + 4 + i];
      }
    }

    if (mbAvailMap[0] && mbAvailMap[1]) {
      A = (S0 + S2 + 4)>>3;
      B = (S1 + 2)>>2;
      C = (S3 + 2)>>2;
      D = (S1 + S3 + 4)>>3;
    }
    else if (mbAvailMap[0]) {
      A = B = (S2 + 2)>>2;
      C = D = (S3 + 2)>>2;
    }
    else if (mbAvailMap[1]) {
      A = C = (S0 + 2)>>2;
      B = D = (S1 + 2)>>2;
    }
    else
      A = B = C = D = 128;

    for (j = 0; j < BLK_SIZE; j++) {
      for (i = 0; i < BLK_SIZE; i++) {
        pred[IPR_CHROMA_MODE_DC][j  ][comp+i  ] = (u_int8) A;
        pred[IPR_CHROMA_MODE_DC][j  ][comp+4+i] = (u_int8) B;
        pred[IPR_CHROMA_MODE_DC][4+j][comp+i  ] = (u_int8) C;
        pred[IPR_CHROMA_MODE_DC][4+j][comp+4+i] = (u_int8) D;
      }
    }
  }

  modeAvail[IPR_CHROMA_MODE_DC] = 1;

  /*
   * Vertical prediction
   */

  if (mbAvailMap[1]) {
    for (comp = 0; comp < MBK_SIZE; comp+=MBK_SIZE/2) {

      recoPic = comp == 0 ? recoU : recoV;

      for (i = 0; i < MBK_SIZE/2; i++)
        for (j = 0; j < MBK_SIZE/2; j++)
          pred[IPR_CHROMA_MODE_VERT][j][comp+i] = recoPic[-width + i];
    }

    modeAvail[IPR_CHROMA_MODE_VERT] = 1;
  }
  else
    modeAvail[IPR_CHROMA_MODE_VERT] = 0;

  /*
   * Horizontal prediction
   */

  if (mbAvailMap[0]) {
    for (comp = 0; comp < MBK_SIZE; comp+=MBK_SIZE/2) {

      recoPic = comp == 0 ? recoU : recoV;

      for (j = 0; j < MBK_SIZE/2; j++)
        for (i = 0; i < MBK_SIZE/2; i++)
          pred[IPR_CHROMA_MODE_HOR][j][comp+i] = recoPic[j * width - 1];
    }

    modeAvail[IPR_CHROMA_MODE_HOR] = 1;
  }
  else
    modeAvail[IPR_CHROMA_MODE_HOR] = 0;

  /*
   * Plane Prediction
   */

  if (mbAvailMap[0] && mbAvailMap[1] && mbAvailMap[3]) {

    for (comp = 0; comp < MBK_SIZE; comp+=MBK_SIZE/2) {

      recoPic = comp == 0 ? recoU : recoV;
      
      for (H = V = 0, i = 1; i <= 4; i++) {
        H += i * (recoPic[-width + 3 + i] - recoPic[-width + 3 - i]);
        V += i * (recoPic[(3 + i) * width - 1] - recoPic[(3 - i) * width - 1]);
      }
      
      a = 16 * (recoPic[7 * width - 1] + recoPic[-width + 7]);
      b = (17 * H + 16) >> 5;
      c = (17 * V + 16) >> 5;
      
      // pre-compute constant, complete equation (a + b(i-7) + c(j-7) + 16) >> 5
      a += 16 - 3 * (b + c);
      for (j = 0; j < MBK_SIZE/2; j++)
        for (i = 0; i < MBK_SIZE/2; i++)
        {
          // Overflow possible??
          pred[IPR_CHROMA_MODE_PLANE][j][comp+i] = 
            clip8Buf[((a + b*i + c*j) >> 5) + 256];
           
        }
    }
    modeAvail[IPR_CHROMA_MODE_PLANE] = 1;
  }
  else
    modeAvail[IPR_CHROMA_MODE_PLANE] = 0;

 }