Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1 | /* |
Urvang Joshi | 8a02d76 | 2016-07-28 15:51:12 -0700 | [diff] [blame] | 2 | * Copyright (c) 2016, Alliance for Open Media. All rights reserved |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3 | * |
Urvang Joshi | 8a02d76 | 2016-07-28 15:51:12 -0700 | [diff] [blame] | 4 | * This source code is subject to the terms of the BSD 2 Clause License and |
| 5 | * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License |
| 6 | * was not distributed with this source code in the LICENSE file, you can |
| 7 | * obtain it at www.aomedia.org/license/software. If the Alliance for Open |
| 8 | * Media Patent License 1.0 was not distributed with this source code in the |
| 9 | * PATENTS file, you can obtain it at www.aomedia.org/license/patent. |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 10 | */ |
| 11 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 12 | #ifndef AV1_ENCODER_ENCODER_H_ |
| 13 | #define AV1_ENCODER_ENCODER_H_ |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 14 | |
| 15 | #include <stdio.h> |
| 16 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 17 | #include "./aom_config.h" |
| 18 | #include "aom/aomcx.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 19 | |
| 20 | #include "av1/common/alloccommon.h" |
| 21 | #include "av1/common/entropymode.h" |
| 22 | #include "av1/common/thread_common.h" |
| 23 | #include "av1/common/onyxc_int.h" |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 24 | #include "av1/common/resize.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 25 | #include "av1/encoder/aq_cyclicrefresh.h" |
| 26 | #if CONFIG_ANS |
Alex Converse | eb780e7 | 2016-12-13 12:46:41 -0800 | [diff] [blame] | 27 | #include "aom_dsp/ans.h" |
Alex Converse | 1ac1ae7 | 2016-09-17 15:11:16 -0700 | [diff] [blame] | 28 | #include "aom_dsp/buf_ans.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 29 | #endif |
Tom Finegan | 17ce8b1 | 2017-02-08 12:46:31 -0800 | [diff] [blame] | 30 | #include "av1/encoder/av1_quantize.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 31 | #include "av1/encoder/context_tree.h" |
| 32 | #include "av1/encoder/encodemb.h" |
| 33 | #include "av1/encoder/firstpass.h" |
| 34 | #include "av1/encoder/lookahead.h" |
| 35 | #include "av1/encoder/mbgraph.h" |
| 36 | #include "av1/encoder/mcomp.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 37 | #include "av1/encoder/ratectrl.h" |
| 38 | #include "av1/encoder/rd.h" |
| 39 | #include "av1/encoder/speed_features.h" |
| 40 | #include "av1/encoder/tokenize.h" |
Rostislav Pehlivanov | 002e7b7 | 2017-02-15 19:45:54 +0000 | [diff] [blame] | 41 | #if CONFIG_XIPHRC |
| 42 | #include "av1/encoder/ratectrl_xiph.h" |
| 43 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 44 | |
| 45 | #if CONFIG_INTERNAL_STATS |
| 46 | #include "aom_dsp/ssim.h" |
| 47 | #endif |
| 48 | #include "aom_dsp/variance.h" |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 49 | #include "aom/internal/aom_codec_internal.h" |
| 50 | #include "aom_util/aom_thread.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 51 | |
| 52 | #ifdef __cplusplus |
| 53 | extern "C" { |
| 54 | #endif |
| 55 | |
| 56 | typedef struct { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 57 | int nmv_vec_cost[NMV_CONTEXTS][MV_JOINTS]; |
| 58 | int nmv_costs[NMV_CONTEXTS][2][MV_VALS]; |
| 59 | int nmv_costs_hp[NMV_CONTEXTS][2][MV_VALS]; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 60 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 61 | // 0 = Intra, Last, GF, ARF |
| 62 | signed char last_ref_lf_deltas[TOTAL_REFS_PER_FRAME]; |
| 63 | // 0 = ZERO_MV, MV |
| 64 | signed char last_mode_lf_deltas[MAX_MODE_LF_DELTAS]; |
| 65 | |
| 66 | FRAME_CONTEXT fc; |
| 67 | } CODING_CONTEXT; |
| 68 | |
| 69 | typedef enum { |
| 70 | // regular inter frame |
| 71 | REGULAR_FRAME = 0, |
| 72 | // alternate reference frame |
| 73 | ARF_FRAME = 1, |
| 74 | // overlay frame |
| 75 | OVERLAY_FRAME = 2, |
| 76 | // golden frame |
| 77 | GLD_FRAME = 3, |
| 78 | #if CONFIG_EXT_REFS |
| 79 | // backward reference frame |
| 80 | BRF_FRAME = 4, |
| 81 | // extra alternate reference frame |
| 82 | EXT_ARF_FRAME = 5 |
| 83 | #endif |
| 84 | } FRAME_CONTEXT_INDEX; |
| 85 | |
| 86 | typedef enum { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 87 | NORMAL = 0, |
| 88 | FOURFIVE = 1, |
| 89 | THREEFIVE = 2, |
| 90 | ONETWO = 3 |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 91 | } AOM_SCALING; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 92 | |
| 93 | typedef enum { |
| 94 | // Good Quality Fast Encoding. The encoder balances quality with the amount of |
| 95 | // time it takes to encode the output. Speed setting controls how fast. |
Thomas Daede | 8082614 | 2017-03-20 15:44:24 -0700 | [diff] [blame] | 96 | GOOD |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 97 | } MODE; |
| 98 | |
| 99 | typedef enum { |
| 100 | FRAMEFLAGS_KEY = 1 << 0, |
| 101 | FRAMEFLAGS_GOLDEN = 1 << 1, |
| 102 | #if CONFIG_EXT_REFS |
| 103 | FRAMEFLAGS_BWDREF = 1 << 2, |
| 104 | FRAMEFLAGS_ALTREF = 1 << 3, |
| 105 | #else |
| 106 | FRAMEFLAGS_ALTREF = 1 << 2, |
| 107 | #endif // CONFIG_EXT_REFS |
| 108 | } FRAMETYPE_FLAGS; |
| 109 | |
| 110 | typedef enum { |
| 111 | NO_AQ = 0, |
| 112 | VARIANCE_AQ = 1, |
| 113 | COMPLEXITY_AQ = 2, |
| 114 | CYCLIC_REFRESH_AQ = 3, |
Fangwen Fu | 6160df2 | 2017-04-24 09:45:51 -0700 | [diff] [blame] | 115 | #if CONFIG_DELTA_Q && !CONFIG_EXT_DELTA_Q |
Arild Fuldseth | 0744116 | 2016-08-15 15:07:52 +0200 | [diff] [blame] | 116 | DELTA_AQ = 4, |
| 117 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 118 | AQ_MODE_COUNT // This should always be the last member of the enum |
| 119 | } AQ_MODE; |
Fangwen Fu | 6160df2 | 2017-04-24 09:45:51 -0700 | [diff] [blame] | 120 | #if CONFIG_EXT_DELTA_Q |
| 121 | typedef enum { |
| 122 | NO_DELTA_Q = 0, |
| 123 | DELTA_Q_ONLY = 1, |
| 124 | DELTA_Q_LF = 2, |
| 125 | DELTAQ_MODE_COUNT // This should always be the last member of the enum |
| 126 | } DELTAQ_MODE; |
| 127 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 128 | typedef enum { |
| 129 | RESIZE_NONE = 0, // No frame resizing allowed. |
| 130 | RESIZE_FIXED = 1, // All frames are coded at the specified dimension. |
| 131 | RESIZE_DYNAMIC = 2 // Coded size of each frame is determined by the codec. |
Debargha Mukherjee | 29e40a6 | 2017-06-14 09:37:12 -0700 | [diff] [blame] | 132 | } RESIZE_MODE; |
Fergus Simpson | c4e7894 | 2017-04-10 14:59:00 -0700 | [diff] [blame] | 133 | #if CONFIG_FRAME_SUPERRES |
| 134 | typedef enum { |
| 135 | SUPERRES_NONE = 0, |
| 136 | SUPERRES_FIXED = 1, |
| 137 | SUPERRES_DYNAMIC = 2 |
| 138 | } SUPERRES_MODE; |
| 139 | #endif // CONFIG_FRAME_SUPERRES |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 140 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 141 | typedef struct AV1EncoderConfig { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 142 | BITSTREAM_PROFILE profile; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 143 | aom_bit_depth_t bit_depth; // Codec bit-depth. |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 144 | int width; // width of data passed to the compressor |
| 145 | int height; // height of data passed to the compressor |
| 146 | unsigned int input_bit_depth; // Input bit depth. |
| 147 | double init_framerate; // set to passed in framerate |
| 148 | int64_t target_bandwidth; // bandwidth to be used in bits per second |
| 149 | |
| 150 | int noise_sensitivity; // pre processing blur: recommendation 0 |
| 151 | int sharpness; // sharpening output: recommendation 0: |
| 152 | int speed; |
| 153 | // maximum allowed bitrate for any intra frame in % of bitrate target. |
| 154 | unsigned int rc_max_intra_bitrate_pct; |
| 155 | // maximum allowed bitrate for any inter frame in % of bitrate target. |
| 156 | unsigned int rc_max_inter_bitrate_pct; |
| 157 | // percent of rate boost for golden frame in CBR mode. |
| 158 | unsigned int gf_cbr_boost_pct; |
| 159 | |
| 160 | MODE mode; |
| 161 | int pass; |
| 162 | |
| 163 | // Key Framing Operations |
| 164 | int auto_key; // autodetect cut scenes and set the keyframes |
| 165 | int key_freq; // maximum distance to key frame. |
| 166 | |
| 167 | int lag_in_frames; // how many frames lag before we start encoding |
| 168 | |
| 169 | // ---------------------------------------------------------------- |
| 170 | // DATARATE CONTROL OPTIONS |
| 171 | |
| 172 | // vbr, cbr, constrained quality or constant quality |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 173 | enum aom_rc_mode rc_mode; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 174 | |
| 175 | // buffer targeting aggressiveness |
| 176 | int under_shoot_pct; |
| 177 | int over_shoot_pct; |
| 178 | |
| 179 | // buffering parameters |
| 180 | int64_t starting_buffer_level_ms; |
| 181 | int64_t optimal_buffer_level_ms; |
| 182 | int64_t maximum_buffer_size_ms; |
| 183 | |
| 184 | // Frame drop threshold. |
| 185 | int drop_frames_water_mark; |
| 186 | |
| 187 | // controlling quality |
| 188 | int fixed_q; |
| 189 | int worst_allowed_q; |
| 190 | int best_allowed_q; |
| 191 | int cq_level; |
| 192 | AQ_MODE aq_mode; // Adaptive Quantization mode |
Fangwen Fu | 6160df2 | 2017-04-24 09:45:51 -0700 | [diff] [blame] | 193 | #if CONFIG_EXT_DELTA_Q |
| 194 | DELTAQ_MODE deltaq_mode; |
| 195 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 196 | #if CONFIG_AOM_QM |
| 197 | int using_qm; |
| 198 | int qm_minlevel; |
| 199 | int qm_maxlevel; |
| 200 | #endif |
Thomas Davies | af6df17 | 2016-11-09 14:04:18 +0000 | [diff] [blame] | 201 | #if CONFIG_TILE_GROUPS |
| 202 | unsigned int num_tile_groups; |
| 203 | unsigned int mtu; |
| 204 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 205 | |
Fangwen Fu | 8d164de | 2016-12-14 13:40:54 -0800 | [diff] [blame] | 206 | #if CONFIG_TEMPMV_SIGNALING |
| 207 | unsigned int disable_tempmv; |
| 208 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 209 | // Internal frame size scaling. |
Debargha Mukherjee | 29e40a6 | 2017-06-14 09:37:12 -0700 | [diff] [blame] | 210 | RESIZE_MODE resize_mode; |
| 211 | uint8_t resize_scale_numerator; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 212 | |
Fergus Simpson | 3502d08 | 2017-04-10 12:25:07 -0700 | [diff] [blame] | 213 | #if CONFIG_FRAME_SUPERRES |
Fergus Simpson | c4e7894 | 2017-04-10 14:59:00 -0700 | [diff] [blame] | 214 | // Frame Super-Resolution size scaling. |
| 215 | SUPERRES_MODE superres_mode; |
| 216 | uint8_t superres_scale_numerator; |
Fergus Simpson | 3502d08 | 2017-04-10 12:25:07 -0700 | [diff] [blame] | 217 | #endif // CONFIG_FRAME_SUPERRES |
| 218 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 219 | // Enable feature to reduce the frame quantization every x frames. |
| 220 | int frame_periodic_boost; |
| 221 | |
| 222 | // two pass datarate control |
| 223 | int two_pass_vbrbias; // two pass datarate control tweaks |
| 224 | int two_pass_vbrmin_section; |
| 225 | int two_pass_vbrmax_section; |
| 226 | // END DATARATE CONTROL OPTIONS |
| 227 | // ---------------------------------------------------------------- |
| 228 | |
| 229 | int enable_auto_arf; |
| 230 | #if CONFIG_EXT_REFS |
| 231 | int enable_auto_brf; // (b)ackward (r)ef (f)rame |
| 232 | #endif // CONFIG_EXT_REFS |
| 233 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 234 | /* Bitfield defining the error resiliency features to enable. |
| 235 | * Can provide decodable frames after losses in previous |
| 236 | * frames and decodable partitions after losses in the same frame. |
| 237 | */ |
| 238 | unsigned int error_resilient_mode; |
| 239 | |
| 240 | /* Bitfield defining the parallel decoding mode where the |
| 241 | * decoding in successive frames may be conducted in parallel |
| 242 | * just by decoding the frame headers. |
| 243 | */ |
| 244 | unsigned int frame_parallel_decoding_mode; |
| 245 | |
| 246 | int arnr_max_frames; |
| 247 | int arnr_strength; |
| 248 | |
| 249 | int min_gf_interval; |
| 250 | int max_gf_interval; |
| 251 | |
| 252 | int tile_columns; |
| 253 | int tile_rows; |
Fangwen Fu | 7b9f2b3 | 2017-01-17 14:01:52 -0800 | [diff] [blame] | 254 | #if CONFIG_DEPENDENT_HORZTILES |
| 255 | int dependent_horz_tiles; |
| 256 | #endif |
Ryan Lei | 9b02b0e | 2017-01-30 15:52:20 -0800 | [diff] [blame] | 257 | #if CONFIG_LOOPFILTERING_ACROSS_TILES |
Ryan Lei | 7386eda | 2016-12-08 21:08:31 -0800 | [diff] [blame] | 258 | int loop_filter_across_tiles_enabled; |
Ryan Lei | 9b02b0e | 2017-01-30 15:52:20 -0800 | [diff] [blame] | 259 | #endif // CONFIG_LOOPFILTERING_ACROSS_TILES |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 260 | |
| 261 | int max_threads; |
| 262 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 263 | aom_fixed_buf_t two_pass_stats_in; |
| 264 | struct aom_codec_pkt_list *output_pkt_list; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 265 | |
| 266 | #if CONFIG_FP_MB_STATS |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 267 | aom_fixed_buf_t firstpass_mb_stats_in; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 268 | #endif |
| 269 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 270 | aom_tune_metric tuning; |
| 271 | aom_tune_content content; |
Sebastien Alaiwan | 71e8784 | 2017-04-12 16:03:28 +0200 | [diff] [blame] | 272 | #if CONFIG_HIGHBITDEPTH |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 273 | int use_highbitdepth; |
| 274 | #endif |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 275 | aom_color_space_t color_space; |
anorkin | 76fb126 | 2017-03-22 15:12:12 -0700 | [diff] [blame] | 276 | #if CONFIG_COLORSPACE_HEADERS |
| 277 | aom_transfer_function_t transfer_function; |
| 278 | aom_chroma_sample_position_t chroma_sample_position; |
| 279 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 280 | int color_range; |
| 281 | int render_width; |
| 282 | int render_height; |
| 283 | |
| 284 | #if CONFIG_EXT_PARTITION |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 285 | aom_superblock_size_t superblock_size; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 286 | #endif // CONFIG_EXT_PARTITION |
Alex Converse | eb780e7 | 2016-12-13 12:46:41 -0800 | [diff] [blame] | 287 | #if CONFIG_ANS && ANS_MAX_SYMBOLS |
| 288 | int ans_window_size_log2; |
| 289 | #endif // CONFIG_ANS && ANS_MAX_SYMBOLS |
Yunqing Wang | d8cd55f | 2017-02-27 12:16:00 -0800 | [diff] [blame] | 290 | #if CONFIG_EXT_TILE |
| 291 | unsigned int tile_encoding_mode; |
| 292 | #endif // CONFIG_EXT_TILE |
Yunqing Wang | ff4fa06 | 2017-04-21 10:56:08 -0700 | [diff] [blame] | 293 | |
| 294 | unsigned int motion_vector_unit_test; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 295 | } AV1EncoderConfig; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 296 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 297 | static INLINE int is_lossless_requested(const AV1EncoderConfig *cfg) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 298 | return cfg->best_allowed_q == 0 && cfg->worst_allowed_q == 0; |
| 299 | } |
| 300 | |
| 301 | // TODO(jingning) All spatially adaptive variables should go to TileDataEnc. |
| 302 | typedef struct TileDataEnc { |
| 303 | TileInfo tile_info; |
| 304 | int thresh_freq_fact[BLOCK_SIZES][MAX_MODES]; |
| 305 | int mode_map[BLOCK_SIZES][MAX_MODES]; |
Yunqing Wang | 8c1e57c | 2016-10-25 15:15:23 -0700 | [diff] [blame] | 306 | int m_search_count; |
| 307 | int ex_search_count; |
Yushin Cho | 77bba8d | 2016-11-04 16:36:56 -0700 | [diff] [blame] | 308 | #if CONFIG_PVQ |
| 309 | PVQ_QUEUE pvq_q; |
| 310 | #endif |
Luc Trudeau | f816415 | 2017-04-11 16:20:51 -0400 | [diff] [blame] | 311 | #if CONFIG_CFL |
| 312 | CFL_CTX cfl; |
| 313 | #endif |
Thomas Davies | f77d4ad | 2017-01-10 18:55:42 +0000 | [diff] [blame] | 314 | #if CONFIG_EC_ADAPT |
Jingning Han | 9f07be1 | 2017-04-13 09:31:40 -0700 | [diff] [blame] | 315 | DECLARE_ALIGNED(16, FRAME_CONTEXT, tctx); |
Thomas Davies | f77d4ad | 2017-01-10 18:55:42 +0000 | [diff] [blame] | 316 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 317 | } TileDataEnc; |
| 318 | |
| 319 | typedef struct RD_COUNTS { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 320 | av1_coeff_count coef_counts[TX_SIZES][PLANE_TYPES]; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 321 | int64_t comp_pred_diff[REFERENCE_MODES]; |
Debargha Mukherjee | a575d23 | 2017-04-28 17:46:47 -0700 | [diff] [blame] | 322 | #if CONFIG_GLOBAL_MOTION |
| 323 | // Stores number of 4x4 blocks using global motion per reference frame. |
| 324 | int global_motion_used[TOTAL_REFS_PER_FRAME]; |
| 325 | #endif // CONFIG_GLOBAL_MOTION |
Arild Fuldseth (arilfuld) | 6c20c78 | 2017-06-15 09:45:02 +0200 | [diff] [blame^] | 326 | int single_ref_used_flag; |
| 327 | int compound_ref_used_flag; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 328 | } RD_COUNTS; |
| 329 | |
| 330 | typedef struct ThreadData { |
| 331 | MACROBLOCK mb; |
| 332 | RD_COUNTS rd_counts; |
| 333 | FRAME_COUNTS *counts; |
| 334 | |
| 335 | PICK_MODE_CONTEXT *leaf_tree; |
| 336 | PC_TREE *pc_tree; |
| 337 | PC_TREE *pc_root[MAX_MIB_SIZE_LOG2 - MIN_MIB_SIZE_LOG2 + 1]; |
Jingning Han | d064cf0 | 2017-06-01 10:00:39 -0700 | [diff] [blame] | 338 | #if CONFIG_MOTION_VAR |
| 339 | int32_t *wsrc_buf; |
| 340 | int32_t *mask_buf; |
| 341 | uint8_t *above_pred_buf; |
| 342 | uint8_t *left_pred_buf; |
| 343 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 344 | |
hui su | 5d49314 | 2017-05-08 12:06:12 -0700 | [diff] [blame] | 345 | #if CONFIG_PALETTE |
| 346 | PALETTE_BUFFER *palette_buffer; |
| 347 | #endif // CONFIG_PALETTE |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 348 | } ThreadData; |
| 349 | |
| 350 | struct EncWorkerData; |
| 351 | |
| 352 | typedef struct ActiveMap { |
| 353 | int enabled; |
| 354 | int update; |
| 355 | unsigned char *map; |
| 356 | } ActiveMap; |
| 357 | |
Urvang Joshi | b5ed350 | 2016-10-17 16:38:05 -0700 | [diff] [blame] | 358 | #define NUM_STAT_TYPES 4 // types of stats: Y, U, V and ALL |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 359 | |
| 360 | typedef struct IMAGE_STAT { |
Urvang Joshi | b5ed350 | 2016-10-17 16:38:05 -0700 | [diff] [blame] | 361 | double stat[NUM_STAT_TYPES]; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 362 | double worst; |
| 363 | } ImageStat; |
| 364 | |
Urvang Joshi | b5ed350 | 2016-10-17 16:38:05 -0700 | [diff] [blame] | 365 | #undef NUM_STAT_TYPES |
| 366 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 367 | typedef struct { |
| 368 | int ref_count; |
| 369 | YV12_BUFFER_CONFIG buf; |
| 370 | } EncRefCntBuffer; |
| 371 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 372 | typedef struct TileBufferEnc { |
| 373 | uint8_t *data; |
| 374 | size_t size; |
| 375 | } TileBufferEnc; |
| 376 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 377 | typedef struct AV1_COMP { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 378 | QUANTS quants; |
| 379 | ThreadData td; |
| 380 | MB_MODE_INFO_EXT *mbmi_ext_base; |
Yi Luo | c621023 | 2017-05-25 15:09:25 -0700 | [diff] [blame] | 381 | Dequants dequants; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 382 | AV1_COMMON common; |
| 383 | AV1EncoderConfig oxcf; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 384 | struct lookahead_ctx *lookahead; |
| 385 | struct lookahead_entry *alt_ref_source; |
| 386 | |
Alex Converse | f77fd0b | 2017-04-20 11:00:24 -0700 | [diff] [blame] | 387 | YV12_BUFFER_CONFIG *source; |
| 388 | YV12_BUFFER_CONFIG *last_source; // NULL for first frame and alt_ref frames |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 389 | YV12_BUFFER_CONFIG *unscaled_source; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 390 | YV12_BUFFER_CONFIG scaled_source; |
| 391 | YV12_BUFFER_CONFIG *unscaled_last_source; |
| 392 | YV12_BUFFER_CONFIG scaled_last_source; |
| 393 | |
| 394 | // Up-sampled reference buffers |
| 395 | // NOTE(zoeliu): It is needed to allocate sufficient space to the up-sampled |
| 396 | // reference buffers, which should include the up-sampled version of all the |
| 397 | // possibly stored references plus the currently coded frame itself. |
| 398 | EncRefCntBuffer upsampled_ref_bufs[REF_FRAMES + 1]; |
| 399 | int upsampled_ref_idx[REF_FRAMES + 1]; |
| 400 | |
| 401 | // For a still frame, this flag is set to 1 to skip partition search. |
| 402 | int partition_search_skippable_frame; |
| 403 | |
| 404 | int scaled_ref_idx[TOTAL_REFS_PER_FRAME]; |
| 405 | #if CONFIG_EXT_REFS |
| 406 | int lst_fb_idxes[LAST_REF_FRAMES]; |
| 407 | #else |
| 408 | int lst_fb_idx; |
| 409 | #endif // CONFIG_EXT_REFS |
| 410 | int gld_fb_idx; |
| 411 | #if CONFIG_EXT_REFS |
| 412 | int bwd_fb_idx; // BWD_REF_FRAME |
| 413 | #endif // CONFIG_EXT_REFS |
| 414 | int alt_fb_idx; |
| 415 | |
| 416 | int last_show_frame_buf_idx; // last show frame buffer index |
| 417 | |
| 418 | int refresh_last_frame; |
| 419 | int refresh_golden_frame; |
| 420 | #if CONFIG_EXT_REFS |
| 421 | int refresh_bwd_ref_frame; |
| 422 | #endif // CONFIG_EXT_REFS |
| 423 | int refresh_alt_ref_frame; |
| 424 | |
| 425 | int ext_refresh_frame_flags_pending; |
| 426 | int ext_refresh_last_frame; |
| 427 | int ext_refresh_golden_frame; |
| 428 | int ext_refresh_alt_ref_frame; |
| 429 | |
| 430 | int ext_refresh_frame_context_pending; |
| 431 | int ext_refresh_frame_context; |
| 432 | |
| 433 | YV12_BUFFER_CONFIG last_frame_uf; |
| 434 | #if CONFIG_LOOP_RESTORATION |
| 435 | YV12_BUFFER_CONFIG last_frame_db; |
Debargha Mukherjee | 999d2f6 | 2016-12-15 13:23:21 -0800 | [diff] [blame] | 436 | YV12_BUFFER_CONFIG trial_frame_rst; |
Debargha Mukherjee | a43a2d9 | 2017-01-03 15:14:57 -0800 | [diff] [blame] | 437 | uint8_t *extra_rstbuf; // Extra buffers used in restoration search |
| 438 | RestorationInfo rst_search[MAX_MB_PLANE]; // Used for encoder side search |
| 439 | #endif // CONFIG_LOOP_RESTORATION |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 440 | |
| 441 | // Ambient reconstruction err target for force key frames |
| 442 | int64_t ambient_err; |
| 443 | |
| 444 | RD_OPT rd; |
| 445 | |
| 446 | CODING_CONTEXT coding_context; |
| 447 | |
Urvang Joshi | bffc0b5 | 2016-07-25 13:38:49 -0700 | [diff] [blame] | 448 | int nmv_costs[NMV_CONTEXTS][2][MV_VALS]; |
| 449 | int nmv_costs_hp[NMV_CONTEXTS][2][MV_VALS]; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 450 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 451 | int64_t last_time_stamp_seen; |
| 452 | int64_t last_end_time_stamp_seen; |
| 453 | int64_t first_time_stamp_ever; |
| 454 | |
| 455 | RATE_CONTROL rc; |
Rostislav Pehlivanov | 002e7b7 | 2017-02-15 19:45:54 +0000 | [diff] [blame] | 456 | #if CONFIG_XIPHRC |
| 457 | od_rc_state od_rc; |
| 458 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 459 | double framerate; |
| 460 | |
| 461 | // NOTE(zoeliu): Any inter frame allows maximum of REF_FRAMES inter |
| 462 | // references; Plus the currently coded frame itself, it is needed to allocate |
| 463 | // sufficient space to the size of the maximum possible number of frames. |
| 464 | int interp_filter_selected[REF_FRAMES + 1][SWITCHABLE]; |
| 465 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 466 | struct aom_codec_pkt_list *output_pkt_list; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 467 | |
| 468 | MBGRAPH_FRAME_STATS mbgraph_stats[MAX_LAG_BUFFERS]; |
| 469 | int mbgraph_n_frames; // number of frames filled in the above |
| 470 | int static_mb_pct; // % forced skip mbs by segmentation |
| 471 | int ref_frame_flags; |
| 472 | |
| 473 | SPEED_FEATURES sf; |
| 474 | |
| 475 | unsigned int max_mv_magnitude; |
| 476 | int mv_step_param; |
| 477 | |
| 478 | int allow_comp_inter_inter; |
| 479 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 480 | uint8_t *segmentation_map; |
| 481 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 482 | CYCLIC_REFRESH *cyclic_refresh; |
| 483 | ActiveMap active_map; |
| 484 | |
| 485 | fractional_mv_step_fp *find_fractional_mv_step; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 486 | av1_full_search_fn_t full_search_sad; // It is currently unused. |
| 487 | av1_diamond_search_fn_t diamond_search_sad; |
| 488 | aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES]; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 489 | uint64_t time_receive_data; |
| 490 | uint64_t time_compress_data; |
| 491 | uint64_t time_pick_lpf; |
| 492 | uint64_t time_encode_sb_row; |
| 493 | |
| 494 | #if CONFIG_FP_MB_STATS |
| 495 | int use_fp_mb_stats; |
| 496 | #endif |
| 497 | |
| 498 | TWO_PASS twopass; |
| 499 | |
| 500 | YV12_BUFFER_CONFIG alt_ref_buffer; |
| 501 | |
| 502 | #if CONFIG_INTERNAL_STATS |
| 503 | unsigned int mode_chosen_counts[MAX_MODES]; |
| 504 | |
| 505 | int count; |
| 506 | uint64_t total_sq_error; |
| 507 | uint64_t total_samples; |
| 508 | ImageStat psnr; |
| 509 | |
| 510 | double total_blockiness; |
| 511 | double worst_blockiness; |
| 512 | |
| 513 | int bytes; |
| 514 | double summed_quality; |
| 515 | double summed_weights; |
| 516 | unsigned int tot_recode_hits; |
| 517 | double worst_ssim; |
| 518 | |
| 519 | ImageStat fastssim; |
| 520 | ImageStat psnrhvs; |
| 521 | |
| 522 | int b_calculate_blockiness; |
| 523 | int b_calculate_consistency; |
| 524 | |
| 525 | double total_inconsistency; |
| 526 | double worst_consistency; |
| 527 | Ssimv *ssim_vars; |
| 528 | Metrics metrics; |
| 529 | #endif |
| 530 | int b_calculate_psnr; |
| 531 | |
| 532 | int droppable; |
| 533 | |
| 534 | int initial_width; |
| 535 | int initial_height; |
| 536 | int initial_mbs; // Number of MBs in the full-size frame; to be used to |
| 537 | // normalize the firstpass stats. This will differ from the |
| 538 | // number of MBs in the current frame when the frame is |
| 539 | // scaled. |
| 540 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 541 | int frame_flags; |
| 542 | |
| 543 | search_site_config ss_cfg; |
| 544 | |
| 545 | int mbmode_cost[BLOCK_SIZE_GROUPS][INTRA_MODES]; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 546 | int newmv_mode_cost[NEWMV_MODE_CONTEXTS][2]; |
| 547 | int zeromv_mode_cost[ZEROMV_MODE_CONTEXTS][2]; |
| 548 | int refmv_mode_cost[REFMV_MODE_CONTEXTS][2]; |
| 549 | int drl_mode_cost0[DRL_MODE_CONTEXTS][2]; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 550 | |
| 551 | unsigned int inter_mode_cost[INTER_MODE_CONTEXTS][INTER_MODES]; |
| 552 | #if CONFIG_EXT_INTER |
clang-format | 67948d3 | 2016-09-07 22:40:40 -0700 | [diff] [blame] | 553 | unsigned int inter_compound_mode_cost[INTER_MODE_CONTEXTS] |
| 554 | [INTER_COMPOUND_MODES]; |
Zoe Liu | 85b6646 | 2017-04-20 14:28:19 -0700 | [diff] [blame] | 555 | #if CONFIG_COMPOUND_SINGLEREF |
| 556 | unsigned int inter_singleref_comp_mode_cost[INTER_MODE_CONTEXTS] |
| 557 | [INTER_SINGLEREF_COMP_MODES]; |
| 558 | #endif // CONFIG_COMPOUND_SINGLEREF |
Yue Chen | 4d26acb | 2017-05-01 12:28:34 -0700 | [diff] [blame] | 559 | #if CONFIG_INTERINTRA |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 560 | unsigned int interintra_mode_cost[BLOCK_SIZE_GROUPS][INTERINTRA_MODES]; |
Yue Chen | 4d26acb | 2017-05-01 12:28:34 -0700 | [diff] [blame] | 561 | #endif // CONFIG_INTERINTRA |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 562 | #endif // CONFIG_EXT_INTER |
Yue Chen | cb60b18 | 2016-10-13 15:18:22 -0700 | [diff] [blame] | 563 | #if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION |
| 564 | int motion_mode_cost[BLOCK_SIZES][MOTION_MODES]; |
Yue Chen | 69f18e1 | 2016-09-08 14:48:15 -0700 | [diff] [blame] | 565 | #if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION |
| 566 | int motion_mode_cost1[BLOCK_SIZES][2]; |
| 567 | #endif // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION |
Yue Chen | cb60b18 | 2016-10-13 15:18:22 -0700 | [diff] [blame] | 568 | #endif // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 569 | int intra_uv_mode_cost[INTRA_MODES][INTRA_MODES]; |
| 570 | int y_mode_costs[INTRA_MODES][INTRA_MODES][INTRA_MODES]; |
| 571 | int switchable_interp_costs[SWITCHABLE_FILTER_CONTEXTS][SWITCHABLE_FILTERS]; |
| 572 | #if CONFIG_EXT_PARTITION_TYPES |
Alex Converse | 55c6bde | 2017-01-12 15:55:31 -0800 | [diff] [blame] | 573 | int partition_cost[PARTITION_CONTEXTS + CONFIG_UNPOISON_PARTITION_CTX] |
| 574 | [EXT_PARTITION_TYPES]; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 575 | #else |
Alex Converse | 55c6bde | 2017-01-12 15:55:31 -0800 | [diff] [blame] | 576 | int partition_cost[PARTITION_CONTEXTS + CONFIG_UNPOISON_PARTITION_CTX] |
| 577 | [PARTITION_TYPES]; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 578 | #endif |
Urvang Joshi | b100db7 | 2016-10-12 16:28:56 -0700 | [diff] [blame] | 579 | #if CONFIG_PALETTE |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 580 | int palette_y_size_cost[PALETTE_BLOCK_SIZES][PALETTE_SIZES]; |
| 581 | int palette_uv_size_cost[PALETTE_BLOCK_SIZES][PALETTE_SIZES]; |
Alex Converse | 9210981 | 2017-02-22 10:21:40 -0800 | [diff] [blame] | 582 | int palette_y_color_cost[PALETTE_SIZES][PALETTE_COLOR_INDEX_CONTEXTS] |
clang-format | 67948d3 | 2016-09-07 22:40:40 -0700 | [diff] [blame] | 583 | [PALETTE_COLORS]; |
Alex Converse | 9210981 | 2017-02-22 10:21:40 -0800 | [diff] [blame] | 584 | int palette_uv_color_cost[PALETTE_SIZES][PALETTE_COLOR_INDEX_CONTEXTS] |
clang-format | 67948d3 | 2016-09-07 22:40:40 -0700 | [diff] [blame] | 585 | [PALETTE_COLORS]; |
Urvang Joshi | b100db7 | 2016-10-12 16:28:56 -0700 | [diff] [blame] | 586 | #endif // CONFIG_PALETTE |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 587 | int tx_size_cost[TX_SIZES - 1][TX_SIZE_CONTEXTS][TX_SIZES]; |
| 588 | #if CONFIG_EXT_TX |
| 589 | int inter_tx_type_costs[EXT_TX_SETS_INTER][EXT_TX_SIZES][TX_TYPES]; |
| 590 | int intra_tx_type_costs[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES] |
| 591 | [TX_TYPES]; |
| 592 | #else |
| 593 | int intra_tx_type_costs[EXT_TX_SIZES][TX_TYPES][TX_TYPES]; |
| 594 | int inter_tx_type_costs[EXT_TX_SIZES][TX_TYPES]; |
| 595 | #endif // CONFIG_EXT_TX |
| 596 | #if CONFIG_EXT_INTRA |
hui su | eda3d76 | 2016-12-06 16:58:23 -0800 | [diff] [blame] | 597 | #if CONFIG_INTRA_INTERP |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 598 | int intra_filter_cost[INTRA_FILTERS + 1][INTRA_FILTERS]; |
hui su | eda3d76 | 2016-12-06 16:58:23 -0800 | [diff] [blame] | 599 | #endif // CONFIG_INTRA_INTERP |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 600 | #endif // CONFIG_EXT_INTRA |
Debargha Mukherjee | 5cd2ab9 | 2016-09-08 15:15:17 -0700 | [diff] [blame] | 601 | #if CONFIG_LOOP_RESTORATION |
| 602 | int switchable_restore_cost[RESTORE_SWITCHABLE_TYPES]; |
| 603 | #endif // CONFIG_LOOP_RESTORATION |
Debargha Mukherjee | 9febfc1 | 2016-12-07 13:20:44 -0800 | [diff] [blame] | 604 | #if CONFIG_GLOBAL_MOTION |
| 605 | int gmtype_cost[TRANS_TYPES]; |
Debargha Mukherjee | 265db6d | 2017-03-28 11:15:27 -0700 | [diff] [blame] | 606 | int gmparams_cost[TOTAL_REFS_PER_FRAME]; |
Debargha Mukherjee | 9febfc1 | 2016-12-07 13:20:44 -0800 | [diff] [blame] | 607 | #endif // CONFIG_GLOBAL_MOTION |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 608 | |
| 609 | int multi_arf_allowed; |
| 610 | int multi_arf_enabled; |
| 611 | int multi_arf_last_grp_enabled; |
| 612 | |
| 613 | TileDataEnc *tile_data; |
| 614 | int allocated_tiles; // Keep track of memory allocated for tiles. |
| 615 | |
| 616 | TOKENEXTRA *tile_tok[MAX_TILE_ROWS][MAX_TILE_COLS]; |
| 617 | unsigned int tok_count[MAX_TILE_ROWS][MAX_TILE_COLS]; |
| 618 | |
| 619 | TileBufferEnc tile_buffers[MAX_TILE_ROWS][MAX_TILE_COLS]; |
| 620 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 621 | int resize_state; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 622 | int resize_avg_qp; |
| 623 | int resize_buffer_underflow; |
| 624 | int resize_count; |
| 625 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 626 | // VARIANCE_AQ segment map refresh |
| 627 | int vaq_refresh; |
| 628 | |
| 629 | // Multi-threading |
| 630 | int num_workers; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 631 | AVxWorker *workers; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 632 | struct EncWorkerData *tile_thr_data; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 633 | AV1LfSync lf_row_sync; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 634 | #if CONFIG_ANS |
| 635 | struct BufAnsCoder buf_ans; |
| 636 | #endif |
| 637 | #if CONFIG_EXT_REFS |
| 638 | int refresh_frame_mask; |
| 639 | int existing_fb_idx_to_show; |
| 640 | int is_arf_filter_off[MAX_EXT_ARFS + 1]; |
| 641 | int num_extra_arfs; |
| 642 | int arf_map[MAX_EXT_ARFS + 1]; |
| 643 | #endif // CONFIG_EXT_REFS |
| 644 | #if CONFIG_GLOBAL_MOTION |
Debargha Mukherjee | b98a702 | 2016-11-15 16:07:12 -0800 | [diff] [blame] | 645 | int global_motion_search_done; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 646 | #endif |
Arild Fuldseth (arilfuld) | 5114b7b | 2016-11-09 13:32:54 +0100 | [diff] [blame] | 647 | #if CONFIG_REFERENCE_BUFFER |
| 648 | SequenceHeader seq_params; |
| 649 | #endif |
Angie Chiang | f0fbf9d | 2017-03-15 15:01:22 -0700 | [diff] [blame] | 650 | #if CONFIG_LV_MAP |
| 651 | tran_low_t *tcoeff_buf[MAX_MB_PLANE]; |
| 652 | #endif |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 653 | } AV1_COMP; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 654 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 655 | void av1_initialize_enc(void); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 656 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 657 | struct AV1_COMP *av1_create_compressor(AV1EncoderConfig *oxcf, |
| 658 | BufferPool *const pool); |
| 659 | void av1_remove_compressor(AV1_COMP *cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 660 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 661 | void av1_change_config(AV1_COMP *cpi, const AV1EncoderConfig *oxcf); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 662 | |
| 663 | // receive a frames worth of data. caller can assume that a copy of this |
| 664 | // frame is made and not just a copy of the pointer.. |
James Zern | 3e2613b | 2017-03-30 23:14:40 -0700 | [diff] [blame] | 665 | int av1_receive_raw_frame(AV1_COMP *cpi, aom_enc_frame_flags_t frame_flags, |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 666 | YV12_BUFFER_CONFIG *sd, int64_t time_stamp, |
| 667 | int64_t end_time_stamp); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 668 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 669 | int av1_get_compressed_data(AV1_COMP *cpi, unsigned int *frame_flags, |
| 670 | size_t *size, uint8_t *dest, int64_t *time_stamp, |
| 671 | int64_t *time_end, int flush); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 672 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 673 | int av1_get_preview_raw_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *dest); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 674 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 675 | int av1_get_last_show_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *frame); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 676 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 677 | int av1_use_as_reference(AV1_COMP *cpi, int ref_frame_flags); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 678 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 679 | void av1_update_reference(AV1_COMP *cpi, int ref_frame_flags); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 680 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 681 | int av1_copy_reference_enc(AV1_COMP *cpi, AOM_REFFRAME ref_frame_flag, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 682 | YV12_BUFFER_CONFIG *sd); |
| 683 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 684 | int av1_set_reference_enc(AV1_COMP *cpi, AOM_REFFRAME ref_frame_flag, |
| 685 | YV12_BUFFER_CONFIG *sd); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 686 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 687 | int av1_update_entropy(AV1_COMP *cpi, int update); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 688 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 689 | int av1_set_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 690 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 691 | int av1_get_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 692 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 693 | int av1_set_internal_size(AV1_COMP *cpi, AOM_SCALING horiz_mode, |
| 694 | AOM_SCALING vert_mode); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 695 | |
Fergus Simpson | 0a30c88 | 2017-05-16 16:54:51 -0700 | [diff] [blame] | 696 | // Returns 1 if the assigned width or height was <= 0. |
| 697 | int av1_set_size_literal(AV1_COMP *cpi, int width, int height); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 698 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 699 | int av1_get_quantizer(struct AV1_COMP *cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 700 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 701 | void av1_full_to_model_counts(av1_coeff_count_model *model_count, |
| 702 | av1_coeff_count *full_count); |
| 703 | |
| 704 | static INLINE int frame_is_kf_gf_arf(const AV1_COMP *cpi) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 705 | return frame_is_intra_only(&cpi->common) || cpi->refresh_alt_ref_frame || |
| 706 | (cpi->refresh_golden_frame && !cpi->rc.is_src_frame_alt_ref); |
| 707 | } |
| 708 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 709 | static INLINE int get_ref_frame_map_idx(const AV1_COMP *cpi, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 710 | MV_REFERENCE_FRAME ref_frame) { |
| 711 | #if CONFIG_EXT_REFS |
| 712 | if (ref_frame >= LAST_FRAME && ref_frame <= LAST3_FRAME) |
| 713 | return cpi->lst_fb_idxes[ref_frame - 1]; |
| 714 | #else |
| 715 | if (ref_frame == LAST_FRAME) return cpi->lst_fb_idx; |
| 716 | #endif // CONFIG_EXT_REFS |
| 717 | else if (ref_frame == GOLDEN_FRAME) |
| 718 | return cpi->gld_fb_idx; |
| 719 | #if CONFIG_EXT_REFS |
| 720 | else if (ref_frame == BWDREF_FRAME) |
| 721 | return cpi->bwd_fb_idx; |
| 722 | #endif // CONFIG_EXT_REFS |
| 723 | else |
| 724 | return cpi->alt_fb_idx; |
| 725 | } |
| 726 | |
Urvang Joshi | 5264844 | 2016-10-13 17:27:51 -0700 | [diff] [blame] | 727 | static INLINE int get_ref_frame_buf_idx(const AV1_COMP *cpi, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 728 | MV_REFERENCE_FRAME ref_frame) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 729 | const AV1_COMMON *const cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 730 | const int map_idx = get_ref_frame_map_idx(cpi, ref_frame); |
| 731 | return (map_idx != INVALID_IDX) ? cm->ref_frame_map[map_idx] : INVALID_IDX; |
| 732 | } |
| 733 | |
| 734 | static INLINE YV12_BUFFER_CONFIG *get_ref_frame_buffer( |
Urvang Joshi | 5264844 | 2016-10-13 17:27:51 -0700 | [diff] [blame] | 735 | const AV1_COMP *cpi, MV_REFERENCE_FRAME ref_frame) { |
| 736 | const AV1_COMMON *const cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 737 | const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame); |
| 738 | return buf_idx != INVALID_IDX ? &cm->buffer_pool->frame_bufs[buf_idx].buf |
| 739 | : NULL; |
| 740 | } |
| 741 | |
| 742 | static INLINE const YV12_BUFFER_CONFIG *get_upsampled_ref( |
Urvang Joshi | 5264844 | 2016-10-13 17:27:51 -0700 | [diff] [blame] | 743 | const AV1_COMP *cpi, const MV_REFERENCE_FRAME ref_frame) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 744 | // Use up-sampled reference frames. |
| 745 | const int buf_idx = |
| 746 | cpi->upsampled_ref_idx[get_ref_frame_map_idx(cpi, ref_frame)]; |
| 747 | return &cpi->upsampled_ref_bufs[buf_idx].buf; |
| 748 | } |
| 749 | |
Jingning Han | 3c4556c | 2017-05-19 11:27:17 -0700 | [diff] [blame] | 750 | #if CONFIG_EXT_REFS || CONFIG_TEMPMV_SIGNALING |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 751 | static INLINE int enc_is_ref_frame_buf(AV1_COMP *cpi, RefCntBuffer *frame_buf) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 752 | MV_REFERENCE_FRAME ref_frame; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 753 | AV1_COMMON *const cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 754 | for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { |
| 755 | const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame); |
| 756 | if (buf_idx == INVALID_IDX) continue; |
| 757 | if (frame_buf == &cm->buffer_pool->frame_bufs[buf_idx]) break; |
| 758 | } |
| 759 | return (ref_frame <= ALTREF_FRAME); |
| 760 | } |
| 761 | #endif // CONFIG_EXT_REFS |
| 762 | |
| 763 | static INLINE unsigned int get_token_alloc(int mb_rows, int mb_cols) { |
Jingning Han | 7f76d47 | 2016-07-29 10:48:34 -0700 | [diff] [blame] | 764 | // We assume 3 planes all at full resolution. We assume up to 1 token per |
| 765 | // pixel, and then allow a head room of 1 EOSB token per 4x4 block per plane, |
| 766 | // plus EOSB_TOKEN per plane. |
| 767 | return mb_rows * mb_cols * (16 * 16 + 17) * 3; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 768 | } |
| 769 | |
| 770 | // Get the allocated token size for a tile. It does the same calculation as in |
| 771 | // the frame token allocation. |
| 772 | static INLINE unsigned int allocated_tokens(TileInfo tile) { |
Jingning Han | eafbd5f | 2017-03-07 11:18:17 -0800 | [diff] [blame] | 773 | #if CONFIG_CB4X4 |
| 774 | int tile_mb_rows = (tile.mi_row_end - tile.mi_row_start + 2) >> 2; |
| 775 | int tile_mb_cols = (tile.mi_col_end - tile.mi_col_start + 2) >> 2; |
| 776 | #else |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 777 | int tile_mb_rows = (tile.mi_row_end - tile.mi_row_start + 1) >> 1; |
| 778 | int tile_mb_cols = (tile.mi_col_end - tile.mi_col_start + 1) >> 1; |
Jingning Han | eafbd5f | 2017-03-07 11:18:17 -0800 | [diff] [blame] | 779 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 780 | |
| 781 | return get_token_alloc(tile_mb_rows, tile_mb_cols); |
| 782 | } |
| 783 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 784 | void av1_alloc_compressor_data(AV1_COMP *cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 785 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 786 | void av1_scale_references(AV1_COMP *cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 787 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 788 | void av1_update_reference_frames(AV1_COMP *cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 789 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 790 | void av1_set_high_precision_mv(AV1_COMP *cpi, int allow_high_precision_mv); |
Fangwen Fu | 8d164de | 2016-12-14 13:40:54 -0800 | [diff] [blame] | 791 | #if CONFIG_TEMPMV_SIGNALING |
| 792 | void av1_set_temporal_mv_prediction(AV1_COMP *cpi, int allow_tempmv_prediction); |
| 793 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 794 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 795 | void av1_apply_encoding_flags(AV1_COMP *cpi, aom_enc_frame_flags_t flags); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 796 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 797 | static INLINE int is_altref_enabled(const AV1_COMP *const cpi) { |
Thomas Daede | 8082614 | 2017-03-20 15:44:24 -0700 | [diff] [blame] | 798 | return cpi->oxcf.lag_in_frames > 0 && cpi->oxcf.enable_auto_arf; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 799 | } |
| 800 | |
| 801 | // TODO(zoeliu): To set up cpi->oxcf.enable_auto_brf |
| 802 | #if 0 && CONFIG_EXT_REFS |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 803 | static INLINE int is_bwdref_enabled(const AV1_COMP *const cpi) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 804 | // NOTE(zoeliu): The enabling of bi-predictive frames depends on the use of |
| 805 | // alt_ref, and now will be off when the alt_ref interval is |
| 806 | // not sufficiently large. |
| 807 | return is_altref_enabled(cpi) && cpi->oxcf.enable_auto_brf; |
| 808 | } |
| 809 | #endif // CONFIG_EXT_REFS |
| 810 | |
Urvang Joshi | 5264844 | 2016-10-13 17:27:51 -0700 | [diff] [blame] | 811 | static INLINE void set_ref_ptrs(const AV1_COMMON *cm, MACROBLOCKD *xd, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 812 | MV_REFERENCE_FRAME ref0, |
| 813 | MV_REFERENCE_FRAME ref1) { |
| 814 | xd->block_refs[0] = |
| 815 | &cm->frame_refs[ref0 >= LAST_FRAME ? ref0 - LAST_FRAME : 0]; |
| 816 | xd->block_refs[1] = |
| 817 | &cm->frame_refs[ref1 >= LAST_FRAME ? ref1 - LAST_FRAME : 0]; |
| 818 | } |
| 819 | |
Yaowu Xu | 4ff59b5 | 2017-04-24 12:41:56 -0700 | [diff] [blame] | 820 | static INLINE int get_chessboard_index(int frame_index) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 821 | return frame_index & 0x1; |
| 822 | } |
| 823 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 824 | static INLINE int *cond_cost_list(const struct AV1_COMP *cpi, int *cost_list) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 825 | return cpi->sf.mv.subpel_search_method != SUBPEL_TREE ? cost_list : NULL; |
| 826 | } |
| 827 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 828 | void av1_new_framerate(AV1_COMP *cpi, double framerate); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 829 | |
| 830 | #define LAYER_IDS_TO_IDX(sl, tl, num_tl) ((sl) * (num_tl) + (tl)) |
| 831 | |
| 832 | // Update up-sampled reference frame index. |
| 833 | static INLINE void uref_cnt_fb(EncRefCntBuffer *ubufs, int *uidx, |
| 834 | int new_uidx) { |
| 835 | const int ref_index = *uidx; |
| 836 | |
| 837 | if (ref_index >= 0 && ubufs[ref_index].ref_count > 0) |
| 838 | ubufs[ref_index].ref_count--; |
| 839 | |
| 840 | *uidx = new_uidx; |
| 841 | ubufs[new_uidx].ref_count++; |
| 842 | } |
| 843 | |
Fergus Simpson | fecb2ab | 2017-04-30 15:49:57 -0700 | [diff] [blame] | 844 | // Returns 1 if a frame is unscaled and 0 otherwise. |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 845 | static INLINE int av1_resize_unscaled(const AV1_COMMON *cm) { |
| 846 | #if CONFIG_FRAME_SUPERRES |
| 847 | return cm->superres_upscaled_width == cm->render_width && |
| 848 | cm->superres_upscaled_height == cm->render_height; |
| 849 | #else |
| 850 | return cm->width == cm->render_width && cm->height == cm->render_height; |
| 851 | #endif // CONFIG_FRAME_SUPERRES |
Fergus Simpson | fecb2ab | 2017-04-30 15:49:57 -0700 | [diff] [blame] | 852 | } |
| 853 | |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 854 | static INLINE int av1_frame_unscaled(const AV1_COMMON *cm) { |
| 855 | #if CONFIG_FRAME_SUPERRES |
| 856 | return av1_superres_unscaled(cm) && av1_resize_unscaled(cm); |
| 857 | #else |
| 858 | return av1_resize_unscaled(cm); |
| 859 | #endif // CONFIG_FRAME_SUPERRES |
Fergus Simpson | fecb2ab | 2017-04-30 15:49:57 -0700 | [diff] [blame] | 860 | } |
| 861 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 862 | #ifdef __cplusplus |
| 863 | } // extern "C" |
| 864 | #endif |
| 865 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 866 | #endif // AV1_ENCODER_ENCODER_H_ |