ref: fb027a765800b4f725181ef03442346bfaaf78ce
parent: 059f2929e9aa8a46e7eadb4fa35eb56c1fc8393e
author: Jim Bankoski <jimbankoski@google.com>
date: Tue Jul 9 15:55:07 EDT 2013
removing case statements around prediction entropy coding Removes SEG_ID Removes MBSKIP Removes SWITCHABLE_INTERP Removes INTRA_INTER Removes COMP_INTER_INTER Removes COMP_REF_P Removes SINGLE_REF_P1 Removes SINGLE_REF_P2 Removes TX_SIZE Change-Id: Ie4520ae1f65c8cac312432c0616cc80dea5bf34b
--- a/vp9/common/vp9_pred_common.c
+++ b/vp9/common/vp9_pred_common.c
@@ -16,15 +16,28 @@
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_treecoder.h"
-// TBD prediction functions for various bitstream signals
+void vp9_set_pred_flag_seg_id(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize,
+ unsigned char pred_flag) {+ const int mis = xd->mode_info_stride;
+ const int bh = 1 << mi_height_log2(bsize);
+ const int bw = 1 << mi_width_log2(bsize);
+#define sub(a, b) (b) < 0 ? (a) + (b) : (a)
+ const int x_mis = sub(bw, xd->mb_to_right_edge >> (3 + LOG2_MI_SIZE));
+ const int y_mis = sub(bh, xd->mb_to_bottom_edge >> (3 + LOG2_MI_SIZE));
+#undef sub
+ int x, y;
+ for (y = 0; y < y_mis; y++)
+ for (x = 0; x < x_mis; x++)
+ xd->mode_info_context[y * mis + x].mbmi.seg_id_predicted = pred_flag;
+}
// Returns a context number for the given MB prediction signal
-unsigned char vp9_get_pred_context(const VP9_COMMON *cm, const MACROBLOCKD *xd,
- PRED_ID pred_id) {+unsigned char vp9_get_pred_context_switchable_interp(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd) {int pred_context;
- const MODE_INFO *const mi = xd->mode_info_context;
- const MODE_INFO *const above_mi = mi - cm->mode_info_stride;
- const MODE_INFO *const left_mi = mi - 1;
+ const MODE_INFO * const mi = xd->mode_info_context;
+ const MODE_INFO * const above_mi = mi - cm->mode_info_stride;
+ const MODE_INFO * const left_mi = mi - 1;
const int left_in_image = xd->left_available && left_mi->mbmi.mb_in_image;
const int above_in_image = xd->up_available && above_mi->mbmi.mb_in_image;
// Note:
@@ -31,431 +44,424 @@
// The mode info data structure has a one element border above and to the
// left of the entries correpsonding to real macroblocks.
// The prediction flags in these dummy entries are initialised to 0.
- switch (pred_id) {- case PRED_SEG_ID:
- pred_context = above_mi->mbmi.seg_id_predicted;
- if (xd->left_available)
- pred_context += left_mi->mbmi.seg_id_predicted;
- break;
+ // left
+ const int left_mv_pred = is_inter_mode(left_mi->mbmi.mode);
+ const int left_interp =
+ left_in_image && left_mv_pred ?
+ vp9_switchable_interp_map[left_mi->mbmi.interp_filter] :
+ VP9_SWITCHABLE_FILTERS;
- case PRED_MBSKIP:
- pred_context = above_mi->mbmi.mb_skip_coeff;
- if (xd->left_available)
- pred_context += left_mi->mbmi.mb_skip_coeff;
- break;
+ // above
+ const int above_mv_pred = is_inter_mode(above_mi->mbmi.mode);
+ const int above_interp =
+ above_in_image && above_mv_pred ?
+ vp9_switchable_interp_map[above_mi->mbmi.interp_filter] :
+ VP9_SWITCHABLE_FILTERS;
- case PRED_SWITCHABLE_INTERP: {- // left
- const int left_mv_pred = is_inter_mode(left_mi->mbmi.mode);
- const int left_interp = left_in_image && left_mv_pred ?
- vp9_switchable_interp_map[left_mi->mbmi.interp_filter] :
- VP9_SWITCHABLE_FILTERS;
+ assert(left_interp != -1);
+ assert(above_interp != -1);
- // above
- const int above_mv_pred = is_inter_mode(above_mi->mbmi.mode);
- const int above_interp = above_in_image && above_mv_pred ?
- vp9_switchable_interp_map[above_mi->mbmi.interp_filter] :
- VP9_SWITCHABLE_FILTERS;
+ if (left_interp == above_interp)
+ pred_context = left_interp;
+ else if (left_interp == VP9_SWITCHABLE_FILTERS
+ && above_interp != VP9_SWITCHABLE_FILTERS)
+ pred_context = above_interp;
+ else if (left_interp != VP9_SWITCHABLE_FILTERS
+ && above_interp == VP9_SWITCHABLE_FILTERS)
+ pred_context = left_interp;
+ else
+ pred_context = VP9_SWITCHABLE_FILTERS;
- assert(left_interp != -1);
- assert(above_interp != -1);
-
- if (left_interp == above_interp)
- pred_context = left_interp;
- else if (left_interp == VP9_SWITCHABLE_FILTERS &&
- above_interp != VP9_SWITCHABLE_FILTERS)
- pred_context = above_interp;
- else if (left_interp != VP9_SWITCHABLE_FILTERS &&
- above_interp == VP9_SWITCHABLE_FILTERS)
- pred_context = left_interp;
- else
- pred_context = VP9_SWITCHABLE_FILTERS;
-
- break;
+ return pred_context;
+}
+// Returns a context number for the given MB prediction signal
+unsigned char vp9_get_pred_context_intra_inter(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd) {+ int pred_context;
+ const MODE_INFO *const mi = xd->mode_info_context;
+ const MODE_INFO *const above_mi = mi - cm->mode_info_stride;
+ const MODE_INFO *const left_mi = mi - 1;
+ const int left_in_image = xd->left_available && left_mi->mbmi.mb_in_image;
+ const int above_in_image = xd->up_available && above_mi->mbmi.mb_in_image;
+ // Note:
+ // The mode info data structure has a one element border above and to the
+ // left of the entries correpsonding to real macroblocks.
+ // The prediction flags in these dummy entries are initialised to 0.
+ if (above_in_image && left_in_image) { // both edges available+ if (left_mi->mbmi.ref_frame[0] == INTRA_FRAME &&
+ above_mi->mbmi.ref_frame[0] == INTRA_FRAME) { // intra/intra (3)+ pred_context = 3;
+ } else { // intra/inter (1) or inter/inter (0)+ pred_context = left_mi->mbmi.ref_frame[0] == INTRA_FRAME ||
+ above_mi->mbmi.ref_frame[0] == INTRA_FRAME;
}
+ } else if (above_in_image || left_in_image) { // one edge available+ const MODE_INFO *edge = above_in_image ? above_mi : left_mi;
- case PRED_INTRA_INTER: {- if (above_in_image && left_in_image) { // both edges available- if (left_mi->mbmi.ref_frame[0] == INTRA_FRAME &&
- above_mi->mbmi.ref_frame[0] == INTRA_FRAME) { // intra/intra (3)- pred_context = 3;
- } else { // intra/inter (1) or inter/inter (0)- pred_context = left_mi->mbmi.ref_frame[0] == INTRA_FRAME ||
- above_mi->mbmi.ref_frame[0] == INTRA_FRAME;
- }
- } else if (above_in_image || left_in_image) { // one edge available- const MODE_INFO *edge = above_in_image ? above_mi : left_mi;
-
- // inter: 0, intra: 2
- pred_context = 2 * (edge->mbmi.ref_frame[0] == INTRA_FRAME);
- } else {- pred_context = 0;
- }
- assert(pred_context >= 0 && pred_context < INTRA_INTER_CONTEXTS);
- break;
+ // inter: 0, intra: 2
+ pred_context = 2 * (edge->mbmi.ref_frame[0] == INTRA_FRAME);
+ } else {+ pred_context = 0;
+ }
+ assert(pred_context >= 0 && pred_context < INTRA_INTER_CONTEXTS);
+ return pred_context;
+}
+// Returns a context number for the given MB prediction signal
+unsigned char vp9_get_pred_context_comp_inter_inter(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd) {+ int pred_context;
+ const MODE_INFO *const mi = xd->mode_info_context;
+ const MODE_INFO *const above_mi = mi - cm->mode_info_stride;
+ const MODE_INFO *const left_mi = mi - 1;
+ const int left_in_image = xd->left_available && left_mi->mbmi.mb_in_image;
+ const int above_in_image = xd->up_available && above_mi->mbmi.mb_in_image;
+ // Note:
+ // The mode info data structure has a one element border above and to the
+ // left of the entries correpsonding to real macroblocks.
+ // The prediction flags in these dummy entries are initialised to 0.
+ if (above_in_image && left_in_image) { // both edges available+ if (above_mi->mbmi.ref_frame[1] <= INTRA_FRAME &&
+ left_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {+ // neither edge uses comp pred (0/1)
+ pred_context = ((above_mi->mbmi.ref_frame[0] == cm->comp_fixed_ref) ^
+ (left_mi->mbmi.ref_frame[0] == cm->comp_fixed_ref));
+ } else if (above_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {+ // one of two edges uses comp pred (2/3)
+ pred_context = 2 +
+ (above_mi->mbmi.ref_frame[0] == cm->comp_fixed_ref ||
+ above_mi->mbmi.ref_frame[0] == INTRA_FRAME);
+ } else if (left_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {+ // one of two edges uses comp pred (2/3)
+ pred_context = 2 +
+ (left_mi->mbmi.ref_frame[0] == cm->comp_fixed_ref ||
+ left_mi->mbmi.ref_frame[0] == INTRA_FRAME);
+ } else { // both edges use comp pred (4)+ pred_context = 4;
}
+ } else if (above_in_image || left_in_image) { // one edge available+ const MODE_INFO *edge = above_in_image ? above_mi : left_mi;
- case PRED_COMP_INTER_INTER: {- if (above_in_image && left_in_image) { // both edges available- if (above_mi->mbmi.ref_frame[1] <= INTRA_FRAME &&
- left_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {- // neither edge uses comp pred (0/1)
- pred_context = ((above_mi->mbmi.ref_frame[0] == cm->comp_fixed_ref) ^
- (left_mi->mbmi.ref_frame[0] == cm->comp_fixed_ref));
- } else if (above_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {- // one of two edges uses comp pred (2/3)
- pred_context = 2 +
- (above_mi->mbmi.ref_frame[0] == cm->comp_fixed_ref ||
- above_mi->mbmi.ref_frame[0] == INTRA_FRAME);
- } else if (left_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {- // one of two edges uses comp pred (2/3)
- pred_context = 2 +
- (left_mi->mbmi.ref_frame[0] == cm->comp_fixed_ref ||
- left_mi->mbmi.ref_frame[0] == INTRA_FRAME);
- } else { // both edges use comp pred (4)- pred_context = 4;
- }
- } else if (above_in_image || left_in_image) { // one edge available- const MODE_INFO *edge = above_in_image ? above_mi : left_mi;
-
- if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {- // edge does not use comp pred (0/1)
- pred_context = edge->mbmi.ref_frame[0] == cm->comp_fixed_ref;
- } else { // edge uses comp pred (3)- pred_context = 3;
- }
- } else { // no edges available (1)- pred_context = 1;
- }
- assert(pred_context >= 0 && pred_context < COMP_INTER_CONTEXTS);
- break;
+ if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {+ // edge does not use comp pred (0/1)
+ pred_context = edge->mbmi.ref_frame[0] == cm->comp_fixed_ref;
+ } else { // edge uses comp pred (3)+ pred_context = 3;
}
+ } else { // no edges available (1)+ pred_context = 1;
+ }
+ assert(pred_context >= 0 && pred_context < COMP_INTER_CONTEXTS);
+ return pred_context;
+}
- case PRED_COMP_REF_P: {- const int fix_ref_idx = cm->ref_frame_sign_bias[cm->comp_fixed_ref];
- const int var_ref_idx = !fix_ref_idx;
+// Returns a context number for the given MB prediction signal
+unsigned char vp9_get_pred_context_comp_ref_p(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd) {+ int pred_context;
+ const MODE_INFO *const mi = xd->mode_info_context;
+ const MODE_INFO *const above_mi = mi - cm->mode_info_stride;
+ const MODE_INFO *const left_mi = mi - 1;
+ const int left_in_image = xd->left_available && left_mi->mbmi.mb_in_image;
+ const int above_in_image = xd->up_available && above_mi->mbmi.mb_in_image;
+ // Note:
+ // The mode info data structure has a one element border above and to the
+ // left of the entries correpsonding to real macroblocks.
+ // The prediction flags in these dummy entries are initialised to 0.
+ const int fix_ref_idx = cm->ref_frame_sign_bias[cm->comp_fixed_ref];
+ const int var_ref_idx = !fix_ref_idx;
- if (above_in_image && left_in_image) { // both edges available- if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME &&
- left_mi->mbmi.ref_frame[0] == INTRA_FRAME) { // intra/intra (2)- pred_context = 2;
- } else if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME ||
- left_mi->mbmi.ref_frame[0] == INTRA_FRAME) { // intra/inter- const MODE_INFO *edge = above_mi->mbmi.ref_frame[0] == INTRA_FRAME ?
- left_mi : above_mi;
+ if (above_in_image && left_in_image) { // both edges available+ if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME
+ && left_mi->mbmi.ref_frame[0] == INTRA_FRAME) { // intra/intra (2)+ pred_context = 2;
+ } else if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME
+ || left_mi->mbmi.ref_frame[0] == INTRA_FRAME) { // intra/inter+ const MODE_INFO *edge =
+ above_mi->mbmi.ref_frame[0] == INTRA_FRAME ? left_mi : above_mi;
- if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) { // single pred (1/3)- pred_context = 1 +
- 2 * edge->mbmi.ref_frame[0] != cm->comp_var_ref[1];
- } else { // comp pred (1/3)- pred_context = 1 +
- 2 * edge->mbmi.ref_frame[var_ref_idx] != cm->comp_var_ref[1];
- }
- } else { // inter/inter- int l_sg = left_mi->mbmi.ref_frame[1] <= INTRA_FRAME;
- int a_sg = above_mi->mbmi.ref_frame[1] <= INTRA_FRAME;
- MV_REFERENCE_FRAME vrfa = a_sg ? above_mi->mbmi.ref_frame[0] :
+ if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) { // single pred (1/3)+ pred_context = 1 + 2 * edge->mbmi.ref_frame[0] != cm->comp_var_ref[1];
+ } else { // comp pred (1/3)+ pred_context = 1 + 2 * edge->mbmi.ref_frame[var_ref_idx]
+ != cm->comp_var_ref[1];
+ }
+ } else { // inter/inter+ int l_sg = left_mi->mbmi.ref_frame[1] <= INTRA_FRAME;
+ int a_sg = above_mi->mbmi.ref_frame[1] <= INTRA_FRAME;
+ MV_REFERENCE_FRAME vrfa =
+ a_sg ?
+ above_mi->mbmi.ref_frame[0] :
above_mi->mbmi.ref_frame[var_ref_idx];
- MV_REFERENCE_FRAME vrfl = l_sg ? left_mi->mbmi.ref_frame[0] :
- left_mi->mbmi.ref_frame[var_ref_idx];
+ MV_REFERENCE_FRAME vrfl =
+ l_sg ?
+ left_mi->mbmi.ref_frame[0] : left_mi->mbmi.ref_frame[var_ref_idx];
- if (vrfa == vrfl && cm->comp_var_ref[1] == vrfa) {- pred_context = 0;
- } else if (l_sg && a_sg) { // single/single- if ((vrfa == cm->comp_fixed_ref && vrfl == cm->comp_var_ref[0]) ||
- (vrfl == cm->comp_fixed_ref && vrfa == cm->comp_var_ref[0])) {- pred_context = 4;
- } else if (vrfa == vrfl) {- pred_context = 3;
- } else {- pred_context = 1;
- }
- } else if (l_sg || a_sg) { // single/comp- MV_REFERENCE_FRAME vrfc = l_sg ? vrfa : vrfl;
- MV_REFERENCE_FRAME rfs = a_sg ? vrfa : vrfl;
-
- if (vrfc == cm->comp_var_ref[1] && rfs != cm->comp_var_ref[1]) {- pred_context = 1;
- } else if (rfs == cm->comp_var_ref[1] &&
- vrfc != cm->comp_var_ref[1]) {- pred_context = 2;
- } else {- pred_context = 4;
- }
- } else if (vrfa == vrfl) { // comp/comp- pred_context = 4;
- } else {- pred_context = 2;
- }
+ if (vrfa == vrfl && cm->comp_var_ref[1] == vrfa) {+ pred_context = 0;
+ } else if (l_sg && a_sg) { // single/single+ if ((vrfa == cm->comp_fixed_ref && vrfl == cm->comp_var_ref[0])
+ || (vrfl == cm->comp_fixed_ref && vrfa == cm->comp_var_ref[0])) {+ pred_context = 4;
+ } else if (vrfa == vrfl) {+ pred_context = 3;
+ } else {+ pred_context = 1;
}
- } else if (above_in_image || left_in_image) { // one edge available- const MODE_INFO *edge = above_in_image ? above_mi : left_mi;
+ } else if (l_sg || a_sg) { // single/comp+ MV_REFERENCE_FRAME vrfc = l_sg ? vrfa : vrfl;
+ MV_REFERENCE_FRAME rfs = a_sg ? vrfa : vrfl;
- if (edge->mbmi.ref_frame[0] == INTRA_FRAME) {+ if (vrfc == cm->comp_var_ref[1] && rfs != cm->comp_var_ref[1]) {+ pred_context = 1;
+ } else if (rfs == cm->comp_var_ref[1] && vrfc != cm->comp_var_ref[1]) {pred_context = 2;
- } else if (edge->mbmi.ref_frame[1] > INTRA_FRAME) {- pred_context =
- 4 * edge->mbmi.ref_frame[var_ref_idx] != cm->comp_var_ref[1];
} else {- pred_context = 3 * edge->mbmi.ref_frame[0] != cm->comp_var_ref[1];
+ pred_context = 4;
}
- } else { // no edges available (2)+ } else if (vrfa == vrfl) { // comp/comp+ pred_context = 4;
+ } else {pred_context = 2;
}
- assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
- break;
}
+ } else if (above_in_image || left_in_image) { // one edge available+ const MODE_INFO *edge = above_in_image ? above_mi : left_mi;
- case PRED_SINGLE_REF_P1: {- if (above_in_image && left_in_image) { // both edges available- if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME &&
- left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {- pred_context = 2;
- } else if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME ||
- left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {- const MODE_INFO *edge = above_mi->mbmi.ref_frame[0] == INTRA_FRAME ?
- left_mi : above_mi;
+ if (edge->mbmi.ref_frame[0] == INTRA_FRAME) {+ pred_context = 2;
+ } else if (edge->mbmi.ref_frame[1] > INTRA_FRAME) {+ pred_context = 4 * edge->mbmi.ref_frame[var_ref_idx]
+ != cm->comp_var_ref[1];
+ } else {+ pred_context = 3 * edge->mbmi.ref_frame[0] != cm->comp_var_ref[1];
+ }
+ } else { // no edges available (2)+ pred_context = 2;
+ }
+ assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
- if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {- pred_context = 4 * (edge->mbmi.ref_frame[0] == LAST_FRAME);
- } else {- pred_context = 1 + (edge->mbmi.ref_frame[0] == LAST_FRAME ||
- edge->mbmi.ref_frame[1] == LAST_FRAME);
- }
- } else if (above_mi->mbmi.ref_frame[1] <= INTRA_FRAME &&
- left_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {- pred_context = 2 * (above_mi->mbmi.ref_frame[0] == LAST_FRAME) +
- 2 * (left_mi->mbmi.ref_frame[0] == LAST_FRAME);
- } else if (above_mi->mbmi.ref_frame[1] > INTRA_FRAME &&
- left_mi->mbmi.ref_frame[1] > INTRA_FRAME) {- pred_context = 1 + (above_mi->mbmi.ref_frame[0] == LAST_FRAME ||
- above_mi->mbmi.ref_frame[1] == LAST_FRAME ||
- left_mi->mbmi.ref_frame[0] == LAST_FRAME ||
- left_mi->mbmi.ref_frame[1] == LAST_FRAME);
- } else {- MV_REFERENCE_FRAME rfs = above_mi->mbmi.ref_frame[1] <= INTRA_FRAME ?
+ return pred_context;
+}
+unsigned char vp9_get_pred_context_single_ref_p1(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd) {+ int pred_context;
+ const MODE_INFO *const mi = xd->mode_info_context;
+ const MODE_INFO *const above_mi = mi - cm->mode_info_stride;
+ const MODE_INFO *const left_mi = mi - 1;
+ const int left_in_image = xd->left_available && left_mi->mbmi.mb_in_image;
+ const int above_in_image = xd->up_available && above_mi->mbmi.mb_in_image;
+ // Note:
+ // The mode info data structure has a one element border above and to the
+ // left of the entries correpsonding to real macroblocks.
+ // The prediction flags in these dummy entries are initialised to 0.
+ if (above_in_image && left_in_image) { // both edges available+ if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME
+ && left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {+ pred_context = 2;
+ } else if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME
+ || left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {+ const MODE_INFO *edge =
+ above_mi->mbmi.ref_frame[0] == INTRA_FRAME ? left_mi : above_mi;
+
+ if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {+ pred_context = 4 * (edge->mbmi.ref_frame[0] == LAST_FRAME);
+ } else {+ pred_context = 1
+ + (edge->mbmi.ref_frame[0] == LAST_FRAME
+ || edge->mbmi.ref_frame[1] == LAST_FRAME);
+ }
+ } else if (above_mi->mbmi.ref_frame[1] <= INTRA_FRAME
+ && left_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {+ pred_context = 2 * (above_mi->mbmi.ref_frame[0] == LAST_FRAME)
+ + 2 * (left_mi->mbmi.ref_frame[0] == LAST_FRAME);
+ } else if (above_mi->mbmi.ref_frame[1] > INTRA_FRAME
+ && left_mi->mbmi.ref_frame[1] > INTRA_FRAME) {+ pred_context = 1
+ + (above_mi->mbmi.ref_frame[0] == LAST_FRAME
+ || above_mi->mbmi.ref_frame[1] == LAST_FRAME
+ || left_mi->mbmi.ref_frame[0] == LAST_FRAME
+ || left_mi->mbmi.ref_frame[1] == LAST_FRAME);
+ } else {+ MV_REFERENCE_FRAME rfs =
+ above_mi->mbmi.ref_frame[1] <= INTRA_FRAME ?
above_mi->mbmi.ref_frame[0] : left_mi->mbmi.ref_frame[0];
- MV_REFERENCE_FRAME crf1 = above_mi->mbmi.ref_frame[1] > INTRA_FRAME ?
+ MV_REFERENCE_FRAME crf1 =
+ above_mi->mbmi.ref_frame[1] > INTRA_FRAME ?
above_mi->mbmi.ref_frame[0] : left_mi->mbmi.ref_frame[0];
- MV_REFERENCE_FRAME crf2 = above_mi->mbmi.ref_frame[1] > INTRA_FRAME ?
+ MV_REFERENCE_FRAME crf2 =
+ above_mi->mbmi.ref_frame[1] > INTRA_FRAME ?
above_mi->mbmi.ref_frame[1] : left_mi->mbmi.ref_frame[1];
- if (rfs == LAST_FRAME) {- pred_context = 3 + (crf1 == LAST_FRAME || crf2 == LAST_FRAME);
- } else {- pred_context = crf1 == LAST_FRAME || crf2 == LAST_FRAME;
- }
- }
- } else if (above_in_image || left_in_image) { // one edge available- const MODE_INFO *edge = above_in_image ? above_mi : left_mi;
-
- if (edge->mbmi.ref_frame[0] == INTRA_FRAME) {- pred_context = 2;
- } else if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {- pred_context = 4 * (edge->mbmi.ref_frame[0] == LAST_FRAME);
- } else {- pred_context = 1 + (edge->mbmi.ref_frame[0] == LAST_FRAME ||
- edge->mbmi.ref_frame[1] == LAST_FRAME);
- }
- } else { // no edges available (2)- pred_context = 2;
+ if (rfs == LAST_FRAME) {+ pred_context = 3 + (crf1 == LAST_FRAME || crf2 == LAST_FRAME);
+ } else {+ pred_context = crf1 == LAST_FRAME || crf2 == LAST_FRAME;
}
- assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
- break;
}
+ } else if (above_in_image || left_in_image) { // one edge available+ const MODE_INFO *edge = above_in_image ? above_mi : left_mi;
- case PRED_SINGLE_REF_P2: {- if (above_in_image && left_in_image) { // both edges available- if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME &&
- left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {- pred_context = 2;
- } else if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME ||
- left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {- const MODE_INFO *edge = above_mi->mbmi.ref_frame[0] == INTRA_FRAME ?
- left_mi : above_mi;
+ if (edge->mbmi.ref_frame[0] == INTRA_FRAME) {+ pred_context = 2;
+ } else if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {+ pred_context = 4 * (edge->mbmi.ref_frame[0] == LAST_FRAME);
+ } else {+ pred_context = 1
+ + (edge->mbmi.ref_frame[0] == LAST_FRAME
+ || edge->mbmi.ref_frame[1] == LAST_FRAME);
+ }
+ } else { // no edges available (2)+ pred_context = 2;
+ }
+ assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
+ return pred_context;
+}
- if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {- if (edge->mbmi.ref_frame[0] == LAST_FRAME) {- pred_context = 3;
- } else {- pred_context = 4 * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME);
- }
- } else {- pred_context = 1 + 2 * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME ||
- edge->mbmi.ref_frame[1] == GOLDEN_FRAME);
- }
- } else if (above_mi->mbmi.ref_frame[1] <= INTRA_FRAME &&
- left_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {- if (above_mi->mbmi.ref_frame[0] == LAST_FRAME &&
- left_mi->mbmi.ref_frame[0] == LAST_FRAME) {- pred_context = 3;
- } else if (above_mi->mbmi.ref_frame[0] == LAST_FRAME ||
- left_mi->mbmi.ref_frame[0] == LAST_FRAME) {- const MODE_INFO *edge = above_mi->mbmi.ref_frame[0] == LAST_FRAME ?
- left_mi : above_mi;
+unsigned char vp9_get_pred_context_single_ref_p2(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd) {+ int pred_context;
+ const MODE_INFO *const mi = xd->mode_info_context;
+ const MODE_INFO *const above_mi = mi - cm->mode_info_stride;
+ const MODE_INFO *const left_mi = mi - 1;
+ const int left_in_image = xd->left_available && left_mi->mbmi.mb_in_image;
+ const int above_in_image = xd->up_available && above_mi->mbmi.mb_in_image;
+ // Note:
+ // The mode info data structure has a one element border above and to the
+ // left of the entries correpsonding to real macroblocks.
+ // The prediction flags in these dummy entries are initialised to 0.
+ if (above_in_image && left_in_image) { // both edges available+ if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME
+ && left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {+ pred_context = 2;
+ } else if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME
+ || left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {+ const MODE_INFO *edge =
+ above_mi->mbmi.ref_frame[0] == INTRA_FRAME ? left_mi : above_mi;
- pred_context = 4 * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME);
- } else {- pred_context = 2 * (above_mi->mbmi.ref_frame[0] == GOLDEN_FRAME) +
- 2 * (left_mi->mbmi.ref_frame[0] == GOLDEN_FRAME);
- }
- } else if (above_mi->mbmi.ref_frame[1] > INTRA_FRAME &&
- left_mi->mbmi.ref_frame[1] > INTRA_FRAME) {- if (above_mi->mbmi.ref_frame[0] == left_mi->mbmi.ref_frame[0] &&
- above_mi->mbmi.ref_frame[1] == left_mi->mbmi.ref_frame[1]) {- pred_context = 3 * (above_mi->mbmi.ref_frame[0] == GOLDEN_FRAME ||
- above_mi->mbmi.ref_frame[1] == GOLDEN_FRAME ||
- left_mi->mbmi.ref_frame[0] == GOLDEN_FRAME ||
- left_mi->mbmi.ref_frame[1] == GOLDEN_FRAME);
- } else {- pred_context = 2;
- }
+ if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {+ if (edge->mbmi.ref_frame[0] == LAST_FRAME) {+ pred_context = 3;
} else {- MV_REFERENCE_FRAME rfs = above_mi->mbmi.ref_frame[1] <= INTRA_FRAME ?
- above_mi->mbmi.ref_frame[0] : left_mi->mbmi.ref_frame[0];
- MV_REFERENCE_FRAME crf1 = above_mi->mbmi.ref_frame[1] > INTRA_FRAME ?
- above_mi->mbmi.ref_frame[0] : left_mi->mbmi.ref_frame[0];
- MV_REFERENCE_FRAME crf2 = above_mi->mbmi.ref_frame[1] > INTRA_FRAME ?
- above_mi->mbmi.ref_frame[1] : left_mi->mbmi.ref_frame[1];
-
- if (rfs == GOLDEN_FRAME) {- pred_context = 3 + (crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME);
- } else if (rfs == ALTREF_FRAME) {- pred_context = crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME;
- } else {- pred_context =
- 1 + 2 * (crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME);
- }
- }
- } else if (above_in_image || left_in_image) { // one edge available- const MODE_INFO *edge = above_in_image ? above_mi : left_mi;
-
- if (edge->mbmi.ref_frame[0] == INTRA_FRAME ||
- (edge->mbmi.ref_frame[0] == LAST_FRAME &&
- edge->mbmi.ref_frame[1] <= INTRA_FRAME)) {- pred_context = 2;
- } else if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {pred_context = 4 * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME);
- } else {- pred_context = 3 * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME ||
- edge->mbmi.ref_frame[1] == GOLDEN_FRAME);
}
- } else { // no edges available (2)- pred_context = 2;
+ } else {+ pred_context = 1
+ + 2
+ * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME
+ || edge->mbmi.ref_frame[1] == GOLDEN_FRAME);
}
- assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
- break;
- }
+ } else if (above_mi->mbmi.ref_frame[1] <= INTRA_FRAME
+ && left_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {+ if (above_mi->mbmi.ref_frame[0] == LAST_FRAME
+ && left_mi->mbmi.ref_frame[0] == LAST_FRAME) {+ pred_context = 3;
+ } else if (above_mi->mbmi.ref_frame[0] == LAST_FRAME
+ || left_mi->mbmi.ref_frame[0] == LAST_FRAME) {+ const MODE_INFO *edge =
+ above_mi->mbmi.ref_frame[0] == LAST_FRAME ? left_mi : above_mi;
- case PRED_TX_SIZE: {- int above_context, left_context;
- int max_tx_size;
- if (mi->mbmi.sb_type < BLOCK_SIZE_SB8X8)
- max_tx_size = TX_4X4;
- else if (mi->mbmi.sb_type < BLOCK_SIZE_MB16X16)
- max_tx_size = TX_8X8;
- else if (mi->mbmi.sb_type < BLOCK_SIZE_SB32X32)
- max_tx_size = TX_16X16;
- else
- max_tx_size = TX_32X32;
- above_context = left_context = max_tx_size;
- if (above_in_image) {- above_context = (above_mi->mbmi.mb_skip_coeff ?
- max_tx_size : above_mi->mbmi.txfm_size);
+ pred_context = 4 * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME);
+ } else {+ pred_context = 2 * (above_mi->mbmi.ref_frame[0] == GOLDEN_FRAME)
+ + 2 * (left_mi->mbmi.ref_frame[0] == GOLDEN_FRAME);
}
- if (left_in_image) {- left_context = (left_mi->mbmi.mb_skip_coeff ?
- max_tx_size : left_mi->mbmi.txfm_size);
+ } else if (above_mi->mbmi.ref_frame[1] > INTRA_FRAME
+ && left_mi->mbmi.ref_frame[1] > INTRA_FRAME) {+ if (above_mi->mbmi.ref_frame[0] == left_mi->mbmi.ref_frame[0]
+ && above_mi->mbmi.ref_frame[1] == left_mi->mbmi.ref_frame[1]) {+ pred_context = 3
+ * (above_mi->mbmi.ref_frame[0] == GOLDEN_FRAME
+ || above_mi->mbmi.ref_frame[1] == GOLDEN_FRAME
+ || left_mi->mbmi.ref_frame[0] == GOLDEN_FRAME
+ || left_mi->mbmi.ref_frame[1] == GOLDEN_FRAME);
+ } else {+ pred_context = 2;
}
- if (!left_in_image) {- left_context = above_context;
+ } else {+ MV_REFERENCE_FRAME rfs =
+ above_mi->mbmi.ref_frame[1] <= INTRA_FRAME ?
+ above_mi->mbmi.ref_frame[0] : left_mi->mbmi.ref_frame[0];
+ MV_REFERENCE_FRAME crf1 =
+ above_mi->mbmi.ref_frame[1] > INTRA_FRAME ?
+ above_mi->mbmi.ref_frame[0] : left_mi->mbmi.ref_frame[0];
+ MV_REFERENCE_FRAME crf2 =
+ above_mi->mbmi.ref_frame[1] > INTRA_FRAME ?
+ above_mi->mbmi.ref_frame[1] : left_mi->mbmi.ref_frame[1];
+
+ if (rfs == GOLDEN_FRAME) {+ pred_context = 3 + (crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME);
+ } else if (rfs == ALTREF_FRAME) {+ pred_context = crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME;
+ } else {+ pred_context = 1 + 2 * (crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME);
}
- if (!above_in_image) {- above_context = left_context;
- }
- pred_context = (above_context + left_context > max_tx_size);
- break;
}
+ } else if (above_in_image || left_in_image) { // one edge available+ const MODE_INFO *edge = above_in_image ? above_mi : left_mi;
- default:
- assert(0);
- pred_context = 0; // *** add error trap code.
- break;
+ if (edge->mbmi.ref_frame[0] == INTRA_FRAME
+ || (edge->mbmi.ref_frame[0] == LAST_FRAME
+ && edge->mbmi.ref_frame[1] <= INTRA_FRAME)) {+ pred_context = 2;
+ } else if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {+ pred_context = 4 * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME);
+ } else {+ pred_context = 3
+ * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME
+ || edge->mbmi.ref_frame[1] == GOLDEN_FRAME);
+ }
+ } else { // no edges available (2)+ pred_context = 2;
}
-
+ assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
return pred_context;
}
-
-// This function returns a context probability for coding a given
-// prediction signal
-vp9_prob vp9_get_pred_prob(const VP9_COMMON *cm, const MACROBLOCKD *xd,
- PRED_ID pred_id) {- const int pred_context = vp9_get_pred_context(cm, xd, pred_id);
-
- switch (pred_id) {- case PRED_SEG_ID:
- return cm->segment_pred_probs[pred_context];
- case PRED_MBSKIP:
- return cm->fc.mbskip_probs[pred_context];
- case PRED_INTRA_INTER:
- return cm->fc.intra_inter_prob[pred_context];
- case PRED_COMP_INTER_INTER:
- return cm->fc.comp_inter_prob[pred_context];
- case PRED_COMP_REF_P:
- return cm->fc.comp_ref_prob[pred_context];
- case PRED_SINGLE_REF_P1:
- return cm->fc.single_ref_prob[pred_context][0];
- case PRED_SINGLE_REF_P2:
- return cm->fc.single_ref_prob[pred_context][1];
- default:
- assert(0);
- return 128; // *** add error trap code.
+// Returns a context number for the given MB prediction signal
+unsigned char vp9_get_pred_context_tx_size(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd) {+ int pred_context;
+ const MODE_INFO * const mi = xd->mode_info_context;
+ const MODE_INFO * const above_mi = mi - cm->mode_info_stride;
+ const MODE_INFO * const left_mi = mi - 1;
+ const int left_in_image = xd->left_available && left_mi->mbmi.mb_in_image;
+ const int above_in_image = xd->up_available && above_mi->mbmi.mb_in_image;
+ // Note:
+ // The mode info data structure has a one element border above and to the
+ // left of the entries correpsonding to real macroblocks.
+ // The prediction flags in these dummy entries are initialised to 0.
+ int above_context, left_context;
+ int max_tx_size;
+ if (mi->mbmi.sb_type < BLOCK_SIZE_SB8X8)
+ max_tx_size = TX_4X4;
+ else if (mi->mbmi.sb_type < BLOCK_SIZE_MB16X16)
+ max_tx_size = TX_8X8;
+ else if (mi->mbmi.sb_type < BLOCK_SIZE_SB32X32)
+ max_tx_size = TX_16X16;
+ else
+ max_tx_size = TX_32X32;
+ above_context = left_context = max_tx_size;
+ if (above_in_image) {+ above_context = (
+ above_mi->mbmi.mb_skip_coeff ? max_tx_size : above_mi->mbmi.txfm_size);
}
-}
-
-// This function returns a context probability ptr for coding a given
-// prediction signal
-const vp9_prob *vp9_get_pred_probs(const VP9_COMMON *cm, const MACROBLOCKD * xd,
- PRED_ID pred_id) {- const MODE_INFO *const mi = xd->mode_info_context;
- const int pred_context = vp9_get_pred_context(cm, xd, pred_id);
-
- switch (pred_id) {- case PRED_SWITCHABLE_INTERP:
- return &cm->fc.switchable_interp_prob[pred_context][0];
-
- case PRED_TX_SIZE:
- if (mi->mbmi.sb_type < BLOCK_SIZE_MB16X16)
- return cm->fc.tx_probs_8x8p[pred_context];
- else if (mi->mbmi.sb_type < BLOCK_SIZE_SB32X32)
- return cm->fc.tx_probs_16x16p[pred_context];
- else
- return cm->fc.tx_probs_32x32p[pred_context];
-
- default:
- assert(0);
- return NULL; // *** add error trap code.
+ if (left_in_image) {+ left_context = (
+ left_mi->mbmi.mb_skip_coeff ? max_tx_size : left_mi->mbmi.txfm_size);
}
-}
-
-// This function returns the status of the given prediction signal.
-// I.e. is the predicted value for the given signal correct.
-unsigned char vp9_get_pred_flag(const MACROBLOCKD *const xd,
- PRED_ID pred_id) {- switch (pred_id) {- case PRED_SEG_ID:
- return xd->mode_info_context->mbmi.seg_id_predicted;
- case PRED_MBSKIP:
- return xd->mode_info_context->mbmi.mb_skip_coeff;
- default:
- assert(0);
- return 0; // *** add error trap code.
+ if (!left_in_image) {+ left_context = above_context;
}
+ if (!above_in_image) {+ above_context = left_context;
+ }
+ pred_context = (above_context + left_context > max_tx_size);
+
+ return pred_context;
}
// This function sets the status of the given prediction signal.
// I.e. is the predicted value for the given signal correct.
-void vp9_set_pred_flag(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize, PRED_ID pred_id,
+void vp9_set_pred_flag_mbskip(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize,
unsigned char pred_flag) {const int mis = xd->mode_info_stride;
const int bh = 1 << mi_height_log2(bsize);
@@ -466,24 +472,9 @@
#undef sub
int x, y;
- switch (pred_id) {- case PRED_SEG_ID:
- for (y = 0; y < y_mis; y++)
- for (x = 0; x < x_mis; x++)
- xd->mode_info_context[y * mis + x].mbmi.seg_id_predicted = pred_flag;
- break;
-
- case PRED_MBSKIP:
- for (y = 0; y < y_mis; y++)
- for (x = 0; x < x_mis; x++)
- xd->mode_info_context[y * mis + x].mbmi.mb_skip_coeff = pred_flag;
- break;
-
- default:
- assert(0);
- // *** add error trap code.
- break;
- }
+ for (y = 0; y < y_mis; y++)
+ for (x = 0; x < x_mis; x++)
+ xd->mode_info_context[y * mis + x].mbmi.mb_skip_coeff = pred_flag;
}
int vp9_get_segment_id(VP9_COMMON *cm, const uint8_t *segment_ids,
--- a/vp9/common/vp9_pred_common.h
+++ b/vp9/common/vp9_pred_common.h
@@ -14,34 +14,125 @@
#include "vp9/common/vp9_blockd.h"
#include "vp9/common/vp9_onyxc_int.h"
-// Predicted items
-typedef enum {- PRED_SEG_ID = 0, // Segment identifier
- PRED_MBSKIP = 1,
- PRED_SWITCHABLE_INTERP = 2,
- PRED_INTRA_INTER = 3,
- PRED_COMP_INTER_INTER = 4,
- PRED_SINGLE_REF_P1 = 5,
- PRED_SINGLE_REF_P2 = 6,
- PRED_COMP_REF_P = 7,
- PRED_TX_SIZE = 8
-} PRED_ID;
+int vp9_get_segment_id(VP9_COMMON *cm, const uint8_t *segment_ids,
+ BLOCK_SIZE_TYPE bsize, int mi_row, int mi_col);
-unsigned char vp9_get_pred_context(const VP9_COMMON *cm, const MACROBLOCKD *xd,
- PRED_ID pred_id);
-vp9_prob vp9_get_pred_prob(const VP9_COMMON *cm, const MACROBLOCKD *xd,
- PRED_ID pred_id);
+static INLINE unsigned char vp9_get_pred_context_seg_id(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd) {+ int pred_context;
+ const MODE_INFO * const mi = xd->mode_info_context;
+ const MODE_INFO * const above_mi = mi - cm->mode_info_stride;
+ const MODE_INFO * const left_mi = mi - 1;
+ pred_context = above_mi->mbmi.seg_id_predicted;
+ if (xd->left_available)
+ pred_context += left_mi->mbmi.seg_id_predicted;
+ return pred_context;
+}
+static INLINE vp9_prob vp9_get_pred_prob_seg_id(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd) {+ const int pred_context = vp9_get_pred_context_seg_id(cm, xd);
+ return cm->segment_pred_probs[pred_context];
+}
+static INLINE unsigned char vp9_get_pred_flag_seg_id(
+ const MACROBLOCKD * const xd) {+ return xd->mode_info_context->mbmi.seg_id_predicted;
+}
-const vp9_prob *vp9_get_pred_probs(const VP9_COMMON *cm, const MACROBLOCKD *xd,
- PRED_ID pred_id);
+void vp9_set_pred_flag_seg_id(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize,
+ unsigned char pred_flag);
-unsigned char vp9_get_pred_flag(const MACROBLOCKD *xd, PRED_ID pred_id);
+static INLINE unsigned char vp9_get_pred_context_mbskip(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd) {+ int pred_context;
+ const MODE_INFO * const mi = xd->mode_info_context;
+ const MODE_INFO * const above_mi = mi - cm->mode_info_stride;
+ const MODE_INFO * const left_mi = mi - 1;
+ pred_context = above_mi->mbmi.mb_skip_coeff;
+ if (xd->left_available)
+ pred_context += left_mi->mbmi.mb_skip_coeff;
+ return pred_context;
+}
+static INLINE vp9_prob vp9_get_pred_prob_mbskip(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd) {+ const int pred_context = vp9_get_pred_context_mbskip(cm, xd);
+ return cm->fc.mbskip_probs[pred_context];
+}
+static INLINE unsigned char vp9_get_pred_flag_mbskip(
+ const MACROBLOCKD * const xd) {+ return xd->mode_info_context->mbmi.mb_skip_coeff;
+}
+void vp9_set_pred_flag_mbskip(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize,
+ unsigned char pred_flag);
-void vp9_set_pred_flag(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize, PRED_ID pred_id,
- unsigned char pred_flag);
+unsigned char vp9_get_pred_context_switchable_interp(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd);
-int vp9_get_segment_id(VP9_COMMON *cm, const uint8_t *segment_ids,
- BLOCK_SIZE_TYPE bsize, int mi_row, int mi_col);
+static INLINE const vp9_prob *vp9_get_pred_probs_switchable_interp(
+ const VP9_COMMON *cm, const MACROBLOCKD * xd) {+ const int pred_context = vp9_get_pred_context_switchable_interp(cm, xd);
+ return &cm->fc.switchable_interp_prob[pred_context][0];
+}
+
+unsigned char vp9_get_pred_context_intra_inter(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd);
+static INLINE vp9_prob vp9_get_pred_prob_intra_inter(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd) {+ const int pred_context = vp9_get_pred_context_intra_inter(cm, xd);
+
+ return cm->fc.intra_inter_prob[pred_context];
+}
+
+unsigned char vp9_get_pred_context_comp_inter_inter(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd);
+
+
+static INLINE vp9_prob vp9_get_pred_prob_comp_inter_inter(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd) {+ const int pred_context = vp9_get_pred_context_comp_inter_inter(cm, xd);
+ return cm->fc.comp_inter_prob[pred_context];
+}
+
+unsigned char vp9_get_pred_context_comp_ref_p(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd);
+
+static INLINE vp9_prob vp9_get_pred_prob_comp_ref_p(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd) {+ const int pred_context = vp9_get_pred_context_comp_ref_p(cm, xd);
+ return cm->fc.comp_ref_prob[pred_context];
+}
+
+unsigned char vp9_get_pred_context_single_ref_p1(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd);
+
+static INLINE vp9_prob vp9_get_pred_prob_single_ref_p1(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd) {+ const int pred_context = vp9_get_pred_context_single_ref_p1(cm, xd);
+ return cm->fc.single_ref_prob[pred_context][0];
+}
+
+unsigned char vp9_get_pred_context_single_ref_p2(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd);
+
+static INLINE vp9_prob vp9_get_pred_prob_single_ref_p2(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd) {+ const int pred_context = vp9_get_pred_context_single_ref_p2(cm, xd);
+ return cm->fc.single_ref_prob[pred_context][1];
+}
+
+unsigned char vp9_get_pred_context_tx_size(const VP9_COMMON *cm,
+ const MACROBLOCKD *xd);
+
+static INLINE const vp9_prob *vp9_get_pred_probs_tx_size(const VP9_COMMON *cm,
+ const MACROBLOCKD * xd) {+ const MODE_INFO *const mi = xd->mode_info_context;
+ const int pred_context = vp9_get_pred_context_tx_size(cm, xd);
+ if (mi->mbmi.sb_type < BLOCK_SIZE_MB16X16)
+ return cm->fc.tx_probs_8x8p[pred_context];
+ else if (mi->mbmi.sb_type < BLOCK_SIZE_SB32X32)
+ return cm->fc.tx_probs_16x16p[pred_context];
+ else
+ return cm->fc.tx_probs_32x32p[pred_context];
+}
#endif // VP9_COMMON_VP9_PRED_COMMON_H_
--- a/vp9/decoder/vp9_decodemv.c
+++ b/vp9/decoder/vp9_decodemv.c
@@ -50,8 +50,8 @@
static TX_SIZE read_selected_txfm_size(VP9_COMMON *cm, MACROBLOCKD *xd,
BLOCK_SIZE_TYPE bsize, vp9_reader *r) {- const int context = vp9_get_pred_context(cm, xd, PRED_TX_SIZE);
- const vp9_prob *tx_probs = vp9_get_pred_probs(cm, xd, PRED_TX_SIZE);
+ const int context = vp9_get_pred_context_tx_size(cm, xd);
+ const vp9_prob *tx_probs = vp9_get_pred_probs_tx_size(cm, xd);
TX_SIZE txfm_size = vp9_read(r, tx_probs[0]);
if (txfm_size != TX_4X4 && bsize >= BLOCK_SIZE_MB16X16) {txfm_size += vp9_read(r, tx_probs[1]);
@@ -123,8 +123,8 @@
MACROBLOCKD *const xd = &pbi->mb;
int skip_coeff = vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP);
if (!skip_coeff) {- const uint8_t ctx = vp9_get_pred_context(cm, xd, PRED_MBSKIP);
- skip_coeff = vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
+ const uint8_t ctx = vp9_get_pred_context_mbskip(cm, xd);
+ skip_coeff = vp9_read(r, vp9_get_pred_prob_mbskip(cm, xd));
cm->fc.mbskip_count[ctx][skip_coeff]++;
}
return skip_coeff;
@@ -294,7 +294,7 @@
ref_frame[0] = vp9_get_segdata(xd, segment_id, SEG_LVL_REF_FRAME);
ref_frame[1] = NONE;
} else {- const int comp_ctx = vp9_get_pred_context(cm, xd, PRED_COMP_INTER_INTER);
+ const int comp_ctx = vp9_get_pred_context_comp_inter_inter(cm, xd);
int is_comp;
if (cm->comp_pred_mode == HYBRID_PREDICTION) {@@ -307,16 +307,16 @@
// FIXME(rbultje) I'm pretty sure this breaks segmentation ref frame coding
if (is_comp) {const int fix_ref_idx = cm->ref_frame_sign_bias[cm->comp_fixed_ref];
- const int ref_ctx = vp9_get_pred_context(cm, xd, PRED_COMP_REF_P);
+ const int ref_ctx = vp9_get_pred_context_comp_ref_p(cm, xd);
const int b = vp9_read(r, fc->comp_ref_prob[ref_ctx]);
fc->comp_ref_count[ref_ctx][b]++;
ref_frame[fix_ref_idx] = cm->comp_fixed_ref;
ref_frame[!fix_ref_idx] = cm->comp_var_ref[b];
} else {- const int ref1_ctx = vp9_get_pred_context(cm, xd, PRED_SINGLE_REF_P1);
+ const int ref1_ctx = vp9_get_pred_context_single_ref_p1(cm, xd);
ref_frame[1] = NONE;
if (vp9_read(r, fc->single_ref_prob[ref1_ctx][0])) {- const int ref2_ctx = vp9_get_pred_context(cm, xd, PRED_SINGLE_REF_P2);
+ const int ref2_ctx = vp9_get_pred_context_single_ref_p2(cm, xd);
const int b = vp9_read(r, fc->single_ref_prob[ref2_ctx][1]);
ref_frame[0] = b ? ALTREF_FRAME : GOLDEN_FRAME;
fc->single_ref_count[ref1_ctx][0][1]++;
@@ -379,9 +379,9 @@
return pred_segment_id;
if (cm->temporal_update) {- const vp9_prob pred_prob = vp9_get_pred_prob(cm, xd, PRED_SEG_ID);
+ const vp9_prob pred_prob = vp9_get_pred_prob_seg_id(cm, xd);
const int pred_flag = vp9_read(r, pred_prob);
- vp9_set_pred_flag(xd, bsize, PRED_SEG_ID, pred_flag);
+ vp9_set_pred_flag_seg_id(xd, bsize, pred_flag);
segment_id = pred_flag ? pred_segment_id
: read_segment_id(r, xd);
} else {@@ -406,9 +406,9 @@
VP9D_COMP *pbi, vp9_reader *r) {VP9_COMMON *const cm = &pbi->common;
MACROBLOCKD *const xd = &pbi->mb;
- const vp9_prob *probs = vp9_get_pred_probs(cm, xd, PRED_SWITCHABLE_INTERP);
+ const vp9_prob *probs = vp9_get_pred_probs_switchable_interp(cm, xd);
const int index = treed_read(r, vp9_switchable_interp_tree, probs);
- const int ctx = vp9_get_pred_context(cm, xd, PRED_SWITCHABLE_INTERP);
+ const int ctx = vp9_get_pred_context_switchable_interp(cm, xd);
++cm->fc.switchable_interp_count[ctx][index];
return vp9_switchable_interp[index];
}
@@ -456,9 +456,9 @@
MV_REFERENCE_FRAME ref;
if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_REF_FRAME)) {- const int ctx = vp9_get_pred_context(cm, xd, PRED_INTRA_INTER);
+ const int ctx = vp9_get_pred_context_intra_inter(cm, xd);
ref = (MV_REFERENCE_FRAME)
- vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_INTRA_INTER));
+ vp9_read(r, vp9_get_pred_prob_intra_inter(cm, xd));
cm->fc.intra_inter_count[ctx][ref != INTRA_FRAME]++;
} else {ref = (MV_REFERENCE_FRAME)
--- a/vp9/decoder/vp9_decodframe.c
+++ b/vp9/decoder/vp9_decodframe.c
@@ -271,7 +271,7 @@
} else {assert(mbmi->sb_type == bsize);
if (eobtotal == 0)
- vp9_set_pred_flag(xd, bsize, PRED_MBSKIP, 1); // skip loopfilter
+ vp9_set_pred_flag_mbskip(xd, bsize, 1); // skip loopfilter
else if (eobtotal > 0)
foreach_transformed_block(xd, bsize, decode_block, xd);
}
--- a/vp9/encoder/vp9_bitstream.c
+++ b/vp9/encoder/vp9_bitstream.c
@@ -204,7 +204,7 @@
BLOCK_SIZE_TYPE bsize, vp9_writer *w) {const VP9_COMMON *const c = &cpi->common;
const MACROBLOCKD *const xd = &cpi->mb.e_mbd;
- const vp9_prob *tx_probs = vp9_get_pred_probs(c, xd, PRED_TX_SIZE);
+ const vp9_prob *tx_probs = vp9_get_pred_probs_tx_size(c, xd);
vp9_write(w, tx_size != TX_4X4, tx_probs[0]);
if (bsize >= BLOCK_SIZE_MB16X16 && tx_size != TX_4X4) {vp9_write(w, tx_size != TX_8X8, tx_probs[1]);
@@ -220,7 +220,7 @@
return 1;
} else {const int skip_coeff = m->mbmi.mb_skip_coeff;
- vp9_write(w, skip_coeff, vp9_get_pred_prob(&cpi->common, xd, PRED_MBSKIP));
+ vp9_write(w, skip_coeff, vp9_get_pred_prob_mbskip(&cpi->common, xd));
return skip_coeff;
}
}
@@ -378,7 +378,7 @@
// (if not specified at the frame/segment level)
if (pc->comp_pred_mode == HYBRID_PREDICTION) {vp9_write(bc, mi->ref_frame[1] > INTRA_FRAME,
- vp9_get_pred_prob(pc, xd, PRED_COMP_INTER_INTER));
+ vp9_get_pred_prob_comp_inter_inter(pc, xd));
} else {assert((mi->ref_frame[1] <= INTRA_FRAME) ==
(pc->comp_pred_mode == SINGLE_PREDICTION_ONLY));
@@ -386,13 +386,13 @@
if (mi->ref_frame[1] > INTRA_FRAME) {vp9_write(bc, mi->ref_frame[0] == GOLDEN_FRAME,
- vp9_get_pred_prob(pc, xd, PRED_COMP_REF_P));
+ vp9_get_pred_prob_comp_ref_p(pc, xd));
} else {vp9_write(bc, mi->ref_frame[0] != LAST_FRAME,
- vp9_get_pred_prob(pc, xd, PRED_SINGLE_REF_P1));
+ vp9_get_pred_prob_single_ref_p1(pc, xd));
if (mi->ref_frame[0] != LAST_FRAME)
vp9_write(bc, mi->ref_frame[0] != GOLDEN_FRAME,
- vp9_get_pred_prob(pc, xd, PRED_SINGLE_REF_P2));
+ vp9_get_pred_prob_single_ref_p2(pc, xd));
}
} else {assert(mi->ref_frame[1] <= INTRA_FRAME);
@@ -426,8 +426,8 @@
if (cpi->mb.e_mbd.update_mb_segmentation_map) {// Is temporal coding of the segment map enabled
if (pc->temporal_update) {- unsigned char prediction_flag = vp9_get_pred_flag(xd, PRED_SEG_ID);
- vp9_prob pred_prob = vp9_get_pred_prob(pc, xd, PRED_SEG_ID);
+ unsigned char prediction_flag = vp9_get_pred_flag_seg_id(xd);
+ vp9_prob pred_prob = vp9_get_pred_prob_seg_id(pc, xd);
// Code the segment id prediction flag for this mb
vp9_write(bc, prediction_flag, pred_prob);
@@ -445,7 +445,7 @@
if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_REF_FRAME))
vp9_write(bc, rf != INTRA_FRAME,
- vp9_get_pred_prob(pc, xd, PRED_INTRA_INTER));
+ vp9_get_pred_prob_intra_inter(pc, xd));
if (mi->sb_type >= BLOCK_SIZE_SB8X8 && pc->txfm_mode == TX_MODE_SELECT &&
!(rf != INTRA_FRAME &&
@@ -493,7 +493,7 @@
if (cpi->common.mcomp_filter_type == SWITCHABLE) {write_token(bc, vp9_switchable_interp_tree,
- vp9_get_pred_probs(&cpi->common, xd, PRED_SWITCHABLE_INTERP),
+ vp9_get_pred_probs_switchable_interp(&cpi->common, xd),
vp9_switchable_interp_encodings +
vp9_switchable_interp_map[mi->interp_filter]);
} else {--- a/vp9/encoder/vp9_encodeframe.c
+++ b/vp9/encoder/vp9_encodeframe.c
@@ -422,9 +422,9 @@
if (cpi->common.mcomp_filter_type == SWITCHABLE
&& is_inter_mode(mbmi->mode)) {- ++cpi->common.fc.switchable_interp_count[vp9_get_pred_context(
- &cpi->common, xd, PRED_SWITCHABLE_INTERP)][vp9_switchable_interp_map[mbmi
- ->interp_filter]];
+ ++cpi->common.fc.switchable_interp_count[
+ vp9_get_pred_context_switchable_interp(&cpi->common, xd)]
+ [vp9_switchable_interp_map[mbmi->interp_filter]];
}
cpi->rd_comp_pred_diff[SINGLE_PREDICTION_ONLY] += ctx->single_pred_diff;
@@ -583,7 +583,7 @@
seg_ref_active = vp9_segfeature_active(xd, segment_id, SEG_LVL_REF_FRAME);
if (!seg_ref_active)
- cpi->intra_inter_count[vp9_get_pred_context(cm, xd, PRED_INTRA_INTER)][mbmi
+ cpi->intra_inter_count[vp9_get_pred_context_intra_inter(cm, xd)][mbmi
->ref_frame[0] > INTRA_FRAME]++;
// If the segment reference feature is enabled we have only a single
@@ -591,19 +591,18 @@
// the reference frame counts used to work out probabilities.
if ((mbmi->ref_frame[0] > INTRA_FRAME) && !seg_ref_active) {if (cm->comp_pred_mode == HYBRID_PREDICTION)
- cpi->comp_inter_count[vp9_get_pred_context(cm, xd,
- PRED_COMP_INTER_INTER)][mbmi
- ->ref_frame[1] > INTRA_FRAME]++;
+ cpi->comp_inter_count[vp9_get_pred_context_comp_inter_inter(cm, xd)]
+ [mbmi->ref_frame[1] > INTRA_FRAME]++;
if (mbmi->ref_frame[1] > INTRA_FRAME) {- cpi->comp_ref_count[vp9_get_pred_context(cm, xd, PRED_COMP_REF_P)][mbmi
+ cpi->comp_ref_count[vp9_get_pred_context_comp_ref_p(cm, xd)][mbmi
->ref_frame[0] == GOLDEN_FRAME]++;
} else {- cpi->single_ref_count[vp9_get_pred_context(cm, xd, PRED_SINGLE_REF_P1)][0][mbmi
- ->ref_frame[0] != LAST_FRAME]++;
+ cpi->single_ref_count[vp9_get_pred_context_single_ref_p1(cm, xd)]
+ [0][mbmi->ref_frame[0] != LAST_FRAME]++;
if (mbmi->ref_frame[0] != LAST_FRAME)
- cpi->single_ref_count[vp9_get_pred_context(cm, xd, PRED_SINGLE_REF_P2)][1][mbmi
- ->ref_frame[0] != GOLDEN_FRAME]++;
+ cpi->single_ref_count[vp9_get_pred_context_single_ref_p2(cm, xd)][1]
+ [mbmi->ref_frame[0] != GOLDEN_FRAME]++;
}
}
// Count of last ref frame 0,0 usage
@@ -2368,7 +2367,7 @@
// copy skip flag on all mb_mode_info contexts in this SB
// if this was a skip at this txfm size
- vp9_set_pred_flag(xd, bsize, PRED_MBSKIP, mi->mbmi.mb_skip_coeff);
+ vp9_set_pred_flag_mbskip(xd, bsize, mi->mbmi.mb_skip_coeff);
if (output_enabled) {if (cm->txfm_mode == TX_MODE_SELECT && mbmi->sb_type >= BLOCK_SIZE_SB8X8
@@ -2375,7 +2374,7 @@
&& !(mbmi->ref_frame[0] != INTRA_FRAME
&& (mbmi->mb_skip_coeff
|| vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)))) {- const int context = vp9_get_pred_context(cm, xd, PRED_TX_SIZE);
+ const int context = vp9_get_pred_context_tx_size(cm, xd);
if (bsize >= BLOCK_SIZE_SB32X32) {cm->fc.tx_count_32x32p[context][mbmi->txfm_size]++;
} else if (bsize >= BLOCK_SIZE_MB16X16) {--- a/vp9/encoder/vp9_rdopt.c
+++ b/vp9/encoder/vp9_rdopt.c
@@ -877,12 +877,12 @@
VP9_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
- vp9_prob skip_prob = vp9_get_pred_prob(cm, xd, PRED_MBSKIP);
+ vp9_prob skip_prob = vp9_get_pred_prob_mbskip(cm, xd);
int64_t rd[TX_SIZE_MAX_SB][2];
int n, m;
int s0, s1;
- const vp9_prob *tx_probs = vp9_get_pred_probs(cm, xd, PRED_TX_SIZE);
+ const vp9_prob *tx_probs = vp9_get_pred_probs_tx_size(cm, xd);
for (n = TX_4X4; n <= max_txfm_size; n++) {r[n][1] = r[n][0];
@@ -981,7 +981,7 @@
VP9_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
- vp9_prob skip_prob = vp9_get_pred_prob(cm, xd, PRED_MBSKIP);
+ vp9_prob skip_prob = vp9_get_pred_prob_mbskip(cm, xd);
int64_t rd[TX_SIZE_MAX_SB][2];
int n, m;
int s0, s1;
@@ -988,7 +988,7 @@
double scale_rd[TX_SIZE_MAX_SB] = {1.73, 1.44, 1.20, 1.00}; // double scale_r[TX_SIZE_MAX_SB] = {2.82, 2.00, 1.41, 1.00};- const vp9_prob *tx_probs = vp9_get_pred_probs(cm, xd, PRED_TX_SIZE);
+ const vp9_prob *tx_probs = vp9_get_pred_probs_tx_size(cm, xd);
// for (n = TX_4X4; n <= max_txfm_size; n++)
// r[n][0] = (r[n][0] * scale_r[n]);
@@ -2136,11 +2136,11 @@
vpx_memset(ref_costs_comp, 0, MAX_REF_FRAMES * sizeof(*ref_costs_comp));
*comp_mode_p = 128;
} else {- vp9_prob intra_inter_p = vp9_get_pred_prob(cm, xd, PRED_INTRA_INTER);
+ vp9_prob intra_inter_p = vp9_get_pred_prob_intra_inter(cm, xd);
vp9_prob comp_inter_p = 128;
if (cm->comp_pred_mode == HYBRID_PREDICTION) {- comp_inter_p = vp9_get_pred_prob(cm, xd, PRED_COMP_INTER_INTER);
+ comp_inter_p = vp9_get_pred_prob_comp_inter_inter(cm, xd);
*comp_mode_p = comp_inter_p;
} else {*comp_mode_p = 128;
@@ -2149,8 +2149,8 @@
ref_costs_single[INTRA_FRAME] = vp9_cost_bit(intra_inter_p, 0);
if (cm->comp_pred_mode != COMP_PREDICTION_ONLY) {- vp9_prob ref_single_p1 = vp9_get_pred_prob(cm, xd, PRED_SINGLE_REF_P1);
- vp9_prob ref_single_p2 = vp9_get_pred_prob(cm, xd, PRED_SINGLE_REF_P2);
+ vp9_prob ref_single_p1 = vp9_get_pred_prob_single_ref_p1(cm, xd);
+ vp9_prob ref_single_p2 = vp9_get_pred_prob_single_ref_p2(cm, xd);
unsigned int base_cost = vp9_cost_bit(intra_inter_p, 1);
if (cm->comp_pred_mode == HYBRID_PREDICTION)
@@ -2169,7 +2169,7 @@
ref_costs_single[ALTREF_FRAME] = 512;
}
if (cm->comp_pred_mode != SINGLE_PREDICTION_ONLY) {- vp9_prob ref_comp_p = vp9_get_pred_prob(cm, xd, PRED_COMP_REF_P);
+ vp9_prob ref_comp_p = vp9_get_pred_prob_comp_ref_p(cm, xd);
unsigned int base_cost = vp9_cost_bit(intra_inter_p, 1);
if (cm->comp_pred_mode == HYBRID_PREDICTION)
@@ -2305,7 +2305,7 @@
MACROBLOCKD *xd = &x->e_mbd;
MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
- const int c = vp9_get_pred_context(cm, xd, PRED_SWITCHABLE_INTERP);
+ const int c = vp9_get_pred_context_switchable_interp(cm, xd);
const int m = vp9_switchable_interp_map[mbmi->interp_filter];
return SWITCHABLE_INTERP_RATE_FACTOR * x->switchable_interp_costs[c][m];
}
@@ -2879,7 +2879,7 @@
if (y_skip && uv_skip) {*returnrate = rate_y + rate_uv - rate_y_tokenonly - rate_uv_tokenonly +
- vp9_cost_bit(vp9_get_pred_prob(cm, xd, PRED_MBSKIP), 1);
+ vp9_cost_bit(vp9_get_pred_prob_mbskip(cm, xd), 1);
*returndist = dist_y + (dist_uv >> 2);
memset(ctx->txfm_rd_diff, 0, sizeof(ctx->txfm_rd_diff));
xd->mode_info_context->mbmi.mode = mode;
@@ -2886,7 +2886,7 @@
xd->mode_info_context->mbmi.txfm_size = txfm_size;
} else if (bsize < BLOCK_SIZE_SB8X8 && err4x4 < err) {*returnrate = rate4x4_y + rate_uv +
- vp9_cost_bit(vp9_get_pred_prob(cm, xd, PRED_MBSKIP), 0);
+ vp9_cost_bit(vp9_get_pred_prob_mbskip(cm, xd), 0);
*returndist = dist4x4_y + (dist_uv >> 2);
vpx_memset(ctx->txfm_rd_diff, 0, sizeof(ctx->txfm_rd_diff));
xd->mode_info_context->mbmi.txfm_size = TX_4X4;
@@ -2893,7 +2893,7 @@
} else {int i;
*returnrate = rate_y + rate_uv +
- vp9_cost_bit(vp9_get_pred_prob(cm, xd, PRED_MBSKIP), 0);
+ vp9_cost_bit(vp9_get_pred_prob_mbskip(cm, xd), 0);
*returndist = dist_y + (dist_uv >> 2);
if (cpi->sf.tx_size_search_method == USE_FULL_RD) { for (i = 0; i < NB_TXFM_MODES; i++) {@@ -3471,7 +3471,7 @@
// Cost the skip mb case
vp9_prob skip_prob =
- vp9_get_pred_prob(cm, xd, PRED_MBSKIP);
+ vp9_get_pred_prob_mbskip(cm, xd);
if (skip_prob) {prob_skip_cost = vp9_cost_bit(skip_prob, 1);
@@ -3483,13 +3483,13 @@
if (RDCOST(x->rdmult, x->rddiv, rate_y + rate_uv, distortion2) <
RDCOST(x->rdmult, x->rddiv, 0, total_sse)) {// Add in the cost of the no skip flag.
- int prob_skip_cost = vp9_cost_bit(vp9_get_pred_prob(cm, xd,
- PRED_MBSKIP), 0);
+ int prob_skip_cost = vp9_cost_bit(vp9_get_pred_prob_mbskip(cm, xd),
+ 0);
rate2 += prob_skip_cost;
} else {// FIXME(rbultje) make this work for splitmv also
- int prob_skip_cost = vp9_cost_bit(vp9_get_pred_prob(cm, xd,
- PRED_MBSKIP), 1);
+ int prob_skip_cost = vp9_cost_bit(vp9_get_pred_prob_mbskip(cm, xd),
+ 1);
rate2 += prob_skip_cost;
distortion2 = total_sse;
assert(total_sse >= 0);
@@ -3500,8 +3500,8 @@
}
} else if (mb_skip_allowed) {// Add in the cost of the no skip flag.
- int prob_skip_cost = vp9_cost_bit(vp9_get_pred_prob(cm, xd,
- PRED_MBSKIP), 0);
+ int prob_skip_cost = vp9_cost_bit(vp9_get_pred_prob_mbskip(cm, xd),
+ 0);
rate2 += prob_skip_cost;
}
--- a/vp9/encoder/vp9_segmentation.c
+++ b/vp9/encoder/vp9_segmentation.c
@@ -141,11 +141,11 @@
const int pred_segment_id = vp9_get_segment_id(cm, cm->last_frame_seg_map,
bsize, mi_row, mi_col);
const int pred_flag = pred_segment_id == segment_id;
- const int pred_context = vp9_get_pred_context(cm, xd, PRED_SEG_ID);
+ const int pred_context = vp9_get_pred_context_seg_id(cm, xd);
// Store the prediction status for this mb and update counts
// as appropriate
- vp9_set_pred_flag(xd, bsize, PRED_SEG_ID, pred_flag);
+ vp9_set_pred_flag_seg_id(xd, bsize, pred_flag);
temporal_predictor_count[pred_context][pred_flag]++;
if (!pred_flag)
--- a/vp9/encoder/vp9_tokenize.c
+++ b/vp9/encoder/vp9_tokenize.c
@@ -273,7 +273,7 @@
VP9_COMMON * const cm = &cpi->common;
MB_MODE_INFO * const mbmi = &xd->mode_info_context->mbmi;
TOKENEXTRA *t_backup = *t;
- const int mb_skip_context = vp9_get_pred_context(cm, xd, PRED_MBSKIP);
+ const int mb_skip_context = vp9_get_pred_context_mbskip(cm, xd);
const int segment_id = mbmi->segment_id;
const int skip_inc = !vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP);
const TX_SIZE txfm_size = mbmi->txfm_size;