Merge "Revise precision clamping in GM param refinement" into nextgenv2
diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index 8d7c7f8..65f7440 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -712,6 +712,14 @@
void av1_setup_block_planes(MACROBLOCKD *xd, int ss_x, int ss_y);
+static INLINE int tx_size_to_depth(const TX_SIZE tx_size) {
+ return (int)(tx_size - TX_4X4);
+}
+
+static INLINE TX_SIZE depth_to_tx_size(const int depth) {
+ return (TX_SIZE)(depth + TX_4X4);
+}
+
static INLINE TX_SIZE get_uv_tx_size(const MB_MODE_INFO *mbmi,
const struct macroblockd_plane *pd) {
TX_SIZE uv_txsize;
diff --git a/av1/common/entropy.c b/av1/common/entropy.c
index 870632d..f58f134 100644
--- a/av1/common/entropy.c
+++ b/av1/common/entropy.c
@@ -2913,7 +2913,7 @@
count_sat = COEF_COUNT_SAT;
}
#endif // CONFIG_ENTROPY
- for (tx_size = TX_4X4; tx_size <= TX_32X32; tx_size++)
+ for (tx_size = 0; tx_size < TX_SIZES; tx_size++)
adapt_coef_probs(cm, tx_size, count_sat, update_factor);
#if CONFIG_RANS
av1_coef_pareto_cdfs(cm->fc);
diff --git a/av1/common/filter.h b/av1/common/filter.h
index 15fc806..eb39a7f 100644
--- a/av1/common/filter.h
+++ b/av1/common/filter.h
@@ -38,8 +38,8 @@
#else
#define SWITCHABLE_FILTERS 3 /* Number of switchable filters */
#define LOG_SWITCHABLE_FILTERS \
- 2 /* (1 << LOG_SWITCHABLE_FILTERS) > SWITCHABLE_FILTERS */
-#endif // CONFIG_EXT_INTERP
+ 2 /* (1 << LOG_SWITCHABLE_FILTERS) > SWITCHABLE_FILTERS */
+#endif // CONFIG_EXT_INTERP
#define USE_TEMPORALFILTER_12TAP 1
#if USE_TEMPORALFILTER_12TAP
diff --git a/av1/common/reconinter.h b/av1/common/reconinter.h
index 3eec384..351c7d4 100644
--- a/av1/common/reconinter.h
+++ b/av1/common/reconinter.h
@@ -462,7 +462,6 @@
}
#endif
-#if CONFIG_EXT_INTERP
static INLINE int av1_is_interp_needed(const MACROBLOCKD *const xd) {
MODE_INFO *const mi = xd->mi[0];
MB_MODE_INFO *const mbmi = &mi->mbmi;
@@ -513,7 +512,6 @@
}
return !intpel_mv;
}
-#endif // CONFIG_EXT_INTERP
#if CONFIG_MOTION_VAR
const uint8_t *av1_get_obmc_mask(int length);
diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index 3993e72..4ac6e32 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -350,11 +350,11 @@
int tx_size_cat, aom_reader *r) {
FRAME_COUNTS *counts = xd->counts;
const int ctx = get_tx_size_context(xd);
- int tx_size =
- aom_read_tree(r, av1_tx_size_tree[tx_size_cat],
- cm->fc->tx_size_probs[tx_size_cat][ctx], ACCT_STR);
+ int depth = aom_read_tree(r, av1_tx_size_tree[tx_size_cat],
+ cm->fc->tx_size_probs[tx_size_cat][ctx], ACCT_STR);
+ TX_SIZE tx_size = depth_to_tx_size(depth);
if (counts) ++counts->tx_size[tx_size_cat][ctx][tx_size];
- return (TX_SIZE)tx_size;
+ return tx_size;
}
static TX_SIZE read_tx_size_intra(AV1_COMMON *cm, MACROBLOCKD *xd,
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 260319e..899aa81 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -414,6 +414,7 @@
const int tx_size_cat = is_inter ? inter_tx_size_cat_lookup[bsize]
: intra_tx_size_cat_lookup[bsize];
const TX_SIZE coded_tx_size = txsize_sqr_up_map[tx_size];
+ const int depth = tx_size_to_depth(coded_tx_size);
#if CONFIG_EXT_TX && CONFIG_RECT_TX
assert(IMPLIES(is_rect_tx(tx_size), is_rect_tx_allowed(xd, mbmi)));
@@ -423,7 +424,7 @@
av1_write_token(w, av1_tx_size_tree[tx_size_cat],
cm->fc->tx_size_probs[tx_size_cat][tx_size_ctx],
- &tx_size_encodings[tx_size_cat][coded_tx_size]);
+ &tx_size_encodings[tx_size_cat][depth]);
}
}
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 522d6bb..c94c1d8 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -4442,8 +4442,10 @@
av1_zero_above_context(cm, tile_info->mi_col_start, tile_info->mi_col_end);
// Set up pointers to per thread motion search counters.
- td->mb.m_search_count_ptr = &td->rd_counts.m_search_count;
- td->mb.ex_search_count_ptr = &td->rd_counts.ex_search_count;
+ this_tile->m_search_count = 0; // Count of motion search hits.
+ this_tile->ex_search_count = 0; // Exhaustive mesh search hits.
+ td->mb.m_search_count_ptr = &this_tile->m_search_count;
+ td->mb.ex_search_count_ptr = &this_tile->ex_search_count;
for (mi_row = tile_info->mi_row_start; mi_row < tile_info->mi_row_end;
mi_row += cm->mib_size) {
@@ -4644,8 +4646,6 @@
av1_zero(*td->counts);
av1_zero(rdc->coef_counts);
av1_zero(rdc->comp_pred_diff);
- rdc->m_search_count = 0; // Count of motion search hits.
- rdc->ex_search_count = 0; // Exhaustive mesh search hits.
#if CONFIG_GLOBAL_MOTION
aom_clear_system_state();
@@ -5234,6 +5234,7 @@
const int tx_size_cat = is_inter ? inter_tx_size_cat_lookup[bsize]
: intra_tx_size_cat_lookup[bsize];
const TX_SIZE coded_tx_size = txsize_sqr_up_map[mbmi->tx_size];
+ const int depth = tx_size_to_depth(coded_tx_size);
#if CONFIG_EXT_TX && CONFIG_RECT_TX
assert(IMPLIES(is_rect_tx(mbmi->tx_size), is_rect_tx_allowed(xd, mbmi)));
#endif // CONFIG_EXT_TX && CONFIG_RECT_TX
@@ -5247,7 +5248,7 @@
if (is_inter) {
tx_partition_count_update(cm, x, bsize, mi_row, mi_col, td->counts);
} else {
- ++td->counts->tx_size[tx_size_cat][tx_size_ctx][coded_tx_size];
+ ++td->counts->tx_size[tx_size_cat][tx_size_ctx][depth];
if (mbmi->tx_size != max_txsize_lookup[bsize]) ++x->txb_split_count;
}
#if CONFIG_EXT_TX && CONFIG_RECT_TX
@@ -5255,7 +5256,7 @@
#endif
#endif
#if !CONFIG_VAR_TX
- ++td->counts->tx_size[tx_size_cat][tx_size_ctx][coded_tx_size];
+ ++td->counts->tx_size[tx_size_cat][tx_size_ctx][depth];
#endif
} else {
int i, j;
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index 629eb46..03f6ffd 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -3596,7 +3596,7 @@
recon_err = aom_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
if (cpi->twopass.total_left_stats.coded_error != 0.0)
- fprintf(f, "%10u %dx%d %10d %10d %d %d %10d %10d %10d %10d"
+ fprintf(f, "%10u %dx%d %d %d %10d %10d %10d %10d"
"%10"PRId64" %10"PRId64" %5d %5d %10"PRId64" "
"%10"PRId64" %10"PRId64" %10d "
"%7.2lf %7.2lf %7.2lf %7.2lf %7.2lf"
@@ -3605,8 +3605,6 @@
"%10lf %8u %10"PRId64" %10d %10d %10d\n",
cpi->common.current_video_frame,
cm->width, cm->height,
- cpi->td.rd_counts.m_search_count,
- cpi->td.rd_counts.ex_search_count,
cpi->rc.source_alt_ref_pending,
cpi->rc.source_alt_ref_active,
cpi->rc.this_frame_target,
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index 8738609..00abc71 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -268,13 +268,13 @@
TileInfo tile_info;
int thresh_freq_fact[BLOCK_SIZES][MAX_MODES];
int mode_map[BLOCK_SIZES][MAX_MODES];
+ int m_search_count;
+ int ex_search_count;
} TileDataEnc;
typedef struct RD_COUNTS {
av1_coeff_count coef_counts[TX_SIZES][PLANE_TYPES];
int64_t comp_pred_diff[REFERENCE_MODES];
- int m_search_count;
- int ex_search_count;
} RD_COUNTS;
typedef struct ThreadData {
diff --git a/av1/encoder/ethread.c b/av1/encoder/ethread.c
index 117d0ed..5876d15 100644
--- a/av1/encoder/ethread.c
+++ b/av1/encoder/ethread.c
@@ -27,10 +27,6 @@
for (n = 0; n < ENTROPY_TOKENS; n++)
td->rd_counts.coef_counts[i][j][k][l][m][n] +=
td_t->rd_counts.coef_counts[i][j][k][l][m][n];
-
- // Counts of all motion searches and exhuastive mesh searches.
- td->rd_counts.m_search_count += td_t->rd_counts.m_search_count;
- td->rd_counts.ex_search_count += td_t->rd_counts.ex_search_count;
}
static int enc_worker_hook(EncWorkerData *const thread_data, void *unused) {
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index 4a2bc3f..cfc8cb3 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -720,30 +720,41 @@
#if CONFIG_DUAL_FILTER
int av1_get_switchable_rate(const AV1_COMP *cpi, const MACROBLOCKD *const xd) {
- const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
- int inter_filter_cost = 0;
- int dir;
+ const AV1_COMMON *const cm = &cpi->common;
+ if (cm->interp_filter == SWITCHABLE) {
+ const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
+ int inter_filter_cost = 0;
+ int dir;
- for (dir = 0; dir < 2; ++dir) {
- if (has_subpel_mv_component(xd->mi[0], xd, dir) ||
- (mbmi->ref_frame[1] > INTRA_FRAME &&
- has_subpel_mv_component(xd->mi[0], xd, dir + 2))) {
- const int ctx = av1_get_pred_context_switchable_interp(xd, dir);
- inter_filter_cost +=
- cpi->switchable_interp_costs[ctx][mbmi->interp_filter[dir]];
+ for (dir = 0; dir < 2; ++dir) {
+ if (has_subpel_mv_component(xd->mi[0], xd, dir) ||
+ (mbmi->ref_frame[1] > INTRA_FRAME &&
+ has_subpel_mv_component(xd->mi[0], xd, dir + 2))) {
+ const int ctx = av1_get_pred_context_switchable_interp(xd, dir);
+ inter_filter_cost +=
+ cpi->switchable_interp_costs[ctx][mbmi->interp_filter[dir]];
+ }
}
+ return SWITCHABLE_INTERP_RATE_FACTOR * inter_filter_cost;
+ } else {
+ return 0;
}
- return SWITCHABLE_INTERP_RATE_FACTOR * inter_filter_cost;
}
#else
int av1_get_switchable_rate(const AV1_COMP *cpi, const MACROBLOCKD *const xd) {
- const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
- const int ctx = av1_get_pred_context_switchable_interp(xd);
+ const AV1_COMMON *const cm = &cpi->common;
+ if (cm->interp_filter == SWITCHABLE) {
#if CONFIG_EXT_INTERP
- if (!av1_is_interp_needed(xd)) return 0;
-#endif // CONFIG_EXT_INTERP
- return SWITCHABLE_INTERP_RATE_FACTOR *
- cpi->switchable_interp_costs[ctx][mbmi->interp_filter];
+ if (av1_is_interp_needed(xd))
+#endif
+ {
+ const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
+ const int ctx = av1_get_pred_context_switchable_interp(xd);
+ return SWITCHABLE_INTERP_RATE_FACTOR *
+ cpi->switchable_interp_costs[ctx][mbmi->interp_filter];
+ }
+ }
+ return 0;
}
#endif
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 76d471e..f24c283 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -1318,9 +1318,9 @@
const int tx_size_cat =
is_inter ? inter_tx_size_cat_lookup[bs] : intra_tx_size_cat_lookup[bs];
const TX_SIZE coded_tx_size = txsize_sqr_up_map[tx_size];
+ const int depth = tx_size_to_depth(coded_tx_size);
const int tx_select = cm->tx_mode == TX_MODE_SELECT;
- const int r_tx_size =
- cpi->tx_size_cost[tx_size_cat][tx_size_ctx][coded_tx_size];
+ const int r_tx_size = cpi->tx_size_cost[tx_size_cat][tx_size_ctx][depth];
assert(skip_prob > 0);
#if CONFIG_EXT_TX && CONFIG_RECT_TX
@@ -2746,7 +2746,7 @@
// not the tokenonly rate.
this_rate_tokenonly -=
cpi->tx_size_cost[max_tx_size - TX_8X8][get_tx_size_context(xd)]
- [mic->mbmi.tx_size];
+ [tx_size_to_depth(mic->mbmi.tx_size)];
}
#if CONFIG_PALETTE
if (cpi->common.allow_screen_content_tools && mic->mbmi.mode == DC_PRED)
@@ -6367,10 +6367,6 @@
const int this_mode = mbmi->mode;
int refs[2] = { mbmi->ref_frame[0],
(mbmi->ref_frame[1] < 0 ? 0 : mbmi->ref_frame[1]) };
-#if CONFIG_DUAL_FILTER
- (void)pred_filter_search;
- return SWITCHABLE;
-#else
if (pred_filter_search) {
InterpFilter af = SWITCHABLE, lf = SWITCHABLE;
if (xd->up_available) af = xd->mi[-xd->mi_stride]->mbmi.interp_filter;
@@ -6385,7 +6381,6 @@
#endif // CONFIG_EXT_INTER
best_filter = af;
}
-#endif
if (is_comp_pred) {
if (cpi->sf.adaptive_mode_search) {
#if CONFIG_EXT_INTER
@@ -6448,15 +6443,8 @@
#endif // CONFIG_EXT_INTER
}
}
- if (cm->interp_filter != BILINEAR) {
- if (x->source_variance < cpi->sf.disable_filter_search_var_thresh) {
- best_filter = EIGHTTAP_REGULAR;
- }
-#if CONFIG_EXT_INTERP
- else if (!av1_is_interp_needed(xd) && cm->interp_filter == SWITCHABLE) {
- best_filter = EIGHTTAP_REGULAR;
- }
-#endif
+ if (x->source_variance < cpi->sf.disable_filter_search_var_thresh) {
+ best_filter = EIGHTTAP_REGULAR;
}
return best_filter;
}
@@ -6676,6 +6664,7 @@
int_mv cur_mv[2];
int rate_mv = 0;
#if CONFIG_EXT_INTER
+ int pred_exists = 1;
const int bw = 4 * num_4x4_blocks_wide_lookup[bsize];
int mv_idx = (this_mode == NEWFROMNEARMV) ? 1 : 0;
int_mv single_newmv[TOTAL_REFS_PER_FRAME];
@@ -6706,6 +6695,7 @@
uint8_t best_blk_skip[MAX_MB_PLANE][MAX_MIB_SIZE * MAX_MIB_SIZE * 4];
#endif // CONFIG_VAR_TX
int64_t best_distortion = INT64_MAX;
+ int64_t best_rd = INT64_MAX;
MB_MODE_INFO best_mbmi;
#if CONFIG_EXT_INTER
int rate2_bmc_nocoeff;
@@ -6713,24 +6703,14 @@
MB_MODE_INFO best_bmc_mbmi;
#endif // CONFIG_EXT_INTER
#endif // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
-
- int pred_exists = 0;
- int intpel_mv;
- int64_t rd, tmp_rd, best_rd = INT64_MAX;
- int best_needs_copy = 0;
+ int64_t rd = INT64_MAX;
+ int64_t tmp_rd = INT64_MAX;
uint8_t *orig_dst[MAX_MB_PLANE];
int orig_dst_stride[MAX_MB_PLANE];
+ uint8_t *tmp_dst[MAX_MB_PLANE];
+ int tmp_dst_stride[MAX_MB_PLANE];
int rs = 0;
-#if CONFIG_DUAL_FILTER
- // Index use case:
- // {0, 1} -> (vertical, horizontal) filter types for the first ref frame
- // {2, 3} -> (vertical, horizontal) filter types for the second ref frame
- InterpFilter best_filter[4] = {
- SWITCHABLE, SWITCHABLE, SWITCHABLE, SWITCHABLE,
- };
-#else
- InterpFilter best_filter = SWITCHABLE;
-#endif
+ InterpFilter assign_filter = SWITCHABLE;
int skip_txfm_sb = 0;
int64_t skip_sse_sb = INT64_MAX;
@@ -6966,6 +6946,10 @@
// one for future predictions. In the end, copy from tmp_buf to
// dst if necessary.
for (i = 0; i < MAX_MB_PLANE; i++) {
+ tmp_dst[i] = tmp_buf + i * MAX_SB_SQUARE;
+ tmp_dst_stride[i] = MAX_SB_SIZE;
+ }
+ for (i = 0; i < MAX_MB_PLANE; i++) {
orig_dst[i] = xd->plane[i].dst.buf;
orig_dst_stride[i] = xd->plane[i].dst.stride;
}
@@ -7003,135 +6987,125 @@
)
return INT64_MAX;
- pred_exists = 0;
- // Are all MVs integer pel for Y and UV
- intpel_mv = !mv_has_subpel(&mbmi->mv[0].as_mv);
- if (is_comp_pred) intpel_mv &= !mv_has_subpel(&mbmi->mv[1].as_mv);
-
+ if (cm->interp_filter == SWITCHABLE) {
#if !CONFIG_DUAL_FILTER
- best_filter =
- predict_interp_filter(cpi, x, bsize, mi_row, mi_col, single_filter);
+ assign_filter =
+ predict_interp_filter(cpi, x, bsize, mi_row, mi_col, single_filter);
#endif
+#if CONFIG_EXT_INTERP || CONFIG_DUAL_FILTER
+ if (!av1_is_interp_needed(xd)) assign_filter = EIGHTTAP_REGULAR;
+#endif
+ } else {
+ assign_filter = cm->interp_filter;
+ }
- if (cm->interp_filter != BILINEAR) {
- int newbest;
- int tmp_rate_sum = 0;
- int64_t tmp_dist_sum = 0;
-
+ { // Do interpolation filter search in the parentheses
+ int tmp_rate;
+ int64_t tmp_dist;
#if CONFIG_DUAL_FILTER
- for (i = 0; i < SWITCHABLE_FILTERS * SWITCHABLE_FILTERS; ++i)
+ mbmi->interp_filter[0] =
+ assign_filter == SWITCHABLE ? EIGHTTAP_REGULAR : assign_filter;
+ mbmi->interp_filter[1] =
+ assign_filter == SWITCHABLE ? EIGHTTAP_REGULAR : assign_filter;
+ mbmi->interp_filter[2] =
+ assign_filter == SWITCHABLE ? EIGHTTAP_REGULAR : assign_filter;
+ mbmi->interp_filter[3] =
+ assign_filter == SWITCHABLE ? EIGHTTAP_REGULAR : assign_filter;
#else
- for (i = 0; i < SWITCHABLE_FILTERS; ++i)
+ mbmi->interp_filter =
+ assign_filter == SWITCHABLE ? EIGHTTAP_REGULAR : assign_filter;
#endif
- {
- int j;
- int64_t rs_rd;
- int tmp_skip_sb = 0;
- int64_t tmp_skip_sse = INT64_MAX;
+ rs = av1_get_switchable_rate(cpi, xd);
+ av1_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
+ model_rd_for_sb(cpi, bsize, x, xd, 0, MAX_MB_PLANE - 1, &tmp_rate,
+ &tmp_dist, &skip_txfm_sb, &skip_sse_sb);
+ rd = RDCOST(x->rdmult, x->rddiv, rs + tmp_rate, tmp_dist);
+ if (assign_filter == SWITCHABLE) {
+ // do interp_filter search
+ if (av1_is_interp_needed(xd)) {
+ int best_in_temp = 0;
#if CONFIG_DUAL_FILTER
- mbmi->interp_filter[0] = filter_sets[i][0];
- mbmi->interp_filter[1] = filter_sets[i][1];
- mbmi->interp_filter[2] = filter_sets[i][0];
- mbmi->interp_filter[3] = filter_sets[i][1];
+ InterpFilter best_filter[4];
+ av1_copy(best_filter, mbmi->interp_filter);
#else
- mbmi->interp_filter = i;
+ InterpFilter best_filter = mbmi->interp_filter;
#endif
- rs = av1_get_switchable_rate(cpi, xd);
- rs_rd = RDCOST(x->rdmult, x->rddiv, rs, 0);
+ restore_dst_buf(xd, tmp_dst, tmp_dst_stride);
+#if CONFIG_DUAL_FILTER
+ // EIGHTTAP_REGULAR mode is calculated beforehand
+ for (i = 1; i < SWITCHABLE_FILTERS * SWITCHABLE_FILTERS; ++i)
+#else
+ // EIGHTTAP_REGULAR mode is calculated beforehand
+ for (i = 1; i < SWITCHABLE_FILTERS; ++i)
+#endif
+ {
+ int tmp_skip_sb = 0;
+ int64_t tmp_skip_sse = INT64_MAX;
+ int tmp_rs;
+#if CONFIG_DUAL_FILTER
+ mbmi->interp_filter[0] = filter_sets[i][0];
+ mbmi->interp_filter[1] = filter_sets[i][1];
+ mbmi->interp_filter[2] = filter_sets[i][0];
+ mbmi->interp_filter[3] = filter_sets[i][1];
+#else
+ mbmi->interp_filter = i;
+#endif
+ tmp_rs = av1_get_switchable_rate(cpi, xd);
+ av1_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
+ model_rd_for_sb(cpi, bsize, x, xd, 0, MAX_MB_PLANE - 1, &tmp_rate,
+ &tmp_dist, &tmp_skip_sb, &tmp_skip_sse);
+ tmp_rd = RDCOST(x->rdmult, x->rddiv, tmp_rs + tmp_rate, tmp_dist);
- if (i > 0 && intpel_mv && IsInterpolatingFilter(i)) {
- rd = RDCOST(x->rdmult, x->rddiv, tmp_rate_sum, tmp_dist_sum);
- if (cm->interp_filter == SWITCHABLE) rd += rs_rd;
- } else {
- int rate_sum = 0;
- int64_t dist_sum = 0;
- if ((cm->interp_filter == SWITCHABLE && (!i || best_needs_copy)) ||
-#if CONFIG_EXT_INTER
- is_comp_interintra_pred ||
-#endif // CONFIG_EXT_INTER
- (cm->interp_filter != SWITCHABLE &&
- (
+ if (tmp_rd < rd) {
+ rd = tmp_rd;
+ rs = av1_get_switchable_rate(cpi, xd);
#if CONFIG_DUAL_FILTER
- cm->interp_filter == mbmi->interp_filter[0]
+ av1_copy(best_filter, mbmi->interp_filter);
#else
- cm->interp_filter == mbmi->interp_filter
+ best_filter = mbmi->interp_filter;
#endif
- || (i == 0 && intpel_mv && IsInterpolatingFilter(i))))) {
- restore_dst_buf(xd, orig_dst, orig_dst_stride);
- } else {
- for (j = 0; j < MAX_MB_PLANE; j++) {
- xd->plane[j].dst.buf = tmp_buf + j * MAX_SB_SQUARE;
- xd->plane[j].dst.stride = MAX_SB_SIZE;
+ skip_txfm_sb = tmp_skip_sb;
+ skip_sse_sb = tmp_skip_sse;
+ best_in_temp = !best_in_temp;
+ if (best_in_temp) {
+ restore_dst_buf(xd, orig_dst, orig_dst_stride);
+ } else {
+ restore_dst_buf(xd, tmp_dst, tmp_dst_stride);
+ }
}
}
- av1_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
- model_rd_for_sb(cpi, bsize, x, xd, 0, MAX_MB_PLANE - 1, &rate_sum,
- &dist_sum, &tmp_skip_sb, &tmp_skip_sse);
-
- rd = RDCOST(x->rdmult, x->rddiv, rate_sum, dist_sum);
- if (cm->interp_filter == SWITCHABLE) rd += rs_rd;
-
- if (i == 0 && intpel_mv && IsInterpolatingFilter(i)) {
- tmp_rate_sum = rate_sum;
- tmp_dist_sum = dist_sum;
+ if (best_in_temp) {
+ restore_dst_buf(xd, tmp_dst, tmp_dst_stride);
+ } else {
+ restore_dst_buf(xd, orig_dst, orig_dst_stride);
}
- }
- newbest = i == 0 || rd < best_rd;
-
- if (newbest) {
- best_rd = rd;
#if CONFIG_DUAL_FILTER
- best_filter[0] = mbmi->interp_filter[0];
- best_filter[1] = mbmi->interp_filter[1];
- best_filter[2] = mbmi->interp_filter[2];
- best_filter[3] = mbmi->interp_filter[3];
+ av1_copy(mbmi->interp_filter, best_filter);
#else
- best_filter = mbmi->interp_filter;
+ mbmi->interp_filter = best_filter;
#endif
- if (cm->interp_filter == SWITCHABLE && i &&
- !(intpel_mv && IsInterpolatingFilter(i)))
- best_needs_copy = !best_needs_copy;
- }
-
- if ((cm->interp_filter == SWITCHABLE && newbest) ||
- (cm->interp_filter != SWITCHABLE &&
-#if CONFIG_DUAL_FILTER
- cm->interp_filter == mbmi->interp_filter[0]
-#else
- cm->interp_filter == mbmi->interp_filter
-#endif
- )) {
- pred_exists = 1;
- tmp_rd = best_rd;
-
- skip_txfm_sb = tmp_skip_sb;
- skip_sse_sb = tmp_skip_sse;
} else {
- pred_exists = 0;
+#if !CONFIG_EXT_INTERP && !CONFIG_DUAL_FILTER
+ int tmp_rs;
+ InterpFilter best_filter = mbmi->interp_filter;
+ rs = av1_get_switchable_rate(cpi, xd);
+ for (i = 1; i < SWITCHABLE_FILTERS; ++i) {
+ mbmi->interp_filter = i;
+ tmp_rs = av1_get_switchable_rate(cpi, xd);
+ if (tmp_rs < rs) {
+ rs = tmp_rs;
+ best_filter = i;
+ }
+ }
+ mbmi->interp_filter = best_filter;
+#else
+ assert(0);
+#endif
}
}
- restore_dst_buf(xd, orig_dst, orig_dst_stride);
}
-// Set the appropriate filter
-#if CONFIG_DUAL_FILTER
- mbmi->interp_filter[0] =
- cm->interp_filter != SWITCHABLE ? cm->interp_filter : best_filter[0];
- mbmi->interp_filter[1] =
- cm->interp_filter != SWITCHABLE ? cm->interp_filter : best_filter[1];
- if (mbmi->ref_frame[1] > INTRA_FRAME) {
- mbmi->interp_filter[2] =
- cm->interp_filter != SWITCHABLE ? cm->interp_filter : best_filter[2];
- mbmi->interp_filter[3] =
- cm->interp_filter != SWITCHABLE ? cm->interp_filter : best_filter[3];
- }
-#else
- mbmi->interp_filter =
- cm->interp_filter != SWITCHABLE ? cm->interp_filter : best_filter;
-#endif
- rs = cm->interp_filter == SWITCHABLE ? av1_get_switchable_rate(cpi, xd) : 0;
-
#if CONFIG_EXT_INTER
#if CONFIG_MOTION_VAR
best_bmc_mbmi = *mbmi;
@@ -7432,29 +7406,15 @@
pred_exists = 0;
}
#endif // CONFIG_EXT_INTERP
-#endif // CONFIG_EXT_INTER
-
- if (pred_exists) {
- if (best_needs_copy) {
- // again temporarily set the buffers to local memory to prevent a memcpy
- for (i = 0; i < MAX_MB_PLANE; i++) {
- xd->plane[i].dst.buf = tmp_buf + i * MAX_SB_SQUARE;
- xd->plane[i].dst.stride = MAX_SB_SIZE;
- }
- }
- rd = tmp_rd;
- } else {
+ if (pred_exists == 0) {
int tmp_rate;
int64_t tmp_dist;
-
- // Handles the special case when a filter that is not in the
- // switchable list (ex. bilinear) is indicated at the frame level, or
- // skip condition holds.
av1_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
model_rd_for_sb(cpi, bsize, x, xd, 0, MAX_MB_PLANE - 1, &tmp_rate,
&tmp_dist, &skip_txfm_sb, &skip_sse_sb);
rd = RDCOST(x->rdmult, x->rddiv, rs + tmp_rate, tmp_dist);
}
+#endif // CONFIG_EXT_INTER
#if CONFIG_DUAL_FILTER
if (!is_comp_pred) single_filter[this_mode][refs[0]] = mbmi->interp_filter[0];
@@ -8054,7 +8014,7 @@
// (prediction granularity), so we account for it in the full rate,
// not the tokenonly rate.
rate_y -= cpi->tx_size_cost[max_tx_size - TX_8X8][get_tx_size_context(xd)]
- [mbmi->tx_size];
+ [tx_size_to_depth(mbmi->tx_size)];
}
rate2 += av1_cost_bit(cm->fc->filter_intra_probs[0],
@@ -8811,8 +8771,9 @@
// tokenonly rate, but for intra blocks, tx_size is always coded
// (prediction granularity), so we account for it in the full rate,
// not the tokenonly rate.
- rate_y -= cpi->tx_size_cost[max_tx_size - TX_8X8]
- [get_tx_size_context(xd)][mbmi->tx_size];
+ rate_y -=
+ cpi->tx_size_cost[max_tx_size - TX_8X8][get_tx_size_context(xd)]
+ [tx_size_to_depth(mbmi->tx_size)];
}
#if CONFIG_EXT_INTRA
if (is_directional_mode) {
diff --git a/test/ethread_test.cc b/test/ethread_test.cc
index 6b2f1ea..c72f16d 100644
--- a/test/ethread_test.cc
+++ b/test/ethread_test.cc
@@ -89,6 +89,7 @@
encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
encoder->Control(AOME_SET_ARNR_TYPE, 3);
+ encoder->Control(AV1E_SET_FRAME_PARALLEL_DECODING, 0);
} else {
encoder->Control(AOME_SET_ENABLEAUTOALTREF, 0);
encoder->Control(AV1E_SET_AQ_MODE, 3);
@@ -180,5 +181,5 @@
AV1_INSTANTIATE_TEST_CASE(AVxEncoderThreadTestLarge,
::testing::Values(::libaom_test::kTwoPassGood,
::libaom_test::kOnePassGood),
- ::testing::Range(1, 3));
+ ::testing::Range(0, 3));
} // namespace
