libvpx: Pull from upstream

source/libvpx/vp9/common/vp9_reconintra.c

 /*
  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 13 matching lines @@
   DCT_ADST,   // H
   DCT_DCT,    // D45
   ADST_ADST,  // D135
   ADST_DCT,   // D117
   DCT_ADST,   // D153
   DCT_ADST,   // D207
   ADST_DCT,   // D63
   ADST_ADST,  // TM
 };
 
+// This serves as a wrapper function, so that all the prediction functions
+// can be unified and accessed as a pointer array. Note that the boundary
+// above and left are not necessarily used all the time.
 #define intra_pred_sized(type, size) \
   void vp9_##type##_predictor_##size##x##size##_c(uint8_t *dst, \
                                                   ptrdiff_t stride, \
                                                   const uint8_t *above, \
                                                   const uint8_t *left) { \
     type##_predictor(dst, stride, size, above, left); \
   }
 
 #define intra_pred_allsizes(type) \
   intra_pred_sized(type, 4) \
   intra_pred_sized(type, 8) \
   intra_pred_sized(type, 16) \
   intra_pred_sized(type, 32)
 
 static INLINE void d207_predictor(uint8_t *dst, ptrdiff_t stride, int bs,
                                   const uint8_t *above, const uint8_t *left) {
   int r, c;
-
+  (void) above;
   // first column
   for (r = 0; r < bs - 1; ++r)
     dst[r * stride] = ROUND_POWER_OF_TWO(left[r] + left[r + 1], 1);
   dst[(bs - 1) * stride] = left[bs - 1];
   dst++;
 
   // second column
   for (r = 0; r < bs - 2; ++r)
     dst[r * stride] = ROUND_POWER_OF_TWO(left[r] + left[r + 1] * 2 +
                                          left[r + 2], 2);
   dst[(bs - 2) * stride] = ROUND_POWER_OF_TWO(left[bs - 2] +
                                               left[bs - 1] * 3, 2);
   dst[(bs - 1) * stride] = left[bs - 1];
   dst++;
 
   // rest of last row
   for (c = 0; c < bs - 2; ++c)
     dst[(bs - 1) * stride + c] = left[bs - 1];
 
   for (r = bs - 2; r >= 0; --r)
     for (c = 0; c < bs - 2; ++c)
       dst[r * stride + c] = dst[(r + 1) * stride + c - 2];
 }
 intra_pred_allsizes(d207)
 
 static INLINE void d63_predictor(uint8_t *dst, ptrdiff_t stride, int bs,
                                  const uint8_t *above, const uint8_t *left) {
   int r, c;
+  (void) left;
   for (r = 0; r < bs; ++r) {
     for (c = 0; c < bs; ++c)
       dst[c] = r & 1 ? ROUND_POWER_OF_TWO(above[r/2 + c] +
                                           above[r/2 + c + 1] * 2 +
                                           above[r/2 + c + 2], 2)
                      : ROUND_POWER_OF_TWO(above[r/2 + c] +
                                           above[r/2 + c + 1], 1);
     dst += stride;
   }
 }
 intra_pred_allsizes(d63)
 
 static INLINE void d45_predictor(uint8_t *dst, ptrdiff_t stride, int bs,
                                  const uint8_t *above, const uint8_t *left) {
   int r, c;
+  (void) left;
   for (r = 0; r < bs; ++r) {
     for (c = 0; c < bs; ++c)
       dst[c] = r + c + 2 < bs * 2 ?  ROUND_POWER_OF_TWO(above[r + c] +
                                                         above[r + c + 1] * 2 +
                                                         above[r + c + 2], 2)
                                   : above[bs * 2 - 1];
     dst += stride;
   }
 }
 intra_pred_allsizes(d45)
@@ skipping 72 matching lines @@
     for (c = 0; c < bs - 2; c++)
       dst[c] = dst[-stride + c - 2];
     dst += stride;
   }
 }
 intra_pred_allsizes(d153)
 
 static INLINE void v_predictor(uint8_t *dst, ptrdiff_t stride, int bs,
                                const uint8_t *above, const uint8_t *left) {
   int r;
+  (void) left;
 
   for (r = 0; r < bs; r++) {
     vpx_memcpy(dst, above, bs);
     dst += stride;
   }
 }
 intra_pred_allsizes(v)
 
 static INLINE void h_predictor(uint8_t *dst, ptrdiff_t stride, int bs,
                                const uint8_t *above, const uint8_t *left) {
   int r;
+  (void) above;
 
   for (r = 0; r < bs; r++) {
     vpx_memset(dst, left[r], bs);
     dst += stride;
   }
 }
 intra_pred_allsizes(h)
 
 static INLINE void tm_predictor(uint8_t *dst, ptrdiff_t stride, int bs,
                                 const uint8_t *above, const uint8_t *left) {
   int r, c;
   int ytop_left = above[-1];
 
   for (r = 0; r < bs; r++) {
     for (c = 0; c < bs; c++)
       dst[c] = clip_pixel(left[r] + above[c] - ytop_left);
     dst += stride;
   }
 }
 intra_pred_allsizes(tm)
 
 static INLINE void dc_128_predictor(uint8_t *dst, ptrdiff_t stride, int bs,
                                     const uint8_t *above, const uint8_t *left) {
   int r;
+  (void) above;
+  (void) left;
 
   for (r = 0; r < bs; r++) {
     vpx_memset(dst, 128, bs);
     dst += stride;
   }
 }
 intra_pred_allsizes(dc_128)
 
 static INLINE void dc_left_predictor(uint8_t *dst, ptrdiff_t stride, int bs,
                                      const uint8_t *above,
                                      const uint8_t *left) {
   int i, r, expected_dc, sum = 0;
+  (void) above;
 
   for (i = 0; i < bs; i++)
     sum += left[i];
   expected_dc = (sum + (bs >> 1)) / bs;
 
   for (r = 0; r < bs; r++) {
     vpx_memset(dst, expected_dc, bs);
     dst += stride;
   }
 }
 intra_pred_allsizes(dc_left)
 
 static INLINE void dc_top_predictor(uint8_t *dst, ptrdiff_t stride, int bs,
                                     const uint8_t *above, const uint8_t *left) {
   int i, r, expected_dc, sum = 0;
+  (void) left;
 
   for (i = 0; i < bs; i++)
     sum += above[i];
   expected_dc = (sum + (bs >> 1)) / bs;
 
   for (r = 0; r < bs; r++) {
     vpx_memset(dst, expected_dc, bs);
     dst += stride;
   }
 }
@@ skipping 184 matching lines @@
   const int have_top = (block_idx >> bwl) || xd->up_available;
   const int have_left = (block_idx & wmask) || xd->left_available;
   const int have_right = ((block_idx & wmask) != wmask);
   const int x = aoff * 4;
   const int y = loff * 4;
 
   assert(bwl >= 0);
   build_intra_predictors(xd, ref, ref_stride, dst, dst_stride, mode, tx_size,
                          have_top, have_left, have_right, x, y, plane);
 }