libvpx: Pull from upstream

source/libvpx/vp9/encoder/vp9_aq_complexity.c

Index: source/libvpx/vp9/encoder/vp9_aq_complexity.c
===================================================================
--- source/libvpx/vp9/encoder/vp9_aq_complexity.c	(revision 281795)
+++ source/libvpx/vp9/encoder/vp9_aq_complexity.c	(working copy)
@@ -15,9 +15,20 @@
 
 #include "vp9/encoder/vp9_segmentation.h"
 
-static const double in_frame_q_adj_ratio[MAX_SEGMENTS] =
-  {1.0, 2.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
+#define AQ_C_SEGMENTS  3
+#define AQ_C_STRENGTHS  3
+static const int aq_c_active_segments[AQ_C_STRENGTHS] = {1, 2, 3};
+static const double aq_c_q_adj_factor[AQ_C_STRENGTHS][AQ_C_SEGMENTS] =
+  {{1.0, 1.0, 1.0}, {1.0, 2.0, 1.0}, {1.0, 1.5, 2.5}};
+static const double aq_c_transitions[AQ_C_STRENGTHS][AQ_C_SEGMENTS] =
+  {{1.0, 1.0, 1.0}, {1.0, 0.25, 0.0}, {1.0, 0.5, 0.25}};
 
+static int get_aq_c_strength(int q_index) {
+  // Approximate base quatizer (truncated to int)
+  int base_quant = vp9_ac_quant(q_index, 0) / 4;
+  return (base_quant > 20) + (base_quant > 45);
+}
+
 void vp9_setup_in_frame_q_adj(VP9_COMP *cpi) {
   VP9_COMMON *const cm = &cpi->common;
   struct segmentation *const seg = &cm->seg;
@@ -29,6 +40,8 @@
       cpi->refresh_alt_ref_frame ||
       (cpi->refresh_golden_frame && !cpi->rc.is_src_frame_alt_ref)) {
     int segment;
+    const int aq_strength = get_aq_c_strength(cm->base_qindex);
+    const int active_segments = aq_c_active_segments[aq_strength];
 
     // Clear down the segment map.
     vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
@@ -36,9 +49,17 @@
     // Clear down the complexity map used for rd.
     vpx_memset(cpi->complexity_map, 0, cm->mi_rows * cm->mi_cols);
 
-    vp9_enable_segmentation(seg);
     vp9_clearall_segfeatures(seg);
 
+    // Segmentation only makes sense if the target bits per SB is above a
+    // threshold. Below this the overheads will usually outweigh any benefit.
+    if (cpi->rc.sb64_target_rate < 256) {
+      vp9_disable_segmentation(seg);
+      return;
+    }
+
+    vp9_enable_segmentation(seg);
+
     // Select delta coding method.
     seg->abs_delta = SEGMENT_DELTADATA;
 
@@ -46,14 +67,14 @@
     vp9_disable_segfeature(seg, 0, SEG_LVL_ALT_Q);
 
     // Use some of the segments for in frame Q adjustment.
-    for (segment = 1; segment < 2; segment++) {
+    for (segment = 1; segment < active_segments; ++segment) {
       int qindex_delta =
           vp9_compute_qdelta_by_rate(&cpi->rc, cm->frame_type, cm->base_qindex,
-                                     in_frame_q_adj_ratio[segment]);
+                                     aq_c_q_adj_factor[aq_strength][segment]);
 
-      // For AQ mode 2, we dont allow Q0 in a segment if the base Q is not 0.
-      // Q0 (lossless) implies 4x4 only and in AQ mode 2 a segment Q delta
-      // is sometimes applied without going back around the rd loop.
+      // For AQ complexity mode, we dont allow Q0 in a segment if the base
+      // Q is not 0. Q0 (lossless) implies 4x4 only and in AQ mode 2 a segment
+      // Q delta is sometimes applied without going back around the rd loop.
       // This could lead to an illegal combination of partition size and q.
       if ((cm->base_qindex != 0) && ((cm->base_qindex + qindex_delta) == 0)) {
         qindex_delta = -cm->base_qindex + 1;
@@ -66,10 +87,15 @@
   }
 }
 
-// Select a segment for the current SB64
+// Select a segment for the current SB64 block.
+// The choice of segment for a block depends on the ratio of the projected
+// bits for the block vs a target average.
+// An "aq_strength" value determines how many segments are supported,
+// the set of transition points to use and the extent of the quantizer
+// adjustment for each segment (configured in vp9_setup_in_frame_q_adj()).
 void vp9_select_in_frame_q_segment(VP9_COMP *cpi,
-                                      int mi_row, int mi_col,
-                                      int output_enabled, int projected_rate) {
+                                   int mi_row, int mi_col,
+                                   int output_enabled, int projected_rate) {
   VP9_COMMON *const cm = &cpi->common;
 
   const int mi_offset = mi_row * cm->mi_cols + mi_col;
@@ -89,11 +115,22 @@
     // It is converted to bits * 256 units.
     const int target_rate = (cpi->rc.sb64_target_rate * xmis * ymis * 256) /
                             (bw * bh);
+    const int aq_strength = get_aq_c_strength(cm->base_qindex);
+    const int active_segments = aq_c_active_segments[aq_strength];
 
-    if (projected_rate < (target_rate / 4)) {
-      segment = 1;
-    } else {
-      segment = 0;
+    // The number of segments considered and the transition points used to
+    // select them is determined by the "aq_strength" value.
+    // Currently this loop only supports segments that reduce Q (i.e. where
+    // there is undershoot.
+    // The loop counts down towards segment 0 which is the default segment
+    // with no Q adjustment.
+    segment = active_segments - 1;
+    while (segment > 0) {
+      if (projected_rate <
+          (target_rate * aq_c_transitions[aq_strength][segment])) {
+        break;
+      }
+      --segment;
     }
 
     if (target_rate > 0) {