adds force partitioning greater than or less than block size

adds a new speed feature to force partitioning to be greater than
or less than a certain size

Change-Id: I8c048eeeef93700ae822eccf98f8751a45b2e7d0

diff --git a/vp9/encoder/vp9_encodeframe.c b/vp9/encoder/vp9_encodeframe.c
index 14fb061..1624bf9 100644 (file)
--- a/vp9/encoder/vp9_encodeframe.c
+++ b/vp9/encoder/vp9_encodeframe.c
@@ -1347,121 +1347,127 @@ static void rd_pick_partition(VP9_COMP *cpi, TOKENEXTRA **tp, int mi_row,
   save_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
 
   // PARTITION_SPLIT
-  if (bsize >= BLOCK_SIZE_SB8X8) {
-    int r4 = 0, d4 = 0;
-    subsize = get_subsize(bsize, PARTITION_SPLIT);
-    *(get_sb_partitioning(x, bsize)) = subsize;
+  if (!cpi->sf.use_partitions_greater_than
+      || (cpi->sf.use_partitions_greater_than
+          && bsize > cpi->sf.greater_than_block_size)) {
+    if (bsize >= BLOCK_SIZE_SB8X8) {
+      int r4 = 0, d4 = 0;
+      subsize = get_subsize(bsize, PARTITION_SPLIT);
+      *(get_sb_partitioning(x, bsize)) = subsize;
 
-    for (i = 0; i < 4; ++i) {
-      int x_idx = (i & 1) * (ms >> 1);
-      int y_idx = (i >> 1) * (ms >> 1);
-      int r = 0, d = 0;
+      for (i = 0; i < 4; ++i) {
+        int x_idx = (i & 1) * (ms >> 1);
+        int y_idx = (i >> 1) * (ms >> 1);
+        int r = 0, d = 0;
 
-      if ((mi_row + y_idx >= cm->mi_rows) || (mi_col + x_idx >= cm->mi_cols))
-        continue;
+        if ((mi_row + y_idx >= cm->mi_rows) || (mi_col + x_idx >= cm->mi_cols))
+          continue;
 
-      *(get_sb_index(xd, subsize)) = i;
-      rd_pick_partition(cpi, tp, mi_row + y_idx, mi_col + x_idx, subsize, &r,
-                        &d);
+        *(get_sb_index(xd, subsize)) = i;
+        rd_pick_partition(cpi, tp, mi_row + y_idx, mi_col + x_idx, subsize, &r,
+                          &d);
 
-      r4 += r;
-      d4 += d;
+        r4 += r;
+        d4 += d;
+      }
+      set_partition_seg_context(cm, xd, mi_row, mi_col);
+      pl = partition_plane_context(xd, bsize);
+      if (r4 < INT_MAX)
+        r4 += x->partition_cost[pl][PARTITION_SPLIT];
+      assert(r4 >= 0);
+      assert(d4 >= 0);
+      srate = r4;
+      sdist = d4;
+      restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
     }
-    set_partition_seg_context(cm, xd, mi_row, mi_col);
-    pl = partition_plane_context(xd, bsize);
-    if (r4 < INT_MAX)
-      r4 += x->partition_cost[pl][PARTITION_SPLIT];
-    assert(r4 >= 0);
-    assert(d4 >= 0);
-    srate = r4;
-    sdist = d4;
-    restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
   }
-
-  // PARTITION_HORZ
-  if (bsize >= BLOCK_SIZE_SB8X8 && mi_col + (ms >> 1) < cm->mi_cols) {
-    int r2, d2;
-    int r = 0, d = 0;
-    subsize = get_subsize(bsize, PARTITION_HORZ);
-    *(get_sb_index(xd, subsize)) = 0;
-    pick_sb_modes(cpi, mi_row, mi_col, tp, &r2, &d2, subsize,
-                  get_block_context(x, subsize));
-
-    if (mi_row + (ms >> 1) < cm->mi_rows) {
-      update_state(cpi, get_block_context(x, subsize), subsize, 0);
-      encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
-
-      *(get_sb_index(xd, subsize)) = 1;
-      pick_sb_modes(cpi, mi_row + (ms >> 1), mi_col, tp, &r, &d, subsize,
+  if (!cpi->sf.use_partitions_less_than
+      || (cpi->sf.use_partitions_less_than
+          && bsize <= cpi->sf.less_than_block_size)) {
+    // PARTITION_HORZ
+    if (bsize >= BLOCK_SIZE_SB8X8 && mi_col + (ms >> 1) < cm->mi_cols) {
+      int r2, d2;
+      int r = 0, d = 0;
+      subsize = get_subsize(bsize, PARTITION_HORZ);
+      *(get_sb_index(xd, subsize)) = 0;
+      pick_sb_modes(cpi, mi_row, mi_col, tp, &r2, &d2, subsize,
                     get_block_context(x, subsize));
-      r2 += r;
-      d2 += d;
-    }
-    set_partition_seg_context(cm, xd, mi_row, mi_col);
-    pl = partition_plane_context(xd, bsize);
-    if (r2 < INT_MAX)
-      r2 += x->partition_cost[pl][PARTITION_HORZ];
-    if (RDCOST(x->rdmult, x->rddiv, r2, d2)
-        < RDCOST(x->rdmult, x->rddiv, srate, sdist)) {
-      srate = r2;
-      sdist = d2;
-      *(get_sb_partitioning(x, bsize)) = subsize;
-    }
-    restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
-  }
 
-  // PARTITION_VERT
-  if (bsize >= BLOCK_SIZE_SB8X8 && mi_row + (ms >> 1) < cm->mi_rows) {
-    int r2, d2;
-    subsize = get_subsize(bsize, PARTITION_VERT);
-    *(get_sb_index(xd, subsize)) = 0;
-    pick_sb_modes(cpi, mi_row, mi_col, tp, &r2, &d2, subsize,
-                  get_block_context(x, subsize));
-    if (mi_col + (ms >> 1) < cm->mi_cols) {
-      int r = 0, d = 0;
-      update_state(cpi, get_block_context(x, subsize), subsize, 0);
-      encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
+      if (mi_row + (ms >> 1) < cm->mi_rows) {
+        update_state(cpi, get_block_context(x, subsize), subsize, 0);
+        encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
 
-      *(get_sb_index(xd, subsize)) = 1;
-      pick_sb_modes(cpi, mi_row, mi_col + (ms >> 1), tp, &r, &d, subsize,
-                    get_block_context(x, subsize));
-      r2 += r;
-      d2 += d;
-    }
-    set_partition_seg_context(cm, xd, mi_row, mi_col);
-    pl = partition_plane_context(xd, bsize);
-    if (r2 < INT_MAX)
-      r2 += x->partition_cost[pl][PARTITION_VERT];
-    if (RDCOST(x->rdmult, x->rddiv, r2, d2)
-        < RDCOST(x->rdmult, x->rddiv, srate, sdist)) {
-      srate = r2;
-      sdist = d2;
-      *(get_sb_partitioning(x, bsize)) = subsize;
+        *(get_sb_index(xd, subsize)) = 1;
+        pick_sb_modes(cpi, mi_row + (ms >> 1), mi_col, tp, &r, &d, subsize,
+                      get_block_context(x, subsize));
+        r2 += r;
+        d2 += d;
+      }
+      set_partition_seg_context(cm, xd, mi_row, mi_col);
+      pl = partition_plane_context(xd, bsize);
+      if (r2 < INT_MAX)
+        r2 += x->partition_cost[pl][PARTITION_HORZ];
+      if (RDCOST(x->rdmult, x->rddiv, r2, d2)
+          < RDCOST(x->rdmult, x->rddiv, srate, sdist)) {
+        srate = r2;
+        sdist = d2;
+        *(get_sb_partitioning(x, bsize)) = subsize;
+      }
+      restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
     }
-    restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
-  }
 
-  // PARTITION_NONE
-  if ((mi_row + (ms >> 1) < cm->mi_rows) &&
-      (mi_col + (ms >> 1) < cm->mi_cols)) {
-    int r, d;
-    pick_sb_modes(cpi, mi_row, mi_col, tp, &r, &d, bsize,
-                  get_block_context(x, bsize));
-    if (bsize >= BLOCK_SIZE_SB8X8) {
+    // PARTITION_VERT
+    if (bsize >= BLOCK_SIZE_SB8X8 && mi_row + (ms >> 1) < cm->mi_rows) {
+      int r2, d2;
+      subsize = get_subsize(bsize, PARTITION_VERT);
+      *(get_sb_index(xd, subsize)) = 0;
+      pick_sb_modes(cpi, mi_row, mi_col, tp, &r2, &d2, subsize,
+                    get_block_context(x, subsize));
+      if (mi_col + (ms >> 1) < cm->mi_cols) {
+        int r = 0, d = 0;
+        update_state(cpi, get_block_context(x, subsize), subsize, 0);
+        encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
+
+        *(get_sb_index(xd, subsize)) = 1;
+        pick_sb_modes(cpi, mi_row, mi_col + (ms >> 1), tp, &r, &d, subsize,
+                      get_block_context(x, subsize));
+        r2 += r;
+        d2 += d;
+      }
       set_partition_seg_context(cm, xd, mi_row, mi_col);
       pl = partition_plane_context(xd, bsize);
-      r += x->partition_cost[pl][PARTITION_NONE];
+      if (r2 < INT_MAX)
+        r2 += x->partition_cost[pl][PARTITION_VERT];
+      if (RDCOST(x->rdmult, x->rddiv, r2, d2)
+          < RDCOST(x->rdmult, x->rddiv, srate, sdist)) {
+        srate = r2;
+        sdist = d2;
+        *(get_sb_partitioning(x, bsize)) = subsize;
+      }
+      restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
     }
 
-    if (RDCOST(x->rdmult, x->rddiv, r, d)
-        < RDCOST(x->rdmult, x->rddiv, srate, sdist)) {
-      srate = r;
-      sdist = d;
-      if (bsize >= BLOCK_SIZE_SB8X8)
-        *(get_sb_partitioning(x, bsize)) = bsize;
+    // PARTITION_NONE
+    if ((mi_row + (ms >> 1) < cm->mi_rows) &&
+        (mi_col + (ms >> 1) < cm->mi_cols)) {
+      int r, d;
+      pick_sb_modes(cpi, mi_row, mi_col, tp, &r, &d, bsize,
+                    get_block_context(x, bsize));
+      if (bsize >= BLOCK_SIZE_SB8X8) {
+        set_partition_seg_context(cm, xd, mi_row, mi_col);
+        pl = partition_plane_context(xd, bsize);
+        r += x->partition_cost[pl][PARTITION_NONE];
+      }
+
+      if (RDCOST(x->rdmult, x->rddiv, r, d)
+          < RDCOST(x->rdmult, x->rddiv, srate, sdist)) {
+        srate = r;
+        sdist = d;
+        if (bsize >= BLOCK_SIZE_SB8X8)
+          *(get_sb_partitioning(x, bsize)) = bsize;
+      }
     }
   }
-
   *rate = srate;
   *dist = sdist;
 

diff --git a/vp9/encoder/vp9_onyx_if.c b/vp9/encoder/vp9_onyx_if.c
index c27e6cb..61e2b4e 100644 (file)
--- a/vp9/encoder/vp9_onyx_if.c
+++ b/vp9/encoder/vp9_onyx_if.c
@@ -692,6 +692,10 @@ void vp9_set_speed_features(VP9_COMP *cpi) {
   sf->adjust_thresholds_by_speed = 0;
   sf->partition_by_variance = 0;
   sf->use_one_partition_size_always = 0;
+  sf->use_partitions_less_than = 0;
+  sf->less_than_block_size = BLOCK_SIZE_MB16X16;
+  sf->use_partitions_greater_than = 0;
+  sf->greater_than_block_size = BLOCK_SIZE_SB8X8;
 
 #if CONFIG_MULTIPLE_ARF
   // Switch segmentation off.
@@ -735,6 +739,19 @@ void vp9_set_speed_features(VP9_COMP *cpi) {
         sf->use_one_partition_size_always = 1;
         sf->always_this_block_size = BLOCK_SIZE_MB16X16;
       }
+      if (speed == 2) {
+        sf->first_step = 0;
+        sf->comp_inter_joint_search_thresh = BLOCK_SIZE_SB8X8;
+        sf->use_partitions_less_than = 1;
+        sf->less_than_block_size = BLOCK_SIZE_MB16X16;
+      }
+      if (speed == 3) {
+        sf->first_step = 0;
+        sf->comp_inter_joint_search_thresh = BLOCK_SIZE_SB8X8;
+        sf->use_partitions_greater_than = 1;
+        sf->greater_than_block_size = BLOCK_SIZE_SB8X8;
+      }
+
      break;
 
   }; /* switch */

diff --git a/vp9/encoder/vp9_onyx_int.h b/vp9/encoder/vp9_onyx_int.h
index 3474583..0811976 100644 (file)
--- a/vp9/encoder/vp9_onyx_int.h
+++ b/vp9/encoder/vp9_onyx_int.h
@@ -225,6 +225,10 @@ typedef struct {
   int partition_by_variance;
   int use_one_partition_size_always;
   BLOCK_SIZE_TYPE always_this_block_size;
+  int use_partitions_greater_than;
+  BLOCK_SIZE_TYPE greater_than_block_size;
+  int use_partitions_less_than;
+  BLOCK_SIZE_TYPE less_than_block_size;
 } SPEED_FEATURES;
 
 enum BlockSize {