Home | History | Annotate | Download | only in encoder
      1 /*
      2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
      3  *
      4  *  Use of this source code is governed by a BSD-style license
      5  *  that can be found in the LICENSE file in the root of the source
      6  *  tree. An additional intellectual property rights grant can be found
      7  *  in the file PATENTS.  All contributing project authors may
      8  *  be found in the AUTHORS file in the root of the source tree.
      9  */
     10 
     11 #ifndef VP9_ENCODER_VP9_SPEED_FEATURES_H_
     12 #define VP9_ENCODER_VP9_SPEED_FEATURES_H_
     13 
     14 #include "vp9/common/vp9_enums.h"
     15 
     16 #ifdef __cplusplus
     17 extern "C" {
     18 #endif
     19 
     20 enum {
     21   INTRA_ALL = (1 << DC_PRED) | (1 << V_PRED) | (1 << H_PRED) | (1 << D45_PRED) |
     22               (1 << D135_PRED) | (1 << D117_PRED) | (1 << D153_PRED) |
     23               (1 << D207_PRED) | (1 << D63_PRED) | (1 << TM_PRED),
     24   INTRA_DC = (1 << DC_PRED),
     25   INTRA_DC_TM = (1 << DC_PRED) | (1 << TM_PRED),
     26   INTRA_DC_H_V = (1 << DC_PRED) | (1 << V_PRED) | (1 << H_PRED),
     27   INTRA_DC_TM_H_V =
     28       (1 << DC_PRED) | (1 << TM_PRED) | (1 << V_PRED) | (1 << H_PRED)
     29 };
     30 
     31 enum {
     32   INTER_ALL = (1 << NEARESTMV) | (1 << NEARMV) | (1 << ZEROMV) | (1 << NEWMV),
     33   INTER_NEAREST = (1 << NEARESTMV),
     34   INTER_NEAREST_NEW = (1 << NEARESTMV) | (1 << NEWMV),
     35   INTER_NEAREST_ZERO = (1 << NEARESTMV) | (1 << ZEROMV),
     36   INTER_NEAREST_NEW_ZERO = (1 << NEARESTMV) | (1 << ZEROMV) | (1 << NEWMV),
     37   INTER_NEAREST_NEAR_NEW = (1 << NEARESTMV) | (1 << NEARMV) | (1 << NEWMV),
     38   INTER_NEAREST_NEAR_ZERO = (1 << NEARESTMV) | (1 << NEARMV) | (1 << ZEROMV),
     39 };
     40 
     41 enum {
     42   DISABLE_ALL_INTER_SPLIT = (1 << THR_COMP_GA) | (1 << THR_COMP_LA) |
     43                             (1 << THR_ALTR) | (1 << THR_GOLD) | (1 << THR_LAST),
     44 
     45   DISABLE_ALL_SPLIT = (1 << THR_INTRA) | DISABLE_ALL_INTER_SPLIT,
     46 
     47   DISABLE_COMPOUND_SPLIT = (1 << THR_COMP_GA) | (1 << THR_COMP_LA),
     48 
     49   LAST_AND_INTRA_SPLIT_ONLY = (1 << THR_COMP_GA) | (1 << THR_COMP_LA) |
     50                               (1 << THR_ALTR) | (1 << THR_GOLD)
     51 };
     52 
     53 typedef enum {
     54   DIAMOND = 0,
     55   NSTEP = 1,
     56   HEX = 2,
     57   BIGDIA = 3,
     58   SQUARE = 4,
     59   FAST_HEX = 5,
     60   FAST_DIAMOND = 6
     61 } SEARCH_METHODS;
     62 
     63 typedef enum {
     64   // No recode.
     65   DISALLOW_RECODE = 0,
     66   // Allow recode for KF and exceeding maximum frame bandwidth.
     67   ALLOW_RECODE_KFMAXBW = 1,
     68   // Allow recode only for KF/ARF/GF frames.
     69   ALLOW_RECODE_KFARFGF = 2,
     70   // Allow recode for ARF/GF/KF and first normal frame in each group.
     71   ALLOW_RECODE_FIRST = 3,
     72   // Allow recode for all frames based on bitrate constraints.
     73   ALLOW_RECODE = 4,
     74 } RECODE_LOOP_TYPE;
     75 
     76 typedef enum {
     77   SUBPEL_TREE = 0,
     78   SUBPEL_TREE_PRUNED = 1,           // Prunes 1/2-pel searches
     79   SUBPEL_TREE_PRUNED_MORE = 2,      // Prunes 1/2-pel searches more aggressively
     80   SUBPEL_TREE_PRUNED_EVENMORE = 3,  // Prunes 1/2- and 1/4-pel searches
     81   // Other methods to come
     82 } SUBPEL_SEARCH_METHODS;
     83 
     84 typedef enum {
     85   NO_MOTION_THRESHOLD = 0,
     86   LOW_MOTION_THRESHOLD = 7
     87 } MOTION_THRESHOLD;
     88 
     89 typedef enum {
     90   USE_FULL_RD = 0,
     91   USE_LARGESTALL,
     92   USE_TX_8X8
     93 } TX_SIZE_SEARCH_METHOD;
     94 
     95 typedef enum {
     96   NOT_IN_USE = 0,
     97   RELAXED_NEIGHBORING_MIN_MAX = 1,
     98   STRICT_NEIGHBORING_MIN_MAX = 2
     99 } AUTO_MIN_MAX_MODE;
    100 
    101 typedef enum {
    102   // Try the full image with different values.
    103   LPF_PICK_FROM_FULL_IMAGE,
    104   // Try a small portion of the image with different values.
    105   LPF_PICK_FROM_SUBIMAGE,
    106   // Estimate the level based on quantizer and frame type
    107   LPF_PICK_FROM_Q,
    108   // Pick 0 to disable LPF if LPF was enabled last frame
    109   LPF_PICK_MINIMAL_LPF
    110 } LPF_PICK_METHOD;
    111 
    112 typedef enum {
    113   // Terminate search early based on distortion so far compared to
    114   // qp step, distortion in the neighborhood of the frame, etc.
    115   FLAG_EARLY_TERMINATE = 1 << 0,
    116 
    117   // Skips comp inter modes if the best so far is an intra mode.
    118   FLAG_SKIP_COMP_BESTINTRA = 1 << 1,
    119 
    120   // Skips oblique intra modes if the best so far is an inter mode.
    121   FLAG_SKIP_INTRA_BESTINTER = 1 << 3,
    122 
    123   // Skips oblique intra modes  at angles 27, 63, 117, 153 if the best
    124   // intra so far is not one of the neighboring directions.
    125   FLAG_SKIP_INTRA_DIRMISMATCH = 1 << 4,
    126 
    127   // Skips intra modes other than DC_PRED if the source variance is small
    128   FLAG_SKIP_INTRA_LOWVAR = 1 << 5,
    129 } MODE_SEARCH_SKIP_LOGIC;
    130 
    131 typedef enum {
    132   FLAG_SKIP_EIGHTTAP = 1 << EIGHTTAP,
    133   FLAG_SKIP_EIGHTTAP_SMOOTH = 1 << EIGHTTAP_SMOOTH,
    134   FLAG_SKIP_EIGHTTAP_SHARP = 1 << EIGHTTAP_SHARP,
    135 } INTERP_FILTER_MASK;
    136 
    137 typedef enum {
    138   // Search partitions using RD/NONRD criterion
    139   SEARCH_PARTITION,
    140 
    141   // Always use a fixed size partition
    142   FIXED_PARTITION,
    143 
    144   REFERENCE_PARTITION,
    145 
    146   // Use an arbitrary partitioning scheme based on source variance within
    147   // a 64X64 SB
    148   VAR_BASED_PARTITION,
    149 
    150   // Use non-fixed partitions based on source variance
    151   SOURCE_VAR_BASED_PARTITION
    152 } PARTITION_SEARCH_TYPE;
    153 
    154 typedef enum {
    155   // Does a dry run to see if any of the contexts need to be updated or not,
    156   // before the final run.
    157   TWO_LOOP = 0,
    158 
    159   // No dry run, also only half the coef contexts and bands are updated.
    160   // The rest are not updated at all.
    161   ONE_LOOP_REDUCED = 1
    162 } FAST_COEFF_UPDATE;
    163 
    164 typedef struct MV_SPEED_FEATURES {
    165   // Motion search method (Diamond, NSTEP, Hex, Big Diamond, Square, etc).
    166   SEARCH_METHODS search_method;
    167 
    168   // This parameter controls which step in the n-step process we start at.
    169   // It's changed adaptively based on circumstances.
    170   int reduce_first_step_size;
    171 
    172   // If this is set to 1, we limit the motion search range to 2 times the
    173   // largest motion vector found in the last frame.
    174   int auto_mv_step_size;
    175 
    176   // Subpel_search_method can only be subpel_tree which does a subpixel
    177   // logarithmic search that keeps stepping at 1/2 pixel units until
    178   // you stop getting a gain, and then goes on to 1/4 and repeats
    179   // the same process. Along the way it skips many diagonals.
    180   SUBPEL_SEARCH_METHODS subpel_search_method;
    181 
    182   // Maximum number of steps in logarithmic subpel search before giving up.
    183   int subpel_iters_per_step;
    184 
    185   // Control when to stop subpel search:
    186   // 0: Full subpel search.
    187   // 1: Stop at quarter pixel.
    188   // 2: Stop at half pixel.
    189   // 3: Stop at full pixel.
    190   int subpel_force_stop;
    191 
    192   // This variable sets the step_param used in full pel motion search.
    193   int fullpel_search_step_param;
    194 } MV_SPEED_FEATURES;
    195 
    196 typedef struct PARTITION_SEARCH_BREAKOUT_THR {
    197   int64_t dist;
    198   int rate;
    199 } PARTITION_SEARCH_BREAKOUT_THR;
    200 
    201 #define MAX_MESH_STEP 4
    202 
    203 typedef struct MESH_PATTERN {
    204   int range;
    205   int interval;
    206 } MESH_PATTERN;
    207 
    208 typedef struct SPEED_FEATURES {
    209   MV_SPEED_FEATURES mv;
    210 
    211   // Frame level coding parameter update
    212   int frame_parameter_update;
    213 
    214   RECODE_LOOP_TYPE recode_loop;
    215 
    216   // Trellis (dynamic programming) optimization of quantized values (+1, 0).
    217   int optimize_coefficients;
    218 
    219   // Always set to 0. If on it enables 0 cost background transmission
    220   // (except for the initial transmission of the segmentation). The feature is
    221   // disabled because the addition of very large block sizes make the
    222   // backgrounds very to cheap to encode, and the segmentation we have
    223   // adds overhead.
    224   int static_segmentation;
    225 
    226   // If 1 we iterate finding a best reference for 2 ref frames together - via
    227   // a log search that iterates 4 times (check around mv for last for best
    228   // error of combined predictor then check around mv for alt). If 0 we
    229   // we just use the best motion vector found for each frame by itself.
    230   BLOCK_SIZE comp_inter_joint_search_thresh;
    231 
    232   // This variable is used to cap the maximum number of times we skip testing a
    233   // mode to be evaluated. A high value means we will be faster.
    234   // Turned off when (row_mt_bit_exact == 1 && adaptive_rd_thresh_row_mt == 0).
    235   int adaptive_rd_thresh;
    236 
    237   // Flag to use adaptive_rd_thresh when row-mt it enabled, only for non-rd
    238   // pickmode.
    239   int adaptive_rd_thresh_row_mt;
    240 
    241   // Enables skipping the reconstruction step (idct, recon) in the
    242   // intermediate steps assuming the last frame didn't have too many intra
    243   // blocks and the q is less than a threshold.
    244   int skip_encode_sb;
    245   int skip_encode_frame;
    246   // Speed feature to allow or disallow skipping of recode at block
    247   // level within a frame.
    248   int allow_skip_recode;
    249 
    250   // Coefficient probability model approximation step size
    251   int coeff_prob_appx_step;
    252 
    253   // Enable uniform quantizer followed by trellis coefficient optimization
    254   int allow_quant_coeff_opt;
    255   double quant_opt_thresh;
    256 
    257   // Enable asymptotic closed-loop encoding decision for key frame and
    258   // alternate reference frames.
    259   int allow_acl;
    260 
    261   // Use transform domain distortion. Use pixel domain distortion in speed 0
    262   // and certain situations in higher speed to improve the RD model precision.
    263   int allow_txfm_domain_distortion;
    264   double tx_domain_thresh;
    265 
    266   // The threshold is to determine how slow the motino is, it is used when
    267   // use_lastframe_partitioning is set to LAST_FRAME_PARTITION_LOW_MOTION
    268   MOTION_THRESHOLD lf_motion_threshold;
    269 
    270   // Determine which method we use to determine transform size. We can choose
    271   // between options like full rd, largest for prediction size, largest
    272   // for intra and model coefs for the rest.
    273   TX_SIZE_SEARCH_METHOD tx_size_search_method;
    274 
    275   // Low precision 32x32 fdct keeps everything in 16 bits and thus is less
    276   // precise but significantly faster than the non lp version.
    277   int use_lp32x32fdct;
    278 
    279   // After looking at the first set of modes (set by index here), skip
    280   // checking modes for reference frames that don't match the reference frame
    281   // of the best so far.
    282   int mode_skip_start;
    283 
    284   // TODO(JBB): Remove this.
    285   int reference_masking;
    286 
    287   PARTITION_SEARCH_TYPE partition_search_type;
    288 
    289   // Used if partition_search_type = FIXED_SIZE_PARTITION
    290   BLOCK_SIZE always_this_block_size;
    291 
    292   // Skip rectangular partition test when partition type none gives better
    293   // rd than partition type split.
    294   int less_rectangular_check;
    295 
    296   // Disable testing non square partitions. (eg 16x32)
    297   int use_square_partition_only;
    298   BLOCK_SIZE use_square_only_threshold;
    299 
    300   // Sets min and max partition sizes for this 64x64 region based on the
    301   // same 64x64 in last encoded frame, and the left and above neighbor.
    302   AUTO_MIN_MAX_MODE auto_min_max_partition_size;
    303   // Ensures the rd based auto partition search will always
    304   // go down at least to the specified level.
    305   BLOCK_SIZE rd_auto_partition_min_limit;
    306 
    307   // Min and max partition size we enable (block_size) as per auto
    308   // min max, but also used by adjust partitioning, and pick_partitioning.
    309   BLOCK_SIZE default_min_partition_size;
    310   BLOCK_SIZE default_max_partition_size;
    311 
    312   // Whether or not we allow partitions one smaller or one greater than the last
    313   // frame's partitioning. Only used if use_lastframe_partitioning is set.
    314   int adjust_partitioning_from_last_frame;
    315 
    316   // How frequently we re do the partitioning from scratch. Only used if
    317   // use_lastframe_partitioning is set.
    318   int last_partitioning_redo_frequency;
    319 
    320   // Disables sub 8x8 blocksizes in different scenarios: Choices are to disable
    321   // it always, to allow it for only Last frame and Intra, disable it for all
    322   // inter modes or to enable it always.
    323   int disable_split_mask;
    324 
    325   // TODO(jingning): combine the related motion search speed features
    326   // This allows us to use motion search at other sizes as a starting
    327   // point for this motion search and limits the search range around it.
    328   int adaptive_motion_search;
    329 
    330   // Threshold for allowing exhaistive motion search.
    331   int exhaustive_searches_thresh;
    332 
    333   // Pattern to be used for any exhaustive mesh searches.
    334   MESH_PATTERN mesh_patterns[MAX_MESH_STEP];
    335 
    336   int schedule_mode_search;
    337 
    338   // Allows sub 8x8 modes to use the prediction filter that was determined
    339   // best for 8x8 mode. If set to 0 we always re check all the filters for
    340   // sizes less than 8x8, 1 means we check all filter modes if no 8x8 filter
    341   // was selected, and 2 means we use 8 tap if no 8x8 filter mode was selected.
    342   int adaptive_pred_interp_filter;
    343 
    344   // Adaptive prediction mode search
    345   int adaptive_mode_search;
    346 
    347   // Chessboard pattern prediction filter type search
    348   int cb_pred_filter_search;
    349 
    350   int cb_partition_search;
    351 
    352   int motion_field_mode_search;
    353 
    354   int alt_ref_search_fp;
    355 
    356   // Fast quantization process path
    357   int use_quant_fp;
    358 
    359   // Use finer quantizer in every other few frames that run variable block
    360   // partition type search.
    361   int force_frame_boost;
    362 
    363   // Maximally allowed base quantization index fluctuation.
    364   int max_delta_qindex;
    365 
    366   // Implements various heuristics to skip searching modes
    367   // The heuristics selected are based on  flags
    368   // defined in the MODE_SEARCH_SKIP_HEURISTICS enum
    369   unsigned int mode_search_skip_flags;
    370 
    371   // A source variance threshold below which filter search is disabled
    372   // Choose a very large value (UINT_MAX) to use 8-tap always
    373   unsigned int disable_filter_search_var_thresh;
    374 
    375   // These bit masks allow you to enable or disable intra modes for each
    376   // transform size separately.
    377   int intra_y_mode_mask[TX_SIZES];
    378   int intra_uv_mode_mask[TX_SIZES];
    379 
    380   // These bit masks allow you to enable or disable intra modes for each
    381   // prediction block size separately.
    382   int intra_y_mode_bsize_mask[BLOCK_SIZES];
    383 
    384   // This variable enables an early break out of mode testing if the model for
    385   // rd built from the prediction signal indicates a value that's much
    386   // higher than the best rd we've seen so far.
    387   int use_rd_breakout;
    388 
    389   // This enables us to use an estimate for intra rd based on dc mode rather
    390   // than choosing an actual uv mode in the stage of encoding before the actual
    391   // final encode.
    392   int use_uv_intra_rd_estimate;
    393 
    394   // This feature controls how the loop filter level is determined.
    395   LPF_PICK_METHOD lpf_pick;
    396 
    397   // This feature limits the number of coefficients updates we actually do
    398   // by only looking at counts from 1/2 the bands.
    399   FAST_COEFF_UPDATE use_fast_coef_updates;
    400 
    401   // This flag controls the use of non-RD mode decision.
    402   int use_nonrd_pick_mode;
    403 
    404   // A binary mask indicating if NEARESTMV, NEARMV, ZEROMV, NEWMV
    405   // modes are used in order from LSB to MSB for each BLOCK_SIZE.
    406   int inter_mode_mask[BLOCK_SIZES];
    407 
    408   // This feature controls whether we do the expensive context update and
    409   // calculation in the rd coefficient costing loop.
    410   int use_fast_coef_costing;
    411 
    412   // This feature controls the tolerence vs target used in deciding whether to
    413   // recode a frame. It has no meaning if recode is disabled.
    414   int recode_tolerance_low;
    415   int recode_tolerance_high;
    416 
    417   // This variable controls the maximum block size where intra blocks can be
    418   // used in inter frames.
    419   // TODO(aconverse): Fold this into one of the other many mode skips
    420   BLOCK_SIZE max_intra_bsize;
    421 
    422   // The frequency that we check if SOURCE_VAR_BASED_PARTITION or
    423   // FIXED_PARTITION search type should be used.
    424   int search_type_check_frequency;
    425 
    426   // When partition is pre-set, the inter prediction result from pick_inter_mode
    427   // can be reused in final block encoding process. It is enabled only for real-
    428   // time mode speed 6.
    429   int reuse_inter_pred_sby;
    430 
    431   // This variable sets the encode_breakout threshold. Currently, it is only
    432   // enabled in real time mode.
    433   int encode_breakout_thresh;
    434 
    435   // default interp filter choice
    436   INTERP_FILTER default_interp_filter;
    437 
    438   // Early termination in transform size search, which only applies while
    439   // tx_size_search_method is USE_FULL_RD.
    440   int tx_size_search_breakout;
    441 
    442   // adaptive interp_filter search to allow skip of certain filter types.
    443   int adaptive_interp_filter_search;
    444 
    445   // mask for skip evaluation of certain interp_filter type.
    446   INTERP_FILTER_MASK interp_filter_search_mask;
    447 
    448   // Partition search early breakout thresholds.
    449   PARTITION_SEARCH_BREAKOUT_THR partition_search_breakout_thr;
    450 
    451   // Machine-learning based partition search early termination
    452   int ml_partition_search_early_termination;
    453 
    454   // Allow skipping partition search for still image frame
    455   int allow_partition_search_skip;
    456 
    457   // Fast approximation of vp9_model_rd_from_var_lapndz
    458   int simple_model_rd_from_var;
    459 
    460   // Skip a number of expensive mode evaluations for blocks with zero source
    461   // variance.
    462   int short_circuit_flat_blocks;
    463 
    464   // Skip a number of expensive mode evaluations for blocks with very low
    465   // temporal variance. If the low temporal variance flag is set for a block,
    466   // do the following:
    467   // 1: Skip all golden modes and ALL INTRA for bsize >= 32x32.
    468   // 2: Skip golden non-zeromv and newmv-last for bsize >= 16x16, skip ALL
    469   // INTRA for bsize >= 32x32 and vert/horz INTRA for bsize 16x16, 16x32 and
    470   // 32x16.
    471   // 3: Same as (2), but also skip golden zeromv.
    472   int short_circuit_low_temp_var;
    473 
    474   // Limits the rd-threshold update for early exit for the newmv-last mode,
    475   // for non-rd mode.
    476   int limit_newmv_early_exit;
    477 
    478   // Adds a bias against golden reference, for non-rd mode.
    479   int bias_golden;
    480 
    481   // Bias to use base mv and skip 1/4 subpel search when use base mv in
    482   // enhancement layer.
    483   int base_mv_aggressive;
    484 
    485   // Global flag to enable partition copy from the previous frame.
    486   int copy_partition_flag;
    487 
    488   // Compute the source sad for every superblock of the frame,
    489   // prior to encoding the frame, to be used to bypass some encoder decisions.
    490   int use_source_sad;
    491 
    492   int use_simple_block_yrd;
    493 
    494   // If source sad of superblock is high (> adapt_partition_thresh), will switch
    495   // from VARIANCE_PARTITION to REFERENCE_PARTITION (which selects partition
    496   // based on the nonrd-pickmode).
    497   int adapt_partition_source_sad;
    498   int adapt_partition_thresh;
    499 
    500   // Enable use of alt-refs in 1 pass VBR.
    501   int use_altref_onepass;
    502 
    503   // Enable use of compound prediction, for nonrd_pickmode with nonzero lag.
    504   int use_compound_nonrd_pickmode;
    505 
    506   // Always use nonrd_pick_intra for all block sizes on keyframes.
    507   int nonrd_keyframe;
    508 
    509   // For SVC: enables use of partition from lower spatial resolution.
    510   int svc_use_lowres_part;
    511 } SPEED_FEATURES;
    512 
    513 struct VP9_COMP;
    514 
    515 void vp9_set_speed_features_framesize_independent(struct VP9_COMP *cpi);
    516 void vp9_set_speed_features_framesize_dependent(struct VP9_COMP *cpi);
    517 
    518 #ifdef __cplusplus
    519 }  // extern "C"
    520 #endif
    521 
    522 #endif  // VP9_ENCODER_VP9_SPEED_FEATURES_H_
    523