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

Combined two experiments of NEWMVREF and COMPOUND_MODES to NEW_INTER

Browse Source 
Runborgs results on derflr show consistent results between NEW_INTER
and the previous combination of NEWMVREF and COMPOUND_MODES.

Change-Id: Ieba239c4faa7f93bc5c05ad656a7a3b818b4fbfc
This commit is contained in:
Zoe Liu 2015-05-19 10:16:44 -07:00
parent 0a1c529b26
commit 6437c3cb6d
19 changed files with 458 additions and 669 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
vp9/common/vp9_blockd.h
View File

@ -88,10 +88,8 @@ typedef enum {
NEARMV,
ZEROMV,
NEWMV,
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
NEAR_FORNEWMV,
#endif // CONFIG_NEWMVREF
#if CONFIG_COMPOUND_MODES
NEAREST_NEARESTMV,
NEAREST_NEARMV,
NEAR_NEARESTMV,
@ -101,7 +99,7 @@ typedef enum {
NEW_NEARMV,
ZERO_ZEROMV,
NEW_NEWMV,
#endif
#endif // CONFIG_NEW_INTER
MB_MODE_COUNT
} PREDICTION_MODE;
@ -116,38 +114,31 @@ typedef enum {
#endif // CONFIG_COPY_MODE
static INLINE int is_inter_mode(PREDICTION_MODE mode) {
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
return mode >= NEARESTMV && mode <= NEAR_FORNEWMV;
#else
return mode >= NEARESTMV && mode <= NEWMV;
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
}
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
static INLINE int is_inter_compound_mode(PREDICTION_MODE mode) {
return mode >= NEAREST_NEARESTMV && mode <= NEW_NEWMV;
}
#endif
#endif // CONFIG_NEW_INTER
static INLINE int have_newmv_in_inter_mode(PREDICTION_MODE mode) {
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
return (mode == NEWMV ||
#if CONFIG_NEWMVREF
mode == NEAR_FORNEWMV ||
#endif // CONFIG_NEWMVREF
mode == NEW_NEWMV ||
mode == NEAREST_NEWMV ||
mode == NEW_NEARESTMV ||
mode == NEAR_NEWMV ||
mode == NEW_NEARMV);
#else
#if CONFIG_NEWMVREF
return (mode == NEWMV ||
mode == NEAR_FORNEWMV);
#else
return (mode == NEWMV);
#endif // CONFIG_NEWMVREF
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
}
#if CONFIG_INTRABC
@ -159,21 +150,21 @@ static INLINE int is_intrabc_mode(PREDICTION_MODE mode) {
#define INTRA_MODES (TM_PRED + 1) // XXX
#endif // CONFIG_INTRABC
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
#define INTER_MODES (1 + NEAR_FORNEWMV - NEARESTMV)
#else
#define INTER_MODES (1 + NEWMV - NEARESTMV)
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
#define INTER_OFFSET(mode) ((mode) - NEARESTMV)
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
#define INTER_COMPOUND_MODES (1 + NEW_NEWMV - NEAREST_NEARESTMV)
#define INTER_COMPOUND_OFFSET(mode) ((mode) - NEAREST_NEARESTMV)
#endif
#endif // CONFIG_NEW_INTER
#if CONFIG_TX64X64
#define MAXTXLEN 64
@ -188,9 +179,9 @@ static INLINE int is_intrabc_mode(PREDICTION_MODE mode) {
typedef struct {
PREDICTION_MODE as_mode;
int_mv as_mv[2]; // first, second inter predictor motion vectors
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
int_mv ref_mv[2];
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
} b_mode_info;
// Note that the rate-distortion optimization loop, bit-stream writer, and

24
vp9/common/vp9_entropymode.c
View File

@ -414,7 +414,7 @@ static const vp9_prob default_partition_probs[PARTITION_CONTEXTS]
static const vp9_prob default_inter_mode_probs[INTER_MODE_CONTEXTS]
[INTER_MODES - 1] = {
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
// TODO(zoeliu): To adjust the initial default probs
{2, 173, 34, 173}, // 0 = both zero mv
{7, 145, 85, 145}, // 1 = one zero mv + one a predicted mv
@ -431,10 +431,10 @@ static const vp9_prob default_inter_mode_probs[INTER_MODE_CONTEXTS]
{8, 64, 46}, // 4 = two new mvs
{17, 81, 31}, // 5 = one intra neighbour + x
{25, 29, 30}, // 6 = two intra neighbours
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
};
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
static const vp9_prob default_inter_compound_mode_probs
[INTER_MODE_CONTEXTS][INTER_COMPOUND_MODES - 1] = {
{ 2, 173, 68, 192, 192, 128, 180, 180}, // 0 = both zero mv
@ -445,7 +445,7 @@ static const vp9_prob default_inter_compound_mode_probs
{17, 81, 52, 192, 192, 128, 180, 180}, // 5 = one intra neighbour
{25, 29, 50, 192, 192, 128, 180, 180}, // 6 = two intra neighbours
};
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
/* Array indices are identical to previously-existing INTRAMODECONTEXTNODES. */
const vp9_tree_index vp9_intra_mode_tree[TREE_SIZE(INTRA_MODES)] = {
@ -468,15 +468,15 @@ const vp9_tree_index vp9_intra_mode_tree[TREE_SIZE(INTRA_MODES)] = {
const vp9_tree_index vp9_inter_mode_tree[TREE_SIZE(INTER_MODES)] = {
-INTER_OFFSET(ZEROMV), 2,
-INTER_OFFSET(NEARESTMV), 4,
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
-INTER_OFFSET(NEARMV), 6,
-INTER_OFFSET(NEWMV), -INTER_OFFSET(NEAR_FORNEWMV)
#else
-INTER_OFFSET(NEARMV), -INTER_OFFSET(NEWMV)
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
};
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
const vp9_tree_index vp9_inter_compound_mode_tree
[TREE_SIZE(INTER_COMPOUND_MODES)] = {
-INTER_COMPOUND_OFFSET(ZERO_ZEROMV), 2,
@ -489,7 +489,7 @@ const vp9_tree_index vp9_inter_compound_mode_tree
-INTER_COMPOUND_OFFSET(NEAREST_NEWMV), -INTER_COMPOUND_OFFSET(NEW_NEARESTMV),
-INTER_COMPOUND_OFFSET(NEAR_NEWMV), -INTER_COMPOUND_OFFSET(NEW_NEARMV),
};
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
const vp9_tree_index vp9_partition_tree[TREE_SIZE(PARTITION_TYPES)] = {
-PARTITION_NONE, 2,
@ -990,9 +990,9 @@ void vp9_init_mode_probs(FRAME_CONTEXT *fc) {
fc->tx_probs = default_tx_probs;
vp9_copy(fc->skip_probs, default_skip_probs);
vp9_copy(fc->inter_mode_probs, default_inter_mode_probs);
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
vp9_copy(fc->inter_compound_mode_probs, default_inter_compound_mode_probs);
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
#if CONFIG_FILTERINTRA
vp9_copy(fc->filterintra_prob, default_filterintra_prob);
#endif // CONFIG_FILTERINTRA
@ -1074,13 +1074,13 @@ void vp9_adapt_mode_probs(VP9_COMMON *cm) {
adapt_probs(vp9_inter_mode_tree, pre_fc->inter_mode_probs[i],
counts->inter_mode[i], fc->inter_mode_probs[i]);
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
for (i = 0; i < INTER_MODE_CONTEXTS; i++)
adapt_probs(vp9_inter_compound_mode_tree,
pre_fc->inter_compound_mode_probs[i],
counts->inter_compound_mode[i],
fc->inter_compound_mode_probs[i]);
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
for (i = 0; i < BLOCK_SIZE_GROUPS; i++)
adapt_probs(vp9_intra_mode_tree, pre_fc->y_mode_prob[i],

12
vp9/common/vp9_entropymode.h
View File

@ -49,10 +49,10 @@ typedef struct frame_contexts {
vp9_prob switchable_interp_prob[SWITCHABLE_FILTER_CONTEXTS]
[SWITCHABLE_FILTERS - 1];
vp9_prob inter_mode_probs[INTER_MODE_CONTEXTS][INTER_MODES - 1];
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
vp9_prob inter_compound_mode_probs[INTER_MODE_CONTEXTS]
[INTER_COMPOUND_MODES - 1];
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
vp9_prob intra_inter_prob[INTRA_INTER_CONTEXTS];
vp9_prob comp_inter_prob[COMP_INTER_CONTEXTS];
vp9_prob single_ref_prob[REF_CONTEXTS][2];
@ -116,9 +116,9 @@ typedef struct {
unsigned int switchable_interp[SWITCHABLE_FILTER_CONTEXTS]
[SWITCHABLE_FILTERS];
unsigned int inter_mode[INTER_MODE_CONTEXTS][INTER_MODES];
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
unsigned int inter_compound_mode[INTER_MODE_CONTEXTS][INTER_COMPOUND_MODES];
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
unsigned int intra_inter[INTRA_INTER_CONTEXTS][2];
unsigned int comp_inter[COMP_INTER_CONTEXTS][2];
unsigned int single_ref[REF_CONTEXTS][2][2];
@ -192,10 +192,10 @@ extern const vp9_tree_index vp9_copy_mode_tree_l2[TREE_SIZE(2)];
extern const vp9_tree_index vp9_copy_mode_tree[TREE_SIZE(COPY_MODE_COUNT - 1)];
#endif // CONFIG_COPY_MODE
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
extern const vp9_tree_index vp9_inter_compound_mode_tree
[TREE_SIZE(INTER_COMPOUND_MODES)];
#endif
#endif // CONFIG_NEW_INTER
void vp9_setup_past_independence(struct VP9Common *cm);

10
vp9/common/vp9_loopfilter.c
View File

@ -221,12 +221,10 @@ static const int mode_lf_lut[MB_MODE_COUNT] = {
0,
#endif // CONFIG_INTRABC
1, 1, 0, 1, // INTER_MODES (ZEROMV == 0)
#if CONFIG_NEWMVREF
1, // NEAR_FORNEWMV mode
#endif // CONFIG_NEWMVREF
#if CONFIG_COMPOUND_MODES
1, 1, 1, 1, 1, 1, 1, 0, 1 // INTER_COMPOUND_MODES (ZERO_ZEROMV == 0)
#endif
#if CONFIG_NEW_INTER
1, // NEAR_FORNEWMV mode
1, 1, 1, 1, 1, 1, 1, 0, 1 // INTER_COMPOUND_MODES (ZERO_ZEROMV == 0)
#endif // CONFIG_NEW_INTER
};
#if CONFIG_LOOP_POSTFILTER

36
vp9/common/vp9_mvref_common.c
View File

@ -25,9 +25,9 @@ static void find_mv_refs_idx(const VP9_COMMON *cm, const MACROBLOCKD *xd,
const MB_MODE_INFO *const prev_mbmi = prev_mi ? &prev_mi->mbmi : NULL;
const POSITION *const mv_ref_search = mv_ref_blocks[mi->mbmi.sb_type];
int different_ref_found = 0;
#if !CONFIG_NEWMVREF
#if !CONFIG_NEW_INTER
int context_counter = 0;
#endif // CONFIG_NEWMVREF
#endif // !CONFIG_NEW_INTER
// Blank the reference vector list
vpx_memset(mv_ref_list, 0, sizeof(*mv_ref_list) * MAX_MV_REF_CANDIDATES);
@ -42,9 +42,9 @@ static void find_mv_refs_idx(const VP9_COMMON *cm, const MACROBLOCKD *xd,
xd->mi_stride].src_mi;
const MB_MODE_INFO *const candidate = &candidate_mi->mbmi;
// Keep counts for entropy encoding.
#if !CONFIG_NEWMVREF
#if !CONFIG_NEW_INTER
context_counter += mode_2_counter[candidate->mode];
#endif // CONFIG_NEWMVREF
#endif // !CONFIG_NEW_INTER
different_ref_found = 1;
if (candidate->ref_frame[0] == ref_frame) {
@ -102,16 +102,16 @@ static void find_mv_refs_idx(const VP9_COMMON *cm, const MACROBLOCKD *xd,
Done:
#if !CONFIG_NEWMVREF
#if !CONFIG_NEW_INTER
mi->mbmi.mode_context[ref_frame] = counter_to_context[context_counter];
#endif // CONFIG_NEWMVREF
#endif // !CONFIG_NEW_INTER
// Clamp vectors
for (i = 0; i < MAX_MV_REF_CANDIDATES; ++i)
clamp_mv_ref(&mv_ref_list[i].as_mv, xd);
}
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
// This function keeps a mode count for a given MB/SB
void vp9_update_mv_context(const VP9_COMMON *cm, const MACROBLOCKD *xd,
const TileInfo *const tile,
@ -149,17 +149,17 @@ void vp9_update_mv_context(const VP9_COMMON *cm, const MACROBLOCKD *xd,
mi->mbmi.mode_context[ref_frame] = counter_to_context[context_counter];
}
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
void vp9_find_mv_refs(const VP9_COMMON *cm, const MACROBLOCKD *xd,
const TileInfo *const tile,
MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
int_mv *mv_ref_list,
int mi_row, int mi_col) {
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
vp9_update_mv_context(cm, xd, tile, mi, ref_frame, mv_ref_list, -1,
mi_row, mi_col);
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
find_mv_refs_idx(cm, xd, tile, mi, ref_frame, mv_ref_list, -1,
mi_row, mi_col);
}
@ -181,13 +181,13 @@ void vp9_find_best_ref_mvs(MACROBLOCKD *xd, int allow_hp,
void vp9_append_sub8x8_mvs_for_idx(VP9_COMMON *cm, MACROBLOCKD *xd,
const TileInfo *const tile,
int block, int ref, int mi_row, int mi_col,
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
int_mv *mv_list,
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
int_mv *nearest, int_mv *near) {
#if !CONFIG_NEWMVREF
#if !CONFIG_NEW_INTER
int_mv mv_list[MAX_MV_REF_CANDIDATES];
#endif // CONFIG_NEWMVREF
#endif // !CONFIG_NEW_INTER
MODE_INFO *const mi = xd->mi[0].src_mi;
b_mode_info *bmi = mi->bmi;
int n;
@ -204,9 +204,9 @@ void vp9_append_sub8x8_mvs_for_idx(VP9_COMMON *cm, MACROBLOCKD *xd,
near->as_int = mv_list[1].as_int;
break;
case 1:
#if !CONFIG_NEWMVREF
#if !CONFIG_NEW_INTER
case 2:
#endif // !CONFIG_NEWMVREF
#endif // !CONFIG_NEW_INTER
nearest->as_int = bmi[0].as_mv[ref].as_int;
for (n = 0; n < MAX_MV_REF_CANDIDATES; ++n)
if (nearest->as_int != mv_list[n].as_int) {
@ -214,7 +214,7 @@ void vp9_append_sub8x8_mvs_for_idx(VP9_COMMON *cm, MACROBLOCKD *xd,
break;
}
break;
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
case 2: {
int_mv candidates[1 + MAX_MV_REF_CANDIDATES];
candidates[0] = bmi[1].as_mv[ref];
@ -229,7 +229,7 @@ void vp9_append_sub8x8_mvs_for_idx(VP9_COMMON *cm, MACROBLOCKD *xd,
}
break;
}
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
case 3: {
int_mv candidates[2 + MAX_MV_REF_CANDIDATES];
candidates[0] = bmi[1].as_mv[ref];

14
vp9/common/vp9_mvref_common.h
View File

@ -59,10 +59,8 @@ static const int mode_2_counter[MB_MODE_COUNT] = {
0, // NEARMV
3, // ZEROMV
1, // NEWMV
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
1, // NEAR_FORNEWMV
#endif // CONFIG_NEWMVREF
#if CONFIG_COMPOUND_MODES
0, // NEAREST_NEARESTMV
0, // NEAREST_NEARMV
0, // NEAR_NEARESTMV
@ -72,7 +70,7 @@ static const int mode_2_counter[MB_MODE_COUNT] = {
1, // NEW_NEARMV
3, // ZERO_ZEROMV
1, // NEW_NEWMV
#endif
#endif // CONFIG_NEW_INTER
};
// There are 3^3 different combinations of 3 counts that can be either 0,1 or
@ -226,14 +224,14 @@ static INLINE void clamp_mv2(MV *mv, const MACROBLOCKD *xd) {
xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN);
}
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
// This function keeps a mode count for a given MB/SB
void vp9_update_mv_context(const VP9_COMMON *cm, const MACROBLOCKD *xd,
const TileInfo *const tile,
MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
int_mv *mv_ref_list,
int block, int mi_row, int mi_col);
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
void vp9_find_mv_refs(const VP9_COMMON *cm, const MACROBLOCKD *xd,
const TileInfo *const tile,
@ -258,9 +256,9 @@ void vp9_find_best_ref_mvs(MACROBLOCKD *xd, int allow_hp,
void vp9_append_sub8x8_mvs_for_idx(VP9_COMMON *cm, MACROBLOCKD *xd,
const TileInfo *const tile,
int block, int ref, int mi_row, int mi_col,
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
int_mv *mv_list,
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
int_mv *nearest, int_mv *near);
#if CONFIG_COPY_MODE

12
vp9/decoder/vp9_decodeframe.c
View File

@ -2486,7 +2486,7 @@ static void read_supertx_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
}
#endif // CONFIG_SUPERTX
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
static void read_inter_compound_mode_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
int i, j;
if (vp9_read(r, GROUP_DIFF_UPDATE_PROB)) {
@ -2495,7 +2495,7 @@ static void read_inter_compound_mode_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
vp9_diff_update_prob(r, &fc->inter_compound_mode_probs[j][i]);
}
}
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
#if CONFIG_GLOBAL_MOTION
static void read_global_motion_params(Global_Motion_Params *params,
@ -2574,9 +2574,9 @@ static int read_compressed_header(VP9Decoder *pbi, const uint8_t *data,
int i, j;
read_inter_mode_probs(fc, &r);
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
read_inter_compound_mode_probs(fc, &r);
#endif
#endif // CONFIG_NEW_INTER
if (cm->interp_filter == SWITCHABLE)
read_switchable_interp_probs(fc, &r);
@ -2735,11 +2735,11 @@ static void debug_check_frame_counts(const VP9_COMMON *const cm) {
assert(!memcmp(cm->counts.ext_tx, zero_counts.ext_tx,
sizeof(cm->counts.ext_tx)));
#endif
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
assert(!memcmp(cm->counts.inter_compound_mode,
zero_counts.inter_compound_mode,
sizeof(cm->counts.inter_compound_mode)));
#endif
#endif // CONFIG_NEW_INTER
}
#endif // NDEBUG

88
vp9/decoder/vp9_decodemv.c
View File

@ -48,7 +48,7 @@ static PREDICTION_MODE read_intra_mode_uv(VP9_COMMON *cm, vp9_reader *r,
return uv_mode;
}
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
static PREDICTION_MODE read_inter_compound_mode(VP9_COMMON *cm, vp9_reader *r,
int ctx) {
int mode = 0;
@ -60,7 +60,7 @@ static PREDICTION_MODE read_inter_compound_mode(VP9_COMMON *cm, vp9_reader *r,
assert(is_inter_compound_mode(NEAREST_NEARESTMV + mode));
return NEAREST_NEARESTMV + mode;
}
#endif
#endif // CONFIG_NEW_INTER
static PREDICTION_MODE read_inter_mode(VP9_COMMON *cm, vp9_reader *r,
int ctx) {
@ -865,15 +865,15 @@ static INLINE int assign_mv(VP9_COMMON *cm, PREDICTION_MODE mode,
int i;
int ret = 1;
(void) ref_frame;
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
assert(is_inter_mode(mode) || is_inter_compound_mode(mode));
#else
assert(is_inter_mode(mode));
#endif
#endif // CONFIG_NEW_INTER
switch (mode) {
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
case NEAR_FORNEWMV:
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
case NEWMV: {
nmv_context_counts *const mv_counts = cm->frame_parallel_decoding_mode ?
NULL : &cm->counts.mv;
@ -912,7 +912,7 @@ static INLINE int assign_mv(VP9_COMMON *cm, PREDICTION_MODE mode,
#endif
break;
}
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
case NEW_NEWMV: {
nmv_context_counts *const mv_counts = cm->frame_parallel_decoding_mode ?
NULL : &cm->counts.mv;
@ -1008,7 +1008,7 @@ static INLINE int assign_mv(VP9_COMMON *cm, PREDICTION_MODE mode,
#endif // CONFIG_GLOBAL_MOTION
break;
}
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
default: {
return 0;
}
@ -1045,9 +1045,9 @@ static void read_inter_block_mode_info(VP9_COMMON *const cm,
int_mv nearestmv[2], nearmv[2];
int_mv ref_mv[2];
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
int mv_idx;
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
int inter_mode_ctx, ref, is_compound;
#if CONFIG_SUPERTX
(void) supertx_enabled;
@ -1092,21 +1092,21 @@ static void read_inter_block_mode_info(VP9_COMMON *const cm,
}
} else {
if (bsize >= BLOCK_8X8) {
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
if (is_compound)
mbmi->mode = read_inter_compound_mode(cm, r, inter_mode_ctx);
else
#endif
#endif // CONFIG_NEW_INTER
mbmi->mode = read_inter_mode(cm, r, inter_mode_ctx);
}
}
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
if (bsize < BLOCK_8X8 ||
(mbmi->mode != ZEROMV && mbmi->mode != ZERO_ZEROMV)) {
#else
if (bsize < BLOCK_8X8 || mbmi->mode != ZEROMV) {
#endif
#endif // CONFIG_NEW_INTER
for (ref = 0; ref < 1 + is_compound; ++ref) {
vp9_find_best_ref_mvs(xd, allow_hp, mbmi->ref_mvs[mbmi->ref_frame[ref]],
&nearestmv[ref], &nearmv[ref]);
@ -1157,71 +1157,59 @@ static void read_inter_block_mode_info(VP9_COMMON *const cm,
int idx, idy;
PREDICTION_MODE b_mode;
int_mv nearest_sub8x8[2], near_sub8x8[2];
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
int_mv ref_mvs[2][2];
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
for (idy = 0; idy < 2; idy += num_4x4_h) {
for (idx = 0; idx < 2; idx += num_4x4_w) {
int_mv mv_sub8x8[2];
const int j = idy * 2 + idx;
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
if (is_compound)
b_mode = read_inter_compound_mode(cm, r, inter_mode_ctx);
else
#endif
#endif // CONFIG_NEW_INTER
b_mode = read_inter_mode(cm, r, inter_mode_ctx);
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
mv_idx = (b_mode == NEAR_FORNEWMV) ? 1 : 0;
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
if (b_mode == NEARESTMV || b_mode == NEARMV ||
#if CONFIG_NEWMVREF
b_mode == NEWMV || b_mode == NEAR_FORNEWMV ||
b_mode == NEW_NEWMV ||
#endif // CONFIG_NEWMVREF
b_mode == NEAREST_NEARESTMV ||
b_mode == NEAREST_NEARMV || b_mode == NEAR_NEARESTMV ||
b_mode == NEAREST_NEWMV || b_mode == NEW_NEARESTMV ||
b_mode == NEAR_NEWMV || b_mode == NEW_NEARMV)
b_mode == NEAR_NEWMV || b_mode == NEW_NEARMV) {
#else
if (b_mode == NEARESTMV || b_mode == NEARMV
#if CONFIG_NEWMVREF
|| b_mode == NEWMV || b_mode == NEAR_FORNEWMV
#endif // CONFIG_NEWMVREF
)
#endif // CONFIG_COMPOUND_MODES
{
if (b_mode == NEARESTMV || b_mode == NEARMV) {
#endif // CONFIG_NEW_INTER
for (ref = 0; ref < 1 + is_compound; ++ref) {
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
int_mv mv_ref_list[MAX_MV_REF_CANDIDATES];
vp9_update_mv_context(cm, xd, tile, mi, mbmi->ref_frame[ref],
mv_ref_list, j, mi_row, mi_col);
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
vp9_append_sub8x8_mvs_for_idx(cm, xd, tile, j, ref, mi_row, mi_col,
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
mv_ref_list,
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
&nearest_sub8x8[ref],
&near_sub8x8[ref]);
#if CONFIG_NEWMVREF
if (b_mode == NEWMV || b_mode == NEAR_FORNEWMV
#if CONFIG_COMPOUND_MODES
|| b_mode == NEW_NEWMV ||
b_mode == NEAREST_NEWMV ||
b_mode == NEW_NEARESTMV ||
b_mode == NEAR_NEWMV ||
b_mode == NEW_NEARMV
#endif // CONFIG_COMPOUND_MODES
) {
#if CONFIG_NEW_INTER
if (b_mode == NEWMV || b_mode == NEAR_FORNEWMV ||
b_mode == NEW_NEWMV ||
b_mode == NEAREST_NEWMV || b_mode == NEW_NEARESTMV ||
b_mode == NEAR_NEWMV || b_mode == NEW_NEARMV) {
mv_ref_list[0].as_int = nearest_sub8x8[ref].as_int;
mv_ref_list[1].as_int = near_sub8x8[ref].as_int;
vp9_find_best_ref_mvs(xd, allow_hp, mv_ref_list,
&ref_mvs[0][ref], &ref_mvs[1][ref]);
ref_mv[ref].as_int = ref_mvs[mv_idx][ref].as_int;
}
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
}
}
@ -1248,12 +1236,12 @@ static void read_inter_block_mode_info(VP9_COMMON *const cm,
mbmi->mv[0].as_int = mi->bmi[3].as_mv[0].as_int;
mbmi->mv[1].as_int = mi->bmi[3].as_mv[1].as_int;
} else {
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
if (mbmi->mode == NEAR_FORNEWMV) {
for (ref = 0; ref < 1 + is_compound; ++ref)
ref_mv[ref].as_int = nearmv[ref].as_int;
}
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
xd->corrupted |= !assign_mv(cm, mbmi->mode, mbmi->ref_frame, mbmi->mv,
ref_mv, nearestmv, nearmv, is_compound,
allow_hp, r);
@ -1264,9 +1252,9 @@ static void read_inter_block_mode_info(VP9_COMMON *const cm,
#if CONFIG_WEDGE_PARTITION
mbmi->use_wedge_interinter = 0;
if (cm->reference_mode != SINGLE_REFERENCE &&
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
is_inter_compound_mode(mbmi->mode) &&
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
get_wedge_bits(bsize) &&
mbmi->ref_frame[1] > INTRA_FRAME) {
mbmi->use_wedge_interinter =

95
vp9/encoder/vp9_bitstream.c
View File

@ -52,9 +52,9 @@ static struct vp9_token palette_color_encodings[PALETTE_COLORS];
static struct vp9_token copy_mode_encodings_l2[2];
static struct vp9_token copy_mode_encodings[COPY_MODE_COUNT - 1];
#endif
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
static struct vp9_token inter_compound_mode_encodings[INTER_COMPOUND_MODES];
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
#if CONFIG_GLOBAL_MOTION
static struct vp9_token global_motion_types_encodings[GLOBAL_MOTION_TYPES];
#endif // CONFIG_GLOBAL_MOTION
@ -83,10 +83,10 @@ void vp9_entropy_mode_init() {
vp9_tokens_from_tree(palette_size_encodings, vp9_palette_size_tree);
vp9_tokens_from_tree(palette_color_encodings, vp9_palette_color_tree);
#endif // CONFIG_PALETTE
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
vp9_tokens_from_tree(inter_compound_mode_encodings,
vp9_inter_compound_mode_tree);
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
#if CONFIG_COPY_MODE
vp9_tokens_from_tree(copy_mode_encodings_l2, vp9_copy_mode_tree_l2);
vp9_tokens_from_tree(copy_mode_encodings, vp9_copy_mode_tree);
@ -124,14 +124,14 @@ static void write_copy_mode(VP9_COMMON *cm, vp9_writer *w, COPY_MODE mode,
}
#endif // CONFIG_COPY_MODE
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
static void write_inter_compound_mode(vp9_writer *w, PREDICTION_MODE mode,
const vp9_prob *probs) {
assert(is_inter_compound_mode(mode));
vp9_write_token(w, vp9_inter_compound_mode_tree, probs,
&inter_compound_mode_encodings[INTER_COMPOUND_OFFSET(mode)]);
}
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
static void encode_unsigned_max(struct vp9_write_bit_buffer *wb,
int data, int max) {
@ -265,7 +265,7 @@ static void update_supertx_probs(VP9_COMMON *cm, vp9_writer *w) {
}
#endif // CONFIG_SUPERTX
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
static void update_inter_compound_mode_probs(VP9_COMMON *cm, vp9_writer *w) {
const int savings_thresh = vp9_cost_one(GROUP_DIFF_UPDATE_PROB) -
vp9_cost_zero(GROUP_DIFF_UPDATE_PROB);
@ -289,7 +289,7 @@ static void update_inter_compound_mode_probs(VP9_COMMON *cm, vp9_writer *w) {
}
}
}
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
static void pack_mb_tokens(vp9_writer *w,
TOKENEXTRA **tp, const TOKENEXTRA *const stop,
@ -692,20 +692,20 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, const MODE_INFO *mi,
#endif // CONFIG_COPY_MODE
const int mode_ctx = mbmi->mode_context[mbmi->ref_frame[0]];
const vp9_prob *const inter_probs = cm->fc.inter_mode_probs[mode_ctx];
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
const vp9_prob *const inter_compound_probs =
cm->fc.inter_compound_mode_probs[mode_ctx];
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
write_ref_frames(cm, xd, w);
// If segment skip is not enabled code the mode.
if (!vp9_segfeature_active(seg, segment_id, SEG_LVL_SKIP)) {
if (bsize >= BLOCK_8X8) {
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
if (is_inter_compound_mode(mode))
write_inter_compound_mode(w, mode, inter_compound_probs);
else if (is_inter_mode(mode))
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
write_inter_mode(w, mode, inter_probs);
}
}
@ -754,85 +754,60 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, const MODE_INFO *mi,
for (idx = 0; idx < 2; idx += num_4x4_w) {
const int j = idy * 2 + idx;
const PREDICTION_MODE b_mode = mi->bmi[j].as_mode;
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
if (is_inter_compound_mode(b_mode))
write_inter_compound_mode(w, b_mode, inter_compound_probs);
else if (is_inter_mode(b_mode))
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
write_inter_mode(w, b_mode, inter_probs);
#if CONFIG_COMPOUND_MODES
if (b_mode == NEWMV ||
#if CONFIG_NEWMVREF
b_mode == NEAR_FORNEWMV ||
#endif // CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
if (b_mode == NEWMV || b_mode == NEAR_FORNEWMV ||
b_mode == NEW_NEWMV) {
#else
#if CONFIG_NEWMVREF
if (b_mode == NEWMV || b_mode == NEAR_FORNEWMV) {
#else
if (b_mode == NEWMV) {
#endif // CONFIG_NEWMVREF
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
for (ref = 0; ref < 1 + is_compound; ++ref) {
vp9_encode_mv(cpi, w, &mi->bmi[j].as_mv[ref].as_mv,
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
&mi->bmi[j].ref_mv[ref].as_mv,
#else
&mbmi->ref_mvs[mbmi->ref_frame[ref]][0].as_mv,
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
nmvc, allow_hp);
}
}
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
else if (b_mode == NEAREST_NEWMV || b_mode == NEAR_NEWMV) {
vp9_encode_mv(cpi, w, &mi->bmi[j].as_mv[1].as_mv,
#if CONFIG_NEWMVREF
&mi->bmi[j].ref_mv[1].as_mv,
#else
&mbmi->ref_mvs[mbmi->ref_frame[1]][0].as_mv,
#endif // CONFIG_NEWMVREF
nmvc, allow_hp);
&mi->bmi[j].ref_mv[1].as_mv, nmvc, allow_hp);
} else if (b_mode == NEW_NEARESTMV || b_mode == NEW_NEARMV) {
vp9_encode_mv(cpi, w, &mi->bmi[j].as_mv[0].as_mv,
#if CONFIG_NEWMVREF
&mi->bmi[j].ref_mv[0].as_mv,
#else
&mbmi->ref_mvs[mbmi->ref_frame[0]][0].as_mv,
#endif // CONFIG_NEWMVREF
nmvc, allow_hp);
&mi->bmi[j].ref_mv[0].as_mv, nmvc, allow_hp);
}
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
}
}
} else {
#if CONFIG_COMPOUND_MODES
if (mode == NEWMV ||
#if CONFIG_NEWMVREF
mode == NEAR_FORNEWMV ||
#endif // CONFIG_NEWMVREF
mode == NEW_NEWMV) {
#else // CONFIG_COMPOUND_MODES
#if CONFIG_NEWMVREF
if (mode == NEWMV || mode == NEAR_FORNEWMV) {
#if CONFIG_NEW_INTER
if (mode == NEWMV || mode == NEAR_FORNEWMV || mode == NEW_NEWMV) {
#else
if (mode == NEWMV) {
#endif // CONFIG_NEWMVREF
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
for (ref = 0; ref < 1 + is_compound; ++ref) {
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
if (mode == NEAR_FORNEWMV)
vp9_encode_mv(cpi, w, &mbmi->mv[ref].as_mv,
&mbmi->ref_mvs[mbmi->ref_frame[ref]][1].as_mv, nmvc,
allow_hp);
else
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
vp9_encode_mv(cpi, w, &mbmi->mv[ref].as_mv,
&mbmi->ref_mvs[mbmi->ref_frame[ref]][0].as_mv, nmvc,
allow_hp);
}
}
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
else if (mode == NEAREST_NEWMV || mode == NEAR_NEWMV) {
vp9_encode_mv(cpi, w, &mbmi->mv[1].as_mv,
&mbmi->ref_mvs[mbmi->ref_frame[1]][0].as_mv, nmvc,
@ -842,13 +817,13 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, const MODE_INFO *mi,
&mbmi->ref_mvs[mbmi->ref_frame[0]][0].as_mv, nmvc,
allow_hp);
}
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
}
#if CONFIG_WEDGE_PARTITION
if (cm->reference_mode != SINGLE_REFERENCE &&
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
is_inter_compound_mode(mode) &&
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
get_wedge_bits(bsize) &&
mbmi->ref_frame[1] > INTRA_FRAME) {
vp9_write(w, mbmi->use_wedge_interinter,
@ -857,7 +832,7 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, const MODE_INFO *mi,
vp9_write_literal(w, mbmi->interinter_wedge_index,
get_wedge_bits(bsize));
}
#endif // CONFIG_WEDGE_PARTITION
#endif // CONFIG_NEW_INTER
}
}
@ -2257,9 +2232,9 @@ static size_t write_compressed_header(VP9_COMP *cpi, uint8_t *data) {
cm->counts.inter_mode[i], INTER_MODES, &header_bc);
}
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
update_inter_compound_mode_probs(cm, &header_bc);
#endif
#endif // CONFIG_NEW_INTER
if (cm->interp_filter == SWITCHABLE)
update_switchable_interp_probs(cm, &header_bc);

35
vp9/encoder/vp9_denoiser.c
View File

@ -253,26 +253,20 @@ static VP9_DENOISER_DECISION perform_motion_compensation(VP9_DENOISER *denoiser,
frame = ctx->best_zeromv_reference_frame;
mbmi->ref_frame[0] = ctx->best_zeromv_reference_frame;
#if CONFIG_COMPOUND_MODES
if (has_second_ref(mbmi)) {
#if CONFIG_NEW_INTER
if (has_second_ref(mbmi))
mbmi->mode = ZERO_ZEROMV;
} else {
mbmi->mode = ZEROMV;
}
#else
else
#endif // CONFIG_NEW_INTER
mbmi->mode = ZEROMV;
#endif
mbmi->mv[0].as_int = 0;
#if CONFIG_COMPOUND_MODES
if (has_second_ref(mbmi)) {
#if CONFIG_NEW_INTER
if (has_second_ref(mbmi))
ctx->best_sse_inter_mode = ZERO_ZEROMV;
} else {
ctx->best_sse_inter_mode = ZEROMV;
}
#else
else
#endif // CONFIG_NEW_INTER
ctx->best_sse_inter_mode = ZEROMV;
#endif
ctx->best_sse_mv.as_int = 0;
ctx->newmv_sse = ctx->zeromv_sse;
}
@ -425,19 +419,12 @@ void vp9_denoiser_update_frame_stats(MB_MODE_INFO *mbmi, unsigned int sse,
ctx->zeromv_sse = sse;
ctx->best_zeromv_reference_frame = mbmi->ref_frame[0];
}
#if CONFIG_COMPOUND_MODES
if (mode == NEW_NEWMV || mode == NEWMV ||
#if CONFIG_NEWMVREF
mode == NEAR_FORNEWMV ||
#endif // CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
if (mode == NEW_NEWMV || mode == NEWMV || mode == NEAR_FORNEWMV ||
mode == NEW_NEARESTMV || mode == NEAREST_NEWMV) {
#else
#if CONFIG_NEWMVREF
if (mode == NEWMV || mode == NEAR_FORNEWMV) {
#else
if (mode == NEWMV) {
#endif // CONFIG_NEWMVREF
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
ctx->newmv_sse = sse;
ctx->best_sse_inter_mode = mode;
ctx->best_sse_mv = mbmi->mv[0];

40
vp9/encoder/vp9_encodeframe.c
View File

@ -890,7 +890,7 @@ static void update_state(VP9_COMP *cpi, PICK_MODE_CONTEXT *ctx,
#endif // CONFIG_COPY_MODE
#if CONFIG_GLOBAL_MOTION
if (bsize >= BLOCK_8X8) {
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
if (mbmi->mode == ZEROMV || mbmi->mode == ZERO_ZEROMV) {
++cpi->global_motion_used[mbmi->ref_frame[0]];
if (mbmi->mode == ZERO_ZEROMV)
@ -902,7 +902,7 @@ static void update_state(VP9_COMP *cpi, PICK_MODE_CONTEXT *ctx,
if (has_second_ref(mbmi))
++cpi->global_motion_used[mbmi->ref_frame[1]];
}
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
} else {
const int num_4x4_w = num_4x4_blocks_wide_lookup[bsize];
const int num_4x4_h = num_4x4_blocks_high_lookup[bsize];
@ -911,7 +911,7 @@ static void update_state(VP9_COMP *cpi, PICK_MODE_CONTEXT *ctx,
for (idx = 0; idx < 2; idx += num_4x4_w) {
const int j = idy * 2 + idx;
const PREDICTION_MODE b_mode = mi->bmi[j].as_mode;
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
if (b_mode == ZEROMV || b_mode == ZERO_ZEROMV) {
++cpi->global_motion_used[mbmi->ref_frame[0]];
if (b_mode == ZERO_ZEROMV)
@ -923,7 +923,7 @@ static void update_state(VP9_COMP *cpi, PICK_MODE_CONTEXT *ctx,
if (has_second_ref(mbmi))
++cpi->global_motion_used[mbmi->ref_frame[1]];
}
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
}
}
}
@ -1519,15 +1519,12 @@ static void update_stats(VP9_COMMON *cm, const MACROBLOCK *x) {
const int mode_ctx = mbmi->mode_context[mbmi->ref_frame[0]];
if (bsize >= BLOCK_8X8) {
const PREDICTION_MODE mode = mbmi->mode;
#if CONFIG_COMPOUND_MODES
if (is_inter_compound_mode(mode)) {
#if CONFIG_NEW_INTER
if (is_inter_compound_mode(mode))
++counts->inter_compound_mode[mode_ctx][INTER_COMPOUND_OFFSET(mode)];
} else {
++counts->inter_mode[mode_ctx][INTER_OFFSET(mode)];
}
#else
else
#endif // CONFIG_NEW_INTER
++counts->inter_mode[mode_ctx][INTER_OFFSET(mode)];
#endif
} else {
const int num_4x4_w = num_4x4_blocks_wide_lookup[bsize];
const int num_4x4_h = num_4x4_blocks_high_lookup[bsize];
@ -1536,16 +1533,13 @@ static void update_stats(VP9_COMMON *cm, const MACROBLOCK *x) {
for (idx = 0; idx < 2; idx += num_4x4_w) {
const int j = idy * 2 + idx;
const PREDICTION_MODE b_mode = mi->bmi[j].as_mode;
#if CONFIG_COMPOUND_MODES
if (is_inter_compound_mode(b_mode)) {
#if CONFIG_NEW_INTER
if (is_inter_compound_mode(b_mode))
++counts->inter_compound_mode[mode_ctx]
[INTER_COMPOUND_OFFSET(b_mode)];
} else {
++counts->inter_mode[mode_ctx][INTER_OFFSET(b_mode)];
}
#else
else
#endif // CONFIG_NEW_INTER
++counts->inter_mode[mode_ctx][INTER_OFFSET(b_mode)];
#endif
}
}
}
@ -3125,12 +3119,12 @@ static void rd_pick_partition(VP9_COMP *cpi, const TileInfo *const tile,
0);
sum_rdc.rdcost =
RDCOST(x->rdmult, x->rddiv, sum_rdc.rate, sum_rdc.dist);
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
if (is_inter_mode(pc_tree->leaf_split[0]->mic.mbmi.mode) ||
is_inter_compound_mode(pc_tree->leaf_split[0]->mic.mbmi.mode)) {
#else
if (is_inter_mode(pc_tree->leaf_split[0]->mic.mbmi.mode)) {
#endif
#endif // CONFIG_NEW_INTER
#if CONFIG_EXT_TX
EXT_TX_TYPE best_tx = NORM;
#endif
@ -5256,7 +5250,7 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, int output_enabled,
#if CONFIG_SUPERTX
static int check_intra_b(PICK_MODE_CONTEXT *ctx) {
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
#if CONFIG_INTERINTRA
return (!is_inter_mode((&ctx->mic)->mbmi.mode) &&
!is_inter_compound_mode((&ctx->mic)->mbmi.mode)) ||
@ -5265,14 +5259,14 @@ static int check_intra_b(PICK_MODE_CONTEXT *ctx) {
return !is_inter_mode((&ctx->mic)->mbmi.mode) &&
!is_inter_compound_mode((&ctx->mic)->mbmi.mode);
#endif // CONFIG_INTERINTRA
#else // CONFIG_COMPOUND_MODES
#else // CONFIG_NEW_INTER
#if CONFIG_INTERINTRA
return !is_inter_mode((&ctx->mic)->mbmi.mode) ||
(ctx->mic.mbmi.ref_frame[1] == INTRA_FRAME);
#else
return !is_inter_mode((&ctx->mic)->mbmi.mode);
#endif // CONFIG_INTERINTRA
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
}
static int check_intra_sb(VP9_COMP *cpi, const TileInfo *const tile,

46
vp9/encoder/vp9_encodemv.c
View File

@ -299,7 +299,7 @@ static void inc_mvs(const MB_MODE_INFO *mbmi, const int_mv mv[2],
}
}
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
static void inc_compound_single_mv(int ref_idx,
const int_mv mv[2],
const int_mv ref_mv[2],
@ -308,7 +308,7 @@ static void inc_compound_single_mv(int ref_idx,
mv[ref_idx].as_mv.col - ref_mv[ref_idx].as_mv.col};
vp9_inc_mv(&diff, counts);
}
#endif
#endif // CONFIG_NEW_INTER
void vp9_update_mv_count(VP9_COMMON *cm, const MACROBLOCKD *xd) {
const MODE_INFO *mi = xd->mi[0].src_mi;
@ -317,11 +317,11 @@ void vp9_update_mv_count(VP9_COMMON *cm, const MACROBLOCKD *xd) {
int_mv ref_mv[2];
for (ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) {
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
if (mbmi->sb_type >= BLOCK_8X8 && mbmi->mode == NEAR_FORNEWMV)
ref_mv[ref].as_int = mbmi->ref_mvs[mbmi->ref_frame[ref]][1].as_int;
else
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
ref_mv[ref].as_int = mbmi->ref_mvs[mbmi->ref_frame[ref]][0].as_int;
}
@ -334,28 +334,21 @@ void vp9_update_mv_count(VP9_COMMON *cm, const MACROBLOCKD *xd) {
for (idx = 0; idx < 2; idx += num_4x4_w) {
const int i = idy * 2 + idx;
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
for (ref = 0; ref < 1 + has_second_ref(mbmi); ++ref)
ref_mv[ref].as_int = mi->bmi[i].ref_mv[ref].as_int;
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
if (mi->bmi[i].as_mode == NEWMV ||
#if CONFIG_NEWMVREF
mi->bmi[i].as_mode == NEAR_FORNEWMV ||
#endif // CONFIG_NEWMVREF
mi->bmi[i].as_mode == NEW_NEWMV)
#else
#if CONFIG_NEWMVREF
if (mi->bmi[i].as_mode == NEWMV ||
mi->bmi[i].as_mode == NEAR_FORNEWMV)
#else
if (mi->bmi[i].as_mode == NEWMV)
#endif // CONFIG_NEWMVREF
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
inc_mvs(mbmi, mi->bmi[i].as_mv,
ref_mv, &cm->counts.mv);
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
else if (mi->bmi[i].as_mode == NEAREST_NEWMV ||
mi->bmi[i].as_mode == NEAR_NEWMV)
inc_compound_single_mv(1, mi->bmi[i].as_mv,
@ -364,30 +357,23 @@ void vp9_update_mv_count(VP9_COMMON *cm, const MACROBLOCKD *xd) {
mi->bmi[i].as_mode == NEW_NEARMV)
inc_compound_single_mv(0, mi->bmi[i].as_mv,
ref_mv, &cm->counts.mv);
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
}
}
} else {
#if CONFIG_COMPOUND_MODES
if (mbmi->mode == NEWMV ||
#if CONFIG_NEWMVREF
mbmi->mode == NEAR_FORNEWMV ||
#endif // CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
if (mbmi->mode == NEWMV || mbmi->mode == NEAR_FORNEWMV ||
mbmi->mode == NEW_NEWMV)
#else // CONFIG_COMPOUND_MODES
#if CONFIG_NEWMVREF
if (mbmi->mode == NEWMV || mbmi->mode == NEAR_FORNEWMV)
#else // CONFIG_NEWMVREF
#else
if (mbmi->mode == NEWMV)
#endif // CONFIG_NEWMVREF
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
inc_mvs(mbmi, mbmi->mv, ref_mv, &cm->counts.mv);
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
else if (mbmi->mode == NEAREST_NEWMV || mbmi->mode == NEAR_NEWMV)
inc_compound_single_mv(1, mbmi->mv, ref_mv, &cm->counts.mv);
else if (mbmi->mode == NEW_NEARESTMV || mbmi->mode == NEW_NEARMV)
inc_compound_single_mv(0, mbmi->mv, ref_mv, &cm->counts.mv);
#endif
#endif // CONFIG_NEW_INTER
}
}

4
vp9/encoder/vp9_encoder.h
View File

@ -396,10 +396,10 @@ typedef struct VP9_COMP {
int mbmode_cost[INTRA_MODES];
unsigned int inter_mode_cost[INTER_MODE_CONTEXTS][INTER_MODES];
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
unsigned int inter_compound_mode_cost[INTER_MODE_CONTEXTS]
[INTER_COMPOUND_MODES];
#endif
#endif // CONFIG_NEW_INTER
int intra_uv_mode_cost[FRAME_TYPES][INTRA_MODES];
int y_mode_costs[INTRA_MODES][INTRA_MODES][INTRA_MODES];
int switchable_interp_costs[SWITCHABLE_FILTER_CONTEXTS][SWITCHABLE_FILTERS];

11
vp9/encoder/vp9_mbgraph.c
View File

@ -62,15 +62,12 @@ static unsigned int do_16x16_motion_iteration(VP9_COMP *cpi,
NULL, NULL,
&distortion, &sse, NULL, 0, 0);
}
#if CONFIG_COMPOUND_MODES
if (has_second_ref(&xd->mi[0].src_mi->mbmi)) {
#if CONFIG_NEW_INTER
if (has_second_ref(&xd->mi[0].src_mi->mbmi))
xd->mi[0].src_mi->mbmi.mode = NEW_NEWMV;
} else {
#endif
else
#endif // CONFIG_NEW_INTER
xd->mi[0].src_mi->mbmi.mode = NEWMV;
#if CONFIG_COMPOUND_MODES
}
#endif
xd->mi[0].src_mi->mbmi.mv[0].as_mv = *dst_mv;
#if CONFIG_INTERINTRA
xd->mi[0].src_mi->mbmi.ref_frame[1] = NONE;

77
vp9/encoder/vp9_pickmode.c
View File

@ -174,17 +174,14 @@ static int combined_motion_search(VP9_COMP *cpi, MACROBLOCK *x,
*rate_mv = vp9_mv_bit_cost(&mvp_full, &ref_mv,
x->nmvjointcost, x->mvcost, MV_COST_WEIGHT);
#if CONFIG_COMPOUND_MODES
if (has_second_ref(mbmi)) {
#if CONFIG_NEW_INTER
if (has_second_ref(mbmi))
rate_mode = cpi->inter_compound_mode_cost[mbmi->mode_context[ref]]
[INTER_COMPOUND_OFFSET(NEW_NEWMV)];
} else {
#endif
else
#endif // CONFIG_NEW_INTER
rate_mode = cpi->inter_mode_cost[mbmi->mode_context[ref]]
[INTER_OFFSET(NEWMV)];
#if CONFIG_COMPOUND_MODES
}
#endif
rv = !(RDCOST(x->rdmult, x->rddiv, (*rate_mv + rate_mode), 0) >
best_rd_sofar);
@ -394,18 +391,15 @@ static void encode_breakout_test(VP9_COMP *cpi, MACROBLOCK *x,
x->skip = 1;
// The cost of skip bit needs to be added.
#if CONFIG_COMPOUND_MODES
if (has_second_ref(mbmi)) {
#if CONFIG_NEW_INTER
if (has_second_ref(mbmi))
*rate = cpi->inter_compound_mode_cost[mbmi->mode_context[ref_frame]]
[INTER_COMPOUND_OFFSET(this_mode)];
} else {
#endif
else
#endif // CONFIG_NEW_INTER
*rate = cpi->inter_mode_cost[mbmi->mode_context[ref_frame]]
[INTER_OFFSET(this_mode)];
#if CONFIG_COMPOUND_MODES
}
#endif
// More on this part of rate
// rate += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1);
@ -471,7 +465,7 @@ static void estimate_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
}
static const THR_MODES mode_idx[MAX_REF_FRAMES - 1][INTER_MODES] = {
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
{THR_NEARESTMV, THR_NEARMV, THR_ZEROMV, THR_NEWMV, THR_NEAR_FORNEWMV},
{THR_NEARESTG, THR_NEARG, THR_ZEROG, THR_NEWG, THR_NEAR_FORNEWG},
{THR_NEARESTA, THR_NEARA, THR_ZEROA, THR_NEWA, THR_NEAR_FORNEWA},
@ -479,7 +473,7 @@ static const THR_MODES mode_idx[MAX_REF_FRAMES - 1][INTER_MODES] = {
{THR_NEARESTMV, THR_NEARMV, THR_ZEROMV, THR_NEWMV},
{THR_NEARESTG, THR_NEARG, THR_ZEROG, THR_NEWG},
{THR_NEARESTA, THR_NEARA, THR_ZEROA, THR_NEWA},
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
};
// TODO(jingning) placeholder for inter-frame non-RD mode decision.
@ -626,51 +620,48 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
mbmi->ref_frame[0] = ref_frame;
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
for (this_mode = NEARESTMV; this_mode <= NEW_NEWMV; ++this_mode) {
#else
for (this_mode = NEARESTMV; this_mode <= NEWMV; ++this_mode) {
#endif
#endif // CONFIG_NEW_INTER
int rate_mv = 0;
int mode_rd_thresh;
#if CONFIG_GLOBAL_MOTION
if (const_motion[ref_frame] && this_mode == NEARMV)
#else // CONFIG_GLOBAL_MOTION
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
if (const_motion[ref_frame] &&
(this_mode == NEARMV || this_mode == ZEROMV ||
this_mode == ZERO_ZEROMV))
#else
if (const_motion[ref_frame] &&
(this_mode == NEARMV || this_mode == ZEROMV))
#endif
#endif // CONFIG_NEW_INTER
#endif // CONFIG_GLOBAL_MOTION
continue;
if (!(cpi->sf.inter_mode_mask[bsize] & (1 << this_mode)))
continue;
#if CONFIG_COMPOUND_MODES
if (has_second_ref(mbmi)) {
#if CONFIG_NEW_INTER
if (has_second_ref(mbmi))
mode_rd_thresh =
rd_threshes[mode_idx[ref_frame - LAST_FRAME]
[INTER_COMPOUND_OFFSET(this_mode)]];
} else {
#endif
mode_rd_thresh =
rd_threshes[mode_idx[ref_frame -
LAST_FRAME][INTER_OFFSET(this_mode)]];
#if CONFIG_COMPOUND_MODES
}
#endif
if (rd_less_than_thresh(best_rdc.rdcost, mode_rd_thresh,
rd_thresh_freq_fact[this_mode]))
continue;
else
#endif // CONFIG_NEW_INTER
mode_rd_thresh =
rd_threshes[mode_idx[ref_frame - LAST_FRAME]
[INTER_OFFSET(this_mode)]];
if (rd_less_than_thresh(best_rdc.rdcost, mode_rd_thresh,
rd_thresh_freq_fact[this_mode]))
continue;
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
if (this_mode == NEWMV || this_mode == NEW_NEWMV) {
#else
if (this_mode == NEWMV) {
#endif
#endif // CONFIG_NEW_INTER
if (cpi->sf.partition_search_type != VAR_BASED_PARTITION &&
this_rdc.rdcost < (int64_t)(1 << num_pels_log2_lookup[bsize]))
continue;
@ -680,11 +671,11 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
continue;
}
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
if (this_mode != NEARESTMV && this_mode != NEAREST_NEARESTMV &&
#else
if (this_mode != NEARESTMV &&
#endif
#endif // CONFIG_NEW_INTER
frame_mv[this_mode][ref_frame].as_int ==
frame_mv[NEARESTMV][ref_frame].as_int)
continue;
@ -696,11 +687,11 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
// motion vector is at sub-pixel accuracy level for luma component, i.e.,
// the last three bits are all zeros.
if (cpi->sf.reuse_inter_pred_sby) {
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
if (this_mode == NEARESTMV || this_mode == NEAREST_NEARESTMV) {
#else
if (this_mode == NEARESTMV) {
#endif
#endif // CONFIG_NEW_INTER
this_mode_pred = &tmp[3];
} else {
this_mode_pred = &tmp[get_pred_buffer(tmp, 3)];
@ -709,12 +700,12 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
}
}
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
if ((this_mode == NEWMV || this_mode == NEW_NEWMV ||
filter_ref == SWITCHABLE) &&
#else
if ((this_mode == NEWMV || filter_ref == SWITCHABLE) &&
#endif
#endif // CONFIG_NEW_INTER
pred_filter_search &&
((mbmi->mv[0].as_mv.row & 0x07) != 0 ||
(mbmi->mv[0].as_mv.col & 0x07) != 0)) {
@ -775,13 +766,13 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
}
this_rdc.rate += rate_mv;
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
if (has_second_ref(mbmi))
this_rdc.rate += cpi->inter_compound_mode_cost
[mbmi->mode_context[ref_frame]]
[INTER_COMPOUND_OFFSET(this_mode)];
else
#endif
#endif // CONFIG_NEW_INTER
this_rdc.rate += cpi->inter_mode_cost[mbmi->mode_context[ref_frame]]
[INTER_OFFSET(this_mode)];
this_rdc.rdcost = RDCOST(x->rdmult, x->rddiv,

20
vp9/encoder/vp9_rd.c
View File

@ -344,12 +344,12 @@ void vp9_initialize_rd_consts(VP9_COMP *cpi) {
vp9_cost_tokens((int *)cpi->inter_mode_cost[i],
cm->fc.inter_mode_probs[i], vp9_inter_mode_tree);
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
vp9_cost_tokens((int *)cpi->inter_compound_mode_cost[i],
cm->fc.inter_compound_mode_probs[i],
vp9_inter_compound_mode_tree);
#endif
#endif // CONFIG_NEW_INTER
#if CONFIG_INTRABC
} else {
vp9_build_nmv_cost_table(x->nmvjointcost,
@ -633,18 +633,18 @@ void vp9_set_rd_speed_thresholds(VP9_COMP *cpi) {
rd->thresh_mult[THR_NEWA] += 1000;
rd->thresh_mult[THR_NEWG] += 1000;
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
rd->thresh_mult[THR_NEAR_FORNEWMV] += 1000;
rd->thresh_mult[THR_NEAR_FORNEWA] += 1000;
rd->thresh_mult[THR_NEAR_FORNEWG] += 1000;
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
// Adjust threshold only in real time mode, which only uses last
// reference frame.
rd->thresh_mult[THR_NEWMV] += sf->elevate_newmv_thresh;
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
rd->thresh_mult[THR_NEAR_FORNEWMV] += sf->elevate_newmv_thresh;
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
rd->thresh_mult[THR_NEARMV] += 1000;
rd->thresh_mult[THR_NEARA] += 1000;
@ -656,7 +656,7 @@ void vp9_set_rd_speed_thresholds(VP9_COMP *cpi) {
rd->thresh_mult[THR_ZEROG] += 2000;
rd->thresh_mult[THR_ZEROA] += 2000;
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
rd->thresh_mult[THR_COMP_NEAREST_NEARESTLA] += 1000;
rd->thresh_mult[THR_COMP_NEAREST_NEARESTGA] += 1000;
rd->thresh_mult[THR_COMP_NEAREST_NEARLA] += 1200;
@ -682,13 +682,9 @@ void vp9_set_rd_speed_thresholds(VP9_COMP *cpi) {
rd->thresh_mult[THR_COMP_NEARGA] += 1500;
rd->thresh_mult[THR_COMP_NEWLA] += 2000;
rd->thresh_mult[THR_COMP_NEWGA] += 2000;
#if CONFIG_NEWMVREF
rd->thresh_mult[THR_COMP_NEAR_FORNEWLA] += 2000;
rd->thresh_mult[THR_COMP_NEAR_FORNEWGA] += 2000;
#endif // CONFIG_NEWMVREF
rd->thresh_mult[THR_COMP_ZEROLA] += 2500;
rd->thresh_mult[THR_COMP_ZEROGA] += 2500;
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
rd->thresh_mult[THR_H_PRED] += 2000;
rd->thresh_mult[THR_V_PRED] += 2000;

47
vp9/encoder/vp9_rd.h
View File

@ -37,47 +37,23 @@ extern "C" {
#define INVALID_MV 0x80008000
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
#if CONFIG_INTERINTRA
#if CONFIG_NEWMVREF
#define MAX_MODES 55
#else
#define MAX_MODES 52
#endif // CONFIG_NEWMVREF
#else // CONFIG_INTERINTRA
#if CONFIG_NEWMVREF
#define MAX_MODES 43
#else
#define MAX_MODES 40
#endif // CONFIG_NEWMVREF
#endif // CONFIG_INTERINTRA
#else // CONFIG_COMPOUND_MODES
#else // CONFIG_NEW_INTER
#if CONFIG_INTERINTRA
#if CONFIG_NEWMVREF
#define MAX_MODES 47
#else
#define MAX_MODES 42
#endif // CONFIG_NEWMVREF
#else // CONFIG_INTERINTRA
#if CONFIG_NEWMVREF
#define MAX_MODES 35
#else
#define MAX_MODES 30
#endif // CONFIG_NEWMVREF
#endif // CONFIG_INTERINTRA
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
#define MAX_REFS 6
@ -94,11 +70,11 @@ typedef enum {
THR_NEWA,
THR_NEWG,
#if CONFIG_NEWMVREF
#if CONFIG_NEW_INTER
THR_NEAR_FORNEWMV,
THR_NEAR_FORNEWA,
THR_NEAR_FORNEWG,
#endif // CONFIG_NEWMVREF
#endif // CONFIG_NEW_INTER
THR_NEARMV,
THR_NEARA,
@ -108,17 +84,17 @@ typedef enum {
THR_ZEROG,
THR_ZEROA,
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
THR_COMP_NEAREST_NEARESTLA,
THR_COMP_NEAREST_NEARESTGA,
#else
THR_COMP_NEARESTLA,
THR_COMP_NEARESTGA,
#endif
#endif // CONFIG_NEW_INTER
THR_TM,
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
THR_COMP_NEAR_NEARESTLA,
THR_COMP_NEAR_NEARESTGA,
THR_COMP_NEAREST_NEARLA,
@ -145,14 +121,9 @@ typedef enum {
THR_COMP_NEARGA,
THR_COMP_NEWGA,
#if CONFIG_NEWMVREF
THR_COMP_NEAR_FORNEWLA,
THR_COMP_NEAR_FORNEWGA,
#endif // CONFIG_NEWMVREF
THR_COMP_ZEROLA,
THR_COMP_ZEROGA,
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
THR_H_PRED,
THR_V_PRED,

502
vp9/encoder/vp9_rdopt.c
View File

File diff suppressed because it is too large Load Diff

17
vp9/encoder/vp9_speed_features.h
View File

@ -31,13 +31,11 @@ enum {
(1 << H_PRED)
};
#if CONFIG_COMPOUND_MODES
#if CONFIG_NEW_INTER
enum {
INTER_ALL =
(1 << NEARESTMV) | (1 << NEARMV) | (1 << ZEROMV) | (1 << NEWMV) |
#if CONFIG_NEWMVREF
(1 << NEAR_FORNEWMV) |
#endif // CONFIG_NEWMVREF
(1 << NEARESTMV) | (1 << NEARMV) | (1 << ZEROMV) |
(1 << NEWMV) | (1 << NEAR_FORNEWMV) |
(1 << NEAREST_NEARESTMV) | (1 << ZERO_ZEROMV) | (1 << NEAREST_NEARMV) |
(1 << NEAR_NEARESTMV) | (1 << NEW_NEWMV) | (1 << NEAREST_NEWMV) |
(1 << NEAR_NEWMV) | (1 << NEW_NEARMV) | (1 << NEW_NEARESTMV),
@ -74,12 +72,7 @@ enum {
};
#else
enum {
INTER_ALL = (1 << NEARESTMV) | (1 << NEARMV) | (1 << ZEROMV) |
#if CONFIG_NEWMVREF
(1 << NEWMV) | (1 << NEAR_FORNEWMV),
#else
(1 << NEWMV),
#endif // CONFIG_NEWMVREF
INTER_ALL = (1 << NEARESTMV) | (1 << NEARMV) | (1 << ZEROMV) | (1 << NEWMV),
INTER_NEAREST = (1 << NEARESTMV),
INTER_NEAREST_NEW = (1 << NEARESTMV) | (1 << NEWMV),
INTER_NEAREST_ZERO = (1 << NEARESTMV) | (1 << ZEROMV),
@ -87,7 +80,7 @@ enum {
INTER_NEAREST_NEAR_NEW = (1 << NEARESTMV) | (1 << NEARMV) | (1 << NEWMV),
INTER_NEAREST_NEAR_ZERO = (1 << NEARESTMV) | (1 << NEARMV) | (1 << ZEROMV),
};
#endif // CONFIG_COMPOUND_MODES
#endif // CONFIG_NEW_INTER
enum {
DISABLE_ALL_INTER_SPLIT = (1 << THR_COMP_GA) |