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