Seperate weight from candidate_mv structure
Seperating 'weight' from candidate_mv structure. This patch
will facilitate in changing the datatype of weight from int to
uint16_t.
Change-Id: I9c4af0c76e34221bdfea69fa08ec9a2bfe965c67
diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index 9395c36..45bd9a7 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -535,6 +535,7 @@
uint8_t ref_mv_count[MODE_CTX_REF_FRAMES];
CANDIDATE_MV ref_mv_stack[MODE_CTX_REF_FRAMES][MAX_REF_MV_STACK_SIZE];
+ int weight[MODE_CTX_REF_FRAMES][MAX_REF_MV_STACK_SIZE];
uint8_t is_sec_rect;
// Counts of each reference frame in the above and left neighboring blocks.
diff --git a/av1/common/mv.h b/av1/common/mv.h
index d097f9e..fe821ee 100644
--- a/av1/common/mv.h
+++ b/av1/common/mv.h
@@ -277,7 +277,6 @@
typedef struct candidate_mv {
int_mv this_mv;
int_mv comp_mv;
- int weight;
} CANDIDATE_MV;
static INLINE int is_zero_mv(const MV *mv) {
diff --git a/av1/common/mvref_common.c b/av1/common/mvref_common.c
index e38891f..a6bef20 100644
--- a/av1/common/mvref_common.c
+++ b/av1/common/mvref_common.c
@@ -74,7 +74,7 @@
static void add_ref_mv_candidate(
const MB_MODE_INFO *const candidate, const MV_REFERENCE_FRAME rf[2],
uint8_t *refmv_count, uint8_t *ref_match_count, uint8_t *newmv_count,
- CANDIDATE_MV *ref_mv_stack, int_mv *gm_mv_candidates,
+ CANDIDATE_MV *ref_mv_stack, int *ref_mv_weight, int_mv *gm_mv_candidates,
const WarpedMotionParams *gm_params, int col, int weight) {
if (!is_inter_block(candidate)) return; // for intrabc
int index = 0, ref;
@@ -93,12 +93,12 @@
for (index = 0; index < *refmv_count; ++index)
if (ref_mv_stack[index].this_mv.as_int == this_refmv.as_int) break;
- if (index < *refmv_count) ref_mv_stack[index].weight += weight;
+ if (index < *refmv_count) ref_mv_weight[index] += weight;
// Add a new item to the list.
if (index == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) {
ref_mv_stack[index].this_mv = this_refmv;
- ref_mv_stack[index].weight = weight;
+ ref_mv_weight[index] = weight;
++(*refmv_count);
}
if (have_newmv_in_inter_mode(candidate->mode)) ++*newmv_count;
@@ -122,13 +122,13 @@
(ref_mv_stack[index].comp_mv.as_int == this_refmv[1].as_int))
break;
- if (index < *refmv_count) ref_mv_stack[index].weight += weight;
+ if (index < *refmv_count) ref_mv_weight[index] += weight;
// Add a new item to the list.
if (index == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) {
ref_mv_stack[index].this_mv = this_refmv[0];
ref_mv_stack[index].comp_mv = this_refmv[1];
- ref_mv_stack[index].weight = weight;
+ ref_mv_weight[index] = weight;
++(*refmv_count);
}
if (have_newmv_in_inter_mode(candidate->mode)) ++*newmv_count;
@@ -140,10 +140,10 @@
static void scan_row_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd,
int mi_row, int mi_col,
const MV_REFERENCE_FRAME rf[2], int row_offset,
- CANDIDATE_MV *ref_mv_stack, uint8_t *refmv_count,
- uint8_t *ref_match_count, uint8_t *newmv_count,
- int_mv *gm_mv_candidates, int max_row_offset,
- int *processed_rows) {
+ CANDIDATE_MV *ref_mv_stack, int *ref_mv_weight,
+ uint8_t *refmv_count, uint8_t *ref_match_count,
+ uint8_t *newmv_count, int_mv *gm_mv_candidates,
+ int max_row_offset, int *processed_rows) {
int end_mi = AOMMIN(xd->n4_w, cm->mi_cols - mi_col);
end_mi = AOMMIN(end_mi, mi_size_wide[BLOCK_64X64]);
const int n8_w_8 = mi_size_wide[BLOCK_8X8];
@@ -180,8 +180,9 @@
}
add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count,
- newmv_count, ref_mv_stack, gm_mv_candidates,
- cm->global_motion, col_offset + i, len * weight);
+ newmv_count, ref_mv_stack, ref_mv_weight,
+ gm_mv_candidates, cm->global_motion, col_offset + i,
+ len * weight);
i += len;
}
@@ -190,10 +191,10 @@
static void scan_col_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd,
int mi_row, int mi_col,
const MV_REFERENCE_FRAME rf[2], int col_offset,
- CANDIDATE_MV *ref_mv_stack, uint8_t *refmv_count,
- uint8_t *ref_match_count, uint8_t *newmv_count,
- int_mv *gm_mv_candidates, int max_col_offset,
- int *processed_cols) {
+ CANDIDATE_MV *ref_mv_stack, int *ref_mv_weight,
+ uint8_t *refmv_count, uint8_t *ref_match_count,
+ uint8_t *newmv_count, int_mv *gm_mv_candidates,
+ int max_col_offset, int *processed_cols) {
int end_mi = AOMMIN(xd->n4_h, cm->mi_rows - mi_row);
end_mi = AOMMIN(end_mi, mi_size_high[BLOCK_64X64]);
const int n8_h_8 = mi_size_high[BLOCK_8X8];
@@ -229,8 +230,9 @@
}
add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count,
- newmv_count, ref_mv_stack, gm_mv_candidates,
- cm->global_motion, col_offset, len * weight);
+ newmv_count, ref_mv_stack, ref_mv_weight,
+ gm_mv_candidates, cm->global_motion, col_offset,
+ len * weight);
i += len;
}
@@ -240,8 +242,8 @@
const int mi_row, const int mi_col,
const MV_REFERENCE_FRAME rf[2], int row_offset,
int col_offset, CANDIDATE_MV *ref_mv_stack,
- uint8_t *ref_match_count, uint8_t *newmv_count,
- int_mv *gm_mv_candidates,
+ int *ref_mv_weight, uint8_t *ref_match_count,
+ uint8_t *newmv_count, int_mv *gm_mv_candidates,
uint8_t refmv_count[MODE_CTX_REF_FRAMES]) {
const TileInfo *const tile = &xd->tile;
POSITION mi_pos;
@@ -255,8 +257,9 @@
const int len = mi_size_wide[BLOCK_8X8];
add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count,
- newmv_count, ref_mv_stack, gm_mv_candidates,
- cm->global_motion, mi_pos.col, 2 * len);
+ newmv_count, ref_mv_stack, ref_mv_weight,
+ gm_mv_candidates, cm->global_motion, mi_pos.col,
+ 2 * len);
} // Analyze a single 8x8 block motion information.
}
@@ -328,6 +331,7 @@
int blk_row, int blk_col, int_mv *gm_mv_candidates,
uint8_t refmv_count[MODE_CTX_REF_FRAMES],
CANDIDATE_MV ref_mv_stacks[][MAX_REF_MV_STACK_SIZE],
+ int ref_mv_weights[][MAX_REF_MV_STACK_SIZE],
int16_t *mode_context) {
POSITION mi_pos;
int idx;
@@ -352,7 +356,7 @@
int cur_offset_0 = get_relative_dist(&cm->seq_params.order_hint_info,
cur_frame_index, frame0_index);
CANDIDATE_MV *ref_mv_stack = ref_mv_stacks[rf[0]];
-
+ int *ref_mv_weight = ref_mv_weights[rf[0]];
if (prev_frame_mvs->mfmv0.as_int != INVALID_MV) {
int_mv this_refmv;
@@ -369,12 +373,12 @@
for (idx = 0; idx < refmv_count[rf[0]]; ++idx)
if (this_refmv.as_int == ref_mv_stack[idx].this_mv.as_int) break;
- if (idx < refmv_count[rf[0]]) ref_mv_stack[idx].weight += 2 * weight_unit;
+ if (idx < refmv_count[rf[0]]) ref_mv_weight[idx] += 2 * weight_unit;
if (idx == refmv_count[rf[0]] &&
refmv_count[rf[0]] < MAX_REF_MV_STACK_SIZE) {
ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int;
- ref_mv_stack[idx].weight = 2 * weight_unit;
+ ref_mv_weight[idx] = 2 * weight_unit;
++(refmv_count[rf[0]]);
}
return 1;
@@ -392,7 +396,7 @@
int cur_offset_1 = get_relative_dist(&cm->seq_params.order_hint_info,
cur_frame_index, frame1_index);
CANDIDATE_MV *ref_mv_stack = ref_mv_stacks[ref_frame];
-
+ int *ref_mv_weight = ref_mv_weights[ref_frame];
if (prev_frame_mvs->mfmv0.as_int != INVALID_MV) {
int_mv this_refmv;
int_mv comp_refmv;
@@ -418,14 +422,13 @@
comp_refmv.as_int == ref_mv_stack[idx].comp_mv.as_int)
break;
- if (idx < refmv_count[ref_frame])
- ref_mv_stack[idx].weight += 2 * weight_unit;
+ if (idx < refmv_count[ref_frame]) ref_mv_weight[idx] += 2 * weight_unit;
if (idx == refmv_count[ref_frame] &&
refmv_count[ref_frame] < MAX_REF_MV_STACK_SIZE) {
ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int;
ref_mv_stack[idx].comp_mv.as_int = comp_refmv.as_int;
- ref_mv_stack[idx].weight = 2 * weight_unit;
+ ref_mv_weight[idx] = 2 * weight_unit;
++(refmv_count[ref_frame]);
}
return 1;
@@ -462,7 +465,8 @@
static void process_single_ref_mv_candidate(
const MB_MODE_INFO *const candidate, const AV1_COMMON *const cm,
MV_REFERENCE_FRAME ref_frame, uint8_t refmv_count[MODE_CTX_REF_FRAMES],
- CANDIDATE_MV ref_mv_stack[][MAX_REF_MV_STACK_SIZE]) {
+ CANDIDATE_MV ref_mv_stack[][MAX_REF_MV_STACK_SIZE],
+ int ref_mv_weight[][MAX_REF_MV_STACK_SIZE]) {
for (int rf_idx = 0; rf_idx < 2; ++rf_idx) {
if (candidate->ref_frame[rf_idx] > INTRA_FRAME) {
int_mv this_mv = candidate->mv[rf_idx];
@@ -482,7 +486,7 @@
// TODO(jingning): Set an arbitrary small number here. The weight
// doesn't matter as long as it is properly initialized.
- ref_mv_stack[ref_frame][stack_idx].weight = 2;
+ ref_mv_weight[ref_frame][stack_idx] = 2;
++refmv_count[ref_frame];
}
}
@@ -493,6 +497,7 @@
const AV1_COMMON *cm, const MACROBLOCKD *xd, MV_REFERENCE_FRAME ref_frame,
uint8_t refmv_count[MODE_CTX_REF_FRAMES],
CANDIDATE_MV ref_mv_stack[][MAX_REF_MV_STACK_SIZE],
+ int ref_mv_weight[][MAX_REF_MV_STACK_SIZE],
int_mv mv_ref_list[][MAX_MV_REF_CANDIDATES], int_mv *gm_mv_candidates,
int mi_row, int mi_col, int16_t *mode_context) {
const int bs = AOMMAX(xd->n4_w, xd->n4_h);
@@ -536,25 +541,28 @@
// Scan the first above row mode info. row_offset = -1;
if (abs(max_row_offset) >= 1)
scan_row_mbmi(cm, xd, mi_row, mi_col, rf, -1, ref_mv_stack[ref_frame],
- &refmv_count[ref_frame], &row_match_count, &newmv_count,
- gm_mv_candidates, max_row_offset, &processed_rows);
+ ref_mv_weight[ref_frame], &refmv_count[ref_frame],
+ &row_match_count, &newmv_count, gm_mv_candidates,
+ max_row_offset, &processed_rows);
// Scan the first left column mode info. col_offset = -1;
if (abs(max_col_offset) >= 1)
scan_col_mbmi(cm, xd, mi_row, mi_col, rf, -1, ref_mv_stack[ref_frame],
- &refmv_count[ref_frame], &col_match_count, &newmv_count,
- gm_mv_candidates, max_col_offset, &processed_cols);
+ ref_mv_weight[ref_frame], &refmv_count[ref_frame],
+ &col_match_count, &newmv_count, gm_mv_candidates,
+ max_col_offset, &processed_cols);
// Check top-right boundary
if (has_tr)
scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, xd->n4_w,
- ref_mv_stack[ref_frame], &row_match_count, &newmv_count,
- gm_mv_candidates, &refmv_count[ref_frame]);
+ ref_mv_stack[ref_frame], ref_mv_weight[ref_frame],
+ &row_match_count, &newmv_count, gm_mv_candidates,
+ &refmv_count[ref_frame]);
const uint8_t nearest_match = (row_match_count > 0) + (col_match_count > 0);
const uint8_t nearest_refmv_count = refmv_count[ref_frame];
// TODO(yunqing): for comp_search, do it for all 3 cases.
for (int idx = 0; idx < nearest_refmv_count; ++idx)
- ref_mv_stack[ref_frame][idx].weight += REF_CAT_LEVEL;
+ ref_mv_weight[ref_frame][idx] += REF_CAT_LEVEL;
if (cm->allow_ref_frame_mvs) {
int is_available = 0;
@@ -584,7 +592,7 @@
for (int blk_col = 0; blk_col < blk_col_end; blk_col += step_w) {
int ret = add_tpl_ref_mv(cm, xd, mi_row, mi_col, ref_frame, blk_row,
blk_col, gm_mv_candidates, refmv_count,
- ref_mv_stack, mode_context);
+ ref_mv_stack, ref_mv_weight, mode_context);
if (blk_row == 0 && blk_col == 0) is_available = ret;
}
}
@@ -597,7 +605,8 @@
if (!check_sb_border(mi_row, mi_col, blk_row, blk_col)) continue;
add_tpl_ref_mv(cm, xd, mi_row, mi_col, ref_frame, blk_row, blk_col,
- gm_mv_candidates, refmv_count, ref_mv_stack, mode_context);
+ gm_mv_candidates, refmv_count, ref_mv_stack, ref_mv_weight,
+ mode_context);
}
}
@@ -605,8 +614,8 @@
// Scan the second outer area.
scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, -1, ref_mv_stack[ref_frame],
- &row_match_count, &dummy_newmv_count, gm_mv_candidates,
- &refmv_count[ref_frame]);
+ ref_mv_weight[ref_frame], &row_match_count, &dummy_newmv_count,
+ gm_mv_candidates, &refmv_count[ref_frame]);
for (int idx = 2; idx <= MVREF_ROW_COLS; ++idx) {
const int row_offset = -(idx << 1) + 1 + row_adj;
@@ -615,16 +624,18 @@
if (abs(row_offset) <= abs(max_row_offset) &&
abs(row_offset) > processed_rows)
scan_row_mbmi(cm, xd, mi_row, mi_col, rf, row_offset,
- ref_mv_stack[ref_frame], &refmv_count[ref_frame],
- &row_match_count, &dummy_newmv_count, gm_mv_candidates,
- max_row_offset, &processed_rows);
+ ref_mv_stack[ref_frame], ref_mv_weight[ref_frame],
+ &refmv_count[ref_frame], &row_match_count,
+ &dummy_newmv_count, gm_mv_candidates, max_row_offset,
+ &processed_rows);
if (abs(col_offset) <= abs(max_col_offset) &&
abs(col_offset) > processed_cols)
scan_col_mbmi(cm, xd, mi_row, mi_col, rf, col_offset,
- ref_mv_stack[ref_frame], &refmv_count[ref_frame],
- &col_match_count, &dummy_newmv_count, gm_mv_candidates,
- max_col_offset, &processed_cols);
+ ref_mv_stack[ref_frame], ref_mv_weight[ref_frame],
+ &refmv_count[ref_frame], &col_match_count,
+ &dummy_newmv_count, gm_mv_candidates, max_col_offset,
+ &processed_cols);
}
const uint8_t ref_match_count = (row_match_count > 0) + (col_match_count > 0);
@@ -661,11 +672,13 @@
while (len > 0) {
int nr_len = 0;
for (int idx = 1; idx < len; ++idx) {
- if (ref_mv_stack[ref_frame][idx - 1].weight <
- ref_mv_stack[ref_frame][idx].weight) {
+ if (ref_mv_weight[ref_frame][idx - 1] < ref_mv_weight[ref_frame][idx]) {
CANDIDATE_MV tmp_mv = ref_mv_stack[ref_frame][idx - 1];
+ int tmp_ref_mv_weight = ref_mv_weight[ref_frame][idx - 1];
ref_mv_stack[ref_frame][idx - 1] = ref_mv_stack[ref_frame][idx];
ref_mv_stack[ref_frame][idx] = tmp_mv;
+ ref_mv_weight[ref_frame][idx - 1] = ref_mv_weight[ref_frame][idx];
+ ref_mv_weight[ref_frame][idx] = tmp_ref_mv_weight;
nr_len = idx;
}
}
@@ -676,11 +689,13 @@
while (len > nearest_refmv_count) {
int nr_len = nearest_refmv_count;
for (int idx = nearest_refmv_count + 1; idx < len; ++idx) {
- if (ref_mv_stack[ref_frame][idx - 1].weight <
- ref_mv_stack[ref_frame][idx].weight) {
+ if (ref_mv_weight[ref_frame][idx - 1] < ref_mv_weight[ref_frame][idx]) {
CANDIDATE_MV tmp_mv = ref_mv_stack[ref_frame][idx - 1];
+ int tmp_ref_mv_weight = ref_mv_weight[ref_frame][idx - 1];
ref_mv_stack[ref_frame][idx - 1] = ref_mv_stack[ref_frame][idx];
ref_mv_stack[ref_frame][idx] = tmp_mv;
+ ref_mv_weight[ref_frame][idx - 1] = ref_mv_weight[ref_frame][idx];
+ ref_mv_weight[ref_frame][idx] = tmp_ref_mv_weight;
nr_len = idx;
}
}
@@ -745,7 +760,7 @@
ref_mv_stack[ref_frame][refmv_count[ref_frame]].comp_mv =
comp_list[0][1];
}
- ref_mv_stack[ref_frame][refmv_count[ref_frame]].weight = 2;
+ ref_mv_weight[ref_frame][refmv_count[ref_frame]] = 2;
++refmv_count[ref_frame];
} else {
for (int idx = 0; idx < MAX_MV_REF_CANDIDATES; ++idx) {
@@ -753,7 +768,7 @@
comp_list[idx][0];
ref_mv_stack[ref_frame][refmv_count[ref_frame]].comp_mv =
comp_list[idx][1];
- ref_mv_stack[ref_frame][refmv_count[ref_frame]].weight = 2;
+ ref_mv_weight[ref_frame][refmv_count[ref_frame]] = 2;
++refmv_count[ref_frame];
}
}
@@ -779,7 +794,7 @@
refmv_count[ref_frame] < MAX_MV_REF_CANDIDATES;) {
const MB_MODE_INFO *const candidate = xd->mi[-xd->mi_stride + idx];
process_single_ref_mv_candidate(candidate, cm, ref_frame, refmv_count,
- ref_mv_stack);
+ ref_mv_stack, ref_mv_weight);
idx += mi_size_wide[candidate->sb_type];
}
@@ -787,7 +802,7 @@
refmv_count[ref_frame] < MAX_MV_REF_CANDIDATES;) {
const MB_MODE_INFO *const candidate = xd->mi[idx * xd->mi_stride - 1];
process_single_ref_mv_candidate(candidate, cm, ref_frame, refmv_count,
- ref_mv_stack);
+ ref_mv_stack, ref_mv_weight);
idx += mi_size_high[candidate->sb_type];
}
@@ -813,6 +828,7 @@
MB_MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
uint8_t ref_mv_count[MODE_CTX_REF_FRAMES],
CANDIDATE_MV ref_mv_stack[][MAX_REF_MV_STACK_SIZE],
+ int ref_mv_weight[][MAX_REF_MV_STACK_SIZE],
int_mv mv_ref_list[][MAX_MV_REF_CANDIDATES],
int_mv *global_mvs, int mi_row, int mi_col,
int16_t *mode_context) {
@@ -848,8 +864,9 @@
zeromv[0].as_int = zeromv[1].as_int = 0;
}
- setup_ref_mv_list(cm, xd, ref_frame, ref_mv_count, ref_mv_stack, mv_ref_list,
- zeromv, mi_row, mi_col, mode_context);
+ setup_ref_mv_list(cm, xd, ref_frame, ref_mv_count, ref_mv_stack,
+ ref_mv_weight, mv_ref_list, zeromv, mi_row, mi_col,
+ mode_context);
}
void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv,
diff --git a/av1/common/mvref_common.h b/av1/common/mvref_common.h
index 0aa9d38..ad67b22 100644
--- a/av1/common/mvref_common.h
+++ b/av1/common/mvref_common.h
@@ -189,18 +189,17 @@
return comp_ctx;
}
-static INLINE uint8_t av1_drl_ctx(const CANDIDATE_MV *ref_mv_stack,
- int ref_idx) {
- if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL &&
- ref_mv_stack[ref_idx + 1].weight >= REF_CAT_LEVEL)
+static INLINE uint8_t av1_drl_ctx(const int *ref_mv_weight, int ref_idx) {
+ if (ref_mv_weight[ref_idx] >= REF_CAT_LEVEL &&
+ ref_mv_weight[ref_idx + 1] >= REF_CAT_LEVEL)
return 0;
- if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL &&
- ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL)
+ if (ref_mv_weight[ref_idx] >= REF_CAT_LEVEL &&
+ ref_mv_weight[ref_idx + 1] < REF_CAT_LEVEL)
return 1;
- if (ref_mv_stack[ref_idx].weight < REF_CAT_LEVEL &&
- ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL)
+ if (ref_mv_weight[ref_idx] < REF_CAT_LEVEL &&
+ ref_mv_weight[ref_idx + 1] < REF_CAT_LEVEL)
return 2;
return 0;
@@ -251,6 +250,7 @@
MB_MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
uint8_t ref_mv_count[MODE_CTX_REF_FRAMES],
CANDIDATE_MV ref_mv_stack[][MAX_REF_MV_STACK_SIZE],
+ int ref_mv_weight[][MAX_REF_MV_STACK_SIZE],
int_mv mv_ref_list[][MAX_MV_REF_CANDIDATES],
int_mv *global_mvs, int mi_row, int mi_col,
int16_t *mode_context);
diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index 2791f3a..311ee76 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -183,7 +183,7 @@
if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV) {
for (int idx = 0; idx < 2; ++idx) {
if (xd->ref_mv_count[ref_frame_type] > idx + 1) {
- uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
+ uint8_t drl_ctx = av1_drl_ctx(xd->weight[ref_frame_type], idx);
int drl_idx = aom_read_symbol(r, ec_ctx->drl_cdf[drl_ctx], 2, ACCT_STR);
mbmi->ref_mv_idx = idx + drl_idx;
if (!drl_idx) return;
@@ -196,7 +196,7 @@
// mode is factored in.
for (int idx = 1; idx < 3; ++idx) {
if (xd->ref_mv_count[ref_frame_type] > idx + 1) {
- uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
+ uint8_t drl_ctx = av1_drl_ctx(xd->weight[ref_frame_type], idx);
int drl_idx = aom_read_symbol(r, ec_ctx->drl_cdf[drl_ctx], 2, ACCT_STR);
mbmi->ref_mv_idx = idx + drl_idx - 1;
if (!drl_idx) return;
@@ -680,8 +680,8 @@
int_mv ref_mvs[INTRA_FRAME + 1][MAX_MV_REF_CANDIDATES];
av1_find_mv_refs(cm, xd, mbmi, INTRA_FRAME, xd->ref_mv_count,
- xd->ref_mv_stack, ref_mvs, /*global_mvs=*/NULL, mi_row,
- mi_col, inter_mode_ctx);
+ xd->ref_mv_stack, xd->weight, ref_mvs, /*global_mvs=*/NULL,
+ mi_row, mi_col, inter_mode_ctx);
int_mv nearestmv, nearmv;
@@ -1271,7 +1271,7 @@
MV_REFERENCE_FRAME ref_frame = av1_ref_frame_type(mbmi->ref_frame);
av1_find_mv_refs(cm, xd, mbmi, ref_frame, xd->ref_mv_count, xd->ref_mv_stack,
- ref_mvs, /*global_mvs=*/NULL, mi_row, mi_col,
+ xd->weight, ref_mvs, /*global_mvs=*/NULL, mi_row, mi_col,
inter_mode_ctx);
int mode_ctx = av1_mode_context_analyzer(inter_mode_ctx, mbmi->ref_frame);
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 354f9eb..1db2822 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -106,8 +106,7 @@
int idx;
for (idx = 0; idx < 2; ++idx) {
if (mbmi_ext->ref_mv_count[ref_frame_type] > idx + 1) {
- uint8_t drl_ctx =
- av1_drl_ctx(mbmi_ext->ref_mv_stack[ref_frame_type], idx);
+ uint8_t drl_ctx = av1_drl_ctx(mbmi_ext->weight[ref_frame_type], idx);
aom_write_symbol(w, mbmi->ref_mv_idx != idx, ec_ctx->drl_cdf[drl_ctx],
2);
@@ -122,8 +121,7 @@
// TODO(jingning): Temporary solution to compensate the NEARESTMV offset.
for (idx = 1; idx < 3; ++idx) {
if (mbmi_ext->ref_mv_count[ref_frame_type] > idx + 1) {
- uint8_t drl_ctx =
- av1_drl_ctx(mbmi_ext->ref_mv_stack[ref_frame_type], idx);
+ uint8_t drl_ctx = av1_drl_ctx(mbmi_ext->weight[ref_frame_type], idx);
aom_write_symbol(w, mbmi->ref_mv_idx != (idx - 1),
ec_ctx->drl_cdf[drl_ctx], 2);
if (mbmi->ref_mv_idx == (idx - 1)) return;
diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index 96b0991d..e8ca91c 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h
@@ -77,6 +77,7 @@
// TODO(angiebird): Reduce the buffer size according to sb_type
CB_COEFF_BUFFER *cb_coef_buff;
CANDIDATE_MV ref_mv_stack[MODE_CTX_REF_FRAMES][MAX_REF_MV_STACK_SIZE];
+ int weight[MODE_CTX_REF_FRAMES][MAX_REF_MV_STACK_SIZE];
int_mv global_mvs[REF_FRAMES];
int cb_offset;
int16_t mode_context[MODE_CTX_REF_FRAMES];
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index fc341d0..b1306ce 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -1361,7 +1361,7 @@
if (mbmi_ext->ref_mv_count[ref_frame_type] > idx + 1) {
#if CONFIG_ENTROPY_STATS
uint8_t drl_ctx =
- av1_drl_ctx(mbmi_ext->ref_mv_stack[ref_frame_type], idx);
+ av1_drl_ctx(mbmi_ext->weight[ref_frame_type], idx);
++counts->drl_mode[drl_ctx][mbmi->ref_mv_idx != idx];
#endif
@@ -1378,7 +1378,7 @@
if (mbmi_ext->ref_mv_count[ref_frame_type] > idx + 1) {
#if CONFIG_ENTROPY_STATS
uint8_t drl_ctx =
- av1_drl_ctx(mbmi_ext->ref_mv_stack[ref_frame_type], idx);
+ av1_drl_ctx(mbmi_ext->weight[ref_frame_type], idx);
++counts->drl_mode[drl_ctx][mbmi->ref_mv_idx != idx - 1];
#endif
diff --git a/av1/encoder/nonrd_pickmode.c b/av1/encoder/nonrd_pickmode.c
index 2576815..443fee6 100644
--- a/av1/encoder/nonrd_pickmode.c
+++ b/av1/encoder/nonrd_pickmode.c
@@ -449,8 +449,9 @@
av1_setup_pred_block(xd, yv12_mb[ref_frame], yv12, mi_row, mi_col, sf, sf,
num_planes);
av1_find_mv_refs(cm, xd, mbmi, ref_frame, mbmi_ext->ref_mv_count,
- mbmi_ext->ref_mv_stack, NULL, mbmi_ext->global_mvs, mi_row,
- mi_col, mbmi_ext->mode_context);
+ mbmi_ext->ref_mv_stack, mbmi_ext->weight, NULL,
+ mbmi_ext->global_mvs, mi_row, mi_col,
+ mbmi_ext->mode_context);
av1_find_best_ref_mvs_from_stack(cm->allow_high_precision_mv, mbmi_ext,
ref_frame, &frame_mv[NEARESTMV][ref_frame],
&frame_mv[NEARMV][ref_frame], 0);
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index bf79787..5a6556e 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -7041,8 +7041,9 @@
// Gets an initial list of candidate vectors from neighbours and orders them
av1_find_mv_refs(cm, xd, mbmi, ref_frame, mbmi_ext->ref_mv_count,
- mbmi_ext->ref_mv_stack, NULL, mbmi_ext->global_mvs, mi_row,
- mi_col, mbmi_ext->mode_context);
+ mbmi_ext->ref_mv_stack, mbmi_ext->weight, NULL,
+ mbmi_ext->global_mvs, mi_row, mi_col,
+ mbmi_ext->mode_context);
// Further refinement that is encode side only to test the top few candidates
// in full and choose the best as the center point for subsequent searches.
@@ -9840,8 +9841,7 @@
if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV) {
for (int idx = 0; idx < 2; ++idx) {
if (mbmi_ext->ref_mv_count[ref_frame_type] > idx + 1) {
- uint8_t drl_ctx =
- av1_drl_ctx(mbmi_ext->ref_mv_stack[ref_frame_type], idx);
+ uint8_t drl_ctx = av1_drl_ctx(mbmi_ext->weight[ref_frame_type], idx);
cost += drl_mode_cost0[drl_ctx][mbmi->ref_mv_idx != idx];
if (mbmi->ref_mv_idx == idx) return cost;
}
@@ -9852,8 +9852,7 @@
if (have_nearmv_in_inter_mode(mbmi->mode)) {
for (int idx = 1; idx < 3; ++idx) {
if (mbmi_ext->ref_mv_count[ref_frame_type] > idx + 1) {
- uint8_t drl_ctx =
- av1_drl_ctx(mbmi_ext->ref_mv_stack[ref_frame_type], idx);
+ uint8_t drl_ctx = av1_drl_ctx(mbmi_ext->weight[ref_frame_type], idx);
cost += drl_mode_cost0[drl_ctx][mbmi->ref_mv_idx != (idx - 1)];
if (mbmi->ref_mv_idx == (idx - 1)) return cost;
}
@@ -10263,8 +10262,8 @@
mbmi->ref_frame[0] == LAST3_FRAME ||
mbmi->ref_frame[1] == LAST2_FRAME ||
mbmi->ref_frame[1] == LAST3_FRAME) {
- if (mbmi_ext->ref_mv_stack[ref_frame_type][ref_mv_idx + has_nearmv]
- .weight < REF_CAT_LEVEL) {
+ if (mbmi_ext->weight[ref_frame_type][ref_mv_idx + has_nearmv] <
+ REF_CAT_LEVEL) {
continue;
}
}
@@ -10657,8 +10656,9 @@
MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
MV_REFERENCE_FRAME ref_frame = INTRA_FRAME;
av1_find_mv_refs(cm, xd, mbmi, ref_frame, mbmi_ext->ref_mv_count,
- mbmi_ext->ref_mv_stack, NULL, mbmi_ext->global_mvs, mi_row,
- mi_col, mbmi_ext->mode_context);
+ mbmi_ext->ref_mv_stack, mbmi_ext->weight, NULL,
+ mbmi_ext->global_mvs, mi_row, mi_col,
+ mbmi_ext->mode_context);
int_mv nearestmv, nearmv;
av1_find_best_ref_mvs_from_stack(0, mbmi_ext, ref_frame, &nearestmv, &nearmv,
@@ -10973,8 +10973,9 @@
}
MB_MODE_INFO_EXT *mbmi_ext = x->mbmi_ext;
av1_find_mv_refs(cm, xd, mbmi, ref_frame_type, mbmi_ext->ref_mv_count,
- mbmi_ext->ref_mv_stack, NULL, mbmi_ext->global_mvs, mi_row,
- mi_col, mbmi_ext->mode_context);
+ mbmi_ext->ref_mv_stack, mbmi_ext->weight, NULL,
+ mbmi_ext->global_mvs, mi_row, mi_col,
+ mbmi_ext->mode_context);
}
assert(this_mode == NEAREST_NEARESTMV);
@@ -11446,8 +11447,9 @@
}
}
av1_find_mv_refs(cm, xd, mbmi, ref_frame, mbmi_ext->ref_mv_count,
- mbmi_ext->ref_mv_stack, NULL, mbmi_ext->global_mvs, mi_row,
- mi_col, mbmi_ext->mode_context);
+ mbmi_ext->ref_mv_stack, mbmi_ext->weight, NULL,
+ mbmi_ext->global_mvs, mi_row, mi_col,
+ mbmi_ext->mode_context);
}
av1_count_overlappable_neighbors(cm, xd, mi_row, mi_col);
