From adf4293e4e3e1006e4ddfb2fe1908d9849678640 Mon Sep 17 00:00:00 2001 From: Paul Wilkins Date: Wed, 4 Jun 2014 14:14:14 +0100 Subject: [PATCH] Adapt strength of AQ2. Adapt the use of segmentation in AQ mode 2 based on the ambient kf/arf/gf Q. Disable segmentation where the rate per SB is very low and overheads are likely to outweigh the benefits. This patch reduces the -ve average metrics impact of AQ mode 2 while allowing stronger 3 segment AQ in some cases. Average improvement ~0.5-1.0%. Change-Id: I5892dfcc7507c5cc6444531cc7fe17554cf8d0c7 --- vp9/encoder/vp9_aq_complexity.c | 67 +++++++++++++++++++++++++-------- vp9/encoder/vp9_segmentation.c | 2 + 2 files changed, 54 insertions(+), 15 deletions(-) diff --git a/vp9/encoder/vp9_aq_complexity.c b/vp9/encoder/vp9_aq_complexity.c index 0d6b41d15..33f92393c 100644 --- a/vp9/encoder/vp9_aq_complexity.c +++ b/vp9/encoder/vp9_aq_complexity.c @@ -15,8 +15,19 @@ #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; @@ -29,6 +40,8 @@ void vp9_setup_in_frame_q_adj(VP9_COMP *cpi) { 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 @@ void vp9_setup_in_frame_q_adj(VP9_COMP *cpi) { // 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 @@ void vp9_setup_in_frame_q_adj(VP9_COMP *cpi) { 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 @@ void vp9_setup_in_frame_q_adj(VP9_COMP *cpi) { } } -// 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 @@ void vp9_select_in_frame_q_segment(VP9_COMP *cpi, // 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) { diff --git a/vp9/encoder/vp9_segmentation.c b/vp9/encoder/vp9_segmentation.c index 574df6293..897ae0129 100644 --- a/vp9/encoder/vp9_segmentation.c +++ b/vp9/encoder/vp9_segmentation.c @@ -27,6 +27,8 @@ void vp9_enable_segmentation(struct segmentation *seg) { 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,