diff options
35 files changed, 612 insertions, 1123 deletions
diff --git a/vp8/common/arm/arm_systemdependent.c b/vp8/common/arm/arm_systemdependent.c index 5fd5f5b1b..65a518188 100644 --- a/vp8/common/arm/arm_systemdependent.c +++ b/vp8/common/arm/arm_systemdependent.c @@ -49,17 +49,6 @@ void vp8_arch_arm_common_init(VP8_COMMON *ctx) { // rtcd->idct.iwalsh1 = vp8_short_inv_walsh4x4_1_v6; // rtcd->idct.iwalsh16 = vp8_short_inv_walsh4x4_v6; - rtcd->loopfilter.normal_mb_v = vp8_loop_filter_mbv_armv6; - rtcd->loopfilter.normal_b_v = vp8_loop_filter_bv_armv6; - rtcd->loopfilter.normal_mb_h = vp8_loop_filter_mbh_armv6; - rtcd->loopfilter.normal_b_h = vp8_loop_filter_bh_armv6; - rtcd->loopfilter.simple_mb_v = - vp8_loop_filter_simple_vertical_edge_armv6; - rtcd->loopfilter.simple_b_v = vp8_loop_filter_bvs_armv6; - rtcd->loopfilter.simple_mb_h = - vp8_loop_filter_simple_horizontal_edge_armv6; - rtcd->loopfilter.simple_b_h = vp8_loop_filter_bhs_armv6; - rtcd->recon.copy16x16 = vp8_copy_mem16x16_v6; rtcd->recon.copy8x8 = vp8_copy_mem8x8_v6; rtcd->recon.copy8x4 = vp8_copy_mem8x4_v6; @@ -86,15 +75,6 @@ void vp8_arch_arm_common_init(VP8_COMMON *ctx) { // rtcd->idct.iwalsh1 = vp8_short_inv_walsh4x4_1_neon; // rtcd->idct.iwalsh16 = vp8_short_inv_walsh4x4_neon; - rtcd->loopfilter.normal_mb_v = vp8_loop_filter_mbv_neon; - rtcd->loopfilter.normal_b_v = vp8_loop_filter_bv_neon; - rtcd->loopfilter.normal_mb_h = vp8_loop_filter_mbh_neon; - rtcd->loopfilter.normal_b_h = vp8_loop_filter_bh_neon; - rtcd->loopfilter.simple_mb_v = vp8_loop_filter_mbvs_neon; - rtcd->loopfilter.simple_b_v = vp8_loop_filter_bvs_neon; - rtcd->loopfilter.simple_mb_h = vp8_loop_filter_mbhs_neon; - rtcd->loopfilter.simple_b_h = vp8_loop_filter_bhs_neon; - rtcd->recon.copy16x16 = vp8_copy_mem16x16_neon; rtcd->recon.copy8x8 = vp8_copy_mem8x8_neon; rtcd->recon.copy8x4 = vp8_copy_mem8x4_neon; diff --git a/vp8/common/arm/loopfilter_arm.h b/vp8/common/arm/loopfilter_arm.h index 390a547b0..5df2a181b 100644 --- a/vp8/common/arm/loopfilter_arm.h +++ b/vp8/common/arm/loopfilter_arm.h @@ -24,32 +24,6 @@ extern prototype_simple_loopfilter(vp8_loop_filter_bhs_armv6); extern prototype_simple_loopfilter(vp8_loop_filter_simple_horizontal_edge_armv6); extern prototype_simple_loopfilter(vp8_loop_filter_simple_vertical_edge_armv6); -#if !CONFIG_RUNTIME_CPU_DETECT -#undef vp8_lf_normal_mb_v -#define vp8_lf_normal_mb_v vp8_loop_filter_mbv_armv6 - -#undef vp8_lf_normal_b_v -#define vp8_lf_normal_b_v vp8_loop_filter_bv_armv6 - -#undef vp8_lf_normal_mb_h -#define vp8_lf_normal_mb_h vp8_loop_filter_mbh_armv6 - -#undef vp8_lf_normal_b_h -#define vp8_lf_normal_b_h vp8_loop_filter_bh_armv6 - -#undef vp8_lf_simple_mb_v -#define vp8_lf_simple_mb_v vp8_loop_filter_simple_vertical_edge_armv6 - -#undef vp8_lf_simple_b_v -#define vp8_lf_simple_b_v vp8_loop_filter_bvs_armv6 - -#undef vp8_lf_simple_mb_h -#define vp8_lf_simple_mb_h vp8_loop_filter_simple_horizontal_edge_armv6 - -#undef vp8_lf_simple_b_h -#define vp8_lf_simple_b_h vp8_loop_filter_bhs_armv6 -#endif /* !CONFIG_RUNTIME_CPU_DETECT */ - #endif /* HAVE_ARMV6 */ #if HAVE_ARMV7 @@ -62,32 +36,6 @@ extern prototype_simple_loopfilter(vp8_loop_filter_bvs_neon); extern prototype_simple_loopfilter(vp8_loop_filter_mbhs_neon); extern prototype_simple_loopfilter(vp8_loop_filter_bhs_neon); -#if !CONFIG_RUNTIME_CPU_DETECT -#undef vp8_lf_normal_mb_v -#define vp8_lf_normal_mb_v vp8_loop_filter_mbv_neon - -#undef vp8_lf_normal_b_v -#define vp8_lf_normal_b_v vp8_loop_filter_bv_neon - -#undef vp8_lf_normal_mb_h -#define vp8_lf_normal_mb_h vp8_loop_filter_mbh_neon - -#undef vp8_lf_normal_b_h -#define vp8_lf_normal_b_h vp8_loop_filter_bh_neon - -#undef vp8_lf_simple_mb_v -#define vp8_lf_simple_mb_v vp8_loop_filter_mbvs_neon - -#undef vp8_lf_simple_b_v -#define vp8_lf_simple_b_v vp8_loop_filter_bvs_neon - -#undef vp8_lf_simple_mb_h -#define vp8_lf_simple_mb_h vp8_loop_filter_mbhs_neon - -#undef vp8_lf_simple_b_h -#define vp8_lf_simple_b_h vp8_loop_filter_bhs_neon -#endif /* !CONFIG_RUNTIME_CPU_DETECT */ - #endif /* HAVE_ARMV7 */ #endif /* LOOPFILTER_ARM_H */ diff --git a/vp8/common/generic/systemdependent.c b/vp8/common/generic/systemdependent.c index 0e5e7da33..0acae30f5 100644 --- a/vp8/common/generic/systemdependent.c +++ b/vp8/common/generic/systemdependent.c @@ -14,7 +14,6 @@ #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" @@ -34,57 +33,6 @@ 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; @@ -116,15 +64,6 @@ void vp8_machine_specific_config(VP8_COMMON *ctx) { rtcd->subpix.bilinear4x4 = vp8_bilinear_predict4x4_c; rtcd->subpix.bilinear_avg4x4 = vp8_bilinear_predict_avg4x4_c; - rtcd->loopfilter.normal_mb_v = vp8_loop_filter_mbv_c; - rtcd->loopfilter.normal_b_v = vp8_loop_filter_bv_c; - rtcd->loopfilter.normal_mb_h = vp8_loop_filter_mbh_c; - rtcd->loopfilter.normal_b_h = vp8_loop_filter_bh_c; - rtcd->loopfilter.simple_mb_v = vp8_loop_filter_simple_vertical_edge_c; - rtcd->loopfilter.simple_b_v = vp8_loop_filter_bvs_c; - rtcd->loopfilter.simple_mb_h = vp8_loop_filter_simple_horizontal_edge_c; - rtcd->loopfilter.simple_b_h = vp8_loop_filter_bhs_c; - #if CONFIG_POSTPROC || (CONFIG_VP8_ENCODER && CONFIG_INTERNAL_STATS) rtcd->postproc.down = vp8_mbpost_proc_down_c; rtcd->postproc.across = vp8_mbpost_proc_across_ip_c; diff --git a/vp8/common/loopfilter.c b/vp8/common/loopfilter.c index 5937f6c06..b34ee0272 100644 --- a/vp8/common/loopfilter.c +++ b/vp8/common/loopfilter.c @@ -16,102 +16,6 @@ #include "vp8/common/seg_common.h" -typedef unsigned char uc; - -prototype_loopfilter(vp8_loop_filter_horizontal_edge_c); -prototype_loopfilter(vp8_loop_filter_vertical_edge_c); - - -prototype_loopfilter(vp8_mbloop_filter_horizontal_edge_c); -prototype_loopfilter(vp8_mbloop_filter_vertical_edge_c); - -prototype_simple_loopfilter(vp8_loop_filter_simple_horizontal_edge_c); -prototype_simple_loopfilter(vp8_loop_filter_simple_vertical_edge_c); - -/* Horizontal MB filtering */ -void vp8_loop_filter_mbh_c(unsigned char *y_ptr, unsigned char *u_ptr, - unsigned char *v_ptr, int y_stride, int uv_stride, - loop_filter_info *lfi) { - vp8_mbloop_filter_horizontal_edge_c(y_ptr, y_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 2); - - if (u_ptr) - vp8_mbloop_filter_horizontal_edge_c(u_ptr, uv_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 1); - - if (v_ptr) - vp8_mbloop_filter_horizontal_edge_c(v_ptr, uv_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 1); -} - -/* Vertical MB Filtering */ -void vp8_loop_filter_mbv_c(unsigned char *y_ptr, unsigned char *u_ptr, - unsigned char *v_ptr, int y_stride, int uv_stride, - loop_filter_info *lfi) { - vp8_mbloop_filter_vertical_edge_c(y_ptr, y_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 2); - - if (u_ptr) - vp8_mbloop_filter_vertical_edge_c(u_ptr, uv_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 1); - - if (v_ptr) - vp8_mbloop_filter_vertical_edge_c(v_ptr, uv_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 1); -} - -/* Horizontal B Filtering */ -void vp8_loop_filter_bh_c(unsigned char *y_ptr, unsigned char *u_ptr, - unsigned char *v_ptr, int y_stride, int uv_stride, - loop_filter_info *lfi) { - vp8_loop_filter_horizontal_edge_c(y_ptr + 4 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); - vp8_loop_filter_horizontal_edge_c(y_ptr + 8 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); - vp8_loop_filter_horizontal_edge_c(y_ptr + 12 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); - - if (u_ptr) - vp8_loop_filter_horizontal_edge_c(u_ptr + 4 * uv_stride, uv_stride, lfi->blim, lfi->lim, lfi->hev_thr, 1); - - if (v_ptr) - vp8_loop_filter_horizontal_edge_c(v_ptr + 4 * uv_stride, uv_stride, lfi->blim, lfi->lim, lfi->hev_thr, 1); -} - -void vp8_loop_filter_bh8x8_c(unsigned char *y_ptr, unsigned char *u_ptr, - unsigned char *v_ptr, int y_stride, int uv_stride, - loop_filter_info *lfi) { - vp8_mbloop_filter_horizontal_edge_c( - y_ptr + 8 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); -} - -void vp8_loop_filter_bhs_c(unsigned char *y_ptr, int y_stride, - const unsigned char *blimit) { - vp8_loop_filter_simple_horizontal_edge_c(y_ptr + 4 * y_stride, y_stride, blimit); - vp8_loop_filter_simple_horizontal_edge_c(y_ptr + 8 * y_stride, y_stride, blimit); - vp8_loop_filter_simple_horizontal_edge_c(y_ptr + 12 * y_stride, y_stride, blimit); -} - -/* Vertical B Filtering */ -void vp8_loop_filter_bv_c(unsigned char *y_ptr, unsigned char *u_ptr, - unsigned char *v_ptr, int y_stride, int uv_stride, - loop_filter_info *lfi) { - vp8_loop_filter_vertical_edge_c(y_ptr + 4, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); - vp8_loop_filter_vertical_edge_c(y_ptr + 8, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); - vp8_loop_filter_vertical_edge_c(y_ptr + 12, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); - - if (u_ptr) - vp8_loop_filter_vertical_edge_c(u_ptr + 4, uv_stride, lfi->blim, lfi->lim, lfi->hev_thr, 1); - - if (v_ptr) - vp8_loop_filter_vertical_edge_c(v_ptr + 4, uv_stride, lfi->blim, lfi->lim, lfi->hev_thr, 1); -} - -void vp8_loop_filter_bv8x8_c(unsigned char *y_ptr, unsigned char *u_ptr, - unsigned char *v_ptr, int y_stride, int uv_stride, - loop_filter_info *lfi) { - vp8_mbloop_filter_vertical_edge_c( - y_ptr + 8, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); -} - -void vp8_loop_filter_bvs_c(unsigned char *y_ptr, int y_stride, - const unsigned char *blimit) { - vp8_loop_filter_simple_vertical_edge_c(y_ptr + 4, y_stride, blimit); - vp8_loop_filter_simple_vertical_edge_c(y_ptr + 8, y_stride, blimit); - vp8_loop_filter_simple_vertical_edge_c(y_ptr + 12, y_stride, blimit); -} - static void lf_init_lut(loop_filter_info_n *lfi) { int filt_lvl; @@ -281,7 +185,7 @@ void vp8_loop_filter_frame ) { YV12_BUFFER_CONFIG *post = cm->frame_to_show; loop_filter_info_n *lfi_n = &cm->lf_info; - loop_filter_info lfi; + struct loop_filter_info lfi; FRAME_TYPE frame_type = cm->frame_type; @@ -332,16 +236,16 @@ void vp8_loop_filter_frame mode_info_context[-1].mbmi.mb_skip_coeff) #endif ) - vp8_loop_filter_mbv_c - (y_ptr, u_ptr, v_ptr, post->y_stride, post->uv_stride, &lfi); + vp8_loop_filter_mbv(y_ptr, u_ptr, v_ptr, post->y_stride, + post->uv_stride, &lfi); if (!skip_lf && tx_type != TX_16X16) { if (tx_type == TX_8X8) - vp8_loop_filter_bv8x8_c - (y_ptr, u_ptr, v_ptr, post->y_stride, post->uv_stride, &lfi); + vp8_loop_filter_bv8x8(y_ptr, u_ptr, v_ptr, post->y_stride, + post->uv_stride, &lfi); else - LF_INVOKE(&cm->rtcd.loopfilter, normal_b_v) - (y_ptr, u_ptr, v_ptr, post->y_stride, post->uv_stride, &lfi); + vp8_loop_filter_bv(y_ptr, u_ptr, v_ptr, post->y_stride, + post->uv_stride, &lfi); } @@ -353,16 +257,16 @@ void vp8_loop_filter_frame mode_info_context[-cm->mode_info_stride].mbmi.mb_skip_coeff) #endif ) - vp8_loop_filter_mbh_c - (y_ptr, u_ptr, v_ptr, post->y_stride, post->uv_stride, &lfi); + vp8_loop_filter_mbh(y_ptr, u_ptr, v_ptr, post->y_stride, + post->uv_stride, &lfi); if (!skip_lf && tx_type != TX_16X16) { if (tx_type == TX_8X8) - vp8_loop_filter_bh8x8_c - (y_ptr, u_ptr, v_ptr, post->y_stride, post->uv_stride, &lfi); + vp8_loop_filter_bh8x8(y_ptr, u_ptr, v_ptr, post->y_stride, + post->uv_stride, &lfi); else - LF_INVOKE(&cm->rtcd.loopfilter, normal_b_h) - (y_ptr, u_ptr, v_ptr, post->y_stride, post->uv_stride, &lfi); + vp8_loop_filter_bh(y_ptr, u_ptr, v_ptr, post->y_stride, + post->uv_stride, &lfi); } } else { // FIXME: Not 8x8 aware @@ -373,12 +277,12 @@ void vp8_loop_filter_frame mode_info_context[-1].mbmi.mb_skip_coeff) #endif ) - LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_v) - (y_ptr, post->y_stride, lfi_n->mblim[filter_level]); + vp8_loop_filter_simple_mbv(y_ptr, post->y_stride, + lfi_n->mblim[filter_level]); if (!skip_lf) - LF_INVOKE(&cm->rtcd.loopfilter, simple_b_v) - (y_ptr, post->y_stride, lfi_n->blim[filter_level]); + vp8_loop_filter_simple_bv(y_ptr, post->y_stride, + lfi_n->blim[filter_level]); /* don't apply across umv border */ if (mb_row > 0 @@ -388,12 +292,12 @@ void vp8_loop_filter_frame mode_info_context[-cm->mode_info_stride].mbmi.mb_skip_coeff) #endif ) - LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_h) - (y_ptr, post->y_stride, lfi_n->mblim[filter_level]); + vp8_loop_filter_simple_mbh(y_ptr, post->y_stride, + lfi_n->mblim[filter_level]); if (!skip_lf) - LF_INVOKE(&cm->rtcd.loopfilter, simple_b_h) - (y_ptr, post->y_stride, lfi_n->blim[filter_level]); + vp8_loop_filter_simple_bh(y_ptr, post->y_stride, + lfi_n->blim[filter_level]); } } @@ -425,7 +329,7 @@ void vp8_loop_filter_frame_yonly int mb_col; loop_filter_info_n *lfi_n = &cm->lf_info; - loop_filter_info lfi; + struct loop_filter_info lfi; int filter_level; FRAME_TYPE frame_type = cm->frame_type; @@ -467,49 +371,43 @@ void vp8_loop_filter_frame_yonly lfi.hev_thr = lfi_n->hev_thr[hev_index]; if (mb_col > 0) - vp8_loop_filter_mbv_c - (y_ptr, 0, 0, post->y_stride, 0, &lfi); + vp8_loop_filter_mbv(y_ptr, 0, 0, post->y_stride, 0, &lfi); if (!skip_lf && tx_type != TX_16X16) { if (tx_type == TX_8X8) - vp8_loop_filter_bv8x8_c - (y_ptr, 0, 0, post->y_stride, 0, &lfi); + vp8_loop_filter_bv8x8(y_ptr, 0, 0, post->y_stride, 0, &lfi); else - LF_INVOKE(&cm->rtcd.loopfilter, normal_b_v) - (y_ptr, 0, 0, post->y_stride, 0, &lfi); + vp8_loop_filter_bv(y_ptr, 0, 0, post->y_stride, 0, &lfi); } /* don't apply across umv border */ if (mb_row > 0) - vp8_loop_filter_mbh_c - (y_ptr, 0, 0, post->y_stride, 0, &lfi); + vp8_loop_filter_mbh(y_ptr, 0, 0, post->y_stride, 0, &lfi); if (!skip_lf && tx_type != TX_16X16) { if (tx_type == TX_8X8) - vp8_loop_filter_bh8x8_c - (y_ptr, 0, 0, post->y_stride, 0, &lfi); + vp8_loop_filter_bh8x8(y_ptr, 0, 0, post->y_stride, 0, &lfi); else - LF_INVOKE(&cm->rtcd.loopfilter, normal_b_h) - (y_ptr, 0, 0, post->y_stride, 0, &lfi); + vp8_loop_filter_bh(y_ptr, 0, 0, post->y_stride, 0, &lfi); } } else { // FIXME: Not 8x8 aware if (mb_col > 0) - LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_v) - (y_ptr, post->y_stride, lfi_n->mblim[filter_level]); + vp8_loop_filter_simple_mbv(y_ptr, post->y_stride, + lfi_n->mblim[filter_level]); if (!skip_lf) - LF_INVOKE(&cm->rtcd.loopfilter, simple_b_v) - (y_ptr, post->y_stride, lfi_n->blim[filter_level]); + vp8_loop_filter_simple_bv(y_ptr, post->y_stride, + lfi_n->blim[filter_level]); /* don't apply across umv border */ if (mb_row > 0) - LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_h) - (y_ptr, post->y_stride, lfi_n->mblim[filter_level]); + vp8_loop_filter_simple_mbh(y_ptr, post->y_stride, + lfi_n->mblim[filter_level]); if (!skip_lf) - LF_INVOKE(&cm->rtcd.loopfilter, simple_b_h) - (y_ptr, post->y_stride, lfi_n->blim[filter_level]); + vp8_loop_filter_simple_bh(y_ptr, post->y_stride, + lfi_n->blim[filter_level]); } } @@ -536,7 +434,7 @@ void vp8_loop_filter_frame_segment(VP8_COMMON *cm, MACROBLOCKD *xd, int mb_col; loop_filter_info_n *lfi_n = &cm->lf_info; - loop_filter_info lfi; + struct loop_filter_info lfi; int filter_level; FRAME_TYPE frame_type = cm->frame_type; @@ -589,41 +487,35 @@ void vp8_loop_filter_frame_segment(VP8_COMMON *cm, MACROBLOCKD *xd, lfi.hev_thr = lfi_n->hev_thr[hev_index]; if (mb_col > 0) - vp8_loop_filter_mbv_c(y_ptr, 0, 0, post->y_stride, 0, + vp8_loop_filter_mbv(y_ptr, 0, 0, post->y_stride, 0, &lfi); if (!skip_lf) - LF_INVOKE(&cm->rtcd.loopfilter, normal_b_v)( - y_ptr, 0, 0, post->y_stride, 0, &lfi); + vp8_loop_filter_bv(y_ptr, 0, 0, post->y_stride, 0, &lfi); /* don't apply across umv border */ if (mb_row > 0) - vp8_loop_filter_mbh_c(y_ptr, 0, 0, post->y_stride, 0, + vp8_loop_filter_mbh(y_ptr, 0, 0, post->y_stride, 0, &lfi); if (!skip_lf) - LF_INVOKE(&cm->rtcd.loopfilter, normal_b_h)( - y_ptr, 0, 0, post->y_stride, 0, &lfi); + vp8_loop_filter_bh(y_ptr, 0, 0, post->y_stride, 0, &lfi); } else { if (mb_col > 0) - LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_v)( - y_ptr, post->y_stride, + vp8_loop_filter_simple_mbv(y_ptr, post->y_stride, lfi_n->mblim[filter_level]); if (!skip_lf) - LF_INVOKE(&cm->rtcd.loopfilter, simple_b_v)( - y_ptr, post->y_stride, + vp8_loop_filter_simple_bv(y_ptr, post->y_stride, lfi_n->blim[filter_level]); /* don't apply across umv border */ if (mb_row > 0) - LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_h)( - y_ptr, post->y_stride, + vp8_loop_filter_simple_mbh(y_ptr, post->y_stride, lfi_n->mblim[filter_level]); if (!skip_lf) - LF_INVOKE(&cm->rtcd.loopfilter, simple_b_h)( - y_ptr, post->y_stride, + vp8_loop_filter_simple_bh(y_ptr, post->y_stride, lfi_n->blim[filter_level]); } } @@ -656,7 +548,7 @@ void vp8_loop_filter_partial_frame int linestocopy, i; loop_filter_info_n *lfi_n = &cm->lf_info; - loop_filter_info lfi; + struct loop_filter_info lfi; int filter_level; int alt_flt_enabled = xd->segmentation_enabled; @@ -721,34 +613,30 @@ void vp8_loop_filter_partial_frame lfi.hev_thr = lfi_n->hev_thr[hev_index]; if (mb_col > 0) - LF_INVOKE(&cm->rtcd.loopfilter, normal_mb_v) - (y_ptr, 0, 0, post->y_stride, 0, &lfi); + vp8_loop_filter_mbv(y_ptr, 0, 0, post->y_stride, 0, &lfi); if (!skip_lf) - LF_INVOKE(&cm->rtcd.loopfilter, normal_b_v) - (y_ptr, 0, 0, post->y_stride, 0, &lfi); + vp8_loop_filter_bv(y_ptr, 0, 0, post->y_stride, 0, &lfi); - LF_INVOKE(&cm->rtcd.loopfilter, normal_mb_h) - (y_ptr, 0, 0, post->y_stride, 0, &lfi); + vp8_loop_filter_mbh(y_ptr, 0, 0, post->y_stride, 0, &lfi); if (!skip_lf) - LF_INVOKE(&cm->rtcd.loopfilter, normal_b_h) - (y_ptr, 0, 0, post->y_stride, 0, &lfi); + vp8_loop_filter_bh(y_ptr, 0, 0, post->y_stride, 0, &lfi); } else { if (mb_col > 0) - LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_v) - (y_ptr, post->y_stride, lfi_n->mblim[filter_level]); + vp8_loop_filter_simple_mbv (y_ptr, post->y_stride, + lfi_n->mblim[filter_level]); if (!skip_lf) - LF_INVOKE(&cm->rtcd.loopfilter, simple_b_v) - (y_ptr, post->y_stride, lfi_n->blim[filter_level]); + vp8_loop_filter_simple_bv(y_ptr, post->y_stride, + lfi_n->blim[filter_level]); - LF_INVOKE(&cm->rtcd.loopfilter, simple_mb_h) - (y_ptr, post->y_stride, lfi_n->mblim[filter_level]); + vp8_loop_filter_simple_mbh(y_ptr, post->y_stride, + lfi_n->mblim[filter_level]); if (!skip_lf) - LF_INVOKE(&cm->rtcd.loopfilter, simple_b_h) - (y_ptr, post->y_stride, lfi_n->blim[filter_level]); + vp8_loop_filter_simple_bh(y_ptr, post->y_stride, + lfi_n->blim[filter_level]); } } diff --git a/vp8/common/loopfilter.h b/vp8/common/loopfilter.h index b2ba95d5f..df78b8c12 100644 --- a/vp8/common/loopfilter.h +++ b/vp8/common/loopfilter.h @@ -42,12 +42,12 @@ typedef struct { unsigned char mode_lf_lut[MB_MODE_COUNT]; } loop_filter_info_n; -typedef struct { +struct loop_filter_info { const unsigned char *mblim; const unsigned char *blim; const unsigned char *lim; const unsigned char *hev_thr; -} loop_filter_info; +}; #define prototype_loopfilter(sym) \ @@ -56,7 +56,7 @@ typedef struct { #define prototype_loopfilter_block(sym) \ void sym(unsigned char *y, unsigned char *u, unsigned char *v, \ - int ystride, int uv_stride, loop_filter_info *lfi) + int ystride, int uv_stride, struct loop_filter_info *lfi) #define prototype_simple_loopfilter(sym) \ void sym(unsigned char *y, int ystride, const unsigned char *blimit) @@ -69,66 +69,6 @@ typedef struct { #include "arm/loopfilter_arm.h" #endif -#ifndef vp8_lf_normal_mb_v -#define vp8_lf_normal_mb_v vp8_loop_filter_mbv_c -#endif -extern prototype_loopfilter_block(vp8_lf_normal_mb_v); - -#ifndef vp8_lf_normal_b_v -#define vp8_lf_normal_b_v vp8_loop_filter_bv_c -#endif -extern prototype_loopfilter_block(vp8_lf_normal_b_v); - -#ifndef vp8_lf_normal_mb_h -#define vp8_lf_normal_mb_h vp8_loop_filter_mbh_c -#endif -extern prototype_loopfilter_block(vp8_lf_normal_mb_h); - -#ifndef vp8_lf_normal_b_h -#define vp8_lf_normal_b_h vp8_loop_filter_bh_c -#endif -extern prototype_loopfilter_block(vp8_lf_normal_b_h); - -#ifndef vp8_lf_simple_mb_v -#define vp8_lf_simple_mb_v vp8_loop_filter_simple_vertical_edge_c -#endif -extern prototype_simple_loopfilter(vp8_lf_simple_mb_v); - -#ifndef vp8_lf_simple_b_v -#define vp8_lf_simple_b_v vp8_loop_filter_bvs_c -#endif -extern prototype_simple_loopfilter(vp8_lf_simple_b_v); - -#ifndef vp8_lf_simple_mb_h -#define vp8_lf_simple_mb_h vp8_loop_filter_simple_horizontal_edge_c -#endif -extern prototype_simple_loopfilter(vp8_lf_simple_mb_h); - -#ifndef vp8_lf_simple_b_h -#define vp8_lf_simple_b_h vp8_loop_filter_bhs_c -#endif -extern prototype_simple_loopfilter(vp8_lf_simple_b_h); - -typedef prototype_loopfilter_block((*vp8_lf_block_fn_t)); -typedef prototype_simple_loopfilter((*vp8_slf_block_fn_t)); - -typedef struct { - vp8_lf_block_fn_t normal_mb_v; - vp8_lf_block_fn_t normal_b_v; - vp8_lf_block_fn_t normal_mb_h; - vp8_lf_block_fn_t normal_b_h; - vp8_slf_block_fn_t simple_mb_v; - vp8_slf_block_fn_t simple_b_v; - vp8_slf_block_fn_t simple_mb_h; - vp8_slf_block_fn_t simple_b_h; -} vp8_loopfilter_rtcd_vtable_t; - -#if CONFIG_RUNTIME_CPU_DETECT -#define LF_INVOKE(ctx,fn) (ctx)->fn -#else -#define LF_INVOKE(ctx,fn) vp8_lf_##fn -#endif - typedef void loop_filter_uvfunction ( unsigned char *u, /* source pointer */ diff --git a/vp8/common/loopfilter_filters.c b/vp8/common/loopfilter_filters.c index ef69ffecc..3f97d2101 100644 --- a/vp8/common/loopfilter_filters.c +++ b/vp8/common/loopfilter_filters.c @@ -379,3 +379,87 @@ void vp8_loop_filter_simple_vertical_edge_c } while (++i < 16); } + +/* Vertical MB Filtering */ +void vp8_loop_filter_mbv_c(unsigned char *y_ptr, unsigned char *u_ptr, + unsigned char *v_ptr, int y_stride, int uv_stride, + struct loop_filter_info *lfi) { + vp8_mbloop_filter_vertical_edge_c(y_ptr, y_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 2); + + if (u_ptr) + vp8_mbloop_filter_vertical_edge_c(u_ptr, uv_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 1); + + if (v_ptr) + vp8_mbloop_filter_vertical_edge_c(v_ptr, uv_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 1); +} + +/* Vertical B Filtering */ +void vp8_loop_filter_bv_c(unsigned char *y_ptr, unsigned char *u_ptr, + unsigned char *v_ptr, int y_stride, int uv_stride, + struct loop_filter_info *lfi) { + vp8_loop_filter_vertical_edge_c(y_ptr + 4, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); + vp8_loop_filter_vertical_edge_c(y_ptr + 8, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); + vp8_loop_filter_vertical_edge_c(y_ptr + 12, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); + + if (u_ptr) + vp8_loop_filter_vertical_edge_c(u_ptr + 4, uv_stride, lfi->blim, lfi->lim, lfi->hev_thr, 1); + + if (v_ptr) + vp8_loop_filter_vertical_edge_c(v_ptr + 4, uv_stride, lfi->blim, lfi->lim, lfi->hev_thr, 1); +} + +/* Horizontal MB filtering */ +void vp8_loop_filter_mbh_c(unsigned char *y_ptr, unsigned char *u_ptr, + unsigned char *v_ptr, int y_stride, int uv_stride, + struct loop_filter_info *lfi) { + vp8_mbloop_filter_horizontal_edge_c(y_ptr, y_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 2); + + if (u_ptr) + vp8_mbloop_filter_horizontal_edge_c(u_ptr, uv_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 1); + + if (v_ptr) + vp8_mbloop_filter_horizontal_edge_c(v_ptr, uv_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 1); +} + +/* Horizontal B Filtering */ +void vp8_loop_filter_bh_c(unsigned char *y_ptr, unsigned char *u_ptr, + unsigned char *v_ptr, int y_stride, int uv_stride, + struct loop_filter_info *lfi) { + vp8_loop_filter_horizontal_edge_c(y_ptr + 4 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); + vp8_loop_filter_horizontal_edge_c(y_ptr + 8 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); + vp8_loop_filter_horizontal_edge_c(y_ptr + 12 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); + + if (u_ptr) + vp8_loop_filter_horizontal_edge_c(u_ptr + 4 * uv_stride, uv_stride, lfi->blim, lfi->lim, lfi->hev_thr, 1); + + if (v_ptr) + vp8_loop_filter_horizontal_edge_c(v_ptr + 4 * uv_stride, uv_stride, lfi->blim, lfi->lim, lfi->hev_thr, 1); +} + +void vp8_loop_filter_bh8x8_c(unsigned char *y_ptr, unsigned char *u_ptr, + unsigned char *v_ptr, int y_stride, int uv_stride, + struct loop_filter_info *lfi) { + vp8_mbloop_filter_horizontal_edge_c( + y_ptr + 8 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); +} + +void vp8_loop_filter_bhs_c(unsigned char *y_ptr, int y_stride, + const unsigned char *blimit) { + vp8_loop_filter_simple_horizontal_edge_c(y_ptr + 4 * y_stride, y_stride, blimit); + vp8_loop_filter_simple_horizontal_edge_c(y_ptr + 8 * y_stride, y_stride, blimit); + vp8_loop_filter_simple_horizontal_edge_c(y_ptr + 12 * y_stride, y_stride, blimit); +} + +void vp8_loop_filter_bv8x8_c(unsigned char *y_ptr, unsigned char *u_ptr, + unsigned char *v_ptr, int y_stride, int uv_stride, + struct loop_filter_info *lfi) { + vp8_mbloop_filter_vertical_edge_c( + y_ptr + 8, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); +} + +void vp8_loop_filter_bvs_c(unsigned char *y_ptr, int y_stride, + const unsigned char *blimit) { + vp8_loop_filter_simple_vertical_edge_c(y_ptr + 4, y_stride, blimit); + vp8_loop_filter_simple_vertical_edge_c(y_ptr + 8, y_stride, blimit); + vp8_loop_filter_simple_vertical_edge_c(y_ptr + 12, y_stride, blimit); +} diff --git a/vp8/common/onyxc_int.h b/vp8/common/onyxc_int.h index 31dd6c15c..0396a7087 100644 --- a/vp8/common/onyxc_int.h +++ b/vp8/common/onyxc_int.h @@ -20,7 +20,6 @@ #include "entropy.h" #include "entropymode.h" #include "idct.h" -#include "recon.h" #if CONFIG_POSTPROC #include "postproc.h" #endif @@ -171,9 +170,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_postproc_rtcd_vtable_t postproc; #endif diff --git a/vp8/common/recon.c b/vp8/common/recon.c index cf2d2fb85..ce35e4b12 100644 --- a/vp8/common/recon.c +++ b/vp8/common/recon.c @@ -10,7 +10,7 @@ #include "vpx_ports/config.h" -#include "recon.h" +#include "vpx_rtcd.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(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *xd, uint8_t *dst) { +void vp8_recon_mby_s_c(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(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *xd, uin } } -void vp8_recon_mbuv_s_c(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *xd, uint8_t *udst, uint8_t *vdst) { +void vp8_recon_mbuv_s_c(MACROBLOCKD *xd, uint8_t *udst, uint8_t *vdst) { int x, y, i; uint8_t *dst = udst; @@ -170,71 +170,28 @@ void vp8_recon_mbuv_s_c(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *xd, ui } #endif -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 +void vp8_recon_mby_c(MACROBLOCKD *xd) { int i; for (i = 0; i < 16; i += 4) { BLOCKD *b = &xd->block[i]; - RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride); + vp8_recon4b(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride); } -#endif } -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 +void vp8_recon_mb_c(MACROBLOCKD *xd) { int i; for (i = 0; i < 16; i += 4) { BLOCKD *b = &xd->block[i]; - RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride); + vp8_recon4b(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride); } for (i = 16; i < 24; i += 2) { BLOCKD *b = &xd->block[i]; - RECON_INVOKE(rtcd, recon2)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride); + vp8_recon2b(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride); } -#endif } diff --git a/vp8/common/recon.h b/vp8/common/recon.h deleted file mode 100644 index 54d133b85..000000000 --- a/vp8/common/recon.h +++ /dev/null @@ -1,268 +0,0 @@ -/* - * 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 diff --git a/vp8/common/reconinter.c b/vp8/common/reconinter.c index 5b50b0335..a41d233ab 100644 --- a/vp8/common/reconinter.c +++ b/vp8/common/reconinter.c @@ -11,7 +11,6 @@ #include "vpx_ports/config.h" #include "vpx/vpx_integer.h" -#include "recon.h" #include "subpixel.h" #include "blockd.h" #include "reconinter.h" @@ -295,7 +294,7 @@ void vp8_build_2nd_inter_predictors_b(BLOCKD *d, int pitch, vp8_subpix_fn_t sppf } } -static void build_inter_predictors4b(MACROBLOCKD *xd, BLOCKD *d, int pitch) { +void vp8_build_inter_predictors4b(MACROBLOCKD *xd, BLOCKD *d, int pitch) { unsigned char *ptr_base; unsigned char *ptr; unsigned char *pred_ptr = d->predictor; @@ -310,8 +309,7 @@ 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 { - RECON_INVOKE(&xd->rtcd->recon, copy8x8) - (ptr, d->pre_stride, pred_ptr, pitch); + vp8_copy_mem8x8(ptr, d->pre_stride, pred_ptr, pitch); } } @@ -321,8 +319,8 @@ static void build_inter_predictors4b(MACROBLOCKD *xd, BLOCKD *d, int pitch) { * come from an earlier call to build_inter_predictors_4b()) with the * predictor of the second reference frame / motion vector. */ -static void build_2nd_inter_predictors4b(MACROBLOCKD *xd, - BLOCKD *d, int pitch) { +void vp8_build_2nd_inter_predictors4b(MACROBLOCKD *xd, + BLOCKD *d, int pitch) { unsigned char *ptr_base; unsigned char *ptr; unsigned char *pred_ptr = d->predictor; @@ -337,8 +335,7 @@ 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 { - RECON_INVOKE(&xd->rtcd->recon, avg8x8) - (ptr, d->pre_stride, pred_ptr, pitch); + vp8_avg_mem8x8(ptr, d->pre_stride, pred_ptr, pitch); } } @@ -357,7 +354,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 { - RECON_INVOKE(&xd->rtcd->recon, copy8x4)(ptr, d->pre_stride, pred_ptr, pitch); + vp8_copy_mem8x4(ptr, d->pre_stride, pred_ptr, pitch); } } @@ -741,10 +738,8 @@ 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 { - 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); + vp8_copy_mem8x8(uptr, pre_stride, dst_u, dst_uvstride); + vp8_copy_mem8x8(vptr, pre_stride, dst_v, dst_uvstride); } } @@ -863,8 +858,7 @@ 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! - RECON_INVOKE(&xd->rtcd->recon, avg16x16)(ptr, pre_stride, dst_y, - dst_ystride); + vp8_avg_mem16x16(ptr, pre_stride, dst_y, dst_ystride); } } else #endif // CONFIG_PRED_FILTER @@ -873,8 +867,7 @@ 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 { - RECON_INVOKE(&xd->rtcd->recon, avg16x16)(ptr, pre_stride, dst_y, - dst_ystride); + vp8_avg_mem16x16(ptr, pre_stride, dst_y, dst_ystride); } } } @@ -937,8 +930,7 @@ 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! - RECON_INVOKE(&xd->rtcd->recon, avg8x8)(pSrc, pre_stride, pDst, - dst_uvstride); + vp8_avg_mem8x8(pSrc, pre_stride, pDst, dst_uvstride); } // V @@ -953,8 +945,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 { - 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_avg_mem8x8(uptr, pre_stride, dst_u, dst_uvstride); + vp8_avg_mem8x8(vptr, pre_stride, dst_v, dst_uvstride); } } @@ -993,16 +985,16 @@ static void build_inter4x4_predictors_mb(MACROBLOCKD *xd) { } - build_inter_predictors4b(xd, &blockd[ 0], 16); - build_inter_predictors4b(xd, &blockd[ 2], 16); - build_inter_predictors4b(xd, &blockd[ 8], 16); - build_inter_predictors4b(xd, &blockd[10], 16); + vp8_build_inter_predictors4b(xd, &blockd[ 0], 16); + vp8_build_inter_predictors4b(xd, &blockd[ 2], 16); + vp8_build_inter_predictors4b(xd, &blockd[ 8], 16); + vp8_build_inter_predictors4b(xd, &blockd[10], 16); if (mbmi->second_ref_frame) { - build_2nd_inter_predictors4b(xd, &blockd[ 0], 16); - build_2nd_inter_predictors4b(xd, &blockd[ 2], 16); - build_2nd_inter_predictors4b(xd, &blockd[ 8], 16); - build_2nd_inter_predictors4b(xd, &blockd[10], 16); + vp8_build_2nd_inter_predictors4b(xd, &blockd[ 0], 16); + vp8_build_2nd_inter_predictors4b(xd, &blockd[ 2], 16); + vp8_build_2nd_inter_predictors4b(xd, &blockd[ 8], 16); + vp8_build_2nd_inter_predictors4b(xd, &blockd[10], 16); } } else { for (i = 0; i < 16; i += 2) { diff --git a/vp8/common/reconinter.h b/vp8/common/reconinter.h index 37e34b5e1..c78611920 100644 --- a/vp8/common/reconinter.h +++ b/vp8/common/reconinter.h @@ -12,9 +12,7 @@ #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, @@ -61,6 +59,11 @@ extern void vp8_build_inter_predictors_b(BLOCKD *d, int pitch, extern void vp8_build_2nd_inter_predictors_b(BLOCKD *d, int pitch, vp8_subpix_fn_t sppf); +extern void vp8_build_inter_predictors4b(MACROBLOCKD *xd, BLOCKD *d, + int pitch); +extern void vp8_build_2nd_inter_predictors4b(MACROBLOCKD *xd, + BLOCKD *d, int pitch); + extern void vp8_build_inter4x4_predictors_mbuv(MACROBLOCKD *xd); extern void vp8_setup_interp_filters(MACROBLOCKD *xd, INTERPOLATIONFILTERTYPE filter, diff --git a/vp8/common/reconintra.c b/vp8/common/reconintra.c index cad9652b7..9bee3a7da 100644 --- a/vp8/common/reconintra.c +++ b/vp8/common/reconintra.c @@ -10,7 +10,7 @@ #include <stdio.h> #include "vpx_ports/config.h" -#include "recon.h" +#include "vpx_rtcd.h" #include "reconintra.h" #include "vpx_mem/vpx_mem.h" @@ -196,14 +196,12 @@ void d153_predictor(unsigned char *ypred_ptr, int y_stride, int n, } } -void vp8_recon_intra_mbuv(const vp8_recon_rtcd_vtable_t *rtcd, - MACROBLOCKD *xd) { +void vp8_recon_intra_mbuv(MACROBLOCKD *xd) { int i; for (i = 16; i < 24; i += 2) { BLOCKD *b = &xd->block[i]; - RECON_INVOKE(rtcd, recon2)(b->predictor, b->diff, - *(b->base_dst) + b->dst, b->dst_stride); + vp8_recon2b(b->predictor, b->diff,*(b->base_dst) + b->dst, b->dst_stride); } } diff --git a/vp8/common/reconintra4x4.c b/vp8/common/reconintra4x4.c index 69faab09d..0ba0a2cff 100644 --- a/vp8/common/reconintra4x4.c +++ b/vp8/common/reconintra4x4.c @@ -10,13 +10,12 @@ #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(BLOCKD *x, - int b_mode, - unsigned char *predictor) { +void vp8_intra4x4_predict_c(BLOCKD *x, int b_mode, + unsigned char *predictor) { int i, r, c; unsigned char *Above = *(x->base_dst) + x->dst - x->dst_stride; @@ -276,7 +275,7 @@ void vp8_intra4x4_predict(BLOCKD *x, } #if CONFIG_COMP_INTRA_PRED -void vp8_comp_intra4x4_predict(BLOCKD *x, +void vp8_comp_intra4x4_predict_c(BLOCKD *x, int b_mode, int b_mode2, unsigned char *out_predictor) { unsigned char predictor[2][4 * 16]; diff --git a/vp8/common/rtcd.c b/vp8/common/rtcd.c index a7bb92ce4..01dad4691 100644 --- a/vp8/common/rtcd.c +++ b/vp8/common/rtcd.c @@ -11,20 +11,95 @@ #define RTCD_C #include "vpx_rtcd.h" +#if CONFIG_MULTITHREAD && defined(_WIN32) +#include <windows.h> +#include <stdlib.h> +static void once(void (*func)(void)) +{ + static CRITICAL_SECTION *lock; + static LONG waiters; + static int done; + void *lock_ptr = &lock; + + /* If the initialization is complete, return early. This isn't just an + * optimization, it prevents races on the destruction of the global + * lock. + */ + if(done) + return; + + InterlockedIncrement(&waiters); + + /* Get a lock. We create one and try to make it the one-true-lock, + * throwing it away if we lost the race. + */ + + { + /* Scope to protect access to new_lock */ + CRITICAL_SECTION *new_lock = malloc(sizeof(CRITICAL_SECTION)); + InitializeCriticalSection(new_lock); + if (InterlockedCompareExchangePointer(lock_ptr, new_lock, NULL) != NULL) + { + DeleteCriticalSection(new_lock); + free(new_lock); + } + } + + /* At this point, we have a lock that can be synchronized on. We don't + * care which thread actually performed the allocation. + */ + + EnterCriticalSection(lock); + + if (!done) + { + func(); + done = 1; + } + + LeaveCriticalSection(lock); + + /* Last one out should free resources. The destructed objects are + * protected by checking if(done) above. + */ + if(!InterlockedDecrement(&waiters)) + { + DeleteCriticalSection(lock); + free(lock); + lock = NULL; + } +} + + +#elif CONFIG_MULTITHREAD && HAVE_PTHREAD_H +#include <pthread.h> +static void once(void (*func)(void)) +{ + static pthread_once_t lock = PTHREAD_ONCE_INIT; + pthread_once(&lock, func); +} + + +#else /* No-op version that performs no synchronization. vpx_rtcd() is idempotent, * so as long as your platform provides atomic loads/stores of pointers * no synchronization is strictly necessary. */ -static void once(void (*func)(void)) { - static int done; +static void once(void (*func)(void)) +{ + static int done; - if(!done) { - func(); - done = 1; - } + if(!done) + { + func(); + done = 1; + } } +#endif + -void vpx_rtcd() { - once(setup_rtcd_internal); +void vpx_rtcd() +{ + once(setup_rtcd_internal); } diff --git a/vp8/common/rtcd_defs.sh b/vp8/common/rtcd_defs.sh index 6667c6562..ef272df90 100644 --- a/vp8/common/rtcd_defs.sh +++ b/vp8/common/rtcd_defs.sh @@ -1,12 +1,17 @@ common_forward_decls() { cat <<EOF -struct blockd; +#include "vp8/common/blockd.h" + +struct loop_filter_info; + +/* Encoder forward decls */ +struct variance_vtable; +union int_mv; +struct yv12_buffer_config; EOF } forward_decls common_forward_decls - - prototype void vp8_filter_block2d_4x4_8 "const unsigned char *src_ptr, const unsigned int src_stride, const short *HFilter_aligned16, const short *VFilter_aligned16, unsigned char *dst_ptr, unsigned int dst_stride" prototype void vp8_filter_block2d_8x4_8 "const unsigned char *src_ptr, const unsigned int src_stride, const short *HFilter_aligned16, const short *VFilter_aligned16, unsigned char *dst_ptr, unsigned int dst_stride" prototype void vp8_filter_block2d_8x8_8 "const unsigned char *src_ptr, const unsigned int src_stride, const short *HFilter_aligned16, const short *VFilter_aligned16, unsigned char *dst_ptr, unsigned int dst_stride" @@ -30,3 +35,142 @@ prototype void vp8_copy_mem16x16 "unsigned char *src, int src_pitch, unsigned ch specialize vp8_copy_mem16x16 mmx sse2 media neon dspr2 vp8_copy_mem16x16_media=vp8_copy_mem16x16_v6 vp8_copy_mem16x16_dspr2=vp8_copy_mem16x16_dspr2 + +prototype void vp8_copy_mem8x8 "unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch" +specialize vp8_copy_mem8x8 mmx media neon dspr2 +vp8_copy_mem8x8_media=vp8_copy_mem8x8_v6 +vp8_copy_mem8x8_dspr2=vp8_copy_mem8x8_dspr2 + +prototype void vp8_copy_mem8x4 "unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch" +specialize vp8_copy_mem8x4 mmx + +prototype void vp8_intra4x4_predict "unsigned char *Above, unsigned char *yleft, int left_stride, B_PREDICTION_MODE b_mode, unsigned char *dst, int dst_stride, unsigned char top_left" +specialize vp8_intra4x4_predict + +prototype void vp8_avg_mem16x16 "unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch" +specialize vp8_avg_mem16x16 + +prototype void vp8_avg_mem8x8 "unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch" +specialize vp8_avg_mem8x8 + +prototype void vp8_copy_mem8x4 "unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch" +specialize vp8_copy_mem8x4 mmx media neon dspr2 +vp8_copy_mem8x4_media=vp8_copy_mem8x4_v6 +vp8_copy_mem8x4_dspr2=vp8_copy_mem8x4_dspr2 + +prototype void vp8_recon_b "unsigned char *pred_ptr, short *diff_ptr, unsigned char *dst_ptr, int stride" +specialize vp8_recon_b + +prototype void vp8_recon_uv_b "unsigned char *pred_ptr, short *diff_ptr, unsigned char *dst_ptr, int stride" +specialize vp8_recon_uv_b + +prototype void vp8_recon2b "unsigned char *pred_ptr, short *diff_ptr, unsigned char *dst_ptr, int stride" +specialize vp8_recon2b sse2 + +prototype void vp8_recon4b "unsigned char *pred_ptr, short *diff_ptr, unsigned char *dst_ptr, int stride" +specialize vp8_recon4b sse2 + +prototype void vp8_recon_mb "MACROBLOCKD *x" +specialize vp8_recon_mb + +prototype void vp8_recon_mby "MACROBLOCKD *x" +specialize vp8_recon_mby + +prototype void vp8_build_intra_predictors_mby_s "MACROBLOCKD *x" +specialize vp8_build_intra_predictors_mby_s + +prototype void vp8_build_intra_predictors_sby_s "MACROBLOCKD *x" +specialize vp8_build_intra_predictors_sby_s; + +prototype void vp8_build_intra_predictors_sbuv_s "MACROBLOCKD *x" +specialize vp8_build_intra_predictors_sbuv_s; + +prototype void vp8_build_intra_predictors_mby "MACROBLOCKD *x" +specialize vp8_build_intra_predictors_mby; + +prototype void vp8_build_comp_intra_predictors_mby "MACROBLOCKD *x" +specialize vp8_build_comp_intra_predictors_mby; + +prototype void vp8_build_intra_predictors_mby_s "MACROBLOCKD *x" +specialize vp8_build_intra_predictors_mby_s; + +prototype void vp8_build_intra_predictors_mbuv "MACROBLOCKD *x" +specialize vp8_build_intra_predictors_mbuv; + +prototype void vp8_build_intra_predictors_mbuv_s "MACROBLOCKD *x" +specialize vp8_build_intra_predictors_mbuv_s; + +prototype void vp8_build_comp_intra_predictors_mbuv "MACROBLOCKD *x" +specialize vp8_build_comp_intra_predictors_mbuv; + +prototype void vp8_intra4x4_predict "BLOCKD *x, int b_mode, unsigned char *predictor" +specialize vp8_intra4x4_predict; + +prototype void vp8_comp_intra4x4_predict "BLOCKD *x, int b_mode, int second_mode, unsigned char *predictor" +specialize vp8_comp_intra4x4_predict; + +prototype void vp8_intra8x8_predict "BLOCKD *x, int b_mode, unsigned char *predictor" +specialize vp8_intra8x8_predict; + +prototype void vp8_comp_intra8x8_predict "BLOCKD *x, int b_mode, int second_mode, unsigned char *predictor" +specialize vp8_comp_intra8x8_predict; + +prototype void vp8_intra_uv4x4_predict "BLOCKD *x, int b_mode, unsigned char *predictor" +specialize vp8_intra_uv4x4_predict; + +prototype void vp8_comp_intra_uv4x4_predict "BLOCKD *x, int b_mode, int second_mode, unsigned char *predictor" +specialize vp8_comp_intra_uv4x4_predict; + +# +# Loopfilter +# +prototype void vp8_loop_filter_mbv "unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi" +specialize vp8_loop_filter_mbv; + +prototype void vp8_loop_filter_bv "unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi" +specialize vp8_loop_filter_bv; + +prototype void vp8_loop_filter_bv8x8 "unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi" +specialize vp8_loop_filter_bv8x8; + +prototype void vp8_loop_filter_mbh "unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi" +specialize vp8_loop_filter_mbh; + +prototype void vp8_loop_filter_bh "unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi" +specialize vp8_loop_filter_bh; + +prototype void vp8_loop_filter_bh8x8 "unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi" +specialize vp8_loop_filter_bh8x8; + +prototype void vp8_loop_filter_simple_mbv "unsigned char *y, int ystride, const unsigned char *blimit" +specialize vp8_loop_filter_simple_mbv mmx sse2 media neon +vp8_loop_filter_simple_mbv_c=vp8_loop_filter_simple_vertical_edge_c +vp8_loop_filter_simple_mbv_mmx=vp8_loop_filter_simple_vertical_edge_mmx +vp8_loop_filter_simple_mbv_sse2=vp8_loop_filter_simple_vertical_edge_sse2 +vp8_loop_filter_simple_mbv_media=vp8_loop_filter_simple_vertical_edge_armv6 +vp8_loop_filter_simple_mbv_neon=vp8_loop_filter_mbvs_neon + +prototype void vp8_loop_filter_simple_mbh "unsigned char *y, int ystride, const unsigned char *blimit" +specialize vp8_loop_filter_simple_mbh mmx sse2 media neon +vp8_loop_filter_simple_mbh_c=vp8_loop_filter_simple_horizontal_edge_c +vp8_loop_filter_simple_mbh_mmx=vp8_loop_filter_simple_horizontal_edge_mmx +vp8_loop_filter_simple_mbh_sse2=vp8_loop_filter_simple_horizontal_edge_sse2 +vp8_loop_filter_simple_mbh_media=vp8_loop_filter_simple_horizontal_edge_armv6 +vp8_loop_filter_simple_mbh_neon=vp8_loop_filter_mbhs_neon + +prototype void vp8_loop_filter_simple_bv "unsigned char *y, int ystride, const unsigned char *blimit" +specialize vp8_loop_filter_simple_bv mmx sse2 media neon +vp8_loop_filter_simple_bv_c=vp8_loop_filter_bvs_c +vp8_loop_filter_simple_bv_mmx=vp8_loop_filter_bvs_mmx +vp8_loop_filter_simple_bv_sse2=vp8_loop_filter_bvs_sse2 +vp8_loop_filter_simple_bv_media=vp8_loop_filter_bvs_armv6 +vp8_loop_filter_simple_bv_neon=vp8_loop_filter_bvs_neon + +prototype void vp8_loop_filter_simple_bh "unsigned char *y, int ystride, const unsigned char *blimit" +specialize vp8_loop_filter_simple_bh mmx sse2 media neon +vp8_loop_filter_simple_bh_c=vp8_loop_filter_bhs_c +vp8_loop_filter_simple_bh_mmx=vp8_loop_filter_bhs_mmx +vp8_loop_filter_simple_bh_sse2=vp8_loop_filter_bhs_sse2 +vp8_loop_filter_simple_bh_media=vp8_loop_filter_bhs_armv6 +vp8_loop_filter_simple_bh_neon=vp8_loop_filter_bhs_neon + diff --git a/vp8/common/x86/loopfilter_x86.c b/vp8/common/x86/loopfilter_x86.c index add888835..e7239818e 100644 --- a/vp8/common/x86/loopfilter_x86.c +++ b/vp8/common/x86/loopfilter_x86.c @@ -30,7 +30,7 @@ extern loop_filter_uvfunction vp8_mbloop_filter_vertical_edge_uv_sse2; #if HAVE_MMX /* Horizontal MB filtering */ void vp8_loop_filter_mbh_mmx(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, - int y_stride, int uv_stride, loop_filter_info *lfi) { + int y_stride, int uv_stride, struct loop_filter_info *lfi) { vp8_mbloop_filter_horizontal_edge_mmx(y_ptr, y_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 2); if (u_ptr) @@ -43,7 +43,7 @@ void vp8_loop_filter_mbh_mmx(unsigned char *y_ptr, unsigned char *u_ptr, unsigne /* Vertical MB Filtering */ void vp8_loop_filter_mbv_mmx(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, - int y_stride, int uv_stride, loop_filter_info *lfi) { + int y_stride, int uv_stride, struct loop_filter_info *lfi) { vp8_mbloop_filter_vertical_edge_mmx(y_ptr, y_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 2); if (u_ptr) @@ -56,7 +56,7 @@ void vp8_loop_filter_mbv_mmx(unsigned char *y_ptr, unsigned char *u_ptr, unsigne /* Horizontal B Filtering */ void vp8_loop_filter_bh_mmx(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, - int y_stride, int uv_stride, loop_filter_info *lfi) { + int y_stride, int uv_stride, struct loop_filter_info *lfi) { vp8_loop_filter_horizontal_edge_mmx(y_ptr + 4 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); vp8_loop_filter_horizontal_edge_mmx(y_ptr + 8 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); vp8_loop_filter_horizontal_edge_mmx(y_ptr + 12 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); @@ -78,7 +78,7 @@ void vp8_loop_filter_bhs_mmx(unsigned char *y_ptr, int y_stride, const unsigned /* Vertical B Filtering */ void vp8_loop_filter_bv_mmx(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, - int y_stride, int uv_stride, loop_filter_info *lfi) { + int y_stride, int uv_stride, struct loop_filter_info *lfi) { vp8_loop_filter_vertical_edge_mmx(y_ptr + 4, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); vp8_loop_filter_vertical_edge_mmx(y_ptr + 8, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); vp8_loop_filter_vertical_edge_mmx(y_ptr + 12, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); @@ -102,7 +102,7 @@ void vp8_loop_filter_bvs_mmx(unsigned char *y_ptr, int y_stride, const unsigned /* Horizontal MB filtering */ #if HAVE_SSE2 void vp8_loop_filter_mbh_sse2(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, - int y_stride, int uv_stride, loop_filter_info *lfi) { + int y_stride, int uv_stride, struct loop_filter_info *lfi) { vp8_mbloop_filter_horizontal_edge_sse2(y_ptr, y_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 2); if (u_ptr) @@ -112,7 +112,7 @@ void vp8_loop_filter_mbh_sse2(unsigned char *y_ptr, unsigned char *u_ptr, unsign /* Vertical MB Filtering */ void vp8_loop_filter_mbv_sse2(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, - int y_stride, int uv_stride, loop_filter_info *lfi) { + int y_stride, int uv_stride, struct loop_filter_info *lfi) { vp8_mbloop_filter_vertical_edge_sse2(y_ptr, y_stride, lfi->mblim, lfi->lim, lfi->hev_thr, 2); if (u_ptr) @@ -122,7 +122,7 @@ void vp8_loop_filter_mbv_sse2(unsigned char *y_ptr, unsigned char *u_ptr, unsign /* Horizontal B Filtering */ void vp8_loop_filter_bh_sse2(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, - int y_stride, int uv_stride, loop_filter_info *lfi) { + int y_stride, int uv_stride, struct loop_filter_info *lfi) { vp8_loop_filter_horizontal_edge_sse2(y_ptr + 4 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); vp8_loop_filter_horizontal_edge_sse2(y_ptr + 8 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); vp8_loop_filter_horizontal_edge_sse2(y_ptr + 12 * y_stride, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); @@ -141,7 +141,7 @@ void vp8_loop_filter_bhs_sse2(unsigned char *y_ptr, int y_stride, const unsigned /* Vertical B Filtering */ void vp8_loop_filter_bv_sse2(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr, - int y_stride, int uv_stride, loop_filter_info *lfi) { + int y_stride, int uv_stride, struct loop_filter_info *lfi) { vp8_loop_filter_vertical_edge_sse2(y_ptr + 4, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); vp8_loop_filter_vertical_edge_sse2(y_ptr + 8, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); vp8_loop_filter_vertical_edge_sse2(y_ptr + 12, y_stride, lfi->blim, lfi->lim, lfi->hev_thr, 2); diff --git a/vp8/common/x86/loopfilter_x86.h b/vp8/common/x86/loopfilter_x86.h index 1ed6c213f..3cbea8f04 100644 --- a/vp8/common/x86/loopfilter_x86.h +++ b/vp8/common/x86/loopfilter_x86.h @@ -28,33 +28,6 @@ extern prototype_simple_loopfilter(vp8_loop_filter_simple_vertical_edge_mmx); extern prototype_simple_loopfilter(vp8_loop_filter_bvs_mmx); extern prototype_simple_loopfilter(vp8_loop_filter_simple_horizontal_edge_mmx); extern prototype_simple_loopfilter(vp8_loop_filter_bhs_mmx); - - -#if !CONFIG_RUNTIME_CPU_DETECT -#undef vp8_lf_normal_mb_v -#define vp8_lf_normal_mb_v vp8_loop_filter_mbv_mmx - -#undef vp8_lf_normal_b_v -#define vp8_lf_normal_b_v vp8_loop_filter_bv_mmx - -#undef vp8_lf_normal_mb_h -#define vp8_lf_normal_mb_h vp8_loop_filter_mbh_mmx - -#undef vp8_lf_normal_b_h -#define vp8_lf_normal_b_h vp8_loop_filter_bh_mmx - -#undef vp8_lf_simple_mb_v -#define vp8_lf_simple_mb_v vp8_loop_filter_simple_vertical_edge_mmx - -#undef vp8_lf_simple_b_v -#define vp8_lf_simple_b_v vp8_loop_filter_bvs_mmx - -#undef vp8_lf_simple_mb_h -#define vp8_lf_simple_mb_h vp8_loop_filter_simple_horizontal_edge_mmx - -#undef vp8_lf_simple_b_h -#define vp8_lf_simple_b_h vp8_loop_filter_bhs_mmx -#endif #endif @@ -67,33 +40,6 @@ extern prototype_simple_loopfilter(vp8_loop_filter_simple_vertical_edge_sse2); extern prototype_simple_loopfilter(vp8_loop_filter_bvs_sse2); extern prototype_simple_loopfilter(vp8_loop_filter_simple_horizontal_edge_sse2); extern prototype_simple_loopfilter(vp8_loop_filter_bhs_sse2); - - -#if !CONFIG_RUNTIME_CPU_DETECT -#undef vp8_lf_normal_mb_v -#define vp8_lf_normal_mb_v vp8_loop_filter_mbv_sse2 - -#undef vp8_lf_normal_b_v -#define vp8_lf_normal_b_v vp8_loop_filter_bv_sse2 - -#undef vp8_lf_normal_mb_h -#define vp8_lf_normal_mb_h vp8_loop_filter_mbh_sse2 - -#undef vp8_lf_normal_b_h -#define vp8_lf_normal_b_h vp8_loop_filter_bh_sse2 - -#undef vp8_lf_simple_mb_v -#define vp8_lf_simple_mb_v vp8_loop_filter_simple_vertical_edge_sse2 - -#undef vp8_lf_simple_b_v -#define vp8_lf_simple_b_v vp8_loop_filter_bvs_sse2 - -#undef vp8_lf_simple_mb_h -#define vp8_lf_simple_mb_h vp8_loop_filter_simple_horizontal_edge_sse2 - -#undef vp8_lf_simple_b_h -#define vp8_lf_simple_b_h vp8_loop_filter_bhs_sse2 -#endif #endif diff --git a/vp8/common/x86/recon_wrapper_sse2.c b/vp8/common/x86/recon_wrapper_sse2.c index e304d055b..681aff81e 100644 --- a/vp8/common/x86/recon_wrapper_sse2.c +++ b/vp8/common/x86/recon_wrapper_sse2.c @@ -9,9 +9,8 @@ */ #include "vpx_ports/config.h" -#include "vp8/common/recon.h" -#include "recon_x86.h" #include "vpx_mem/vpx_mem.h" +#include "vp8/common/blockd.h" #define build_intra_predictors_mbuv_prototype(sym) \ void sym(unsigned char *dst, int dst_stride, \ diff --git a/vp8/common/x86/recon_x86.h b/vp8/common/x86/recon_x86.h deleted file mode 100644 index c0180cc56..000000000 --- a/vp8/common/x86/recon_x86.h +++ /dev/null @@ -1,81 +0,0 @@ -/* - * 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 RECON_X86_H -#define RECON_X86_H - -/* Note: - * - * This platform is commonly built for runtime CPU detection. If you modify - * any of the function mappings present in this file, be sure to also update - * them in the function pointer initialization code - */ - -#if HAVE_MMX -extern prototype_recon_block(vp8_recon_b_mmx); -extern prototype_copy_block(vp8_copy_mem8x8_mmx); -extern prototype_copy_block(vp8_copy_mem8x4_mmx); -extern prototype_copy_block(vp8_copy_mem16x16_mmx); - - -#if !CONFIG_RUNTIME_CPU_DETECT -#undef vp8_recon_recon -#define vp8_recon_recon vp8_recon_b_mmx - -#undef vp8_recon_copy8x8 -#define vp8_recon_copy8x8 vp8_copy_mem8x8_mmx - -#undef vp8_recon_copy8x4 -#define vp8_recon_copy8x4 vp8_copy_mem8x4_mmx - -#endif -#endif - -#if HAVE_SSE2 -extern prototype_recon_block(vp8_recon2b_sse2); -extern prototype_recon_block(vp8_recon4b_sse2); -extern prototype_copy_block(vp8_copy_mem16x16_sse2); -extern prototype_build_intra_predictors(vp8_build_intra_predictors_mbuv_sse2); -extern prototype_build_intra_predictors(vp8_build_intra_predictors_mbuv_s_sse2); - -#if !CONFIG_RUNTIME_CPU_DETECT -#undef vp8_recon_recon2 -#define vp8_recon_recon2 vp8_recon2b_sse2 - -#undef vp8_recon_recon4 -#define vp8_recon_recon4 vp8_recon4b_sse2 - -#undef vp8_recon_copy16x16 -#define vp8_recon_copy16x16 vp8_copy_mem16x16_sse2 - -#undef vp8_recon_build_intra_predictors_mbuv -#define vp8_recon_build_intra_predictors_mbuv vp8_build_intra_predictors_mbuv_sse2 - -#undef vp8_recon_build_intra_predictors_mbuv_s -#define vp8_recon_build_intra_predictors_mbuv_s vp8_build_intra_predictors_mbuv_s_sse2 - -#endif -#endif - -#if HAVE_SSSE3 -extern prototype_build_intra_predictors(vp8_build_intra_predictors_mbuv_ssse3); -extern prototype_build_intra_predictors(vp8_build_intra_predictors_mbuv_s_ssse3); - -#if !CONFIG_RUNTIME_CPU_DETECT -#undef vp8_recon_build_intra_predictors_mbuv -#define vp8_recon_build_intra_predictors_mbuv vp8_build_intra_predictors_mbuv_ssse3 - -#undef vp8_recon_build_intra_predictors_mbuv_s -#define vp8_recon_build_intra_predictors_mbuv_s vp8_build_intra_predictors_mbuv_s_ssse3 - -#endif -#endif -#endif diff --git a/vp8/common/x86/x86_systemdependent.c b/vp8/common/x86/x86_systemdependent.c index c50778521..b6d058fbf 100644 --- a/vp8/common/x86/x86_systemdependent.c +++ b/vp8/common/x86/x86_systemdependent.c @@ -14,7 +14,6 @@ #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/pragmas.h" #include "vp8/common/onyxc_int.h" @@ -41,10 +40,6 @@ void vp8_arch_x86_common_init(VP8_COMMON *ctx) { // rtcd->idct.iwalsh16 = vp8_short_inv_walsh4x4_mmx; // rtcd->idct.iwalsh1 = vp8_short_inv_walsh4x4_1_mmx; - rtcd->recon.recon = vp8_recon_b_mmx; - rtcd->recon.copy8x8 = vp8_copy_mem8x8_mmx; - rtcd->recon.copy8x4 = vp8_copy_mem8x4_mmx; - /* Disabled due to unsupported enhanced interpolation/high_prec mv rtcd->subpix.sixtap16x16 = vp8_sixtap_predict16x16_mmx; rtcd->subpix.sixtap8x8 = vp8_sixtap_predict8x8_mmx; @@ -56,15 +51,6 @@ void vp8_arch_x86_common_init(VP8_COMMON *ctx) { rtcd->subpix.bilinear8x4 = vp8_bilinear_predict8x4_mmx; rtcd->subpix.bilinear4x4 = vp8_bilinear_predict4x4_mmx; - rtcd->loopfilter.normal_mb_v = vp8_loop_filter_mbv_mmx; - rtcd->loopfilter.normal_b_v = vp8_loop_filter_bv_mmx; - rtcd->loopfilter.normal_mb_h = vp8_loop_filter_mbh_mmx; - rtcd->loopfilter.normal_b_h = vp8_loop_filter_bh_mmx; - rtcd->loopfilter.simple_mb_v = vp8_loop_filter_simple_vertical_edge_mmx; - rtcd->loopfilter.simple_b_v = vp8_loop_filter_bvs_mmx; - rtcd->loopfilter.simple_mb_h = vp8_loop_filter_simple_horizontal_edge_mmx; - rtcd->loopfilter.simple_b_h = vp8_loop_filter_bhs_mmx; - #if CONFIG_POSTPROC rtcd->postproc.down = vp8_mbpost_proc_down_mmx; /*rtcd->postproc.across = vp8_mbpost_proc_across_ip_c;*/ @@ -77,15 +63,7 @@ void vp8_arch_x86_common_init(VP8_COMMON *ctx) { #if HAVE_SSE2 if (flags & HAS_SSE2) { - rtcd->recon.recon2 = vp8_recon2b_sse2; - rtcd->recon.recon4 = vp8_recon4b_sse2; - /* these are disable because of unsupported diagonal pred modes - rtcd->recon.build_intra_predictors_mbuv = - vp8_build_intra_predictors_mbuv_sse2; - rtcd->recon.build_intra_predictors_mbuv_s = - vp8_build_intra_predictors_mbuv_s_sse2; - */ // rtcd->idct.iwalsh16 = vp8_short_inv_walsh4x4_sse2; @@ -97,15 +75,6 @@ void vp8_arch_x86_common_init(VP8_COMMON *ctx) { rtcd->subpix.bilinear16x16 = vp8_bilinear_predict16x16_sse2; rtcd->subpix.bilinear8x8 = vp8_bilinear_predict8x8_sse2; - rtcd->loopfilter.normal_mb_v = vp8_loop_filter_mbv_sse2; - rtcd->loopfilter.normal_b_v = vp8_loop_filter_bv_sse2; - rtcd->loopfilter.normal_mb_h = vp8_loop_filter_mbh_sse2; - rtcd->loopfilter.normal_b_h = vp8_loop_filter_bh_sse2; - rtcd->loopfilter.simple_mb_v = vp8_loop_filter_simple_vertical_edge_sse2; - rtcd->loopfilter.simple_b_v = vp8_loop_filter_bvs_sse2; - rtcd->loopfilter.simple_mb_h = vp8_loop_filter_simple_horizontal_edge_sse2; - rtcd->loopfilter.simple_b_h = vp8_loop_filter_bhs_sse2; - #if CONFIG_POSTPROC rtcd->postproc.down = vp8_mbpost_proc_down_xmm; rtcd->postproc.across = vp8_mbpost_proc_across_ip_xmm; diff --git a/vp8/decoder/decodframe.c b/vp8/decoder/decodframe.c index f966a06e9..30878cfdf 100644 --- a/vp8/decoder/decodframe.c +++ b/vp8/decoder/decodframe.c @@ -13,7 +13,6 @@ #include "vp8/common/header.h" #include "vp8/common/reconintra.h" #include "vp8/common/reconintra4x4.h" -#include "vp8/common/recon.h" #include "vp8/common/reconinter.h" #include "dequantize.h" #include "detokenize.h" @@ -35,6 +34,7 @@ #include "vp8/common/seg_common.h" #include "vp8/common/entropy.h" +#include "vpx_rtcd.h" #include <assert.h> #include <stdio.h> @@ -173,14 +173,12 @@ static void skip_recon_mb(VP8D_COMP *pbi, MACROBLOCKD *xd) { if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) { #if CONFIG_SUPERBLOCKS if (xd->mode_info_context->mbmi.encoded_as_sb) { - RECON_INVOKE(&pbi->common.rtcd.recon, build_intra_predictors_sbuv_s)(xd); - RECON_INVOKE(&pbi->common.rtcd.recon, - build_intra_predictors_sby_s)(xd); + vp8_build_intra_predictors_sbuv_s(xd); + vp8_build_intra_predictors_sby_s(xd); } else { #endif - RECON_INVOKE(&pbi->common.rtcd.recon, build_intra_predictors_mbuv_s)(xd); - RECON_INVOKE(&pbi->common.rtcd.recon, - build_intra_predictors_mby_s)(xd); + vp8_build_intra_predictors_mbuv_s(xd); + vp8_build_intra_predictors_mby_s(xd); #if CONFIG_SUPERBLOCKS } #endif @@ -331,15 +329,14 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd, if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) { #if CONFIG_SUPERBLOCKS if (xd->mode_info_context->mbmi.encoded_as_sb) { - RECON_INVOKE(&pbi->common.rtcd.recon, build_intra_predictors_sby_s)(xd); - RECON_INVOKE(&pbi->common.rtcd.recon, build_intra_predictors_sbuv_s)(xd); + vp8_build_intra_predictors_sby_s(xd); + vp8_build_intra_predictors_sbuv_s(xd); } else #endif if (mode != I8X8_PRED) { - RECON_INVOKE(&pbi->common.rtcd.recon, build_intra_predictors_mbuv)(xd); + vp8_build_intra_predictors_mbuv(xd); if (mode != B_PRED) { - RECON_INVOKE(&pbi->common.rtcd.recon, - build_intra_predictors_mby)(xd); + vp8_build_intra_predictors_mby(xd); } #if 0 // Intra-modes requiring recon data from top-right @@ -379,8 +376,7 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd, b = &xd->block[ib]; i8x8mode = b->bmi.as_mode.first; - RECON_INVOKE(RTCD_VTABLE(recon), intra8x8_predict)(b, i8x8mode, - b->predictor); + vp8_intra8x8_predict(b, i8x8mode, b->predictor); if (xd->mode_info_context->mbmi.txfm_size == TX_8X8) { #if CONFIG_HYBRIDTRANSFORM8X8 @@ -400,15 +396,13 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd, } b = &xd->block[16 + i]; - RECON_INVOKE(RTCD_VTABLE(recon), intra_uv4x4_predict)(b, i8x8mode, - b->predictor); + vp8_intra_uv4x4_predict(b, i8x8mode, b->predictor); DEQUANT_INVOKE(&pbi->dequant, idct_add)(b->qcoeff, b->dequant, b->predictor, *(b->base_dst) + b->dst, 8, b->dst_stride); b = &xd->block[20 + i]; - RECON_INVOKE(RTCD_VTABLE(recon), intra_uv4x4_predict)(b, i8x8mode, - b->predictor); + vp8_intra_uv4x4_predict(b, i8x8mode, b->predictor); DEQUANT_INVOKE(&pbi->dequant, idct_add)(b->qcoeff, b->dequant, b->predictor, *(b->base_dst) + b->dst, 8, @@ -423,12 +417,10 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd, if (b_mode2 == (B_PREDICTION_MODE)(B_DC_PRED - 1)) { #endif - RECON_INVOKE(RTCD_VTABLE(recon), intra4x4_predict) - (b, b_mode, b->predictor); + vp8_intra4x4_predict(b, b_mode, b->predictor); #if CONFIG_COMP_INTRA_PRED } else { - RECON_INVOKE(RTCD_VTABLE(recon), comp_intra4x4_predict) - (b, b_mode, b_mode2, b->predictor); + vp8_comp_intra4x4_predict(b, b_mode, b_mode2, b->predictor); } #endif @@ -1166,9 +1158,27 @@ int vp8_decode_frame(VP8D_COMP *pbi) { xd->update_mb_segmentation_map = (unsigned char)vp8_read_bit(bc); // If so what method will be used. - if (xd->update_mb_segmentation_map) - pc->temporal_update = (unsigned char)vp8_read_bit(bc); + if (xd->update_mb_segmentation_map) { + // Which macro block level features are enabled + + // Read the probs used to decode the segment id for each macro + // block. + for (i = 0; i < MB_FEATURE_TREE_PROBS; i++) { + xd->mb_segment_tree_probs[i] = vp8_read_bit(bc) ? + (vp8_prob)vp8_read_literal(bc, 8) : 255; + } + // Read the prediction probs needed to decode the segment id + pc->temporal_update = (unsigned char)vp8_read_bit(bc); + for (i = 0; i < PREDICTION_PROBS; i++) { + if (pc->temporal_update) { + pc->segment_pred_probs[i] = vp8_read_bit(bc) ? + (vp8_prob)vp8_read_literal(bc, 8) : 255; + } else { + pc->segment_pred_probs[i] = 255; + } + } + } // Is the segment data being updated xd->update_mb_segmentation_data = (unsigned char)vp8_read_bit(bc); @@ -1233,38 +1243,6 @@ int vp8_decode_frame(VP8D_COMP *pbi) { } } } - - if (xd->update_mb_segmentation_map) { - // Which macro block level features are enabled - vpx_memset(xd->mb_segment_tree_probs, 255, - sizeof(xd->mb_segment_tree_probs)); - vpx_memset(pc->segment_pred_probs, 255, - sizeof(pc->segment_pred_probs)); - - // Read the probs used to decode the segment id for each macro - // block. - for (i = 0; i < MB_FEATURE_TREE_PROBS; i++) { - // If not explicitly set value is defaulted to 255 by - // memset above - if (vp8_read_bit(bc)) - xd->mb_segment_tree_probs[i] = - (vp8_prob)vp8_read_literal(bc, 8); - } - - // If predictive coding of segment map is enabled read the - // prediction probabilities. - if (pc->temporal_update) { - // Read the prediction probs needed to decode the segment id - // when predictive coding enabled - for (i = 0; i < PREDICTION_PROBS; i++) { - // If not explicitly set value is defaulted to 255 by - // memset above - if (vp8_read_bit(bc)) - pc->segment_pred_probs[i] = - (vp8_prob)vp8_read_literal(bc, 8); - } - } - } } // Read common prediction model status flag probability updates for the diff --git a/vp8/decoder/reconintra_mt.c b/vp8/decoder/reconintra_mt.c index f447cb189..ebd1bb314 100644 --- a/vp8/decoder/reconintra_mt.c +++ b/vp8/decoder/reconintra_mt.c @@ -10,7 +10,6 @@ #include "vpx_ports/config.h" -#include "vp8/common/recon.h" #include "vp8/common/reconintra.h" #include "vpx_mem/vpx_mem.h" #include "onyxd_int.h" diff --git a/vp8/encoder/bitstream.c b/vp8/encoder/bitstream.c index 49f2bb973..2657fd2b2 100644 --- a/vp8/encoder/bitstream.c +++ b/vp8/encoder/bitstream.c @@ -2440,9 +2440,33 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) if (xd->update_mb_segmentation_map) { // Select the coding strategy (temporal or spatial) choose_segmap_coding_method(cpi); + // Send the tree probabilities used to decode unpredicted + // macro-block segments + for (i = 0; i < MB_FEATURE_TREE_PROBS; i++) { + int data = xd->mb_segment_tree_probs[i]; + + if (data != 255) { + vp8_write_bit(bc, 1); + vp8_write_literal(bc, data, 8); + } else { + vp8_write_bit(bc, 0); + } + } // Write out the chosen coding method. vp8_write_bit(bc, (pc->temporal_update) ? 1 : 0); + if (pc->temporal_update) { + for (i = 0; i < PREDICTION_PROBS; i++) { + int data = pc->segment_pred_probs[i]; + + if (data != 255) { + vp8_write_bit(bc, 1); + vp8_write_literal(bc, data, 8); + } else { + vp8_write_bit(bc, 0); + } + } + } } vp8_write_bit(bc, (xd->update_mb_segmentation_data) ? 1 : 0); @@ -2536,33 +2560,6 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) save_segment_info(xd); #endif - if (xd->update_mb_segmentation_map) { - // Send the tree probabilities used to decode unpredicted - // macro-block segments - for (i = 0; i < MB_FEATURE_TREE_PROBS; i++) { - int Data = xd->mb_segment_tree_probs[i]; - - if (Data != 255) { - vp8_write_bit(bc, 1); - vp8_write_literal(bc, Data, 8); - } else - vp8_write_bit(bc, 0); - } - - // If predictive coding of segment map is enabled send the - // prediction probabilities. - if (pc->temporal_update) { - for (i = 0; i < PREDICTION_PROBS; i++) { - int Data = pc->segment_pred_probs[i]; - - if (Data != 255) { - vp8_write_bit(bc, 1); - vp8_write_literal(bc, Data, 8); - } else - vp8_write_bit(bc, 0); - } - } - } } // Encode the common prediction model status flag probability updates for diff --git a/vp8/encoder/dct.h b/vp8/encoder/dct.h index 597640d8c..180192bbb 100644 --- a/vp8/encoder/dct.h +++ b/vp8/encoder/dct.h @@ -42,6 +42,7 @@ extern prototype_fdct(vp8_fdct_short16x16); extern prototype_fdct(vp8_fdct_short8x8); #ifndef vp8_fhaar_short2x2 +#define vp8_fdct_haar_short2x2 vp8_fhaar_short2x2 #define vp8_fhaar_short2x2 vp8_short_fhaar2x2_c #endif extern prototype_fdct(vp8_fhaar_short2x2); diff --git a/vp8/encoder/encodeframe.c b/vp8/encoder/encodeframe.c index afabd7165..8a2c56175 100644 --- a/vp8/encoder/encodeframe.c +++ b/vp8/encoder/encodeframe.c @@ -26,6 +26,7 @@ #include "vp8/common/findnearmv.h" #include "vp8/common/reconintra.h" #include "vp8/common/seg_common.h" +#include "vpx_rtcd.h" #include <stdio.h> #include <math.h> #include <limits.h> @@ -1878,8 +1879,8 @@ void vp8cx_encode_intra_super_block(VP8_COMP *cpi, vp8_update_zbin_extra(cpi, x); } - RECON_INVOKE(&rtcd->common->recon, build_intra_predictors_sby_s)(&x->e_mbd); - RECON_INVOKE(&rtcd->common->recon, build_intra_predictors_sbuv_s)(&x->e_mbd); + vp8_build_intra_predictors_sby_s(&x->e_mbd); + vp8_build_intra_predictors_sbuv_s(&x->e_mbd); assert(x->e_mbd.mode_info_context->mbmi.txfm_size == TX_8X8); for (n = 0; n < 4; n++) @@ -1908,9 +1909,8 @@ void vp8cx_encode_intra_super_block(VP8_COMP *cpi, vp8_optimize_mbuv_8x8(x, rtcd); } vp8_inverse_transform_mb_8x8(IF_RTCD(&rtcd->common->idct), &x->e_mbd); - vp8_recon_mby_s_c(IF_RTCD(&rtcd->common->recon), &x->e_mbd, - dst + x_idx * 16 + y_idx * 16 * dst_y_stride); - vp8_recon_mbuv_s_c(IF_RTCD(&rtcd->common->recon), &x->e_mbd, + vp8_recon_mby_s_c(&x->e_mbd, dst + x_idx * 16 + y_idx * 16 * dst_y_stride); + vp8_recon_mbuv_s_c(&x->e_mbd, udst + x_idx * 8 + y_idx * 8 * dst_uv_stride, vdst + x_idx * 8 + y_idx * 8 * dst_uv_stride); @@ -2244,8 +2244,8 @@ void vp8cx_encode_inter_superblock(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t, set_pred_flag(xd, PRED_REF, ref_pred_flag); if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) { - RECON_INVOKE(&rtcd->common->recon, build_intra_predictors_sby_s)(&x->e_mbd); - RECON_INVOKE(&rtcd->common->recon, build_intra_predictors_sbuv_s)(&x->e_mbd); + vp8_build_intra_predictors_sby_s(&x->e_mbd); + vp8_build_intra_predictors_sbuv_s(&x->e_mbd); } else { int ref_fb_idx; @@ -2307,9 +2307,9 @@ void vp8cx_encode_inter_superblock(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t, vp8_optimize_mbuv_8x8(x, rtcd); } vp8_inverse_transform_mb_8x8(IF_RTCD(&rtcd->common->idct), &x->e_mbd); - vp8_recon_mby_s_c(IF_RTCD(&rtcd->common->recon), &x->e_mbd, + vp8_recon_mby_s_c( &x->e_mbd, dst + x_idx * 16 + y_idx * 16 * dst_y_stride); - vp8_recon_mbuv_s_c(IF_RTCD(&rtcd->common->recon), &x->e_mbd, + vp8_recon_mbuv_s_c(&x->e_mbd, udst + x_idx * 8 + y_idx * 8 * dst_uv_stride, vdst + x_idx * 8 + y_idx * 8 * dst_uv_stride); diff --git a/vp8/encoder/encodeintra.c b/vp8/encoder/encodeintra.c index 8021055d1..703a1015e 100644 --- a/vp8/encoder/encodeintra.c +++ b/vp8/encoder/encodeintra.c @@ -15,10 +15,10 @@ #include "vp8/common/reconintra4x4.h" #include "encodemb.h" #include "vp8/common/invtrans.h" -#include "vp8/common/recon.h" #include "dct.h" #include "vp8/common/g_common.h" #include "encodeintra.h" +#include "vpx_rtcd.h" #if CONFIG_RUNTIME_CPU_DETECT #define IF_RTCD(x) (x) @@ -61,12 +61,11 @@ void vp8_encode_intra4x4block(const VP8_ENCODER_RTCD *rtcd, #if CONFIG_COMP_INTRA_PRED if (b->bmi.as_mode.second == (B_PREDICTION_MODE)(B_DC_PRED - 1)) { #endif - RECON_INVOKE(&rtcd->common->recon, intra4x4_predict) - (b, b->bmi.as_mode.first, b->predictor); + vp8_intra4x4_predict(b, b->bmi.as_mode.first, b->predictor); #if CONFIG_COMP_INTRA_PRED } else { - RECON_INVOKE(&rtcd->common->recon, comp_intra4x4_predict) - (b, b->bmi.as_mode.first, b->bmi.as_mode.second, b->predictor); + vp8_comp_intra4x4_predict(b, b->bmi.as_mode.first, b->bmi.as_mode.second, + b->predictor); } #endif @@ -86,7 +85,7 @@ void vp8_encode_intra4x4block(const VP8_ENCODER_RTCD *rtcd, vp8_inverse_transform_b_4x4(IF_RTCD(&rtcd->common->idct), b, 32) ; } - RECON_INVOKE(&rtcd->common->recon, recon)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride); + vp8_recon_b(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride); } void vp8_encode_intra4x4mby(const VP8_ENCODER_RTCD *rtcd, MACROBLOCK *mb) { @@ -114,10 +113,10 @@ void vp8_encode_intra16x16mby(const VP8_ENCODER_RTCD *rtcd, MACROBLOCK *x) { #if CONFIG_COMP_INTRA_PRED if (xd->mode_info_context->mbmi.second_mode == (MB_PREDICTION_MODE)(DC_PRED - 1)) #endif - RECON_INVOKE(&rtcd->common->recon, build_intra_predictors_mby)(xd); + vp8_build_intra_predictors_mby(xd); #if CONFIG_COMP_INTRA_PRED else - RECON_INVOKE(&rtcd->common->recon, build_comp_intra_predictors_mby)(xd); + vp8_build_comp_intra_predictors_mby(xd); #endif ENCODEMB_INVOKE(&rtcd->encodemb, submby)(x->src_diff, *(b->base_src), @@ -158,8 +157,7 @@ void vp8_encode_intra16x16mby(const VP8_ENCODER_RTCD *rtcd, MACROBLOCK *x) { vp8_inverse_transform_mby_4x4(IF_RTCD(&rtcd->common->idct), xd); } - RECON_INVOKE(&rtcd->common->recon, recon_mby)(IF_RTCD(&rtcd->common->recon), - xd); + vp8_recon_mby(xd); } void vp8_encode_intra16x16mbuv(const VP8_ENCODER_RTCD *rtcd, MACROBLOCK *x) { @@ -169,10 +167,10 @@ void vp8_encode_intra16x16mbuv(const VP8_ENCODER_RTCD *rtcd, MACROBLOCK *x) { #if CONFIG_COMP_INTRA_PRED if (xd->mode_info_context->mbmi.second_uv_mode == (MB_PREDICTION_MODE)(DC_PRED - 1)) { #endif - RECON_INVOKE(&rtcd->common->recon, build_intra_predictors_mbuv)(xd); + vp8_build_intra_predictors_mbuv(xd); #if CONFIG_COMP_INTRA_PRED } else { - RECON_INVOKE(&rtcd->common->recon, build_comp_intra_predictors_mbuv)(xd); + vp8_build_comp_intra_predictors_mbuv(xd); } #endif @@ -193,7 +191,7 @@ void vp8_encode_intra16x16mbuv(const VP8_ENCODER_RTCD *rtcd, MACROBLOCK *x) { vp8_inverse_transform_mbuv_8x8(IF_RTCD(&rtcd->common->idct), xd); } - vp8_recon_intra_mbuv(IF_RTCD(&rtcd->common->recon), xd); + vp8_recon_intra_mbuv(xd); } void vp8_encode_intra8x8(const VP8_ENCODER_RTCD *rtcd, @@ -207,12 +205,11 @@ void vp8_encode_intra8x8(const VP8_ENCODER_RTCD *rtcd, #if CONFIG_COMP_INTRA_PRED if (b->bmi.as_mode.second == (MB_PREDICTION_MODE)(DC_PRED - 1)) { #endif - RECON_INVOKE(&rtcd->common->recon, intra8x8_predict) - (b, b->bmi.as_mode.first, b->predictor); + vp8_intra8x8_predict(b, b->bmi.as_mode.first, b->predictor); #if CONFIG_COMP_INTRA_PRED } else { - RECON_INVOKE(&rtcd->common->recon, comp_intra8x8_predict) - (b, b->bmi.as_mode.first, b->bmi.as_mode.second, b->predictor); + vp8_comp_intra8x8_predict(b, b->bmi.as_mode.first, b->bmi.as_mode.second, + b->predictor); } #endif @@ -271,12 +268,10 @@ void vp8_encode_intra_uv4x4(const VP8_ENCODER_RTCD *rtcd, #if CONFIG_COMP_INTRA_PRED if (second == -1) { #endif - RECON_INVOKE(&rtcd->common->recon, intra_uv4x4_predict) - (b, mode, b->predictor); + vp8_intra_uv4x4_predict(b, mode, b->predictor); #if CONFIG_COMP_INTRA_PRED } else { - RECON_INVOKE(&rtcd->common->recon, comp_intra_uv4x4_predict) - (b, mode, second, b->predictor); + vp8_comp_intra_uv4x4_predict(b, mode, second, b->predictor); } #endif @@ -286,8 +281,7 @@ void vp8_encode_intra_uv4x4(const VP8_ENCODER_RTCD *rtcd, x->quantize_b_4x4(be, b); vp8_inverse_transform_b_4x4(IF_RTCD(&rtcd->common->idct), b, 16); - RECON_INVOKE(&rtcd->common->recon, recon_uv)(b->predictor, - b->diff, *(b->base_dst) + b->dst, b->dst_stride); + vp8_recon_uv_b_c(b->predictor,b->diff, *(b->base_dst) + b->dst, b->dst_stride); } void vp8_encode_intra8x8mbuv(const VP8_ENCODER_RTCD *rtcd, MACROBLOCK *x) { diff --git a/vp8/encoder/encodemb.c b/vp8/encoder/encodemb.c index 5abf69d2f..50de2f2c0 100644 --- a/vp8/encoder/encodemb.c +++ b/vp8/encoder/encodemb.c @@ -14,7 +14,6 @@ #include "quantize.h" #include "tokenize.h" #include "vp8/common/invtrans.h" -#include "vp8/common/recon.h" #include "vp8/common/reconintra.h" #include "dct.h" #include "vpx_mem/vpx_mem.h" @@ -914,8 +913,7 @@ void vp8_encode_inter16x16(const VP8_ENCODER_RTCD *rtcd, MACROBLOCK *x) { vp8_inverse_transform_mb_4x4(IF_RTCD(&rtcd->common->idct), xd); } - RECON_INVOKE(&rtcd->common->recon, recon_mb)(IF_RTCD(&rtcd->common->recon), - xd); + vp8_recon_mb(xd); } /* this function is used by first pass only */ @@ -937,6 +935,5 @@ void vp8_encode_inter16x16y(const VP8_ENCODER_RTCD *rtcd, MACROBLOCK *x) { vp8_quantize_mby_4x4(x); vp8_inverse_transform_mby_4x4(IF_RTCD(&rtcd->common->idct), xd); - RECON_INVOKE(&rtcd->common->recon, recon_mby)(IF_RTCD(&rtcd->common->recon), - xd); + vp8_recon_mby(xd); } diff --git a/vp8/encoder/generic/csystemdependent.c b/vp8/encoder/generic/csystemdependent.c index 56199d902..356e32c3f 100644 --- a/vp8/encoder/generic/csystemdependent.c +++ b/vp8/encoder/generic/csystemdependent.c @@ -118,13 +118,18 @@ void vp8_cmachine_specific_config(VP8_COMP *cpi) { cpi->rtcd.search.refining_search = vp8_refining_search_sad; cpi->rtcd.search.diamond_search = vp8_diamond_search_sad; cpi->rtcd.temporal.apply = vp8_temporal_filter_apply_c; + cpi->rtcd.variance.satd16x16 = vp8_satd16x16_c; + cpi->rtcd.fdct.short4x4 = vp8_short_fdct4x4_c; + cpi->rtcd.fdct.short8x4 = vp8_short_fdct8x4_c; + cpi->rtcd.fdct.fast4x4 = vp8_short_fdct4x4_c; + cpi->rtcd.fdct.fast8x4 = vp8_short_fdct8x4_c; + cpi->rtcd.fdct.walsh_short4x4 = vp8_short_walsh4x4_c; #if CONFIG_INTERNAL_STATS cpi->rtcd.variance.ssimpf_8x8 = vp8_ssim_parms_8x8_c; cpi->rtcd.variance.ssimpf_16x16 = vp8_ssim_parms_16x16_c; #endif #endif - cpi->rtcd.variance.satd16x16 = vp8_satd16x16_c; vp8_yv12_copy_partial_frame_ptr = vp8_yv12_copy_partial_frame; #if ARCH_X86 || ARCH_X86_64 @@ -135,10 +140,5 @@ void vp8_cmachine_specific_config(VP8_COMP *cpi) { vp8_arch_arm_encoder_init(cpi); #endif - cpi->rtcd.fdct.short4x4 = vp8_short_fdct4x4_c; - cpi->rtcd.fdct.short8x4 = vp8_short_fdct8x4_c; - cpi->rtcd.fdct.fast4x4 = vp8_short_fdct4x4_c; - cpi->rtcd.fdct.fast8x4 = vp8_short_fdct8x4_c; - cpi->rtcd.fdct.walsh_short4x4 = vp8_short_walsh4x4_c; } diff --git a/vp8/encoder/mbgraph.c b/vp8/encoder/mbgraph.c index d512ae4bc..180ee5870 100644 --- a/vp8/encoder/mbgraph.c +++ b/vp8/encoder/mbgraph.c @@ -220,7 +220,7 @@ static int find_best_16x16_intra unsigned int err; xd->mode_info_context->mbmi.mode = mode; - RECON_INVOKE(&cpi->rtcd.common->recon, build_intra_predictors_mby)(xd); + vp8_build_intra_predictors_mby(xd); // VARIANCE_INVOKE(&cpi->rtcd.variance, satd16x16) err = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16) (xd->predictor, 16, diff --git a/vp8/encoder/onyx_if.c b/vp8/encoder/onyx_if.c index fc35757c9..cf9989d8b 100644 --- a/vp8/encoder/onyx_if.c +++ b/vp8/encoder/onyx_if.c @@ -4412,8 +4412,9 @@ int vp8_get_compressed_data(VP8_PTR ptr, unsigned int *frame_flags, unsigned lon { double frame_psnr2, frame_ssim2 = 0; double weight = 0; - +#if CONFIG_POSTPROC vp8_deblock(cm->frame_to_show, &cm->post_proc_buffer, cm->filter_level * 10 / 6, 1, 0, IF_RTCD(&cm->rtcd.postproc)); +#endif vp8_clear_system_state(); ye = calc_plane_error(orig->y_buffer, orig->y_stride, diff --git a/vp8/encoder/rdopt.c b/vp8/encoder/rdopt.c index 91f3f1a6d..22da82a79 100644 --- a/vp8/encoder/rdopt.c +++ b/vp8/encoder/rdopt.c @@ -1188,12 +1188,10 @@ static int64_t rd_pick_intra4x4block(VP8_COMP *cpi, MACROBLOCK *x, BLOCK *be, #if CONFIG_COMP_INTRA_PRED if (mode2 == (B_PREDICTION_MODE)(B_DC_PRED - 1)) { #endif - RECON_INVOKE(&cpi->rtcd.common->recon, intra4x4_predict) - (b, mode, b->predictor); + vp8_intra4x4_predict(b, mode, b->predictor); #if CONFIG_COMP_INTRA_PRED } else { - RECON_INVOKE(&cpi->rtcd.common->recon, comp_intra4x4_predict) - (b, mode, mode2, b->predictor); + vp8_comp_intra4x4_predict(b, mode, mode2, b->predictor); rate += bmode_costs[mode2]; } #endif @@ -1263,7 +1261,7 @@ static int64_t rd_pick_intra4x4block(VP8_COMP *cpi, MACROBLOCK *x, BLOCK *be, IDCT_INVOKE(IF_RTCD(&cpi->rtcd.common->idct), idct16)(best_dqcoeff, b->diff, 32); #endif - RECON_INVOKE(IF_RTCD(&cpi->rtcd.common->recon), recon)(best_predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride); + vp8_recon_b(best_predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride); return best_rd; } @@ -1369,8 +1367,7 @@ static int64_t rd_pick_intra_sby_mode(VP8_COMP *cpi, /* Y Search for 32x32 intra prediction mode */ for (mode = DC_PRED; mode <= TM_PRED; mode++) { x->e_mbd.mode_info_context->mbmi.mode = mode; - RECON_INVOKE(&cpi->common.rtcd.recon, - build_intra_predictors_sby_s)(&x->e_mbd); + vp8_build_intra_predictors_sby_s(&x->e_mbd); super_block_yrd_8x8(x, &this_rate_tokenonly, &this_distortion, IF_RTCD(&cpi->rtcd), &s); @@ -1436,13 +1433,11 @@ static int64_t rd_pick_intra16x16mby_mode(VP8_COMP *cpi, mbmi->second_mode = mode2; if (mode2 == (MB_PREDICTION_MODE)(DC_PRED - 1)) { #endif - RECON_INVOKE(&cpi->common.rtcd.recon, build_intra_predictors_mby) - (&x->e_mbd); + vp8_build_intra_predictors_mby(&x->e_mbd); #if CONFIG_COMP_INTRA_PRED } else { continue; // i.e. disable for now - RECON_INVOKE(&cpi->common.rtcd.recon, build_comp_intra_predictors_mby) - (&x->e_mbd); + vp8_build_comp_intra_predictors_mby(&x->e_mbd); } #endif @@ -1548,13 +1543,11 @@ static int64_t rd_pick_intra8x8block(VP8_COMP *cpi, MACROBLOCK *x, int ib, #if CONFIG_COMP_INTRA_PRED if (mode2 == (MB_PREDICTION_MODE)(DC_PRED - 1)) { #endif - RECON_INVOKE(&cpi->rtcd.common->recon, intra8x8_predict) - (b, mode, b->predictor); + vp8_intra8x8_predict(b, mode, b->predictor); #if CONFIG_COMP_INTRA_PRED } else { continue; // i.e. disable for now - RECON_INVOKE(&cpi->rtcd.common->recon, comp_intra8x8_predict) - (b, mode, mode2, b->predictor); + vp8_comp_intra8x8_predict(b, mode, mode2, b->predictor); } #endif @@ -1891,13 +1884,11 @@ static void rd_pick_intra_mbuv_mode(VP8_COMP *cpi, mbmi->second_uv_mode = mode2; if (mode2 == (MB_PREDICTION_MODE)(DC_PRED - 1)) { #endif - RECON_INVOKE(&cpi->rtcd.common->recon, build_intra_predictors_mbuv) - (&x->e_mbd); + vp8_build_intra_predictors_mbuv(&x->e_mbd); #if CONFIG_COMP_INTRA_PRED } else { continue; - RECON_INVOKE(&cpi->rtcd.common->recon, build_comp_intra_predictors_mbuv) - (&x->e_mbd); + vp8_build_comp_intra_predictors_mbuv(&x->e_mbd); } #endif @@ -1959,8 +1950,7 @@ static void rd_pick_intra_mbuv_mode_8x8(VP8_COMP *cpi, int64_t this_rd; mbmi->uv_mode = mode; - RECON_INVOKE(&cpi->rtcd.common->recon, build_intra_predictors_mbuv) - (&x->e_mbd); + vp8_build_intra_predictors_mbuv(&x->e_mbd); ENCODEMB_INVOKE(IF_RTCD(&cpi->rtcd.encodemb), submbuv)(x->src_diff, x->src.u_buffer, x->src.v_buffer, x->e_mbd.predictor, x->src.uv_stride); @@ -2053,8 +2043,7 @@ static int64_t rd_pick_intra_sbuv_mode(VP8_COMP *cpi, for (mode = DC_PRED; mode <= TM_PRED; mode++) { x->e_mbd.mode_info_context->mbmi.uv_mode = mode; - RECON_INVOKE(&cpi->rtcd.common->recon, - build_intra_predictors_sbuv_s)(&x->e_mbd); + vp8_build_intra_predictors_sbuv_s(&x->e_mbd); super_block_uvrd_8x8(x, &this_rate_tokenonly, &this_distortion, IF_RTCD(&cpi->rtcd), &s); @@ -2210,30 +2199,19 @@ static int labels2mode( return cost; } -static int rdcost_mbsegment_y(MACROBLOCK *mb, const int *labels, - int which_label, ENTROPY_CONTEXT *ta, - ENTROPY_CONTEXT *tl) { - int b, cost = 0; - MACROBLOCKD *xd = &mb->e_mbd; - - for (b = 0; b < 16; b++) - if (labels[ b] == which_label) - cost += cost_coeffs(mb, xd->block + b, PLANE_TYPE_Y_WITH_DC, - ta + vp8_block2above[b], - tl + vp8_block2left[b], TX_4X4); - - return cost; - -} - -static unsigned int vp8_encode_inter_mb_segment(MACROBLOCK *x, - int const *labels, - int which_label, - const VP8_ENCODER_RTCD *rtcd) { +static int64_t encode_inter_mb_segment(MACROBLOCK *x, + int const *labels, + int which_label, + int *labelyrate, + int *distortion, + ENTROPY_CONTEXT *ta, + ENTROPY_CONTEXT *tl, + const VP8_ENCODER_RTCD *rtcd) { int i; - unsigned int distortion = 0; MACROBLOCKD *xd = &x->e_mbd; + *labelyrate = 0; + *distortion = 0; for (i = 0; i < 16; i++) { if (labels[i] == which_label) { BLOCKD *bd = &x->e_mbd.block[i]; @@ -2245,18 +2223,65 @@ static unsigned int vp8_encode_inter_mb_segment(MACROBLOCK *x, vp8_build_2nd_inter_predictors_b(bd, 16, xd->subpixel_predict_avg); ENCODEMB_INVOKE(&rtcd->encodemb, subb)(be, bd, 16); x->vp8_short_fdct4x4(be->src_diff, be->coeff, 32); - - // set to 0 no way to account for 2nd order DC so discount - // be->coeff[0] = 0; x->quantize_b_4x4(be, bd); - thisdistortion = ENCODEMB_INVOKE(&rtcd->encodemb, berr)( - be->coeff, bd->dqcoeff, 16) / 4; - distortion += thisdistortion; + thisdistortion = vp8_block_error_c(be->coeff, bd->dqcoeff, 16); + *distortion += thisdistortion; + *labelyrate += cost_coeffs(x, bd, PLANE_TYPE_Y_WITH_DC, + ta + vp8_block2above[i], + tl + vp8_block2left[i], TX_4X4); } } - return distortion; + *distortion >>= 2; + return RDCOST(x->rdmult, x->rddiv, *labelyrate, *distortion); } +static int64_t encode_inter_mb_segment_8x8(MACROBLOCK *x, + int const *labels, + int which_label, + int *labelyrate, + int *distortion, + ENTROPY_CONTEXT *ta, + ENTROPY_CONTEXT *tl, + const VP8_ENCODER_RTCD *rtcd) { + int i, j; + MACROBLOCKD *xd = &x->e_mbd; + const int iblock[4] = { 0, 1, 4, 5 }; + + *distortion = 0; + *labelyrate = 0; + for (i = 0; i < 4; i++) { + int ib = vp8_i8x8_block[i]; + + if (labels[ib] == which_label) { + BLOCKD *bd = &xd->block[ib]; + BLOCK *be = &x->block[ib]; + int thisdistortion; + + vp8_build_inter_predictors4b(xd, bd, 16); + if (xd->mode_info_context->mbmi.second_ref_frame) + vp8_build_2nd_inter_predictors4b(xd, bd, 16); + vp8_subtract_4b_c(be, bd, 16); + + for (j = 0; j < 4; j += 2) { + bd = &xd->block[ib + iblock[j]]; + be = &x->block[ib + iblock[j]]; + x->vp8_short_fdct8x4(be->src_diff, be->coeff, 32); + x->quantize_b_4x4_pair(be, be + 1, bd, bd + 1); + thisdistortion = vp8_block_error_c(be->coeff, bd->dqcoeff, 32); + *distortion += thisdistortion; + *labelyrate += cost_coeffs(x, bd, PLANE_TYPE_Y_WITH_DC, + ta + vp8_block2above[ib + iblock[j]], + tl + vp8_block2left[ib + iblock[j]], TX_4X4); + *labelyrate += cost_coeffs(x, bd + 1, PLANE_TYPE_Y_WITH_DC, + ta + vp8_block2above[ib + iblock[j] + 1], + tl + vp8_block2left[ib + iblock[j]], + TX_4X4); + } + } + } + *distortion >>= 2; + return RDCOST(x->rdmult, x->rddiv, *labelyrate, *distortion); +} static const unsigned int segmentation_to_sseshift[4] = {3, 3, 2, 0}; @@ -2465,15 +2490,18 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x, mv_check_bounds(x, &second_mode_mv[this_mode])) continue; - distortion = vp8_encode_inter_mb_segment( - x, labels, i, - IF_RTCD(&cpi->rtcd)); - - labelyrate = rdcost_mbsegment_y(x, labels, i, ta_s, tl_s); + if (segmentation == BLOCK_4X4) { + this_rd = encode_inter_mb_segment(x, labels, i, &labelyrate, + &distortion, + ta_s, tl_s, IF_RTCD(&cpi->rtcd)); + } else { + this_rd = encode_inter_mb_segment_8x8(x, labels, i, &labelyrate, + &distortion, ta_s, tl_s, + IF_RTCD(&cpi->rtcd)); + } + this_rd += RDCOST(x->rdmult, x->rddiv, rate, 0); rate += labelyrate; - this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion); - if (this_rd < best_label_rd) { sbr = rate; sbd = distortion; @@ -3555,8 +3583,7 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int case D63_PRED: mbmi->ref_frame = INTRA_FRAME; // FIXME compound intra prediction - RECON_INVOKE(&cpi->common.rtcd.recon, build_intra_predictors_mby) - (&x->e_mbd); + vp8_build_intra_predictors_mby(&x->e_mbd); macro_block_yrd(cpi, x, &rate_y, &distortion, &skippable, txfm_cache); #if CONFIG_HYBRIDTRANSFORM16X16 rd_txtype = x->e_mbd.block[0].bmi.as_mode.tx_type; diff --git a/vp8/encoder/temporal_filter.c b/vp8/encoder/temporal_filter.c index 6bc24a01f..e59aa14fa 100644 --- a/vp8/encoder/temporal_filter.c +++ b/vp8/encoder/temporal_filter.c @@ -79,8 +79,8 @@ static void vp8_temporal_filter_predictors_mb_c (omv_col & 15), (omv_row & 15), &pred[320], 8); } else { - RECON_INVOKE(&xd->rtcd->recon, copy8x8)(uptr, stride, &pred[256], 8); - RECON_INVOKE(&xd->rtcd->recon, copy8x8)(vptr, stride, &pred[320], 8); + vp8_copy_mem8x8(uptr, stride, &pred[256], 8); + vp8_copy_mem8x8(vptr, stride, &pred[320], 8); } } void vp8_temporal_filter_apply_c diff --git a/vp8/encoder/x86/x86_csystemdependent.c b/vp8/encoder/x86/x86_csystemdependent.c index 146888a1f..71c51c14f 100644 --- a/vp8/encoder/x86/x86_csystemdependent.c +++ b/vp8/encoder/x86/x86_csystemdependent.c @@ -115,13 +115,6 @@ void vp8_arch_x86_encoder_init(VP8_COMP *cpi) { cpi->rtcd.variance.mse16x16 = vp8_mse16x16_mmx; cpi->rtcd.variance.getmbss = vp8_get_mb_ss_mmx; - cpi->rtcd.fdct.short4x4 = vp8_short_fdct4x4_mmx; - cpi->rtcd.fdct.short8x4 = vp8_short_fdct8x4_mmx; - cpi->rtcd.fdct.fast4x4 = vp8_short_fdct4x4_mmx; - cpi->rtcd.fdct.fast8x4 = vp8_short_fdct8x4_mmx; - - cpi->rtcd.fdct.walsh_short4x4 = vp8_short_walsh4x4_c; - cpi->rtcd.encodemb.berr = vp8_block_error_mmx; cpi->rtcd.encodemb.mberr = vp8_mbblock_error_mmx; cpi->rtcd.encodemb.mbuverr = vp8_mbuverror_mmx; @@ -159,13 +152,6 @@ void vp8_arch_x86_encoder_init(VP8_COMP *cpi) { cpi->rtcd.variance.mse16x16 = vp8_mse16x16_wmt; cpi->rtcd.variance.getmbss = vp8_get_mb_ss_sse2; - cpi->rtcd.fdct.short4x4 = vp8_short_fdct4x4_sse2; - cpi->rtcd.fdct.short8x4 = vp8_short_fdct8x4_sse2; - cpi->rtcd.fdct.fast4x4 = vp8_short_fdct4x4_sse2; - cpi->rtcd.fdct.fast8x4 = vp8_short_fdct8x4_sse2; - - cpi->rtcd.fdct.walsh_short4x4 = vp8_short_walsh4x4_sse2; - cpi->rtcd.encodemb.berr = vp8_block_error_xmm; cpi->rtcd.encodemb.mberr = vp8_mbblock_error_xmm; cpi->rtcd.encodemb.mbuverr = vp8_mbuverror_xmm; diff --git a/vp8/vp8_common.mk b/vp8/vp8_common.mk index f04bc3497..25c4fe210 100644 --- a/vp8/vp8_common.mk +++ b/vp8/vp8_common.mk @@ -48,7 +48,6 @@ VP8_COMMON_SRCS-yes += common/onyxc_int.h VP8_COMMON_SRCS-yes += common/pred_common.h VP8_COMMON_SRCS-yes += common/pred_common.c VP8_COMMON_SRCS-yes += common/quant_common.h -VP8_COMMON_SRCS-yes += common/recon.h VP8_COMMON_SRCS-yes += common/reconinter.h VP8_COMMON_SRCS-yes += common/reconintra.h VP8_COMMON_SRCS-yes += common/reconintra4x4.h @@ -82,7 +81,6 @@ VP8_COMMON_SRCS-yes += common/implicit_segmentation.c VP8_COMMON_SRCS-$(ARCH_X86)$(ARCH_X86_64) += common/x86/idct_x86.h VP8_COMMON_SRCS-$(ARCH_X86)$(ARCH_X86_64) += common/x86/subpixel_x86.h -VP8_COMMON_SRCS-$(ARCH_X86)$(ARCH_X86_64) += common/x86/recon_x86.h VP8_COMMON_SRCS-$(ARCH_X86)$(ARCH_X86_64) += common/x86/loopfilter_x86.h VP8_COMMON_SRCS-$(ARCH_X86)$(ARCH_X86_64) += common/x86/postproc_x86.h VP8_COMMON_SRCS-$(ARCH_X86)$(ARCH_X86_64) += common/x86/x86_systemdependent.c diff --git a/vp8/vp8cx.mk b/vp8/vp8cx.mk index 3b804b7b1..7058e316b 100644 --- a/vp8/vp8cx.mk +++ b/vp8/vp8cx.mk @@ -79,8 +79,10 @@ VP8_CX_SRCS-$(CONFIG_INTERNAL_STATS) += encoder/ssim.c VP8_CX_SRCS-yes += encoder/tokenize.c VP8_CX_SRCS-yes += encoder/treewriter.c VP8_CX_SRCS-yes += encoder/variance_c.c +ifeq ($(CONFIG_POSTPROC),yes) VP8_CX_SRCS-$(CONFIG_INTERNAL_STATS) += common/postproc.h VP8_CX_SRCS-$(CONFIG_INTERNAL_STATS) += common/postproc.c +endif VP8_CX_SRCS-yes += encoder/temporal_filter.c VP8_CX_SRCS-yes += encoder/temporal_filter.h VP8_CX_SRCS-yes += encoder/mbgraph.c |