Consistently use get_prob(), clip_prob() and newly added clip_pixel().

Add a function clip_pixel() to clip a pixel value to the [0,255] range
of allowed values, and use this where-ever appropriate (e.g. prediction,
reconstruction). Likewise, consistently use the recently added function
clip_prob(), which calculates a binary probability in the [1,255] range.
If possible, try to use get_prob() or its sister get_binary_prob() to
calculate binary probabilities, for consistency.

Since in some places, this means that binary probability calculations
are changed (we use {255,256}*count0/(total) in a range of places,
and all of these are now changed to use 256*count0+(total>>1)/total),
this changes the encoding result, so this patch warrants some extensive
testing.

Change-Id: Ibeeff8d886496839b8e0c0ace9ccc552351f7628

1 files changed, 46 insertions, 54 deletions

diff --git a/vp9/common/vp9_reconintra4x4.c b/vp9/common/vp9_reconintra4x4.c
index f542acb3d..82338901a 100644
--- a/vp9/common/vp9_reconintra4x4.c
+++ b/vp9/common/vp9_reconintra4x4.c
@@ -156,14 +156,14 @@ void vp9_intra4x4_predict(BLOCKD *x,
                           unsigned char *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];
+  unsigned char *above = *(x->base_dst) + x->dst - x->dst_stride;
+  unsigned char left[4];
+  unsigned char 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 @@ void vp9_intra4x4_predict(BLOCKD *x,
       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 @@ void vp9_intra4x4_predict(BLOCKD *x,
       /* 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;
@@ -213,10 +205,10 @@ void vp9_intra4x4_predict(BLOCKD *x,
     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++) {
@@ -234,10 +226,10 @@ void vp9_intra4x4_predict(BLOCKD *x,
     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++) {
@@ -249,7 +241,7 @@ void vp9_intra4x4_predict(BLOCKD *x,
     }
     break;
     case B_LD_PRED: {
-      unsigned char *ptr = Above;
+      unsigned char *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;
@@ -273,15 +265,15 @@ void vp9_intra4x4_predict(BLOCKD *x,
 
       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] =
@@ -306,15 +298,15 @@ void vp9_intra4x4_predict(BLOCKD *x,
 
       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;
@@ -338,7 +330,7 @@ void vp9_intra4x4_predict(BLOCKD *x,
     break;
     case B_VL_PRED: {
 
-      unsigned char *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;
@@ -361,15 +353,15 @@ void vp9_intra4x4_predict(BLOCKD *x,
 
     case B_HD_PRED: {
       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] + 1) >> 1;
@@ -393,7 +385,7 @@ void vp9_intra4x4_predict(BLOCKD *x,
 
 
     case B_HU_PRED: {
-      unsigned char *pp = Left;
+      unsigned char *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,7 +410,7 @@ void vp9_intra4x4_predict(BLOCKD *x,
     break;
     /*
     case B_CORNER_PRED:
-    corner_predictor(predictor, 16, 4, Above, Left);
+    corner_predictor(predictor, 16, 4, above, left);
     break;
     */
 #endif