| Index: source/libvpx/vp9/common/vp9_reconintra4x4.c
 | 
| ===================================================================
 | 
| --- source/libvpx/vp9/common/vp9_reconintra4x4.c	(revision 177019)
 | 
| +++ source/libvpx/vp9/common/vp9_reconintra4x4.c	(working copy)
 | 
| @@ -9,13 +9,13 @@
 | 
|   */
 | 
|  
 | 
|  
 | 
| -#include "vpx_ports/config.h"
 | 
| +#include "./vpx_config.h"
 | 
|  #include "vpx_mem/vpx_mem.h"
 | 
|  #include "vp9/common/vp9_reconintra.h"
 | 
|  #include "vp9_rtcd.h"
 | 
|  
 | 
|  #if CONFIG_NEWBINTRAMODES
 | 
| -static int find_grad_measure(unsigned char *x, int stride, int n, int t,
 | 
| +static int find_grad_measure(uint8_t *x, int stride, int n, int t,
 | 
|                               int dx, int dy) {
 | 
|    int i, j;
 | 
|    int count = 0, gsum = 0, gdiv;
 | 
| @@ -35,8 +35,8 @@
 | 
|  }
 | 
|  
 | 
|  #if CONTEXT_PRED_REPLACEMENTS == 6
 | 
| -B_PREDICTION_MODE vp9_find_dominant_direction(
 | 
| -    unsigned char *ptr, int stride, int n) {
 | 
| +B_PREDICTION_MODE vp9_find_dominant_direction(uint8_t *ptr,
 | 
| +                                              int stride, int n) {
 | 
|    int g[8], i, imin, imax;
 | 
|    g[1] = find_grad_measure(ptr, stride, n, 4,  2, 1);
 | 
|    g[2] = find_grad_measure(ptr, stride, n, 4,  1, 1);
 | 
| @@ -72,8 +72,8 @@
 | 
|    }
 | 
|  }
 | 
|  #elif CONTEXT_PRED_REPLACEMENTS == 4
 | 
| -B_PREDICTION_MODE vp9_find_dominant_direction(
 | 
| -    unsigned char *ptr, int stride, int n) {
 | 
| +B_PREDICTION_MODE vp9_find_dominant_direction(uint8_t *ptr,
 | 
| +                                              int stride, int n) {
 | 
|    int g[8], i, imin, imax;
 | 
|    g[1] = find_grad_measure(ptr, stride, n, 4,  2, 1);
 | 
|    g[3] = find_grad_measure(ptr, stride, n, 4,  1, 2);
 | 
| @@ -103,8 +103,8 @@
 | 
|    }
 | 
|  }
 | 
|  #elif CONTEXT_PRED_REPLACEMENTS == 0
 | 
| -B_PREDICTION_MODE vp9_find_dominant_direction(
 | 
| -    unsigned char *ptr, int stride, int n) {
 | 
| +B_PREDICTION_MODE vp9_find_dominant_direction(uint8_t *ptr,
 | 
| +                                              int stride, int n) {
 | 
|    int g[8], i, imin, imax;
 | 
|    g[0] = find_grad_measure(ptr, stride, n, 4,  1, 0);
 | 
|    g[1] = find_grad_measure(ptr, stride, n, 4,  2, 1);
 | 
| @@ -145,7 +145,7 @@
 | 
|  #endif
 | 
|  
 | 
|  B_PREDICTION_MODE vp9_find_bpred_context(BLOCKD *x) {
 | 
| -  unsigned char *ptr = *(x->base_dst) + x->dst;
 | 
| +  uint8_t *ptr = *(x->base_dst) + x->dst;
 | 
|    int stride = x->dst_stride;
 | 
|    return vp9_find_dominant_direction(ptr, stride, 4);
 | 
|  }
 | 
| @@ -153,17 +153,17 @@
 | 
|  
 | 
|  void vp9_intra4x4_predict(BLOCKD *x,
 | 
|                            int b_mode,
 | 
| -                          unsigned char *predictor) {
 | 
| +                          uint8_t *predictor) {
 | 
|    int i, r, c;
 | 
|  
 | 
| -  unsigned char *Above = *(x->base_dst) + x->dst - x->dst_stride;
 | 
| -  unsigned char Left[4];
 | 
| -  unsigned char top_left = Above[-1];
 | 
| +  uint8_t *above = *(x->base_dst) + x->dst - x->dst_stride;
 | 
| +  uint8_t left[4];
 | 
| +  uint8_t top_left = above[-1];
 | 
|  
 | 
| -  Left[0] = (*(x->base_dst))[x->dst - 1];
 | 
| -  Left[1] = (*(x->base_dst))[x->dst - 1 + x->dst_stride];
 | 
| -  Left[2] = (*(x->base_dst))[x->dst - 1 + 2 * x->dst_stride];
 | 
| -  Left[3] = (*(x->base_dst))[x->dst - 1 + 3 * x->dst_stride];
 | 
| +  left[0] = (*(x->base_dst))[x->dst - 1];
 | 
| +  left[1] = (*(x->base_dst))[x->dst - 1 + x->dst_stride];
 | 
| +  left[2] = (*(x->base_dst))[x->dst - 1 + 2 * x->dst_stride];
 | 
| +  left[3] = (*(x->base_dst))[x->dst - 1 + 3 * x->dst_stride];
 | 
|  
 | 
|  #if CONFIG_NEWBINTRAMODES
 | 
|    if (b_mode == B_CONTEXT_PRED)
 | 
| @@ -175,8 +175,8 @@
 | 
|        int expected_dc = 0;
 | 
|  
 | 
|        for (i = 0; i < 4; i++) {
 | 
| -        expected_dc += Above[i];
 | 
| -        expected_dc += Left[i];
 | 
| +        expected_dc += above[i];
 | 
| +        expected_dc += left[i];
 | 
|        }
 | 
|  
 | 
|        expected_dc = (expected_dc + 4) >> 3;
 | 
| @@ -194,15 +194,7 @@
 | 
|        /* prediction similar to true_motion prediction */
 | 
|        for (r = 0; r < 4; r++) {
 | 
|          for (c = 0; c < 4; c++) {
 | 
| -          int pred = Above[c] - top_left + Left[r];
 | 
| -
 | 
| -          if (pred < 0)
 | 
| -            pred = 0;
 | 
| -
 | 
| -          if (pred > 255)
 | 
| -            pred = 255;
 | 
| -
 | 
| -          predictor[c] = pred;
 | 
| +          predictor[c] = clip_pixel(above[c] - top_left + left[r]);
 | 
|          }
 | 
|  
 | 
|          predictor += 16;
 | 
| @@ -211,34 +203,31 @@
 | 
|      break;
 | 
|  
 | 
|      case B_VE_PRED: {
 | 
| -
 | 
|        unsigned int ap[4];
 | 
| -      ap[0] = Above[0];
 | 
| -      ap[1] = Above[1];
 | 
| -      ap[2] = Above[2];
 | 
| -      ap[3] = Above[3];
 | 
|  
 | 
| +      ap[0] = above[0];
 | 
| +      ap[1] = above[1];
 | 
| +      ap[2] = above[2];
 | 
| +      ap[3] = above[3];
 | 
| +
 | 
|        for (r = 0; r < 4; r++) {
 | 
|          for (c = 0; c < 4; c++) {
 | 
| -
 | 
|            predictor[c] = ap[c];
 | 
|          }
 | 
|  
 | 
|          predictor += 16;
 | 
|        }
 | 
| -
 | 
|      }
 | 
|      break;
 | 
|  
 | 
| -
 | 
|      case B_HE_PRED: {
 | 
| -
 | 
|        unsigned int lp[4];
 | 
| -      lp[0] = Left[0];
 | 
| -      lp[1] = Left[1];
 | 
| -      lp[2] = Left[2];
 | 
| -      lp[3] = Left[3];
 | 
|  
 | 
| +      lp[0] = left[0];
 | 
| +      lp[1] = left[1];
 | 
| +      lp[2] = left[2];
 | 
| +      lp[3] = left[3];
 | 
| +
 | 
|        for (r = 0; r < 4; r++) {
 | 
|          for (c = 0; c < 4; c++) {
 | 
|            predictor[c] = lp[r];
 | 
| @@ -249,7 +238,8 @@
 | 
|      }
 | 
|      break;
 | 
|      case B_LD_PRED: {
 | 
| -      unsigned char *ptr = Above;
 | 
| +      uint8_t *ptr = above;
 | 
| +
 | 
|        predictor[0 * 16 + 0] = (ptr[0] + ptr[1] * 2 + ptr[2] + 2) >> 2;
 | 
|        predictor[0 * 16 + 1] =
 | 
|          predictor[1 * 16 + 0] = (ptr[1] + ptr[2] * 2 + ptr[3] + 2) >> 2;
 | 
| @@ -270,18 +260,17 @@
 | 
|      }
 | 
|      break;
 | 
|      case B_RD_PRED: {
 | 
| +      uint8_t pp[9];
 | 
|  
 | 
| -      unsigned char pp[9];
 | 
| -
 | 
| -      pp[0] = Left[3];
 | 
| -      pp[1] = Left[2];
 | 
| -      pp[2] = Left[1];
 | 
| -      pp[3] = Left[0];
 | 
| +      pp[0] = left[3];
 | 
| +      pp[1] = left[2];
 | 
| +      pp[2] = left[1];
 | 
| +      pp[3] = left[0];
 | 
|        pp[4] = top_left;
 | 
| -      pp[5] = Above[0];
 | 
| -      pp[6] = Above[1];
 | 
| -      pp[7] = Above[2];
 | 
| -      pp[8] = Above[3];
 | 
| +      pp[5] = above[0];
 | 
| +      pp[6] = above[1];
 | 
| +      pp[7] = above[2];
 | 
| +      pp[8] = above[3];
 | 
|  
 | 
|        predictor[3 * 16 + 0] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
 | 
|        predictor[3 * 16 + 1] =
 | 
| @@ -303,20 +292,18 @@
 | 
|      }
 | 
|      break;
 | 
|      case B_VR_PRED: {
 | 
| +      uint8_t pp[9];
 | 
|  
 | 
| -      unsigned char pp[9];
 | 
| -
 | 
| -      pp[0] = Left[3];
 | 
| -      pp[1] = Left[2];
 | 
| -      pp[2] = Left[1];
 | 
| -      pp[3] = Left[0];
 | 
| +      pp[0] = left[3];
 | 
| +      pp[1] = left[2];
 | 
| +      pp[2] = left[1];
 | 
| +      pp[3] = left[0];
 | 
|        pp[4] = top_left;
 | 
| -      pp[5] = Above[0];
 | 
| -      pp[6] = Above[1];
 | 
| -      pp[7] = Above[2];
 | 
| -      pp[8] = Above[3];
 | 
| +      pp[5] = above[0];
 | 
| +      pp[6] = above[1];
 | 
| +      pp[7] = above[2];
 | 
| +      pp[8] = above[3];
 | 
|  
 | 
| -
 | 
|        predictor[3 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
 | 
|        predictor[2 * 16 + 0] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2;
 | 
|        predictor[3 * 16 + 1] =
 | 
| @@ -337,9 +324,8 @@
 | 
|      }
 | 
|      break;
 | 
|      case B_VL_PRED: {
 | 
| +      uint8_t *pp = above;
 | 
|  
 | 
| -      unsigned char *pp = Above;
 | 
| -
 | 
|        predictor[0 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1;
 | 
|        predictor[1 * 16 + 0] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
 | 
|        predictor[2 * 16 + 0] =
 | 
| @@ -360,16 +346,17 @@
 | 
|      break;
 | 
|  
 | 
|      case B_HD_PRED: {
 | 
| -      unsigned char pp[9];
 | 
| -      pp[0] = Left[3];
 | 
| -      pp[1] = Left[2];
 | 
| -      pp[2] = Left[1];
 | 
| -      pp[3] = Left[0];
 | 
| +      uint8_t pp[9];
 | 
| +
 | 
| +      pp[0] = left[3];
 | 
| +      pp[1] = left[2];
 | 
| +      pp[2] = left[1];
 | 
| +      pp[3] = left[0];
 | 
|        pp[4] = top_left;
 | 
| -      pp[5] = Above[0];
 | 
| -      pp[6] = Above[1];
 | 
| -      pp[7] = Above[2];
 | 
| -      pp[8] = Above[3];
 | 
| +      pp[5] = above[0];
 | 
| +      pp[6] = above[1];
 | 
| +      pp[7] = above[2];
 | 
| +      pp[8] = above[3];
 | 
|  
 | 
|  
 | 
|        predictor[3 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1;
 | 
| @@ -393,7 +380,7 @@
 | 
|  
 | 
|  
 | 
|      case B_HU_PRED: {
 | 
| -      unsigned char *pp = Left;
 | 
| +      uint8_t *pp = left;
 | 
|        predictor[0 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1;
 | 
|        predictor[0 * 16 + 1] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
 | 
|        predictor[0 * 16 + 2] =
 | 
| @@ -418,49 +405,39 @@
 | 
|      break;
 | 
|      /*
 | 
|      case B_CORNER_PRED:
 | 
| -    corner_predictor(predictor, 16, 4, Above, Left);
 | 
| +    corner_predictor(predictor, 16, 4, above, left);
 | 
|      break;
 | 
|      */
 | 
|  #endif
 | 
|    }
 | 
|  }
 | 
|  
 | 
| -#if CONFIG_COMP_INTRA_PRED
 | 
| -void vp9_comp_intra4x4_predict_c(BLOCKD *x,
 | 
| -                               int b_mode, int b_mode2,
 | 
| -                               unsigned char *out_predictor) {
 | 
| -  unsigned char predictor[2][4 * 16];
 | 
| -  int i, j;
 | 
| -
 | 
| -  vp9_intra4x4_predict(x, b_mode, predictor[0]);
 | 
| -  vp9_intra4x4_predict(x, b_mode2, predictor[1]);
 | 
| -
 | 
| -  for (i = 0; i < 16 * 4; i += 16) {
 | 
| -    for (j = i; j < i + 4; j++) {
 | 
| -      out_predictor[j] = (predictor[0][j] + predictor[1][j] + 1) >> 1;
 | 
| -    }
 | 
| -  }
 | 
| -}
 | 
| -#endif
 | 
| -
 | 
|  /* copy 4 bytes from the above right down so that the 4x4 prediction modes using pixels above and
 | 
|   * to the right prediction have filled in pixels to use.
 | 
|   */
 | 
|  void vp9_intra_prediction_down_copy(MACROBLOCKD *xd) {
 | 
| -  int extend_edge = (xd->mb_to_right_edge == 0 && xd->mb_index < 2);
 | 
| -  unsigned char *above_right = *(xd->block[0].base_dst) + xd->block[0].dst -
 | 
| +  int extend_edge = xd->mb_to_right_edge == 0 && xd->mb_index < 2;
 | 
| +  uint8_t *above_right = *(xd->block[0].base_dst) + xd->block[0].dst -
 | 
|                                 xd->block[0].dst_stride + 16;
 | 
| -  unsigned int *src_ptr = (unsigned int *)
 | 
| -      (above_right - (xd->mb_index == 3 ? 16 * xd->block[0].dst_stride : 0));
 | 
| +  uint32_t *dst_ptr0 = (uint32_t *)above_right;
 | 
| +  uint32_t *dst_ptr1 =
 | 
| +    (uint32_t *)(above_right + 4 * xd->block[0].dst_stride);
 | 
| +  uint32_t *dst_ptr2 =
 | 
| +    (uint32_t *)(above_right + 8 * xd->block[0].dst_stride);
 | 
| +  uint32_t *dst_ptr3 =
 | 
| +    (uint32_t *)(above_right + 12 * xd->block[0].dst_stride);
 | 
|  
 | 
| -  unsigned int *dst_ptr0 = (unsigned int *)above_right;
 | 
| -  unsigned int *dst_ptr1 =
 | 
| -    (unsigned int *)(above_right + 4 * xd->block[0].dst_stride);
 | 
| -  unsigned int *dst_ptr2 =
 | 
| -    (unsigned int *)(above_right + 8 * xd->block[0].dst_stride);
 | 
| -  unsigned int *dst_ptr3 =
 | 
| -    (unsigned int *)(above_right + 12 * xd->block[0].dst_stride);
 | 
| +  uint32_t *src_ptr = (uint32_t *) above_right;
 | 
|  
 | 
| +  if ((xd->sb_index >= 2 && xd->mb_to_right_edge == 0) ||
 | 
| +      (xd->sb_index == 3 && xd->mb_index & 1))
 | 
| +    src_ptr = (uint32_t *) (((uint8_t *) src_ptr) - 32 *
 | 
| +                                                    xd->block[0].dst_stride);
 | 
| +  if (xd->mb_index == 3 ||
 | 
| +      (xd->mb_to_right_edge == 0 && xd->mb_index == 2))
 | 
| +    src_ptr = (uint32_t *) (((uint8_t *) src_ptr) - 16 *
 | 
| +                                                    xd->block[0].dst_stride);
 | 
| +
 | 
|    if (extend_edge) {
 | 
|      *src_ptr = ((uint8_t *) src_ptr)[-1] * 0x01010101U;
 | 
|    }
 | 
| 
 |