Refactor motion estimation in MOTION_VAR experiment
To get ready for pulling AV1 to nextgenv2. Refactoring is done to
make the code structures similar, especially for the motion search
part.
Change-Id: I5d7636394408d97de55394d668540f5627827983
diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index 8a6e134..9efd895 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h
@@ -127,6 +127,10 @@
int *nmvsadcost[2];
int *nmvsadcost_hp[2];
int **mvsadcost;
+#if CONFIG_MOTION_VAR
+ int32_t *wsrc_buf;
+ int32_t *mask_buf;
+#endif // CONFIG_MOTION_VAR
PALETTE_BUFFER *palette_buffer;
diff --git a/av1/encoder/mcomp.c b/av1/encoder/mcomp.c
index 1dc6b99..bd90739 100644
--- a/av1/encoder/mcomp.c
+++ b/av1/encoder/mcomp.c
@@ -3031,11 +3031,13 @@
}
int av1_find_best_obmc_sub_pixel_tree_up(
- AV1_COMP *cpi, MACROBLOCK *x, const int32_t *wsrc, const int32_t *mask,
- int mi_row, int mi_col, MV *bestmv, const MV *ref_mv, int allow_hp,
- int error_per_bit, const aom_variance_fn_ptr_t *vfp, int forced_stop,
- int iters_per_step, int *mvjcost, int *mvcost[2], int *distortion,
- unsigned int *sse1, int is_second, int use_upsampled_ref) {
+ AV1_COMP *cpi, MACROBLOCK *x, int mi_row, int mi_col, MV *bestmv,
+ const MV *ref_mv, int allow_hp, int error_per_bit,
+ const aom_variance_fn_ptr_t *vfp, int forced_stop, int iters_per_step,
+ int *mvjcost, int *mvcost[2], int *distortion, unsigned int *sse1,
+ int is_second, int use_upsampled_ref) {
+ const int32_t *wsrc = x->wsrc_buf;
+ const int32_t *mask = x->mask_buf;
const int *const z = wsrc;
const int *const src_address = z;
MACROBLOCKD *xd = &x->e_mbd;
@@ -3356,11 +3358,12 @@
}
int av1_obmc_full_pixel_diamond(const AV1_COMP *cpi, MACROBLOCK *x,
- const int32_t *wsrc, const int32_t *mask,
MV *mvp_full, int step_param, int sadpb,
int further_steps, int do_refine,
const aom_variance_fn_ptr_t *fn_ptr,
const MV *ref_mv, MV *dst_mv, int is_second) {
+ const int32_t *wsrc = x->wsrc_buf;
+ const int32_t *mask = x->mask_buf;
MV temp_mv;
int thissme, n, num00 = 0;
int bestsme =
diff --git a/av1/encoder/mcomp.h b/av1/encoder/mcomp.h
index f1eccc2..8c42825 100644
--- a/av1/encoder/mcomp.h
+++ b/av1/encoder/mcomp.h
@@ -142,17 +142,16 @@
#if CONFIG_MOTION_VAR
int av1_obmc_full_pixel_diamond(const struct AV1_COMP *cpi, MACROBLOCK *x,
- const int32_t *wsrc, const int32_t *mask,
MV *mvp_full, int step_param, int sadpb,
int further_steps, int do_refine,
const aom_variance_fn_ptr_t *fn_ptr,
const MV *ref_mv, MV *dst_mv, int is_second);
int av1_find_best_obmc_sub_pixel_tree_up(
- struct AV1_COMP *cpi, MACROBLOCK *x, const int32_t *wsrc,
- const int32_t *mask, int mi_row, int mi_col, MV *bestmv, const MV *ref_mv,
- int allow_hp, int error_per_bit, const aom_variance_fn_ptr_t *vfp,
- int forced_stop, int iters_per_step, int *mvjcost, int *mvcost[2],
- int *distortion, unsigned int *sse1, int is_second, int use_upsampled_ref);
+ struct AV1_COMP *cpi, MACROBLOCK *x, int mi_row, int mi_col, MV *bestmv,
+ const MV *ref_mv, int allow_hp, int error_per_bit,
+ const aom_variance_fn_ptr_t *vfp, int forced_stop, int iters_per_step,
+ int *mvjcost, int *mvcost[2], int *distortion, unsigned int *sse1,
+ int is_second, int use_upsampled_ref);
#endif // CONFIG_MOTION_VAR
#ifdef __cplusplus
} // extern "C"
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 8707061..7acf23f 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -5895,16 +5895,36 @@
av1_set_mv_search_range(x, &ref_mv);
- mvp_full = pred_mv[x->mv_best_ref_index[ref]];
+#if CONFIG_MOTION_VAR
+ if (mbmi->motion_mode != SIMPLE_TRANSLATION)
+ mvp_full = mbmi->mv[0].as_mv;
+ else
+#endif // CONFIG_MOTION_VAR
+ mvp_full = pred_mv[x->mv_best_ref_index[ref]];
mvp_full.col >>= 3;
mvp_full.row >>= 3;
x->best_mv.as_int = x->second_best_mv.as_int = INVALID_MV;
- bestsme = av1_full_pixel_search(cpi, x, bsize, &mvp_full, step_param, sadpb,
- cond_cost_list(cpi, cost_list), &ref_mv,
- INT_MAX, 1);
+#if CONFIG_MOTION_VAR
+ switch (mbmi->motion_mode) {
+ case SIMPLE_TRANSLATION:
+#endif // CONFIG_MOTION_VAR
+ bestsme = av1_full_pixel_search(cpi, x, bsize, &mvp_full, step_param,
+ sadpb, cond_cost_list(cpi, cost_list),
+ &ref_mv, INT_MAX, 1);
+#if CONFIG_MOTION_VAR
+ break;
+ case OBMC_CAUSAL:
+ bestsme = av1_obmc_full_pixel_diamond(
+ cpi, x, &mvp_full, step_param, sadpb,
+ MAX_MVSEARCH_STEPS - 1 - step_param, 1, &cpi->fn_ptr[bsize], &ref_mv,
+ &(x->best_mv.as_mv), 0);
+ break;
+ default: assert("Invalid motion mode!\n");
+ }
+#endif // CONFIG_MOTION_VAR
x->mv_col_min = tmp_col_min;
x->mv_col_max = tmp_col_max;
@@ -5913,68 +5933,92 @@
if (bestsme < INT_MAX) {
int dis; /* TODO: use dis in distortion calculation later. */
- if (cpi->sf.use_upsampled_references) {
- int best_mv_var;
- const int try_second = x->second_best_mv.as_int != INVALID_MV &&
- x->second_best_mv.as_int != x->best_mv.as_int;
- const int pw = 4 * num_4x4_blocks_wide_lookup[bsize];
- const int ph = 4 * num_4x4_blocks_high_lookup[bsize];
- // Use up-sampled reference frames.
- struct macroblockd_plane *const pd = &xd->plane[0];
- struct buf_2d backup_pred = pd->pre[ref_idx];
- const YV12_BUFFER_CONFIG *upsampled_ref = get_upsampled_ref(cpi, ref);
+#if CONFIG_MOTION_VAR
+ switch (mbmi->motion_mode) {
+ case SIMPLE_TRANSLATION:
+#endif // CONFIG_MOTION_VAR
+ if (cpi->sf.use_upsampled_references) {
+ int best_mv_var;
+ const int try_second = x->second_best_mv.as_int != INVALID_MV &&
+ x->second_best_mv.as_int != x->best_mv.as_int;
+ const int pw = 4 * num_4x4_blocks_wide_lookup[bsize];
+ const int ph = 4 * num_4x4_blocks_high_lookup[bsize];
+ // Use up-sampled reference frames.
+ struct macroblockd_plane *const pd = &xd->plane[0];
+ struct buf_2d backup_pred = pd->pre[ref_idx];
+ const YV12_BUFFER_CONFIG *upsampled_ref = get_upsampled_ref(cpi, ref);
- // Set pred for Y plane
- setup_pred_plane(&pd->pre[ref_idx], upsampled_ref->y_buffer,
- upsampled_ref->y_crop_width,
- upsampled_ref->y_crop_height, upsampled_ref->y_stride,
- (mi_row << 3), (mi_col << 3), NULL, pd->subsampling_x,
- pd->subsampling_y);
+ // Set pred for Y plane
+ setup_pred_plane(
+ &pd->pre[ref_idx], upsampled_ref->y_buffer,
+ upsampled_ref->y_crop_width, upsampled_ref->y_crop_height,
+ upsampled_ref->y_stride, (mi_row << 3), (mi_col << 3), NULL,
+ pd->subsampling_x, pd->subsampling_y);
- best_mv_var = cpi->find_fractional_mv_step(
- x, &ref_mv, cm->allow_high_precision_mv, x->errorperbit,
- &cpi->fn_ptr[bsize], cpi->sf.mv.subpel_force_stop,
- cpi->sf.mv.subpel_iters_per_step, cond_cost_list(cpi, cost_list),
- x->nmvjointcost, x->mvcost, &dis, &x->pred_sse[ref], NULL, pw, ph, 1);
-
- if (try_second) {
- const int minc = AOMMAX(x->mv_col_min * 8, ref_mv.col - MV_MAX);
- const int maxc = AOMMIN(x->mv_col_max * 8, ref_mv.col + MV_MAX);
- const int minr = AOMMAX(x->mv_row_min * 8, ref_mv.row - MV_MAX);
- const int maxr = AOMMIN(x->mv_row_max * 8, ref_mv.row + MV_MAX);
- int this_var;
- MV best_mv = x->best_mv.as_mv;
-
- x->best_mv = x->second_best_mv;
- if (x->best_mv.as_mv.row * 8 <= maxr &&
- x->best_mv.as_mv.row * 8 >= minr &&
- x->best_mv.as_mv.col * 8 <= maxc &&
- x->best_mv.as_mv.col * 8 >= minc) {
- this_var = cpi->find_fractional_mv_step(
+ best_mv_var = cpi->find_fractional_mv_step(
x, &ref_mv, cm->allow_high_precision_mv, x->errorperbit,
&cpi->fn_ptr[bsize], cpi->sf.mv.subpel_force_stop,
cpi->sf.mv.subpel_iters_per_step, cond_cost_list(cpi, cost_list),
x->nmvjointcost, x->mvcost, &dis, &x->pred_sse[ref], NULL, pw, ph,
1);
- if (this_var < best_mv_var) best_mv = x->best_mv.as_mv;
- x->best_mv.as_mv = best_mv;
- }
- }
- // Restore the reference frames.
- pd->pre[ref_idx] = backup_pred;
- } else {
- cpi->find_fractional_mv_step(
- x, &ref_mv, cm->allow_high_precision_mv, x->errorperbit,
- &cpi->fn_ptr[bsize], cpi->sf.mv.subpel_force_stop,
- cpi->sf.mv.subpel_iters_per_step, cond_cost_list(cpi, cost_list),
- x->nmvjointcost, x->mvcost, &dis, &x->pred_sse[ref], NULL, 0, 0, 0);
+ if (try_second) {
+ const int minc = AOMMAX(x->mv_col_min * 8, ref_mv.col - MV_MAX);
+ const int maxc = AOMMIN(x->mv_col_max * 8, ref_mv.col + MV_MAX);
+ const int minr = AOMMAX(x->mv_row_min * 8, ref_mv.row - MV_MAX);
+ const int maxr = AOMMIN(x->mv_row_max * 8, ref_mv.row + MV_MAX);
+ int this_var;
+ MV best_mv = x->best_mv.as_mv;
+
+ x->best_mv = x->second_best_mv;
+ if (x->best_mv.as_mv.row * 8 <= maxr &&
+ x->best_mv.as_mv.row * 8 >= minr &&
+ x->best_mv.as_mv.col * 8 <= maxc &&
+ x->best_mv.as_mv.col * 8 >= minc) {
+ this_var = cpi->find_fractional_mv_step(
+ x, &ref_mv, cm->allow_high_precision_mv, x->errorperbit,
+ &cpi->fn_ptr[bsize], cpi->sf.mv.subpel_force_stop,
+ cpi->sf.mv.subpel_iters_per_step,
+ cond_cost_list(cpi, cost_list), x->nmvjointcost, x->mvcost,
+ &dis, &x->pred_sse[ref], NULL, pw, ph, 1);
+ if (this_var < best_mv_var) best_mv = x->best_mv.as_mv;
+ x->best_mv.as_mv = best_mv;
+ }
+ }
+
+ // Restore the reference frames.
+ pd->pre[ref_idx] = backup_pred;
+ } else {
+ cpi->find_fractional_mv_step(
+ x, &ref_mv, cm->allow_high_precision_mv, x->errorperbit,
+ &cpi->fn_ptr[bsize], cpi->sf.mv.subpel_force_stop,
+ cpi->sf.mv.subpel_iters_per_step, cond_cost_list(cpi, cost_list),
+ x->nmvjointcost, x->mvcost, &dis, &x->pred_sse[ref], NULL, 0, 0,
+ 0);
+ }
+#if CONFIG_MOTION_VAR
+ break;
+ case OBMC_CAUSAL:
+ av1_find_best_obmc_sub_pixel_tree_up(
+ cpi, x, mi_row, mi_col, &x->best_mv.as_mv, &ref_mv,
+ cm->allow_high_precision_mv, x->errorperbit, &cpi->fn_ptr[bsize],
+ cpi->sf.mv.subpel_force_stop, cpi->sf.mv.subpel_iters_per_step,
+ x->nmvjointcost, x->mvcost, &dis, &x->pred_sse[ref], 0,
+ cpi->sf.use_upsampled_references);
+ break;
+ default: assert("Invalid motion mode!\n");
}
+#endif // CONFIG_MOTION_VAR
}
*rate_mv = av1_mv_bit_cost(&x->best_mv.as_mv, &ref_mv, x->nmvjointcost,
x->mvcost, MV_COST_WEIGHT);
- if (cpi->sf.adaptive_motion_search) x->pred_mv[ref] = x->best_mv.as_mv;
+#if CONFIG_MOTION_VAR
+ if (cpi->sf.adaptive_motion_search && mbmi->motion_mode == SIMPLE_TRANSLATION)
+#else
+ if (cpi->sf.adaptive_motion_search)
+#endif // CONFIG_MOTION_VAR
+ x->pred_mv[ref] = x->best_mv.as_mv;
if (scaled_ref_frame) {
int i;
@@ -5993,138 +6037,6 @@
}
}
-#if CONFIG_MOTION_VAR
-static void single_motion_search_obmc(AV1_COMP *cpi, MACROBLOCK *x,
- BLOCK_SIZE bsize, int mi_row, int mi_col,
- const int32_t *wsrc, const int32_t *mask,
-#if CONFIG_EXT_INTER
- int ref_idx, int mv_idx,
-#endif // CONFIG_EXT_INTER
- int_mv *tmp_mv, int_mv pred_mv,
- int *rate_mv) {
- MACROBLOCKD *xd = &x->e_mbd;
- const AV1_COMMON *cm = &cpi->common;
- MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
- struct buf_2d backup_yv12[MAX_MB_PLANE] = { { 0, 0, 0, 0, 0 } };
- int bestsme = INT_MAX;
- int step_param;
- int sadpb = x->sadperbit16;
- MV mvp_full;
-#if CONFIG_EXT_INTER
- int ref = mbmi->ref_frame[ref_idx];
- MV ref_mv = x->mbmi_ext->ref_mvs[ref][mv_idx].as_mv;
-#else
- int ref = mbmi->ref_frame[0];
- MV ref_mv = x->mbmi_ext->ref_mvs[ref][0].as_mv;
- int ref_idx = 0;
-#endif // CONFIG_EXT_INTER
-
- int tmp_col_min = x->mv_col_min;
- int tmp_col_max = x->mv_col_max;
- int tmp_row_min = x->mv_row_min;
- int tmp_row_max = x->mv_row_max;
-
- const YV12_BUFFER_CONFIG *scaled_ref_frame =
- av1_get_scaled_ref_frame(cpi, ref);
-
-#if CONFIG_REF_MV
- av1_set_mvcost(x, ref, ref_idx, mbmi->ref_mv_idx);
-#endif
-
- if (scaled_ref_frame) {
- int i;
- // Swap out the reference frame for a version that's been scaled to
- // match the resolution of the current frame, allowing the existing
- // motion search code to be used without additional modifications.
- for (i = 0; i < MAX_MB_PLANE; i++)
- backup_yv12[i] = xd->plane[i].pre[ref_idx];
-
- av1_setup_pre_planes(xd, ref_idx, scaled_ref_frame, mi_row, mi_col, NULL);
- }
-
- // Work out the size of the first step in the mv step search.
- // 0 here is maximum length first step. 1 is AOMMAX >> 1 etc.
- if (cpi->sf.mv.auto_mv_step_size && cm->show_frame) {
- // Take wtd average of the step_params based on the last frame's
- // max mv magnitude and that based on the best ref mvs of the current
- // block for the given reference.
- step_param =
- (av1_init_search_range(x->max_mv_context[ref]) + cpi->mv_step_param) /
- 2;
- } else {
- step_param = cpi->mv_step_param;
- }
-
- if (cpi->sf.adaptive_motion_search && bsize < cm->sb_size) {
- int boffset =
- 2 * (b_width_log2_lookup[cm->sb_size] -
- AOMMIN(b_height_log2_lookup[bsize], b_width_log2_lookup[bsize]));
- step_param = AOMMAX(step_param, boffset);
- }
-
- if (cpi->sf.adaptive_motion_search) {
- int bwl = b_width_log2_lookup[bsize];
- int bhl = b_height_log2_lookup[bsize];
- int tlevel = x->pred_mv_sad[ref] >> (bwl + bhl + 4);
-
- if (tlevel < 5) step_param += 2;
-
- // prev_mv_sad is not setup for dynamically scaled frames.
- if (cpi->oxcf.resize_mode != RESIZE_DYNAMIC) {
- int i;
- for (i = LAST_FRAME; i <= ALTREF_FRAME && cm->show_frame; ++i) {
- if ((x->pred_mv_sad[ref] >> 3) > x->pred_mv_sad[i]) {
- x->pred_mv[ref].row = 0;
- x->pred_mv[ref].col = 0;
- tmp_mv->as_int = INVALID_MV;
-
- if (scaled_ref_frame) {
- int i;
- for (i = 0; i < MAX_MB_PLANE; ++i)
- xd->plane[i].pre[ref_idx] = backup_yv12[i];
- }
- return;
- }
- }
- }
- }
-
- av1_set_mv_search_range(x, &ref_mv);
-
- mvp_full = pred_mv.as_mv;
- mvp_full.col >>= 3;
- mvp_full.row >>= 3;
-
- bestsme = av1_obmc_full_pixel_diamond(
- cpi, x, wsrc, mask, &mvp_full, step_param, sadpb,
- MAX_MVSEARCH_STEPS - 1 - step_param, 1, &cpi->fn_ptr[bsize], &ref_mv,
- &tmp_mv->as_mv, ref_idx);
-
- x->mv_col_min = tmp_col_min;
- x->mv_col_max = tmp_col_max;
- x->mv_row_min = tmp_row_min;
- x->mv_row_max = tmp_row_max;
-
- if (bestsme < INT_MAX) {
- int dis;
- av1_find_best_obmc_sub_pixel_tree_up(
- cpi, x, wsrc, mask, mi_row, mi_col, &tmp_mv->as_mv, &ref_mv,
- cm->allow_high_precision_mv, x->errorperbit, &cpi->fn_ptr[bsize],
- cpi->sf.mv.subpel_force_stop, cpi->sf.mv.subpel_iters_per_step,
- x->nmvjointcost, x->mvcost, &dis, &x->pred_sse[ref], ref_idx,
- cpi->sf.use_upsampled_references);
- }
- *rate_mv = av1_mv_bit_cost(&tmp_mv->as_mv, &ref_mv, x->nmvjointcost,
- x->mvcost, MV_COST_WEIGHT);
-
- if (scaled_ref_frame) {
- int i;
- for (i = 0; i < MAX_MB_PLANE; i++)
- xd->plane[i].pre[ref_idx] = backup_yv12[i];
- }
-}
-#endif // CONFIG_MOTION_VAR
-
#if CONFIG_EXT_INTER
static void do_masked_motion_search(AV1_COMP *cpi, MACROBLOCK *x,
const uint8_t *mask, int mask_stride,
@@ -6662,8 +6574,8 @@
int *disable_skip, int_mv (*mode_mv)[TOTAL_REFS_PER_FRAME], int mi_row,
int mi_col,
#if CONFIG_MOTION_VAR
- uint8_t *dst_buf1[3], int dst_stride1[3], uint8_t *dst_buf2[3],
- int dst_stride2[3], const int32_t *const wsrc, const int32_t *const mask2d,
+ uint8_t *above_pred_buf[3], int above_pred_stride[3],
+ uint8_t *left_pred_buf[3], int left_pred_stride[3],
#endif // CONFIG_MOTION_VAR
#if CONFIG_EXT_INTER
int_mv single_newmvs[2][TOTAL_REFS_PER_FRAME],
@@ -6785,6 +6697,7 @@
return INT64_MAX;
}
+ mbmi->motion_mode = SIMPLE_TRANSLATION;
if (have_newmv_in_inter_mode(this_mode)) {
if (is_comp_pred) {
#if CONFIG_EXT_INTER
@@ -7556,18 +7469,16 @@
mbmi->motion_mode = OBMC_CAUSAL;
#endif // CONFIG_EXT_INTER
if (!is_comp_pred && have_newmv_in_inter_mode(this_mode)) {
- int_mv tmp_mv;
- int_mv pred_mv;
int tmp_rate_mv = 0;
- pred_mv.as_int = mbmi->mv[0].as_int;
- single_motion_search_obmc(cpi, x, bsize, mi_row, mi_col, wsrc, mask2d,
+ single_motion_search(cpi, x, bsize, mi_row, mi_col,
#if CONFIG_EXT_INTER
- 0, mv_idx,
+ 0, mv_idx,
#endif // CONFIG_EXT_INTER
- &tmp_mv, pred_mv, &tmp_rate_mv);
- mbmi->mv[0].as_int = tmp_mv.as_int;
- if (discount_newmv_test(cpi, this_mode, tmp_mv, mode_mv, refs[0])) {
+ &tmp_rate_mv);
+ mbmi->mv[0].as_int = x->best_mv.as_int;
+ if (discount_newmv_test(cpi, this_mode, mbmi->mv[0], mode_mv,
+ refs[0])) {
tmp_rate_mv = AOMMAX((tmp_rate_mv / NEW_MV_DISCOUNT_FACTOR), 1);
}
#if CONFIG_EXT_INTER
@@ -7595,8 +7506,9 @@
av1_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
#endif // CONFIG_EXT_INTER
}
- av1_build_obmc_inter_prediction(cm, xd, mi_row, mi_col, dst_buf1,
- dst_stride1, dst_buf2, dst_stride2);
+ av1_build_obmc_inter_prediction(cm, xd, mi_row, mi_col, above_pred_buf,
+ above_pred_stride, left_pred_buf,
+ left_pred_stride);
model_rd_for_sb(cpi, bsize, x, xd, 0, MAX_MB_PLANE - 1, &tmp_rate,
&tmp_dist, &skip_txfm_sb, &skip_sse_sb);
}
@@ -8185,8 +8097,7 @@
const MACROBLOCKD *xd, int mi_row,
int mi_col, const uint8_t *above,
int above_stride, const uint8_t *left,
- int left_stride, int32_t *mask_buf,
- int32_t *wsrc_buf);
+ int left_stride);
#endif // CONFIG_MOTION_VAR
void av1_rd_pick_inter_mode_sb(AV1_COMP *cpi, TileDataEnc *tile_data,
@@ -8405,9 +8316,10 @@
av1_build_prediction_by_left_preds(cm, xd, mi_row, mi_col, dst_buf2,
dst_width2, dst_height2, dst_stride2);
av1_setup_dst_planes(xd->plane, get_frame_new_buffer(cm), mi_row, mi_col);
+ x->mask_buf = mask2d_buf;
+ x->wsrc_buf = weighted_src_buf;
calc_target_weighted_pred(cm, x, xd, mi_row, mi_col, dst_buf1[0],
- dst_stride1[0], dst_buf2[0], dst_stride2[0],
- mask2d_buf, weighted_src_buf);
+ dst_stride1[0], dst_buf2[0], dst_stride2[0]);
#endif // CONFIG_MOTION_VAR
for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
@@ -8929,8 +8841,7 @@
cpi, x, bsize, &rate2, &distortion2, &skippable, &rate_y, &rate_uv,
&disable_skip, frame_mv, mi_row, mi_col,
#if CONFIG_MOTION_VAR
- dst_buf1, dst_stride1, dst_buf2, dst_stride2, weighted_src_buf,
- mask2d_buf,
+ dst_buf1, dst_stride1, dst_buf2, dst_stride2,
#endif // CONFIG_MOTION_VAR
#if CONFIG_EXT_INTER
single_newmvs, single_newmvs_rate, &compmode_interintra_cost,
@@ -9037,8 +8948,7 @@
cpi, x, bsize, &tmp_rate, &tmp_dist, &tmp_skip, &tmp_rate_y,
&tmp_rate_uv, &dummy_disable_skip, frame_mv, mi_row, mi_col,
#if CONFIG_MOTION_VAR
- dst_buf1, dst_stride1, dst_buf2, dst_stride2, weighted_src_buf,
- mask2d_buf,
+ dst_buf1, dst_stride1, dst_buf2, dst_stride2,
#endif // CONFIG_MOTION_VAR
#if CONFIG_EXT_INTER
dummy_single_newmvs, dummy_single_newmvs_rate,
@@ -10768,12 +10678,13 @@
const MACROBLOCKD *xd, int mi_row,
int mi_col, const uint8_t *above,
int above_stride, const uint8_t *left,
- int left_stride, int32_t *mask_buf,
- int32_t *wsrc_buf) {
+ int left_stride) {
const BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type;
int row, col, i;
const int bw = 8 * xd->n8_w;
const int bh = 8 * xd->n8_h;
+ int32_t *mask_buf = x->mask_buf;
+ int32_t *wsrc_buf = x->wsrc_buf;
const int wsrc_stride = bw;
const int mask_stride = bw;
const int src_scale = AOM_BLEND_A64_MAX_ALPHA * AOM_BLEND_A64_MAX_ALPHA;
