generic-library/vpx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

removing case statements around prediction entropy coding

Browse Source 
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
This commit is contained in:
Jim Bankoski 2013-07-09 19:55:07 -07:00 committed by Gerrit Code Review
parent 059f2929e9
commit fb027a7658
9 changed files with 625 additions and 544 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

901
vp9/common/vp9_pred_common.c
View File

@ -16,446 +16,7 @@
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_treecoder.h"
// TBD prediction functions for various bitstream signals
// 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) {
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.
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;
case PRED_MBSKIP:
pred_context = above_mi->mbmi.mb_skip_coeff;
if (xd->left_available)
pred_context += left_mi->mbmi.mb_skip_coeff;
break;
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;
// 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;
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;
}
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;
}
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;
}
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;
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] :
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];
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;
}
}
} 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[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);
break;
}
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[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 ?
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 == 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;
}
assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
break;
}
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[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;
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;
}
} 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;
}
assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
break;
}
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);
}
if (left_in_image) {
left_context = (left_mi->mbmi.mb_skip_coeff ?
max_tx_size : left_mi->mbmi.txfm_size);
}
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);
break;
}
default:
assert(0);
pred_context = 0; // *** add error trap code.
break;
}
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.
}
}
// 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.
}
}
// 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.
}
}
// 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_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);
@ -466,24 +27,454 @@ void vp9_set_pred_flag(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize, PRED_ID pred_id,
#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;
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_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 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.
// 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:
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;
// 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;
default:
assert(0);
// *** add error trap code.
break;
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;
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;
// 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;
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;
}
// 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 (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];
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;
}
}
} 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[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);
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 ?
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 == 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;
}
assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
return pred_context;
}
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;
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;
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;
}
} 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;
}
assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
return pred_context;
}
// 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);
}
if (left_in_image) {
left_context = (
left_mi->mbmi.mb_skip_coeff ? max_tx_size : left_mi->mbmi.txfm_size);
}
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_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);
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.mb_skip_coeff = pred_flag;
}
int vp9_get_segment_id(VP9_COMMON *cm, const uint8_t *segment_ids,

145
vp9/common/vp9_pred_common.h
View File

@ -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;
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);
const vp9_prob *vp9_get_pred_probs(const VP9_COMMON *cm, const MACROBLOCKD *xd,
PRED_ID pred_id);
unsigned char vp9_get_pred_flag(const MACROBLOCKD *xd, PRED_ID pred_id);
void vp9_set_pred_flag(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize, PRED_ID pred_id,
unsigned char pred_flag);
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 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;
}
void vp9_set_pred_flag_seg_id(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize,
unsigned char pred_flag);
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);
unsigned char vp9_get_pred_context_switchable_interp(const VP9_COMMON *cm,
const MACROBLOCKD *xd);
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_

28
vp9/decoder/vp9_decodemv.c
View File

@ -50,8 +50,8 @@ static int read_segment_id(vp9_reader *r, MACROBLOCKD *xd) {
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 @@ static uint8_t read_skip_coeff(VP9D_COMP *pbi, int segment_id, vp9_reader *r) {
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 @@ static void read_ref_frame(VP9D_COMP *pbi, vp9_reader *r,
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 @@ static void read_ref_frame(VP9D_COMP *pbi, vp9_reader *r,
// 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 @@ static int read_inter_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
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 @@ static INLINE INTERPOLATIONFILTERTYPE read_switchable_filter_type(
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 @@ static MV_REFERENCE_FRAME read_reference_frame(VP9D_COMP *pbi, int segment_id,
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)

2
vp9/decoder/vp9_decodframe.c
View File

@ -271,7 +271,7 @@ static void decode_modes_b(VP9D_COMP *pbi, int mi_row, int mi_col,
} 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);
}

20
vp9/encoder/vp9_bitstream.c
View File

@ -204,7 +204,7 @@ static void write_selected_txfm_size(const VP9_COMP *cpi, TX_SIZE tx_size,
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 @@ static int write_skip_coeff(const VP9_COMP *cpi, int segment_id, MODE_INFO *m,
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 @@ static void encode_ref_frame(VP9_COMP *cpi, vp9_writer *bc) {
// (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 @@ static void encode_ref_frame(VP9_COMP *cpi, vp9_writer *bc) {
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 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m,
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 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m,
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 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m,
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 {

27
vp9/encoder/vp9_encodeframe.c
View File

@ -422,9 +422,9 @@ static void update_state(VP9_COMP *cpi, PICK_MODE_CONTEXT *ctx,
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 @@ static void update_stats(VP9_COMP *cpi, int mi_row, int mi_col) {
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 @@ static void update_stats(VP9_COMP *cpi, int mi_row, int mi_col) {
// 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,14 +2367,14 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, int output_enabled,
// 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
&& !(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) {

40
vp9/encoder/vp9_rdopt.c
View File

@ -877,12 +877,12 @@ static void choose_txfm_size_from_rd(VP9_COMP *cpi, MACROBLOCK *x,
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,14 +981,14 @@ static void choose_txfm_size_from_modelrd(VP9_COMP *cpi, MACROBLOCK *x,
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;
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 @@ static void estimate_ref_frame_costs(VP9_COMP *cpi, int segment_id,
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 @@ static void estimate_ref_frame_costs(VP9_COMP *cpi, int segment_id,
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 @@ static void estimate_ref_frame_costs(VP9_COMP *cpi, int segment_id,
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 @@ static INLINE int get_switchable_rate(VP9_COMMON *cm, MACROBLOCK *x) {
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,21 +2879,21 @@ void vp9_rd_pick_intra_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
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;
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;
} 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 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
// 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 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
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 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
}
} 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;
}

4
vp9/encoder/vp9_segmentation.c
View File

@ -141,11 +141,11 @@ static void count_segs(VP9_COMP *cpi, MODE_INFO *mi,
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)

2
vp9/encoder/vp9_tokenize.c
View File

@ -273,7 +273,7 @@ void vp9_tokenize_sb(VP9_COMP *cpi,
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;