libvpx: Pull from upstream

source/libvpx/vp9/encoder/vp9_pickmode.c

 /*
  *  Copyright (c) 2014 The WebM project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 597 matching lines @@
 
 typedef struct {
   MV_REFERENCE_FRAME ref_frame;
   PREDICTION_MODE pred_mode;
 } REF_MODE;
 
 #define RT_INTER_MODES 8
 static const REF_MODE ref_mode_set[RT_INTER_MODES] = {
     {LAST_FRAME, ZEROMV},
     {LAST_FRAME, NEARESTMV},
+    {GOLDEN_FRAME, ZEROMV},
     {LAST_FRAME, NEARMV},
     {LAST_FRAME, NEWMV},
-    {GOLDEN_FRAME, ZEROMV},
     {GOLDEN_FRAME, NEARESTMV},
     {GOLDEN_FRAME, NEARMV},
     {GOLDEN_FRAME, NEWMV}
 };
 
 // TODO(jingning) placeholder for inter-frame non-RD mode decision.
 // this needs various further optimizations. to be continued..
 void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
                          TileDataEnc *tile_data,
                          int mi_row, int mi_col, RD_COST *rd_cost,
                          BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) {
   VP9_COMMON *const cm = &cpi->common;
   TileInfo *const tile_info = &tile_data->tile_info;
   MACROBLOCKD *const xd = &x->e_mbd;
   MB_MODE_INFO *const mbmi = &xd->mi[0].src_mi->mbmi;
   struct macroblockd_plane *const pd = &xd->plane[0];
   PREDICTION_MODE best_mode = ZEROMV;
   MV_REFERENCE_FRAME ref_frame, best_ref_frame = LAST_FRAME;
+  MV_REFERENCE_FRAME usable_ref_frame;
   TX_SIZE best_tx_size = TX_SIZES;
   INTERP_FILTER best_pred_filter = EIGHTTAP;
   int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES];
   struct buf_2d yv12_mb[4][MAX_MB_PLANE];
   static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG,
                                     VP9_ALT_FLAG };
   RD_COST this_rdc, best_rdc;
   uint8_t skip_txfm = 0, best_mode_skip_txfm = 0;
   // var_y and sse_y are saved to be used in skipping checking
   unsigned int var_y = UINT_MAX;
@@ skipping 62 matching lines @@
     filter_ref = cm->interp_filter;
 
   // initialize mode decisions
   vp9_rd_cost_reset(&best_rdc);
   vp9_rd_cost_reset(rd_cost);
   mbmi->sb_type = bsize;
   mbmi->ref_frame[0] = NONE;
   mbmi->ref_frame[1] = NONE;
   mbmi->tx_size = MIN(max_txsize_lookup[bsize],
                       tx_mode_to_biggest_tx_size[cm->tx_mode]);
-  mbmi->interp_filter = cm->interp_filter == SWITCHABLE ?
-                        EIGHTTAP : cm->interp_filter;
 
 #if CONFIG_VP9_TEMPORAL_DENOISING
   vp9_denoiser_reset_frame_stats(ctx);
 #endif
-
-  for (ref_frame = LAST_FRAME; ref_frame <= GOLDEN_FRAME; ++ref_frame) {
+  if (cpi->rc.frames_since_golden == 0) {
+    ref_frame_skip_mask |= (1 << GOLDEN_FRAME);
+    usable_ref_frame = LAST_FRAME;
+  } else {
+    usable_ref_frame = GOLDEN_FRAME;
+  }
+  for (ref_frame = LAST_FRAME; ref_frame <= usable_ref_frame; ++ref_frame) {
     const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_buffer(cpi, ref_frame);
 
     x->pred_mv_sad[ref_frame] = INT_MAX;
     frame_mv[NEWMV][ref_frame].as_int = INVALID_MV;
     frame_mv[ZEROMV][ref_frame].as_int = 0;
 
     if ((cpi->ref_frame_flags & flag_list[ref_frame]) && (yv12 != NULL)) {
       int_mv *const candidates = mbmi->ref_mvs[ref_frame];
       const struct scale_factors *const sf = &cm->frame_refs[ref_frame - 1].sf;
 
@@ skipping 14 matching lines @@
                             &frame_mv[NEARMV][ref_frame]);
 
       if (!vp9_is_scaled(sf) && bsize >= BLOCK_8X8)
         vp9_mv_pred(cpi, x, yv12_mb[ref_frame][0].buf, yv12->y_stride,
                     ref_frame, bsize);
     } else {
       ref_frame_skip_mask |= (1 << ref_frame);
     }
   }
 
-  if (cpi->rc.frames_since_golden == 0)
-    ref_frame_skip_mask |= (1 << GOLDEN_FRAME);
-
   for (idx = 0; idx < RT_INTER_MODES; ++idx) {
     int rate_mv = 0;
     int mode_rd_thresh;
     int mode_index;
     int i;
     PREDICTION_MODE this_mode = ref_mode_set[idx].pred_mode;
+    if (!(cpi->sf.inter_mode_mask[bsize] & (1 << this_mode)))
+      continue;
 
     ref_frame = ref_mode_set[idx].ref_frame;
-    mode_index = mode_idx[ref_frame][INTER_OFFSET(this_mode)];
+    if (!(cpi->ref_frame_flags & flag_list[ref_frame]))
+      continue;
+    if (const_motion[ref_frame] && this_mode == NEARMV)
+      continue;
 
     i = (ref_frame == LAST_FRAME) ? GOLDEN_FRAME : LAST_FRAME;
-
-    if (!(cpi->ref_frame_flags & flag_list[ref_frame]))
-      continue;
-
     if (cpi->ref_frame_flags & flag_list[i])
       if (x->pred_mv_sad[ref_frame] > (x->pred_mv_sad[i] << 1))
         ref_frame_skip_mask |= (1 << ref_frame);
-
     if (ref_frame_skip_mask & (1 << ref_frame))
       continue;
 
     // Select prediction reference frames.
     for (i = 0; i < MAX_MB_PLANE; i++)
       xd->plane[i].pre[0] = yv12_mb[ref_frame][i];
 
-    clamp_mv2(&frame_mv[NEARESTMV][ref_frame].as_mv, xd);
-    clamp_mv2(&frame_mv[NEARMV][ref_frame].as_mv, xd);
-
     mbmi->ref_frame[0] = ref_frame;
     set_ref_ptrs(cm, xd, ref_frame, NONE);
 
-    if (const_motion[ref_frame] && this_mode == NEARMV)
-      continue;
-
-    if (!(cpi->sf.inter_mode_mask[bsize] & (1 << this_mode)))
-      continue;
-
+    mode_index = mode_idx[ref_frame][INTER_OFFSET(this_mode)];
     mode_rd_thresh = best_mode_skip_txfm ?
             rd_threshes[mode_index] << 1 : rd_threshes[mode_index];
     if (rd_less_than_thresh(best_rdc.rdcost, mode_rd_thresh,
                             rd_thresh_freq_fact[mode_index]))
       continue;
 
     if (this_mode == NEWMV) {
-      if (cpi->sf.partition_search_type != VAR_BASED_PARTITION
-          && best_rdc.rdcost < (int64_t) (1 << num_pels_log2_lookup[bsize]))
-        continue;
       if (ref_frame > LAST_FRAME) {
         int tmp_sad;
         int dis, cost_list[5];
 
         if (bsize < BLOCK_16X16)
           continue;
 
         tmp_sad = vp9_int_pro_motion_estimation(cpi, x, bsize);
         if (tmp_sad > x->pred_mv_sad[LAST_FRAME])
           continue;
@@ skipping 14 matching lines @@
           cpi->sf.mv.subpel_iters_per_step,
           cond_cost_list(cpi, cost_list),
           x->nmvjointcost, x->mvcost, &dis,
           &x->pred_sse[ref_frame], NULL, 0, 0);
       } else if (!combined_motion_search(cpi, x, bsize, mi_row, mi_col,
         &frame_mv[NEWMV][ref_frame], &rate_mv, best_rdc.rdcost)) {
         continue;
       }
     }
 
-    if (this_mode != NEARESTMV && frame_mv[this_mode][ref_frame].as_int ==
-        frame_mv[NEARESTMV][ref_frame].as_int)
+    if (this_mode != NEARESTMV &&
+        frame_mv[this_mode][ref_frame].as_int ==
+            frame_mv[NEARESTMV][ref_frame].as_int)
       continue;
 
     mbmi->mode = this_mode;
     mbmi->mv[0].as_int = frame_mv[this_mode][ref_frame].as_int;
 
     // Search for the best prediction filter type, when the resulting
     // motion vector is at sub-pixel accuracy level for luma component, i.e.,
     // the last three bits are all zeros.
     if (reuse_inter_pred) {
       if (!this_mode_pred) {
@@ skipping 43 matching lines @@
               pd->dst.stride = bw;
             }
           }
         }
       }
 
       if (reuse_inter_pred && this_mode_pred != current_pred)
         free_pred_buffer(current_pred);
 
       mbmi->interp_filter = best_filter;
-      mbmi->tx_size = pf_tx_size[mbmi->interp_filter];
-      this_rdc.rate = pf_rate[mbmi->interp_filter];
-      this_rdc.dist = pf_dist[mbmi->interp_filter];
-      var_y = pf_var[mbmi->interp_filter];
-      sse_y = pf_sse[mbmi->interp_filter];
+      mbmi->tx_size = pf_tx_size[best_filter];
+      this_rdc.rate = pf_rate[best_filter];
+      this_rdc.dist = pf_dist[best_filter];
+      var_y = pf_var[best_filter];
+      sse_y = pf_sse[best_filter];
       x->skip_txfm[0] = skip_txfm;
     } else {
       mbmi->interp_filter = (filter_ref == SWITCHABLE) ? EIGHTTAP : filter_ref;
       vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize);
       model_rd_for_sb_y(cpi, bsize, x, xd, &this_rdc.rate, &this_rdc.dist,
                         &var_y, &sse_y);
       this_rdc.rate +=
           cm->interp_filter == SWITCHABLE ?
               vp9_get_switchable_rate(cpi, xd) : 0;
     }
@@ skipping 437 matching lines @@
         xd->mi[0].bmi[block + 2] = bsi[best_ref_frame][block];
     }
   }
   mbmi->mode = xd->mi[0].bmi[3].as_mode;
   ctx->mic = *(xd->mi[0].src_mi);
   ctx->skip_txfm[0] = 0;
   ctx->skip = 0;
   // Dummy assignment for speed -5. No effect in speed -6.
   rd_cost->rdcost = best_rd;
 }