Remove TOTAL_REFS_PER_FRAME
In the codebase, TOTAL_REFS_PER_FRAME in fact completely overlaps
with REF_FRAMES, as both are valued 8 and both indicate the maximum
total number of reference frames that can be buffered and then can
be used for each inter coded frame. This CL keeps REF_FRAMES and
removes TOTAL_REFS_PER_FRAME to avoid unnecessary confusion due to
duplicate definitions.
Change-Id: Ia9761194d7223cc7d3c1a974bf7b782c06e8b224
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 9ab8a6b..92d7580 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -1993,14 +1993,14 @@
const int prime_idx = cm->primary_ref_frame;
const int buf_idx =
prime_idx == PRIMARY_REF_NONE ? -1 : cm->frame_refs[prime_idx].idx;
- int8_t last_ref_deltas[TOTAL_REFS_PER_FRAME];
+ int8_t last_ref_deltas[REF_FRAMES];
if (prime_idx == PRIMARY_REF_NONE || buf_idx < 0) {
av1_set_default_ref_deltas(last_ref_deltas);
} else {
memcpy(last_ref_deltas, cm->buffer_pool->frame_bufs[buf_idx].ref_deltas,
- TOTAL_REFS_PER_FRAME);
+ REF_FRAMES);
}
- for (i = 0; i < TOTAL_REFS_PER_FRAME; i++) {
+ for (i = 0; i < REF_FRAMES; i++) {
const int delta = lf->ref_deltas[i];
const int changed = delta != last_ref_deltas[i];
aom_wb_write_bit(wb, changed);
@@ -2579,8 +2579,7 @@
if (!pars->update_parameters) {
RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs;
int ref_frame, ref_idx, buf_idx;
- for (ref_frame = LAST_FRAME; ref_frame < TOTAL_REFS_PER_FRAME;
- ref_frame++) {
+ for (ref_frame = LAST_FRAME; ref_frame < REF_FRAMES; ref_frame++) {
ref_idx = get_ref_frame_map_idx(cpi, ref_frame);
assert(ref_idx != INVALID_IDX);
buf_idx = cm->ref_frame_map[ref_idx];
@@ -2589,7 +2588,7 @@
break;
}
}
- assert(ref_frame < TOTAL_REFS_PER_FRAME);
+ assert(ref_frame < REF_FRAMES);
aom_wb_write_literal(wb, ref_idx, 3);
return;
}
diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index 096f024..63c99b9 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h
@@ -195,11 +195,11 @@
BLOCK_SIZE min_partition_size;
BLOCK_SIZE max_partition_size;
- int mv_best_ref_index[TOTAL_REFS_PER_FRAME];
- unsigned int max_mv_context[TOTAL_REFS_PER_FRAME];
+ int mv_best_ref_index[REF_FRAMES];
+ unsigned int max_mv_context[REF_FRAMES];
unsigned int source_variance;
- unsigned int pred_sse[TOTAL_REFS_PER_FRAME];
- int pred_mv_sad[TOTAL_REFS_PER_FRAME];
+ unsigned int pred_sse[REF_FRAMES];
+ int pred_mv_sad[REF_FRAMES];
int *nmvjointcost;
int nmv_vec_cost[MV_JOINTS];
@@ -300,7 +300,7 @@
int intrabc_cost[2];
// Used to store sub partition's choices.
- MV pred_mv[TOTAL_REFS_PER_FRAME];
+ MV pred_mv[REF_FRAMES];
// Store the best motion vector during motion search
int_mv best_mv;
diff --git a/av1/encoder/context_tree.c b/av1/encoder/context_tree.c
index 75bdfc1..d6e556b 100644
--- a/av1/encoder/context_tree.c
+++ b/av1/encoder/context_tree.c
@@ -207,7 +207,7 @@
dst_ctx->rdcost = src_ctx->rdcost;
dst_ctx->rd_mode_is_ready = src_ctx->rd_mode_is_ready;
- memcpy(dst_ctx->pred_mv, src_ctx->pred_mv, sizeof(MV) * TOTAL_REFS_PER_FRAME);
+ memcpy(dst_ctx->pred_mv, src_ctx->pred_mv, sizeof(MV) * REF_FRAMES);
dst_ctx->pred_interp_filter = src_ctx->pred_interp_filter;
dst_ctx->partition = src_ctx->partition;
diff --git a/av1/encoder/context_tree.h b/av1/encoder/context_tree.h
index ee3fb11..d44c72d 100644
--- a/av1/encoder/context_tree.h
+++ b/av1/encoder/context_tree.h
@@ -67,7 +67,7 @@
// motion vector cache for adaptive motion search control in partition
// search loop
- MV pred_mv[TOTAL_REFS_PER_FRAME];
+ MV pred_mv[REF_FRAMES];
InterpFilter pred_interp_filter;
PARTITION_TYPE partition;
} PICK_MODE_CONTEXT;
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index faf1187..3968b47 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -3855,14 +3855,14 @@
// (INTER_REFS_PER_FRAME - 1)
static void enforce_max_ref_frames(AV1_COMP *cpi) {
AV1_COMMON *const cm = &cpi->common;
- static const int flag_list[TOTAL_REFS_PER_FRAME] = { 0,
- AOM_LAST_FLAG,
- AOM_LAST2_FLAG,
- AOM_LAST3_FLAG,
- AOM_GOLD_FLAG,
- AOM_BWD_FLAG,
- AOM_ALT2_FLAG,
- AOM_ALT_FLAG };
+ static const int flag_list[REF_FRAMES] = { 0,
+ AOM_LAST_FLAG,
+ AOM_LAST2_FLAG,
+ AOM_LAST3_FLAG,
+ AOM_GOLD_FLAG,
+ AOM_BWD_FLAG,
+ AOM_ALT2_FLAG,
+ AOM_ALT_FLAG };
MV_REFERENCE_FRAME ref_frame;
int total_valid_refs = 0;
@@ -4006,14 +4006,14 @@
// High Latency: Turn off skip mode if all refs are fwd.
if (cpi->all_one_sided_refs && cpi->oxcf.lag_in_frames > 0) return 0;
- static const int flag_list[TOTAL_REFS_PER_FRAME] = { 0,
- AOM_LAST_FLAG,
- AOM_LAST2_FLAG,
- AOM_LAST3_FLAG,
- AOM_GOLD_FLAG,
- AOM_BWD_FLAG,
- AOM_ALT2_FLAG,
- AOM_ALT_FLAG };
+ static const int flag_list[REF_FRAMES] = { 0,
+ AOM_LAST_FLAG,
+ AOM_LAST2_FLAG,
+ AOM_LAST3_FLAG,
+ AOM_GOLD_FLAG,
+ AOM_BWD_FLAG,
+ AOM_ALT2_FLAG,
+ AOM_ALT_FLAG };
const int ref_frame[2] = { cm->ref_frame_idx_0 + LAST_FRAME,
cm->ref_frame_idx_1 + LAST_FRAME };
if (!(cpi->ref_frame_flags & flag_list[ref_frame[0]]) ||
@@ -4193,10 +4193,10 @@
av1_set_default_ref_deltas(cm->lf.ref_deltas);
av1_set_default_mode_deltas(cm->lf.mode_deltas);
} else if (cm->prev_frame) {
- memcpy(cm->lf.ref_deltas, cm->prev_frame->ref_deltas, TOTAL_REFS_PER_FRAME);
+ memcpy(cm->lf.ref_deltas, cm->prev_frame->ref_deltas, REF_FRAMES);
memcpy(cm->lf.mode_deltas, cm->prev_frame->mode_deltas, MAX_MODE_LF_DELTAS);
}
- memcpy(cm->cur_frame->ref_deltas, cm->lf.ref_deltas, TOTAL_REFS_PER_FRAME);
+ memcpy(cm->cur_frame->ref_deltas, cm->lf.ref_deltas, REF_FRAMES);
memcpy(cm->cur_frame->mode_deltas, cm->lf.mode_deltas, MAX_MODE_LF_DELTAS);
// Special case: set prev_mi to NULL when the previous mode info
@@ -4210,7 +4210,7 @@
av1_zero(cpi->gmparams_cost);
if (cpi->common.frame_type == INTER_FRAME && cpi->source &&
!cpi->global_motion_search_done) {
- YV12_BUFFER_CONFIG *ref_buf[TOTAL_REFS_PER_FRAME];
+ YV12_BUFFER_CONFIG *ref_buf[REF_FRAMES];
int frame;
double params_by_motion[RANSAC_NUM_MOTIONS * (MAX_PARAMDIM - 1)];
const double *params_this_motion;
@@ -4323,7 +4323,7 @@
cpi->global_motion_search_done = 1;
}
memcpy(cm->cur_frame->global_motion, cm->global_motion,
- TOTAL_REFS_PER_FRAME * sizeof(WarpedMotionParams));
+ REF_FRAMES * sizeof(WarpedMotionParams));
av1_setup_motion_field(cm);
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index 33d54fb..fd8414d 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -3617,7 +3617,7 @@
AV1_COMMON *cm = &cpi->common;
int i;
// TODO(isbs): only refresh the necessary frames, rather than all of them
- for (i = 0; i < TOTAL_REFS_PER_FRAME; ++i) {
+ for (i = 0; i < REF_FRAMES; ++i) {
const int idx = cpi->scaled_ref_idx[i];
RefCntBuffer *const buf =
idx != INVALID_IDX ? &cm->buffer_pool->frame_bufs[idx] : NULL;
@@ -4574,7 +4574,7 @@
static int setup_interp_filter_search_mask(AV1_COMP *cpi) {
InterpFilter ifilter;
- int ref_total[TOTAL_REFS_PER_FRAME] = { 0 };
+ int ref_total[REF_FRAMES] = { 0 };
MV_REFERENCE_FRAME ref;
int mask = 0;
int arf_idx = ALTREF_FRAME;
@@ -4626,14 +4626,14 @@
return;
}
- static const int flag_list[TOTAL_REFS_PER_FRAME] = { 0,
- AOM_LAST_FLAG,
- AOM_LAST2_FLAG,
- AOM_LAST3_FLAG,
- AOM_GOLD_FLAG,
- AOM_BWD_FLAG,
- AOM_ALT2_FLAG,
- AOM_ALT_FLAG };
+ static const int flag_list[REF_FRAMES] = { 0,
+ AOM_LAST_FLAG,
+ AOM_LAST2_FLAG,
+ AOM_LAST3_FLAG,
+ AOM_GOLD_FLAG,
+ AOM_BWD_FLAG,
+ AOM_ALT2_FLAG,
+ AOM_ALT_FLAG };
printf(
"\n***Frame=%d (frame_offset=%d, show_frame=%d, "
"show_existing_frame=%d) "
@@ -5873,8 +5873,7 @@
}
if (cpi->oxcf.pass != 0 || frame_is_intra_only(cm) == 1) {
- for (i = 0; i < TOTAL_REFS_PER_FRAME; ++i)
- cpi->scaled_ref_idx[i] = INVALID_IDX;
+ for (i = 0; i < REF_FRAMES; ++i) cpi->scaled_ref_idx[i] = INVALID_IDX;
}
cm->using_qmatrix = cpi->oxcf.using_qm;
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index 88e594e..cec3238 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -318,7 +318,7 @@
typedef struct RD_COUNTS {
int64_t comp_pred_diff[REFERENCE_MODES];
// Stores number of 4x4 blocks using global motion per reference frame.
- int global_motion_used[TOTAL_REFS_PER_FRAME];
+ int global_motion_used[REF_FRAMES];
int compound_ref_used_flag;
int skip_mode_used_flag;
} RD_COUNTS;
@@ -397,7 +397,7 @@
int cur_poc; // DebugInfo
#endif
- int scaled_ref_idx[TOTAL_REFS_PER_FRAME];
+ int scaled_ref_idx[REF_FRAMES];
int lst_fb_idxes[LAST_REF_FRAMES];
int gld_fb_idx;
int bwd_fb_idx; // BWDREF_FRAME
@@ -435,7 +435,7 @@
CODING_CONTEXT coding_context;
int gmtype_cost[TRANS_TYPES];
- int gmparams_cost[TOTAL_REFS_PER_FRAME];
+ int gmparams_cost[REF_FRAMES];
int nmv_costs[2][MV_VALS];
int nmv_costs_hp[2][MV_VALS];
diff --git a/av1/encoder/ethread.c b/av1/encoder/ethread.c
index 1dc7caa..bc83440 100644
--- a/av1/encoder/ethread.c
+++ b/av1/encoder/ethread.c
@@ -18,7 +18,7 @@
for (int i = 0; i < REFERENCE_MODES; i++)
td->rd_counts.comp_pred_diff[i] += td_t->rd_counts.comp_pred_diff[i];
- for (int i = 0; i < TOTAL_REFS_PER_FRAME; i++)
+ for (int i = 0; i < REF_FRAMES; i++)
td->rd_counts.global_motion_used[i] +=
td_t->rd_counts.global_motion_used[i];
diff --git a/av1/encoder/mbgraph.h b/av1/encoder/mbgraph.h
index e5c84a2..3e0a4fa 100644
--- a/av1/encoder/mbgraph.h
+++ b/av1/encoder/mbgraph.h
@@ -23,7 +23,7 @@
int_mv mv;
PREDICTION_MODE mode;
} m;
- } ref[TOTAL_REFS_PER_FRAME];
+ } ref[REF_FRAMES];
} MBGRAPH_MB_STATS;
typedef struct {
diff --git a/av1/encoder/rd.h b/av1/encoder/rd.h
index c67d054..47194d4 100644
--- a/av1/encoder/rd.h
+++ b/av1/encoder/rd.h
@@ -282,7 +282,7 @@
int threshes[MAX_SEGMENTS][BLOCK_SIZES_ALL][MAX_MODES];
- int64_t prediction_type_threshes[TOTAL_REFS_PER_FRAME][REFERENCE_MODES];
+ int64_t prediction_type_threshes[REF_FRAMES][REFERENCE_MODES];
int RDMULT;
} RD_OPT;
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index ec03137..89560bb 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -5114,12 +5114,13 @@
// 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,
- const int16_t mode_context[TOTAL_REFS_PER_FRAME],
- int_mv frame_mv[MB_MODE_COUNT][TOTAL_REFS_PER_FRAME], int this_mode,
- const MV_REFERENCE_FRAME ref_frames[2], const BLOCK_SIZE bsize, int mi_row,
- int mi_col) {
+static int check_best_zero_mv(const AV1_COMP *const cpi,
+ const MACROBLOCK *const x,
+ const int16_t mode_context[REF_FRAMES],
+ int_mv frame_mv[MB_MODE_COUNT][REF_FRAMES],
+ int this_mode,
+ const MV_REFERENCE_FRAME ref_frames[2],
+ const BLOCK_SIZE bsize, int mi_row, int mi_col) {
int_mv zeromv[2] = { { .as_int = 0 } };
int comp_pred_mode = ref_frames[1] > INTRA_FRAME;
if (this_mode == GLOBALMV || this_mode == GLOBAL_GLOBALMV) {
@@ -5390,16 +5391,15 @@
static void estimate_ref_frame_costs(
const AV1_COMMON *cm, const MACROBLOCKD *xd, const MACROBLOCK *x,
int segment_id, unsigned int *ref_costs_single,
- unsigned int (*ref_costs_comp)[TOTAL_REFS_PER_FRAME]) {
+ unsigned int (*ref_costs_comp)[REF_FRAMES]) {
int seg_ref_active =
segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME);
if (seg_ref_active) {
- memset(ref_costs_single, 0,
- TOTAL_REFS_PER_FRAME * sizeof(*ref_costs_single));
+ memset(ref_costs_single, 0, REF_FRAMES * sizeof(*ref_costs_single));
int ref_frame;
- for (ref_frame = 0; ref_frame < TOTAL_REFS_PER_FRAME; ++ref_frame)
+ for (ref_frame = 0; ref_frame < REF_FRAMES; ++ref_frame)
memset(ref_costs_comp[ref_frame], 0,
- TOTAL_REFS_PER_FRAME * sizeof((*ref_costs_comp)[0]));
+ REF_FRAMES * sizeof((*ref_costs_comp)[0]));
} else {
int intra_inter_ctx = av1_get_intra_inter_context(xd);
ref_costs_single[INTRA_FRAME] = x->intra_inter_cost[intra_inter_ctx][0];
@@ -5450,7 +5450,7 @@
const int ref_comp_ctx_p2 = av1_get_pred_context_comp_ref_p2(xd);
const int comp_ref_type_ctx = av1_get_comp_reference_type_context(xd);
- unsigned int ref_bicomp_costs[TOTAL_REFS_PER_FRAME] = { 0 };
+ unsigned int ref_bicomp_costs[REF_FRAMES] = { 0 };
ref_bicomp_costs[LAST_FRAME] = ref_bicomp_costs[LAST2_FRAME] =
ref_bicomp_costs[LAST3_FRAME] = ref_bicomp_costs[GOLDEN_FRAME] =
@@ -5544,9 +5544,8 @@
static void setup_buffer_inter(
const AV1_COMP *const cpi, MACROBLOCK *x, MV_REFERENCE_FRAME ref_frame,
BLOCK_SIZE block_size, int mi_row, int mi_col,
- int_mv frame_nearest_mv[TOTAL_REFS_PER_FRAME],
- int_mv frame_near_mv[TOTAL_REFS_PER_FRAME],
- struct buf_2d yv12_mb[TOTAL_REFS_PER_FRAME][MAX_MB_PLANE]) {
+ int_mv frame_nearest_mv[REF_FRAMES], int_mv frame_near_mv[REF_FRAMES],
+ struct buf_2d yv12_mb[REF_FRAMES][MAX_MB_PLANE]) {
const AV1_COMMON *cm = &cpi->common;
const int num_planes = av1_num_planes(cm);
const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_buffer(cpi, ref_frame);
@@ -6053,7 +6052,7 @@
mask = av1_get_compound_type_mask(comp_data, sb_type);
- int_mv frame_mv[TOTAL_REFS_PER_FRAME];
+ int_mv frame_mv[REF_FRAMES];
MV_REFERENCE_FRAME rf[2] = { mbmi->ref_frame[0], mbmi->ref_frame[1] };
frame_mv[rf[0]].as_int = cur_mv[0].as_int;
@@ -6078,8 +6077,7 @@
// near mv modes to reduce distortion in subsequent blocks and also improve
// visual quality.
static int discount_newmv_test(const AV1_COMP *const cpi, int this_mode,
- int_mv this_mv,
- int_mv (*mode_mv)[TOTAL_REFS_PER_FRAME],
+ int_mv this_mv, int_mv (*mode_mv)[REF_FRAMES],
int ref_frame) {
return (!cpi->rc.is_src_frame_alt_ref && (this_mode == NEWMV) &&
(this_mv.as_int != 0) &&
@@ -6509,13 +6507,13 @@
int *single_newmv_valid;
// Pointer to array of predicted rate-distortion
// Should point to first of 2 arrays in 2D array
- int64_t (*modelled_rd)[TOTAL_REFS_PER_FRAME];
- InterpFilter single_filter[MB_MODE_COUNT][TOTAL_REFS_PER_FRAME];
+ int64_t (*modelled_rd)[REF_FRAMES];
+ InterpFilter single_filter[MB_MODE_COUNT][REF_FRAMES];
} HandleInterModeArgs;
static int64_t handle_newmv(const AV1_COMP *const cpi, MACROBLOCK *const x,
const BLOCK_SIZE bsize,
- int_mv (*const mode_mv)[TOTAL_REFS_PER_FRAME],
+ int_mv (*const mode_mv)[REF_FRAMES],
const int mi_row, const int mi_col,
int *const rate_mv, int_mv *const single_newmv,
HandleInterModeArgs *const args) {
@@ -6607,8 +6605,7 @@
static int64_t interpolation_filter_search(
MACROBLOCK *const x, const AV1_COMP *const cpi, BLOCK_SIZE bsize,
int mi_row, int mi_col, const BUFFER_SET *const tmp_dst,
- BUFFER_SET *const orig_dst,
- InterpFilter (*const single_filter)[TOTAL_REFS_PER_FRAME],
+ BUFFER_SET *const orig_dst, InterpFilter (*const single_filter)[REF_FRAMES],
int64_t *const rd, int *const switchable_rate, int *const skip_txfm_sb,
int64_t *const skip_sse_sb) {
const AV1_COMMON *cm = &cpi->common;
@@ -6775,12 +6772,14 @@
// TODO(afergs): Refactor the MBMI references in here - there's four
// TODO(afergs): Refactor optional args - add them to a struct or remove
-static int64_t motion_mode_rd(
- const AV1_COMP *const cpi, MACROBLOCK *const x, BLOCK_SIZE bsize,
- RD_STATS *rd_stats, RD_STATS *rd_stats_y, RD_STATS *rd_stats_uv,
- int *disable_skip, int_mv (*mode_mv)[TOTAL_REFS_PER_FRAME], int mi_row,
- int mi_col, HandleInterModeArgs *const args, const int64_t ref_best_rd,
- const int *refs, int rate_mv, BUFFER_SET *orig_dst) {
+static int64_t motion_mode_rd(const AV1_COMP *const cpi, MACROBLOCK *const x,
+ BLOCK_SIZE bsize, RD_STATS *rd_stats,
+ RD_STATS *rd_stats_y, RD_STATS *rd_stats_uv,
+ int *disable_skip, int_mv (*mode_mv)[REF_FRAMES],
+ int mi_row, int mi_col,
+ HandleInterModeArgs *const args,
+ const int64_t ref_best_rd, const int *refs,
+ int rate_mv, BUFFER_SET *orig_dst) {
const AV1_COMMON *const cm = &cpi->common;
const int num_planes = av1_num_planes(cm);
MACROBLOCKD *xd = &x->e_mbd;
@@ -7279,11 +7278,13 @@
return 0;
}
-static int64_t handle_inter_mode(
- const AV1_COMP *const cpi, MACROBLOCK *x, BLOCK_SIZE bsize,
- RD_STATS *rd_stats, RD_STATS *rd_stats_y, RD_STATS *rd_stats_uv,
- int *disable_skip, int_mv (*mode_mv)[TOTAL_REFS_PER_FRAME], int mi_row,
- int mi_col, HandleInterModeArgs *args, const int64_t ref_best_rd) {
+static int64_t handle_inter_mode(const AV1_COMP *const cpi, MACROBLOCK *x,
+ BLOCK_SIZE bsize, RD_STATS *rd_stats,
+ RD_STATS *rd_stats_y, RD_STATS *rd_stats_uv,
+ int *disable_skip,
+ int_mv (*mode_mv)[REF_FRAMES], int mi_row,
+ int mi_col, HandleInterModeArgs *args,
+ const int64_t ref_best_rd) {
const AV1_COMMON *cm = &cpi->common;
const int num_planes = av1_num_planes(cm);
MACROBLOCKD *xd = &x->e_mbd;
@@ -7300,7 +7301,7 @@
int rate_mv = 0;
int pred_exists = 1;
const int bw = block_size_wide[bsize];
- int_mv single_newmv[TOTAL_REFS_PER_FRAME];
+ int_mv single_newmv[REF_FRAMES];
uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
DECLARE_ALIGNED(32, uint8_t, tmp_buf_[2 * MAX_MB_PLANE * MAX_SB_SQUARE]);
uint8_t *tmp_buf;
@@ -8173,8 +8174,8 @@
static void estimate_skip_mode_rdcost(
const AV1_COMP *const cpi, TileDataEnc *tile_data, MACROBLOCK *const x,
BLOCK_SIZE bsize, int mi_row, int mi_col,
- int_mv frame_mv[MB_MODE_COUNT][TOTAL_REFS_PER_FRAME],
- struct buf_2d yv12_mb[TOTAL_REFS_PER_FRAME][MAX_MB_PLANE]) {
+ int_mv frame_mv[MB_MODE_COUNT][REF_FRAMES],
+ struct buf_2d yv12_mb[REF_FRAMES][MAX_MB_PLANE]) {
const AV1_COMMON *const cm = &cpi->common;
const int num_planes = av1_num_planes(cm);
MACROBLOCKD *const xd = &x->e_mbd;
@@ -8182,14 +8183,14 @@
MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
int *mode_map = tile_data->mode_map[bsize];
- static const int flag_list[TOTAL_REFS_PER_FRAME] = { 0,
- AOM_LAST_FLAG,
- AOM_LAST2_FLAG,
- AOM_LAST3_FLAG,
- AOM_GOLD_FLAG,
- AOM_BWD_FLAG,
- AOM_ALT2_FLAG,
- AOM_ALT_FLAG };
+ static const int flag_list[REF_FRAMES] = { 0,
+ AOM_LAST_FLAG,
+ AOM_LAST2_FLAG,
+ AOM_LAST3_FLAG,
+ AOM_GOLD_FLAG,
+ AOM_BWD_FLAG,
+ AOM_ALT2_FLAG,
+ AOM_ALT_FLAG };
int i;
for (int midx = 0; midx < MAX_MODES; ++midx) {
@@ -8308,21 +8309,21 @@
MV_REFERENCE_FRAME ref_frame, second_ref_frame;
unsigned char segment_id = mbmi->segment_id;
int comp_pred, i, k;
- int_mv frame_mv[MB_MODE_COUNT][TOTAL_REFS_PER_FRAME];
- struct buf_2d yv12_mb[TOTAL_REFS_PER_FRAME][MAX_MB_PLANE];
+ int_mv frame_mv[MB_MODE_COUNT][REF_FRAMES];
+ struct buf_2d yv12_mb[REF_FRAMES][MAX_MB_PLANE];
// Save a set of single_newmv for each checked ref_mv.
- int_mv single_newmv[MAX_REF_MV_SERCH][TOTAL_REFS_PER_FRAME] = { { { 0 } } };
- int single_newmv_rate[MAX_REF_MV_SERCH][TOTAL_REFS_PER_FRAME] = { { 0 } };
- int single_newmv_valid[MAX_REF_MV_SERCH][TOTAL_REFS_PER_FRAME] = { { 0 } };
- int64_t modelled_rd[MB_MODE_COUNT][TOTAL_REFS_PER_FRAME];
- static const int flag_list[TOTAL_REFS_PER_FRAME] = { 0,
- AOM_LAST_FLAG,
- AOM_LAST2_FLAG,
- AOM_LAST3_FLAG,
- AOM_GOLD_FLAG,
- AOM_BWD_FLAG,
- AOM_ALT2_FLAG,
- AOM_ALT_FLAG };
+ int_mv single_newmv[MAX_REF_MV_SERCH][REF_FRAMES] = { { { 0 } } };
+ int single_newmv_rate[MAX_REF_MV_SERCH][REF_FRAMES] = { { 0 } };
+ int single_newmv_valid[MAX_REF_MV_SERCH][REF_FRAMES] = { { 0 } };
+ int64_t modelled_rd[MB_MODE_COUNT][REF_FRAMES];
+ static const int flag_list[REF_FRAMES] = { 0,
+ AOM_LAST_FLAG,
+ AOM_LAST2_FLAG,
+ AOM_LAST3_FLAG,
+ AOM_GOLD_FLAG,
+ AOM_BWD_FLAG,
+ AOM_ALT2_FLAG,
+ AOM_ALT_FLAG };
int64_t best_rd = best_rd_so_far;
int best_rate_y = INT_MAX, best_rate_uv = INT_MAX;
int64_t best_pred_diff[REFERENCE_MODES];
@@ -8333,8 +8334,8 @@
int rate_skip1 = x->skip_cost[skip_ctx][1];
int best_mode_skippable = 0;
int midx, best_mode_index = -1;
- unsigned int ref_costs_single[TOTAL_REFS_PER_FRAME];
- unsigned int ref_costs_comp[TOTAL_REFS_PER_FRAME][TOTAL_REFS_PER_FRAME];
+ unsigned int ref_costs_single[REF_FRAMES];
+ unsigned int ref_costs_comp[REF_FRAMES][REF_FRAMES];
int *comp_inter_cost = x->comp_inter_cost[av1_get_reference_mode_context(xd)];
int64_t best_intra_rd = INT64_MAX;
unsigned int best_pred_sse = UINT_MAX;
@@ -8352,7 +8353,7 @@
const int *const intra_mode_cost = x->mbmode_cost[size_group_lookup[bsize]];
int best_skip2 = 0;
uint16_t ref_frame_skip_mask[2] = { 0 };
- uint32_t mode_skip_mask[TOTAL_REFS_PER_FRAME] = { 0 };
+ uint32_t mode_skip_mask[REF_FRAMES] = { 0 };
int mode_skip_start = sf->mode_skip_start + 1;
const int *const rd_threshes = rd_opt->threshes[segment_id][bsize];
const int *const rd_thresh_freq_fact = tile_data->thresh_freq_fact[bsize];
@@ -8399,8 +8400,8 @@
args.left_pred_buf[2] = x->left_pred_buf + MAX_SB_SQUARE;
}
- int64_t dist_refs[TOTAL_REFS_PER_FRAME];
- int dist_order_refs[TOTAL_REFS_PER_FRAME];
+ int64_t dist_refs[REF_FRAMES];
+ int dist_order_refs[REF_FRAMES];
int num_available_refs = 0;
memset(dist_refs, -1, sizeof(dist_refs));
memset(dist_order_refs, -1, sizeof(dist_order_refs));
@@ -8415,9 +8416,9 @@
for (i = 0; i < REFERENCE_MODES; ++i) best_pred_rd[i] = INT64_MAX;
for (i = 0; i < TX_SIZES_ALL; i++) rate_uv_intra[i] = INT_MAX;
- for (i = 0; i < TOTAL_REFS_PER_FRAME; ++i) x->pred_sse[i] = INT_MAX;
+ for (i = 0; i < REF_FRAMES; ++i) x->pred_sse[i] = INT_MAX;
for (i = 0; i < MB_MODE_COUNT; ++i) {
- for (k = 0; k < TOTAL_REFS_PER_FRAME; ++k) {
+ for (k = 0; k < REF_FRAMES; ++k) {
args.single_filter[i][k] = SWITCHABLE;
}
}
@@ -8603,7 +8604,7 @@
x->use_default_inter_tx_type = 0;
for (i = 0; i < MB_MODE_COUNT; ++i)
- for (ref_frame = 0; ref_frame < TOTAL_REFS_PER_FRAME; ++ref_frame)
+ for (ref_frame = 0; ref_frame < REF_FRAMES; ++ref_frame)
modelled_rd[i][ref_frame] = INT64_MAX;
x->skip_mode_rdcost = -1;
@@ -8692,9 +8693,7 @@
ref_frame_skip_mask[1] |= SECOND_REF_FRAME_MASK;
break;
case NONE_FRAME:
- case TOTAL_REFS_PER_FRAME:
- assert(0 && "Invalid Reference frame");
- break;
+ case REF_FRAMES: assert(0 && "Invalid Reference frame"); break;
}
}
@@ -9394,8 +9393,8 @@
// Reach the last single ref prediction mode
if (ref_frame == ALTREF_FRAME && this_mode == GLOBALMV) {
// bubble sort dist_refs and the order index
- for (i = 0; i < TOTAL_REFS_PER_FRAME; ++i) {
- for (k = i + 1; k < TOTAL_REFS_PER_FRAME; ++k) {
+ for (i = 0; i < REF_FRAMES; ++i) {
+ for (k = i + 1; k < REF_FRAMES; ++k) {
if (dist_refs[i] < dist_refs[k]) {
int64_t tmp_dist = dist_refs[i];
dist_refs[i] = dist_refs[k];
@@ -9408,7 +9407,7 @@
}
}
- for (i = 0; i < TOTAL_REFS_PER_FRAME; ++i) {
+ for (i = 0; i < REF_FRAMES; ++i) {
if (dist_refs[i] == -1) break;
num_available_refs = i;
}
@@ -9853,8 +9852,8 @@
const int comp_pred = 0;
int i;
int64_t best_pred_diff[REFERENCE_MODES];
- unsigned int ref_costs_single[TOTAL_REFS_PER_FRAME];
- unsigned int ref_costs_comp[TOTAL_REFS_PER_FRAME][TOTAL_REFS_PER_FRAME];
+ unsigned int ref_costs_single[REF_FRAMES];
+ unsigned int ref_costs_comp[REF_FRAMES][REF_FRAMES];
int *comp_inter_cost = x->comp_inter_cost[av1_get_reference_mode_context(xd)];
InterpFilter best_filter = SWITCHABLE;
int64_t this_rd = INT64_MAX;
@@ -9868,9 +9867,8 @@
estimate_ref_frame_costs(cm, xd, x, segment_id, ref_costs_single,
ref_costs_comp);
- for (i = 0; i < TOTAL_REFS_PER_FRAME; ++i) x->pred_sse[i] = INT_MAX;
- for (i = LAST_FRAME; i < TOTAL_REFS_PER_FRAME; ++i)
- x->pred_mv_sad[i] = INT_MAX;
+ for (i = 0; i < REF_FRAMES; ++i) x->pred_sse[i] = INT_MAX;
+ for (i = LAST_FRAME; i < REF_FRAMES; ++i) x->pred_mv_sad[i] = INT_MAX;
rd_cost->rate = INT_MAX;
