summaryrefslogtreecommitdiffstats
path: root/third_party/aom/av1/common/pred_common.c
diff options
context:
space:
mode:
authortrav90 <travawine@palemoon.org>2018-10-18 06:04:57 -0500
committertrav90 <travawine@palemoon.org>2018-10-18 06:04:57 -0500
commit7369c7d7a5eed32963d8af37658286617919f91c (patch)
tree5397ce7ee9bca1641118fdc3187bd9e2b24fdc9c /third_party/aom/av1/common/pred_common.c
parent77887af9c4ad1420bbdb33984af4f74b55ca59db (diff)
downloadUXP-7369c7d7a5eed32963d8af37658286617919f91c.tar
UXP-7369c7d7a5eed32963d8af37658286617919f91c.tar.gz
UXP-7369c7d7a5eed32963d8af37658286617919f91c.tar.lz
UXP-7369c7d7a5eed32963d8af37658286617919f91c.tar.xz
UXP-7369c7d7a5eed32963d8af37658286617919f91c.zip
Update aom to commit id f5bdeac22930ff4c6b219be49c843db35970b918
Diffstat (limited to 'third_party/aom/av1/common/pred_common.c')
-rw-r--r--third_party/aom/av1/common/pred_common.c475
1 files changed, 415 insertions, 60 deletions
diff --git a/third_party/aom/av1/common/pred_common.c b/third_party/aom/av1/common/pred_common.c
index 51c343d19..0417a67f8 100644
--- a/third_party/aom/av1/common/pred_common.c
+++ b/third_party/aom/av1/common/pred_common.c
@@ -223,27 +223,34 @@ int av1_get_intra_inter_context(const MACROBLOCKD *xd) {
// The compound/single mode info data structure has one element border above and
// to the left of the entries corresponding to real macroblocks.
// The prediction flags in these dummy entries are initialized to 0.
-// 0 - single/single
-// 1 - single/--, --/single, --/--
-// 2 - single/comp, comp/single
-// 3 - comp/comp, comp/--, --/comp
int av1_get_inter_mode_context(const MACROBLOCKD *xd) {
const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;
const int has_above = xd->up_available;
const int has_left = xd->left_available;
- if (has_above && has_left) { // both edges available (0/2/3)
- const int above_inter_comp_mode = is_inter_compound_mode(above_mbmi->mode);
- const int left_inter_comp_mode = is_inter_compound_mode(left_mbmi->mode);
- return (above_inter_comp_mode && left_inter_comp_mode)
- ? 3
- : (above_inter_comp_mode || left_inter_comp_mode) * 2;
- } else if (has_above || has_left) { // one edge available (1/3)
+ if (has_above && has_left) { // both edges available
+ const int above_inter_comp_mode =
+ is_inter_anyref_comp_mode(above_mbmi->mode);
+ const int left_inter_comp_mode = is_inter_anyref_comp_mode(left_mbmi->mode);
+ if (above_inter_comp_mode && left_inter_comp_mode)
+ return 0;
+ else if (above_inter_comp_mode || left_inter_comp_mode)
+ return 1;
+ else if (!is_inter_block(above_mbmi) && !is_inter_block(left_mbmi))
+ return 2;
+ else
+ return 3;
+ } else if (has_above || has_left) { // one edge available
const MB_MODE_INFO *const edge_mbmi = has_above ? above_mbmi : left_mbmi;
- return is_inter_compound_mode(edge_mbmi->mode) ? 3 : 1;
- } else { // no edge available (1)
- return 1;
+ if (is_inter_anyref_comp_mode(edge_mbmi->mode))
+ return 1;
+ else if (!is_inter_block(edge_mbmi))
+ return 2;
+ else
+ return 3;
+ } else { // no edge available
+ return 2;
}
}
#endif // CONFIG_EXT_INTER && CONFIG_COMPOUND_SINGLEREF
@@ -256,6 +263,9 @@ int av1_get_inter_mode_context(const MACROBLOCKD *xd) {
#define IS_BACKWARD_REF_FRAME(ref_frame) ((ref_frame) == cm->comp_fixed_ref)
#endif // CONFIG_EXT_REFS
+#define CHECK_GOLDEN_OR_LAST3(ref_frame) \
+ (((ref_frame) == GOLDEN_FRAME) || ((ref_frame) == LAST3_FRAME))
+
int av1_get_reference_mode_context(const AV1_COMMON *cm,
const MACROBLOCKD *xd) {
int ctx;
@@ -303,6 +313,247 @@ int av1_get_reference_mode_context(const AV1_COMMON *cm,
return ctx;
}
+#if CONFIG_EXT_COMP_REFS
+#define CHECK_BWDREF_OR_ALTREF(ref_frame) \
+ ((ref_frame) == BWDREF_FRAME || (ref_frame) == ALTREF_FRAME)
+// TODO(zoeliu): To try on the design of 3 contexts, instead of 5:
+// COMP_REF_TYPE_CONTEXTS = 3
+int av1_get_comp_reference_type_context(const MACROBLOCKD *xd) {
+ int pred_context;
+ const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
+ const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;
+ const int above_in_image = xd->up_available;
+ const int left_in_image = xd->left_available;
+
+ if (above_in_image && left_in_image) { // both edges available
+ const int above_intra = !is_inter_block(above_mbmi);
+ const int left_intra = !is_inter_block(left_mbmi);
+
+ if (above_intra && left_intra) { // intra/intra
+ pred_context = 2;
+ } else if (above_intra || left_intra) { // intra/inter
+ const MB_MODE_INFO *inter_mbmi = above_intra ? left_mbmi : above_mbmi;
+
+ if (!has_second_ref(inter_mbmi)) // single pred
+ pred_context = 2;
+ else // comp pred
+ pred_context = 1 + 2 * has_uni_comp_refs(inter_mbmi);
+ } else { // inter/inter
+ const int a_sg = !has_second_ref(above_mbmi);
+ const int l_sg = !has_second_ref(left_mbmi);
+ const MV_REFERENCE_FRAME frfa = above_mbmi->ref_frame[0];
+ const MV_REFERENCE_FRAME frfl = left_mbmi->ref_frame[0];
+
+ if (a_sg && l_sg) { // single/single
+ pred_context = 1 +
+ 2 * (!(CHECK_BWDREF_OR_ALTREF(frfa) ^
+ CHECK_BWDREF_OR_ALTREF(frfl)));
+ } else if (l_sg || a_sg) { // single/comp
+ const int uni_rfc =
+ a_sg ? has_uni_comp_refs(left_mbmi) : has_uni_comp_refs(above_mbmi);
+
+ if (!uni_rfc) // comp bidir
+ pred_context = 1;
+ else // comp unidir
+ pred_context = 3 + (!(CHECK_BWDREF_OR_ALTREF(frfa) ^
+ CHECK_BWDREF_OR_ALTREF(frfl)));
+ } else { // comp/comp
+ const int a_uni_rfc = has_uni_comp_refs(above_mbmi);
+ const int l_uni_rfc = has_uni_comp_refs(left_mbmi);
+
+ if (!a_uni_rfc && !l_uni_rfc) // bidir/bidir
+ pred_context = 0;
+ else if (!a_uni_rfc || !l_uni_rfc) // unidir/bidir
+ pred_context = 2;
+ else // unidir/unidir
+ pred_context =
+ 3 + (!((frfa == BWDREF_FRAME) ^ (frfl == BWDREF_FRAME)));
+ }
+ }
+ } else if (above_in_image || left_in_image) { // one edge available
+ const MB_MODE_INFO *edge_mbmi = above_in_image ? above_mbmi : left_mbmi;
+
+ if (!is_inter_block(edge_mbmi)) { // intra
+ pred_context = 2;
+ } else { // inter
+ if (!has_second_ref(edge_mbmi)) // single pred
+ pred_context = 2;
+ else // comp pred
+ pred_context = 4 * has_uni_comp_refs(edge_mbmi);
+ }
+ } else { // no edges available
+ pred_context = 2;
+ }
+
+ assert(pred_context >= 0 && pred_context < COMP_REF_TYPE_CONTEXTS);
+ return pred_context;
+}
+
+// Returns a context number for the given MB prediction signal
+//
+// Signal the uni-directional compound reference frame pair as either
+// (BWDREF, ALTREF), or (LAST, LAST2) / (LAST, LAST3) / (LAST, GOLDEN),
+// conditioning on the pair is known as uni-directional.
+//
+// 3 contexts: Voting is used to compare the count of forward references with
+// that of backward references from the spatial neighbors.
+int av1_get_pred_context_uni_comp_ref_p(const MACROBLOCKD *xd) {
+ int pred_context;
+ const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
+ const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;
+ const int above_in_image = xd->up_available;
+ const int left_in_image = xd->left_available;
+
+ // Count of forward references (L, L2, L3, or G)
+ int frf_count = 0;
+ // Count of backward references (B or A)
+ int brf_count = 0;
+
+ if (above_in_image && is_inter_block(above_mbmi)) {
+ if (above_mbmi->ref_frame[0] <= GOLDEN_FRAME)
+ ++frf_count;
+ else
+ ++brf_count;
+ if (has_second_ref(above_mbmi)) {
+ if (above_mbmi->ref_frame[1] <= GOLDEN_FRAME)
+ ++frf_count;
+ else
+ ++brf_count;
+ }
+ }
+
+ if (left_in_image && is_inter_block(left_mbmi)) {
+ if (left_mbmi->ref_frame[0] <= GOLDEN_FRAME)
+ ++frf_count;
+ else
+ ++brf_count;
+ if (has_second_ref(left_mbmi)) {
+ if (left_mbmi->ref_frame[1] <= GOLDEN_FRAME)
+ ++frf_count;
+ else
+ ++brf_count;
+ }
+ }
+
+ pred_context =
+ (frf_count == brf_count) ? 1 : ((frf_count < brf_count) ? 0 : 2);
+
+ assert(pred_context >= 0 && pred_context < UNI_COMP_REF_CONTEXTS);
+ return pred_context;
+}
+
+// Returns a context number for the given MB prediction signal
+//
+// Signal the uni-directional compound reference frame pair as
+// either (LAST, LAST2), or (LAST, LAST3) / (LAST, GOLDEN),
+// conditioning on the pair is known as one of the above three.
+//
+// 3 contexts: Voting is used to compare the count of LAST2_FRAME with the
+// total count of LAST3/GOLDEN from the spatial neighbors.
+int av1_get_pred_context_uni_comp_ref_p1(const MACROBLOCKD *xd) {
+ int pred_context;
+ const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
+ const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;
+ const int above_in_image = xd->up_available;
+ const int left_in_image = xd->left_available;
+
+ // Count of LAST2
+ int last2_count = 0;
+ // Count of LAST3 or GOLDEN
+ int last3_or_gld_count = 0;
+
+ if (above_in_image && is_inter_block(above_mbmi)) {
+ last2_count = (above_mbmi->ref_frame[0] == LAST2_FRAME) ? last2_count + 1
+ : last2_count;
+ last3_or_gld_count = CHECK_GOLDEN_OR_LAST3(above_mbmi->ref_frame[0])
+ ? last3_or_gld_count + 1
+ : last3_or_gld_count;
+ if (has_second_ref(above_mbmi)) {
+ last2_count = (above_mbmi->ref_frame[1] == LAST2_FRAME) ? last2_count + 1
+ : last2_count;
+ last3_or_gld_count = CHECK_GOLDEN_OR_LAST3(above_mbmi->ref_frame[1])
+ ? last3_or_gld_count + 1
+ : last3_or_gld_count;
+ }
+ }
+
+ if (left_in_image && is_inter_block(left_mbmi)) {
+ last2_count = (left_mbmi->ref_frame[0] == LAST2_FRAME) ? last2_count + 1
+ : last2_count;
+ last3_or_gld_count = CHECK_GOLDEN_OR_LAST3(left_mbmi->ref_frame[0])
+ ? last3_or_gld_count + 1
+ : last3_or_gld_count;
+ if (has_second_ref(left_mbmi)) {
+ last2_count = (left_mbmi->ref_frame[1] == LAST2_FRAME) ? last2_count + 1
+ : last2_count;
+ last3_or_gld_count = CHECK_GOLDEN_OR_LAST3(left_mbmi->ref_frame[1])
+ ? last3_or_gld_count + 1
+ : last3_or_gld_count;
+ }
+ }
+
+ pred_context = (last2_count == last3_or_gld_count)
+ ? 1
+ : ((last2_count < last3_or_gld_count) ? 0 : 2);
+
+ assert(pred_context >= 0 && pred_context < UNI_COMP_REF_CONTEXTS);
+ return pred_context;
+}
+
+// Returns a context number for the given MB prediction signal
+//
+// Signal the uni-directional compound reference frame pair as
+// either (LAST, LAST3) or (LAST, GOLDEN),
+// conditioning on the pair is known as one of the above two.
+//
+// 3 contexts: Voting is used to compare the count of LAST3_FRAME with the
+// total count of GOLDEN_FRAME from the spatial neighbors.
+int av1_get_pred_context_uni_comp_ref_p2(const MACROBLOCKD *xd) {
+ int pred_context;
+ const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
+ const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;
+ const int above_in_image = xd->up_available;
+ const int left_in_image = xd->left_available;
+
+ // Count of LAST3
+ int last3_count = 0;
+ // Count of GOLDEN
+ int gld_count = 0;
+
+ if (above_in_image && is_inter_block(above_mbmi)) {
+ last3_count = (above_mbmi->ref_frame[0] == LAST3_FRAME) ? last3_count + 1
+ : last3_count;
+ gld_count =
+ (above_mbmi->ref_frame[0] == GOLDEN_FRAME) ? gld_count + 1 : gld_count;
+ if (has_second_ref(above_mbmi)) {
+ last3_count = (above_mbmi->ref_frame[1] == LAST3_FRAME) ? last3_count + 1
+ : last3_count;
+ gld_count = (above_mbmi->ref_frame[1] == GOLDEN_FRAME) ? gld_count + 1
+ : gld_count;
+ }
+ }
+
+ if (left_in_image && is_inter_block(left_mbmi)) {
+ last3_count = (left_mbmi->ref_frame[0] == LAST3_FRAME) ? last3_count + 1
+ : last3_count;
+ gld_count =
+ (left_mbmi->ref_frame[0] == GOLDEN_FRAME) ? gld_count + 1 : gld_count;
+ if (has_second_ref(left_mbmi)) {
+ last3_count = (left_mbmi->ref_frame[1] == LAST3_FRAME) ? last3_count + 1
+ : last3_count;
+ gld_count =
+ (left_mbmi->ref_frame[1] == GOLDEN_FRAME) ? gld_count + 1 : gld_count;
+ }
+ }
+
+ pred_context =
+ (last3_count == gld_count) ? 1 : ((last3_count < gld_count) ? 0 : 2);
+
+ assert(pred_context >= 0 && pred_context < UNI_COMP_REF_CONTEXTS);
+ return pred_context;
+}
+#endif // CONFIG_EXT_COMP_REFS
+
#if CONFIG_EXT_REFS
// TODO(zoeliu): Future work will be conducted to optimize the context design
@@ -311,22 +562,14 @@ int av1_get_reference_mode_context(const AV1_COMMON *cm,
#define CHECK_LAST_OR_LAST2(ref_frame) \
((ref_frame == LAST_FRAME) || (ref_frame == LAST2_FRAME))
-#define CHECK_GOLDEN_OR_LAST3(ref_frame) \
- ((ref_frame == GOLDEN_FRAME) || (ref_frame == LAST3_FRAME))
-
// Returns a context number for the given MB prediction signal
// Signal the first reference frame for a compound mode be either
// GOLDEN/LAST3, or LAST/LAST2.
//
// NOTE(zoeliu): The probability of ref_frame[0] is either
// GOLDEN_FRAME or LAST3_FRAME.
-#if CONFIG_ONE_SIDED_COMPOUND
-int av1_get_pred_context_comp_ref_p(UNUSED const AV1_COMMON *cm,
- const MACROBLOCKD *xd) {
-#else
int av1_get_pred_context_comp_ref_p(const AV1_COMMON *cm,
const MACROBLOCKD *xd) {
-#endif
int pred_context;
const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;
@@ -337,14 +580,16 @@ int av1_get_pred_context_comp_ref_p(const AV1_COMMON *cm,
// 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 CONFIG_ONE_SIDED_COMPOUND // No change to bitstream
+#if CONFIG_ONE_SIDED_COMPOUND || CONFIG_EXT_COMP_REFS // No change to bitstream
// Code seems to assume that signbias of cm->comp_bwd_ref[0] is always 1
const int bwd_ref_sign_idx = 1;
#else
const int bwd_ref_sign_idx = cm->ref_frame_sign_bias[cm->comp_bwd_ref[0]];
-#endif
+#endif // CONFIG_ONE_SIDED_COMPOUND || CONFIG_EXT_COMP_REFS
const int fwd_ref_sign_idx = !bwd_ref_sign_idx;
+ (void)cm;
+
if (above_in_image && left_in_image) { // both edges available
const int above_intra = !is_inter_block(above_mbmi);
const int left_intra = !is_inter_block(left_mbmi);
@@ -396,8 +641,11 @@ int av1_get_pred_context_comp_ref_p(const AV1_COMMON *cm,
if ((CHECK_LAST_OR_LAST2(frfa) && CHECK_LAST_OR_LAST2(frfl))) {
pred_context = 4;
} else {
- // NOTE(zoeliu): Following assert may be removed once confirmed.
+// NOTE(zoeliu): Following assert may be removed once confirmed.
+#if !USE_UNI_COMP_REFS
+ // TODO(zoeliu): To further study the UNIDIR scenario
assert(CHECK_GOLDEN_OR_LAST3(frfa) || CHECK_GOLDEN_OR_LAST3(frfl));
+#endif // !USE_UNI_COMP_REFS
pred_context = 2;
}
}
@@ -430,13 +678,8 @@ int av1_get_pred_context_comp_ref_p(const AV1_COMMON *cm,
//
// NOTE(zoeliu): The probability of ref_frame[0] is LAST_FRAME,
// conditioning on it is either LAST_FRAME or LAST2_FRAME.
-#if CONFIG_ONE_SIDED_COMPOUND
-int av1_get_pred_context_comp_ref_p1(UNUSED const AV1_COMMON *cm,
- const MACROBLOCKD *xd) {
-#else
int av1_get_pred_context_comp_ref_p1(const AV1_COMMON *cm,
const MACROBLOCKD *xd) {
-#endif
int pred_context;
const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;
@@ -447,14 +690,16 @@ int av1_get_pred_context_comp_ref_p1(const AV1_COMMON *cm,
// 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 CONFIG_ONE_SIDED_COMPOUND // No change to bitstream
+#if CONFIG_ONE_SIDED_COMPOUND || CONFIG_EXT_COMP_REFS // No change to bitstream
// Code seems to assume that signbias of cm->comp_bwd_ref[0] is always 1
const int bwd_ref_sign_idx = 1;
#else
const int bwd_ref_sign_idx = cm->ref_frame_sign_bias[cm->comp_bwd_ref[0]];
-#endif
+#endif // CONFIG_ONE_SIDED_COMPOUND || CONFIG_EXT_COMP_REFS
const int fwd_ref_sign_idx = !bwd_ref_sign_idx;
+ (void)cm;
+
if (above_in_image && left_in_image) { // both edges available
const int above_intra = !is_inter_block(above_mbmi);
const int left_intra = !is_inter_block(left_mbmi);
@@ -541,13 +786,8 @@ int av1_get_pred_context_comp_ref_p1(const AV1_COMMON *cm,
//
// NOTE(zoeliu): The probability of ref_frame[0] is GOLDEN_FRAME,
// conditioning on it is either GOLDEN or LAST3.
-#if CONFIG_ONE_SIDED_COMPOUND
-int av1_get_pred_context_comp_ref_p2(UNUSED const AV1_COMMON *cm,
- const MACROBLOCKD *xd) {
-#else
int av1_get_pred_context_comp_ref_p2(const AV1_COMMON *cm,
const MACROBLOCKD *xd) {
-#endif
int pred_context;
const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;
@@ -558,14 +798,16 @@ int av1_get_pred_context_comp_ref_p2(const AV1_COMMON *cm,
// 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 CONFIG_ONE_SIDED_COMPOUND // No change to bitstream
+#if CONFIG_ONE_SIDED_COMPOUND || CONFIG_EXT_COMP_REFS // No change to bitstream
// Code seems to assume that signbias of cm->comp_bwd_ref[0] is always 1
const int bwd_ref_sign_idx = 1;
#else
const int bwd_ref_sign_idx = cm->ref_frame_sign_bias[cm->comp_bwd_ref[0]];
-#endif
+#endif // CONFIG_ONE_SIDED_COMPOUND || CONFIG_EXT_COMP_REFS
const int fwd_ref_sign_idx = !bwd_ref_sign_idx;
+ (void)cm;
+
if (above_in_image && left_in_image) { // both edges available
const int above_intra = !is_inter_block(above_mbmi);
const int left_intra = !is_inter_block(left_mbmi);
@@ -645,14 +887,113 @@ int av1_get_pred_context_comp_ref_p2(const AV1_COMMON *cm,
return pred_context;
}
-// Returns a context number for the given MB prediction signal
-#if CONFIG_ONE_SIDED_COMPOUND
-int av1_get_pred_context_comp_bwdref_p(UNUSED const AV1_COMMON *cm,
+#if CONFIG_ALTREF2
+
+// Obtain contexts to signal a reference frame be either BWDREF/ALTREF2, or
+// ALTREF.
+int av1_get_pred_context_brfarf2_or_arf(const MACROBLOCKD *xd) {
+ const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
+ const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;
+ const int above_in_image = xd->up_available;
+ const int left_in_image = xd->left_available;
+
+ // Counts of BWDREF, ALTREF2, or ALTREF frames (B, A2, or A)
+ int bwdref_counts[ALTREF_FRAME - BWDREF_FRAME + 1] = { 0 };
+
+ if (above_in_image && is_inter_block(above_mbmi)) {
+ if (above_mbmi->ref_frame[0] >= BWDREF_FRAME)
+ ++bwdref_counts[above_mbmi->ref_frame[0] - BWDREF_FRAME];
+ if (has_second_ref(above_mbmi)) {
+ if (above_mbmi->ref_frame[1] >= BWDREF_FRAME)
+ ++bwdref_counts[above_mbmi->ref_frame[1] - BWDREF_FRAME];
+ }
+ }
+
+ if (left_in_image && is_inter_block(left_mbmi)) {
+ if (left_mbmi->ref_frame[0] >= BWDREF_FRAME)
+ ++bwdref_counts[left_mbmi->ref_frame[0] - BWDREF_FRAME];
+ if (has_second_ref(left_mbmi)) {
+ if (left_mbmi->ref_frame[1] >= BWDREF_FRAME)
+ ++bwdref_counts[left_mbmi->ref_frame[1] - BWDREF_FRAME];
+ }
+ }
+
+ const int brfarf2_count = bwdref_counts[BWDREF_FRAME - BWDREF_FRAME] +
+ bwdref_counts[ALTREF2_FRAME - BWDREF_FRAME];
+ const int arf_count = bwdref_counts[ALTREF_FRAME - BWDREF_FRAME];
+ const int pred_context =
+ (brfarf2_count == arf_count) ? 1 : ((brfarf2_count < arf_count) ? 0 : 2);
+
+ assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
+ return pred_context;
+}
+
+// Obtain contexts to signal a reference frame be either BWDREF or ALTREF2.
+int av1_get_pred_context_brf_or_arf2(const MACROBLOCKD *xd) {
+ const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
+ const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;
+ const int above_in_image = xd->up_available;
+ const int left_in_image = xd->left_available;
+
+ // Count of BWDREF frames (B)
+ int brf_count = 0;
+ // Count of ALTREF2 frames (A2)
+ int arf2_count = 0;
+
+ if (above_in_image && is_inter_block(above_mbmi)) {
+ if (above_mbmi->ref_frame[0] == BWDREF_FRAME)
+ ++brf_count;
+ else if (above_mbmi->ref_frame[0] == ALTREF2_FRAME)
+ ++arf2_count;
+ if (has_second_ref(above_mbmi)) {
+ if (above_mbmi->ref_frame[1] == BWDREF_FRAME)
+ ++brf_count;
+ else if (above_mbmi->ref_frame[1] == ALTREF2_FRAME)
+ ++arf2_count;
+ }
+ }
+
+ if (left_in_image && is_inter_block(left_mbmi)) {
+ if (left_mbmi->ref_frame[0] == BWDREF_FRAME)
+ ++brf_count;
+ else if (left_mbmi->ref_frame[0] == ALTREF2_FRAME)
+ ++arf2_count;
+ if (has_second_ref(left_mbmi)) {
+ if (left_mbmi->ref_frame[1] == BWDREF_FRAME)
+ ++brf_count;
+ else if (left_mbmi->ref_frame[1] == ALTREF2_FRAME)
+ ++arf2_count;
+ }
+ }
+
+ const int pred_context =
+ (brf_count == arf2_count) ? 1 : ((brf_count < arf2_count) ? 0 : 2);
+
+ assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
+ return pred_context;
+}
+
+// Signal the 2nd reference frame for a compound mode be either
+// ALTREF, or ALTREF2/BWDREF.
+int av1_get_pred_context_comp_bwdref_p(const AV1_COMMON *cm,
const MACROBLOCKD *xd) {
-#else
+ (void)cm;
+ return av1_get_pred_context_brfarf2_or_arf(xd);
+}
+
+// Signal the 2nd reference frame for a compound mode be either
+// ALTREF2 or BWDREF.
+int av1_get_pred_context_comp_bwdref_p1(const AV1_COMMON *cm,
+ const MACROBLOCKD *xd) {
+ (void)cm;
+ return av1_get_pred_context_brf_or_arf2(xd);
+}
+
+#else // !CONFIG_ALTREF2
+
+// Returns a context number for the given MB prediction signal
int av1_get_pred_context_comp_bwdref_p(const AV1_COMMON *cm,
const MACROBLOCKD *xd) {
-#endif
int pred_context;
const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;
@@ -663,14 +1004,16 @@ int av1_get_pred_context_comp_bwdref_p(const AV1_COMMON *cm,
// The mode info data structure has a one element border above and to the
// left of the entries corresponding to real macroblocks.
// The prediction flags in these dummy entries are initialized to 0.
-#if CONFIG_ONE_SIDED_COMPOUND // No change to bitstream
+#if CONFIG_ONE_SIDED_COMPOUND || CONFIG_EXT_COMP_REFS // No change to bitstream
// Code seems to assume that signbias of cm->comp_bwd_ref[0] is always 1
const int bwd_ref_sign_idx = 1;
#else
const int bwd_ref_sign_idx = cm->ref_frame_sign_bias[cm->comp_bwd_ref[0]];
-#endif
+#endif // CONFIG_ONE_SIDED_COMPOUND || CONFIG_EXT_COMP_REFS
const int fwd_ref_sign_idx = !bwd_ref_sign_idx;
+ (void)cm;
+
if (above_in_image && left_in_image) { // both edges available
const int above_intra = !is_inter_block(above_mbmi);
const int left_intra = !is_inter_block(left_mbmi);
@@ -709,8 +1052,11 @@ int av1_get_pred_context_comp_bwdref_p(const AV1_COMMON *cm,
a_brf == cm->comp_bwd_ref[1]) {
pred_context = 1;
} else {
- // NOTE: Backward ref should be either BWDREF or ALTREF.
+// NOTE: Backward ref should be either BWDREF or ALTREF.
+#if !USE_UNI_COMP_REFS
+ // TODO(zoeliu): To further study the UNIDIR scenario
assert(l_brf == a_brf && l_brf != cm->comp_bwd_ref[1]);
+#endif // !USE_UNI_COMP_REFS
pred_context = 3;
}
} else if (!l_comp && !a_comp) { // single/single
@@ -722,8 +1068,11 @@ int av1_get_pred_context_comp_bwdref_p(const AV1_COMMON *cm,
} else if (l_frf == a_frf) {
pred_context = 3;
} else {
+#if !USE_UNI_COMP_REFS
+ // TODO(zoeliu): To further study the UNIDIR scenario
assert(l_frf != a_frf && l_frf != cm->comp_bwd_ref[1] &&
a_frf != cm->comp_bwd_ref[1]);
+#endif // !USE_UNI_COMP_REFS
pred_context = 4;
}
} else { // comp/single
@@ -764,8 +1113,9 @@ int av1_get_pred_context_comp_bwdref_p(const AV1_COMMON *cm,
return pred_context;
}
+#endif // CONFIG_ALTREF2
-#else // CONFIG_EXT_REFS
+#else // !CONFIG_EXT_REFS
// Returns a context number for the given MB prediction signal
int av1_get_pred_context_comp_ref_p(const AV1_COMMON *cm,
@@ -854,10 +1204,8 @@ int av1_get_pred_context_comp_ref_p(const AV1_COMMON *cm,
#if CONFIG_EXT_REFS
-// For the bit to signal whether the single reference is a ALTREF_FRAME
-// or a BWDREF_FRAME.
-//
-// NOTE(zoeliu): The probability of ref_frame[0] is ALTREF/BWDREF.
+// For the bit to signal whether the single reference is a forward reference
+// frame or a backward reference frame.
int av1_get_pred_context_single_ref_p1(const MACROBLOCKD *xd) {
int pred_context;
const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
@@ -919,11 +1267,12 @@ int av1_get_pred_context_single_ref_p1(const MACROBLOCKD *xd) {
}
// For the bit to signal whether the single reference is ALTREF_FRAME or
-// BWDREF_FRAME, knowing that it shall be either of these 2 choices.
-//
-// NOTE(zoeliu): The probability of ref_frame[0] is ALTREF_FRAME, conditioning
-// on it is either ALTREF_FRAME/BWDREF_FRAME.
+// non-ALTREF backward reference frame, knowing that it shall be either of
+// these 2 choices.
int av1_get_pred_context_single_ref_p2(const MACROBLOCKD *xd) {
+#if CONFIG_ALTREF2
+ return av1_get_pred_context_brfarf2_or_arf(xd);
+#else // !CONFIG_ALTREF2
int pred_context;
const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;
@@ -1010,13 +1359,11 @@ int av1_get_pred_context_single_ref_p2(const MACROBLOCKD *xd) {
assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
return pred_context;
+#endif // CONFIG_ALTREF2
}
// For the bit to signal whether the single reference is LAST3/GOLDEN or
// LAST2/LAST, knowing that it shall be either of these 2 choices.
-//
-// NOTE(zoeliu): The probability of ref_frame[0] is LAST3/GOLDEN, conditioning
-// on it is either LAST3/GOLDEN/LAST2/LAST.
int av1_get_pred_context_single_ref_p3(const MACROBLOCKD *xd) {
int pred_context;
const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
@@ -1293,7 +1640,15 @@ int av1_get_pred_context_single_ref_p5(const MACROBLOCKD *xd) {
return pred_context;
}
-#else // CONFIG_EXT_REFS
+#if CONFIG_ALTREF2
+// For the bit to signal whether the single reference is ALTREF2_FRAME or
+// BWDREF_FRAME, knowing that it shall be either of these 2 choices.
+int av1_get_pred_context_single_ref_p6(const MACROBLOCKD *xd) {
+ return av1_get_pred_context_brf_or_arf2(xd);
+}
+#endif // CONFIG_ALTREF2
+
+#else // !CONFIG_EXT_REFS
int av1_get_pred_context_single_ref_p1(const MACROBLOCKD *xd) {
int pred_context;