Revert "removed the recon. rtcd invoke macro code"

This reverts commit 2113a831

vp8/common/generic/systemdependent.c

@@ -14,6 +14,7 @@
 #include "vp8/common/g_common.h"
 #include "vp8/common/subpixel.h"
 #include "vp8/common/loopfilter.h"
+#include "vp8/common/recon.h"
 #include "vp8/common/idct.h"
 #include "vp8/common/onyxc_int.h"
 
@@ -33,6 +34,57 @@ void vp8_machine_specific_config(VP8_COMMON *ctx) {
   rtcd->idct.idct1_scalar_add_8x8 = vp8_dc_only_idct_add_8x8_c;
   rtcd->idct.ihaar2       = vp8_short_ihaar2x2_c;
   rtcd->idct.idct16x16    = vp8_short_idct16x16_c;
+  rtcd->recon.copy16x16   = vp8_copy_mem16x16_c;
+  rtcd->recon.copy8x8     = vp8_copy_mem8x8_c;
+  rtcd->recon.avg16x16    = vp8_avg_mem16x16_c;
+  rtcd->recon.avg8x8      = vp8_avg_mem8x8_c;
+  rtcd->recon.copy8x4     = vp8_copy_mem8x4_c;
+  rtcd->recon.recon       = vp8_recon_b_c;
+  rtcd->recon.recon_uv    = vp8_recon_uv_b_c;
+  rtcd->recon.recon2      = vp8_recon2b_c;
+  rtcd->recon.recon4      = vp8_recon4b_c;
+  rtcd->recon.recon_mb    = vp8_recon_mb_c;
+  rtcd->recon.recon_mby   = vp8_recon_mby_c;
+#if CONFIG_SUPERBLOCKS
+  rtcd->recon.build_intra_predictors_sby_s =
+    vp8_build_intra_predictors_sby_s;
+  rtcd->recon.build_intra_predictors_sbuv_s =
+    vp8_build_intra_predictors_sbuv_s;
+#endif
+  rtcd->recon.build_intra_predictors_mby =
+    vp8_build_intra_predictors_mby;
+#if CONFIG_COMP_INTRA_PRED
+  rtcd->recon.build_comp_intra_predictors_mby =
+    vp8_build_comp_intra_predictors_mby;
+#endif
+  rtcd->recon.build_intra_predictors_mby_s =
+    vp8_build_intra_predictors_mby_s;
+  rtcd->recon.build_intra_predictors_mbuv =
+    vp8_build_intra_predictors_mbuv;
+  rtcd->recon.build_intra_predictors_mbuv_s =
+    vp8_build_intra_predictors_mbuv_s;
+#if CONFIG_COMP_INTRA_PRED
+  rtcd->recon.build_comp_intra_predictors_mbuv =
+    vp8_build_comp_intra_predictors_mbuv;
+#endif
+  rtcd->recon.intra4x4_predict =
+    vp8_intra4x4_predict;
+#if CONFIG_COMP_INTRA_PRED
+  rtcd->recon.comp_intra4x4_predict =
+    vp8_comp_intra4x4_predict;
+#endif
+  rtcd->recon.intra8x8_predict =
+    vp8_intra8x8_predict;
+#if CONFIG_COMP_INTRA_PRED
+  rtcd->recon.comp_intra8x8_predict =
+    vp8_comp_intra8x8_predict;
+#endif
+  rtcd->recon.intra_uv4x4_predict =
+    vp8_intra_uv4x4_predict;
+#if CONFIG_COMP_INTRA_PRED
+  rtcd->recon.comp_intra_uv4x4_predict =
+    vp8_comp_intra_uv4x4_predict;
+#endif
 
   rtcd->subpix.eighttap16x16       = vp8_eighttap_predict16x16_c;
   rtcd->subpix.eighttap8x8         = vp8_eighttap_predict8x8_c;

vp8/common/onyxc_int.h

@@ -20,6 +20,7 @@
 #include "entropy.h"
 #include "entropymode.h"
 #include "idct.h"
+#include "recon.h"
 #if CONFIG_POSTPROC
 #include "postproc.h"
 #endif
@@ -170,6 +171,7 @@ typedef enum {
 typedef struct VP8_COMMON_RTCD {
 #if CONFIG_RUNTIME_CPU_DETECT
   vp8_idct_rtcd_vtable_t        idct;
+  vp8_recon_rtcd_vtable_t       recon;
   vp8_subpix_rtcd_vtable_t      subpix;
   vp8_loopfilter_rtcd_vtable_t  loopfilter;
 #if CONFIG_POSTPROC

vp8/common/recon.c

@@ -10,7 +10,7 @@
 
 
 #include "vpx_ports/config.h"
-#include "vpx_rtcd.h"
+#include "recon.h"
 #include "blockd.h"
 
 void vp8_recon_b_c
@@ -125,7 +125,7 @@ void vp8_recon2b_c
 }
 
 #if CONFIG_SUPERBLOCKS
-void vp8_recon_mby_s_c(MACROBLOCKD *xd, uint8_t *dst) {
+void vp8_recon_mby_s_c(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *xd, uint8_t *dst) {
   int x, y;
   BLOCKD *b = &xd->block[0];
   int stride = b->dst_stride;
@@ -145,7 +145,7 @@ void vp8_recon_mby_s_c(MACROBLOCKD *xd, uint8_t *dst) {
   }
 }
 
-void vp8_recon_mbuv_s_c(MACROBLOCKD *xd, uint8_t *udst, uint8_t *vdst) {
+void vp8_recon_mbuv_s_c(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *xd, uint8_t *udst, uint8_t *vdst) {
   int x, y, i;
   uint8_t *dst = udst;
 
@@ -170,28 +170,71 @@ void vp8_recon_mbuv_s_c(MACROBLOCKD *xd, uint8_t *udst, uint8_t *vdst) {
 }
 #endif
 
-void vp8_recon_mby_c(MACROBLOCKD *xd) {
+void vp8_recon_mby_c(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *xd) {
+#if ARCH_ARM
+  BLOCKD *b = &xd->block[0];
+  RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
+
+  /*b = &xd->block[4];*/
+  b += 4;
+  RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
+
+  /*b = &xd->block[8];*/
+  b += 4;
+  RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
+
+  /*b = &xd->block[12];*/
+  b += 4;
+  RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
+#else
   int i;
 
   for (i = 0; i < 16; i += 4) {
     BLOCKD *b = &xd->block[i];
 
-    vp8_recon4b(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
+    RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
   }
+#endif
 }
 
-void vp8_recon_mb_c(MACROBLOCKD *xd) {
+void vp8_recon_mb_c(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *xd) {
+#if ARCH_ARM
+  BLOCKD *b = &xd->block[0];
+
+  RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
+  b += 4;
+  RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
+  b += 4;
+  RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
+  b += 4;
+  RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
+  b += 4;
+
+  /*b = &xd->block[16];*/
+
+  RECON_INVOKE(rtcd, recon2)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
+  b++;
+  b++;
+  RECON_INVOKE(rtcd, recon2)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
+  b++;
+  b++;
+  RECON_INVOKE(rtcd, recon2)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
+  b++;
+  b++;
+  RECON_INVOKE(rtcd, recon2)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
+#else
   int i;
 
   for (i = 0; i < 16; i += 4) {
     BLOCKD *b = &xd->block[i];
 
-    vp8_recon4b(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
+    RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
   }
 
   for (i = 16; i < 24; i += 2) {
     BLOCKD *b = &xd->block[i];
 
-    vp8_recon2b(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
+    RECON_INVOKE(rtcd, recon2)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
   }
+#endif
 }

vp8/common/recon.h

+/*
+ *  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.
+ */
+
+
+#ifndef __INC_RECON_H
+#define __INC_RECON_H
+
+#include "blockd.h"
+
+#define prototype_copy_block(sym) \
+  void sym(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch)
+
+#define prototype_recon_block(sym) \
+  void sym(unsigned char *pred, short *diff, unsigned char *dst, int pitch)
+
+#define prototype_recon_macroblock(sym) \
+  void sym(const struct vp8_recon_rtcd_vtable *rtcd, MACROBLOCKD *xd)
+
+#define prototype_build_intra_predictors(sym) \
+  void sym(MACROBLOCKD *xd)
+
+#define prototype_intra4x4_predict(sym) \
+  void sym(BLOCKD *x, int b_mode, unsigned char *predictor)
+
+#if CONFIG_COMP_INTRA_PRED
+#define prototype_comp_intra4x4_predict(sym) \
+  void sym(BLOCKD *x, int b_mode, int mode2, unsigned char *predictor)
+#endif
+
+struct vp8_recon_rtcd_vtable;
+
+#if ARCH_X86 || ARCH_X86_64
+#include "x86/recon_x86.h"
+#endif
+
+#if ARCH_ARM
+#include "arm/recon_arm.h"
+#endif
+
+#ifndef vp8_recon_copy8x8
+#define vp8_recon_copy8x8 vp8_copy_mem8x8_c
+#endif
+extern prototype_copy_block(vp8_recon_copy8x8);
+
+#ifndef vp8_recon_avg16x16
+#define vp8_recon_avg16x16 vp8_avg_mem16x16_c
+#endif
+extern prototype_copy_block(vp8_recon_avg16x16);
+
+#ifndef vp8_recon_avg8x8
+#define vp8_recon_avg8x8 vp8_avg_mem8x8_c
+#endif
+extern prototype_copy_block(vp8_recon_avg8x8);
+
+#ifndef vp8_recon_copy8x4
+#define vp8_recon_copy8x4 vp8_copy_mem8x4_c
+#endif
+extern prototype_copy_block(vp8_recon_copy8x4);
+
+#ifndef vp8_recon_recon
+#define vp8_recon_recon vp8_recon_b_c
+#endif
+extern prototype_recon_block(vp8_recon_recon);
+
+#ifndef vp8_recon_recon_uv
+#define vp8_recon_recon_uv vp8_recon_uv_b_c
+#endif
+extern prototype_recon_block(vp8_recon_recon_uv);
+
+extern prototype_recon_block(vp8_recon_recon);
+#ifndef vp8_recon_recon2
+#define vp8_recon_recon2 vp8_recon2b_c
+#endif
+extern prototype_recon_block(vp8_recon_recon2);
+
+#ifndef vp8_recon_recon4
+#define vp8_recon_recon4 vp8_recon4b_c
+#endif
+extern prototype_recon_block(vp8_recon_recon4);
+
+#ifndef vp8_recon_recon_mb
+#define vp8_recon_recon_mb vp8_recon_mb_c
+#endif
+extern prototype_recon_macroblock(vp8_recon_recon_mb);
+
+#ifndef vp8_recon_recon_mby
+#define vp8_recon_recon_mby vp8_recon_mby_c
+#endif
+extern prototype_recon_macroblock(vp8_recon_recon_mby);
+
+#ifndef vp8_recon_build_intra_predictors_sby_s
+#define vp8_recon_build_intra_predictors_sby_s vp8_build_intra_predictors_sby_s
+#endif
+extern prototype_build_intra_predictors(vp8_recon_build_intra_predictors_sby_s);
+
+#ifndef vp8_recon_build_intra_predictors_mby
+#define vp8_recon_build_intra_predictors_mby vp8_build_intra_predictors_mby
+#endif
+extern prototype_build_intra_predictors\
+(vp8_recon_build_intra_predictors_mby);
+
+#if CONFIG_COMP_INTRA_PRED
+#ifndef vp8_recon_build_comp_intra_predictors_mby
+#define vp8_recon_build_comp_intra_predictors_mby vp8_build_comp_intra_predictors_mby
+#endif
+extern prototype_build_intra_predictors\
+(vp8_recon_build_comp_intra_predictors_mby);
+#endif
+
+#ifndef vp8_recon_build_intra8x8_predictors_mby
+#define vp8_recon_build_intra8x8_predictors_mby vp8_build_intra8x8_predictors_mby
+#endif
+extern prototype_build_intra_predictors\
+(vp8_recon_build_intra8x8_predictors_mby);
+
+#ifndef vp8_recon_build_intra_predictors_mby_s
+#define vp8_recon_build_intra_predictors_mby_s vp8_build_intra_predictors_mby_s
+#endif
+extern prototype_build_intra_predictors\
+(vp8_recon_build_intra_predictors_mby_s);
+
+#ifndef vp8_recon_build_intra_predictors_sbuv_s
+#define vp8_recon_build_intra_predictors_sbuv_s vp8_build_intra_predictors_sbuv_s
+#endif
+extern prototype_build_intra_predictors(vp8_recon_build_intra_predictors_sbuv_s);
+
+#ifndef vp8_recon_build_intra_predictors_mbuv
+#define vp8_recon_build_intra_predictors_mbuv vp8_build_intra_predictors_mbuv
+#endif
+extern prototype_build_intra_predictors\
+(vp8_recon_build_intra_predictors_mbuv);
+
+#ifndef vp8_recon_build_intra8x8_predictors_mbuv
+#define vp8_recon_build_intra8x8_predictors_mbuv vp8_build_intra8x8_predictors_mbuv
+#endif
+extern prototype_build_intra_predictors\
+(vp8_recon_build_intra8x8_predictors_mbuv);
+
+#ifndef vp8_recon_build_intra_predictors_mbuv_s
+#define vp8_recon_build_intra_predictors_mbuv_s vp8_build_intra_predictors_mbuv_s
+#endif
+extern prototype_build_intra_predictors\
+(vp8_recon_build_intra_predictors_mbuv_s);
+
+#if CONFIG_COMP_INTRA_PRED
+#ifndef vp8_recon_build_comp_intra_predictors_mbuv
+#define vp8_recon_build_comp_intra_predictors_mbuv vp8_build_comp_intra_predictors_mbuv
+#endif
+extern prototype_build_intra_predictors\
+(vp8_recon_build_comp_intra_predictors_mbuv);
+#endif
+
+#ifndef vp8_recon_intra4x4_predict
+#define vp8_recon_intra4x4_predict vp8_intra4x4_predict
+#endif
+extern prototype_intra4x4_predict\
+(vp8_recon_intra4x4_predict);
+
+#if CONFIG_COMP_INTRA_PRED
+#ifndef vp8_recon_comp_intra4x4_predict
+#define vp8_recon_comp_intra4x4_predict vp8_comp_intra4x4_predict
+#endif
+extern prototype_comp_intra4x4_predict\
+(vp8_recon_comp_intra4x4_predict);
+#endif
+
+#ifndef vp8_recon_intra8x8_predict
+#define vp8_recon_intra8x8_predict vp8_intra8x8_predict
+#endif
+extern prototype_intra4x4_predict\
+(vp8_recon_intra8x8_predict);
+
+#if CONFIG_COMP_INTRA_PRED
+#ifndef vp8_recon_comp_intra8x8_predict
+#define vp8_recon_comp_intra8x8_predict vp8_comp_intra8x8_predict
+#endif
+extern prototype_comp_intra4x4_predict\
+(vp8_recon_comp_intra8x8_predict);
+#endif
+
+#ifndef vp8_recon_intra_uv4x4_predict
+#define vp8_recon_intra_uv4x4_predict vp8_intra_uv4x4_predict
+#endif
+extern prototype_intra4x4_predict\
+(vp8_recon_intra_uv4x4_predict);
+
+#if CONFIG_COMP_INTRA_PRED
+#ifndef vp8_recon_comp_intra_uv4x4_predict
+#define vp8_recon_comp_intra_uv4x4_predict vp8_comp_intra_uv4x4_predict
+#endif
+extern prototype_comp_intra4x4_predict\
+(vp8_recon_comp_intra_uv4x4_predict);
+#endif
+
+typedef prototype_copy_block((*vp8_copy_block_fn_t));
+typedef prototype_recon_block((*vp8_recon_fn_t));
+typedef prototype_recon_macroblock((*vp8_recon_mb_fn_t));
+typedef prototype_build_intra_predictors((*vp8_build_intra_pred_fn_t));
+typedef prototype_intra4x4_predict((*vp8_intra4x4_pred_fn_t));
+#if CONFIG_COMP_INTRA_PRED
+typedef prototype_comp_intra4x4_predict((*vp8_comp_intra4x4_pred_fn_t));
+#endif
+typedef struct vp8_recon_rtcd_vtable {
+  vp8_copy_block_fn_t  copy16x16;
+  vp8_copy_block_fn_t  copy8x8;
+  vp8_copy_block_fn_t  avg16x16;
+  vp8_copy_block_fn_t  avg8x8;
+  vp8_copy_block_fn_t  copy8x4;
+  vp8_recon_fn_t       recon;
+  vp8_recon_fn_t       recon_uv;
+  vp8_recon_fn_t       recon2;
+  vp8_recon_fn_t       recon4;
+  vp8_recon_mb_fn_t    recon_mb;
+  vp8_recon_mb_fn_t    recon_mby;
+#if CONFIG_SUPERBLOCKS
+  vp8_build_intra_pred_fn_t  build_intra_predictors_sby_s;
+#endif
+  vp8_build_intra_pred_fn_t  build_intra_predictors_mby_s;
+  vp8_build_intra_pred_fn_t  build_intra_predictors_mby;
+#if CONFIG_COMP_INTRA_PRED
+  vp8_build_intra_pred_fn_t  build_comp_intra_predictors_mby;
+#endif
+#if CONFIG_SUPERBLOCKS
+  vp8_build_intra_pred_fn_t  build_intra_predictors_sbuv_s;
+#endif
+  vp8_build_intra_pred_fn_t  build_intra_predictors_mbuv_s;
+  vp8_build_intra_pred_fn_t  build_intra_predictors_mbuv;
+#if CONFIG_COMP_INTRA_PRED
+  vp8_build_intra_pred_fn_t  build_comp_intra_predictors_mbuv;
+#endif
+  vp8_intra4x4_pred_fn_t intra4x4_predict;
+#if CONFIG_COMP_INTRA_PRED
+  vp8_comp_intra4x4_pred_fn_t comp_intra4x4_predict;
+#endif
+  vp8_intra4x4_pred_fn_t intra8x8_predict;
+#if CONFIG_COMP_INTRA_PRED
+  vp8_comp_intra4x4_pred_fn_t comp_intra8x8_predict;
+#endif
+  vp8_intra4x4_pred_fn_t intra_uv4x4_predict;
+#if CONFIG_COMP_INTRA_PRED
+  vp8_comp_intra4x4_pred_fn_t comp_intra_uv4x4_predict;
+#endif
+} vp8_recon_rtcd_vtable_t;
+
+#if CONFIG_RUNTIME_CPU_DETECT
+#define RECON_INVOKE(ctx,fn) (ctx)->fn
+#else
+#define RECON_INVOKE(ctx,fn) vp8_recon_##fn
+#endif
+
+void vp8_recon_intra_mbuv(const vp8_recon_rtcd_vtable_t *rtcd,
+                          MACROBLOCKD *xd);
+
+#if CONFIG_SUPERBLOCKS
+extern void vp8_recon_mby_s_c(const vp8_recon_rtcd_vtable_t *rtcd,
+                              MACROBLOCKD *xd, uint8_t *dst);
+extern void vp8_recon_mbuv_s_c(const vp8_recon_rtcd_vtable_t *rtcd,
+                               MACROBLOCKD *xd, uint8_t *udst, uint8_t *vdst);
+#endif
+
+#endif

vp8/common/reconinter.c

@@ -11,6 +11,7 @@
 
 #include "vpx_ports/config.h"
 #include "vpx/vpx_integer.h"
+#include "recon.h"
 #include "subpixel.h"
 #include "blockd.h"
 #include "reconinter.h"
@@ -309,7 +310,8 @@ static void build_inter_predictors4b(MACROBLOCKD *xd, BLOCKD *d, int pitch) {
     xd->subpixel_predict8x8(ptr, d->pre_stride, (mv.as_mv.col & 7) << 1,
                             (mv.as_mv.row & 7) << 1, pred_ptr, pitch);
   } else {
-    vp8_copy_mem8x8(ptr, d->pre_stride, pred_ptr, pitch);
+    RECON_INVOKE(&xd->rtcd->recon, copy8x8)
+      (ptr, d->pre_stride, pred_ptr, pitch);
   }
 }
 
@@ -335,7 +337,8 @@ static void build_2nd_inter_predictors4b(MACROBLOCKD *xd,
     xd->subpixel_predict_avg8x8(ptr, d->pre_stride, (mv.as_mv.col & 7) << 1,
                                (mv.as_mv.row & 7) << 1, pred_ptr, pitch);
   } else {
-    vp8_avg_mem8x8(ptr, d->pre_stride, pred_ptr, pitch);
+    RECON_INVOKE(&xd->rtcd->recon, avg8x8)
+                (ptr, d->pre_stride, pred_ptr, pitch);
   }
 }
 
@@ -354,7 +357,7 @@ static void build_inter_predictors2b(MACROBLOCKD *xd, BLOCKD *d, int pitch) {
     xd->subpixel_predict8x4(ptr, d->pre_stride, (mv.as_mv.col & 7) << 1,
                            (mv.as_mv.row & 7) << 1, pred_ptr, pitch);
   } else {
-    vp8_copy_mem8x4(ptr, d->pre_stride, pred_ptr, pitch);
+    RECON_INVOKE(&xd->rtcd->recon, copy8x4)(ptr, d->pre_stride, pred_ptr, pitch);
   }
 }
 
@@ -738,8 +741,10 @@ void vp8_build_1st_inter16x16_predictors_mbuv(MACROBLOCKD *xd,
       xd->subpixel_predict8x8(vptr, pre_stride, _o16x16mv.as_mv.col & 15,
                               _o16x16mv.as_mv.row & 15, dst_v, dst_uvstride);
     } else {
-      vp8_copy_mem8x8(uptr, pre_stride, dst_u, dst_uvstride);
-      vp8_copy_mem8x8(vptr, pre_stride, dst_v, dst_uvstride);
+      RECON_INVOKE(&xd->rtcd->recon, copy8x8)
+                   (uptr, pre_stride, dst_u, dst_uvstride);
+      RECON_INVOKE(&xd->rtcd->recon, copy8x8)
+                   (vptr, pre_stride, dst_v, dst_uvstride);
     }
 }
 
@@ -858,7 +863,8 @@ void vp8_build_2nd_inter16x16_predictors_mby(MACROBLOCKD *xd,
     } else {
       // TODO Needs to AVERAGE with the dst_y
       // For now, do not apply the prediction filter in these cases!
-      vp8_avg_mem16x16(ptr, pre_stride, dst_y, dst_ystride);
+      RECON_INVOKE(&xd->rtcd->recon, avg16x16)(ptr, pre_stride, dst_y,
+                                               dst_ystride);
     }
   } else
 #endif  // CONFIG_PRED_FILTER
@@ -867,7 +873,8 @@ void vp8_build_2nd_inter16x16_predictors_mby(MACROBLOCKD *xd,
       xd->subpixel_predict_avg16x16(ptr, pre_stride, (mv_col & 7) << 1,
                                     (mv_row & 7) << 1, dst_y, dst_ystride);
     } else {
-      vp8_avg_mem16x16(ptr, pre_stride, dst_y, dst_ystride);
+      RECON_INVOKE(&xd->rtcd->recon, avg16x16)(ptr, pre_stride, dst_y,
+                                               dst_ystride);
     }
   }
 }
@@ -930,7 +937,8 @@ void vp8_build_2nd_inter16x16_predictors_mbuv(MACROBLOCKD *xd,
       } else {
         // TODO Needs to AVERAGE with the dst_[u|v]
         // For now, do not apply the prediction filter here!
-        vp8_avg_mem8x8(pSrc, pre_stride, pDst, dst_uvstride);
+        RECON_INVOKE(&xd->rtcd->recon, avg8x8)(pSrc, pre_stride, pDst,
+                                               dst_uvstride);
       }
 
       // V
@@ -945,8 +953,8 @@ void vp8_build_2nd_inter16x16_predictors_mbuv(MACROBLOCKD *xd,
       xd->subpixel_predict_avg8x8(vptr, pre_stride, omv_col & 15,
                                   omv_row & 15, dst_v, dst_uvstride);
     } else {
-      vp8_avg_mem8x8(uptr, pre_stride, dst_u, dst_uvstride);
-      vp8_avg_mem8x8(vptr, pre_stride, dst_v, dst_uvstride);
+      RECON_INVOKE(&xd->rtcd->recon, avg8x8)(uptr, pre_stride, dst_u, dst_uvstride);
+      RECON_INVOKE(&xd->rtcd->recon, avg8x8)(vptr, pre_stride, dst_v, dst_uvstride);
     }
 }
 

vp8/common/reconinter.h

@@ -12,7 +12,9 @@
 #ifndef __INC_RECONINTER_H
 #define __INC_RECONINTER_H
 
+#if CONFIG_RUNTIME_CPU_DETECT
 #include "onyxc_int.h"
+#endif
 
 extern void vp8_build_1st_inter16x16_predictors_mby(MACROBLOCKD *xd,
                                                     unsigned char *dst_y,

vp8/common/reconintra.c

@@ -10,7 +10,7 @@
 
 #include <stdio.h>
 #include "vpx_ports/config.h"
-#include "vpx_rtcd.h"
+#include "recon.h"
 #include "reconintra.h"
 #include "vpx_mem/vpx_mem.h"
 
@@ -196,12 +196,14 @@ void d153_predictor(unsigned char *ypred_ptr, int y_stride, int n,
   }
 }
 
-void vp8_recon_intra_mbuv(MACROBLOCKD *xd) {
+void vp8_recon_intra_mbuv(const vp8_recon_rtcd_vtable_t *rtcd,
+                          MACROBLOCKD *xd) {
   int i;
 
   for (i = 16; i < 24; i += 2) {
     BLOCKD *b = &xd->block[i];
-    vp8_recon2b(b->predictor, b->diff,*(b->base_dst) + b->dst, b->dst_stride);
+    RECON_INVOKE(rtcd, recon2)(b->predictor, b->diff,
+                 *(b->base_dst) + b->dst, b->dst_stride);
   }
 }
 

vp8/common/reconintra4x4.c

@@ -10,12 +10,13 @@
 
 
 #include "vpx_ports/config.h"
+#include "recon.h"
 #include "vpx_mem/vpx_mem.h"
 #include "reconintra.h"
-#include "vpx_rtcd.h"
 
-void vp8_intra4x4_predict_c(BLOCKD *x, int b_mode,
-                            unsigned char *predictor) {
+void vp8_intra4x4_predict(BLOCKD *x,
+                          int b_mode,
+                          unsigned char *predictor) {
   int i, r, c;
 
   unsigned char *Above = *(x->base_dst) + x->dst - x->dst_stride;
@@ -275,7 +276,7 @@ void vp8_intra4x4_predict_c(BLOCKD *x, int b_mode,
 }
 
 #if CONFIG_COMP_INTRA_PRED
-void vp8_comp_intra4x4_predict_c(BLOCKD *x,
+void vp8_comp_intra4x4_predict(BLOCKD *x,
                                int b_mode, int b_mode2,
                                unsigned char *out_predictor) {
   unsigned char predictor[2][4 * 16];

vp8/common/rtcd_defs.sh

 common_forward_decls() {
 cat <<EOF
-#include "vp8/common/blockd.h"
-
-struct loop_filter_info;
-
-/* Encoder forward decls */
-struct variance_vtable;
-union int_mv;
-struct yv12_buffer_config;
+struct blockd;
 EOF
 }