shithub: libvpx

Info  •  Files  •  Log  •  Branches

Merge "Adapt strength of AQ2."

--- a/vp9/encoder/vp9_aq_complexity.c

+++ b/vp9/encoder/vp9_aq_complexity.c

@@ -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) {

--- a/vp9/encoder/vp9_segmentation.c

+++ b/vp9/encoder/vp9_segmentation.c

@@ -27,6 +27,8 @@

 void vp9_disable_segmentation(struct segmentation *seg) {

   seg->enabled = 0;

+  seg->update_map = 0;

+  seg->update_data = 0;

 }

 void vp9_set_segment_data(struct segmentation *seg,