generic-library/vpx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Substantial restructuring of AQ mode 2.

Browse Source 
The restructure moves the decision into the rd pick
modes loop and makes a decision based at the 16x16
block level instead of only the 64x64 level.

This gives finer granularity and better visual results
on the clips I have tested. Metrics results are worse
than the old AQ2 especially for PSNR and this mode
now falls between AQ0 and AQ1 in terms of visual
impact and metrics results.

Further tuning of this to follow.

It should be noted that if there are multiple iterations
of the recode loop the segment for a MB could change
in each loop if the previous loop causes a change in the
complexity / variance bin of the block. Also where a block
gets a delta Q this will alter the rd multiplier for this block
in subsequent recode iterations and frames where the
segmentation is applied.

Change-Id: I20256c125daa14734c16f7cc9aefab656ab808f7
This commit is contained in:
Paul Wilkins
2014-11-27 10:50:56 +00:00
parent 127f65531b
commit e68c8dcfd2
5 changed files with 83 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

111
vp9/encoder/vp9_aq_complexity.c
View File

@@ -16,19 +16,29 @@
#include "vp9/common/vp9_seg_common.h" #include "vp9/common/vp9_seg_common.h"
#include "vp9/encoder/vp9_segmentation.h" #include "vp9/encoder/vp9_segmentation.h"
#define AQ_C_SEGMENTS 3 #define AQ_C_SEGMENTS 5
#define AQ_C_STRENGTHS 3 #define DEFAULT_AQ2_SEG 3 // Neutral Q segment
static const int aq_c_active_segments[AQ_C_STRENGTHS] = {1, 2, 3}; #define AQ_C_STRENGTHS 3
static const double aq_c_q_adj_factor[AQ_C_STRENGTHS][AQ_C_SEGMENTS] = 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}}; { {1.75, 1.25, 1.05, 1.00, 0.90},
{2.00, 1.50, 1.15, 1.00, 0.85},
{2.50, 1.75, 1.25, 1.00, 0.80} };
static const double aq_c_transitions[AQ_C_STRENGTHS][AQ_C_SEGMENTS] = 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}}; { {0.15, 0.30, 0.55, 2.00, 100.0},
static const double aq_c_var_thresholds[AQ_C_SEGMENTS] = {100.0, -1.0, -2.0}; {0.20, 0.40, 0.65, 2.00, 100.0},
{0.25, 0.50, 0.75, 2.00, 100.0} };
static const double aq_c_var_thresholds[AQ_C_STRENGTHS][AQ_C_SEGMENTS] =
{ {-4.0, -3.0, -2.0, 100.00, 100.0},
{-3.5, -2.5, -1.5, 100.00, 100.0},
{-3.0, -2.0, -1.0, 100.00, 100.0} };
#define DEFAULT_COMPLEXITY 64
static int get_aq_c_strength(int q_index, vpx_bit_depth_t bit_depth) { static int get_aq_c_strength(int q_index, vpx_bit_depth_t bit_depth) {
// Approximate base quatizer (truncated to int) // Approximate base quatizer (truncated to int)
const int base_quant = vp9_ac_quant(q_index, 0, bit_depth) / 4; const int base_quant = vp9_ac_quant(q_index, 0, bit_depth) / 4;
return (base_quant > 20) + (base_quant > 45); return (base_quant > 10) + (base_quant > 25);
} }
void vp9_setup_in_frame_q_adj(VP9_COMP *cpi) { void vp9_setup_in_frame_q_adj(VP9_COMP *cpi) {
@@ -43,13 +53,10 @@ void vp9_setup_in_frame_q_adj(VP9_COMP *cpi) {
(cpi->refresh_golden_frame && !cpi->rc.is_src_frame_alt_ref)) { (cpi->refresh_golden_frame && !cpi->rc.is_src_frame_alt_ref)) {
int segment; int segment;
const int aq_strength = get_aq_c_strength(cm->base_qindex, cm->bit_depth); const int aq_strength = get_aq_c_strength(cm->base_qindex, cm->bit_depth);
const int active_segments = aq_c_active_segments[aq_strength];
// Clear down the segment map. // Clear down the segment map.
vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols); vpx_memset(cpi->segmentation_map, DEFAULT_AQ2_SEG,
cm->mi_rows * cm->mi_cols);
// Clear down the complexity map used for rd.
vpx_memset(cpi->complexity_map, 0, cm->mi_rows * cm->mi_cols);
vp9_clearall_segfeatures(seg); vp9_clearall_segfeatures(seg);
@@ -65,15 +72,21 @@ void vp9_setup_in_frame_q_adj(VP9_COMP *cpi) {
// Select delta coding method. // Select delta coding method.
seg->abs_delta = SEGMENT_DELTADATA; seg->abs_delta = SEGMENT_DELTADATA;
// Segment 0 "Q" feature is disabled so it defaults to the baseline Q. // Default segment "Q" feature is disabled so it defaults to the baseline Q.
vp9_disable_segfeature(seg, 0, SEG_LVL_ALT_Q); vp9_disable_segfeature(seg, DEFAULT_AQ2_SEG, SEG_LVL_ALT_Q);
// Use some of the segments for in frame Q adjustment. // Use some of the segments for in frame Q adjustment.
for (segment = 1; segment < active_segments; ++segment) { for (segment = 0; segment < AQ_C_SEGMENTS; ++segment) {
int qindex_delta = int qindex_delta;
vp9_compute_qdelta_by_rate(&cpi->rc, cm->frame_type, cm->base_qindex,
aq_c_q_adj_factor[aq_strength][segment], if (segment == DEFAULT_AQ2_SEG)
cm->bit_depth); continue;
qindex_delta =
vp9_compute_qdelta_by_rate(&cpi->rc, cm->frame_type, cm->base_qindex,
aq_c_q_adj_factor[aq_strength][segment],
cm->bit_depth);
// For AQ complexity mode, we dont allow Q0 in a segment if the base // 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 is not 0. Q0 (lossless) implies 4x4 only and in AQ mode 2 a segment
@@ -91,67 +104,53 @@ void vp9_setup_in_frame_q_adj(VP9_COMP *cpi) {
} }
#define DEFAULT_LV_THRESH 10.0 #define DEFAULT_LV_THRESH 10.0
#define MIN_DEFAULT_LV_THRESH 8.0
// Select a segment for the current SB64 block. #define VAR_STRENGTH_STEP 0.25
// Select a segment for the current block.
// The choice of segment for a block depends on the ratio of the projected // The choice of segment for a block depends on the ratio of the projected
// bits for the block vs a target average. // bits for the block vs a target average and its spatial complexity.
// An "aq_strength" value determines how many segments are supported, void vp9_caq_select_segment(VP9_COMP *cpi, MACROBLOCK *mb, BLOCK_SIZE bs,
// the set of transition points to use and the extent of the quantizer int mi_row, int mi_col, int projected_rate) {
// adjustment for each segment (configured in vp9_setup_in_frame_q_adj()).
void vp9_select_in_frame_q_segment(VP9_COMP *cpi, MACROBLOCK *mb,
BLOCK_SIZE bs,
int mi_row, int mi_col,
int output_enabled, int projected_rate) {
VP9_COMMON *const cm = &cpi->common; VP9_COMMON *const cm = &cpi->common;
const int mi_offset = mi_row * cm->mi_cols + mi_col; const int mi_offset = mi_row * cm->mi_cols + mi_col;
const int bw = num_8x8_blocks_wide_lookup[BLOCK_64X64]; const int bw = num_8x8_blocks_wide_lookup[BLOCK_64X64];
const int bh = num_8x8_blocks_high_lookup[BLOCK_64X64]; const int bh = num_8x8_blocks_high_lookup[BLOCK_64X64];
const int xmis = MIN(cm->mi_cols - mi_col, bw); const int xmis = MIN(cm->mi_cols - mi_col, num_8x8_blocks_wide_lookup[bs]);
const int ymis = MIN(cm->mi_rows - mi_row, bh); const int ymis = MIN(cm->mi_rows - mi_row, num_8x8_blocks_high_lookup[bs]);
int complexity_metric = 64;
int x, y; int x, y;
int i;
unsigned char segment; unsigned char segment;
if (!output_enabled) { if (0) {
segment = 0; segment = DEFAULT_AQ2_SEG;
} else { } else {
// Rate depends on fraction of a SB64 in frame (xmis * ymis / bw * bh). // Rate depends on fraction of a SB64 in frame (xmis * ymis / bw * bh).
// It is converted to bits * 256 units. // It is converted to bits * 256 units.
const int target_rate = (cpi->rc.sb64_target_rate * xmis * ymis * 256) / const int target_rate = (cpi->rc.sb64_target_rate * xmis * ymis * 256) /
(bw * bh); (bw * bh);
const int aq_strength = get_aq_c_strength(cm->base_qindex, cm->bit_depth);
const int active_segments = aq_c_active_segments[aq_strength];
double logvar; double logvar;
double low_var_thresh; double low_var_thresh;
const int aq_strength = get_aq_c_strength(cm->base_qindex, cm->bit_depth);
vp9_clear_system_state(); vp9_clear_system_state();
low_var_thresh = low_var_thresh = (cpi->oxcf.pass == 2)
(cpi->oxcf.pass == 2) ? cpi->twopass.mb_av_energy : DEFAULT_LV_THRESH; ? MAX(cpi->twopass.mb_av_energy, MIN_DEFAULT_LV_THRESH)
: DEFAULT_LV_THRESH;
vp9_setup_src_planes(mb, cpi->Source, mi_row, mi_col); vp9_setup_src_planes(mb, cpi->Source, mi_row, mi_col);
logvar = vp9_log_block_var(cpi, mb, bs); logvar = vp9_log_block_var(cpi, mb, bs);
// The number of segments considered and the transition points used to segment = AQ_C_SEGMENTS - 1; // Just in case no break out below.
// select them is determined by the "aq_strength" value. for (i = 0; i < AQ_C_SEGMENTS; ++i) {
// Currently this loop only supports segments that reduce Q (i.e. where // Test rate against a threshold value and variance against a threshold.
// there is undershoot. // Increasing segment number (higher variance and complexity) = higher Q.
// 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 < if ((projected_rate <
target_rate * aq_c_transitions[aq_strength][segment]) && target_rate * aq_c_transitions[aq_strength][i]) &&
(logvar < (low_var_thresh + aq_c_var_thresholds[segment]))) { (logvar < (low_var_thresh + aq_c_var_thresholds[aq_strength][i]))) {
segment = i;
break; break;
} }
--segment;
}
if (target_rate > 0) {
complexity_metric =
clamp((int)((projected_rate * 64) / target_rate), 16, 255);
} }
} }
@@ -159,8 +158,6 @@ void vp9_select_in_frame_q_segment(VP9_COMP *cpi, MACROBLOCK *mb,
for (y = 0; y < ymis; y++) { for (y = 0; y < ymis; y++) {
for (x = 0; x < xmis; x++) { for (x = 0; x < xmis; x++) {
cpi->segmentation_map[mi_offset + y * cm->mi_cols + x] = segment; cpi->segmentation_map[mi_offset + y * cm->mi_cols + x] = segment;
cpi->complexity_map[mi_offset + y * cm->mi_cols + x] =
(unsigned char)complexity_metric;
} }
} }
} }

9
vp9/encoder/vp9_aq_complexity.h
View File

@@ -19,11 +19,10 @@ extern "C" {
struct VP9_COMP; struct VP9_COMP;
struct macroblock; struct macroblock;
// Select a segment for the current SB64. // Select a segment for the current Block.
void vp9_select_in_frame_q_segment(struct VP9_COMP *cpi, struct macroblock *x, void vp9_caq_select_segment(struct VP9_COMP *cpi, struct macroblock *,
BLOCK_SIZE bs, BLOCK_SIZE bs,
int mi_row, int mi_col, int mi_row, int mi_col, int projected_rate);
int output_enabled, int projected_rate);
// This function sets up a set of segments with delta Q values around // This function sets up a set of segments with delta Q values around
// the baseline frame quantizer. // the baseline frame quantizer.

62
vp9/encoder/vp9_encodeframe.c
View File

@@ -700,7 +700,7 @@ static void update_state(VP9_COMP *cpi, ThreadData *td,
mi_addr->src_mi = mi_addr; mi_addr->src_mi = mi_addr;
// If segmentation in use // If segmentation in use
if (seg->enabled && output_enabled) { if (seg->enabled) {
// For in frame complexity AQ copy the segment id from the segment map. // For in frame complexity AQ copy the segment id from the segment map.
if (cpi->oxcf.aq_mode == COMPLEXITY_AQ) { if (cpi->oxcf.aq_mode == COMPLEXITY_AQ) {
const uint8_t *const map = seg->update_map ? cpi->segmentation_map const uint8_t *const map = seg->update_map ? cpi->segmentation_map
@@ -863,6 +863,18 @@ static void set_mode_info_seg_skip(MACROBLOCK *x, TX_MODE tx_mode,
vp9_rd_cost_init(rd_cost); vp9_rd_cost_init(rd_cost);
} }
static int set_segment_rdmult(VP9_COMP *const cpi,
MACROBLOCK *const x,
int8_t segment_id) {
int segment_qindex;
VP9_COMMON *const cm = &cpi->common;
vp9_init_plane_quantizers(cpi, x);
vp9_clear_system_state();
segment_qindex = vp9_get_qindex(&cm->seg, segment_id,
cm->base_qindex);
return vp9_compute_rd_mult(cpi, segment_qindex + cm->y_dc_delta_q);
}
static void rd_pick_sb_modes(VP9_COMP *cpi, static void rd_pick_sb_modes(VP9_COMP *cpi,
TileDataEnc *tile_data, TileDataEnc *tile_data,
MACROBLOCK *const x, MACROBLOCK *const x,
@@ -919,7 +931,6 @@ static void rd_pick_sb_modes(VP9_COMP *cpi,
if (aq_mode == VARIANCE_AQ) { if (aq_mode == VARIANCE_AQ) {
const int energy = bsize <= BLOCK_16X16 ? x->mb_energy const int energy = bsize <= BLOCK_16X16 ? x->mb_energy
: vp9_block_energy(cpi, x, bsize); : vp9_block_energy(cpi, x, bsize);
int segment_qindex;
if (cm->frame_type == KEY_FRAME || if (cm->frame_type == KEY_FRAME ||
cpi->refresh_alt_ref_frame || cpi->refresh_alt_ref_frame ||
(cpi->refresh_golden_frame && !cpi->rc.is_src_frame_alt_ref)) { (cpi->refresh_golden_frame && !cpi->rc.is_src_frame_alt_ref)) {
@@ -929,18 +940,9 @@ static void rd_pick_sb_modes(VP9_COMP *cpi,
: cm->last_frame_seg_map; : cm->last_frame_seg_map;
mbmi->segment_id = vp9_get_segment_id(cm, map, bsize, mi_row, mi_col); mbmi->segment_id = vp9_get_segment_id(cm, map, bsize, mi_row, mi_col);
} }
vp9_init_plane_quantizers(cpi, x); x->rdmult = set_segment_rdmult(cpi, x, mbmi->segment_id);
vp9_clear_system_state();
segment_qindex = vp9_get_qindex(&cm->seg, mbmi->segment_id,
cm->base_qindex);
x->rdmult = vp9_compute_rd_mult(cpi, segment_qindex + cm->y_dc_delta_q);
} else if (aq_mode == COMPLEXITY_AQ) { } else if (aq_mode == COMPLEXITY_AQ) {
const int mi_offset = mi_row * cm->mi_cols + mi_col; x->rdmult = set_segment_rdmult(cpi, x, mbmi->segment_id);
unsigned char complexity = cpi->complexity_map[mi_offset];
const int is_edge = (mi_row <= 1) || (mi_row >= (cm->mi_rows - 2)) ||
(mi_col <= 1) || (mi_col >= (cm->mi_cols - 2));
if (!is_edge && (complexity > 128))
x->rdmult += ((x->rdmult * (complexity - 128)) / 256);
} else if (aq_mode == CYCLIC_REFRESH_AQ) { } else if (aq_mode == CYCLIC_REFRESH_AQ) {
const uint8_t *const map = cm->seg.update_map ? cpi->segmentation_map const uint8_t *const map = cm->seg.update_map ? cpi->segmentation_map
: cm->last_frame_seg_map; : cm->last_frame_seg_map;
@@ -967,6 +969,16 @@ static void rd_pick_sb_modes(VP9_COMP *cpi,
} }
} }
// Examine the resulting rate and for AQ mode 2 make a segment choice.
if ((rd_cost->rate != INT_MAX) &&
(aq_mode == COMPLEXITY_AQ) && (bsize >= BLOCK_16X16) &&
(cm->frame_type == KEY_FRAME ||
cpi->refresh_alt_ref_frame ||
(cpi->refresh_golden_frame && !cpi->rc.is_src_frame_alt_ref))) {
vp9_caq_select_segment(cpi, x, bsize, mi_row, mi_col, rd_cost->rate);
}
x->rdmult = orig_rdmult; x->rdmult = orig_rdmult;
// TODO(jingning) The rate-distortion optimization flow needs to be // TODO(jingning) The rate-distortion optimization flow needs to be
@@ -1761,14 +1773,6 @@ static void rd_use_partition(VP9_COMP *cpi,
if (do_recon) { if (do_recon) {
int output_enabled = (bsize == BLOCK_64X64); int output_enabled = (bsize == BLOCK_64X64);
// Check the projected output rate for this SB against it's target
// and and if necessary apply a Q delta using segmentation to get
// closer to the target.
if ((cpi->oxcf.aq_mode == COMPLEXITY_AQ) && cm->seg.update_map) {
vp9_select_in_frame_q_segment(cpi, x, bsize, mi_row, mi_col,
output_enabled, chosen_rdc.rate);
}
encode_sb(cpi, td, tile_info, tp, mi_row, mi_col, output_enabled, bsize, encode_sb(cpi, td, tile_info, tp, mi_row, mi_col, output_enabled, bsize,
pc_tree); pc_tree);
} }
@@ -2500,13 +2504,6 @@ static void rd_pick_partition(VP9_COMP *cpi, ThreadData *td,
if (best_rdc.rate < INT_MAX && best_rdc.dist < INT64_MAX && if (best_rdc.rate < INT_MAX && best_rdc.dist < INT64_MAX &&
pc_tree->index != 3) { pc_tree->index != 3) {
int output_enabled = (bsize == BLOCK_64X64); int output_enabled = (bsize == BLOCK_64X64);
// Check the projected output rate for this SB against it's target
// and and if necessary apply a Q delta using segmentation to get
// closer to the target.
if ((cpi->oxcf.aq_mode == COMPLEXITY_AQ) && cm->seg.update_map)
vp9_select_in_frame_q_segment(cpi, x, bsize, mi_row, mi_col,
output_enabled, best_rdc.rate);
encode_sb(cpi, td, tile_info, tp, mi_row, mi_col, output_enabled, encode_sb(cpi, td, tile_info, tp, mi_row, mi_col, output_enabled,
bsize, pc_tree); bsize, pc_tree);
} }
@@ -2784,7 +2781,6 @@ static void nonrd_pick_partition(VP9_COMP *cpi, ThreadData *td,
int do_recon, int64_t best_rd, int do_recon, int64_t best_rd,
PC_TREE *pc_tree) { PC_TREE *pc_tree) {
const SPEED_FEATURES *const sf = &cpi->sf; const SPEED_FEATURES *const sf = &cpi->sf;
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
VP9_COMMON *const cm = &cpi->common; VP9_COMMON *const cm = &cpi->common;
TileInfo *const tile_info = &tile_data->tile_info; TileInfo *const tile_info = &tile_data->tile_info;
MACROBLOCK *const x = &td->mb; MACROBLOCK *const x = &td->mb;
@@ -3016,14 +3012,6 @@ static void nonrd_pick_partition(VP9_COMP *cpi, ThreadData *td,
if (best_rdc.rate < INT_MAX && best_rdc.dist < INT64_MAX && do_recon) { if (best_rdc.rate < INT_MAX && best_rdc.dist < INT64_MAX && do_recon) {
int output_enabled = (bsize == BLOCK_64X64); int output_enabled = (bsize == BLOCK_64X64);
// Check the projected output rate for this SB against it's target
// and and if necessary apply a Q delta using segmentation to get
// closer to the target.
if ((oxcf->aq_mode == COMPLEXITY_AQ) && cm->seg.update_map) {
vp9_select_in_frame_q_segment(cpi, x, bsize, mi_row, mi_col,
output_enabled, best_rdc.rate);
}
encode_sb_rt(cpi, td, tile_info, tp, mi_row, mi_col, output_enabled, encode_sb_rt(cpi, td, tile_info, tp, mi_row, mi_col, output_enabled,
bsize, pc_tree); bsize, pc_tree);
} }

7
vp9/encoder/vp9_encoder.c
View File

@@ -213,9 +213,6 @@ static void dealloc_compressor_data(VP9_COMP *cpi) {
vpx_free(cpi->coding_context.last_frame_seg_map_copy); vpx_free(cpi->coding_context.last_frame_seg_map_copy);
cpi->coding_context.last_frame_seg_map_copy = NULL; cpi->coding_context.last_frame_seg_map_copy = NULL;
vpx_free(cpi->complexity_map);
cpi->complexity_map = NULL;
vpx_free(cpi->nmvcosts[0]); vpx_free(cpi->nmvcosts[0]);
vpx_free(cpi->nmvcosts[1]); vpx_free(cpi->nmvcosts[1]);
cpi->nmvcosts[0] = NULL; cpi->nmvcosts[0] = NULL;
@@ -1445,10 +1442,6 @@ VP9_COMP *vp9_create_compressor(VP9EncoderConfig *oxcf) {
CHECK_MEM_ERROR(cm, cpi->segmentation_map, CHECK_MEM_ERROR(cm, cpi->segmentation_map,
vpx_calloc(cm->mi_rows * cm->mi_cols, 1)); vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
// Create a complexity map used for rd adjustment
CHECK_MEM_ERROR(cm, cpi->complexity_map,
vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
// Create a map used for cyclic background refresh. // Create a map used for cyclic background refresh.
CHECK_MEM_ERROR(cm, cpi->cyclic_refresh, CHECK_MEM_ERROR(cm, cpi->cyclic_refresh,
vp9_cyclic_refresh_alloc(cm->mi_rows, cm->mi_cols)); vp9_cyclic_refresh_alloc(cm->mi_rows, cm->mi_cols));

2
vp9/encoder/vp9_encoder.h
View File

@@ -351,8 +351,6 @@ typedef struct VP9_COMP {
// segment threashold for encode breakout // segment threashold for encode breakout
int segment_encode_breakout[MAX_SEGMENTS]; int segment_encode_breakout[MAX_SEGMENTS];
unsigned char *complexity_map;
CYCLIC_REFRESH *cyclic_refresh; CYCLIC_REFRESH *cyclic_refresh;
fractional_mv_step_fp *find_fractional_mv_step; fractional_mv_step_fp *find_fractional_mv_step;