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; }