Rename ZEROMV to GLOBALMV
This name better reflects the functionality of the mode.
Change-Id: Idc2372e7c7b226f70f63fa4f272a88cb4d857089
diff --git a/av1/common/av1_loopfilter.c b/av1/common/av1_loopfilter.c
index 2976422..0fe2d3e 100644
--- a/av1/common/av1_loopfilter.c
+++ b/av1/common/av1_loopfilter.c
@@ -573,13 +573,13 @@
#if CONFIG_SMOOTH_HV
0, 0,
#endif // CONFIG_SMOOTH_HV
- 1, 1, 0, 1, // INTER_MODES (ZEROMV == 0)
+ 1, 1, 0, 1, // INTER_MODES (GLOBALMV == 0)
#if CONFIG_COMPOUND_SINGLEREF
// 1, 1, 1, 1, 1, // INTER_SINGLEREF_COMP_MODES
// NOTE(zoeliu): Remove SR_NEAREST_NEWMV
1, 1, 1, 1, // INTER_SINGLEREF_COMP_MODES
#endif // CONFIG_COMPOUND_SINGLEREF
- 1, 1, 1, 1, 1, 1, 0, 1 // INTER_COMPOUND_MODES (ZERO_ZEROMV == 0)
+ 1, 1, 1, 1, 1, 1, 0, 1 // INTER_COMPOUND_MODES (GLOBAL_GLOBALMV == 0)
};
static void update_sharpness(loop_filter_info_n *lfi, int sharpness_lvl) {
diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index f44b1c7..6818882 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -120,13 +120,13 @@
MB_MODE_COUNT, // PAETH_PRED
MB_MODE_COUNT, // NEARESTMV
MB_MODE_COUNT, // NEARMV
- MB_MODE_COUNT, // ZEROMV
+ MB_MODE_COUNT, // GLOBALMV
MB_MODE_COUNT, // NEWMV
#if CONFIG_COMPOUND_SINGLEREF
NEARESTMV, // SR_NEAREST_NEARMV
// NEARESTMV, // SR_NEAREST_NEWMV
NEARMV, // SR_NEAR_NEWMV
- ZEROMV, // SR_ZERO_NEWMV
+ GLOBALMV, // SR_ZERO_NEWMV
NEWMV, // SR_NEW_NEWMV
#endif // CONFIG_COMPOUND_SINGLEREF
NEARESTMV, // NEAREST_NEARESTMV
@@ -135,7 +135,7 @@
NEWMV, // NEW_NEARESTMV
NEARMV, // NEAR_NEWMV
NEWMV, // NEW_NEARMV
- ZEROMV, // ZERO_ZEROMV
+ GLOBALMV, // GLOBAL_GLOBALMV
NEWMV, // NEW_NEWMV
};
assert(NELEMENTS(lut) == MB_MODE_COUNT);
@@ -166,7 +166,7 @@
MB_MODE_COUNT, // PAETH_PRED
MB_MODE_COUNT, // NEARESTMV
MB_MODE_COUNT, // NEARMV
- MB_MODE_COUNT, // ZEROMV
+ MB_MODE_COUNT, // GLOBALMV
MB_MODE_COUNT, // NEWMV
#if CONFIG_COMPOUND_SINGLEREF
NEARMV, // SR_NEAREST_NEARMV
@@ -181,7 +181,7 @@
NEARESTMV, // NEW_NEARESTMV
NEWMV, // NEAR_NEWMV
NEARMV, // NEW_NEARMV
- ZEROMV, // ZERO_ZEROMV
+ GLOBALMV, // GLOBAL_GLOBALMV
NEWMV, // NEW_NEWMV
};
assert(NELEMENTS(lut) == MB_MODE_COUNT);
@@ -499,7 +499,7 @@
const int block_size_allowed =
AOMMIN(block_size_wide[bsize], block_size_high[bsize]) >= 8;
#endif // GLOBAL_SUB8X8_USED
- return (mode == ZEROMV || mode == ZERO_ZEROMV) && type > TRANSLATION &&
+ return (mode == GLOBALMV || mode == GLOBAL_GLOBALMV) && type > TRANSLATION &&
block_size_allowed;
}
@@ -1502,8 +1502,8 @@
const MB_MODE_INFO *const mbmi = &mi->mbmi;
int ref;
- // First check if all modes are ZEROMV
- if (mbmi->mode != ZEROMV && mbmi->mode != ZERO_ZEROMV) return 0;
+ // First check if all modes are GLOBALMV
+ if (mbmi->mode != GLOBALMV && mbmi->mode != GLOBAL_GLOBALMV) return 0;
#if !GLOBAL_SUB8X8_USED
if (mbmi->sb_type < BLOCK_8X8) return 0;
diff --git a/av1/common/entropymode.c b/av1/common/entropymode.c
index 1b36934..f028ec4 100644
--- a/av1/common/entropymode.c
+++ b/av1/common/entropymode.c
@@ -592,7 +592,7 @@
155, 116, 94, 32, 96, 56, 30,
};
-static const aom_prob default_zeromv_prob[ZEROMV_MODE_CONTEXTS] = {
+static const aom_prob default_zeromv_prob[GLOBALMV_MODE_CONTEXTS] = {
45, 13,
};
@@ -612,7 +612,7 @@
{ AOM_ICDF(128 * 96), AOM_ICDF(32768), 0 },
{ AOM_ICDF(128 * 56), AOM_ICDF(32768), 0 },
{ AOM_ICDF(128 * 30), AOM_ICDF(32768), 0 } };
-static const aom_cdf_prob default_zeromv_cdf[ZEROMV_MODE_CONTEXTS][CDF_SIZE(
+static const aom_cdf_prob default_zeromv_cdf[GLOBALMV_MODE_CONTEXTS][CDF_SIZE(
2)] = { { AOM_ICDF(128 * 45), AOM_ICDF(32768), 0 },
{ AOM_ICDF(128 * 13), AOM_ICDF(32768), 0 } };
static const aom_cdf_prob default_refmv_cdf[REFMV_MODE_CONTEXTS][CDF_SIZE(2)] =
@@ -1117,7 +1117,7 @@
const aom_tree_index av1_inter_compound_mode_tree
[TREE_SIZE(INTER_COMPOUND_MODES)] = {
- -INTER_COMPOUND_OFFSET(ZERO_ZEROMV), 2,
+ -INTER_COMPOUND_OFFSET(GLOBAL_GLOBALMV), 2,
-INTER_COMPOUND_OFFSET(NEAREST_NEARESTMV), 4,
6, -INTER_COMPOUND_OFFSET(NEW_NEWMV),
-INTER_COMPOUND_OFFSET(NEAR_NEARMV), 8,
@@ -6082,7 +6082,7 @@
for (i = 0; i < NEWMV_MODE_CONTEXTS; ++i)
fc->newmv_prob[i] =
av1_mode_mv_merge_probs(pre_fc->newmv_prob[i], counts->newmv_mode[i]);
- for (i = 0; i < ZEROMV_MODE_CONTEXTS; ++i)
+ for (i = 0; i < GLOBALMV_MODE_CONTEXTS; ++i)
fc->zeromv_prob[i] =
av1_mode_mv_merge_probs(pre_fc->zeromv_prob[i], counts->zeromv_mode[i]);
for (i = 0; i < REFMV_MODE_CONTEXTS; ++i)
diff --git a/av1/common/entropymode.h b/av1/common/entropymode.h
index 1ab613d..9d5c068 100644
--- a/av1/common/entropymode.h
+++ b/av1/common/entropymode.h
@@ -185,12 +185,12 @@
#endif
aom_prob newmv_prob[NEWMV_MODE_CONTEXTS];
- aom_prob zeromv_prob[ZEROMV_MODE_CONTEXTS];
+ aom_prob zeromv_prob[GLOBALMV_MODE_CONTEXTS];
aom_prob refmv_prob[REFMV_MODE_CONTEXTS];
aom_prob drl_prob[DRL_MODE_CONTEXTS];
#if CONFIG_NEW_MULTISYMBOL
aom_cdf_prob newmv_cdf[NEWMV_MODE_CONTEXTS][CDF_SIZE(2)];
- aom_cdf_prob zeromv_cdf[ZEROMV_MODE_CONTEXTS][CDF_SIZE(2)];
+ aom_cdf_prob zeromv_cdf[GLOBALMV_MODE_CONTEXTS][CDF_SIZE(2)];
aom_cdf_prob refmv_cdf[REFMV_MODE_CONTEXTS][CDF_SIZE(2)];
aom_cdf_prob drl_cdf[DRL_MODE_CONTEXTS][CDF_SIZE(2)];
#endif
@@ -440,7 +440,7 @@
#endif
unsigned int newmv_mode[NEWMV_MODE_CONTEXTS][2];
- unsigned int zeromv_mode[ZEROMV_MODE_CONTEXTS][2];
+ unsigned int zeromv_mode[GLOBALMV_MODE_CONTEXTS][2];
unsigned int refmv_mode[REFMV_MODE_CONTEXTS][2];
unsigned int drl_mode[DRL_MODE_CONTEXTS][2];
diff --git a/av1/common/enums.h b/av1/common/enums.h
index 43d4572..0fbd4e4 100644
--- a/av1/common/enums.h
+++ b/av1/common/enums.h
@@ -507,7 +507,7 @@
PAETH_PRED, // Predict from the direction of smallest gradient
NEARESTMV,
NEARMV,
- ZEROMV,
+ GLOBALMV,
NEWMV,
#if CONFIG_COMPOUND_SINGLEREF
// Single ref compound modes
@@ -524,7 +524,7 @@
NEW_NEARESTMV,
NEAR_NEWMV,
NEW_NEARMV,
- ZERO_ZEROMV,
+ GLOBAL_GLOBALMV,
NEW_NEWMV,
MB_MODE_COUNT,
INTRA_MODES = PAETH_PRED + 1, // PAETH_PRED has to be the last intra mode.
@@ -632,15 +632,15 @@
#define NMV_CONTEXTS 3
#define NEWMV_MODE_CONTEXTS 7
-#define ZEROMV_MODE_CONTEXTS 2
+#define GLOBALMV_MODE_CONTEXTS 2
#define REFMV_MODE_CONTEXTS 9
#define DRL_MODE_CONTEXTS 5
-#define ZEROMV_OFFSET 3
+#define GLOBALMV_OFFSET 3
#define REFMV_OFFSET 4
-#define NEWMV_CTX_MASK ((1 << ZEROMV_OFFSET) - 1)
-#define ZEROMV_CTX_MASK ((1 << (REFMV_OFFSET - ZEROMV_OFFSET)) - 1)
+#define NEWMV_CTX_MASK ((1 << GLOBALMV_OFFSET) - 1)
+#define GLOBALMV_CTX_MASK ((1 << (REFMV_OFFSET - GLOBALMV_OFFSET)) - 1)
#define REFMV_CTX_MASK ((1 << (8 - REFMV_OFFSET)) - 1)
#define ALL_ZERO_FLAG_OFFSET 8
diff --git a/av1/common/mvref_common.c b/av1/common/mvref_common.c
index 74fd116..3b41f58 100644
--- a/av1/common/mvref_common.c
+++ b/av1/common/mvref_common.c
@@ -476,7 +476,7 @@
if (blk_row == 0 && blk_col == 0)
if (abs(this_refmv.as_mv.row) >= 16 ||
abs(this_refmv.as_mv.col) >= 16)
- mode_context[ref_frame] |= (1 << ZEROMV_OFFSET);
+ mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET);
for (idx = 0; idx < *refmv_count; ++idx)
if (abs(this_refmv.as_mv.row - ref_mv_stack[idx].this_mv.as_mv.row) <
@@ -514,7 +514,7 @@
abs(this_refmv.as_mv.col) >= 16 ||
abs(comp_refmv.as_mv.row) >= 16 ||
abs(comp_refmv.as_mv.col) >= 16)
- mode_context[ref_frame] |= (1 << ZEROMV_OFFSET);
+ mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET);
for (idx = 0; idx < *refmv_count; ++idx)
if (abs(this_refmv.as_mv.row - ref_mv_stack[idx].this_mv.as_mv.row) <
@@ -597,7 +597,7 @@
#endif
{
if (abs(this_refmv.as_mv.row) >= 16 || abs(this_refmv.as_mv.col) >= 16)
- mode_context[ref_frame] |= (1 << ZEROMV_OFFSET);
+ mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET);
}
for (idx = 0; idx < *refmv_count; ++idx)
@@ -746,7 +746,7 @@
}
}
- if (coll_blk_count == 0) mode_context[ref_frame] |= (1 << ZEROMV_OFFSET);
+ if (coll_blk_count == 0) mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET);
for (i = 0; i < 9; ++i) {
blk_row = tpl_sample_pos[i][0];
@@ -822,9 +822,9 @@
}
#endif
- if (coll_blk_count == 0) mode_context[ref_frame] |= (1 << ZEROMV_OFFSET);
+ if (coll_blk_count == 0) mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET);
} else {
- mode_context[ref_frame] |= (1 << ZEROMV_OFFSET);
+ mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET);
}
#endif // CONFIG_MFMV
diff --git a/av1/common/mvref_common.h b/av1/common/mvref_common.h
index fd60335..b854304 100644
--- a/av1/common/mvref_common.h
+++ b/av1/common/mvref_common.h
@@ -61,7 +61,7 @@
9, // PAETH_PRED
0, // NEARESTMV
0, // NEARMV
- 3, // ZEROMV
+ 3, // GLOBALMV
1, // NEWMV
#if CONFIG_COMPOUND_SINGLEREF
0, // SR_NEAREST_NEARMV
@@ -76,7 +76,7 @@
1, // NEW_NEARESTMV
1, // NEAR_NEWMV
1, // NEW_NEARMV
- 3, // ZERO_ZEROMV
+ 3, // GLOBAL_GLOBALMV
1, // NEW_NEWMV
};
diff --git a/av1/common/seg_common.h b/av1/common/seg_common.h
index 6d16aed..f548276 100644
--- a/av1/common/seg_common.h
+++ b/av1/common/seg_common.h
@@ -35,8 +35,8 @@
SEG_LVL_ALT_LF_V, // Use alternate loop filter value on v plane
SEG_LVL_REF_FRAME, // Optional Segment reference frame
SEG_LVL_SKIP, // Optional Segment (0,0) + skip mode
-#if CONFIG_SEGMENT_ZEROMV
- SEG_LVL_ZEROMV,
+#if CONFIG_SEGMENT_GLOBALMV
+ SEG_LVL_GLOBALMV,
SEG_LVL_MAX
#else
SEG_LVL_MAX
@@ -49,8 +49,8 @@
SEG_LVL_ALT_LF = 1, // Use alternate loop filter value...
SEG_LVL_REF_FRAME = 2, // Optional Segment reference frame
SEG_LVL_SKIP = 3, // Optional Segment (0,0) + skip mode
-#if CONFIG_SEGMENT_ZEROMV
- SEG_LVL_ZEROMV = 4,
+#if CONFIG_SEGMENT_GLOBALMV
+ SEG_LVL_GLOBALMV = 4,
SEG_LVL_MAX = 5
#else
SEG_LVL_MAX = 4
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index ccbc04d..9b17cdc 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -151,7 +151,7 @@
int i;
for (i = 0; i < NEWMV_MODE_CONTEXTS; ++i)
av1_diff_update_prob(r, &fc->newmv_prob[i], ACCT_STR);
- for (i = 0; i < ZEROMV_MODE_CONTEXTS; ++i)
+ for (i = 0; i < GLOBALMV_MODE_CONTEXTS; ++i)
av1_diff_update_prob(r, &fc->zeromv_prob[i], ACCT_STR);
for (i = 0; i < REFMV_MODE_CONTEXTS; ++i)
av1_diff_update_prob(r, &fc->refmv_prob[i], ACCT_STR);
diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index dbde690..31f99cd 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -197,8 +197,8 @@
return NEWMV;
}
if (counts) ++counts->newmv_mode[mode_ctx][1];
- if (ctx & (1 << ALL_ZERO_FLAG_OFFSET)) return ZEROMV;
- mode_ctx = (ctx >> ZEROMV_OFFSET) & ZEROMV_CTX_MASK;
+ if (ctx & (1 << ALL_ZERO_FLAG_OFFSET)) return GLOBALMV;
+ mode_ctx = (ctx >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK;
#if CONFIG_NEW_MULTISYMBOL
is_zeromv =
aom_read_symbol(r, ec_ctx->zeromv_cdf[mode_ctx], 2, ACCT_STR) == 0;
@@ -207,7 +207,7 @@
#endif
if (is_zeromv) {
if (counts) ++counts->zeromv_mode[mode_ctx][0];
- return ZEROMV;
+ return GLOBALMV;
}
if (counts) ++counts->zeromv_mode[mode_ctx][1];
mode_ctx = (ctx >> REFMV_OFFSET) & REFMV_CTX_MASK;
@@ -1570,9 +1570,9 @@
SEG_LVL_REF_FRAME);
ref_frame[1] = NONE_FRAME;
}
-#if CONFIG_SEGMENT_ZEROMV
+#if CONFIG_SEGMENT_GLOBALMV
else if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP) ||
- segfeature_active(&cm->seg, segment_id, SEG_LVL_ZEROMV))
+ segfeature_active(&cm->seg, segment_id, SEG_LVL_GLOBALMV))
#else
else if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP))
#endif
@@ -1994,7 +1994,7 @@
if (is_compound) pred_mv[1].as_int = near_mv[1].as_int;
break;
}
- case ZEROMV: {
+ case GLOBALMV: {
mv[0].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame[0]],
cm->allow_high_precision_mv, bsize,
mi_col, mi_row, block
@@ -2178,7 +2178,7 @@
mv[1].as_int = near_mv[1].as_int;
break;
}
- case ZERO_ZEROMV: {
+ case GLOBAL_GLOBALMV: {
assert(is_compound);
mv[0].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame[0]],
cm->allow_high_precision_mv, bsize,
@@ -2275,9 +2275,9 @@
int16_t zeromv_ctx = -1;
int16_t refmv_ctx = -1;
if (mbmi->mode != NEWMV) {
- if (mode_ctx & (1 << ALL_ZERO_FLAG_OFFSET)) assert(mbmi->mode == ZEROMV);
- zeromv_ctx = (mode_ctx >> ZEROMV_OFFSET) & ZEROMV_CTX_MASK;
- if (mbmi->mode != ZEROMV) {
+ if (mode_ctx & (1 << ALL_ZERO_FLAG_OFFSET)) assert(mbmi->mode == GLOBALMV);
+ zeromv_ctx = (mode_ctx >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK;
+ if (mbmi->mode != GLOBALMV) {
refmv_ctx = (mode_ctx >> REFMV_OFFSET) & REFMV_CTX_MASK;
if (mode_ctx & (1 << SKIP_NEARESTMV_OFFSET)) refmv_ctx = 6;
if (mode_ctx & (1 << SKIP_NEARMV_OFFSET)) refmv_ctx = 7;
@@ -2422,14 +2422,14 @@
av1_mode_context_analyzer(inter_mode_ctx, mbmi->ref_frame, bsize, -1);
mbmi->ref_mv_idx = 0;
-#if CONFIG_SEGMENT_ZEROMV
+#if CONFIG_SEGMENT_GLOBALMV
if (segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP) ||
- segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_ZEROMV))
+ segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_GLOBALMV))
#else
if (segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP))
#endif
{
- mbmi->mode = ZEROMV;
+ mbmi->mode = GLOBALMV;
} else {
if (is_compound) mbmi->mode = read_inter_compound_mode(cm, xd, r, mode_ctx);
#if CONFIG_COMPOUND_SINGLEREF
@@ -2446,7 +2446,7 @@
read_drl_idx(ec_ctx, xd, mbmi, r);
}
- if (mbmi->mode != ZEROMV && mbmi->mode != ZERO_ZEROMV) {
+ if (mbmi->mode != GLOBALMV && mbmi->mode != GLOBAL_GLOBALMV) {
for (ref = 0; ref < 1 + is_compound; ++ref) {
#if CONFIG_AMVR
av1_find_best_ref_mvs(allow_hp, ref_mvs[mbmi->ref_frame[ref]],
@@ -2460,9 +2460,9 @@
}
#if CONFIG_COMPOUND_SINGLEREF
- if ((is_compound || is_singleref_comp_mode) && mbmi->mode != ZERO_ZEROMV)
-#else // !CONFIG_COMPOUND_SINGLEREF
- if (is_compound && mbmi->mode != ZERO_ZEROMV)
+ if ((is_compound || is_singleref_comp_mode) && mbmi->mode != GLOBAL_GLOBALMV)
+#else // !CONFIG_COMPOUND_SINGLEREF
+ if (is_compound && mbmi->mode != GLOBAL_GLOBALMV)
#endif // CONFIG_COMPOUND_SINGLEREF
{
uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
diff --git a/av1/encoder/aq_cyclicrefresh.c b/av1/encoder/aq_cyclicrefresh.c
index 8f61c7e..44a4a94 100644
--- a/av1/encoder/aq_cyclicrefresh.c
+++ b/av1/encoder/aq_cyclicrefresh.c
@@ -423,7 +423,7 @@
const int bl_index2 = bl_index + y * cm->mi_cols + x;
// If the block is as a candidate for clean up then mark it
// for possible boost/refresh (segment 1). The segment id may get
- // reset to 0 later if block gets coded anything other than ZEROMV.
+ // reset to 0 later if block gets coded anything other than GLOBALMV.
if (cr->map[bl_index2] == 0) {
if (cr->last_coded_q_map[bl_index2] > qindex_thresh) sum_map++;
} else if (cr->map[bl_index2] < 0) {
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index d8f231e..41ae432 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -132,18 +132,19 @@
if (mode != NEWMV) {
if (mode_ctx & (1 << ALL_ZERO_FLAG_OFFSET)) {
- assert(mode == ZEROMV);
+ assert(mode == GLOBALMV);
return;
}
- const int16_t zeromv_ctx = (mode_ctx >> ZEROMV_OFFSET) & ZEROMV_CTX_MASK;
+ const int16_t zeromv_ctx =
+ (mode_ctx >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK;
#if CONFIG_NEW_MULTISYMBOL
- aom_write_symbol(w, mode != ZEROMV, ec_ctx->zeromv_cdf[zeromv_ctx], 2);
+ aom_write_symbol(w, mode != GLOBALMV, ec_ctx->zeromv_cdf[zeromv_ctx], 2);
#else
- aom_write(w, mode != ZEROMV, ec_ctx->zeromv_prob[zeromv_ctx]);
+ aom_write(w, mode != GLOBALMV, ec_ctx->zeromv_prob[zeromv_ctx]);
#endif
- if (mode != ZEROMV) {
+ if (mode != GLOBALMV) {
int16_t refmv_ctx = (mode_ctx >> REFMV_OFFSET) & REFMV_CTX_MASK;
if (mode_ctx & (1 << SKIP_NEARESTMV_OFFSET)) refmv_ctx = 6;
@@ -354,7 +355,7 @@
for (i = 0; i < NEWMV_MODE_CONTEXTS; ++i)
av1_cond_prob_diff_update(w, &cm->fc->newmv_prob[i], counts->newmv_mode[i],
probwt);
- for (i = 0; i < ZEROMV_MODE_CONTEXTS; ++i)
+ for (i = 0; i < GLOBALMV_MODE_CONTEXTS; ++i)
av1_cond_prob_diff_update(w, &cm->fc->zeromv_prob[i],
counts->zeromv_mode[i], probwt);
for (i = 0; i < REFMV_MODE_CONTEXTS; ++i)
@@ -801,9 +802,9 @@
assert(mbmi->ref_frame[0] ==
get_segdata(&cm->seg, segment_id, SEG_LVL_REF_FRAME));
}
-#if CONFIG_SEGMENT_ZEROMV
+#if CONFIG_SEGMENT_GLOBALMV
else if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP) ||
- segfeature_active(&cm->seg, segment_id, SEG_LVL_ZEROMV))
+ segfeature_active(&cm->seg, segment_id, SEG_LVL_GLOBALMV))
#else
else if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP))
#endif
@@ -1974,11 +1975,11 @@
int16_t zeromv_ctx = -1;
int16_t refmv_ctx = -1;
if (mbmi->mode != NEWMV) {
- zeromv_ctx = (mode_ctx >> ZEROMV_OFFSET) & ZEROMV_CTX_MASK;
+ zeromv_ctx = (mode_ctx >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK;
if (mode_ctx & (1 << ALL_ZERO_FLAG_OFFSET)) {
- assert(mbmi->mode == ZEROMV);
+ assert(mbmi->mode == GLOBALMV);
}
- if (mbmi->mode != ZEROMV) {
+ if (mbmi->mode != GLOBALMV) {
refmv_ctx = (mode_ctx >> REFMV_OFFSET) & REFMV_CTX_MASK;
if (mode_ctx & (1 << SKIP_NEARESTMV_OFFSET)) refmv_ctx = 6;
if (mode_ctx & (1 << SKIP_NEARMV_OFFSET)) refmv_ctx = 7;
diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index c6c2e33..fea97c5 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h
@@ -207,7 +207,7 @@
int mbmode_cost[BLOCK_SIZE_GROUPS][INTRA_MODES];
int newmv_mode_cost[NEWMV_MODE_CONTEXTS][2];
- int zeromv_mode_cost[ZEROMV_MODE_CONTEXTS][2];
+ int zeromv_mode_cost[GLOBALMV_MODE_CONTEXTS][2];
int refmv_mode_cost[REFMV_MODE_CONTEXTS][2];
int drl_mode_cost0[DRL_MODE_CONTEXTS][2];
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 36584a0..fcf0125 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -337,7 +337,7 @@
static void update_global_motion_used(PREDICTION_MODE mode, BLOCK_SIZE bsize,
const MB_MODE_INFO *mbmi,
RD_COUNTS *rdc) {
- if (mode == ZEROMV || mode == ZERO_ZEROMV) {
+ if (mode == GLOBALMV || mode == GLOBAL_GLOBALMV) {
const int num_4x4s =
num_4x4_blocks_wide_lookup[bsize] * num_4x4_blocks_high_lookup[bsize];
int ref;
@@ -952,8 +952,8 @@
return;
}
- mode_ctx = (mode_context >> ZEROMV_OFFSET) & ZEROMV_CTX_MASK;
- if (mode == ZEROMV) {
+ mode_ctx = (mode_context >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK;
+ if (mode == GLOBALMV) {
++counts->zeromv_mode[mode_ctx][0];
return;
} else {
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index ea09c5f..7dd4b89 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -338,7 +338,7 @@
#endif
}
- for (i = 0; i < ZEROMV_MODE_CONTEXTS; ++i) {
+ for (i = 0; i < GLOBALMV_MODE_CONTEXTS; ++i) {
#if CONFIG_NEW_MULTISYMBOL
av1_cost_tokens_from_cdf(x->zeromv_mode_cost[i], fc->zeromv_cdf[i], NULL);
#else
@@ -1156,7 +1156,7 @@
rd->thresh_mult[THR_NEARA] += 1000;
rd->thresh_mult[THR_NEARG] += 1000;
- rd->thresh_mult[THR_ZEROMV] += 2000;
+ rd->thresh_mult[THR_GLOBALMV] += 2000;
rd->thresh_mult[THR_ZEROL2] += 2000;
rd->thresh_mult[THR_ZEROL3] += 2000;
rd->thresh_mult[THR_ZEROB] += 2000;
diff --git a/av1/encoder/rd.h b/av1/encoder/rd.h
index 8f64fcb..77332a7 100644
--- a/av1/encoder/rd.h
+++ b/av1/encoder/rd.h
@@ -75,7 +75,7 @@
THR_NEARA,
THR_NEARG,
- THR_ZEROMV,
+ THR_GLOBALMV,
THR_ZEROL2,
THR_ZEROL3,
THR_ZEROB,
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 109e181..a0ddd66 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -185,13 +185,13 @@
{ NEARMV, { ALTREF_FRAME, NONE_FRAME } },
{ NEARMV, { GOLDEN_FRAME, NONE_FRAME } },
- { ZEROMV, { LAST_FRAME, NONE_FRAME } },
- { ZEROMV, { LAST2_FRAME, NONE_FRAME } },
- { ZEROMV, { LAST3_FRAME, NONE_FRAME } },
- { ZEROMV, { BWDREF_FRAME, NONE_FRAME } },
- { ZEROMV, { ALTREF2_FRAME, NONE_FRAME } },
- { ZEROMV, { GOLDEN_FRAME, NONE_FRAME } },
- { ZEROMV, { ALTREF_FRAME, NONE_FRAME } },
+ { GLOBALMV, { LAST_FRAME, NONE_FRAME } },
+ { GLOBALMV, { LAST2_FRAME, NONE_FRAME } },
+ { GLOBALMV, { LAST3_FRAME, NONE_FRAME } },
+ { GLOBALMV, { BWDREF_FRAME, NONE_FRAME } },
+ { GLOBALMV, { ALTREF2_FRAME, NONE_FRAME } },
+ { GLOBALMV, { GOLDEN_FRAME, NONE_FRAME } },
+ { GLOBALMV, { ALTREF_FRAME, NONE_FRAME } },
// TODO(zoeliu): May need to reconsider the order on the modes to check
@@ -268,7 +268,7 @@
{ NEW_NEARMV, { LAST_FRAME, ALTREF_FRAME } },
{ NEAR_NEWMV, { LAST_FRAME, ALTREF_FRAME } },
{ NEW_NEWMV, { LAST_FRAME, ALTREF_FRAME } },
- { ZERO_ZEROMV, { LAST_FRAME, ALTREF_FRAME } },
+ { GLOBAL_GLOBALMV, { LAST_FRAME, ALTREF_FRAME } },
{ NEAR_NEARMV, { LAST2_FRAME, ALTREF_FRAME } },
{ NEW_NEARESTMV, { LAST2_FRAME, ALTREF_FRAME } },
@@ -276,7 +276,7 @@
{ NEW_NEARMV, { LAST2_FRAME, ALTREF_FRAME } },
{ NEAR_NEWMV, { LAST2_FRAME, ALTREF_FRAME } },
{ NEW_NEWMV, { LAST2_FRAME, ALTREF_FRAME } },
- { ZERO_ZEROMV, { LAST2_FRAME, ALTREF_FRAME } },
+ { GLOBAL_GLOBALMV, { LAST2_FRAME, ALTREF_FRAME } },
{ NEAR_NEARMV, { LAST3_FRAME, ALTREF_FRAME } },
{ NEW_NEARESTMV, { LAST3_FRAME, ALTREF_FRAME } },
@@ -284,7 +284,7 @@
{ NEW_NEARMV, { LAST3_FRAME, ALTREF_FRAME } },
{ NEAR_NEWMV, { LAST3_FRAME, ALTREF_FRAME } },
{ NEW_NEWMV, { LAST3_FRAME, ALTREF_FRAME } },
- { ZERO_ZEROMV, { LAST3_FRAME, ALTREF_FRAME } },
+ { GLOBAL_GLOBALMV, { LAST3_FRAME, ALTREF_FRAME } },
{ NEAR_NEARMV, { GOLDEN_FRAME, ALTREF_FRAME } },
{ NEW_NEARESTMV, { GOLDEN_FRAME, ALTREF_FRAME } },
@@ -292,7 +292,7 @@
{ NEW_NEARMV, { GOLDEN_FRAME, ALTREF_FRAME } },
{ NEAR_NEWMV, { GOLDEN_FRAME, ALTREF_FRAME } },
{ NEW_NEWMV, { GOLDEN_FRAME, ALTREF_FRAME } },
- { ZERO_ZEROMV, { GOLDEN_FRAME, ALTREF_FRAME } },
+ { GLOBAL_GLOBALMV, { GOLDEN_FRAME, ALTREF_FRAME } },
{ NEAR_NEARMV, { LAST_FRAME, BWDREF_FRAME } },
{ NEW_NEARESTMV, { LAST_FRAME, BWDREF_FRAME } },
@@ -300,7 +300,7 @@
{ NEW_NEARMV, { LAST_FRAME, BWDREF_FRAME } },
{ NEAR_NEWMV, { LAST_FRAME, BWDREF_FRAME } },
{ NEW_NEWMV, { LAST_FRAME, BWDREF_FRAME } },
- { ZERO_ZEROMV, { LAST_FRAME, BWDREF_FRAME } },
+ { GLOBAL_GLOBALMV, { LAST_FRAME, BWDREF_FRAME } },
{ NEAR_NEARMV, { LAST2_FRAME, BWDREF_FRAME } },
{ NEW_NEARESTMV, { LAST2_FRAME, BWDREF_FRAME } },
@@ -308,7 +308,7 @@
{ NEW_NEARMV, { LAST2_FRAME, BWDREF_FRAME } },
{ NEAR_NEWMV, { LAST2_FRAME, BWDREF_FRAME } },
{ NEW_NEWMV, { LAST2_FRAME, BWDREF_FRAME } },
- { ZERO_ZEROMV, { LAST2_FRAME, BWDREF_FRAME } },
+ { GLOBAL_GLOBALMV, { LAST2_FRAME, BWDREF_FRAME } },
{ NEAR_NEARMV, { LAST3_FRAME, BWDREF_FRAME } },
{ NEW_NEARESTMV, { LAST3_FRAME, BWDREF_FRAME } },
@@ -316,7 +316,7 @@
{ NEW_NEARMV, { LAST3_FRAME, BWDREF_FRAME } },
{ NEAR_NEWMV, { LAST3_FRAME, BWDREF_FRAME } },
{ NEW_NEWMV, { LAST3_FRAME, BWDREF_FRAME } },
- { ZERO_ZEROMV, { LAST3_FRAME, BWDREF_FRAME } },
+ { GLOBAL_GLOBALMV, { LAST3_FRAME, BWDREF_FRAME } },
{ NEAR_NEARMV, { GOLDEN_FRAME, BWDREF_FRAME } },
{ NEW_NEARESTMV, { GOLDEN_FRAME, BWDREF_FRAME } },
@@ -324,7 +324,7 @@
{ NEW_NEARMV, { GOLDEN_FRAME, BWDREF_FRAME } },
{ NEAR_NEWMV, { GOLDEN_FRAME, BWDREF_FRAME } },
{ NEW_NEWMV, { GOLDEN_FRAME, BWDREF_FRAME } },
- { ZERO_ZEROMV, { GOLDEN_FRAME, BWDREF_FRAME } },
+ { GLOBAL_GLOBALMV, { GOLDEN_FRAME, BWDREF_FRAME } },
{ NEAR_NEARMV, { LAST_FRAME, ALTREF2_FRAME } },
{ NEW_NEARESTMV, { LAST_FRAME, ALTREF2_FRAME } },
@@ -332,7 +332,7 @@
{ NEW_NEARMV, { LAST_FRAME, ALTREF2_FRAME } },
{ NEAR_NEWMV, { LAST_FRAME, ALTREF2_FRAME } },
{ NEW_NEWMV, { LAST_FRAME, ALTREF2_FRAME } },
- { ZERO_ZEROMV, { LAST_FRAME, ALTREF2_FRAME } },
+ { GLOBAL_GLOBALMV, { LAST_FRAME, ALTREF2_FRAME } },
{ NEAR_NEARMV, { LAST2_FRAME, ALTREF2_FRAME } },
{ NEW_NEARESTMV, { LAST2_FRAME, ALTREF2_FRAME } },
@@ -340,7 +340,7 @@
{ NEW_NEARMV, { LAST2_FRAME, ALTREF2_FRAME } },
{ NEAR_NEWMV, { LAST2_FRAME, ALTREF2_FRAME } },
{ NEW_NEWMV, { LAST2_FRAME, ALTREF2_FRAME } },
- { ZERO_ZEROMV, { LAST2_FRAME, ALTREF2_FRAME } },
+ { GLOBAL_GLOBALMV, { LAST2_FRAME, ALTREF2_FRAME } },
{ NEAR_NEARMV, { LAST3_FRAME, ALTREF2_FRAME } },
{ NEW_NEARESTMV, { LAST3_FRAME, ALTREF2_FRAME } },
@@ -348,7 +348,7 @@
{ NEW_NEARMV, { LAST3_FRAME, ALTREF2_FRAME } },
{ NEAR_NEWMV, { LAST3_FRAME, ALTREF2_FRAME } },
{ NEW_NEWMV, { LAST3_FRAME, ALTREF2_FRAME } },
- { ZERO_ZEROMV, { LAST3_FRAME, ALTREF2_FRAME } },
+ { GLOBAL_GLOBALMV, { LAST3_FRAME, ALTREF2_FRAME } },
{ NEAR_NEARMV, { GOLDEN_FRAME, ALTREF2_FRAME } },
{ NEW_NEARESTMV, { GOLDEN_FRAME, ALTREF2_FRAME } },
@@ -356,7 +356,7 @@
{ NEW_NEARMV, { GOLDEN_FRAME, ALTREF2_FRAME } },
{ NEAR_NEWMV, { GOLDEN_FRAME, ALTREF2_FRAME } },
{ NEW_NEWMV, { GOLDEN_FRAME, ALTREF2_FRAME } },
- { ZERO_ZEROMV, { GOLDEN_FRAME, ALTREF2_FRAME } },
+ { GLOBAL_GLOBALMV, { GOLDEN_FRAME, ALTREF2_FRAME } },
#if CONFIG_EXT_COMP_REFS
{ NEAR_NEARMV, { LAST_FRAME, LAST2_FRAME } },
@@ -365,7 +365,7 @@
{ NEW_NEARMV, { LAST_FRAME, LAST2_FRAME } },
{ NEAR_NEWMV, { LAST_FRAME, LAST2_FRAME } },
{ NEW_NEWMV, { LAST_FRAME, LAST2_FRAME } },
- { ZERO_ZEROMV, { LAST_FRAME, LAST2_FRAME } },
+ { GLOBAL_GLOBALMV, { LAST_FRAME, LAST2_FRAME } },
{ NEAR_NEARMV, { LAST_FRAME, LAST3_FRAME } },
{ NEW_NEARESTMV, { LAST_FRAME, LAST3_FRAME } },
@@ -373,7 +373,7 @@
{ NEW_NEARMV, { LAST_FRAME, LAST3_FRAME } },
{ NEAR_NEWMV, { LAST_FRAME, LAST3_FRAME } },
{ NEW_NEWMV, { LAST_FRAME, LAST3_FRAME } },
- { ZERO_ZEROMV, { LAST_FRAME, LAST3_FRAME } },
+ { GLOBAL_GLOBALMV, { LAST_FRAME, LAST3_FRAME } },
{ NEAR_NEARMV, { LAST_FRAME, GOLDEN_FRAME } },
{ NEW_NEARESTMV, { LAST_FRAME, GOLDEN_FRAME } },
@@ -381,7 +381,7 @@
{ NEW_NEARMV, { LAST_FRAME, GOLDEN_FRAME } },
{ NEAR_NEWMV, { LAST_FRAME, GOLDEN_FRAME } },
{ NEW_NEWMV, { LAST_FRAME, GOLDEN_FRAME } },
- { ZERO_ZEROMV, { LAST_FRAME, GOLDEN_FRAME } },
+ { GLOBAL_GLOBALMV, { LAST_FRAME, GOLDEN_FRAME } },
{ NEAR_NEARMV, { BWDREF_FRAME, ALTREF_FRAME } },
{ NEW_NEARESTMV, { BWDREF_FRAME, ALTREF_FRAME } },
@@ -389,7 +389,7 @@
{ NEW_NEARMV, { BWDREF_FRAME, ALTREF_FRAME } },
{ NEAR_NEWMV, { BWDREF_FRAME, ALTREF_FRAME } },
{ NEW_NEWMV, { BWDREF_FRAME, ALTREF_FRAME } },
- { ZERO_ZEROMV, { BWDREF_FRAME, ALTREF_FRAME } },
+ { GLOBAL_GLOBALMV, { BWDREF_FRAME, ALTREF_FRAME } },
#endif // CONFIG_EXT_COMP_REFS
{ H_PRED, { INTRA_FRAME, NONE_FRAME } },
@@ -401,37 +401,37 @@
{ D117_PRED, { INTRA_FRAME, NONE_FRAME } },
{ D45_PRED, { INTRA_FRAME, NONE_FRAME } },
- { ZEROMV, { LAST_FRAME, INTRA_FRAME } },
+ { GLOBALMV, { LAST_FRAME, INTRA_FRAME } },
{ NEARESTMV, { LAST_FRAME, INTRA_FRAME } },
{ NEARMV, { LAST_FRAME, INTRA_FRAME } },
{ NEWMV, { LAST_FRAME, INTRA_FRAME } },
- { ZEROMV, { LAST2_FRAME, INTRA_FRAME } },
+ { GLOBALMV, { LAST2_FRAME, INTRA_FRAME } },
{ NEARESTMV, { LAST2_FRAME, INTRA_FRAME } },
{ NEARMV, { LAST2_FRAME, INTRA_FRAME } },
{ NEWMV, { LAST2_FRAME, INTRA_FRAME } },
- { ZEROMV, { LAST3_FRAME, INTRA_FRAME } },
+ { GLOBALMV, { LAST3_FRAME, INTRA_FRAME } },
{ NEARESTMV, { LAST3_FRAME, INTRA_FRAME } },
{ NEARMV, { LAST3_FRAME, INTRA_FRAME } },
{ NEWMV, { LAST3_FRAME, INTRA_FRAME } },
- { ZEROMV, { GOLDEN_FRAME, INTRA_FRAME } },
+ { GLOBALMV, { GOLDEN_FRAME, INTRA_FRAME } },
{ NEARESTMV, { GOLDEN_FRAME, INTRA_FRAME } },
{ NEARMV, { GOLDEN_FRAME, INTRA_FRAME } },
{ NEWMV, { GOLDEN_FRAME, INTRA_FRAME } },
- { ZEROMV, { BWDREF_FRAME, INTRA_FRAME } },
+ { GLOBALMV, { BWDREF_FRAME, INTRA_FRAME } },
{ NEARESTMV, { BWDREF_FRAME, INTRA_FRAME } },
{ NEARMV, { BWDREF_FRAME, INTRA_FRAME } },
{ NEWMV, { BWDREF_FRAME, INTRA_FRAME } },
- { ZEROMV, { ALTREF2_FRAME, INTRA_FRAME } },
+ { GLOBALMV, { ALTREF2_FRAME, INTRA_FRAME } },
{ NEARESTMV, { ALTREF2_FRAME, INTRA_FRAME } },
{ NEARMV, { ALTREF2_FRAME, INTRA_FRAME } },
{ NEWMV, { ALTREF2_FRAME, INTRA_FRAME } },
- { ZEROMV, { ALTREF_FRAME, INTRA_FRAME } },
+ { GLOBALMV, { ALTREF_FRAME, INTRA_FRAME } },
{ NEARESTMV, { ALTREF_FRAME, INTRA_FRAME } },
{ NEARMV, { ALTREF_FRAME, INTRA_FRAME } },
{ NEWMV, { ALTREF_FRAME, INTRA_FRAME } },
@@ -5877,11 +5877,11 @@
return mode_cost;
} else {
mode_cost = x->newmv_mode_cost[mode_ctx][1];
- mode_ctx = (mode_context >> ZEROMV_OFFSET) & ZEROMV_CTX_MASK;
+ mode_ctx = (mode_context >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK;
if (is_all_zero_mv) return mode_cost;
- if (mode == ZEROMV) {
+ if (mode == GLOBALMV) {
mode_cost += x->zeromv_mode_cost[mode_ctx][0];
return mode_cost;
} else {
@@ -5950,7 +5950,7 @@
(mv->col >> 3) > mv_limits->col_max;
}
-// Check if NEARESTMV/NEARMV/ZEROMV is the cheapest way encode zero motion.
+// Check if NEARESTMV/NEARMV/GLOBALMV is the cheapest way encode zero motion.
// TODO(aconverse): Find out if this is still productive then clean up or remove
static int check_best_zero_mv(
const AV1_COMP *const cpi, const MACROBLOCK *const x,
@@ -5964,7 +5964,7 @@
(void)mi_row;
(void)mi_col;
(void)cpi;
- if (this_mode == ZEROMV || this_mode == ZERO_ZEROMV) {
+ if (this_mode == GLOBALMV || this_mode == GLOBAL_GLOBALMV) {
for (int cur_frm = 0; cur_frm < 1 + comp_pred_mode; cur_frm++) {
zeromv[cur_frm].as_int =
gm_get_motion_vector(&cpi->common.global_motion[ref_frames[cur_frm]],
@@ -5979,7 +5979,8 @@
}
}
- if ((this_mode == NEARMV || this_mode == NEARESTMV || this_mode == ZEROMV) &&
+ if ((this_mode == NEARMV || this_mode == NEARESTMV ||
+ this_mode == GLOBALMV) &&
frame_mv[this_mode][ref_frames[0]].as_int == zeromv[0].as_int &&
(ref_frames[1] <= INTRA_FRAME ||
frame_mv[this_mode][ref_frames[1]].as_int == zeromv[1].as_int)) {
@@ -5987,14 +5988,14 @@
av1_mode_context_analyzer(mode_context, ref_frames, bsize, block);
int c1 = cost_mv_ref(x, NEARMV, rfc);
int c2 = cost_mv_ref(x, NEARESTMV, rfc);
- int c3 = cost_mv_ref(x, ZEROMV, rfc);
+ int c3 = cost_mv_ref(x, GLOBALMV, rfc);
if (this_mode == NEARMV) {
if (c1 > c3) return 0;
} else if (this_mode == NEARESTMV) {
if (c2 > c3) return 0;
} else {
- assert(this_mode == ZEROMV);
+ assert(this_mode == GLOBALMV);
if (ref_frames[1] <= INTRA_FRAME) {
if ((c3 >= c2 && frame_mv[NEARESTMV][ref_frames[0]].as_int == 0) ||
(c3 >= c1 && frame_mv[NEARMV][ref_frames[0]].as_int == 0))
@@ -6008,12 +6009,12 @@
}
}
} else if ((this_mode == NEAREST_NEARESTMV || this_mode == NEAR_NEARMV ||
- this_mode == ZERO_ZEROMV) &&
+ this_mode == GLOBAL_GLOBALMV) &&
frame_mv[this_mode][ref_frames[0]].as_int == zeromv[0].as_int &&
frame_mv[this_mode][ref_frames[1]].as_int == zeromv[1].as_int) {
int16_t rfc = compound_mode_context[ref_frames[0]];
int c2 = cost_mv_ref(x, NEAREST_NEARESTMV, rfc);
- int c3 = cost_mv_ref(x, ZERO_ZEROMV, rfc);
+ int c3 = cost_mv_ref(x, GLOBAL_GLOBALMV, rfc);
int c5 = cost_mv_ref(x, NEAR_NEARMV, rfc);
if (this_mode == NEAREST_NEARESTMV) {
@@ -6021,7 +6022,7 @@
} else if (this_mode == NEAR_NEARMV) {
if (c5 > c3) return 0;
} else {
- assert(this_mode == ZERO_ZEROMV);
+ assert(this_mode == GLOBAL_GLOBALMV);
if ((c3 >= c2 && frame_mv[NEAREST_NEARESTMV][ref_frames[0]].as_int == 0 &&
frame_mv[NEAREST_NEARESTMV][ref_frames[1]].as_int == 0) ||
(c3 >= c5 && frame_mv[NEAR_NEARMV][ref_frames[0]].as_int == 0 &&
@@ -7375,9 +7376,10 @@
if (single_filter[NEARMV][refs[0]] == single_filter[NEARMV][refs[1]])
best_filter = single_filter[NEARMV][refs[0]];
break;
- case ZERO_ZEROMV:
- if (single_filter[ZEROMV][refs[0]] == single_filter[ZEROMV][refs[1]])
- best_filter = single_filter[ZEROMV][refs[0]];
+ case GLOBAL_GLOBALMV:
+ if (single_filter[GLOBALMV][refs[0]] ==
+ single_filter[GLOBALMV][refs[1]])
+ best_filter = single_filter[GLOBALMV][refs[0]];
break;
case NEW_NEWMV:
if (single_filter[NEWMV][refs[0]] == single_filter[NEWMV][refs[1]])
@@ -8376,7 +8378,7 @@
rd_stats->skip = 1;
}
- if (this_mode == ZEROMV || this_mode == ZERO_ZEROMV) {
+ if (this_mode == GLOBALMV || this_mode == GLOBAL_GLOBALMV) {
if (is_nontrans_global_motion(xd)) {
rd_stats->rate -= rs;
mbmi->interp_filters = av1_broadcast_interp_filter(
@@ -9597,7 +9599,7 @@
frame_mv[NEARESTMV], frame_mv[NEARMV], yv12_mb);
}
frame_mv[NEWMV][ref_frame].as_int = INVALID_MV;
- frame_mv[ZEROMV][ref_frame].as_int =
+ frame_mv[GLOBALMV][ref_frame].as_int =
gm_get_motion_vector(&cm->global_motion[ref_frame],
cm->allow_high_precision_mv, bsize, mi_col, mi_row,
0
@@ -9612,7 +9614,7 @@
frame_mv[SR_NEW_NEWMV][ref_frame].as_int = INVALID_MV;
frame_comp_mv[SR_NEW_NEWMV][ref_frame].as_int = INVALID_MV;
#endif // CONFIG_COMPOUND_SINGLEREF
- frame_mv[ZERO_ZEROMV][ref_frame].as_int =
+ frame_mv[GLOBAL_GLOBALMV][ref_frame].as_int =
gm_get_motion_vector(&cm->global_motion[ref_frame],
cm->allow_high_precision_mv, bsize, mi_col, mi_row,
0
@@ -9636,12 +9638,13 @@
MV_REFERENCE_FRAME rf[2];
av1_set_ref_frame(rf, ref_frame);
if (mbmi_ext->ref_mvs[rf[0]][0].as_int !=
- frame_mv[ZEROMV][rf[0]].as_int ||
+ frame_mv[GLOBALMV][rf[0]].as_int ||
mbmi_ext->ref_mvs[rf[0]][1].as_int !=
- frame_mv[ZEROMV][rf[0]].as_int ||
+ frame_mv[GLOBALMV][rf[0]].as_int ||
mbmi_ext->ref_mvs[rf[1]][0].as_int !=
- frame_mv[ZEROMV][rf[1]].as_int ||
- mbmi_ext->ref_mvs[rf[1]][1].as_int != frame_mv[ZEROMV][rf[1]].as_int)
+ frame_mv[GLOBALMV][rf[1]].as_int ||
+ mbmi_ext->ref_mvs[rf[1]][1].as_int !=
+ frame_mv[GLOBALMV][rf[1]].as_int)
mbmi_ext->mode_context[ref_frame] &= ~(1 << ALL_ZERO_FLAG_OFFSET);
}
}
@@ -9692,7 +9695,7 @@
// segment level feature is enabled for this segment. This is to
// prevent the possibility that we end up unable to pick any mode.
if (!segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME)) {
- // Only consider ZEROMV/ALTREF_FRAME for alt ref frame,
+ // Only consider GLOBALMV/ALTREF_FRAME for alt ref frame,
// unless ARNR filtering is enabled in which case we want
// an unfiltered alternative. We allow near/nearest as well
// because they may result in zero-zero MVs but be cheaper.
@@ -10975,7 +10978,7 @@
// The inter modes' rate costs are not calculated precisely in some cases.
// Therefore, sometimes, NEWMV is chosen instead of NEARESTMV, NEARMV, and
-// ZEROMV. Here, checks are added for those cases, and the mode decisions
+// GLOBALMV. Here, checks are added for those cases, and the mode decisions
// are corrected.
#if CONFIG_COMPOUND_SINGLEREF
// NOTE: For SR_NEW_NEWMV, no need to check as the two mvs from the same ref
@@ -11023,7 +11026,7 @@
if (frame_mv[NEARESTMV][refs[0]].as_int == best_mbmode.mv[0].as_int)
best_mbmode.mode = NEARESTMV;
else if (best_mbmode.mv[0].as_int == zeromv[0].as_int)
- best_mbmode.mode = ZEROMV;
+ best_mbmode.mode = GLOBALMV;
} else {
int_mv nearestmv[2];
int_mv nearmv[2];
@@ -11066,7 +11069,7 @@
if (best_mbmode.mode == NEW_NEWMV &&
best_mbmode.mv[0].as_int == zeromv[0].as_int &&
best_mbmode.mv[1].as_int == zeromv[1].as_int)
- best_mbmode.mode = ZERO_ZEROMV;
+ best_mbmode.mode = GLOBAL_GLOBALMV;
}
}
}
@@ -11103,7 +11106,7 @@
)
.as_int;
if (best_mbmode.mv[0].as_int == zeromv.as_int) {
- best_mbmode.mode = ZEROMV;
+ best_mbmode.mode = GLOBALMV;
}
}
}
@@ -11134,15 +11137,15 @@
x->skip |= best_skip2;
// Note: this section is needed since the mode may have been forced to
- // ZEROMV by the all-zero mode handling of ref-mv.
- if (mbmi->mode == ZEROMV || mbmi->mode == ZERO_ZEROMV) {
- // Correct the motion mode for ZEROMV
+ // GLOBALMV by the all-zero mode handling of ref-mv.
+ if (mbmi->mode == GLOBALMV || mbmi->mode == GLOBAL_GLOBALMV) {
+ // Correct the motion mode for GLOBALMV
const MOTION_MODE last_motion_mode_allowed =
motion_mode_allowed(0, xd->global_motion, xd, xd->mi[0]);
if (mbmi->motion_mode > last_motion_mode_allowed)
mbmi->motion_mode = last_motion_mode_allowed;
- // Correct the interpolation filter for ZEROMV
+ // Correct the interpolation filter for GLOBALMV
if (is_nontrans_global_motion(xd)) {
mbmi->interp_filters = av1_broadcast_interp_filter(
av1_unswitchable_filter(cm->interp_filter));
@@ -11221,7 +11224,7 @@
mbmi->filter_intra_mode_info.use_filter_intra_mode[0] = 0;
mbmi->filter_intra_mode_info.use_filter_intra_mode[1] = 0;
#endif // CONFIG_FILTER_INTRA
- mbmi->mode = ZEROMV;
+ mbmi->mode = GLOBALMV;
mbmi->motion_mode = SIMPLE_TRANSLATION;
mbmi->uv_mode = UV_DC_PRED;
if (segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME))
@@ -11311,11 +11314,11 @@
av1_extract_interp_filter(mbmi->interp_filters, 0)));
av1_update_rd_thresh_fact(cm, tile_data->thresh_freq_fact,
- cpi->sf.adaptive_rd_thresh, bsize, THR_ZEROMV);
+ cpi->sf.adaptive_rd_thresh, bsize, THR_GLOBALMV);
av1_zero(best_pred_diff);
- store_coding_context(x, ctx, THR_ZEROMV, best_pred_diff, 0);
+ store_coding_context(x, ctx, THR_GLOBALMV, best_pred_diff, 0);
}
struct calc_target_weighted_pred_ctxt {
diff --git a/av1/encoder/speed_features.h b/av1/encoder/speed_features.h
index 08c7e5b..d886ad4 100644
--- a/av1/encoder/speed_features.h
+++ b/av1/encoder/speed_features.h
@@ -63,21 +63,21 @@
// SR_NEAREST_NEARMV, SR_NEAREST_NEWMV, SR_NEAR_NEWMV,
// SR_ZERO_NEWMV, and SR_NEW_NEWMV.
#endif // CONFIG_COMPOUND_SINGLEREF
- INTER_ALL = (1 << NEARESTMV) | (1 << NEARMV) | (1 << ZEROMV) | (1 << NEWMV) |
- (1 << NEAREST_NEARESTMV) | (1 << NEAR_NEARMV) | (1 << NEW_NEWMV) |
- (1 << NEAREST_NEWMV) | (1 << NEAR_NEWMV) | (1 << NEW_NEARMV) |
- (1 << NEW_NEARESTMV) | (1 << ZERO_ZEROMV),
+ INTER_ALL = (1 << NEARESTMV) | (1 << NEARMV) | (1 << GLOBALMV) |
+ (1 << NEWMV) | (1 << NEAREST_NEARESTMV) | (1 << NEAR_NEARMV) |
+ (1 << NEW_NEWMV) | (1 << NEAREST_NEWMV) | (1 << NEAR_NEWMV) |
+ (1 << NEW_NEARMV) | (1 << NEW_NEARESTMV) | (1 << GLOBAL_GLOBALMV),
INTER_NEAREST = (1 << NEARESTMV) | (1 << NEAREST_NEARESTMV) |
(1 << NEW_NEARESTMV) | (1 << NEAREST_NEWMV),
INTER_NEAREST_NEW = (1 << NEARESTMV) | (1 << NEWMV) |
(1 << NEAREST_NEARESTMV) | (1 << NEW_NEWMV) |
(1 << NEW_NEARESTMV) | (1 << NEAREST_NEWMV) |
(1 << NEW_NEARMV) | (1 << NEAR_NEWMV),
- INTER_NEAREST_ZERO = (1 << NEARESTMV) | (1 << ZEROMV) |
- (1 << NEAREST_NEARESTMV) | (1 << ZERO_ZEROMV) |
+ INTER_NEAREST_ZERO = (1 << NEARESTMV) | (1 << GLOBALMV) |
+ (1 << NEAREST_NEARESTMV) | (1 << GLOBAL_GLOBALMV) |
(1 << NEAREST_NEWMV) | (1 << NEW_NEARESTMV),
- INTER_NEAREST_NEW_ZERO = (1 << NEARESTMV) | (1 << ZEROMV) | (1 << NEWMV) |
- (1 << NEAREST_NEARESTMV) | (1 << ZERO_ZEROMV) |
+ INTER_NEAREST_NEW_ZERO = (1 << NEARESTMV) | (1 << GLOBALMV) | (1 << NEWMV) |
+ (1 << NEAREST_NEARESTMV) | (1 << GLOBAL_GLOBALMV) |
(1 << NEW_NEWMV) | (1 << NEW_NEARESTMV) |
(1 << NEAREST_NEWMV) | (1 << NEW_NEARMV) |
(1 << NEAR_NEWMV),
@@ -86,8 +86,8 @@
(1 << NEW_NEARESTMV) | (1 << NEAREST_NEWMV) |
(1 << NEW_NEARMV) | (1 << NEAR_NEWMV) |
(1 << NEAR_NEARMV),
- INTER_NEAREST_NEAR_ZERO = (1 << NEARESTMV) | (1 << NEARMV) | (1 << ZEROMV) |
- (1 << NEAREST_NEARESTMV) | (1 << ZERO_ZEROMV) |
+ INTER_NEAREST_NEAR_ZERO = (1 << NEARESTMV) | (1 << NEARMV) | (1 << GLOBALMV) |
+ (1 << NEAREST_NEARESTMV) | (1 << GLOBAL_GLOBALMV) |
(1 << NEAREST_NEWMV) | (1 << NEW_NEARESTMV) |
(1 << NEW_NEARMV) | (1 << NEAR_NEWMV) |
(1 << NEAR_NEARMV),
@@ -439,7 +439,7 @@
// by only looking at counts from 1/2 the bands.
FAST_COEFF_UPDATE use_fast_coef_updates;
- // A binary mask indicating if NEARESTMV, NEARMV, ZEROMV, NEWMV
+ // A binary mask indicating if NEARESTMV, NEARMV, GLOBALMV, NEWMV
// modes are used in order from LSB to MSB for each BLOCK_SIZE.
int inter_mode_mask[BLOCK_SIZES_ALL];
diff --git a/build/cmake/aom_config_defaults.cmake b/build/cmake/aom_config_defaults.cmake
index d62396d..be7b770 100644
--- a/build/cmake/aom_config_defaults.cmake
+++ b/build/cmake/aom_config_defaults.cmake
@@ -186,7 +186,7 @@
set(CONFIG_RECT_TX_EXT 0 CACHE NUMBER "AV1 experiment flag.")
set(CONFIG_REFERENCE_BUFFER 1 CACHE NUMBER "AV1 experiment flag.")
set(CONFIG_REF_ADAPT 0 CACHE NUMBER "AV1 experiment flag.")
-set(CONFIG_SEGMENT_ZEROMV 0 CACHE NUMBER "AV1 experiment flag.")
+set(CONFIG_SEGMENT_GLOBALMV 0 CACHE NUMBER "AV1 experiment flag.")
set(CONFIG_SHORT_FILTER 0 CACHE NUMBER "AV1 experiment flag.")
set(CONFIG_SIMPLE_BWD_ADAPT 1 CACHE NUMBER "AV1 experiment flag.")
set(CONFIG_SMOOTH_HV 1 CACHE NUMBER "AV1 experiment flag.")
diff --git a/configure b/configure
index 9579685..5bd5a49 100755
--- a/configure
+++ b/configure
@@ -305,7 +305,7 @@
ctx1d
txk_sel
mv_compress
- segment_zeromv
+ segment_globalmv
frame_superres
new_multisymbol
compound_singleref
diff --git a/examples/inspect.c b/examples/inspect.c
index 5c553d2..7de4d3a 100644
--- a/examples/inspect.c
+++ b/examples/inspect.c
@@ -217,9 +217,9 @@
ENUM(SMOOTH_V_PRED), ENUM(SMOOTH_H_PRED),
#endif // CONFIG_SMOOTH_HV
ENUM(PAETH_PRED), ENUM(NEARESTMV), ENUM(NEARMV),
- ENUM(ZEROMV), ENUM(NEWMV), ENUM(NEAREST_NEARESTMV),
+ ENUM(GLOBALMV), ENUM(NEWMV), ENUM(NEAREST_NEARESTMV),
ENUM(NEAR_NEARMV), ENUM(NEAREST_NEWMV), ENUM(NEW_NEARESTMV),
- ENUM(NEAR_NEWMV), ENUM(NEW_NEARMV), ENUM(ZERO_ZEROMV),
+ ENUM(NEAR_NEWMV), ENUM(NEW_NEARMV), ENUM(GLOBAL_GLOBALMV),
ENUM(NEW_NEWMV), ENUM(INTRA_INVALID), LAST_ENUM
};
diff --git a/tools/aom_entropy_optimizer.c b/tools/aom_entropy_optimizer.c
index 4576a16..4ae4ea7 100644
--- a/tools/aom_entropy_optimizer.c
+++ b/tools/aom_entropy_optimizer.c
@@ -404,14 +404,14 @@
"static const aom_cdf_prob "
"default_newmv_cdf[NEWMV_MODE_CONTEXTS][CDF_SIZE(2)]");
- cts_each_dim[0] = ZEROMV_MODE_CONTEXTS;
+ cts_each_dim[0] = GLOBALMV_MODE_CONTEXTS;
cts_each_dim[1] = 2;
optimize_entropy_table(
&fc.zeromv_mode[0][0], probsfile, 2, cts_each_dim, NULL, 1,
- "static const aom_prob default_zeromv_prob[ZEROMV_MODE_CONTEXTS]");
+ "static const aom_prob default_zeromv_prob[GLOBALMV_MODE_CONTEXTS]");
optimize_cdf_table(&fc.zeromv_mode[0][0], probsfile, 2, cts_each_dim,
"static const aom_cdf_prob "
- "default_zeromv_cdf[ZEROMV_MODE_CONTEXTS][CDF_SIZE(2)]");
+ "default_zeromv_cdf[GLOBALMV_MODE_CONTEXTS][CDF_SIZE(2)]");
cts_each_dim[0] = REFMV_MODE_CONTEXTS;
cts_each_dim[1] = 2;
