shithub: libvpx

Info  •  Files  •  Log  •  Branches

Merge "vp9: Use model rd for large blocks in filter search."

--- a/vp9/encoder/vp9_pickmode.c

+++ b/vp9/encoder/vp9_pickmode.c

@@ -1436,7 +1436,9 @@

                               int mi_row, int mi_col, PRED_BUFFER *tmp,

                               BLOCK_SIZE bsize, int reuse_inter_pred,

                               PRED_BUFFER **this_mode_pred, unsigned int *var_y,

-                              unsigned int *sse_y, int force_smooth_filter) {

+                              unsigned int *sse_y, int force_smooth_filter,

+                              int *this_early_term, int *flag_preduv_computed,

+                              int use_model_yrd_large) {

   MACROBLOCKD *const xd = &x->e_mbd;

   MODE_INFO *const mi = xd->mi[0];

   struct macroblockd_plane *const pd = &xd->plane[0];

@@ -1452,13 +1454,22 @@

   INTERP_FILTER best_filter = SWITCHABLE, filter;

   PRED_BUFFER *current_pred = *this_mode_pred;

   uint8_t skip_txfm = SKIP_TXFM_NONE;

+  int best_early_term = 0;

+  int best_flag_preduv_computed[2] = { 0 };

   INTERP_FILTER filter_start = force_smooth_filter ? EIGHTTAP_SMOOTH : EIGHTTAP;

   for (filter = filter_start; filter <= EIGHTTAP_SMOOTH; ++filter) {

     int64_t cost;

     mi->interp_filter = filter;

     vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize);

-    model_rd_for_sb_y(cpi, bsize, x, xd, &pf_rate[filter], &pf_dist[filter],

-                      &pf_var[filter], &pf_sse[filter]);

+    // For large partition blocks, extra testing is done.

+    if (use_model_yrd_large)

+      model_rd_for_sb_y_large(cpi, bsize, x, xd, &pf_rate[filter],

+                              &pf_dist[filter], &pf_var[filter],

+                              &pf_sse[filter], mi_row, mi_col, this_early_term,

+                              flag_preduv_computed);

+    else

+      model_rd_for_sb_y(cpi, bsize, x, xd, &pf_rate[filter], &pf_dist[filter],

+                        &pf_var[filter], &pf_sse[filter]);

     curr_rate[filter] = pf_rate[filter];

     pf_rate[filter] += vp9_get_switchable_rate(cpi, xd);

     cost = RDCOST(x->rdmult, x->rddiv, pf_rate[filter], pf_dist[filter]);

@@ -1467,6 +1478,9 @@

       best_filter = filter;

       best_cost = cost;

       skip_txfm = x->skip_txfm[0];

+      best_early_term = *this_early_term;

+      best_flag_preduv_computed[0] = flag_preduv_computed[0];

+      best_flag_preduv_computed[1] = flag_preduv_computed[1];

       if (reuse_inter_pred) {

         if (*this_mode_pred != current_pred) {

@@ -1490,6 +1504,9 @@

   *var_y = pf_var[best_filter];

   *sse_y = pf_sse[best_filter];

   x->skip_txfm[0] = skip_txfm;

+  *this_early_term = best_early_term;

+  flag_preduv_computed[0] = best_flag_preduv_computed[0];

+  flag_preduv_computed[1] = best_flag_preduv_computed[1];

   if (reuse_inter_pred) {

     pd->dst.buf = (*this_mode_pred)->data;

     pd->dst.stride = (*this_mode_pred)->stride;

@@ -2239,7 +2256,8 @@

       rd_computed = 1;

       search_filter_ref(cpi, x, &this_rdc, mi_row, mi_col, tmp, bsize,

                         reuse_inter_pred, &this_mode_pred, &var_y, &sse_y,

-                        force_smooth_filter);

+                        force_smooth_filter, &this_early_term,

+                        flag_preduv_computed, use_model_yrd_large);

     } else {

       mi->interp_filter = (filter_ref == SWITCHABLE) ? EIGHTTAP : filter_ref;