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.
  */
 
 #include <stdio.h>
-#include "vpx_ports/config.h"
+#include "./vpx_config.h"
 #include "vp9_rtcd.h"
 #include "vp9/common/vp9_reconintra.h"
 #include "vpx_mem/vpx_mem.h"
 
 /* For skip_recon_mb(), add vp9_build_intra_predictors_mby_s(MACROBLOCKD *xd)
  * and vp9_build_intra_predictors_mbuv_s(MACROBLOCKD *xd).
  */
 
 static void d27_predictor(uint8_t *ypred_ptr, int y_stride, int n,
                           uint8_t *yabove_row, uint8_t *yleft_col) {
@@ skipping 94 matching lines @@
                           uint8_t *yabove_row, uint8_t *yleft_col) {
   int r, c;
   for (r = 0; r < n - 1; ++r) {
     for (c = 0; c <= r; ++c) {
       ypred_ptr[(r - c) * y_stride + c] =
         (yabove_row[r + 1] * (c + 1) +
          yleft_col[r + 1] * (r - c + 1) + r / 2 + 1) / (r + 2);
     }
   }
   for (c = 0; c <= r; ++c) {
-    int yabove_ext = yabove_row[r]; // 2*yabove_row[r] - yabove_row[r-1];
-    int yleft_ext = yleft_col[r]; // 2*yleft_col[r] - yleft_col[r-1];
-    yabove_ext = (yabove_ext > 255 ? 255 : (yabove_ext < 0 ? 0 : yabove_ext));
-    yleft_ext = (yleft_ext > 255 ? 255 : (yleft_ext < 0 ? 0 : yleft_ext));
+    int yabove_ext = yabove_row[r];  // clip_pixel(2 * yabove_row[r] -
+                                     //            yabove_row[r - 1]);
+    int yleft_ext = yleft_col[r];  // clip_pixel(2 * yleft_col[r] -
+                                   //            yleft_col[r-1]);
     ypred_ptr[(r - c) * y_stride + c] =
       (yabove_ext * (c + 1) +
        yleft_ext * (r - c + 1) + r / 2 + 1) / (r + 2);
   }
   for (r = 1; r < n; ++r) {
-    for (c = n - r; c < n; ++c)
-      ypred_ptr[r * y_stride + c] = (ypred_ptr[(r - 1) * y_stride + c] +
-                                     ypred_ptr[r * y_stride + c - 1] + 1) >> 1;
+    for (c = n - r; c < n; ++c) {
+      const int yabove_ext = ypred_ptr[(r - 1) * y_stride + c];
+      const int yleft_ext = ypred_ptr[r * y_stride + c - 1];
+      ypred_ptr[r * y_stride + c] = (yabove_ext + yleft_ext + 1) >> 1;
+    }
   }
 }
 
 static void d117_predictor(uint8_t *ypred_ptr, int y_stride, int n,
                            uint8_t *yabove_row, uint8_t *yleft_col) {
   int r, c;
   for (c = 0; c < n; c++)
     ypred_ptr[c] = (yabove_row[c - 1] + yabove_row[c] + 1) >> 1;
   ypred_ptr += y_stride;
   for (c = 0; c < n; c++)
@@ skipping 40 matching lines @@
   for (c = 0; c < n - 2; c++)
     ypred_ptr[c] = yabove_row[c];
   ypred_ptr += y_stride;
   for (r = 1; r < n; ++r) {
     for (c = 0; c < n - 2; c++)
       ypred_ptr[c] = ypred_ptr[-y_stride + c - 2];
     ypred_ptr += y_stride;
   }
 }
 
-static void corner_predictor(unsigned char *ypred_ptr, int y_stride, int n,
-                             unsigned char *yabove_row,
-                             unsigned char *yleft_col) {
+static void corner_predictor(uint8_t *ypred_ptr, int y_stride, int n,
+                             uint8_t *yabove_row,
+                             uint8_t *yleft_col) {
   int mh, mv, maxgradh, maxgradv, x, y, nx, ny;
   int i, j;
   int top_left = yabove_row[-1];
   mh = mv = 0;
   maxgradh = yabove_row[1] - top_left;
   maxgradv = yleft_col[1] - top_left;
   for (i = 2; i < n; ++i) {
     int gh = yabove_row[i] - yabove_row[i - 2];
     int gv = yleft_col[i] - yleft_col[i - 2];
     if (gh > maxgradh) {
@@ skipping 27 matching lines @@
 }
 
 void vp9_recon_intra_mbuv(MACROBLOCKD *xd) {
   int i;
   for (i = 16; i < 24; i += 2) {
     BLOCKD *b = &xd->block[i];
     vp9_recon2b(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
   }
 }
 
-void vp9_build_intra_predictors_internal(unsigned char *src, int src_stride,
-                                         unsigned char *ypred_ptr,
+void vp9_build_intra_predictors_internal(uint8_t *src, int src_stride,
+                                         uint8_t *ypred_ptr,
                                          int y_stride, int mode, int bsize,
                                          int up_available, int left_available) {
 
-  unsigned char *yabove_row = src - src_stride;
-  unsigned char yleft_col[32];
-  unsigned char ytop_left = yabove_row[-1];
+  uint8_t *yabove_row = src - src_stride;
+  uint8_t yleft_col[64];
+  uint8_t ytop_left = yabove_row[-1];
   int r, c, i;
 
   for (i = 0; i < bsize; i++) {
     yleft_col[i] = src[i * src_stride - 1];
   }
 
   /* for Y */
   switch (mode) {
     case DC_PRED: {
       int expected_dc;
       int i;
       int shift;
       int average = 0;
       int log2_bsize_minus_1;
 
-      assert(bsize == 4 || bsize == 8 || bsize == 16 || bsize == 32);
+      assert(bsize == 4 || bsize == 8 || bsize == 16 || bsize == 32 ||
+             bsize == 64);
       if (bsize == 4) {
         log2_bsize_minus_1 = 1;
       } else if (bsize == 8) {
         log2_bsize_minus_1 = 2;
       } else if (bsize == 16) {
         log2_bsize_minus_1 = 3;
-      } else /* bsize == 32 */ {
+      } else if (bsize == 32) {
         log2_bsize_minus_1 = 4;
+      } else {
+        assert(bsize == 64);
+        log2_bsize_minus_1 = 5;
       }
 
       if (up_available || left_available) {
         if (up_available) {
           for (i = 0; i < bsize; i++) {
             average += yabove_row[i];
           }
         }
 
         if (left_available) {
@@ skipping 23 matching lines @@
     case H_PRED: {
       for (r = 0; r < bsize; r++) {
         vpx_memset(ypred_ptr, yleft_col[r], bsize);
         ypred_ptr += y_stride;
       }
     }
     break;
     case TM_PRED: {
       for (r = 0; r < bsize; r++) {
         for (c = 0; c < bsize; c++) {
-          int pred =  yleft_col[r] + yabove_row[ c] - ytop_left;
-
-          if (pred < 0)
-            pred = 0;
-
-          if (pred > 255)
-            pred = 255;
-
-          ypred_ptr[c] = pred;
+          ypred_ptr[c] = clip_pixel(yleft_col[r] + yabove_row[c] - ytop_left);
         }
 
         ypred_ptr += y_stride;
       }
     }
     break;
     case D45_PRED: {
       d45_predictor(ypred_ptr, y_stride, bsize,  yabove_row, yleft_col);
     }
     break;
@@ skipping 24 matching lines @@
     case ZEROMV:
     case NEWMV:
     case SPLITMV:
     case MB_MODE_COUNT:
       break;
   }
 }
 
 #if CONFIG_COMP_INTERINTRA_PRED
 static void combine_interintra(MB_PREDICTION_MODE mode,
-                               unsigned char *interpred,
+                               uint8_t *interpred,
                                int interstride,
-                               unsigned char *intrapred,
+                               uint8_t *intrapred,
                                int intrastride,
                                int size) {
   // TODO(debargha): Explore different ways of combining predictors
   //                 or designing the tables below
   static const int scale_bits = 8;
   static const int scale_max = 256;     // 1 << scale_bits;
   static const int scale_round = 127;   // (1 << (scale_bits - 1));
   // This table is a function A + B*exp(-kx), where x is hor. index
   static const int weights1d[32] = {
     128, 122, 116, 111, 107, 103,  99,  96,
@@ skipping 126 matching lines @@
     69,  68,  68,  68,  68,  68,  67,  67,
     128, 101,  93,  89,  85,  83,  81,  79,
     78,  76,  75,  74,  74,  73,  72,  72,
     71,  71,  70,  70,  70,  69,  69,  69,
     68,  68,  68,  68,  68,  67,  67,  67,
     128, 101,  93,  88,  85,  82,  80,  79,
     77,  76,  75,  74,  73,  73,  72,  71,
     71,  70,  70,  70,  69,  69,  69,  68,
     68,  68,  68,  68,  67,  67,  67,  67,
   };
-  int size_scale = (size == 32 ? 1 :
+  int size_scale = (size >= 32 ? 1 :
                     size == 16 ? 2 :
                     size == 8  ? 4 : 8);
+  int size_shift = size == 64 ? 1 : 0;
   int i, j;
   switch (mode) {
     case V_PRED:
       for (i = 0; i < size; ++i) {
         for (j = 0; j < size; ++j) {
           int k = i * interstride + j;
-          int scale = weights1d[i * size_scale];
+          int scale = weights1d[i * size_scale >> size_shift];
           interpred[k] =
               ((scale_max - scale) * interpred[k] +
                scale * intrapred[i * intrastride + j] + scale_round)
               >> scale_bits;
         }
       }
       break;
 
     case H_PRED:
       for (i = 0; i < size; ++i) {
         for (j = 0; j < size; ++j) {
           int k = i * interstride + j;
-          int scale = weights1d[j * size_scale];
+          int scale = weights1d[j * size_scale >> size_shift];
           interpred[k] =
               ((scale_max - scale) * interpred[k] +
                scale * intrapred[i * intrastride + j] + scale_round)
               >> scale_bits;
         }
       }
       break;
 
     case D63_PRED:
     case D117_PRED:
       for (i = 0; i < size; ++i) {
         for (j = 0; j < size; ++j) {
           int k = i * interstride + j;
-          int scale = (weights2d[i * size_scale * 32 + j * size_scale] +
-                       weights1d[i * size_scale]) >> 1;
+          int scale = (weights2d[(i * size_scale * 32 +
+                                  j * size_scale) >> size_shift] +
+                       weights1d[i * size_scale >> size_shift]) >> 1;
           interpred[k] =
               ((scale_max - scale) * interpred[k] +
                scale * intrapred[i * intrastride + j] + scale_round)
               >> scale_bits;
         }
       }
       break;
 
     case D27_PRED:
     case D153_PRED:
       for (i = 0; i < size; ++i) {
         for (j = 0; j < size; ++j) {
           int k = i * interstride + j;
-          int scale = (weights2d[i * size_scale * 32 + j * size_scale] +
-                       weights1d[j * size_scale]) >> 1;
+          int scale = (weights2d[(i * size_scale * 32 +
+                                  j * size_scale) >> size_shift] +
+                       weights1d[j * size_scale >> size_shift]) >> 1;
           interpred[k] =
               ((scale_max - scale) * interpred[k] +
                scale * intrapred[i * intrastride + j] + scale_round)
               >> scale_bits;
         }
       }
       break;
 
     case D135_PRED:
       for (i = 0; i < size; ++i) {
         for (j = 0; j < size; ++j) {
           int k = i * interstride + j;
-          int scale = weights2d[i * size_scale * 32 + j * size_scale];
+          int scale = weights2d[(i * size_scale * 32 +
+                                 j * size_scale) >> size_shift];
           interpred[k] =
               ((scale_max - scale) * interpred[k] +
                scale * intrapred[i * intrastride + j] + scale_round)
               >> scale_bits;
         }
       }
       break;
 
     case D45_PRED:
     case DC_PRED:
     case TM_PRED:
     default:
       // simple average
       for (i = 0; i < size; ++i) {
         for (j = 0; j < size; ++j) {
           int k = i * interstride + j;
           interpred[k] = (interpred[k] + intrapred[i * intrastride + j]) >> 1;
         }
       }
       break;
   }
 }
 
 void vp9_build_interintra_16x16_predictors_mb(MACROBLOCKD *xd,
-                                              unsigned char *ypred,
-                                              unsigned char *upred,
-                                              unsigned char *vpred,
+                                              uint8_t *ypred,
+                                              uint8_t *upred,
+                                              uint8_t *vpred,
                                               int ystride, int uvstride) {
   vp9_build_interintra_16x16_predictors_mby(xd, ypred, ystride);
   vp9_build_interintra_16x16_predictors_mbuv(xd, upred, vpred, uvstride);
 }
 
 void vp9_build_interintra_16x16_predictors_mby(MACROBLOCKD *xd,
-                                               unsigned char *ypred,
+                                               uint8_t *ypred,
                                                int ystride) {
-  unsigned char intrapredictor[256];
+  uint8_t intrapredictor[256];
   vp9_build_intra_predictors_internal(
       xd->dst.y_buffer, xd->dst.y_stride,
       intrapredictor, 16,
       xd->mode_info_context->mbmi.interintra_mode, 16,
       xd->up_available, xd->left_available);
   combine_interintra(xd->mode_info_context->mbmi.interintra_mode,
                      ypred, ystride, intrapredictor, 16, 16);
 }
 
 void vp9_build_interintra_16x16_predictors_mbuv(MACROBLOCKD *xd,
-                                                unsigned char *upred,
-                                                unsigned char *vpred,
+                                                uint8_t *upred,
+                                                uint8_t *vpred,
                                                 int uvstride) {
-  unsigned char uintrapredictor[64];
-  unsigned char vintrapredictor[64];
+  uint8_t uintrapredictor[64];
+  uint8_t vintrapredictor[64];
   vp9_build_intra_predictors_internal(
       xd->dst.u_buffer, xd->dst.uv_stride,
       uintrapredictor, 8,
       xd->mode_info_context->mbmi.interintra_uv_mode, 8,
       xd->up_available, xd->left_available);
   vp9_build_intra_predictors_internal(
       xd->dst.v_buffer, xd->dst.uv_stride,
       vintrapredictor, 8,
       xd->mode_info_context->mbmi.interintra_uv_mode, 8,
       xd->up_available, xd->left_available);
   combine_interintra(xd->mode_info_context->mbmi.interintra_uv_mode,
                      upred, uvstride, uintrapredictor, 8, 8);
   combine_interintra(xd->mode_info_context->mbmi.interintra_uv_mode,
                      vpred, uvstride, vintrapredictor, 8, 8);
 }
 
-#if CONFIG_SUPERBLOCKS
 void vp9_build_interintra_32x32_predictors_sby(MACROBLOCKD *xd,
-                                               unsigned char *ypred,
+                                               uint8_t *ypred,
                                                int ystride) {
-  unsigned char intrapredictor[1024];
+  uint8_t intrapredictor[1024];
   vp9_build_intra_predictors_internal(
       xd->dst.y_buffer, xd->dst.y_stride,
       intrapredictor, 32,
       xd->mode_info_context->mbmi.interintra_mode, 32,
       xd->up_available, xd->left_available);
   combine_interintra(xd->mode_info_context->mbmi.interintra_mode,
                      ypred, ystride, intrapredictor, 32, 32);
 }
 
 void vp9_build_interintra_32x32_predictors_sbuv(MACROBLOCKD *xd,
-                                                unsigned char *upred,
-                                                unsigned char *vpred,
+                                                uint8_t *upred,
+                                                uint8_t *vpred,
                                                 int uvstride) {
-  unsigned char uintrapredictor[256];
-  unsigned char vintrapredictor[256];
+  uint8_t uintrapredictor[256];
+  uint8_t vintrapredictor[256];
   vp9_build_intra_predictors_internal(
       xd->dst.u_buffer, xd->dst.uv_stride,
       uintrapredictor, 16,
       xd->mode_info_context->mbmi.interintra_uv_mode, 16,
       xd->up_available, xd->left_available);
   vp9_build_intra_predictors_internal(
       xd->dst.v_buffer, xd->dst.uv_stride,
       vintrapredictor, 16,
       xd->mode_info_context->mbmi.interintra_uv_mode, 16,
       xd->up_available, xd->left_available);
   combine_interintra(xd->mode_info_context->mbmi.interintra_uv_mode,
                      upred, uvstride, uintrapredictor, 16, 16);
   combine_interintra(xd->mode_info_context->mbmi.interintra_uv_mode,
                      vpred, uvstride, vintrapredictor, 16, 16);
 }
 
 void vp9_build_interintra_32x32_predictors_sb(MACROBLOCKD *xd,
-                                              unsigned char *ypred,
-                                              unsigned char *upred,
-                                              unsigned char *vpred,
+                                              uint8_t *ypred,
+                                              uint8_t *upred,
+                                              uint8_t *vpred,
                                               int ystride,
                                               int uvstride) {
   vp9_build_interintra_32x32_predictors_sby(xd, ypred, ystride);
   vp9_build_interintra_32x32_predictors_sbuv(xd, upred, vpred, uvstride);
 }
-#endif
-#endif
+
+void vp9_build_interintra_64x64_predictors_sby(MACROBLOCKD *xd,
+                                               uint8_t *ypred,
+                                               int ystride) {
+  uint8_t intrapredictor[4096];
+  const int mode = xd->mode_info_context->mbmi.interintra_mode;
+  vp9_build_intra_predictors_internal(xd->dst.y_buffer, xd->dst.y_stride,
+                                      intrapredictor, 64, mode, 64,
+                                      xd->up_available, xd->left_available);
+  combine_interintra(xd->mode_info_context->mbmi.interintra_mode,
+                     ypred, ystride, intrapredictor, 64, 64);
+}
+
+void vp9_build_interintra_64x64_predictors_sbuv(MACROBLOCKD *xd,
+                                                uint8_t *upred,
+                                                uint8_t *vpred,
+                                                int uvstride) {
+  uint8_t uintrapredictor[1024];
+  uint8_t vintrapredictor[1024];
+  const int mode = xd->mode_info_context->mbmi.interintra_uv_mode;
+  vp9_build_intra_predictors_internal(xd->dst.u_buffer, xd->dst.uv_stride,
+                                      uintrapredictor, 32, mode, 32,
+                                      xd->up_available, xd->left_available);
+  vp9_build_intra_predictors_internal(xd->dst.v_buffer, xd->dst.uv_stride,
+                                      vintrapredictor, 32, mode, 32,
+                                      xd->up_available, xd->left_available);
+  combine_interintra(xd->mode_info_context->mbmi.interintra_uv_mode,
+                     upred, uvstride, uintrapredictor, 32, 32);
+  combine_interintra(xd->mode_info_context->mbmi.interintra_uv_mode,
+                     vpred, uvstride, vintrapredictor, 32, 32);
+}
+
+void vp9_build_interintra_64x64_predictors_sb(MACROBLOCKD *xd,
+                                              uint8_t *ypred,
+                                              uint8_t *upred,
+                                              uint8_t *vpred,
+                                              int ystride,
+                                              int uvstride) {
+  vp9_build_interintra_64x64_predictors_sby(xd, ypred, ystride);
+  vp9_build_interintra_64x64_predictors_sbuv(xd, upred, vpred, uvstride);
+}
+#endif  // CONFIG_COMP_INTERINTRA_PRED
 
 void vp9_build_intra_predictors_mby(MACROBLOCKD *xd) {
   vp9_build_intra_predictors_internal(xd->dst.y_buffer, xd->dst.y_stride,
                                       xd->predictor, 16,
                                       xd->mode_info_context->mbmi.mode, 16,
                                       xd->up_available, xd->left_available);
 }
 
 void vp9_build_intra_predictors_mby_s(MACROBLOCKD *xd) {
   vp9_build_intra_predictors_internal(xd->dst.y_buffer, xd->dst.y_stride,
                                       xd->dst.y_buffer, xd->dst.y_stride,
                                       xd->mode_info_context->mbmi.mode, 16,
                                       xd->up_available, xd->left_available);
 }
 
-#if CONFIG_SUPERBLOCKS
 void vp9_build_intra_predictors_sby_s(MACROBLOCKD *xd) {
   vp9_build_intra_predictors_internal(xd->dst.y_buffer, xd->dst.y_stride,
                                       xd->dst.y_buffer, xd->dst.y_stride,
                                       xd->mode_info_context->mbmi.mode, 32,
                                       xd->up_available, xd->left_available);
 }
-#endif
 
-#if CONFIG_COMP_INTRA_PRED
-void vp9_build_comp_intra_predictors_mby(MACROBLOCKD *xd) {
-  unsigned char predictor[2][256];
-  int i;
-
+void vp9_build_intra_predictors_sb64y_s(MACROBLOCKD *xd) {
   vp9_build_intra_predictors_internal(xd->dst.y_buffer, xd->dst.y_stride,
-                                      predictor[0], 16,
-                                      xd->mode_info_context->mbmi.mode,
-                                      16, xd->up_available,
-                                      xd->left_available);
-  vp9_build_intra_predictors_internal(xd->dst.y_buffer, xd->dst.y_stride,
-                                      predictor[1], 16,
-                                      xd->mode_info_context->mbmi.second_mode,
-                                      16, xd->up_available,
-                                      xd->left_available);
-
-  for (i = 0; i < 256; i++) {
-    xd->predictor[i] = (predictor[0][i] + predictor[1][i] + 1) >> 1;
-  }
+                                      xd->dst.y_buffer, xd->dst.y_stride,
+                                      xd->mode_info_context->mbmi.mode, 64,
+                                      xd->up_available, xd->left_available);
 }
-#endif
 
 void vp9_build_intra_predictors_mbuv_internal(MACROBLOCKD *xd,
-                                              unsigned char *upred_ptr,
-                                              unsigned char *vpred_ptr,
+                                              uint8_t *upred_ptr,
+                                              uint8_t *vpred_ptr,
                                               int uv_stride,
                                               int mode, int bsize) {
   vp9_build_intra_predictors_internal(xd->dst.u_buffer, xd->dst.uv_stride,
                                       upred_ptr, uv_stride, mode, bsize,
                                       xd->up_available, xd->left_available);
   vp9_build_intra_predictors_internal(xd->dst.v_buffer, xd->dst.uv_stride,
                                       vpred_ptr, uv_stride, mode, bsize,
                                       xd->up_available, xd->left_available);
 }
 
 void vp9_build_intra_predictors_mbuv(MACROBLOCKD *xd) {
   vp9_build_intra_predictors_mbuv_internal(xd, &xd->predictor[256],
                                            &xd->predictor[320], 8,
                                            xd->mode_info_context->mbmi.uv_mode,
                                            8);
 }
 
 void vp9_build_intra_predictors_mbuv_s(MACROBLOCKD *xd) {
   vp9_build_intra_predictors_mbuv_internal(xd, xd->dst.u_buffer,
                                            xd->dst.v_buffer,
                                            xd->dst.uv_stride,
                                            xd->mode_info_context->mbmi.uv_mode,
                                            8);
 }
 
-#if CONFIG_SUPERBLOCKS
 void vp9_build_intra_predictors_sbuv_s(MACROBLOCKD *xd) {
   vp9_build_intra_predictors_mbuv_internal(xd, xd->dst.u_buffer,
                                            xd->dst.v_buffer, xd->dst.uv_stride,
                                            xd->mode_info_context->mbmi.uv_mode,
                                            16);
 }
-#endif
 
-#if CONFIG_COMP_INTRA_PRED
-void vp9_build_comp_intra_predictors_mbuv(MACROBLOCKD *xd) {
-  unsigned char predictor[2][2][64];
-  int i;
-
-  vp9_build_intra_predictors_mbuv_internal(
-      xd, predictor[0][0], predictor[1][0], 8,
-      xd->mode_info_context->mbmi.uv_mode, 8);
-  vp9_build_intra_predictors_mbuv_internal(
-      xd, predictor[0][1], predictor[1][1], 8,
-      xd->mode_info_context->mbmi.second_uv_mode, 8);
-  for (i = 0; i < 64; i++) {
-    xd->predictor[256 + i] = (predictor[0][0][i] + predictor[0][1][i] + 1) >> 1;
-    xd->predictor[256 + 64 + i] = (predictor[1][0][i] +
-                                   predictor[1][1][i] + 1) >> 1;
-  }
+void vp9_build_intra_predictors_sb64uv_s(MACROBLOCKD *xd) {
+  vp9_build_intra_predictors_mbuv_internal(xd, xd->dst.u_buffer,
+                                           xd->dst.v_buffer, xd->dst.uv_stride,
+                                           xd->mode_info_context->mbmi.uv_mode,
+                                           32);
 }
-#endif
 
 void vp9_intra8x8_predict(BLOCKD *xd,
                           int mode,
-                          unsigned char *predictor) {
+                          uint8_t *predictor) {
   vp9_build_intra_predictors_internal(*(xd->base_dst) + xd->dst,
                                       xd->dst_stride, predictor, 16,
                                       mode, 8, 1, 1);
 }
 
-#if CONFIG_COMP_INTRA_PRED
-void vp9_comp_intra8x8_predict(BLOCKD *xd,
-                               int mode, int second_mode,
-                               unsigned char *out_predictor) {
-  unsigned char predictor[2][8 * 16];
-  int i, j;
-
-  vp9_intra8x8_predict(xd, mode, predictor[0]);
-  vp9_intra8x8_predict(xd, second_mode, predictor[1]);
-
-  for (i = 0; i < 8 * 16; i += 16) {
-    for (j = i; j < i + 8; j++) {
-      out_predictor[j] = (predictor[0][j] + predictor[1][j] + 1) >> 1;
-    }
-  }
-}
-#endif
-
 void vp9_intra_uv4x4_predict(BLOCKD *xd,
                              int mode,
-                             unsigned char *predictor) {
+                             uint8_t *predictor) {
   vp9_build_intra_predictors_internal(*(xd->base_dst) + xd->dst,
                                       xd->dst_stride, predictor, 8,
                                       mode, 4, 1, 1);
 }
 
-#if CONFIG_COMP_INTRA_PRED
-void vp9_comp_intra_uv4x4_predict(BLOCKD *xd,
-                                  int mode, int mode2,
-                                  unsigned char *out_predictor) {
-  unsigned char predictor[2][8 * 4];
-  int i, j;
-
-  vp9_intra_uv4x4_predict(xd, mode, predictor[0]);
-  vp9_intra_uv4x4_predict(xd, mode2, predictor[1]);
-
-  for (i = 0; i < 4 * 8; i += 8) {
-    for (j = i; j < i + 4; j++) {
-      out_predictor[j] = (predictor[0][j] + predictor[1][j] + 1) >> 1;
-    }
-  }
-}
-#endif
-
 /* TODO: try different ways of use Y-UV mode correlation
    Current code assumes that a uv 4x4 block use same mode
    as corresponding Y 8x8 area
    */