shithub: libvpx

Info  •  Files  •  Log  •  Branches

Speed up compound inter prediction mode check

This commit allows the encoder to store outcomes of single reference
frame modes and compares them to decide if the inter prediction
filter, forward transform, and quantization can be skipped.

The compression performance of speed 3 is down
derf  -0.364%
stdhd -0.198%

For test sequences, the speed 3 runtime is reduced
highway CIF 100 kbps, 51976 ms -> 45033 ms, 13% speed-up
stockholm 720p 1000 kbps, 71826 ms -> 67838 ms, 5.5% speed-up
pedestrian 1080p 2000 kbps, 154924 ms -> 150702 ms, 2.6% speed-up

Change-Id: I5aa26f918d2b4b5197a2c0afa2779319f1c88e44

--- a/vp9/encoder/vp9_block.h

+++ b/vp9/encoder/vp9_block.h

@@ -112,7 +112,7 @@

   int quant_fp;

   // skip forward transform and quantization

-  int skip_txfm[MAX_MB_PLANE << 2];

+  uint8_t skip_txfm[MAX_MB_PLANE << 2];

   int64_t bsse[MAX_MB_PLANE << 2];

--- a/vp9/encoder/vp9_context_tree.h

+++ b/vp9/encoder/vp9_context_tree.h

@@ -36,7 +36,7 @@

   // For current partition, only if all Y, U, and V transform blocks'

   // coefficients are quantized to 0, skippable is set to 0.

   int skippable;

-  int skip_txfm[MAX_MB_PLANE << 2];

+  uint8_t skip_txfm[MAX_MB_PLANE << 2];

   int best_mode_index;

   int hybrid_pred_diff;

   int comp_pred_diff;

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

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

@@ -423,7 +423,7 @@

                                     VP9_ALT_FLAG };

   int64_t best_rd = INT64_MAX;

   int64_t this_rd = INT64_MAX;

-  int skip_txfm = 0;

+  uint8_t skip_txfm = 0;

   int rate = INT_MAX;

   int64_t dist = INT64_MAX;

   // var_y and sse_y are saved to be used in skipping checking

--- a/vp9/encoder/vp9_rdopt.c

+++ b/vp9/encoder/vp9_rdopt.c

@@ -2150,6 +2150,8 @@

                                  int_mv (*mode_mv)[MAX_REF_FRAMES],

                                  int mi_row, int mi_col,

                                  int_mv single_newmv[MAX_REF_FRAMES],

+                                 INTERP_FILTER (*single_filter)[MAX_REF_FRAMES],

+                                 int (*single_skippable)[MAX_REF_FRAMES],

                                  int64_t *psse,

                                  const int64_t ref_best_rd) {

   VP9_COMMON *cm = &cpi->common;

@@ -2173,7 +2175,7 @@

   int orig_dst_stride[MAX_MB_PLANE];

   int rs = 0;

   INTERP_FILTER best_filter = SWITCHABLE;

-  int skip_txfm[MAX_MB_PLANE << 2] = {0};

+  uint8_t skip_txfm[MAX_MB_PLANE << 2] = {0};

   int64_t bsse[MAX_MB_PLANE << 2] = {0};

   int bsl = mi_width_log2_lookup[bsize];

@@ -2196,6 +2198,12 @@

     if (frame_mv[refs[0]].as_int == INVALID_MV ||

         frame_mv[refs[1]].as_int == INVALID_MV)

       return INT64_MAX;

+

+    if (cpi->sf.adaptive_mode_search) {

+      if (single_filter[this_mode][refs[0]] ==

+          single_filter[this_mode][refs[1]])

+        best_filter = single_filter[this_mode][refs[0]];

+    }

   }

   if (this_mode == NEWMV) {

@@ -2385,8 +2393,19 @@

     vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);

     model_rd_for_sb(cpi, bsize, x, xd, &tmp_rate, &tmp_dist);

     rd = RDCOST(x->rdmult, x->rddiv, rs + tmp_rate, tmp_dist);

+    vpx_memcpy(skip_txfm, x->skip_txfm, sizeof(skip_txfm));

+    vpx_memcpy(bsse, x->bsse, sizeof(bsse));

   }

+  if (!is_comp_pred)

+    single_filter[this_mode][refs[0]] = mbmi->interp_filter;

+

+  if (cpi->sf.adaptive_mode_search)

+    if (is_comp_pred)

+      if (single_skippable[this_mode][refs[0]] &&

+          single_skippable[this_mode][refs[1]])

+        vpx_memset(skip_txfm, 1, sizeof(skip_txfm));

+

   if (cpi->sf.use_rd_breakout && ref_best_rd < INT64_MAX) {

     // if current pred_error modeled rd is substantially more than the best

     // so far, do not bother doing full rd

@@ -2445,6 +2464,9 @@

     *skippable = skippable_y && skippable_uv;

   }

+  if (!is_comp_pred)

+    single_skippable[this_mode][refs[0]] = *skippable;

+

   restore_dst_buf(xd, orig_dst, orig_dst_stride);

   return this_rd;  // if 0, this will be re-calculated by caller

 }

@@ -2551,10 +2573,12 @@

   PREDICTION_MODE this_mode;

   MV_REFERENCE_FRAME ref_frame, second_ref_frame;

   unsigned char segment_id = mbmi->segment_id;

-  int comp_pred, i;

+  int comp_pred, i, k;

   int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES];

   struct buf_2d yv12_mb[4][MAX_MB_PLANE];

   int_mv single_newmv[MAX_REF_FRAMES] = { { 0 } };

+  INTERP_FILTER single_inter_filter[MB_MODE_COUNT][MAX_REF_FRAMES];

+  int single_skippable[MB_MODE_COUNT][MAX_REF_FRAMES];

   static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG,

                                     VP9_ALT_FLAG };

   int64_t best_rd = best_rd_so_far;

@@ -2603,6 +2627,12 @@

     rate_uv_intra[i] = INT_MAX;

   for (i = 0; i < MAX_REF_FRAMES; ++i)

     x->pred_sse[i] = INT_MAX;

+  for (i = 0; i < MB_MODE_COUNT; ++i) {

+    for (k = 0; k < MAX_REF_FRAMES; ++k) {

+      single_inter_filter[i][k] = SWITCHABLE;

+      single_skippable[i][k] = 0;

+    }

+  }

   *returnrate = INT_MAX;

@@ -2886,7 +2916,8 @@

                                   &rate_uv, &distortion_uv,

                                   &disable_skip, frame_mv,

                                   mi_row, mi_col,

-                                  single_newmv, &total_sse, best_rd);

+                                  single_newmv, single_inter_filter,

+                                  single_skippable, &total_sse, best_rd);

       if (this_rd == INT64_MAX)

         continue;