diff options
Diffstat (limited to 'vp8')
| -rw-r--r-- | vp8/common/blockd.h | 4 | ||||
| -rw-r--r-- | vp8/common/onyx.h | 1 | ||||
| -rw-r--r-- | vp8/encoder/block.h | 4 | ||||
| -rw-r--r-- | vp8/encoder/denoising.c | 19 | ||||
| -rw-r--r-- | vp8/encoder/denoising.h | 4 | ||||
| -rw-r--r-- | vp8/encoder/encodeframe.c | 8 | ||||
| -rw-r--r-- | vp8/encoder/ethreading.c | 9 | ||||
| -rw-r--r-- | vp8/encoder/onyx_if.c | 308 | ||||
| -rw-r--r-- | vp8/encoder/onyx_int.h | 9 | ||||
| -rw-r--r-- | vp8/encoder/pickinter.c | 325 | ||||
| -rw-r--r-- | vp8/encoder/quantize.c | 18 | ||||
| -rw-r--r-- | vp8/encoder/ratectrl.c | 8 | ||||
| -rw-r--r-- | vp8/vp8_cx_iface.c | 98 |
13 files changed, 704 insertions, 111 deletions
diff --git a/vp8/common/blockd.h b/vp8/common/blockd.h index ea1a6a4ad..192108a06 100644 --- a/vp8/common/blockd.h +++ b/vp8/common/blockd.h @@ -187,8 +187,12 @@ typedef struct { FRAME_TYPE frame_type; int is_frame_dropped; + // The frame rate for the lowest resolution. + double low_res_framerate; /* The frame number of each reference frames */ unsigned int low_res_ref_frames[MAX_REF_FRAMES]; + // The video frame counter value for the key frame, for lowest resolution. + unsigned int key_frame_counter_value; LOWER_RES_MB_INFO *mb_info; } LOWER_RES_FRAME_INFO; #endif diff --git a/vp8/common/onyx.h b/vp8/common/onyx.h index d48c4fe5e..f39b675cd 100644 --- a/vp8/common/onyx.h +++ b/vp8/common/onyx.h @@ -122,6 +122,7 @@ extern "C" int Sharpness; int cpu_used; unsigned int rc_max_intra_bitrate_pct; + unsigned int screen_content_mode; /* mode -> *(0)=Realtime/Live Encoding. This mode is optimized for realtim diff --git a/vp8/encoder/block.h b/vp8/encoder/block.h index dbdcab957..248e79549 100644 --- a/vp8/encoder/block.h +++ b/vp8/encoder/block.h @@ -125,6 +125,8 @@ typedef struct macroblock int optimize; int q_index; + int is_skin; + int denoise_zeromv; #if CONFIG_TEMPORAL_DENOISING int increase_denoising; @@ -161,6 +163,8 @@ typedef struct macroblock void (*short_walsh4x4)(short *input, short *output, int pitch); void (*quantize_b)(BLOCK *b, BLOCKD *d); + unsigned int mbs_zero_last_dot_suppress; + int zero_last_dot_suppress; } MACROBLOCK; diff --git a/vp8/encoder/denoising.c b/vp8/encoder/denoising.c index c0eff4e55..b9fbf061e 100644 --- a/vp8/encoder/denoising.c +++ b/vp8/encoder/denoising.c @@ -391,7 +391,7 @@ void vp8_denoiser_set_parameters(VP8_DENOISER *denoiser, int mode) { denoiser->denoise_pars.scale_increase_filter = 1; denoiser->denoise_pars.denoise_mv_bias = 60; denoiser->denoise_pars.pickmode_mv_bias = 75; - denoiser->denoise_pars.qp_thresh = 85; + denoiser->denoise_pars.qp_thresh = 80; denoiser->denoise_pars.consec_zerolast = 15; denoiser->denoise_pars.spatial_blur = 0; } @@ -456,10 +456,10 @@ int vp8_denoiser_allocate(VP8_DENOISER *denoiser, int width, int height, denoiser->bitrate_threshold = 400000; // (bits/sec). denoiser->threshold_aggressive_mode = 80; if (width * height > 1280 * 720) { - denoiser->bitrate_threshold = 2500000; - denoiser->threshold_aggressive_mode = 180; + denoiser->bitrate_threshold = 3000000; + denoiser->threshold_aggressive_mode = 200; } else if (width * height > 960 * 540) { - denoiser->bitrate_threshold = 1000000; + denoiser->bitrate_threshold = 1200000; denoiser->threshold_aggressive_mode = 120; } else if (width * height > 640 * 480) { denoiser->bitrate_threshold = 600000; @@ -483,7 +483,6 @@ void vp8_denoiser_free(VP8_DENOISER *denoiser) vpx_free(denoiser->denoise_state); } - void vp8_denoiser_denoise_mb(VP8_DENOISER *denoiser, MACROBLOCK *x, unsigned int best_sse, @@ -554,6 +553,7 @@ void vp8_denoiser_denoise_mb(VP8_DENOISER *denoiser, * Note that any changes to the mode info only affects the * denoising. */ + x->denoise_zeromv = 1; mbmi->ref_frame = x->best_zeromv_reference_frame; @@ -603,6 +603,12 @@ void vp8_denoiser_denoise_mb(VP8_DENOISER *denoiser, motion_threshold = denoiser->denoise_pars.scale_motion_thresh * NOISE_MOTION_THRESHOLD; + // If block is considered to be skin area, lower the motion threshold. + // In current version set threshold = 1, so only denoise very low + // (i.e., zero) mv on skin. + if (x->is_skin) + motion_threshold = 1; + if (motion_magnitude2 < denoiser->denoise_pars.scale_increase_filter * NOISE_MOTION_THRESHOLD) x->increase_denoising = 1; @@ -662,6 +668,7 @@ void vp8_denoiser_denoise_mb(VP8_DENOISER *denoiser, /* No filtering of this block; it differs too much from the predictor, * or the motion vector magnitude is considered too big. */ + x->denoise_zeromv = 0; vp8_copy_mem16x16( x->thismb, 16, denoiser->yv12_running_avg[INTRA_FRAME].y_buffer + recon_yoffset, @@ -692,7 +699,7 @@ void vp8_denoiser_denoise_mb(VP8_DENOISER *denoiser, int uv_stride =denoiser->yv12_running_avg[INTRA_FRAME].uv_stride; // Fix filter level to some nominal value for now. - int filter_level = 32; + int filter_level = 48; int hev_index = lfi_n->hev_thr_lut[INTER_FRAME][filter_level]; lfi.mblim = lfi_n->mblim[filter_level]; diff --git a/vp8/encoder/denoising.h b/vp8/encoder/denoising.h index 6c1f9e22b..9a379a6a1 100644 --- a/vp8/encoder/denoising.h +++ b/vp8/encoder/denoising.h @@ -19,7 +19,7 @@ extern "C" { #endif #define SUM_DIFF_THRESHOLD (16 * 16 * 2) -#define SUM_DIFF_THRESHOLD_HIGH (600) +#define SUM_DIFF_THRESHOLD_HIGH (600) // ~(16 * 16 * 1.5) #define MOTION_MAGNITUDE_THRESHOLD (8*3) #define SUM_DIFF_THRESHOLD_UV (96) // (8 * 8 * 1.5) @@ -27,7 +27,7 @@ extern "C" { #define SUM_DIFF_FROM_AVG_THRESH_UV (8 * 8 * 8) #define MOTION_MAGNITUDE_THRESHOLD_UV (8*3) -#define MAX_GF_ARF_DENOISE_RANGE (16) +#define MAX_GF_ARF_DENOISE_RANGE (8) enum vp8_denoiser_decision { diff --git a/vp8/encoder/encodeframe.c b/vp8/encoder/encodeframe.c index 2a3f69cc8..70632c0c3 100644 --- a/vp8/encoder/encodeframe.c +++ b/vp8/encoder/encodeframe.c @@ -522,7 +522,8 @@ void encode_mb_row(VP8_COMP *cpi, } #endif - // Keep track of how many (consecutive) times a block is coded + + // Keep track of how many (consecutive) times a block is coded // as ZEROMV_LASTREF, for base layer frames. // Reset to 0 if its coded as anything else. if (cpi->current_layer == 0) { @@ -531,9 +532,14 @@ void encode_mb_row(VP8_COMP *cpi, // Increment, check for wrap-around. if (cpi->consec_zero_last[map_index+mb_col] < 255) cpi->consec_zero_last[map_index+mb_col] += 1; + if (cpi->consec_zero_last_mvbias[map_index+mb_col] < 255) + cpi->consec_zero_last_mvbias[map_index+mb_col] += 1; } else { cpi->consec_zero_last[map_index+mb_col] = 0; + cpi->consec_zero_last_mvbias[map_index+mb_col] = 0; } + if (x->zero_last_dot_suppress) + cpi->consec_zero_last_mvbias[map_index+mb_col] = 0; } /* Special case code for cyclic refresh diff --git a/vp8/encoder/ethreading.c b/vp8/encoder/ethreading.c index 3598a7a69..a6b30a6bc 100644 --- a/vp8/encoder/ethreading.c +++ b/vp8/encoder/ethreading.c @@ -215,11 +215,15 @@ THREAD_FUNCTION thread_encoding_proc(void *p_data) LAST_FRAME) { // Increment, check for wrap-around. if (cpi->consec_zero_last[map_index+mb_col] < 255) - cpi->consec_zero_last[map_index+mb_col] += - 1; + cpi->consec_zero_last[map_index+mb_col] += 1; + if (cpi->consec_zero_last_mvbias[map_index+mb_col] < 255) + cpi->consec_zero_last_mvbias[map_index+mb_col] += 1; } else { cpi->consec_zero_last[map_index+mb_col] = 0; + cpi->consec_zero_last_mvbias[map_index+mb_col] = 0; } + if (x->zero_last_dot_suppress) + cpi->consec_zero_last_mvbias[map_index+mb_col] = 0; } /* Special case code for cyclic refresh @@ -505,6 +509,7 @@ void vp8cx_init_mbrthread_data(VP8_COMP *cpi, mb->intra_error = 0; vp8_zero(mb->count_mb_ref_frame_usage); mb->mbs_tested_so_far = 0; + mb->mbs_zero_last_dot_suppress = 0; } } diff --git a/vp8/encoder/onyx_if.c b/vp8/encoder/onyx_if.c index 3cceb5a80..b04645654 100644 --- a/vp8/encoder/onyx_if.c +++ b/vp8/encoder/onyx_if.c @@ -579,11 +579,31 @@ static void cyclic_background_refresh(VP8_COMP *cpi, int Q, int lf_adjustment) cpi->cyclic_refresh_q = Q / 2; + if (cpi->oxcf.screen_content_mode) { + // Modify quality ramp-up based on Q. Above some Q level, increase the + // number of blocks to be refreshed, and reduce it below the thredhold. + // Turn-off under certain conditions (i.e., away from key frame, and if + // we are at good quality (low Q) and most of the blocks were skipped-encoded + // in previous frame. + if (Q >= 100) { + cpi->cyclic_refresh_mode_max_mbs_perframe = + (cpi->common.mb_rows * cpi->common.mb_cols) / 10; + } else if (cpi->frames_since_key > 250 && + Q < 20 && + cpi->mb.skip_true_count > (int)(0.95 * mbs_in_frame)) { + cpi->cyclic_refresh_mode_max_mbs_perframe = 0; + } else { + cpi->cyclic_refresh_mode_max_mbs_perframe = + (cpi->common.mb_rows * cpi->common.mb_cols) / 20; + } + block_count = cpi->cyclic_refresh_mode_max_mbs_perframe; + } + // Set every macroblock to be eligible for update. // For key frame this will reset seg map to 0. vpx_memset(cpi->segmentation_map, 0, mbs_in_frame); - if (cpi->common.frame_type != KEY_FRAME) + if (cpi->common.frame_type != KEY_FRAME && block_count > 0) { /* Cycle through the macro_block rows */ /* MB loop to set local segmentation map */ @@ -617,15 +637,18 @@ static void cyclic_background_refresh(VP8_COMP *cpi, int Q, int lf_adjustment) #if CONFIG_TEMPORAL_DENOISING if (cpi->oxcf.noise_sensitivity > 0) { if (cpi->denoiser.denoiser_mode == kDenoiserOnYUVAggressive && - Q < (int)cpi->denoiser.denoise_pars.qp_thresh) { + Q < (int)cpi->denoiser.denoise_pars.qp_thresh && + (cpi->frames_since_key > + 2 * cpi->denoiser.denoise_pars.consec_zerolast)) { // Under aggressive denoising, use segmentation to turn off loop - // filter below some qp thresh. The filter is turned off for all + // filter below some qp thresh. The filter is reduced for all // blocks that have been encoded as ZEROMV LAST x frames in a row, // where x is set by cpi->denoiser.denoise_pars.consec_zerolast. // This is to avoid "dot" artifacts that can occur from repeated // loop filtering on noisy input source. cpi->cyclic_refresh_q = Q; - lf_adjustment = -MAX_LOOP_FILTER; + // lf_adjustment = -MAX_LOOP_FILTER; + lf_adjustment = -40; for (i = 0; i < mbs_in_frame; ++i) { seg_map[i] = (cpi->consec_zero_last[i] > cpi->denoiser.denoise_pars.consec_zerolast) ? 1 : 0; @@ -786,6 +809,7 @@ void vp8_set_speed_features(VP8_COMP *cpi) } cpi->mb.mbs_tested_so_far = 0; + cpi->mb.mbs_zero_last_dot_suppress = 0; /* best quality defaults */ sf->RD = 1; @@ -853,6 +877,25 @@ void vp8_set_speed_features(VP8_COMP *cpi) sf->thresh_mult[THR_SPLIT2] = sf->thresh_mult[THR_SPLIT3] = speed_map(Speed, thresh_mult_map_split2); + // Special case for temporal layers. + // Reduce the thresholds for zero/nearest/near for GOLDEN, if GOLDEN is + // used as second reference. We don't modify thresholds for ALTREF case + // since ALTREF is usually used as long-term reference in temporal layers. + if ((cpi->Speed <= 6) && + (cpi->oxcf.number_of_layers > 1) && + (cpi->ref_frame_flags & VP8_LAST_FRAME) && + (cpi->ref_frame_flags & VP8_GOLD_FRAME)) { + if (cpi->closest_reference_frame == GOLDEN_FRAME) { + sf->thresh_mult[THR_ZERO2] = sf->thresh_mult[THR_ZERO2] >> 3; + sf->thresh_mult[THR_NEAREST2] = sf->thresh_mult[THR_NEAREST2] >> 3; + sf->thresh_mult[THR_NEAR2] = sf->thresh_mult[THR_NEAR2] >> 3; + } else { + sf->thresh_mult[THR_ZERO2] = sf->thresh_mult[THR_ZERO2] >> 1; + sf->thresh_mult[THR_NEAREST2] = sf->thresh_mult[THR_NEAREST2] >> 1; + sf->thresh_mult[THR_NEAR2] = sf->thresh_mult[THR_NEAR2] >> 1; + } + } + cpi->mode_check_freq[THR_ZERO1] = cpi->mode_check_freq[THR_NEAREST1] = cpi->mode_check_freq[THR_NEAR1] = @@ -1380,6 +1423,12 @@ static void init_config(VP8_COMP *cpi, VP8_CONFIG *oxcf) cpi->ref_framerate = cpi->framerate; + cpi->ref_frame_flags = VP8_ALTR_FRAME | VP8_GOLD_FRAME | VP8_LAST_FRAME; + + cm->refresh_golden_frame = 0; + cm->refresh_last_frame = 1; + cm->refresh_entropy_probs = 1; + /* change includes all joint functionality */ vp8_change_config(cpi, oxcf); @@ -1600,12 +1649,6 @@ void vp8_change_config(VP8_COMP *cpi, VP8_CONFIG *oxcf) cpi->baseline_gf_interval = cpi->oxcf.alt_freq ? cpi->oxcf.alt_freq : DEFAULT_GF_INTERVAL; - cpi->ref_frame_flags = VP8_ALTR_FRAME | VP8_GOLD_FRAME | VP8_LAST_FRAME; - - cm->refresh_golden_frame = 0; - cm->refresh_last_frame = 1; - cm->refresh_entropy_probs = 1; - #if (CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING) cpi->oxcf.token_partitions = 3; #endif @@ -1708,7 +1751,11 @@ void vp8_change_config(VP8_COMP *cpi, VP8_CONFIG *oxcf) if (cpi->oxcf.number_of_layers != prev_number_of_layers) { // If the number of temporal layers are changed we must start at the - // base of the pattern cycle, so reset temporal_pattern_counter. + // base of the pattern cycle, so set the layer id to 0 and reset + // the temporal pattern counter. + if (cpi->temporal_layer_id > 0) { + cpi->temporal_layer_id = 0; + } cpi->temporal_pattern_counter = 0; reset_temporal_layer_change(cpi, oxcf, prev_number_of_layers); } @@ -1855,6 +1902,7 @@ struct VP8_COMP* vp8_create_compressor(VP8_CONFIG *oxcf) memcpy(cpi->base_skip_false_prob, vp8cx_base_skip_false_prob, sizeof(vp8cx_base_skip_false_prob)); cpi->common.current_video_frame = 0; cpi->temporal_pattern_counter = 0; + cpi->temporal_layer_id = -1; cpi->kf_overspend_bits = 0; cpi->kf_bitrate_adjustment = 0; cpi->frames_till_gf_update_due = 0; @@ -1907,6 +1955,8 @@ struct VP8_COMP* vp8_create_compressor(VP8_CONFIG *oxcf) } #endif + cpi->mse_source_denoised = 0; + /* Should we use the cyclic refresh method. * Currently this is tied to error resilliant mode */ @@ -1930,7 +1980,9 @@ struct VP8_COMP* vp8_create_compressor(VP8_CONFIG *oxcf) cpi->cyclic_refresh_map = (signed char *) NULL; CHECK_MEM_ERROR(cpi->consec_zero_last, - vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1)); + vpx_calloc(cm->mb_rows * cm->mb_cols, 1)); + CHECK_MEM_ERROR(cpi->consec_zero_last_mvbias, + vpx_calloc((cpi->common.mb_rows * cpi->common.mb_cols), 1)); #ifdef VP8_ENTROPY_STATS init_context_counters(); @@ -2453,6 +2505,7 @@ void vp8_remove_compressor(VP8_COMP **ptr) vpx_free(cpi->tok); vpx_free(cpi->cyclic_refresh_map); vpx_free(cpi->consec_zero_last); + vpx_free(cpi->consec_zero_last_mvbias); vp8_remove_common(&cpi->common); vpx_free(cpi); @@ -3296,6 +3349,49 @@ static void update_reference_frames(VP8_COMP *cpi) } +static int measure_square_diff_partial(YV12_BUFFER_CONFIG *source, + YV12_BUFFER_CONFIG *dest, + VP8_COMP *cpi) + { + int i, j; + int Total = 0; + int num_blocks = 0; + int skip = 2; + int min_consec_zero_last = 10; + int tot_num_blocks = (source->y_height * source->y_width) >> 8; + unsigned char *src = source->y_buffer; + unsigned char *dst = dest->y_buffer; + + /* Loop through the Y plane, every |skip| blocks along rows and colmumns, + * summing the square differences, and only for blocks that have been + * zero_last mode at least |x| frames in a row. + */ + for (i = 0; i < source->y_height; i += 16 * skip) + { + int block_index_row = (i >> 4) * cpi->common.mb_cols; + for (j = 0; j < source->y_width; j += 16 * skip) + { + int index = block_index_row + (j >> 4); + if (cpi->consec_zero_last[index] >= min_consec_zero_last) { + unsigned int sse; + Total += vp8_mse16x16(src + j, + source->y_stride, + dst + j, dest->y_stride, + &sse); + num_blocks++; + } + } + src += 16 * skip * source->y_stride; + dst += 16 * skip * dest->y_stride; + } + // Only return non-zero if we have at least ~1/16 samples for estimate. + if (num_blocks > (tot_num_blocks >> 4)) { + return (Total / num_blocks); + } else { + return 0; + } + } + #if CONFIG_TEMPORAL_DENOISING static void process_denoiser_mode_change(VP8_COMP *cpi) { const VP8_COMMON *const cm = &cpi->common; @@ -3350,7 +3446,7 @@ static void process_denoiser_mode_change(VP8_COMP *cpi) { // Only consider this block as valid for noise measurement // if the sum_diff average of the current and previous frame // is small (to avoid effects from lighting change). - if ((sse - var) < 256) { + if ((sse - var) < 128) { unsigned int sse2; const unsigned int act = vp8_variance16x16(src + j, ystride, @@ -3421,6 +3517,13 @@ void vp8_loopfilter_frame(VP8_COMP *cpi, VP8_COMMON *cm) { const FRAME_TYPE frame_type = cm->frame_type; + int update_any_ref_buffers = 1; + if (cpi->common.refresh_last_frame == 0 && + cpi->common.refresh_golden_frame == 0 && + cpi->common.refresh_alt_ref_frame == 0) { + update_any_ref_buffers = 0; + } + if (cm->no_lpf) { cm->filter_level = 0; @@ -3432,11 +3535,36 @@ void vp8_loopfilter_frame(VP8_COMP *cpi, VP8_COMMON *cm) vp8_clear_system_state(); vpx_usec_timer_start(&timer); - if (cpi->sf.auto_filter == 0) + if (cpi->sf.auto_filter == 0) { +#if CONFIG_TEMPORAL_DENOISING + if (cpi->oxcf.noise_sensitivity && cm->frame_type != KEY_FRAME) { + // Use the denoised buffer for selecting base loop filter level. + // Denoised signal for current frame is stored in INTRA_FRAME. + // No denoising on key frames. + vp8cx_pick_filter_level_fast( + &cpi->denoiser.yv12_running_avg[INTRA_FRAME], cpi); + } else { + vp8cx_pick_filter_level_fast(cpi->Source, cpi); + } +#else vp8cx_pick_filter_level_fast(cpi->Source, cpi); - - else +#endif + } else { +#if CONFIG_TEMPORAL_DENOISING + if (cpi->oxcf.noise_sensitivity && cm->frame_type != KEY_FRAME) { + // Use the denoised buffer for selecting base loop filter level. + // Denoised signal for current frame is stored in INTRA_FRAME. + // No denoising on key frames. + vp8cx_pick_filter_level( + &cpi->denoiser.yv12_running_avg[INTRA_FRAME], cpi); + } else { + vp8cx_pick_filter_level(cpi->Source, cpi); + } +#else vp8cx_pick_filter_level(cpi->Source, cpi); +#endif + } + if (cm->filter_level > 0) { @@ -3452,7 +3580,9 @@ void vp8_loopfilter_frame(VP8_COMP *cpi, VP8_COMMON *cm) sem_post(&cpi->h_event_end_lpf); /* signal that we have set filter_level */ #endif - if (cm->filter_level > 0) + // No need to apply loop-filter if the encoded frame does not update + // any reference buffers. + if (cm->filter_level > 0 && update_any_ref_buffers) { vp8_loop_filter_frame(cm, &cpi->mb.e_mbd, frame_type); } @@ -3582,39 +3712,78 @@ static void encode_frame_to_data_rate } #if CONFIG_MULTI_RES_ENCODING - /* In multi-resolution encoding, frame_type is decided by lowest-resolution - * encoder. Same frame_type is adopted while encoding at other resolution. - */ - if (cpi->oxcf.mr_encoder_id) - { - LOWER_RES_FRAME_INFO* low_res_frame_info - = (LOWER_RES_FRAME_INFO*)cpi->oxcf.mr_low_res_mode_info; + if (cpi->oxcf.mr_total_resolutions > 1) { + LOWER_RES_FRAME_INFO* low_res_frame_info + = (LOWER_RES_FRAME_INFO*)cpi->oxcf.mr_low_res_mode_info; + if (cpi->oxcf.mr_encoder_id) { + + // TODO(marpan): This constraint shouldn't be needed, as we would like + // to allow for key frame setting (forced or periodic) defined per + // spatial layer. For now, keep this in. cm->frame_type = low_res_frame_info->frame_type; + // Check if lower resolution is available for motion vector reuse. if(cm->frame_type != KEY_FRAME) { - cpi->mr_low_res_mv_avail = 1; - cpi->mr_low_res_mv_avail &= !(low_res_frame_info->is_frame_dropped); - - if (cpi->ref_frame_flags & VP8_LAST_FRAME) - cpi->mr_low_res_mv_avail &= (cpi->current_ref_frames[LAST_FRAME] - == low_res_frame_info->low_res_ref_frames[LAST_FRAME]); - - if (cpi->ref_frame_flags & VP8_GOLD_FRAME) - cpi->mr_low_res_mv_avail &= (cpi->current_ref_frames[GOLDEN_FRAME] - == low_res_frame_info->low_res_ref_frames[GOLDEN_FRAME]); + cpi->mr_low_res_mv_avail = 1; + cpi->mr_low_res_mv_avail &= !(low_res_frame_info->is_frame_dropped); + + if (cpi->ref_frame_flags & VP8_LAST_FRAME) + cpi->mr_low_res_mv_avail &= (cpi->current_ref_frames[LAST_FRAME] + == low_res_frame_info->low_res_ref_frames[LAST_FRAME]); + + if (cpi->ref_frame_flags & VP8_GOLD_FRAME) + cpi->mr_low_res_mv_avail &= (cpi->current_ref_frames[GOLDEN_FRAME] + == low_res_frame_info->low_res_ref_frames[GOLDEN_FRAME]); + + // Don't use altref to determine whether low res is available. + // TODO (marpan): Should we make this type of condition on a + // per-reference frame basis? + /* + if (cpi->ref_frame_flags & VP8_ALTR_FRAME) + cpi->mr_low_res_mv_avail &= (cpi->current_ref_frames[ALTREF_FRAME] + == low_res_frame_info->low_res_ref_frames[ALTREF_FRAME]); + */ + } + } - if (cpi->ref_frame_flags & VP8_ALTR_FRAME) - cpi->mr_low_res_mv_avail &= (cpi->current_ref_frames[ALTREF_FRAME] - == low_res_frame_info->low_res_ref_frames[ALTREF_FRAME]); + // On a key frame: For the lowest resolution, keep track of the key frame + // counter value. For the higher resolutions, reset the current video + // frame counter to that of the lowest resolution. + // This is done to the handle the case where we may stop/start encoding + // higher layer(s). The restart-encoding of higher layer is only signaled + // by a key frame for now. + // TODO (marpan): Add flag to indicate restart-encoding of higher layer. + if (cm->frame_type == KEY_FRAME) { + if (cpi->oxcf.mr_encoder_id) { + // If the initial starting value of the buffer level is zero (this can + // happen because we may have not started encoding this higher stream), + // then reset it to non-zero value based on |starting_buffer_level|. + if (cpi->common.current_video_frame == 0 && cpi->buffer_level == 0) { + unsigned int i; + cpi->bits_off_target = cpi->oxcf.starting_buffer_level; + cpi->buffer_level = cpi->oxcf.starting_buffer_level; + for (i = 0; i < cpi->oxcf.number_of_layers; i++) { + LAYER_CONTEXT *lc = &cpi->layer_context[i]; + lc->bits_off_target = lc->starting_buffer_level; + lc->buffer_level = lc->starting_buffer_level; + } + } + cpi->common.current_video_frame = + low_res_frame_info->key_frame_counter_value; + } else { + low_res_frame_info->key_frame_counter_value = + cpi->common.current_video_frame; } + } + } #endif // Find the reference frame closest to the current frame. cpi->closest_reference_frame = LAST_FRAME; - if (cm->frame_type != KEY_FRAME) { + if(cm->frame_type != KEY_FRAME) { int i; MV_REFERENCE_FRAME closest_ref = INTRA_FRAME; if (cpi->ref_frame_flags & VP8_LAST_FRAME) { @@ -3624,12 +3793,12 @@ static void encode_frame_to_data_rate } else if (cpi->ref_frame_flags & VP8_ALTR_FRAME) { closest_ref = ALTREF_FRAME; } - for (i = 1; i <= 3; i++) { + for(i = 1; i <= 3; i++) { vpx_ref_frame_type_t ref_frame_type = (vpx_ref_frame_type_t) ((i == 3) ? 4 : i); if (cpi->ref_frame_flags & ref_frame_type) { if ((cm->current_video_frame - cpi->current_ref_frames[i]) < - (cm->current_video_frame - cpi->current_ref_frames[closest_ref])) { + (cm->current_video_frame - cpi->current_ref_frames[closest_ref])) { closest_ref = i; } } @@ -3656,6 +3825,8 @@ static void encode_frame_to_data_rate // Reset the zero_last counter to 0 on key frame. vpx_memset(cpi->consec_zero_last, 0, cm->mb_rows * cm->mb_cols); + vpx_memset(cpi->consec_zero_last_mvbias, 0, + (cpi->common.mb_rows * cpi->common.mb_cols)); } #if 0 @@ -4184,8 +4355,10 @@ static void encode_frame_to_data_rate else disable_segmentation(cpi); } - // Reset the consec_zero_last counter on key frame. + // Reset the zero_last counter to 0 on key frame. vpx_memset(cpi->consec_zero_last, 0, cm->mb_rows * cm->mb_cols); + vpx_memset(cpi->consec_zero_last_mvbias, 0, + (cpi->common.mb_rows * cpi->common.mb_cols)); vp8_set_quantizer(cpi, Q); } @@ -4618,6 +4791,22 @@ static void encode_frame_to_data_rate cm->frame_to_show = &cm->yv12_fb[cm->new_fb_idx]; #if CONFIG_TEMPORAL_DENOISING + // Get some measure of the amount of noise, by measuring the (partial) mse + // between source and denoised buffer, for y channel. Partial refers to + // computing the sse for a sub-sample of the frame (i.e., skip x blocks along row/column), + // and only for blocks in that set that are consecutive ZEROMV_LAST mode. + // Do this every ~8 frames, to further reduce complexity. + // TODO(marpan): Keep this for now for the case cpi->oxcf.noise_sensitivity < 4, + // should be removed in favor of the process_denoiser_mode_change() function below. + if (cpi->oxcf.noise_sensitivity > 0 && + cpi->oxcf.noise_sensitivity < 4 && + !cpi->oxcf.screen_content_mode && + cpi->frames_since_key%8 == 0 && + cm->frame_type != KEY_FRAME) { + cpi->mse_source_denoised = measure_square_diff_partial( + &cpi->denoiser.yv12_running_avg[INTRA_FRAME], cpi->Source, cpi); + } + // For the adaptive denoising mode (noise_sensitivity == 4), sample the mse // of source diff (between current and previous frame), and determine if we // should switch the denoiser mode. Sampling refers to computing the mse for @@ -4626,6 +4815,7 @@ static void encode_frame_to_data_rate // constraint on the sum diff between blocks. This process is called every // ~8 frames, to further reduce complexity. if (cpi->oxcf.noise_sensitivity == 4 && + !cpi->oxcf.screen_content_mode && cpi->frames_since_key % 8 == 0 && cm->frame_type != KEY_FRAME) { process_denoiser_mode_change(cpi); @@ -4763,6 +4953,13 @@ static void encode_frame_to_data_rate if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size) cpi->bits_off_target = cpi->oxcf.maximum_buffer_size; + // If the frame dropper is not enabled, don't let the buffer level go below + // some threshold, given here by -|maximum_buffer_size|. For now we only do + // this for screen content input. + if (cpi->drop_frames_allowed == 0 && cpi->oxcf.screen_content_mode && + cpi->bits_off_target < -cpi->oxcf.maximum_buffer_size) + cpi->bits_off_target = -cpi->oxcf.maximum_buffer_size; + /* Rolling monitors of whether we are over or underspending used to * help regulate min and Max Q in two pass. */ @@ -5237,7 +5434,26 @@ int vp8_get_compressed_data(VP8_COMP *cpi, unsigned int *frame_flags, unsigned l cpi->ref_framerate = 10000000.0 / avg_duration; } - +#if CONFIG_MULTI_RES_ENCODING + if (cpi->oxcf.mr_total_resolutions > 1) { + LOWER_RES_FRAME_INFO* low_res_frame_info = (LOWER_RES_FRAME_INFO*) + cpi->oxcf.mr_low_res_mode_info; + // Frame rate should be the same for all spatial layers in + // multi-res-encoding (simulcast), so we constrain the frame for + // higher layers to be that of lowest resolution. This is needed + // as he application may decide to skip encoding a high layer and + // then start again, in which case a big jump in time-stamps will + // be received for that high layer, which will yield an incorrect + // frame rate (from time-stamp adjustment in above calculation). + if (cpi->oxcf.mr_encoder_id) { + cpi->ref_framerate = low_res_frame_info->low_res_framerate; + } + else { + // Keep track of frame rate for lowest resolution. + low_res_frame_info->low_res_framerate = cpi->ref_framerate; + } + } +#endif if (cpi->oxcf.number_of_layers > 1) { unsigned int i; @@ -5267,8 +5483,12 @@ int vp8_get_compressed_data(VP8_COMP *cpi, unsigned int *frame_flags, unsigned l update_layer_contexts (cpi); /* Restore layer specific context & set frame rate */ - layer = cpi->oxcf.layer_id[ - cpi->temporal_pattern_counter % cpi->oxcf.periodicity]; + if (cpi->temporal_layer_id >= 0) { + layer = cpi->temporal_layer_id; + } else { + layer = cpi->oxcf.layer_id[ + cpi->temporal_pattern_counter % cpi->oxcf.periodicity]; + } restore_layer_context (cpi, layer); vp8_new_framerate(cpi, cpi->layer_context[layer].framerate); } diff --git a/vp8/encoder/onyx_int.h b/vp8/encoder/onyx_int.h index f0424e69c..b1a749c1d 100644 --- a/vp8/encoder/onyx_int.h +++ b/vp8/encoder/onyx_int.h @@ -513,10 +513,18 @@ typedef struct VP8_COMP signed char *cyclic_refresh_map; // Count on how many (consecutive) times a macroblock uses ZER0MV_LAST. unsigned char *consec_zero_last; + // Counter that is reset when a block is checked for a mode-bias against + // ZEROMV_LASTREF. + unsigned char *consec_zero_last_mvbias; // Frame counter for the temporal pattern. Counter is rest when the temporal // layers are changed dynamically (run-time change). unsigned int temporal_pattern_counter; + // Temporal layer id. + int temporal_layer_id; + + // Measure of average squared difference between source and denoised signal. + int mse_source_denoised; #if CONFIG_MULTITHREAD /* multithread data */ @@ -687,6 +695,7 @@ typedef struct VP8_COMP #endif /* The frame number of each reference frames */ unsigned int current_ref_frames[MAX_REF_FRAMES]; + // Closest reference frame to current frame. MV_REFERENCE_FRAME closest_reference_frame; struct rd_costs_struct diff --git a/vp8/encoder/pickinter.c b/vp8/encoder/pickinter.c index 9d5556dcd..9eb69324b 100644 --- a/vp8/encoder/pickinter.c +++ b/vp8/encoder/pickinter.c @@ -40,6 +40,134 @@ extern const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES]; extern int vp8_cost_mv_ref(MB_PREDICTION_MODE m, const int near_mv_ref_ct[4]); +// Fixed point implementation of a skin color classifier. Skin color +// is model by a Gaussian distribution in the CbCr color space. +// See ../../test/skin_color_detector_test.cc where the reference +// skin color classifier is defined. + +// Fixed-point skin color model parameters. +static const int skin_mean[2] = {7463, 9614}; // q6 +static const int skin_inv_cov[4] = {4107, 1663, 1663, 2157}; // q16 +static const int skin_threshold = 1570636; // q18 + +// Evaluates the Mahalanobis distance measure for the input CbCr values. +static int evaluate_skin_color_difference(int cb, int cr) +{ + const int cb_q6 = cb << 6; + const int cr_q6 = cr << 6; + const int cb_diff_q12 = (cb_q6 - skin_mean[0]) * (cb_q6 - skin_mean[0]); + const int cbcr_diff_q12 = (cb_q6 - skin_mean[0]) * (cr_q6 - skin_mean[1]); + const int cr_diff_q12 = (cr_q6 - skin_mean[1]) * (cr_q6 - skin_mean[1]); + const int cb_diff_q2 = (cb_diff_q12 + (1 << 9)) >> 10; + const int cbcr_diff_q2 = (cbcr_diff_q12 + (1 << 9)) >> 10; + const int cr_diff_q2 = (cr_diff_q12 + (1 << 9)) >> 10; + const int skin_diff = skin_inv_cov[0] * cb_diff_q2 + + skin_inv_cov[1] * cbcr_diff_q2 + + skin_inv_cov[2] * cbcr_diff_q2 + + skin_inv_cov[3] * cr_diff_q2; + return skin_diff; +} + +static int macroblock_corner_grad(unsigned char* signal, int stride, + int offsetx, int offsety, int sgnx, int sgny) +{ + int y1 = signal[offsetx * stride + offsety]; + int y2 = signal[offsetx * stride + offsety + sgny]; + int y3 = signal[(offsetx + sgnx) * stride + offsety]; + int y4 = signal[(offsetx + sgnx) * stride + offsety + sgny]; + return MAX(MAX(abs(y1 - y2), abs(y1 - y3)), abs(y1 - y4)); +} + +static int check_dot_artifact_candidate(VP8_COMP *cpi, + MACROBLOCK *x, + unsigned char *target_last, + int stride, + unsigned char* last_ref, + int mb_row, + int mb_col, + int channel) +{ + int threshold1 = 6; + int threshold2 = 3; + unsigned int max_num = (cpi->common.MBs) / 10; + int grad_last = 0; + int grad_source = 0; + int index = mb_row * cpi->common.mb_cols + mb_col; + // Threshold for #consecutive (base layer) frames using zero_last mode. + int num_frames = 30; + int shift = 15; + if (channel > 0) { + shift = 7; + } + if (cpi->oxcf.number_of_layers > 1) + { + num_frames = 20; + } + x->zero_last_dot_suppress = 0; + // Blocks on base layer frames that have been using ZEROMV_LAST repeatedly + // (i.e, at least |x| consecutive frames are candidates for increasing the + // rd adjustment for zero_last mode. + // Only allow this for at most |max_num| blocks per frame. + // Don't allow this for screen content input. + if (cpi->current_layer == 0 && + cpi->consec_zero_last_mvbias[index] > num_frames && + x->mbs_zero_last_dot_suppress < max_num && + !cpi->oxcf.screen_content_mode) + { + // If this block is checked here, label it so we don't check it again until + // ~|x| framaes later. + x->zero_last_dot_suppress = 1; + // Dot artifact is noticeable as strong gradient at corners of macroblock, + // for flat areas. As a simple detector for now, we look for a high + // corner gradient on last ref, and a smaller gradient on source. + // Check 4 corners, return if any satisfy condition. + // Top-left: + grad_last = macroblock_corner_grad(last_ref, stride, 0, 0, 1, 1); + grad_source = macroblock_corner_grad(target_last, stride, 0, 0, 1, 1); + if (grad_last >= threshold1 && grad_source <= threshold2) + { + x->mbs_zero_last_dot_suppress++; + return 1; + } + // Top-right: + grad_last = macroblock_corner_grad(last_ref, stride, 0, shift, 1, -1); + grad_source = macroblock_corner_grad(target_last, stride, 0, shift, 1, -1); + if (grad_last >= threshold1 && grad_source <= threshold2) + { + x->mbs_zero_last_dot_suppress++; + return 1; + } + // Bottom-left: + grad_last = macroblock_corner_grad(last_ref, stride, shift, 0, -1, 1); + grad_source = macroblock_corner_grad(target_last, stride, shift, 0, -1, 1); + if (grad_last >= threshold1 && grad_source <= threshold2) + { + x->mbs_zero_last_dot_suppress++; + return 1; + } + // Bottom-right: + grad_last = macroblock_corner_grad(last_ref, stride, shift, shift, -1, -1); + grad_source = macroblock_corner_grad(target_last, stride, shift, shift, -1, -1); + if (grad_last >= threshold1 && grad_source <= threshold2) + { + x->mbs_zero_last_dot_suppress++; + return 1; + } + return 0; + } + return 0; +} + +// Checks if the input yCbCr values corresponds to skin color. +static int is_skin_color(int y, int cb, int cr) +{ + if (y < 40 || y > 220) + { + return 0; + } + return (evaluate_skin_color_difference(cb, cr) < skin_threshold); +} + int vp8_skip_fractional_mv_step(MACROBLOCK *mb, BLOCK *b, BLOCKD *d, int_mv *bestmv, int_mv *ref_mv, int error_per_bit, @@ -514,10 +642,17 @@ static int evaluate_inter_mode(unsigned int* sse, int rate2, int* distortion2, #endif // Adjust rd for ZEROMV and LAST, if LAST is the closest reference frame. - if (this_mode == ZEROMV && - x->e_mbd.mode_info_context->mbmi.ref_frame == LAST_FRAME && - (denoise_aggressive || cpi->closest_reference_frame == LAST_FRAME)) { - this_rd = ((int64_t)this_rd) * rd_adj / 100; + // TODO: We should also add condition on distance of closest to current. + if(!cpi->oxcf.screen_content_mode && + this_mode == ZEROMV && + x->e_mbd.mode_info_context->mbmi.ref_frame == LAST_FRAME && + (denoise_aggressive || (cpi->closest_reference_frame == LAST_FRAME))) + { + // No adjustment if block is considered to be skin area. + if(x->is_skin) + rd_adj = 100; + + this_rd = ((int64_t)this_rd) * rd_adj / 100; } check_for_encode_breakout(*sse, x); @@ -597,6 +732,15 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, #endif int sf_improved_mv_pred = cpi->sf.improved_mv_pred; + +#if CONFIG_MULTI_RES_ENCODING + int dissim = INT_MAX; + int parent_ref_frame = 0; + int_mv parent_ref_mv; + MB_PREDICTION_MODE parent_mode = 0; + int parent_ref_valid = 0; +#endif + int_mv mvp; int near_sadidx[8] = {0, 1, 2, 3, 4, 5, 6, 7}; @@ -607,14 +751,55 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, unsigned char *plane[4][3]; int ref_frame_map[4]; int sign_bias = 0; + int dot_artifact_candidate = 0; + // For detecting dot artifact. + unsigned char* target = x->src.y_buffer; + unsigned char* target_u = x->block[16].src + *x->block[16].base_src; + unsigned char* target_v = x->block[20].src + *x->block[20].base_src; + int stride = x->src.y_stride; + int stride_uv = x->block[16].src_stride; +#if CONFIG_TEMPORAL_DENOISING + if (cpi->oxcf.noise_sensitivity) { + int uv_denoise = (cpi->oxcf.noise_sensitivity >= 2) ? 1 : 0; + target = + cpi->denoiser.yv12_running_avg[LAST_FRAME].y_buffer + recon_yoffset; + stride = cpi->denoiser.yv12_running_avg[LAST_FRAME].y_stride; + if (uv_denoise) { + target_u = + cpi->denoiser.yv12_running_avg[LAST_FRAME].u_buffer + recon_uvoffset; + target_v = + cpi->denoiser.yv12_running_avg[LAST_FRAME].v_buffer + recon_uvoffset; + stride_uv = cpi->denoiser.yv12_running_avg[LAST_FRAME].uv_stride; + } + } +#endif -#if CONFIG_MULTI_RES_ENCODING - int dissim = INT_MAX; - int parent_ref_frame = 0; - int parent_ref_valid = cpi->oxcf.mr_encoder_id && cpi->mr_low_res_mv_avail; - int_mv parent_ref_mv; - MB_PREDICTION_MODE parent_mode = 0; + get_predictor_pointers(cpi, plane, recon_yoffset, recon_uvoffset); + dot_artifact_candidate = + check_dot_artifact_candidate(cpi, x, + target, stride, + plane[LAST_FRAME][0], mb_row, mb_col, 0); + // If not found in Y channel, check UV channel. + if (!dot_artifact_candidate) { + dot_artifact_candidate = + check_dot_artifact_candidate(cpi, x, + target_u, stride_uv, + plane[LAST_FRAME][1], mb_row, mb_col, 1); + if (!dot_artifact_candidate) { + dot_artifact_candidate = + check_dot_artifact_candidate(cpi, x, + target_v, stride_uv, + plane[LAST_FRAME][2], mb_row, mb_col, 2); + } + } + +#if CONFIG_MULTI_RES_ENCODING + // |parent_ref_valid| will be set here if potentially we can do mv resue for + // this higher resol (|cpi->oxcf.mr_encoder_id| > 0) frame. + // |parent_ref_valid| may be reset depending on |parent_ref_frame| for + // the current macroblock below. + parent_ref_valid = cpi->oxcf.mr_encoder_id && cpi->mr_low_res_mv_avail; if (parent_ref_valid) { int parent_ref_flag; @@ -632,17 +817,44 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, * In this event, take the conservative approach of disabling the * lower res info for this MB. */ + parent_ref_flag = 0; + // Note availability for mv reuse is only based on last and golden. if (parent_ref_frame == LAST_FRAME) parent_ref_flag = (cpi->ref_frame_flags & VP8_LAST_FRAME); else if (parent_ref_frame == GOLDEN_FRAME) parent_ref_flag = (cpi->ref_frame_flags & VP8_GOLD_FRAME); - else if (parent_ref_frame == ALTREF_FRAME) - parent_ref_flag = (cpi->ref_frame_flags & VP8_ALTR_FRAME); //assert(!parent_ref_frame || parent_ref_flag); + + // If |parent_ref_frame| did not match either last or golden then + // shut off mv reuse. if (parent_ref_frame && !parent_ref_flag) parent_ref_valid = 0; + + // Don't do mv reuse since we want to allow for another mode besides + // ZEROMV_LAST to remove dot artifact. + if (dot_artifact_candidate) + parent_ref_valid = 0; + } +#endif + + // Check if current macroblock is in skin area. + { + const int y = x->src.y_buffer[7 * x->src.y_stride + 7]; + const int cb = x->src.u_buffer[3 * x->src.uv_stride + 3]; + const int cr = x->src.v_buffer[3 * x->src.uv_stride + 3]; + x->is_skin = 0; + if (!cpi->oxcf.screen_content_mode) + x->is_skin = is_skin_color(y, cb, cr); + } +#if CONFIG_TEMPORAL_DENOISING + if (cpi->oxcf.noise_sensitivity) { + // Under aggressive denoising mode, should we use skin map to reduce denoiser + // and ZEROMV bias? Will need to revisit the accuracy of this detection for + // very noisy input. For now keep this as is (i.e., don't turn it off). + // if (cpi->denoiser.denoiser_mode == kDenoiserOnYUVAggressive) + // x->is_skin = 0; } #endif @@ -680,8 +892,6 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, best_ref_mv.as_int = best_ref_mv_sb[sign_bias].as_int; } - get_predictor_pointers(cpi, plane, recon_yoffset, recon_uvoffset); - /* Count of the number of MBs tested so far this frame */ x->mbs_tested_so_far++; @@ -691,9 +901,13 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME; /* If the frame has big static background and current MB is in low - * motion area, its mode decision is biased to ZEROMV mode. - */ - calculate_zeromv_rd_adjustment(cpi, x, &rd_adjustment); + * motion area, its mode decision is biased to ZEROMV mode. + * No adjustment if cpu_used is <= -12 (i.e., cpi->Speed >= 12). + * At such speed settings, ZEROMV is already heavily favored. + */ + if (cpi->Speed < 12) { + calculate_zeromv_rd_adjustment(cpi, x, &rd_adjustment); + } #if CONFIG_TEMPORAL_DENOISING if (cpi->oxcf.noise_sensitivity) { @@ -702,6 +916,13 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, } #endif + if (dot_artifact_candidate) + { + // Bias against ZEROMV_LAST mode. + rd_adjustment = 150; + } + + /* if we encode a new mv this is important * find the best new motion vector */ @@ -887,14 +1108,17 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, step_param = cpi->sf.first_step + speed_adjust; #if CONFIG_MULTI_RES_ENCODING - /* If lower-res drops this frame, then higher-res encoder does - motion search without any previous knowledge. Also, since - last frame motion info is not stored, then we can not + /* If lower-res frame is not available for mv reuse (because of + frame dropping or different temporal layer pattern), then higher + resol encoder does motion search without any previous knowledge. + Also, since last frame motion info is not stored, then we can not use improved_mv_pred. */ - if (cpi->oxcf.mr_encoder_id && !parent_ref_valid) + if (cpi->oxcf.mr_encoder_id) sf_improved_mv_pred = 0; - if (parent_ref_valid && parent_ref_frame) + // Only use parent MV as predictor if this candidate reference frame + // (|this_ref_frame|) is equal to |parent_ref_frame|. + if (parent_ref_valid && (parent_ref_frame == this_ref_frame)) { /* Use parent MV as predictor. Adjust search range * accordingly. @@ -938,7 +1162,8 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, } #if CONFIG_MULTI_RES_ENCODING - if (parent_ref_valid && parent_ref_frame && dissim <= 2 && + if (parent_ref_valid && (parent_ref_frame == this_ref_frame) && + dissim <= 2 && MAX(abs(best_ref_mv.as_mv.row - parent_ref_mv.as_mv.row), abs(best_ref_mv.as_mv.col - parent_ref_mv.as_mv.col)) <= 4) { @@ -975,10 +1200,12 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, * change the behavior in lowest-resolution encoder. * Will improve it later. */ - /* Set step_param to 0 to ensure large-range motion search - when encoder drops this frame at lower-resolution. - */ - if (!parent_ref_valid) + /* Set step_param to 0 to ensure large-range motion search + * when mv reuse if not valid (i.e. |parent_ref_valid| = 0), + * or if this candidate reference frame (|this_ref_frame|) is + * not equal to |parent_ref_frame|. + */ + if (!parent_ref_valid || (parent_ref_frame != this_ref_frame)) step_param = 0; #endif bestsme = vp8_hex_search(x, b, d, &mvp_full, &d->bmi.mv, @@ -1080,7 +1307,6 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, #if CONFIG_TEMPORAL_DENOISING if (cpi->oxcf.noise_sensitivity) { - /* Store for later use by denoiser. */ // Dont' denoise with GOLDEN OR ALTREF is they are old reference // frames (greater than MAX_GF_ARF_DENOISE_RANGE frames in past). @@ -1096,7 +1322,7 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, x->e_mbd.mode_info_context->mbmi.ref_frame; } - /* Store the best NEWMV in x for later use in the denoiser. */ + // Store the best NEWMV in x for later use in the denoiser. if (x->e_mbd.mode_info_context->mbmi.mode == NEWMV && sse < best_sse && !skip_old_reference) { @@ -1184,6 +1410,8 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, if (cpi->oxcf.noise_sensitivity) { int block_index = mb_row * cpi->common.mb_cols + mb_col; + int reevaluate = 0; + int is_noisy = 0; if (x->best_sse_inter_mode == DC_PRED) { /* No best MV found. */ @@ -1193,18 +1421,52 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, x->best_reference_frame = best_mbmode.ref_frame; best_sse = best_rd_sse; } + // For non-skin blocks that have selected ZEROMV for this current frame, + // and have been selecting ZEROMV_LAST (on the base layer frame) at + // least |x~20| consecutive past frames in a row, label the block for + // possible increase in denoising strength. We also condition this + // labeling on there being significant denoising in the scene + if (cpi->oxcf.noise_sensitivity == 4) { + if (cpi->denoiser.nmse_source_diff > + 70 * cpi->denoiser.threshold_aggressive_mode / 100) + is_noisy = 1; + } else { + if (cpi->mse_source_denoised > 1000) + is_noisy = 1; + } x->increase_denoising = 0; + if (!x->is_skin && + x->best_sse_inter_mode == ZEROMV && + (x->best_reference_frame == LAST_FRAME || + x->best_reference_frame == cpi->closest_reference_frame) && + cpi->consec_zero_last[block_index] >= 20 && + is_noisy) { + x->increase_denoising = 1; + } + x->denoise_zeromv = 0; vp8_denoiser_denoise_mb(&cpi->denoiser, x, best_sse, zero_mv_sse, recon_yoffset, recon_uvoffset, &cpi->common.lf_info, mb_row, mb_col, block_index); - /* Reevaluate ZEROMV after denoising. */ - if (best_mbmode.ref_frame == INTRA_FRAME && + // Reevaluate ZEROMV after denoising: for large noise content + // (i.e., cpi->mse_source_denoised is above threshold), do this for all + // blocks that did not pick ZEROMV as best mode but are using ZEROMV + // for denoising. Otherwise, always re-evaluate for blocks that picked + // INTRA mode as best mode. + // Avoid blocks that have been biased against ZERO_LAST + // (i.e., dot artifact candidate blocks). + reevaluate = (best_mbmode.ref_frame == INTRA_FRAME) || + (best_mbmode.mode != ZEROMV && + x->denoise_zeromv && + cpi->mse_source_denoised > 2000); + if (!dot_artifact_candidate && + reevaluate && x->best_zeromv_reference_frame != INTRA_FRAME) { int this_rd = 0; int this_ref_frame = x->best_zeromv_reference_frame; + rd_adjustment = 100; rate2 = x->ref_frame_cost[this_ref_frame] + vp8_cost_mv_ref(ZEROMV, mdcounts); distortion2 = 0; @@ -1264,7 +1526,6 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, update_mvcount(x, &best_ref_mv); } - void vp8_pick_intra_mode(MACROBLOCK *x, int *rate_) { int error4x4, error16x16 = INT_MAX; diff --git a/vp8/encoder/quantize.c b/vp8/encoder/quantize.c index 2feb316b3..bd47823dd 100644 --- a/vp8/encoder/quantize.c +++ b/vp8/encoder/quantize.c @@ -535,6 +535,7 @@ void vp8_set_quantizer(struct VP8_COMP *cpi, int Q) MACROBLOCKD *mbd = &cpi->mb.e_mbd; int update = 0; int new_delta_q; + int new_uv_delta_q; cm->base_qindex = Q; /* if any of the delta_q values are changing update flag has to be set */ @@ -542,8 +543,6 @@ void vp8_set_quantizer(struct VP8_COMP *cpi, int Q) cm->y1dc_delta_q = 0; cm->y2ac_delta_q = 0; - cm->uvdc_delta_q = 0; - cm->uvac_delta_q = 0; if (Q < 4) { @@ -555,6 +554,21 @@ void vp8_set_quantizer(struct VP8_COMP *cpi, int Q) update |= cm->y2dc_delta_q != new_delta_q; cm->y2dc_delta_q = new_delta_q; + new_uv_delta_q = 0; + // For screen content, lower the q value for UV channel. For now, select + // conservative delta; same delta for dc and ac, and decrease it with lower + // Q, and set to 0 below some threshold. May want to condition this in + // future on the variance/energy in UV channel. + if (cpi->oxcf.screen_content_mode && Q > 40) { + new_uv_delta_q = -(int)(0.15 * Q); + // Check range: magnitude of delta is 4 bits. + if (new_uv_delta_q < -15) { + new_uv_delta_q = -15; + } + } + update |= cm->uvdc_delta_q != new_uv_delta_q; + cm->uvdc_delta_q = new_uv_delta_q; + cm->uvac_delta_q = new_uv_delta_q; /* Set Segment specific quatizers */ mbd->segment_feature_data[MB_LVL_ALT_Q][0] = cpi->segment_feature_data[MB_LVL_ALT_Q][0]; diff --git a/vp8/encoder/ratectrl.c b/vp8/encoder/ratectrl.c index c51650c3c..e30ad9e28 100644 --- a/vp8/encoder/ratectrl.c +++ b/vp8/encoder/ratectrl.c @@ -708,7 +708,13 @@ static void calc_pframe_target_size(VP8_COMP *cpi) Adjustment = (cpi->this_frame_target - min_frame_target); if (cpi->frames_since_golden == (cpi->current_gf_interval >> 1)) - cpi->this_frame_target += ((cpi->current_gf_interval - 1) * Adjustment); + { + Adjustment = (cpi->current_gf_interval - 1) * Adjustment; + // Limit adjustment to 10% of current target. + if (Adjustment > (10 * cpi->this_frame_target) / 100) + Adjustment = (10 * cpi->this_frame_target) / 100; + cpi->this_frame_target += Adjustment; + } else cpi->this_frame_target -= Adjustment; } diff --git a/vp8/vp8_cx_iface.c b/vp8/vp8_cx_iface.c index b1b079cb2..3426f5986 100644 --- a/vp8/vp8_cx_iface.c +++ b/vp8/vp8_cx_iface.c @@ -37,6 +37,7 @@ struct vp8_extracfg vp8e_tuning tuning; unsigned int cq_level; /* constrained quality level */ unsigned int rc_max_intra_bitrate_pct; + unsigned int screen_content_mode; }; @@ -62,6 +63,7 @@ static struct vp8_extracfg default_extracfg = { 0, /* tuning*/ 10, /* cq_level */ 0, /* rc_max_intra_bitrate_pct */ + 0, /* screen_content_mode */ }; struct vpx_codec_alg_priv @@ -79,6 +81,7 @@ struct vpx_codec_alg_priv /* pkt_list size depends on the maximum number of lagged frames allowed. */ vpx_codec_pkt_list_decl(64) pkt_list; unsigned int fixed_kf_cntr; + vpx_enc_frame_flags_t control_frame_flags; }; @@ -194,6 +197,7 @@ static vpx_codec_err_t validate_config(vpx_codec_alg_priv_t *ctx, RANGE_CHECK_HI(vp8_cfg, arnr_strength, 6); RANGE_CHECK(vp8_cfg, arnr_type, 1, 3); RANGE_CHECK(vp8_cfg, cq_level, 0, 63); + RANGE_CHECK_BOOL(vp8_cfg, screen_content_mode); if (finalize && (cfg->rc_end_usage == VPX_CQ || cfg->rc_end_usage == VPX_Q)) RANGE_CHECK(vp8_cfg, cq_level, cfg->rc_min_quantizer, cfg->rc_max_quantizer); @@ -231,7 +235,8 @@ static vpx_codec_err_t validate_config(vpx_codec_alg_priv_t *ctx, RANGE_CHECK_HI(cfg, ts_periodicity, 16); for (i=1; i<cfg->ts_number_layers; i++) - if (cfg->ts_target_bitrate[i] <= cfg->ts_target_bitrate[i-1]) + if (cfg->ts_target_bitrate[i] <= cfg->ts_target_bitrate[i-1] && + cfg->rc_target_bitrate > 0) ERROR("ts_target_bitrate entries are not strictly increasing"); RANGE_CHECK(cfg, ts_rate_decimator[cfg->ts_number_layers-1], 1, 1); @@ -397,6 +402,8 @@ static vpx_codec_err_t set_vp8e_config(VP8_CONFIG *oxcf, oxcf->tuning = vp8_cfg.tuning; + oxcf->screen_content_mode = vp8_cfg.screen_content_mode; + /* printf("Current VP8 Settings: \n"); printf("target_bandwidth: %d\n", oxcf->target_bandwidth); @@ -586,6 +593,15 @@ static vpx_codec_err_t set_rc_max_intra_bitrate_pct(vpx_codec_alg_priv_t *ctx, return update_extracfg(ctx, &extra_cfg); } +static vpx_codec_err_t set_screen_content_mode(vpx_codec_alg_priv_t *ctx, + va_list args) +{ + struct vp8_extracfg extra_cfg = ctx->vp8_cfg; + extra_cfg.screen_content_mode = + CAST(VP8E_SET_SCREEN_CONTENT_MODE, args); + return update_extracfg(ctx, &extra_cfg); +} + static vpx_codec_err_t vp8e_mr_alloc_mem(const vpx_codec_enc_cfg_t *cfg, void **mem_loc) { @@ -768,27 +784,9 @@ static void pick_quickcompress_mode(vpx_codec_alg_priv_t *ctx, } } - -static vpx_codec_err_t vp8e_encode(vpx_codec_alg_priv_t *ctx, - const vpx_image_t *img, - vpx_codec_pts_t pts, - unsigned long duration, - vpx_enc_frame_flags_t flags, - unsigned long deadline) +static vpx_codec_err_t set_reference_and_update(vpx_codec_alg_priv_t *ctx, + int flags) { - vpx_codec_err_t res = VPX_CODEC_OK; - - if (!ctx->cfg.rc_target_bitrate) - return res; - - if (img) - res = validate_img(ctx, img); - - if (!res) - res = validate_config(ctx, &ctx->cfg, &ctx->vp8_cfg, 1); - - pick_quickcompress_mode(ctx, duration, deadline); - vpx_codec_pkt_list_init(&ctx->pkt_list); /* Handle Flags */ if (((flags & VP8_EFLAG_NO_UPD_GF) && (flags & VP8_EFLAG_FORCE_GF)) @@ -838,6 +836,42 @@ static vpx_codec_err_t vp8e_encode(vpx_codec_alg_priv_t *ctx, vp8_update_entropy(ctx->cpi, 0); } + return VPX_CODEC_OK; +} + +static vpx_codec_err_t vp8e_encode(vpx_codec_alg_priv_t *ctx, + const vpx_image_t *img, + vpx_codec_pts_t pts, + unsigned long duration, + vpx_enc_frame_flags_t flags, + unsigned long deadline) +{ + vpx_codec_err_t res = VPX_CODEC_OK; + + if (!ctx->cfg.rc_target_bitrate) + return res; + + if (!ctx->cfg.rc_target_bitrate) + return res; + + if (img) + res = validate_img(ctx, img); + + if (!res) + res = validate_config(ctx, &ctx->cfg, &ctx->vp8_cfg, 1); + + pick_quickcompress_mode(ctx, duration, deadline); + vpx_codec_pkt_list_init(&ctx->pkt_list); + + // If no flags are set in the encode call, then use the frame flags as + // defined via the control function: vp8e_set_frame_flags. + if (!flags) { + flags = ctx->control_frame_flags; + } + ctx->control_frame_flags = 0; + + res = set_reference_and_update(ctx, flags); + /* Handle fixed keyframe intervals */ if (ctx->cfg.kf_mode == VPX_KF_AUTO && ctx->cfg.kf_min_dist == ctx->cfg.kf_max_dist) @@ -1140,6 +1174,25 @@ static vpx_codec_err_t vp8e_use_reference(vpx_codec_alg_priv_t *ctx, return VPX_CODEC_OK; } +static vpx_codec_err_t vp8e_set_frame_flags(vpx_codec_alg_priv_t *ctx, + va_list args) +{ + int frame_flags = va_arg(args, int); + ctx->control_frame_flags = frame_flags; + return set_reference_and_update(ctx, frame_flags); +} + +static vpx_codec_err_t vp8e_set_temporal_layer_id(vpx_codec_alg_priv_t *ctx, + va_list args) +{ + int layer_id = va_arg(args, int); + if (layer_id < 0 || layer_id >= (int)ctx->cfg.ts_number_layers) { + return VPX_CODEC_INVALID_PARAM; + } + ctx->cpi->temporal_layer_id = layer_id; + return VPX_CODEC_OK; +} + static vpx_codec_err_t vp8e_set_roi_map(vpx_codec_alg_priv_t *ctx, va_list args) { @@ -1214,6 +1267,8 @@ static vpx_codec_ctrl_fn_map_t vp8e_ctf_maps[] = {VP8E_UPD_ENTROPY, vp8e_update_entropy}, {VP8E_UPD_REFERENCE, vp8e_update_reference}, {VP8E_USE_REFERENCE, vp8e_use_reference}, + {VP8E_SET_FRAME_FLAGS, vp8e_set_frame_flags}, + {VP8E_SET_TEMPORAL_LAYER_ID, vp8e_set_temporal_layer_id}, {VP8E_SET_ROI_MAP, vp8e_set_roi_map}, {VP8E_SET_ACTIVEMAP, vp8e_set_activemap}, {VP8E_SET_SCALEMODE, vp8e_set_scalemode}, @@ -1231,6 +1286,7 @@ static vpx_codec_ctrl_fn_map_t vp8e_ctf_maps[] = {VP8E_SET_TUNING, set_tuning}, {VP8E_SET_CQ_LEVEL, set_cq_level}, {VP8E_SET_MAX_INTRA_BITRATE_PCT, set_rc_max_intra_bitrate_pct}, + {VP8E_SET_SCREEN_CONTENT_MODE, set_screen_content_mode}, { -1, NULL}, }; |