2014-03-28 21:30:28 +04:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Use of this source code is governed by a BSD-style license
|
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
|
* tree. An additional intellectual property rights grant can be found
|
|
|
|
* in the file PATENTS. All contributing project authors may
|
|
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <limits.h>
|
|
|
|
|
2014-04-19 05:27:47 +04:00
|
|
|
#include "vp9/encoder/vp9_encoder.h"
|
2014-03-28 21:30:28 +04:00
|
|
|
#include "vp9/encoder/vp9_speed_features.h"
|
2015-06-24 13:36:51 +03:00
|
|
|
#include "vp9/encoder/vp9_rdopt.h"
|
2015-09-01 00:36:35 +03:00
|
|
|
#include "vpx_dsp/vpx_dsp_common.h"
|
2015-06-24 13:36:51 +03:00
|
|
|
|
2015-10-14 12:38:49 +03:00
|
|
|
// Mesh search patters for various speed settings
|
|
|
|
static MESH_PATTERN best_quality_mesh_pattern[MAX_MESH_STEP] =
|
2015-11-17 19:20:20 +03:00
|
|
|
{{64, 4}, {28, 2}, {15, 1}, {7, 1}};
|
2015-10-14 12:38:49 +03:00
|
|
|
|
|
|
|
#define MAX_MESH_SPEED 5 // Max speed setting for mesh motion method
|
|
|
|
static MESH_PATTERN good_quality_mesh_patterns[MAX_MESH_SPEED + 1]
|
|
|
|
[MAX_MESH_STEP] =
|
2015-11-17 19:20:20 +03:00
|
|
|
{{{64, 8}, {28, 4}, {15, 1}, {7, 1}},
|
|
|
|
{{64, 8}, {28, 4}, {15, 1}, {7, 1}},
|
|
|
|
{{64, 8}, {14, 2}, {7, 1}, {7, 1}},
|
|
|
|
{{64, 16}, {24, 8}, {12, 4}, {7, 1}},
|
|
|
|
{{64, 16}, {24, 8}, {12, 4}, {7, 1}},
|
|
|
|
{{64, 16}, {24, 8}, {12, 4}, {7, 1}},
|
2015-10-14 12:38:49 +03:00
|
|
|
};
|
|
|
|
static unsigned char good_quality_max_mesh_pct[MAX_MESH_SPEED + 1] =
|
|
|
|
{50, 25, 15, 5, 1, 1};
|
2014-03-28 21:30:28 +04:00
|
|
|
|
2014-08-19 03:32:40 +04:00
|
|
|
// Intra only frames, golden frames (except alt ref overlays) and
|
|
|
|
// alt ref frames tend to be coded at a higher than ambient quality
|
|
|
|
static int frame_is_boosted(const VP9_COMP *cpi) {
|
2014-11-10 20:51:38 +03:00
|
|
|
return frame_is_kf_gf_arf(cpi) || vp9_is_upper_layer_key_frame(cpi);
|
2014-08-19 03:32:40 +04:00
|
|
|
}
|
|
|
|
|
2015-05-27 03:37:18 +03:00
|
|
|
// Sets a partition size down to which the auto partition code will always
|
|
|
|
// search (can go lower), based on the image dimensions. The logic here
|
|
|
|
// is that the extent to which ringing artefacts are offensive, depends
|
|
|
|
// partly on the screen area that over which they propogate. Propogation is
|
|
|
|
// limited by transform block size but the screen area take up by a given block
|
|
|
|
// size will be larger for a small image format stretched to full screen.
|
|
|
|
static BLOCK_SIZE set_partition_min_limit(VP9_COMMON *const cm) {
|
|
|
|
unsigned int screen_area = (cm->width * cm->height);
|
|
|
|
|
|
|
|
// Select block size based on image format size.
|
|
|
|
if (screen_area < 1280 * 720) {
|
|
|
|
// Formats smaller in area than 720P
|
|
|
|
return BLOCK_4X4;
|
|
|
|
} else if (screen_area < 1920 * 1080) {
|
|
|
|
// Format >= 720P and < 1080P
|
|
|
|
return BLOCK_8X8;
|
|
|
|
} else {
|
|
|
|
// Formats 1080P and up
|
|
|
|
return BLOCK_16X16;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-30 02:56:19 +03:00
|
|
|
static void set_good_speed_feature_framesize_dependent(VP9_COMP *cpi,
|
2014-11-10 20:51:38 +03:00
|
|
|
SPEED_FEATURES *sf,
|
|
|
|
int speed) {
|
2015-05-30 02:56:19 +03:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
|
2014-11-10 20:51:38 +03:00
|
|
|
if (speed >= 1) {
|
2015-08-18 04:19:22 +03:00
|
|
|
if (VPXMIN(cm->width, cm->height) >= 720) {
|
2014-11-10 20:51:38 +03:00
|
|
|
sf->disable_split_mask = cm->show_frame ? DISABLE_ALL_SPLIT
|
|
|
|
: DISABLE_ALL_INTER_SPLIT;
|
|
|
|
sf->partition_search_breakout_dist_thr = (1 << 23);
|
|
|
|
} else {
|
|
|
|
sf->disable_split_mask = DISABLE_COMPOUND_SPLIT;
|
|
|
|
sf->partition_search_breakout_dist_thr = (1 << 21);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (speed >= 2) {
|
2015-08-18 04:19:22 +03:00
|
|
|
if (VPXMIN(cm->width, cm->height) >= 720) {
|
2014-11-10 20:51:38 +03:00
|
|
|
sf->disable_split_mask = cm->show_frame ? DISABLE_ALL_SPLIT
|
|
|
|
: DISABLE_ALL_INTER_SPLIT;
|
|
|
|
sf->adaptive_pred_interp_filter = 0;
|
|
|
|
sf->partition_search_breakout_dist_thr = (1 << 24);
|
|
|
|
sf->partition_search_breakout_rate_thr = 120;
|
|
|
|
} else {
|
|
|
|
sf->disable_split_mask = LAST_AND_INTRA_SPLIT_ONLY;
|
|
|
|
sf->partition_search_breakout_dist_thr = (1 << 22);
|
|
|
|
sf->partition_search_breakout_rate_thr = 100;
|
|
|
|
}
|
2015-05-27 03:37:18 +03:00
|
|
|
sf->rd_auto_partition_min_limit = set_partition_min_limit(cm);
|
2014-11-10 20:51:38 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (speed >= 3) {
|
2015-08-18 04:19:22 +03:00
|
|
|
if (VPXMIN(cm->width, cm->height) >= 720) {
|
2014-11-10 20:51:38 +03:00
|
|
|
sf->disable_split_mask = DISABLE_ALL_SPLIT;
|
|
|
|
sf->schedule_mode_search = cm->base_qindex < 220 ? 1 : 0;
|
|
|
|
sf->partition_search_breakout_dist_thr = (1 << 25);
|
|
|
|
sf->partition_search_breakout_rate_thr = 200;
|
|
|
|
} else {
|
|
|
|
sf->max_intra_bsize = BLOCK_32X32;
|
|
|
|
sf->disable_split_mask = DISABLE_ALL_INTER_SPLIT;
|
|
|
|
sf->schedule_mode_search = cm->base_qindex < 175 ? 1 : 0;
|
|
|
|
sf->partition_search_breakout_dist_thr = (1 << 23);
|
|
|
|
sf->partition_search_breakout_rate_thr = 120;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-30 02:56:19 +03:00
|
|
|
// If this is a two pass clip that fits the criteria for animated or
|
|
|
|
// graphics content then reset disable_split_mask for speeds 1-4.
|
2015-06-24 13:36:51 +03:00
|
|
|
// Also if the image edge is internal to the coded area.
|
2015-05-30 02:56:19 +03:00
|
|
|
if ((speed >= 1) && (cpi->oxcf.pass == 2) &&
|
2015-06-24 13:36:51 +03:00
|
|
|
((cpi->twopass.fr_content_type == FC_GRAPHICS_ANIMATION) ||
|
|
|
|
(vp9_internal_image_edge(cpi)))) {
|
2015-05-30 02:56:19 +03:00
|
|
|
sf->disable_split_mask = DISABLE_COMPOUND_SPLIT;
|
|
|
|
}
|
|
|
|
|
2014-11-10 20:51:38 +03:00
|
|
|
if (speed >= 4) {
|
2015-08-18 04:19:22 +03:00
|
|
|
if (VPXMIN(cm->width, cm->height) >= 720) {
|
2014-11-10 20:51:38 +03:00
|
|
|
sf->partition_search_breakout_dist_thr = (1 << 26);
|
|
|
|
} else {
|
|
|
|
sf->partition_search_breakout_dist_thr = (1 << 24);
|
|
|
|
}
|
|
|
|
sf->disable_split_mask = DISABLE_ALL_SPLIT;
|
|
|
|
}
|
|
|
|
}
|
2014-08-19 03:32:40 +04:00
|
|
|
|
2014-04-04 21:52:20 +04:00
|
|
|
static void set_good_speed_feature(VP9_COMP *cpi, VP9_COMMON *cm,
|
|
|
|
SPEED_FEATURES *sf, int speed) {
|
2014-08-19 03:32:40 +04:00
|
|
|
const int boosted = frame_is_boosted(cpi);
|
|
|
|
|
2015-09-23 13:13:52 +03:00
|
|
|
sf->partition_search_breakout_dist_thr = (1 << 20);
|
|
|
|
sf->partition_search_breakout_rate_thr = 80;
|
|
|
|
sf->tx_size_search_breakout = 1;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->adaptive_rd_thresh = 1;
|
|
|
|
sf->allow_skip_recode = 1;
|
2015-09-23 13:13:52 +03:00
|
|
|
sf->less_rectangular_check = 1;
|
|
|
|
sf->use_square_partition_only = !frame_is_boosted(cpi);
|
|
|
|
sf->use_square_only_threshold = BLOCK_16X16;
|
2014-03-28 21:30:28 +04:00
|
|
|
|
|
|
|
if (speed >= 1) {
|
2015-06-24 13:36:51 +03:00
|
|
|
if ((cpi->twopass.fr_content_type == FC_GRAPHICS_ANIMATION) ||
|
|
|
|
vp9_internal_image_edge(cpi)) {
|
2015-07-16 18:20:39 +03:00
|
|
|
sf->use_square_partition_only = !frame_is_boosted(cpi);
|
2015-06-24 13:36:51 +03:00
|
|
|
} else {
|
|
|
|
sf->use_square_partition_only = !frame_is_intra_only(cm);
|
|
|
|
}
|
2015-09-23 13:13:52 +03:00
|
|
|
sf->use_square_only_threshold = BLOCK_4X4;
|
2015-07-16 18:20:39 +03:00
|
|
|
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->less_rectangular_check = 1;
|
|
|
|
|
|
|
|
sf->use_rd_breakout = 1;
|
|
|
|
sf->adaptive_motion_search = 1;
|
2014-06-12 23:35:57 +04:00
|
|
|
sf->mv.auto_mv_step_size = 1;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->adaptive_rd_thresh = 2;
|
2014-06-12 23:35:57 +04:00
|
|
|
sf->mv.subpel_iters_per_step = 1;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->mode_skip_start = 10;
|
|
|
|
sf->adaptive_pred_interp_filter = 1;
|
|
|
|
|
|
|
|
sf->recode_loop = ALLOW_RECODE_KFARFGF;
|
|
|
|
sf->intra_y_mode_mask[TX_32X32] = INTRA_DC_H_V;
|
|
|
|
sf->intra_uv_mode_mask[TX_32X32] = INTRA_DC_H_V;
|
|
|
|
sf->intra_y_mode_mask[TX_16X16] = INTRA_DC_H_V;
|
|
|
|
sf->intra_uv_mode_mask[TX_16X16] = INTRA_DC_H_V;
|
|
|
|
}
|
2014-04-04 21:52:20 +04:00
|
|
|
|
2014-03-28 21:30:28 +04:00
|
|
|
if (speed >= 2) {
|
Add early termination in transform size search
In the full-rd transform size search, we go through all transform
sizes to choose the one with best rd score. In this patch, an
early termination is added to stop the search once we see that the
smaller size won't give better rd score than the larger size. Also,
the search starts from largest transform size, then goes down to
smallest size.
A speed feature tx_size_search_breakout is added, which is turned off
at speed 0, and on for other speeds. The transform size search is
turned on at speed 1.
Borg test results:
1. At speed 1,
derf set: psnr gain: 0.618%, ssim gain: 0.377%;
stdhd set: psnr gain: 0.594%, ssim gain: 0.162%;
No noticeable speed change.
3. At speed 2,
derf set: psnr loss: 0.157%, ssim loss: 0.175%;
stdhd set: psnr loss: 0.090%, ssim loss: 0.101%;
speed gain: ~4%.
Change-Id: I22535cd2017b5e54f2a62bb6a38231aea4268b3f
2014-08-13 01:36:42 +04:00
|
|
|
sf->tx_size_search_method = frame_is_boosted(cpi) ? USE_FULL_RD
|
|
|
|
: USE_LARGESTALL;
|
|
|
|
|
2014-11-15 02:29:18 +03:00
|
|
|
// Reference masking is not supported in dynamic scaling mode.
|
|
|
|
sf->reference_masking = cpi->oxcf.resize_mode != RESIZE_DYNAMIC ? 1 : 0;
|
|
|
|
|
2014-12-05 01:53:36 +03:00
|
|
|
sf->mode_search_skip_flags = (cm->frame_type == KEY_FRAME) ? 0 :
|
|
|
|
FLAG_SKIP_INTRA_DIRMISMATCH |
|
2014-03-28 21:30:28 +04:00
|
|
|
FLAG_SKIP_INTRA_BESTINTER |
|
|
|
|
FLAG_SKIP_COMP_BESTINTRA |
|
|
|
|
FLAG_SKIP_INTRA_LOWVAR;
|
|
|
|
sf->disable_filter_search_var_thresh = 100;
|
|
|
|
sf->comp_inter_joint_search_thresh = BLOCK_SIZES;
|
2015-05-01 13:31:13 +03:00
|
|
|
sf->auto_min_max_partition_size = RELAXED_NEIGHBORING_MIN_MAX;
|
2014-09-24 23:12:25 +04:00
|
|
|
sf->allow_partition_search_skip = 1;
|
2014-03-28 21:30:28 +04:00
|
|
|
}
|
2014-04-04 21:52:20 +04:00
|
|
|
|
2014-03-28 21:30:28 +04:00
|
|
|
if (speed >= 3) {
|
2015-06-24 13:36:51 +03:00
|
|
|
sf->use_square_partition_only = !frame_is_intra_only(cm);
|
2014-04-21 23:04:59 +04:00
|
|
|
sf->tx_size_search_method = frame_is_intra_only(cm) ? USE_FULL_RD
|
|
|
|
: USE_LARGESTALL;
|
2014-09-23 22:21:36 +04:00
|
|
|
sf->mv.subpel_search_method = SUBPEL_TREE_PRUNED;
|
2014-07-22 03:22:56 +04:00
|
|
|
sf->adaptive_pred_interp_filter = 0;
|
2014-08-29 09:58:30 +04:00
|
|
|
sf->adaptive_mode_search = 1;
|
2014-08-19 03:32:40 +04:00
|
|
|
sf->cb_partition_search = !boosted;
|
2014-07-23 03:32:20 +04:00
|
|
|
sf->cb_pred_filter_search = 1;
|
2014-08-18 21:42:23 +04:00
|
|
|
sf->alt_ref_search_fp = 1;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->recode_loop = ALLOW_RECODE_KFMAXBW;
|
|
|
|
sf->adaptive_rd_thresh = 3;
|
|
|
|
sf->mode_skip_start = 6;
|
2014-08-14 04:05:57 +04:00
|
|
|
sf->intra_y_mode_mask[TX_32X32] = INTRA_DC;
|
|
|
|
sf->intra_uv_mode_mask[TX_32X32] = INTRA_DC;
|
2014-08-20 22:17:05 +04:00
|
|
|
sf->adaptive_interp_filter_search = 1;
|
2014-03-28 21:30:28 +04:00
|
|
|
}
|
2014-04-04 21:52:20 +04:00
|
|
|
|
2014-03-28 21:30:28 +04:00
|
|
|
if (speed >= 4) {
|
|
|
|
sf->use_square_partition_only = 1;
|
|
|
|
sf->tx_size_search_method = USE_LARGESTALL;
|
2014-09-10 07:07:11 +04:00
|
|
|
sf->mv.search_method = BIGDIA;
|
2014-10-07 13:48:08 +04:00
|
|
|
sf->mv.subpel_search_method = SUBPEL_TREE_PRUNED_MORE;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->adaptive_rd_thresh = 4;
|
2014-12-05 01:53:36 +03:00
|
|
|
if (cm->frame_type != KEY_FRAME)
|
|
|
|
sf->mode_search_skip_flags |= FLAG_EARLY_TERMINATE;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->disable_filter_search_var_thresh = 200;
|
|
|
|
sf->use_lp32x32fdct = 1;
|
2014-08-13 21:38:21 +04:00
|
|
|
sf->use_fast_coef_updates = ONE_LOOP_REDUCED;
|
|
|
|
sf->use_fast_coef_costing = 1;
|
2014-09-23 23:14:51 +04:00
|
|
|
sf->motion_field_mode_search = !boosted;
|
Rework partition search skip scheme
This commit enables the encoder to skip split partition search if
the bigger block size has all non-zero quantized coefficients in low
frequency area and the total rate cost is below a certain threshold.
It logarithmatically scales the rate threshold according to the
current block size. For speed 3, the compression performance loss:
derf -0.093%
stdhd -0.066%
Local experiments show 4% - 20% encoding speed-up for speed 3.
blue_sky_1080p, 1500 kbps
51051 b/f, 35.891 dB, 67236 ms ->
50554 b/f, 35.857 dB, 59270 ms (12% speed-up)
old_town_cross_720p, 1500 kbps
14431 b/f, 36.249 dB, 57687 ms ->
14108 b/f, 36.172 dB, 46586 ms (19% speed-up)
pedestrian_area_1080p, 1500 kbps
50812 b/f, 40.124 dB, 100439 ms ->
50755 b/f, 40.118 dB, 96549 ms (4% speed-up)
mobile_calendar_720p, 1000 kbps
10352 b/f, 35.055 dB, 51837 ms ->
10172 b/f, 35.003 dB, 44076 ms (15% speed-up)
Change-Id: I412e34db49060775b3b89ba1738522317c3239c8
2014-10-03 04:49:00 +04:00
|
|
|
sf->partition_search_breakout_rate_thr = 300;
|
2014-03-28 21:30:28 +04:00
|
|
|
}
|
2014-04-04 21:52:20 +04:00
|
|
|
|
2014-03-28 21:30:28 +04:00
|
|
|
if (speed >= 5) {
|
2014-04-04 21:52:20 +04:00
|
|
|
int i;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->optimize_coefficients = 0;
|
2014-06-12 23:35:57 +04:00
|
|
|
sf->mv.search_method = HEX;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->disable_filter_search_var_thresh = 500;
|
2014-04-04 21:52:20 +04:00
|
|
|
for (i = 0; i < TX_SIZES; ++i) {
|
2014-05-29 23:11:02 +04:00
|
|
|
sf->intra_y_mode_mask[i] = INTRA_DC;
|
|
|
|
sf->intra_uv_mode_mask[i] = INTRA_DC;
|
2014-03-28 21:30:28 +04:00
|
|
|
}
|
2014-10-21 01:41:20 +04:00
|
|
|
sf->partition_search_breakout_rate_thr = 500;
|
2014-07-02 00:02:05 +04:00
|
|
|
sf->mv.reduce_first_step_size = 1;
|
2015-08-01 01:50:17 +03:00
|
|
|
sf->simple_model_rd_from_var = 1;
|
2014-07-02 00:02:05 +04:00
|
|
|
}
|
2014-03-28 21:30:28 +04:00
|
|
|
}
|
|
|
|
|
2014-11-10 20:51:38 +03:00
|
|
|
static void set_rt_speed_feature_framesize_dependent(VP9_COMP *cpi,
|
|
|
|
SPEED_FEATURES *sf, int speed) {
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
|
|
|
|
if (speed >= 1) {
|
2015-08-18 04:19:22 +03:00
|
|
|
if (VPXMIN(cm->width, cm->height) >= 720) {
|
2014-11-10 20:51:38 +03:00
|
|
|
sf->disable_split_mask = cm->show_frame ? DISABLE_ALL_SPLIT
|
|
|
|
: DISABLE_ALL_INTER_SPLIT;
|
|
|
|
} else {
|
|
|
|
sf->disable_split_mask = DISABLE_COMPOUND_SPLIT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (speed >= 2) {
|
2015-08-18 04:19:22 +03:00
|
|
|
if (VPXMIN(cm->width, cm->height) >= 720) {
|
2014-11-10 20:51:38 +03:00
|
|
|
sf->disable_split_mask = cm->show_frame ? DISABLE_ALL_SPLIT
|
|
|
|
: DISABLE_ALL_INTER_SPLIT;
|
|
|
|
} else {
|
|
|
|
sf->disable_split_mask = LAST_AND_INTRA_SPLIT_ONLY;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (speed >= 5) {
|
2015-08-18 04:19:22 +03:00
|
|
|
if (VPXMIN(cm->width, cm->height) >= 720) {
|
2014-11-10 20:51:38 +03:00
|
|
|
sf->partition_search_breakout_dist_thr = (1 << 25);
|
|
|
|
} else {
|
|
|
|
sf->partition_search_breakout_dist_thr = (1 << 23);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (speed >= 7) {
|
2015-08-18 04:19:22 +03:00
|
|
|
sf->encode_breakout_thresh = (VPXMIN(cm->width, cm->height) >= 720) ?
|
2014-11-10 20:51:38 +03:00
|
|
|
800 : 300;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-23 02:27:35 +04:00
|
|
|
static void set_rt_speed_feature(VP9_COMP *cpi, SPEED_FEATURES *sf,
|
2014-07-19 02:10:56 +04:00
|
|
|
int speed, vp9e_tune_content content) {
|
2014-05-23 02:27:35 +04:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
2014-08-22 04:40:07 +04:00
|
|
|
const int is_keyframe = cm->frame_type == KEY_FRAME;
|
|
|
|
const int frames_since_key = is_keyframe ? 0 : cpi->rc.frames_since_key;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->static_segmentation = 0;
|
|
|
|
sf->adaptive_rd_thresh = 1;
|
|
|
|
sf->use_fast_coef_costing = 1;
|
2015-10-14 12:38:49 +03:00
|
|
|
sf->allow_exhaustive_searches = 0;
|
|
|
|
sf->exhaustive_searches_thresh = INT_MAX;
|
2014-03-28 21:30:28 +04:00
|
|
|
|
2014-05-29 22:11:50 +04:00
|
|
|
if (speed >= 1) {
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->use_square_partition_only = !frame_is_intra_only(cm);
|
|
|
|
sf->less_rectangular_check = 1;
|
2014-04-04 21:52:20 +04:00
|
|
|
sf->tx_size_search_method = frame_is_intra_only(cm) ? USE_FULL_RD
|
|
|
|
: USE_LARGESTALL;
|
2014-03-28 21:30:28 +04:00
|
|
|
|
|
|
|
sf->use_rd_breakout = 1;
|
2014-08-14 02:07:16 +04:00
|
|
|
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->adaptive_motion_search = 1;
|
|
|
|
sf->adaptive_pred_interp_filter = 1;
|
2014-06-12 23:35:57 +04:00
|
|
|
sf->mv.auto_mv_step_size = 1;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->adaptive_rd_thresh = 2;
|
|
|
|
sf->intra_y_mode_mask[TX_32X32] = INTRA_DC_H_V;
|
|
|
|
sf->intra_uv_mode_mask[TX_32X32] = INTRA_DC_H_V;
|
|
|
|
sf->intra_uv_mode_mask[TX_16X16] = INTRA_DC_H_V;
|
|
|
|
}
|
2014-04-04 21:52:20 +04:00
|
|
|
|
2014-03-28 21:30:28 +04:00
|
|
|
if (speed >= 2) {
|
2014-12-05 01:53:36 +03:00
|
|
|
sf->mode_search_skip_flags = (cm->frame_type == KEY_FRAME) ? 0 :
|
|
|
|
FLAG_SKIP_INTRA_DIRMISMATCH |
|
2014-04-04 21:52:20 +04:00
|
|
|
FLAG_SKIP_INTRA_BESTINTER |
|
|
|
|
FLAG_SKIP_COMP_BESTINTRA |
|
|
|
|
FLAG_SKIP_INTRA_LOWVAR;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->adaptive_pred_interp_filter = 2;
|
2014-11-15 02:29:18 +03:00
|
|
|
|
2015-06-05 03:05:11 +03:00
|
|
|
// Disable reference masking if using spatial scaling since
|
|
|
|
// pred_mv_sad will not be set (since vp9_mv_pred will not
|
|
|
|
// be called).
|
|
|
|
// TODO(marpan/agrange): Fix this condition.
|
|
|
|
sf->reference_masking = (cpi->oxcf.resize_mode != RESIZE_DYNAMIC &&
|
|
|
|
cpi->svc.number_spatial_layers == 1) ? 1 : 0;
|
2014-11-15 02:29:18 +03:00
|
|
|
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->disable_filter_search_var_thresh = 50;
|
|
|
|
sf->comp_inter_joint_search_thresh = BLOCK_SIZES;
|
|
|
|
sf->auto_min_max_partition_size = RELAXED_NEIGHBORING_MIN_MAX;
|
2014-06-17 18:31:24 +04:00
|
|
|
sf->lf_motion_threshold = LOW_MOTION_THRESHOLD;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->adjust_partitioning_from_last_frame = 1;
|
|
|
|
sf->last_partitioning_redo_frequency = 3;
|
|
|
|
sf->use_lp32x32fdct = 1;
|
|
|
|
sf->mode_skip_start = 11;
|
|
|
|
sf->intra_y_mode_mask[TX_16X16] = INTRA_DC_H_V;
|
|
|
|
}
|
2014-04-04 21:52:20 +04:00
|
|
|
|
2014-03-28 21:30:28 +04:00
|
|
|
if (speed >= 3) {
|
|
|
|
sf->use_square_partition_only = 1;
|
|
|
|
sf->disable_filter_search_var_thresh = 100;
|
|
|
|
sf->use_uv_intra_rd_estimate = 1;
|
|
|
|
sf->skip_encode_sb = 1;
|
2014-06-12 23:35:57 +04:00
|
|
|
sf->mv.subpel_iters_per_step = 1;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->adaptive_rd_thresh = 4;
|
|
|
|
sf->mode_skip_start = 6;
|
|
|
|
sf->allow_skip_recode = 0;
|
|
|
|
sf->optimize_coefficients = 0;
|
|
|
|
sf->disable_split_mask = DISABLE_ALL_SPLIT;
|
|
|
|
sf->lpf_pick = LPF_PICK_FROM_Q;
|
|
|
|
}
|
2014-04-04 21:52:20 +04:00
|
|
|
|
2014-03-27 03:15:00 +04:00
|
|
|
if (speed >= 4) {
|
2014-03-28 21:30:28 +04:00
|
|
|
int i;
|
|
|
|
sf->last_partitioning_redo_frequency = 4;
|
|
|
|
sf->adaptive_rd_thresh = 5;
|
|
|
|
sf->use_fast_coef_costing = 0;
|
|
|
|
sf->auto_min_max_partition_size = STRICT_NEIGHBORING_MIN_MAX;
|
|
|
|
sf->adjust_partitioning_from_last_frame =
|
|
|
|
cm->last_frame_type != cm->frame_type || (0 ==
|
2014-05-23 02:27:35 +04:00
|
|
|
(frames_since_key + 1) % sf->last_partitioning_redo_frequency);
|
2014-06-12 23:35:57 +04:00
|
|
|
sf->mv.subpel_force_stop = 1;
|
2014-03-28 21:30:28 +04:00
|
|
|
for (i = 0; i < TX_SIZES; i++) {
|
|
|
|
sf->intra_y_mode_mask[i] = INTRA_DC_H_V;
|
2014-05-29 23:11:02 +04:00
|
|
|
sf->intra_uv_mode_mask[i] = INTRA_DC;
|
2014-03-28 21:30:28 +04:00
|
|
|
}
|
2014-05-29 23:11:02 +04:00
|
|
|
sf->intra_y_mode_mask[TX_32X32] = INTRA_DC;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->frame_parameter_update = 0;
|
2014-06-12 23:35:57 +04:00
|
|
|
sf->mv.search_method = FAST_HEX;
|
2014-10-08 03:36:14 +04:00
|
|
|
|
2014-05-29 23:25:41 +04:00
|
|
|
sf->inter_mode_mask[BLOCK_32X32] = INTER_NEAREST_NEAR_NEW;
|
|
|
|
sf->inter_mode_mask[BLOCK_32X64] = INTER_NEAREST;
|
|
|
|
sf->inter_mode_mask[BLOCK_64X32] = INTER_NEAREST;
|
|
|
|
sf->inter_mode_mask[BLOCK_64X64] = INTER_NEAREST;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->max_intra_bsize = BLOCK_32X32;
|
|
|
|
sf->allow_skip_recode = 1;
|
|
|
|
}
|
2014-04-04 21:52:20 +04:00
|
|
|
|
2014-03-27 03:15:00 +04:00
|
|
|
if (speed >= 5) {
|
2014-08-22 04:40:07 +04:00
|
|
|
sf->use_quant_fp = !is_keyframe;
|
|
|
|
sf->auto_min_max_partition_size = is_keyframe ? RELAXED_NEIGHBORING_MIN_MAX
|
|
|
|
: STRICT_NEIGHBORING_MIN_MAX;
|
2014-11-20 20:24:50 +03:00
|
|
|
sf->default_max_partition_size = BLOCK_32X32;
|
|
|
|
sf->default_min_partition_size = BLOCK_8X8;
|
2014-08-22 04:40:07 +04:00
|
|
|
sf->force_frame_boost = is_keyframe ||
|
|
|
|
(frames_since_key % (sf->last_partitioning_redo_frequency << 1) == 1);
|
|
|
|
sf->max_delta_qindex = is_keyframe ? 20 : 15;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->partition_search_type = REFERENCE_PARTITION;
|
2015-03-26 00:40:33 +03:00
|
|
|
sf->use_nonrd_pick_mode = 1;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->allow_skip_recode = 0;
|
2014-10-15 22:37:20 +04:00
|
|
|
sf->inter_mode_mask[BLOCK_32X32] = INTER_NEAREST_NEW_ZERO;
|
|
|
|
sf->inter_mode_mask[BLOCK_32X64] = INTER_NEAREST_NEW_ZERO;
|
|
|
|
sf->inter_mode_mask[BLOCK_64X32] = INTER_NEAREST_NEW_ZERO;
|
|
|
|
sf->inter_mode_mask[BLOCK_64X64] = INTER_NEAREST_NEW_ZERO;
|
Enable mode search threshold update in non-RD coding mode
Adaptively adjust the mode thresholds after each mode search round
to skip checking less likely selected modes. Local tests indicate
5% - 10% speed-up in speed -5 and -6. Average coding performance
loss is -1.055%.
speed -5
vidyo1 720p 1000 kbps
16533 b/f, 40.851 dB, 12607 ms -> 16556 b/f, 40.796 dB, 11831 ms
nik 720p 1000 kbps
33229 b/f, 39.127 dB, 11468 ms -> 33235 b/f, 39.131 dB, 10919 ms
speed -6
vidyo1 720p 1000 kbps
16549 b/f, 40.268 dB, 10138 ms -> 16538 b/f, 40.212 dB, 8456 ms
nik 720p 1000 kbps
33271 b/f, 38.433 dB, 7886 ms -> 33279 b/f, 38.416 dB, 7843 ms
Change-Id: I2c2963f1ce4ed9c1cf233b5b2c880b682e1c1e8b
2014-10-29 00:50:10 +03:00
|
|
|
sf->adaptive_rd_thresh = 2;
|
Hybrid partition search for rtc coding mode
This commit re-designs the recursive partition search scheme in
rtc speed -5. It first checks if the current block is under cyclic
refresh mode. If so, apply recursive partition search. Otherwise,
perform sub-sampled pixel based partition selection. When the
pre-selection finds the partition size should be 32x32 or above,
use the partition size directly. Otherwise, apply partition search
at nearby levels around the preset partition size.
It is enabled in speed -5. The compression performance of rtc
speed -5 is improved by 9.4%. Speed wise, the run-time goes slower
from 1% to 10%.
nik_720p, 1000 kbps
33220 b/f, 38.977 dB, 10109 ms -> 33200 b/f, 39.119 dB, 10210 ms
vidyo1_720p, 1000 kbps
16536 b/f, 40.495 dB, 10119 ms -> 16536 b/f, 40.827 dB, 11287 ms
Change-Id: I65adba352e3adc03bae50854ddaea1b421653c6c
2014-10-17 19:58:28 +04:00
|
|
|
// This feature is only enabled when partition search is disabled.
|
|
|
|
sf->reuse_inter_pred_sby = 1;
|
2014-10-15 23:18:48 +04:00
|
|
|
sf->partition_search_breakout_rate_thr = 200;
|
2014-12-03 05:16:06 +03:00
|
|
|
sf->coeff_prob_appx_step = 4;
|
|
|
|
sf->use_fast_coef_updates = is_keyframe ? TWO_LOOP : ONE_LOOP_REDUCED;
|
2014-12-05 01:53:36 +03:00
|
|
|
sf->mode_search_skip_flags = FLAG_SKIP_INTRA_DIRMISMATCH;
|
2015-05-15 21:08:24 +03:00
|
|
|
sf->tx_size_search_method = is_keyframe ? USE_LARGESTALL : USE_TX_8X8;
|
2015-08-01 01:50:17 +03:00
|
|
|
sf->simple_model_rd_from_var = 1;
|
2014-12-03 05:16:06 +03:00
|
|
|
|
2014-10-25 02:57:48 +04:00
|
|
|
if (!is_keyframe) {
|
|
|
|
int i;
|
|
|
|
if (content == VP9E_CONTENT_SCREEN) {
|
2015-04-30 21:39:02 +03:00
|
|
|
for (i = 0; i < BLOCK_SIZES; ++i)
|
|
|
|
sf->intra_y_mode_bsize_mask[i] = INTRA_DC_TM_H_V;
|
2014-10-25 02:57:48 +04:00
|
|
|
} else {
|
2015-04-30 21:39:02 +03:00
|
|
|
for (i = 0; i < BLOCK_SIZES; ++i)
|
2015-12-18 04:13:01 +03:00
|
|
|
if (i > BLOCK_16X16)
|
2015-04-30 21:39:02 +03:00
|
|
|
sf->intra_y_mode_bsize_mask[i] = INTRA_DC;
|
|
|
|
else
|
|
|
|
// Use H and V intra mode for block sizes <= 16X16.
|
|
|
|
sf->intra_y_mode_bsize_mask[i] = INTRA_DC_H_V;
|
2014-10-25 02:57:48 +04:00
|
|
|
}
|
|
|
|
}
|
2014-03-28 21:30:28 +04:00
|
|
|
}
|
2014-04-04 21:52:20 +04:00
|
|
|
|
2014-03-27 03:15:00 +04:00
|
|
|
if (speed >= 6) {
|
2014-10-08 03:36:14 +04:00
|
|
|
sf->partition_search_type = VAR_BASED_PARTITION;
|
2014-11-20 22:28:00 +03:00
|
|
|
// Turn on this to use non-RD key frame coding mode.
|
2014-11-13 01:51:49 +03:00
|
|
|
sf->use_nonrd_pick_mode = 1;
|
2014-10-08 03:36:14 +04:00
|
|
|
sf->mv.search_method = NSTEP;
|
2014-07-02 00:02:05 +04:00
|
|
|
sf->mv.reduce_first_step_size = 1;
|
2014-11-08 04:50:55 +03:00
|
|
|
sf->skip_encode_sb = 0;
|
2014-03-28 21:30:28 +04:00
|
|
|
}
|
2014-08-22 04:40:07 +04:00
|
|
|
|
2014-03-27 03:15:00 +04:00
|
|
|
if (speed >= 7) {
|
2014-11-01 03:27:54 +03:00
|
|
|
sf->adaptive_rd_thresh = 3;
|
2014-07-09 01:52:47 +04:00
|
|
|
sf->mv.search_method = FAST_DIAMOND;
|
2014-07-01 21:52:17 +04:00
|
|
|
sf->mv.fullpel_search_step_param = 10;
|
2015-08-11 21:06:08 +03:00
|
|
|
if (cpi->svc.number_temporal_layers > 2 &&
|
|
|
|
cpi->svc.temporal_layer_id == 0) {
|
|
|
|
sf->mv.search_method = NSTEP;
|
|
|
|
sf->mv.fullpel_search_step_param = 6;
|
|
|
|
}
|
2014-06-27 21:05:24 +04:00
|
|
|
}
|
2014-12-18 02:15:33 +03:00
|
|
|
if (speed >= 8) {
|
2014-11-01 03:27:54 +03:00
|
|
|
sf->adaptive_rd_thresh = 4;
|
2014-07-16 02:29:52 +04:00
|
|
|
sf->mv.subpel_force_stop = 2;
|
2015-02-02 19:05:31 +03:00
|
|
|
sf->lpf_pick = LPF_PICK_MINIMAL_LPF;
|
2014-07-16 02:29:52 +04:00
|
|
|
}
|
2014-03-28 21:30:28 +04:00
|
|
|
}
|
|
|
|
|
2014-11-10 20:51:38 +03:00
|
|
|
void vp9_set_speed_features_framesize_dependent(VP9_COMP *cpi) {
|
|
|
|
SPEED_FEATURES *const sf = &cpi->sf;
|
|
|
|
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
|
|
|
|
RD_OPT *const rd = &cpi->rd;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (oxcf->mode == REALTIME) {
|
|
|
|
set_rt_speed_feature_framesize_dependent(cpi, sf, oxcf->speed);
|
|
|
|
} else if (oxcf->mode == GOOD) {
|
2015-05-30 02:56:19 +03:00
|
|
|
set_good_speed_feature_framesize_dependent(cpi, sf, oxcf->speed);
|
2014-11-10 20:51:38 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (sf->disable_split_mask == DISABLE_ALL_SPLIT) {
|
|
|
|
sf->adaptive_pred_interp_filter = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cpi->encode_breakout && oxcf->mode == REALTIME &&
|
|
|
|
sf->encode_breakout_thresh > cpi->encode_breakout) {
|
|
|
|
cpi->encode_breakout = sf->encode_breakout_thresh;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check for masked out split cases.
|
|
|
|
for (i = 0; i < MAX_REFS; ++i) {
|
|
|
|
if (sf->disable_split_mask & (1 << i)) {
|
|
|
|
rd->thresh_mult_sub8x8[i] = INT_MAX;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void vp9_set_speed_features_framesize_independent(VP9_COMP *cpi) {
|
2014-03-28 21:30:28 +04:00
|
|
|
SPEED_FEATURES *const sf = &cpi->sf;
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
2014-11-21 22:11:06 +03:00
|
|
|
MACROBLOCK *const x = &cpi->td.mb;
|
2014-04-18 22:01:36 +04:00
|
|
|
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
|
2014-03-28 21:30:28 +04:00
|
|
|
int i;
|
|
|
|
|
|
|
|
// best quality defaults
|
|
|
|
sf->frame_parameter_update = 1;
|
2014-06-12 23:35:57 +04:00
|
|
|
sf->mv.search_method = NSTEP;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->recode_loop = ALLOW_RECODE;
|
2014-06-12 23:35:57 +04:00
|
|
|
sf->mv.subpel_search_method = SUBPEL_TREE;
|
|
|
|
sf->mv.subpel_iters_per_step = 2;
|
|
|
|
sf->mv.subpel_force_stop = 0;
|
2014-06-03 23:52:49 +04:00
|
|
|
sf->optimize_coefficients = !is_lossless_requested(&cpi->oxcf);
|
2014-06-12 23:35:57 +04:00
|
|
|
sf->mv.reduce_first_step_size = 0;
|
2014-12-03 05:16:06 +03:00
|
|
|
sf->coeff_prob_appx_step = 1;
|
2014-06-12 23:35:57 +04:00
|
|
|
sf->mv.auto_mv_step_size = 0;
|
2014-07-01 21:52:17 +04:00
|
|
|
sf->mv.fullpel_search_step_param = 6;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->comp_inter_joint_search_thresh = BLOCK_4X4;
|
|
|
|
sf->tx_size_search_method = USE_FULL_RD;
|
|
|
|
sf->use_lp32x32fdct = 0;
|
|
|
|
sf->adaptive_motion_search = 0;
|
|
|
|
sf->adaptive_pred_interp_filter = 0;
|
2014-08-29 09:58:30 +04:00
|
|
|
sf->adaptive_mode_search = 0;
|
2014-07-23 03:32:20 +04:00
|
|
|
sf->cb_pred_filter_search = 0;
|
2014-07-29 20:50:03 +04:00
|
|
|
sf->cb_partition_search = 0;
|
Enable motion field based mode seach skip
This commit allows the encoder to check the above and left neighbor
blocks' reference frames and motion vectors. If they are all
consistent, skip checking the NEARMV and ZEROMV modes. This is
enabled in speed 3. The coding performance is improved:
pedestrian area 1080p at 2000 kbps,
from 74773 b/f, 41.101 dB, 198064 ms
to 74795 b/f, 41.099 dB, 193078 ms
park joy 1080p at 15000 kbps,
from 290727 b/f, 30.640 dB, 609113 ms
to 290558 b/f, 30.630 dB, 592815 ms
Overall compression performance of speed 3 is changed
derf -0.171%
stdhd -0.168%
Change-Id: I8d47dd543a5f90d7a1c583f74035b926b6704b95
2014-08-12 04:48:14 +04:00
|
|
|
sf->motion_field_mode_search = 0;
|
2014-08-18 21:42:23 +04:00
|
|
|
sf->alt_ref_search_fp = 0;
|
2014-07-02 03:10:44 +04:00
|
|
|
sf->use_quant_fp = 0;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->reference_masking = 0;
|
|
|
|
sf->partition_search_type = SEARCH_PARTITION;
|
|
|
|
sf->less_rectangular_check = 0;
|
|
|
|
sf->use_square_partition_only = 0;
|
2015-09-23 13:13:52 +03:00
|
|
|
sf->use_square_only_threshold = BLOCK_SIZES;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->auto_min_max_partition_size = NOT_IN_USE;
|
2015-05-01 15:45:43 +03:00
|
|
|
sf->rd_auto_partition_min_limit = BLOCK_4X4;
|
2014-11-20 20:24:50 +03:00
|
|
|
sf->default_max_partition_size = BLOCK_64X64;
|
|
|
|
sf->default_min_partition_size = BLOCK_4X4;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->adjust_partitioning_from_last_frame = 0;
|
|
|
|
sf->last_partitioning_redo_frequency = 4;
|
|
|
|
sf->disable_split_mask = 0;
|
|
|
|
sf->mode_search_skip_flags = 0;
|
2014-04-04 02:49:03 +04:00
|
|
|
sf->force_frame_boost = 0;
|
2014-04-02 02:52:38 +04:00
|
|
|
sf->max_delta_qindex = 0;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->disable_filter_search_var_thresh = 0;
|
2014-08-20 22:17:05 +04:00
|
|
|
sf->adaptive_interp_filter_search = 0;
|
2014-09-24 23:12:25 +04:00
|
|
|
sf->allow_partition_search_skip = 0;
|
2014-08-20 22:17:05 +04:00
|
|
|
|
2014-03-28 21:30:28 +04:00
|
|
|
for (i = 0; i < TX_SIZES; i++) {
|
2014-05-29 23:11:02 +04:00
|
|
|
sf->intra_y_mode_mask[i] = INTRA_ALL;
|
|
|
|
sf->intra_uv_mode_mask[i] = INTRA_ALL;
|
2014-03-28 21:30:28 +04:00
|
|
|
}
|
|
|
|
sf->use_rd_breakout = 0;
|
|
|
|
sf->skip_encode_sb = 0;
|
|
|
|
sf->use_uv_intra_rd_estimate = 0;
|
|
|
|
sf->allow_skip_recode = 0;
|
|
|
|
sf->lpf_pick = LPF_PICK_FROM_FULL_IMAGE;
|
2014-04-04 21:31:34 +04:00
|
|
|
sf->use_fast_coef_updates = TWO_LOOP;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->use_fast_coef_costing = 0;
|
|
|
|
sf->mode_skip_start = MAX_MODES; // Mode index at which mode skip mask set
|
Adaptive mode search scheduling
This commit enables an adaptive mode search order scheduling scheme
in the rate-distortion optimization. It changes the compression
performance by -0.433% and -0.420% for derf and stdhd respectively.
It provides speed improvement for speed 3:
bus CIF 1000 kbps
24590 b/f, 35.513 dB, 7864 ms ->
24696 b/f, 35.491 dB, 7408 ms (6% speed-up)
stockholm 720p 1000 kbps
8983 b/f, 35.078 dB, 65698 ms ->
8962 b/f, 35.054 dB, 60298 ms (8%)
old_town_cross 720p 1000 kbps
11804 b/f, 35.666 dB, 62492 ms ->
11778 b/f, 35.609 dB, 56040 ms (10%)
blue_sky 1080p 1500 kbps
57173 b/f, 36.179 dB, 77879 ms ->
57199 b/f, 36.131 dB, 69821 ms (10%)
pedestrian_area 1080p 2000 kbps
74241 b/f, 41.105 dB, 144031 ms ->
74271 b/f, 41.091 dB, 133614 ms (8%)
Change-Id: Iaad28cbc99399030fc5f9951eb5aa7fa633f320e
2014-09-19 00:37:20 +04:00
|
|
|
sf->schedule_mode_search = 0;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->use_nonrd_pick_mode = 0;
|
|
|
|
for (i = 0; i < BLOCK_SIZES; ++i)
|
2014-05-29 23:25:41 +04:00
|
|
|
sf->inter_mode_mask[i] = INTER_ALL;
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->max_intra_bsize = BLOCK_64X64;
|
2014-06-20 21:11:34 +04:00
|
|
|
sf->reuse_inter_pred_sby = 0;
|
2014-03-28 21:30:28 +04:00
|
|
|
// This setting only takes effect when partition_search_type is set
|
|
|
|
// to FIXED_PARTITION.
|
|
|
|
sf->always_this_block_size = BLOCK_16X16;
|
2014-04-02 04:32:20 +04:00
|
|
|
sf->search_type_check_frequency = 50;
|
2014-06-28 04:44:32 +04:00
|
|
|
sf->encode_breakout_thresh = 0;
|
2014-11-01 03:27:54 +03:00
|
|
|
// Recode loop tolerance %.
|
2014-03-31 19:58:39 +04:00
|
|
|
sf->recode_tolerance = 25;
|
2014-07-17 01:28:51 +04:00
|
|
|
sf->default_interp_filter = SWITCHABLE;
|
2015-07-30 23:52:02 +03:00
|
|
|
sf->simple_model_rd_from_var = 0;
|
2014-03-31 19:58:39 +04:00
|
|
|
|
2015-11-17 19:20:20 +03:00
|
|
|
// Some speed-up features even for best quality as minimal impact on quality.
|
|
|
|
sf->adaptive_rd_thresh = 1;
|
|
|
|
sf->tx_size_search_breakout = 1;
|
|
|
|
sf->partition_search_breakout_dist_thr = (1 << 19);
|
|
|
|
sf->partition_search_breakout_rate_thr = 80;
|
|
|
|
|
2014-08-21 22:30:52 +04:00
|
|
|
if (oxcf->mode == REALTIME)
|
2014-08-09 03:29:24 +04:00
|
|
|
set_rt_speed_feature(cpi, sf, oxcf->speed, oxcf->content);
|
2014-08-21 22:30:52 +04:00
|
|
|
else if (oxcf->mode == GOOD)
|
|
|
|
set_good_speed_feature(cpi, cm, sf, oxcf->speed);
|
2014-03-28 21:30:28 +04:00
|
|
|
|
2014-08-09 03:29:24 +04:00
|
|
|
cpi->full_search_sad = vp9_full_search_sad;
|
2015-10-14 12:38:49 +03:00
|
|
|
cpi->diamond_search_sad = vp9_diamond_search_sad;
|
|
|
|
|
|
|
|
sf->allow_exhaustive_searches = 1;
|
|
|
|
if (oxcf->mode == BEST) {
|
|
|
|
if (cpi->twopass.fr_content_type == FC_GRAPHICS_ANIMATION)
|
|
|
|
sf->exhaustive_searches_thresh = (1 << 20);
|
|
|
|
else
|
|
|
|
sf->exhaustive_searches_thresh = (1 << 21);
|
|
|
|
sf->max_exaustive_pct = 100;
|
|
|
|
for (i = 0; i < MAX_MESH_STEP; ++i) {
|
|
|
|
sf->mesh_patterns[i].range = best_quality_mesh_pattern[i].range;
|
|
|
|
sf->mesh_patterns[i].interval = best_quality_mesh_pattern[i].interval;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
int speed = (oxcf->speed > MAX_MESH_SPEED) ? MAX_MESH_SPEED : oxcf->speed;
|
|
|
|
if (cpi->twopass.fr_content_type == FC_GRAPHICS_ANIMATION)
|
|
|
|
sf->exhaustive_searches_thresh = (1 << 22);
|
|
|
|
else
|
|
|
|
sf->exhaustive_searches_thresh = (1 << 23);
|
|
|
|
sf->max_exaustive_pct = good_quality_max_mesh_pct[speed];
|
|
|
|
if (speed > 0)
|
|
|
|
sf->exhaustive_searches_thresh = sf->exhaustive_searches_thresh << 1;
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_MESH_STEP; ++i) {
|
|
|
|
sf->mesh_patterns[i].range =
|
|
|
|
good_quality_mesh_patterns[speed][i].range;
|
|
|
|
sf->mesh_patterns[i].interval =
|
|
|
|
good_quality_mesh_patterns[speed][i].interval;
|
|
|
|
}
|
|
|
|
}
|
2014-08-09 03:29:24 +04:00
|
|
|
|
2014-03-28 21:30:28 +04:00
|
|
|
// Slow quant, dct and trellis not worthwhile for first pass
|
|
|
|
// so make sure they are always turned off.
|
2014-08-09 01:27:34 +04:00
|
|
|
if (oxcf->pass == 1)
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->optimize_coefficients = 0;
|
|
|
|
|
|
|
|
// No recode for 1 pass.
|
2014-08-09 01:27:34 +04:00
|
|
|
if (oxcf->pass == 0) {
|
2014-03-28 21:30:28 +04:00
|
|
|
sf->recode_loop = DISALLOW_RECODE;
|
|
|
|
sf->optimize_coefficients = 0;
|
|
|
|
}
|
|
|
|
|
2014-06-12 23:35:57 +04:00
|
|
|
if (sf->mv.subpel_search_method == SUBPEL_TREE) {
|
2014-03-28 21:30:28 +04:00
|
|
|
cpi->find_fractional_mv_step = vp9_find_best_sub_pixel_tree;
|
2014-08-28 01:06:30 +04:00
|
|
|
} else if (sf->mv.subpel_search_method == SUBPEL_TREE_PRUNED) {
|
|
|
|
cpi->find_fractional_mv_step = vp9_find_best_sub_pixel_tree_pruned;
|
2014-09-25 00:25:34 +04:00
|
|
|
} else if (sf->mv.subpel_search_method == SUBPEL_TREE_PRUNED_MORE) {
|
|
|
|
cpi->find_fractional_mv_step = vp9_find_best_sub_pixel_tree_pruned_more;
|
2014-10-07 13:48:08 +04:00
|
|
|
} else if (sf->mv.subpel_search_method == SUBPEL_TREE_PRUNED_EVENMORE) {
|
|
|
|
cpi->find_fractional_mv_step = vp9_find_best_sub_pixel_tree_pruned_evenmore;
|
2014-03-28 21:30:28 +04:00
|
|
|
}
|
|
|
|
|
2014-11-20 20:24:50 +03:00
|
|
|
x->optimize = sf->optimize_coefficients == 1 && oxcf->pass != 1;
|
|
|
|
|
|
|
|
x->min_partition_size = sf->default_min_partition_size;
|
|
|
|
x->max_partition_size = sf->default_max_partition_size;
|
2014-03-28 21:30:28 +04:00
|
|
|
|
2014-04-04 02:49:03 +04:00
|
|
|
if (!cpi->oxcf.frame_periodic_boost) {
|
|
|
|
sf->max_delta_qindex = 0;
|
|
|
|
}
|
2014-03-28 21:30:28 +04:00
|
|
|
}
|