Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1 | /* |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2 | * Copyright (c) 2021, Alliance for Open Media. All rights reserved |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3 | * |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 4 | * This source code is subject to the terms of the BSD 3-Clause Clear License |
| 5 | * and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear |
| 6 | * License was not distributed with this source code in the LICENSE file, you |
| 7 | * can obtain it at aomedia.org/license/software-license/bsd-3-c-c/. If the |
| 8 | * Alliance for Open Media Patent License 1.0 was not distributed with this |
| 9 | * source code in the PATENTS file, you can obtain it at |
| 10 | * aomedia.org/license/patent-license/. |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 11 | */ |
| 12 | |
| 13 | #include <limits.h> |
Urvang Joshi | bc82d38 | 2019-11-01 17:59:20 -0700 | [diff] [blame] | 14 | #include <float.h> |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 15 | #include <math.h> |
| 16 | #include <stdio.h> |
Debargha Mukherjee | c22e2c5 | 2020-07-07 00:06:58 -0700 | [diff] [blame] | 17 | #include <string.h> |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 18 | |
Tom Finegan | 60e653d | 2018-05-22 11:34:58 -0700 | [diff] [blame] | 19 | #include "config/aom_config.h" |
chiyotsai | c814afb | 2020-08-04 13:12:35 -0700 | [diff] [blame] | 20 | #include "config/aom_dsp_rtcd.h" |
Yaowu Xu | fa3721d | 2018-07-30 14:38:49 -0700 | [diff] [blame] | 21 | |
Yaowu Xu | fa3721d | 2018-07-30 14:38:49 -0700 | [diff] [blame] | 22 | #if CONFIG_DENOISE |
| 23 | #include "aom_dsp/grain_table.h" |
| 24 | #include "aom_dsp/noise_util.h" |
| 25 | #include "aom_dsp/noise_model.h" |
| 26 | #endif |
| 27 | #include "aom_dsp/psnr.h" |
| 28 | #if CONFIG_INTERNAL_STATS |
| 29 | #include "aom_dsp/ssim.h" |
| 30 | #endif |
| 31 | #include "aom_ports/aom_timer.h" |
| 32 | #include "aom_ports/mem.h" |
| 33 | #include "aom_ports/system_state.h" |
| 34 | #include "aom_scale/aom_scale.h" |
David Turner | 1539bb0 | 2019-01-24 15:28:13 +0000 | [diff] [blame] | 35 | #if CONFIG_BITSTREAM_DEBUG |
Yaowu Xu | fa3721d | 2018-07-30 14:38:49 -0700 | [diff] [blame] | 36 | #include "aom_util/debug_util.h" |
David Turner | 1539bb0 | 2019-01-24 15:28:13 +0000 | [diff] [blame] | 37 | #endif // CONFIG_BITSTREAM_DEBUG |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 38 | |
| 39 | #include "av1/common/alloccommon.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 40 | #include "av1/common/filter.h" |
| 41 | #include "av1/common/idct.h" |
| 42 | #include "av1/common/reconinter.h" |
| 43 | #include "av1/common/reconintra.h" |
Fergus Simpson | d056500 | 2017-03-27 16:51:52 -0700 | [diff] [blame] | 44 | #include "av1/common/resize.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 45 | #include "av1/common/tile_common.h" |
| 46 | |
| 47 | #include "av1/encoder/aq_complexity.h" |
| 48 | #include "av1/encoder/aq_cyclicrefresh.h" |
| 49 | #include "av1/encoder/aq_variance.h" |
| 50 | #include "av1/encoder/bitstream.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 51 | #include "av1/encoder/context_tree.h" |
| 52 | #include "av1/encoder/encodeframe.h" |
| 53 | #include "av1/encoder/encodemv.h" |
David Turner | 056f7cd | 2019-01-07 17:48:13 +0000 | [diff] [blame] | 54 | #include "av1/encoder/encode_strategy.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 55 | #include "av1/encoder/encoder.h" |
Satish Kumar Suman | d3caa0d | 2020-06-16 14:02:50 +0530 | [diff] [blame] | 56 | #include "av1/encoder/encoder_alloc.h" |
Satish Kumar Suman | 897b794 | 2020-06-11 11:44:29 +0530 | [diff] [blame] | 57 | #include "av1/encoder/encoder_utils.h" |
Angie Chiang | f0fbf9d | 2017-03-15 15:01:22 -0700 | [diff] [blame] | 58 | #include "av1/encoder/encodetxb.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 59 | #include "av1/encoder/ethread.h" |
| 60 | #include "av1/encoder/firstpass.h" |
RogerZhou | cc5d35d | 2017-08-07 22:20:15 -0700 | [diff] [blame] | 61 | #include "av1/encoder/hash_motion.h" |
chiyotsai | 73ddf44 | 2020-06-01 15:42:23 -0700 | [diff] [blame] | 62 | #include "av1/encoder/intra_mode_search.h" |
chiyotsai | c666b1f | 2019-12-20 10:44:58 -0800 | [diff] [blame] | 63 | #include "av1/encoder/mv_prec.h" |
David Turner | 0fa8c49 | 2019-02-06 16:38:13 +0000 | [diff] [blame] | 64 | #include "av1/encoder/pass2_strategy.h" |
Debargha Mukherjee | 2d565f4 | 2020-06-17 18:07:12 -0700 | [diff] [blame] | 65 | #include "av1/encoder/pickcdef.h" |
yixindu | 368bde5 | 2021-06-04 18:30:53 -0700 | [diff] [blame] | 66 | #if CONFIG_CCSO |
| 67 | #include "av1/encoder/pickccso.h" |
| 68 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 69 | #include "av1/encoder/picklpf.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 70 | #include "av1/encoder/pickrst.h" |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 71 | #include "av1/encoder/random.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 72 | #include "av1/encoder/ratectrl.h" |
Satish Kumar Suman | 47c0689 | 2020-06-10 12:45:25 +0530 | [diff] [blame] | 73 | #include "av1/encoder/rc_utils.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 74 | #include "av1/encoder/rd.h" |
Debargha Mukherjee | df71310 | 2018-10-02 12:33:32 -0700 | [diff] [blame] | 75 | #include "av1/encoder/rdopt.h" |
Debargha Mukherjee | c22e2c5 | 2020-07-07 00:06:58 -0700 | [diff] [blame] | 76 | #include "av1/encoder/reconinter_enc.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 77 | #include "av1/encoder/segmentation.h" |
| 78 | #include "av1/encoder/speed_features.h" |
Debargha Mukherjee | c22e2c5 | 2020-07-07 00:06:58 -0700 | [diff] [blame] | 79 | #include "av1/encoder/subgop.h" |
Satish Kumar Suman | 7a5f5f4 | 2020-06-09 14:20:47 +0530 | [diff] [blame] | 80 | #include "av1/encoder/superres_scale.h" |
Debargha Mukherjee | 347c64d | 2019-05-08 13:53:46 -0700 | [diff] [blame] | 81 | #include "av1/encoder/tpl_model.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 82 | |
Imdad Sardharwalla | e68aa8a | 2018-03-07 18:52:54 +0000 | [diff] [blame] | 83 | #define DEFAULT_EXPLICIT_ORDER_HINT_BITS 7 |
Imdad Sardharwalla | e68aa8a | 2018-03-07 18:52:54 +0000 | [diff] [blame] | 84 | |
Debargha Mukherjee | a4c6f69 | 2021-03-16 19:45:46 -0700 | [diff] [blame] | 85 | #if CONFIG_NEW_INTER_MODES |
| 86 | #define DEF_MAX_DRL_REFMVS 4 |
| 87 | #endif // CONFIG_NEW_INTER_MODES |
| 88 | |
Debargha Mukherjee | 5802ebe | 2016-12-21 04:17:24 -0800 | [diff] [blame] | 89 | #if CONFIG_ENTROPY_STATS |
| 90 | FRAME_COUNTS aggregate_fc; |
| 91 | #endif // CONFIG_ENTROPY_STATS |
| 92 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 93 | // #define OUTPUT_YUV_REC |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 94 | #ifdef OUTPUT_YUV_REC |
| 95 | FILE *yuv_rec_file; |
| 96 | #define FILE_NAME_LEN 100 |
| 97 | #endif |
| 98 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 99 | static INLINE void Scale2Ratio(AOM_SCALING mode, int *hr, int *hs) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 100 | switch (mode) { |
| 101 | case NORMAL: |
| 102 | *hr = 1; |
| 103 | *hs = 1; |
| 104 | break; |
| 105 | case FOURFIVE: |
| 106 | *hr = 4; |
| 107 | *hs = 5; |
| 108 | break; |
| 109 | case THREEFIVE: |
| 110 | *hr = 3; |
| 111 | *hs = 5; |
| 112 | break; |
Marco Paniconi | 4e86937 | 2020-06-23 10:22:50 -0700 | [diff] [blame] | 113 | case THREEFOUR: |
| 114 | *hr = 3; |
| 115 | *hs = 4; |
| 116 | break; |
| 117 | case ONEFOUR: |
| 118 | *hr = 1; |
| 119 | *hs = 4; |
| 120 | break; |
| 121 | case ONEEIGHT: |
| 122 | *hr = 1; |
| 123 | *hs = 8; |
| 124 | break; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 125 | case ONETWO: |
| 126 | *hr = 1; |
| 127 | *hs = 2; |
| 128 | break; |
| 129 | default: |
| 130 | *hr = 1; |
| 131 | *hs = 1; |
| 132 | assert(0); |
| 133 | break; |
| 134 | } |
| 135 | } |
| 136 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 137 | int av1_set_active_map(AV1_COMP *cpi, unsigned char *new_map_16x16, int rows, |
| 138 | int cols) { |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 139 | const CommonModeInfoParams *const mi_params = &cpi->common.mi_params; |
| 140 | if (rows == mi_params->mb_rows && cols == mi_params->mb_cols) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 141 | unsigned char *const active_map_8x8 = cpi->active_map.map; |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 142 | const int mi_rows = mi_params->mi_rows; |
| 143 | const int mi_cols = mi_params->mi_cols; |
Jingning Han | 9d53302 | 2017-04-07 10:14:42 -0700 | [diff] [blame] | 144 | const int row_scale = mi_size_high[BLOCK_16X16] == 2 ? 1 : 2; |
| 145 | const int col_scale = mi_size_wide[BLOCK_16X16] == 2 ? 1 : 2; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 146 | cpi->active_map.update = 1; |
| 147 | if (new_map_16x16) { |
| 148 | int r, c; |
| 149 | for (r = 0; r < mi_rows; ++r) { |
| 150 | for (c = 0; c < mi_cols; ++c) { |
| 151 | active_map_8x8[r * mi_cols + c] = |
Jingning Han | 9d53302 | 2017-04-07 10:14:42 -0700 | [diff] [blame] | 152 | new_map_16x16[(r >> row_scale) * cols + (c >> col_scale)] |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 153 | ? AM_SEGMENT_ID_ACTIVE |
| 154 | : AM_SEGMENT_ID_INACTIVE; |
| 155 | } |
| 156 | } |
| 157 | cpi->active_map.enabled = 1; |
| 158 | } else { |
| 159 | cpi->active_map.enabled = 0; |
| 160 | } |
| 161 | return 0; |
| 162 | } else { |
| 163 | return -1; |
| 164 | } |
| 165 | } |
| 166 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 167 | int av1_get_active_map(AV1_COMP *cpi, unsigned char *new_map_16x16, int rows, |
| 168 | int cols) { |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 169 | const CommonModeInfoParams *const mi_params = &cpi->common.mi_params; |
| 170 | if (rows == mi_params->mb_rows && cols == mi_params->mb_cols && |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 171 | new_map_16x16) { |
Vishesh | 8c90fff | 2020-04-13 11:32:56 +0530 | [diff] [blame] | 172 | unsigned char *const seg_map_8x8 = cpi->enc_seg.map; |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 173 | const int mi_rows = mi_params->mi_rows; |
| 174 | const int mi_cols = mi_params->mi_cols; |
Jingning Han | 9d53302 | 2017-04-07 10:14:42 -0700 | [diff] [blame] | 175 | const int row_scale = mi_size_high[BLOCK_16X16] == 2 ? 1 : 2; |
| 176 | const int col_scale = mi_size_wide[BLOCK_16X16] == 2 ? 1 : 2; |
| 177 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 178 | memset(new_map_16x16, !cpi->active_map.enabled, rows * cols); |
| 179 | if (cpi->active_map.enabled) { |
| 180 | int r, c; |
| 181 | for (r = 0; r < mi_rows; ++r) { |
| 182 | for (c = 0; c < mi_cols; ++c) { |
| 183 | // Cyclic refresh segments are considered active despite not having |
| 184 | // AM_SEGMENT_ID_ACTIVE |
Jingning Han | 9d53302 | 2017-04-07 10:14:42 -0700 | [diff] [blame] | 185 | new_map_16x16[(r >> row_scale) * cols + (c >> col_scale)] |= |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 186 | seg_map_8x8[r * mi_cols + c] != AM_SEGMENT_ID_INACTIVE; |
| 187 | } |
| 188 | } |
| 189 | } |
| 190 | return 0; |
| 191 | } else { |
| 192 | return -1; |
| 193 | } |
| 194 | } |
| 195 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 196 | void av1_initialize_enc(void) { |
Wan-Teh Chang | 3cac454 | 2018-06-29 10:21:39 -0700 | [diff] [blame] | 197 | av1_rtcd(); |
| 198 | aom_dsp_rtcd(); |
| 199 | aom_scale_rtcd(); |
| 200 | av1_init_intra_predictors(); |
| 201 | av1_init_me_luts(); |
| 202 | av1_rc_init_minq_luts(); |
| 203 | av1_init_wedge_masks(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 204 | } |
| 205 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 206 | static void update_reference_segmentation_map(AV1_COMP *cpi) { |
| 207 | AV1_COMMON *const cm = &cpi->common; |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 208 | const CommonModeInfoParams *const mi_params = &cm->mi_params; |
| 209 | MB_MODE_INFO **mi_4x4_ptr = mi_params->mi_grid_base; |
David Turner | b757ce0 | 2018-11-12 15:01:28 +0000 | [diff] [blame] | 210 | uint8_t *cache_ptr = cm->cur_frame->seg_map; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 211 | |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 212 | for (int row = 0; row < mi_params->mi_rows; row++) { |
Yushin Cho | a7f6592 | 2018-04-04 16:06:11 -0700 | [diff] [blame] | 213 | MB_MODE_INFO **mi_4x4 = mi_4x4_ptr; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 214 | uint8_t *cache = cache_ptr; |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 215 | for (int col = 0; col < mi_params->mi_cols; col++, mi_4x4++, cache++) |
Yushin Cho | a7f6592 | 2018-04-04 16:06:11 -0700 | [diff] [blame] | 216 | cache[0] = mi_4x4[0]->segment_id; |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 217 | mi_4x4_ptr += mi_params->mi_stride; |
| 218 | cache_ptr += mi_params->mi_cols; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 219 | } |
| 220 | } |
| 221 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 222 | void av1_new_framerate(AV1_COMP *cpi, double framerate) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 223 | cpi->framerate = framerate < 0.1 ? 30 : framerate; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 224 | av1_rc_update_framerate(cpi, cpi->common.width, cpi->common.height); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 225 | } |
| 226 | |
Hui Su | ef139e1 | 2019-05-20 15:51:22 -0700 | [diff] [blame] | 227 | double av1_get_compression_ratio(const AV1_COMMON *const cm, |
| 228 | size_t encoded_frame_size) { |
| 229 | const int upscaled_width = cm->superres_upscaled_width; |
| 230 | const int height = cm->height; |
| 231 | const int luma_pic_size = upscaled_width * height; |
| 232 | const SequenceHeader *const seq_params = &cm->seq_params; |
| 233 | const BITSTREAM_PROFILE profile = seq_params->profile; |
| 234 | const int pic_size_profile_factor = |
| 235 | profile == PROFILE_0 ? 15 : (profile == PROFILE_1 ? 30 : 36); |
| 236 | encoded_frame_size = |
| 237 | (encoded_frame_size > 129 ? encoded_frame_size - 128 : 1); |
| 238 | const size_t uncompressed_frame_size = |
| 239 | (luma_pic_size * pic_size_profile_factor) >> 3; |
| 240 | return uncompressed_frame_size / (double)encoded_frame_size; |
| 241 | } |
| 242 | |
Vishesh | 0481a78 | 2020-06-11 14:32:46 +0530 | [diff] [blame] | 243 | static void set_tile_info(AV1_COMMON *const cm, |
| 244 | const TileConfig *const tile_cfg) { |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 245 | const CommonModeInfoParams *const mi_params = &cm->mi_params; |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 246 | const SequenceHeader *const seq_params = &cm->seq_params; |
| 247 | CommonTileParams *const tiles = &cm->tiles; |
Dominic Symes | f58f111 | 2017-09-25 12:47:40 +0200 | [diff] [blame] | 248 | int i, start_sb; |
Dominic Symes | db5d66f | 2017-08-18 18:11:34 +0200 | [diff] [blame] | 249 | |
| 250 | av1_get_tile_limits(cm); |
Dominic Symes | db5d66f | 2017-08-18 18:11:34 +0200 | [diff] [blame] | 251 | |
| 252 | // configure tile columns |
Vishesh | 0481a78 | 2020-06-11 14:32:46 +0530 | [diff] [blame] | 253 | if (tile_cfg->tile_width_count == 0 || tile_cfg->tile_height_count == 0) { |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 254 | tiles->uniform_spacing = 1; |
Vishesh | 0481a78 | 2020-06-11 14:32:46 +0530 | [diff] [blame] | 255 | tiles->log2_cols = AOMMAX(tile_cfg->tile_columns, tiles->min_log2_cols); |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 256 | tiles->log2_cols = AOMMIN(tiles->log2_cols, tiles->max_log2_cols); |
Dominic Symes | f58f111 | 2017-09-25 12:47:40 +0200 | [diff] [blame] | 257 | } else { |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 258 | int mi_cols = |
| 259 | ALIGN_POWER_OF_TWO(mi_params->mi_cols, seq_params->mib_size_log2); |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 260 | int sb_cols = mi_cols >> seq_params->mib_size_log2; |
Dominic Symes | 26ad0b2 | 2017-10-01 16:35:13 +0200 | [diff] [blame] | 261 | int size_sb, j = 0; |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 262 | tiles->uniform_spacing = 0; |
Dominic Symes | f58f111 | 2017-09-25 12:47:40 +0200 | [diff] [blame] | 263 | for (i = 0, start_sb = 0; start_sb < sb_cols && i < MAX_TILE_COLS; i++) { |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 264 | tiles->col_start_sb[i] = start_sb; |
Vishesh | 0481a78 | 2020-06-11 14:32:46 +0530 | [diff] [blame] | 265 | size_sb = tile_cfg->tile_widths[j++]; |
| 266 | if (j >= tile_cfg->tile_width_count) j = 0; |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 267 | start_sb += AOMMIN(size_sb, tiles->max_width_sb); |
Dominic Symes | f58f111 | 2017-09-25 12:47:40 +0200 | [diff] [blame] | 268 | } |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 269 | tiles->cols = i; |
| 270 | tiles->col_start_sb[i] = sb_cols; |
Dominic Symes | db5d66f | 2017-08-18 18:11:34 +0200 | [diff] [blame] | 271 | } |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 272 | av1_calculate_tile_cols(seq_params, mi_params->mi_rows, mi_params->mi_cols, |
| 273 | tiles); |
Dominic Symes | db5d66f | 2017-08-18 18:11:34 +0200 | [diff] [blame] | 274 | |
| 275 | // configure tile rows |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 276 | if (tiles->uniform_spacing) { |
Vishesh | 0481a78 | 2020-06-11 14:32:46 +0530 | [diff] [blame] | 277 | tiles->log2_rows = AOMMAX(tile_cfg->tile_rows, tiles->min_log2_rows); |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 278 | tiles->log2_rows = AOMMIN(tiles->log2_rows, tiles->max_log2_rows); |
Dominic Symes | f58f111 | 2017-09-25 12:47:40 +0200 | [diff] [blame] | 279 | } else { |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 280 | int mi_rows = |
| 281 | ALIGN_POWER_OF_TWO(mi_params->mi_rows, seq_params->mib_size_log2); |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 282 | int sb_rows = mi_rows >> seq_params->mib_size_log2; |
Dominic Symes | 26ad0b2 | 2017-10-01 16:35:13 +0200 | [diff] [blame] | 283 | int size_sb, j = 0; |
Dominic Symes | f58f111 | 2017-09-25 12:47:40 +0200 | [diff] [blame] | 284 | for (i = 0, start_sb = 0; start_sb < sb_rows && i < MAX_TILE_ROWS; i++) { |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 285 | tiles->row_start_sb[i] = start_sb; |
Vishesh | 0481a78 | 2020-06-11 14:32:46 +0530 | [diff] [blame] | 286 | size_sb = tile_cfg->tile_heights[j++]; |
| 287 | if (j >= tile_cfg->tile_height_count) j = 0; |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 288 | start_sb += AOMMIN(size_sb, tiles->max_height_sb); |
Dominic Symes | f58f111 | 2017-09-25 12:47:40 +0200 | [diff] [blame] | 289 | } |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 290 | tiles->rows = i; |
| 291 | tiles->row_start_sb[i] = sb_rows; |
Dominic Symes | db5d66f | 2017-08-18 18:11:34 +0200 | [diff] [blame] | 292 | } |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 293 | av1_calculate_tile_rows(seq_params, mi_params->mi_rows, tiles); |
Dominic Symes | db5d66f | 2017-08-18 18:11:34 +0200 | [diff] [blame] | 294 | } |
| 295 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 296 | static void update_frame_size(AV1_COMP *cpi) { |
| 297 | AV1_COMMON *const cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 298 | MACROBLOCKD *const xd = &cpi->td.mb.e_mbd; |
| 299 | |
chiyotsai | a7091f1 | 2019-08-09 16:48:27 -0700 | [diff] [blame] | 300 | // We need to reallocate the context buffers here in case we need more mis. |
| 301 | if (av1_alloc_context_buffers(cm, cm->width, cm->height)) { |
| 302 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
| 303 | "Failed to allocate context buffers"); |
| 304 | } |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 305 | av1_init_mi_buffers(&cm->mi_params); |
chiyotsai | a7091f1 | 2019-08-09 16:48:27 -0700 | [diff] [blame] | 306 | |
Urvang Joshi | 9543ad7 | 2020-04-17 16:59:46 -0700 | [diff] [blame] | 307 | av1_init_macroblockd(cm, xd); |
chiyotsai | 426c066 | 2019-08-05 16:15:11 -0700 | [diff] [blame] | 308 | |
Vishesh | d131791 | 2020-04-07 14:39:44 +0530 | [diff] [blame] | 309 | if (!is_stat_generation_stage(cpi)) |
| 310 | alloc_context_buffers_ext(cm, &cpi->mbmi_ext_info); |
Deepa K G | efb2d24 | 2020-07-08 17:43:49 +0530 | [diff] [blame] | 311 | |
| 312 | if (!cpi->seq_params_locked) |
Jayasanker J | dee179d | 2020-07-10 23:47:37 +0530 | [diff] [blame] | 313 | set_sb_size(&cm->seq_params, av1_select_sb_size(cpi)); |
Deepa K G | efb2d24 | 2020-07-08 17:43:49 +0530 | [diff] [blame] | 314 | |
Vishesh | 0481a78 | 2020-06-11 14:32:46 +0530 | [diff] [blame] | 315 | set_tile_info(cm, &cpi->oxcf.tile_cfg); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 316 | } |
| 317 | |
Debargha Mukherjee | 5749869 | 2018-05-11 13:29:31 -0700 | [diff] [blame] | 318 | static INLINE int does_level_match(int width, int height, double fps, |
| 319 | int lvl_width, int lvl_height, |
| 320 | double lvl_fps, int lvl_dim_mult) { |
| 321 | const int64_t lvl_luma_pels = lvl_width * lvl_height; |
| 322 | const double lvl_display_sample_rate = lvl_luma_pels * lvl_fps; |
| 323 | const int64_t luma_pels = width * height; |
| 324 | const double display_sample_rate = luma_pels * fps; |
| 325 | return luma_pels <= lvl_luma_pels && |
| 326 | display_sample_rate <= lvl_display_sample_rate && |
| 327 | width <= lvl_width * lvl_dim_mult && |
| 328 | height <= lvl_height * lvl_dim_mult; |
| 329 | } |
| 330 | |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 331 | static void set_bitstream_level_tier(SequenceHeader *seq, AV1_COMMON *cm, |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 332 | int width, int height, |
| 333 | double init_framerate) { |
Debargha Mukherjee | 5749869 | 2018-05-11 13:29:31 -0700 | [diff] [blame] | 334 | // TODO(any): This is a placeholder function that only addresses dimensions |
| 335 | // and max display sample rates. |
| 336 | // Need to add checks for max bit rate, max decoded luma sample rate, header |
| 337 | // rate, etc. that are not covered by this function. |
Hui Su | 8427ff2 | 2019-03-11 10:14:33 -0700 | [diff] [blame] | 338 | AV1_LEVEL level = SEQ_LEVEL_MAX; |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 339 | if (does_level_match(width, height, init_framerate, 512, 288, 30.0, 4)) { |
Hui Su | 8427ff2 | 2019-03-11 10:14:33 -0700 | [diff] [blame] | 340 | level = SEQ_LEVEL_2_0; |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 341 | } else if (does_level_match(width, height, init_framerate, 704, 396, 30.0, |
| 342 | 4)) { |
Hui Su | 8427ff2 | 2019-03-11 10:14:33 -0700 | [diff] [blame] | 343 | level = SEQ_LEVEL_2_1; |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 344 | } else if (does_level_match(width, height, init_framerate, 1088, 612, 30.0, |
| 345 | 4)) { |
Hui Su | 8427ff2 | 2019-03-11 10:14:33 -0700 | [diff] [blame] | 346 | level = SEQ_LEVEL_3_0; |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 347 | } else if (does_level_match(width, height, init_framerate, 1376, 774, 30.0, |
| 348 | 4)) { |
Hui Su | 8427ff2 | 2019-03-11 10:14:33 -0700 | [diff] [blame] | 349 | level = SEQ_LEVEL_3_1; |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 350 | } else if (does_level_match(width, height, init_framerate, 2048, 1152, 30.0, |
| 351 | 3)) { |
Hui Su | 8427ff2 | 2019-03-11 10:14:33 -0700 | [diff] [blame] | 352 | level = SEQ_LEVEL_4_0; |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 353 | } else if (does_level_match(width, height, init_framerate, 2048, 1152, 60.0, |
| 354 | 3)) { |
Hui Su | 8427ff2 | 2019-03-11 10:14:33 -0700 | [diff] [blame] | 355 | level = SEQ_LEVEL_4_1; |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 356 | } else if (does_level_match(width, height, init_framerate, 4096, 2176, 30.0, |
| 357 | 2)) { |
Hui Su | 8427ff2 | 2019-03-11 10:14:33 -0700 | [diff] [blame] | 358 | level = SEQ_LEVEL_5_0; |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 359 | } else if (does_level_match(width, height, init_framerate, 4096, 2176, 60.0, |
| 360 | 2)) { |
Hui Su | 8427ff2 | 2019-03-11 10:14:33 -0700 | [diff] [blame] | 361 | level = SEQ_LEVEL_5_1; |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 362 | } else if (does_level_match(width, height, init_framerate, 4096, 2176, 120.0, |
| 363 | 2)) { |
Hui Su | 8427ff2 | 2019-03-11 10:14:33 -0700 | [diff] [blame] | 364 | level = SEQ_LEVEL_5_2; |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 365 | } else if (does_level_match(width, height, init_framerate, 8192, 4352, 30.0, |
| 366 | 2)) { |
Hui Su | 8427ff2 | 2019-03-11 10:14:33 -0700 | [diff] [blame] | 367 | level = SEQ_LEVEL_6_0; |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 368 | } else if (does_level_match(width, height, init_framerate, 8192, 4352, 60.0, |
| 369 | 2)) { |
Todd Nguyen | ff4c860 | 2019-11-25 13:20:21 -0800 | [diff] [blame] | 370 | level = SEQ_LEVEL_6_1; |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 371 | } else if (does_level_match(width, height, init_framerate, 8192, 4352, 120.0, |
| 372 | 2)) { |
Hui Su | 8427ff2 | 2019-03-11 10:14:33 -0700 | [diff] [blame] | 373 | level = SEQ_LEVEL_6_2; |
Debargha Mukherjee | 5749869 | 2018-05-11 13:29:31 -0700 | [diff] [blame] | 374 | } |
chiyotsai | aa33bbf | 2019-12-02 12:07:53 -0800 | [diff] [blame] | 375 | |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 376 | SequenceHeader *const seq_params = &cm->seq_params; |
Debargha Mukherjee | ea67540 | 2018-05-10 16:10:41 -0700 | [diff] [blame] | 377 | for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i) { |
Hui Su | 8427ff2 | 2019-03-11 10:14:33 -0700 | [diff] [blame] | 378 | seq->seq_level_idx[i] = level; |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 379 | // Set the maximum parameters for bitrate and buffer size for this profile, |
| 380 | // level, and tier |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 381 | seq_params->op_params[i].bitrate = av1_max_level_bitrate( |
Hui Su | 8427ff2 | 2019-03-11 10:14:33 -0700 | [diff] [blame] | 382 | cm->seq_params.profile, seq->seq_level_idx[i], seq->tier[i]); |
Andrey Norkin | c7511de | 2018-06-22 12:31:06 -0700 | [diff] [blame] | 383 | // Level with seq_level_idx = 31 returns a high "dummy" bitrate to pass the |
| 384 | // check |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 385 | if (seq_params->op_params[i].bitrate == 0) |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 386 | aom_internal_error( |
| 387 | &cm->error, AOM_CODEC_UNSUP_BITSTREAM, |
| 388 | "AV1 does not support this combination of profile, level, and tier."); |
Andrey Norkin | c7511de | 2018-06-22 12:31:06 -0700 | [diff] [blame] | 389 | // Buffer size in bits/s is bitrate in bits/s * 1 s |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 390 | seq_params->op_params[i].buffer_size = seq_params->op_params[i].bitrate; |
Debargha Mukherjee | ea67540 | 2018-05-10 16:10:41 -0700 | [diff] [blame] | 391 | } |
| 392 | } |
| 393 | |
Marco Paniconi | 2aa13c4 | 2020-06-01 11:18:38 -0700 | [diff] [blame] | 394 | void av1_init_seq_coding_tools(SequenceHeader *seq, AV1_COMMON *cm, |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 395 | const AV1EncoderConfig *oxcf |
| 396 | #if CONFIG_SVC_ENCODER |
| 397 | , |
| 398 | int use_svc |
| 399 | #endif // CONFIG_SVC_ENCODER |
| 400 | ) { |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 401 | const FrameDimensionCfg *const frm_dim_cfg = &oxcf->frm_dim_cfg; |
Vishesh | aa6a170 | 2020-06-30 19:27:22 +0530 | [diff] [blame] | 402 | const ToolCfg *const tool_cfg = &oxcf->tool_cfg; |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 403 | |
Vishesh | 4342d7f | 2020-06-29 18:49:06 +0530 | [diff] [blame] | 404 | seq->still_picture = |
Vishesh | aa6a170 | 2020-06-30 19:27:22 +0530 | [diff] [blame] | 405 | (tool_cfg->force_video_mode == 0) && (oxcf->input_cfg.limit == 1); |
Debargha Mukherjee | c6f24c2 | 2018-04-07 08:43:08 -0700 | [diff] [blame] | 406 | seq->reduced_still_picture_hdr = seq->still_picture; |
Vishesh | aa6a170 | 2020-06-30 19:27:22 +0530 | [diff] [blame] | 407 | seq->reduced_still_picture_hdr &= !tool_cfg->full_still_picture_hdr; |
Fyodor Kyslov | 2b492d8 | 2021-07-11 16:37:35 -0700 | [diff] [blame] | 408 | seq->force_screen_content_tools = 2; |
Debargha Mukherjee | edd7725 | 2018-03-25 12:01:38 -0700 | [diff] [blame] | 409 | seq->force_integer_mv = 2; |
Vishesh | aa6a170 | 2020-06-30 19:27:22 +0530 | [diff] [blame] | 410 | seq->order_hint_info.enable_order_hint = tool_cfg->enable_order_hint; |
David Turner | 936235c | 2018-11-28 13:42:01 +0000 | [diff] [blame] | 411 | seq->frame_id_numbers_present_flag = |
| 412 | !(seq->still_picture && seq->reduced_still_picture_hdr) && |
Vishesh | aa6a170 | 2020-06-30 19:27:22 +0530 | [diff] [blame] | 413 | !oxcf->tile_cfg.enable_large_scale_tile && |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 414 | #if CONFIG_SVC_ENCODER |
| 415 | !use_svc && |
| 416 | #endif // CONFIG_SVC_ENCODER |
| 417 | tool_cfg->error_resilient_mode; |
Debargha Mukherjee | c6f24c2 | 2018-04-07 08:43:08 -0700 | [diff] [blame] | 418 | if (seq->still_picture && seq->reduced_still_picture_hdr) { |
David Turner | ebf96f4 | 2018-11-14 16:57:57 +0000 | [diff] [blame] | 419 | seq->order_hint_info.enable_order_hint = 0; |
Debargha Mukherjee | c6f24c2 | 2018-04-07 08:43:08 -0700 | [diff] [blame] | 420 | seq->force_screen_content_tools = 2; |
| 421 | seq->force_integer_mv = 2; |
| 422 | } |
David Turner | ebf96f4 | 2018-11-14 16:57:57 +0000 | [diff] [blame] | 423 | seq->order_hint_info.order_hint_bits_minus_1 = |
| 424 | seq->order_hint_info.enable_order_hint |
| 425 | ? DEFAULT_EXPLICIT_ORDER_HINT_BITS - 1 |
| 426 | : -1; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 427 | #if CONFIG_NEW_REF_SIGNALING |
| 428 | seq->explicit_ref_frame_map = oxcf->ref_frm_cfg.explicit_ref_frame_map; |
| 429 | seq->max_reference_frames = oxcf->ref_frm_cfg.max_reference_frames; |
| 430 | #endif // CONFIG_NEW_REF_SIGNALING |
Debargha Mukherjee | c6f24c2 | 2018-04-07 08:43:08 -0700 | [diff] [blame] | 431 | |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 432 | seq->max_frame_width = frm_dim_cfg->forced_max_frame_width |
| 433 | ? frm_dim_cfg->forced_max_frame_width |
| 434 | : frm_dim_cfg->width; |
| 435 | seq->max_frame_height = frm_dim_cfg->forced_max_frame_height |
| 436 | ? frm_dim_cfg->forced_max_frame_height |
| 437 | : frm_dim_cfg->height; |
David Turner | 760a2f4 | 2018-12-07 15:25:36 +0000 | [diff] [blame] | 438 | seq->num_bits_width = |
| 439 | (seq->max_frame_width > 1) ? get_msb(seq->max_frame_width - 1) + 1 : 1; |
| 440 | seq->num_bits_height = |
| 441 | (seq->max_frame_height > 1) ? get_msb(seq->max_frame_height - 1) + 1 : 1; |
| 442 | assert(seq->num_bits_width <= 16); |
| 443 | assert(seq->num_bits_height <= 16); |
| 444 | |
| 445 | seq->frame_id_length = FRAME_ID_LENGTH; |
| 446 | seq->delta_frame_id_length = DELTA_FRAME_ID_LENGTH; |
| 447 | |
Hui Su | 93c395b | 2020-10-05 12:00:20 -0700 | [diff] [blame] | 448 | #if !CONFIG_REMOVE_DUAL_FILTER |
Vishesh | aa6a170 | 2020-06-30 19:27:22 +0530 | [diff] [blame] | 449 | seq->enable_dual_filter = tool_cfg->enable_dual_filter; |
Hui Su | 93c395b | 2020-10-05 12:00:20 -0700 | [diff] [blame] | 450 | #endif // !CONFIG_REMOVE_DUAL_FILTER |
Vishesh | aa6a170 | 2020-06-30 19:27:22 +0530 | [diff] [blame] | 451 | seq->order_hint_info.enable_ref_frame_mvs = tool_cfg->ref_frame_mvs_present; |
David Turner | ebf96f4 | 2018-11-14 16:57:57 +0000 | [diff] [blame] | 452 | seq->order_hint_info.enable_ref_frame_mvs &= |
| 453 | seq->order_hint_info.enable_order_hint; |
Vishesh | 0d279aa | 2020-06-03 15:56:56 +0530 | [diff] [blame] | 454 | seq->enable_superres = oxcf->superres_cfg.enable_superres; |
Vishesh | aa6a170 | 2020-06-30 19:27:22 +0530 | [diff] [blame] | 455 | seq->enable_cdef = tool_cfg->enable_cdef; |
| 456 | seq->enable_restoration = tool_cfg->enable_restoration; |
yixindu | 368bde5 | 2021-06-04 18:30:53 -0700 | [diff] [blame] | 457 | #if CONFIG_CCSO |
| 458 | seq->enable_ccso = tool_cfg->enable_ccso; |
| 459 | #endif |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 460 | #if CONFIG_OPTFLOW_REFINEMENT |
| 461 | seq->enable_opfl_refine = tool_cfg->enable_opfl_refine; |
| 462 | #endif // CONFIG_OPTFLOW_REFINEMENT |
Vishesh | 015b496 | 2020-06-15 14:19:55 +0530 | [diff] [blame] | 463 | seq->enable_warped_motion = oxcf->motion_mode_cfg.enable_warped_motion; |
Vishesh | aa6a170 | 2020-06-30 19:27:22 +0530 | [diff] [blame] | 464 | seq->enable_interintra_compound = tool_cfg->enable_interintra_comp; |
Vishesh | 8db8a20 | 2020-06-02 17:09:45 +0530 | [diff] [blame] | 465 | seq->enable_masked_compound = oxcf->comp_type_cfg.enable_masked_comp; |
Vishesh | 2964984 | 2020-06-01 18:18:36 +0530 | [diff] [blame] | 466 | seq->enable_intra_edge_filter = oxcf->intra_mode_cfg.enable_intra_edge_filter; |
| 467 | seq->enable_filter_intra = oxcf->intra_mode_cfg.enable_filter_intra; |
leolzhao | 0214160 | 2021-02-16 15:06:35 -0800 | [diff] [blame] | 468 | #if CONFIG_SDP |
| 469 | seq->enable_sdp = oxcf->part_cfg.enable_sdp; |
| 470 | #endif |
leolzhao | 943a08d | 2021-03-30 15:32:52 -0700 | [diff] [blame] | 471 | #if CONFIG_MRLS |
| 472 | seq->enable_mrls = oxcf->intra_mode_cfg.enable_mrls; |
| 473 | #endif |
SARWER, Mohammed Golam | 4241ffe | 2021-06-08 11:06:06 -0700 | [diff] [blame] | 474 | #if CONFIG_ORIP |
| 475 | seq->enable_orip = oxcf->intra_mode_cfg.enable_orip; |
| 476 | #endif |
Madhu Peringassery Krishnan | ee0d2f0 | 2021-06-14 12:08:32 -0700 | [diff] [blame] | 477 | #if CONFIG_IST |
| 478 | seq->enable_ist = oxcf->txfm_cfg.enable_ist; |
| 479 | #endif |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 480 | #if CONFIG_IBP_DC || CONFIG_IBP_DIR |
| 481 | seq->enable_ibp = oxcf->intra_mode_cfg.enable_ibp; |
| 482 | #endif |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 483 | set_bitstream_level_tier(seq, cm, frm_dim_cfg->width, frm_dim_cfg->height, |
Vishesh | 4342d7f | 2020-06-29 18:49:06 +0530 | [diff] [blame] | 484 | oxcf->input_cfg.init_framerate); |
Adrian Grange | c56f6ec | 2018-05-31 14:19:32 -0700 | [diff] [blame] | 485 | |
| 486 | if (seq->operating_points_cnt_minus_1 == 0) { |
| 487 | seq->operating_point_idc[0] = 0; |
| 488 | } else { |
Marco Paniconi | 6da983b | 2019-09-16 20:12:43 -0700 | [diff] [blame] | 489 | // Set operating_point_idc[] such that the i=0 point corresponds to the |
| 490 | // highest quality operating point (all layers), and subsequent |
| 491 | // operarting points (i > 0) are lower quality corresponding to |
| 492 | // skip decoding enhancement layers (temporal first). |
| 493 | int i = 0; |
| 494 | assert(seq->operating_points_cnt_minus_1 == |
| 495 | (int)(cm->number_spatial_layers * cm->number_temporal_layers - 1)); |
| 496 | for (unsigned int sl = 0; sl < cm->number_spatial_layers; sl++) { |
| 497 | for (unsigned int tl = 0; tl < cm->number_temporal_layers; tl++) { |
| 498 | seq->operating_point_idc[i] = |
| 499 | (~(~0u << (cm->number_spatial_layers - sl)) << 8) | |
| 500 | ~(~0u << (cm->number_temporal_layers - tl)); |
| 501 | i++; |
| 502 | } |
| 503 | } |
Adrian Grange | c56f6ec | 2018-05-31 14:19:32 -0700 | [diff] [blame] | 504 | } |
Ryan Lei | ccc6ea7 | 2021-01-06 11:43:56 -0800 | [diff] [blame] | 505 | #if CONFIG_EXTQUANT |
| 506 | const int is_360p_or_larger = |
| 507 | AOMMIN(seq->max_frame_width, seq->max_frame_height) >= 360; |
| 508 | const int is_720p_or_larger = |
| 509 | AOMMIN(seq->max_frame_width, seq->max_frame_height) >= 720; |
| 510 | if (!is_360p_or_larger) { |
| 511 | seq->base_y_dc_delta_q = -7; |
| 512 | seq->base_uv_dc_delta_q = -6; |
| 513 | } else if (!is_720p_or_larger) { |
| 514 | seq->base_y_dc_delta_q = -5; |
| 515 | seq->base_uv_dc_delta_q = -4; |
| 516 | } else { |
| 517 | seq->base_y_dc_delta_q = -4; |
| 518 | seq->base_uv_dc_delta_q = -3; |
| 519 | } |
| 520 | #endif // CONFIG_EXTQUANT |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 521 | #if CONFIG_REF_MV_BANK |
| 522 | seq->enable_refmvbank = tool_cfg->enable_refmvbank; |
| 523 | #endif // CONFIG_REF_MV_BANK |
Debargha Mukherjee | edd7725 | 2018-03-25 12:01:38 -0700 | [diff] [blame] | 524 | } |
| 525 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 526 | static void init_config(struct AV1_COMP *cpi, AV1EncoderConfig *oxcf) { |
| 527 | AV1_COMMON *const cm = &cpi->common; |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 528 | SequenceHeader *const seq_params = &cm->seq_params; |
Jayasanker J | 0b1dd29 | 2020-04-09 15:47:25 +0530 | [diff] [blame] | 529 | ResizePendingParams *resize_pending_params = &cpi->resize_pending_params; |
Vishesh | a908224 | 2020-06-17 18:26:09 +0530 | [diff] [blame] | 530 | const DecoderModelCfg *const dec_model_cfg = &oxcf->dec_model_cfg; |
Vishesh | 52fdeae | 2020-06-24 14:37:00 +0530 | [diff] [blame] | 531 | const ColorCfg *const color_cfg = &oxcf->color_cfg; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 532 | cpi->oxcf = *oxcf; |
Vishesh | 4342d7f | 2020-06-29 18:49:06 +0530 | [diff] [blame] | 533 | cpi->framerate = oxcf->input_cfg.init_framerate; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 534 | |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 535 | seq_params->profile = oxcf->profile; |
Vishesh | aa6a170 | 2020-06-30 19:27:22 +0530 | [diff] [blame] | 536 | seq_params->bit_depth = oxcf->tool_cfg.bit_depth; |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 537 | seq_params->use_highbitdepth = oxcf->use_highbitdepth; |
Vishesh | 52fdeae | 2020-06-24 14:37:00 +0530 | [diff] [blame] | 538 | seq_params->color_primaries = color_cfg->color_primaries; |
| 539 | seq_params->transfer_characteristics = color_cfg->transfer_characteristics; |
| 540 | seq_params->matrix_coefficients = color_cfg->matrix_coefficients; |
Vishesh | aa6a170 | 2020-06-30 19:27:22 +0530 | [diff] [blame] | 541 | seq_params->monochrome = oxcf->tool_cfg.enable_monochrome; |
Vishesh | 073fc96 | 2020-07-01 17:39:16 +0530 | [diff] [blame] | 542 | seq_params->chroma_sample_position = color_cfg->chroma_sample_position; |
Vishesh | 52fdeae | 2020-06-24 14:37:00 +0530 | [diff] [blame] | 543 | seq_params->color_range = color_cfg->color_range; |
Vishesh | a908224 | 2020-06-17 18:26:09 +0530 | [diff] [blame] | 544 | seq_params->timing_info_present = dec_model_cfg->timing_info_present; |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 545 | seq_params->timing_info.num_units_in_display_tick = |
Vishesh | a908224 | 2020-06-17 18:26:09 +0530 | [diff] [blame] | 546 | dec_model_cfg->timing_info.num_units_in_display_tick; |
| 547 | seq_params->timing_info.time_scale = dec_model_cfg->timing_info.time_scale; |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 548 | seq_params->timing_info.equal_picture_interval = |
Vishesh | a908224 | 2020-06-17 18:26:09 +0530 | [diff] [blame] | 549 | dec_model_cfg->timing_info.equal_picture_interval; |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 550 | seq_params->timing_info.num_ticks_per_picture = |
Vishesh | a908224 | 2020-06-17 18:26:09 +0530 | [diff] [blame] | 551 | dec_model_cfg->timing_info.num_ticks_per_picture; |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 552 | |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 553 | seq_params->display_model_info_present_flag = |
Vishesh | a908224 | 2020-06-17 18:26:09 +0530 | [diff] [blame] | 554 | dec_model_cfg->display_model_info_present_flag; |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 555 | seq_params->decoder_model_info_present_flag = |
Vishesh | a908224 | 2020-06-17 18:26:09 +0530 | [diff] [blame] | 556 | dec_model_cfg->decoder_model_info_present_flag; |
| 557 | if (dec_model_cfg->decoder_model_info_present_flag) { |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 558 | // set the decoder model parameters in schedule mode |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 559 | seq_params->decoder_model_info.num_units_in_decoding_tick = |
Vishesh | a908224 | 2020-06-17 18:26:09 +0530 | [diff] [blame] | 560 | dec_model_cfg->num_units_in_decoding_tick; |
Wan-Teh Chang | f64b3bc | 2018-07-02 09:42:39 -0700 | [diff] [blame] | 561 | cm->buffer_removal_time_present = 1; |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 562 | av1_set_aom_dec_model_info(&seq_params->decoder_model_info); |
| 563 | av1_set_dec_model_op_parameters(&seq_params->op_params[0]); |
| 564 | } else if (seq_params->timing_info_present && |
| 565 | seq_params->timing_info.equal_picture_interval && |
| 566 | !seq_params->decoder_model_info_present_flag) { |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 567 | // set the decoder model parameters in resource availability mode |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 568 | av1_set_resource_availability_parameters(&seq_params->op_params[0]); |
Andrey Norkin | c7511de | 2018-06-22 12:31:06 -0700 | [diff] [blame] | 569 | } else { |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 570 | seq_params->op_params[0].initial_display_delay = |
Andrey Norkin | c7511de | 2018-06-22 12:31:06 -0700 | [diff] [blame] | 571 | 10; // Default value (not signaled) |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 572 | } |
Andrey Norkin | c7511de | 2018-06-22 12:31:06 -0700 | [diff] [blame] | 573 | |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 574 | if (seq_params->monochrome) { |
| 575 | seq_params->subsampling_x = 1; |
| 576 | seq_params->subsampling_y = 1; |
| 577 | } else if (seq_params->color_primaries == AOM_CICP_CP_BT_709 && |
| 578 | seq_params->transfer_characteristics == AOM_CICP_TC_SRGB && |
| 579 | seq_params->matrix_coefficients == AOM_CICP_MC_IDENTITY) { |
| 580 | seq_params->subsampling_x = 0; |
| 581 | seq_params->subsampling_y = 0; |
Tom Finegan | f8d6a16 | 2018-08-21 10:47:55 -0700 | [diff] [blame] | 582 | } else { |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 583 | if (seq_params->profile == 0) { |
| 584 | seq_params->subsampling_x = 1; |
| 585 | seq_params->subsampling_y = 1; |
| 586 | } else if (seq_params->profile == 1) { |
| 587 | seq_params->subsampling_x = 0; |
| 588 | seq_params->subsampling_y = 0; |
Tom Finegan | f8d6a16 | 2018-08-21 10:47:55 -0700 | [diff] [blame] | 589 | } else { |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 590 | if (seq_params->bit_depth == AOM_BITS_12) { |
Vishesh | 4342d7f | 2020-06-29 18:49:06 +0530 | [diff] [blame] | 591 | seq_params->subsampling_x = oxcf->input_cfg.chroma_subsampling_x; |
| 592 | seq_params->subsampling_y = oxcf->input_cfg.chroma_subsampling_y; |
Tom Finegan | f8d6a16 | 2018-08-21 10:47:55 -0700 | [diff] [blame] | 593 | } else { |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 594 | seq_params->subsampling_x = 1; |
| 595 | seq_params->subsampling_y = 0; |
Tom Finegan | f8d6a16 | 2018-08-21 10:47:55 -0700 | [diff] [blame] | 596 | } |
| 597 | } |
Tom Finegan | 02b2a84 | 2018-08-24 13:50:00 -0700 | [diff] [blame] | 598 | } |
| 599 | |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 600 | cm->width = oxcf->frm_dim_cfg.width; |
| 601 | cm->height = oxcf->frm_dim_cfg.height; |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 602 | set_sb_size(seq_params, |
Satish Kumar Suman | 36adf35 | 2020-06-26 11:20:10 +0530 | [diff] [blame] | 603 | av1_select_sb_size(cpi)); // set sb size before allocations |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 604 | alloc_compressor_data(cpi); |
Yaowu Xu | c7119a7 | 2018-03-29 09:59:37 -0700 | [diff] [blame] | 605 | |
Satish Kumar Suman | 36adf35 | 2020-06-26 11:20:10 +0530 | [diff] [blame] | 606 | av1_update_film_grain_parameters(cpi, oxcf); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 607 | |
| 608 | // Single thread case: use counts in common. |
Yue Chen | cc6a6ef | 2018-05-21 16:21:05 -0700 | [diff] [blame] | 609 | cpi->td.counts = &cpi->counts; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 610 | |
Marco Paniconi | 882c5ad | 2019-09-30 21:32:29 -0700 | [diff] [blame] | 611 | // Set init SVC parameters. |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 612 | #if CONFIG_SVC_ENCODER |
Marco Paniconi | 6714211 | 2019-07-24 15:00:31 -0700 | [diff] [blame] | 613 | cpi->use_svc = 0; |
Marco Paniconi | d8574e3 | 2019-08-04 21:30:12 -0700 | [diff] [blame] | 614 | cpi->svc.external_ref_frame_config = 0; |
| 615 | cpi->svc.non_reference_frame = 0; |
Marco Paniconi | 57247a8 | 2020-04-13 09:19:07 -0700 | [diff] [blame] | 616 | cpi->svc.number_spatial_layers = 1; |
| 617 | cpi->svc.number_temporal_layers = 1; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 618 | #endif // CONFIG_SVC_ENCODER |
Marco Paniconi | 6714211 | 2019-07-24 15:00:31 -0700 | [diff] [blame] | 619 | cm->number_spatial_layers = 1; |
| 620 | cm->number_temporal_layers = 1; |
Marco Paniconi | 882c5ad | 2019-09-30 21:32:29 -0700 | [diff] [blame] | 621 | cm->spatial_layer_id = 0; |
| 622 | cm->temporal_layer_id = 0; |
Marco Paniconi | 6714211 | 2019-07-24 15:00:31 -0700 | [diff] [blame] | 623 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 624 | // change includes all joint functionality |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 625 | av1_change_config(cpi, oxcf); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 626 | |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 627 | cm->ref_frame_flags = 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 628 | |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 629 | // Reset resize pending flags |
Jayasanker J | 0b1dd29 | 2020-04-09 15:47:25 +0530 | [diff] [blame] | 630 | resize_pending_params->width = 0; |
| 631 | resize_pending_params->height = 0; |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 632 | |
Vishesh | 2260a59 | 2020-04-06 15:34:51 +0530 | [diff] [blame] | 633 | init_buffer_indices(&cpi->force_intpel_info, cm->remapped_ref_idx); |
Fyodor Kyslov | 34b591f | 2020-06-24 20:13:58 -0700 | [diff] [blame] | 634 | |
| 635 | av1_noise_estimate_init(&cpi->noise_estimate, cm->width, cm->height); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 636 | } |
| 637 | |
Debargha Mukherjee | 5567170 | 2020-08-07 17:31:24 -0700 | [diff] [blame] | 638 | int aom_strcmp(const char *a, const char *b) { |
| 639 | if (a == NULL && b == NULL) return 0; |
| 640 | if (a == NULL && b != NULL) return -1; |
| 641 | if (a != NULL && b == NULL) return 1; |
| 642 | return strcmp(a, b); |
| 643 | } |
| 644 | |
Debargha Mukherjee | a4c6f69 | 2021-03-16 19:45:46 -0700 | [diff] [blame] | 645 | #if CONFIG_NEW_INTER_MODES |
| 646 | static void set_max_drl_bits(struct AV1_COMP *cpi) { |
| 647 | AV1_COMMON *const cm = &cpi->common; |
| 648 | // Add logic to choose this in the range [MIN_MAX_DRL_BITS, MAX_MAX_DRL_BITS] |
| 649 | if (cpi->oxcf.tool_cfg.max_drl_refmvs == 0) { |
| 650 | // TODO(any): Implement an auto mode that potentially adapts the parameter |
| 651 | // frame to frame. Currently set at a default value. |
| 652 | cm->features.max_drl_bits = DEF_MAX_DRL_REFMVS - 1; |
| 653 | } else { |
| 654 | cm->features.max_drl_bits = cpi->oxcf.tool_cfg.max_drl_refmvs - 1; |
| 655 | } |
| 656 | assert(cm->features.max_drl_bits >= MIN_MAX_DRL_BITS && |
| 657 | cm->features.max_drl_bits <= MAX_MAX_DRL_BITS); |
| 658 | } |
| 659 | #endif // CONFIG_NEW_INTER_MODES |
| 660 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 661 | void av1_change_config(struct AV1_COMP *cpi, const AV1EncoderConfig *oxcf) { |
| 662 | AV1_COMMON *const cm = &cpi->common; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 663 | SequenceHeader *const seq_params = &cm->seq_params; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 664 | RATE_CONTROL *const rc = &cpi->rc; |
hui su | d9a812b | 2017-07-06 14:34:37 -0700 | [diff] [blame] | 665 | MACROBLOCK *const x = &cpi->td.mb; |
Vishesh | 8ac928b | 2020-04-01 02:36:35 +0530 | [diff] [blame] | 666 | AV1LevelParams *const level_params = &cpi->level_params; |
Jayasanker J | 44fdab7 | 2020-04-13 20:34:38 +0530 | [diff] [blame] | 667 | InitialDimensions *const initial_dimensions = &cpi->initial_dimensions; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 668 | #if !CONFIG_NEW_REF_SIGNALING |
Jayasanker J | 24cb9bc | 2020-04-15 13:43:10 +0530 | [diff] [blame] | 669 | RefreshFrameFlagsInfo *const refresh_frame_flags = &cpi->refresh_frame; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 670 | #endif // !CONFIG_NEW_REF_SIGNALING |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 671 | const FrameDimensionCfg *const frm_dim_cfg = &cpi->oxcf.frm_dim_cfg; |
Vishesh | a908224 | 2020-06-17 18:26:09 +0530 | [diff] [blame] | 672 | const DecoderModelCfg *const dec_model_cfg = &oxcf->dec_model_cfg; |
Vishesh | 52fdeae | 2020-06-24 14:37:00 +0530 | [diff] [blame] | 673 | const ColorCfg *const color_cfg = &oxcf->color_cfg; |
Vishesh | 073fc96 | 2020-07-01 17:39:16 +0530 | [diff] [blame] | 674 | const RateControlCfg *const rc_cfg = &oxcf->rc_cfg; |
Mufaddal Chakera | 48e1649 | 2020-05-04 16:07:18 +0530 | [diff] [blame] | 675 | // in case of LAP, lag in frames is set according to number of lap buffers |
| 676 | // calculated at init time. This stores and restores LAP's lag in frames to |
| 677 | // prevent override by new cfg. |
| 678 | int lap_lag_in_frames = -1; |
| 679 | if (cpi->lap_enabled && cpi->compressor_stage == LAP_STAGE) { |
Vishesh | 5b50e6d | 2020-06-10 19:20:07 +0530 | [diff] [blame] | 680 | lap_lag_in_frames = cpi->oxcf.gf_cfg.lag_in_frames; |
Mufaddal Chakera | 48e1649 | 2020-05-04 16:07:18 +0530 | [diff] [blame] | 681 | } |
| 682 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 683 | if (seq_params->profile != oxcf->profile) seq_params->profile = oxcf->profile; |
Vishesh | aa6a170 | 2020-06-30 19:27:22 +0530 | [diff] [blame] | 684 | seq_params->bit_depth = oxcf->tool_cfg.bit_depth; |
Vishesh | 52fdeae | 2020-06-24 14:37:00 +0530 | [diff] [blame] | 685 | seq_params->color_primaries = color_cfg->color_primaries; |
| 686 | seq_params->transfer_characteristics = color_cfg->transfer_characteristics; |
| 687 | seq_params->matrix_coefficients = color_cfg->matrix_coefficients; |
Vishesh | aa6a170 | 2020-06-30 19:27:22 +0530 | [diff] [blame] | 688 | seq_params->monochrome = oxcf->tool_cfg.enable_monochrome; |
Vishesh | 073fc96 | 2020-07-01 17:39:16 +0530 | [diff] [blame] | 689 | seq_params->chroma_sample_position = color_cfg->chroma_sample_position; |
Vishesh | 52fdeae | 2020-06-24 14:37:00 +0530 | [diff] [blame] | 690 | seq_params->color_range = color_cfg->color_range; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 691 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 692 | assert(IMPLIES(seq_params->profile <= PROFILE_1, |
| 693 | seq_params->bit_depth <= AOM_BITS_10)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 694 | |
Vishesh | a908224 | 2020-06-17 18:26:09 +0530 | [diff] [blame] | 695 | seq_params->timing_info_present = dec_model_cfg->timing_info_present; |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 696 | seq_params->timing_info.num_units_in_display_tick = |
Vishesh | a908224 | 2020-06-17 18:26:09 +0530 | [diff] [blame] | 697 | dec_model_cfg->timing_info.num_units_in_display_tick; |
| 698 | seq_params->timing_info.time_scale = dec_model_cfg->timing_info.time_scale; |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 699 | seq_params->timing_info.equal_picture_interval = |
Vishesh | a908224 | 2020-06-17 18:26:09 +0530 | [diff] [blame] | 700 | dec_model_cfg->timing_info.equal_picture_interval; |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 701 | seq_params->timing_info.num_ticks_per_picture = |
Vishesh | a908224 | 2020-06-17 18:26:09 +0530 | [diff] [blame] | 702 | dec_model_cfg->timing_info.num_ticks_per_picture; |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 703 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 704 | seq_params->display_model_info_present_flag = |
Vishesh | a908224 | 2020-06-17 18:26:09 +0530 | [diff] [blame] | 705 | dec_model_cfg->display_model_info_present_flag; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 706 | seq_params->decoder_model_info_present_flag = |
Vishesh | a908224 | 2020-06-17 18:26:09 +0530 | [diff] [blame] | 707 | dec_model_cfg->decoder_model_info_present_flag; |
| 708 | if (dec_model_cfg->decoder_model_info_present_flag) { |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 709 | // set the decoder model parameters in schedule mode |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 710 | seq_params->decoder_model_info.num_units_in_decoding_tick = |
Vishesh | a908224 | 2020-06-17 18:26:09 +0530 | [diff] [blame] | 711 | dec_model_cfg->num_units_in_decoding_tick; |
Wan-Teh Chang | f64b3bc | 2018-07-02 09:42:39 -0700 | [diff] [blame] | 712 | cm->buffer_removal_time_present = 1; |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 713 | av1_set_aom_dec_model_info(&seq_params->decoder_model_info); |
| 714 | av1_set_dec_model_op_parameters(&seq_params->op_params[0]); |
| 715 | } else if (seq_params->timing_info_present && |
| 716 | seq_params->timing_info.equal_picture_interval && |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 717 | !seq_params->decoder_model_info_present_flag) { |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 718 | // set the decoder model parameters in resource availability mode |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 719 | av1_set_resource_availability_parameters(&seq_params->op_params[0]); |
Andrey Norkin | c7511de | 2018-06-22 12:31:06 -0700 | [diff] [blame] | 720 | } else { |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 721 | seq_params->op_params[0].initial_display_delay = |
Andrey Norkin | c7511de | 2018-06-22 12:31:06 -0700 | [diff] [blame] | 722 | 10; // Default value (not signaled) |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 723 | } |
Andrey Norkin | 28e9ce2 | 2018-01-08 10:11:21 -0800 | [diff] [blame] | 724 | |
Satish Kumar Suman | 36adf35 | 2020-06-26 11:20:10 +0530 | [diff] [blame] | 725 | av1_update_film_grain_parameters(cpi, oxcf); |
Andrey Norkin | 6f1c2f7 | 2018-01-15 20:08:52 -0800 | [diff] [blame] | 726 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 727 | cpi->oxcf = *oxcf; |
Urvang Joshi | df26571 | 2020-10-05 23:23:09 -0700 | [diff] [blame] | 728 | // When user provides superres_mode = AOM_SUPERRES_AUTO, we still initialize |
| 729 | // superres mode for current encoding = AOM_SUPERRES_NONE. This is to ensure |
| 730 | // that any analysis (e.g. TPL) happening outside the main encoding loop still |
| 731 | // happens at full resolution. |
| 732 | // This value will later be set appropriately just before main encoding loop. |
| 733 | cpi->superres_mode = oxcf->superres_cfg.superres_mode == AOM_SUPERRES_AUTO |
| 734 | ? AOM_SUPERRES_NONE |
| 735 | : oxcf->superres_cfg.superres_mode; // default |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 736 | x->e_mbd.bd = (int)seq_params->bit_depth; |
hui su | d9a812b | 2017-07-06 14:34:37 -0700 | [diff] [blame] | 737 | x->e_mbd.global_motion = cm->global_motion; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 738 | |
Vishesh | 8ac928b | 2020-04-01 02:36:35 +0530 | [diff] [blame] | 739 | memcpy(level_params->target_seq_level_idx, cpi->oxcf.target_seq_level_idx, |
| 740 | sizeof(level_params->target_seq_level_idx)); |
| 741 | level_params->keep_level_stats = 0; |
Wan-Teh Chang | bcacb32 | 2019-09-11 14:50:20 -0700 | [diff] [blame] | 742 | for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i) { |
Vishesh | 8ac928b | 2020-04-01 02:36:35 +0530 | [diff] [blame] | 743 | if (level_params->target_seq_level_idx[i] <= SEQ_LEVELS) { |
| 744 | level_params->keep_level_stats |= 1u << i; |
| 745 | if (!level_params->level_info[i]) { |
| 746 | CHECK_MEM_ERROR(cm, level_params->level_info[i], |
| 747 | aom_calloc(1, sizeof(*level_params->level_info[i]))); |
Wan-Teh Chang | bcacb32 | 2019-09-11 14:50:20 -0700 | [diff] [blame] | 748 | } |
| 749 | } |
| 750 | } |
| 751 | |
| 752 | // TODO(huisu@): level targeting currently only works for the 0th operating |
| 753 | // point, so scalable coding is not supported yet. |
Vishesh | 8ac928b | 2020-04-01 02:36:35 +0530 | [diff] [blame] | 754 | if (level_params->target_seq_level_idx[0] < SEQ_LEVELS) { |
Wan-Teh Chang | bcacb32 | 2019-09-11 14:50:20 -0700 | [diff] [blame] | 755 | // Adjust encoder config in order to meet target level. |
Vishesh | 8ac928b | 2020-04-01 02:36:35 +0530 | [diff] [blame] | 756 | config_target_level(cpi, level_params->target_seq_level_idx[0], |
| 757 | seq_params->tier[0]); |
Wan-Teh Chang | bcacb32 | 2019-09-11 14:50:20 -0700 | [diff] [blame] | 758 | } |
| 759 | |
Urvang Joshi | ade2d32 | 2020-09-01 13:26:46 -0700 | [diff] [blame] | 760 | rc->baseline_gf_interval = (MIN_GF_INTERVAL + MAX_GF_INTERVAL) / 2; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 761 | |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 762 | #if !CONFIG_NEW_REF_SIGNALING |
Jayasanker J | 24cb9bc | 2020-04-15 13:43:10 +0530 | [diff] [blame] | 763 | refresh_frame_flags->golden_frame = false; |
| 764 | refresh_frame_flags->bwd_ref_frame = false; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 765 | #endif // !CONFIG_NEW_REF_SIGNALING |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 766 | |
Vishesh | aa6a170 | 2020-06-30 19:27:22 +0530 | [diff] [blame] | 767 | cm->features.refresh_frame_context = |
| 768 | (oxcf->tool_cfg.frame_parallel_decoding_mode) |
| 769 | ? REFRESH_FRAME_CONTEXT_DISABLED |
| 770 | : REFRESH_FRAME_CONTEXT_BACKWARD; |
Vishesh | 0481a78 | 2020-06-11 14:32:46 +0530 | [diff] [blame] | 771 | if (oxcf->tile_cfg.enable_large_scale_tile) |
Urvang Joshi | 6237b88 | 2020-03-26 15:02:26 -0700 | [diff] [blame] | 772 | cm->features.refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED; |
Rupert Swarbrick | 84b05ac | 2017-10-27 18:10:53 +0100 | [diff] [blame] | 773 | |
Alex Converse | 74ad091 | 2017-07-18 10:22:58 -0700 | [diff] [blame] | 774 | if (x->palette_buffer == NULL) { |
hui su | d9a812b | 2017-07-06 14:34:37 -0700 | [diff] [blame] | 775 | CHECK_MEM_ERROR(cm, x->palette_buffer, |
| 776 | aom_memalign(16, sizeof(*x->palette_buffer))); |
| 777 | } |
Urvang Joshi | 0a4cfad | 2018-09-07 11:10:39 -0700 | [diff] [blame] | 778 | |
Hui Su | 38711e7 | 2019-06-11 10:49:47 -0700 | [diff] [blame] | 779 | if (x->comp_rd_buffer.pred0 == NULL) { |
Satish Kumar Suman | d3caa0d | 2020-06-16 14:02:50 +0530 | [diff] [blame] | 780 | alloc_compound_type_rd_buffers(cm, &x->comp_rd_buffer); |
Hui Su | 38711e7 | 2019-06-11 10:49:47 -0700 | [diff] [blame] | 781 | } |
| 782 | |
Urvang Joshi | 0a4cfad | 2018-09-07 11:10:39 -0700 | [diff] [blame] | 783 | if (x->tmp_conv_dst == NULL) { |
| 784 | CHECK_MEM_ERROR( |
| 785 | cm, x->tmp_conv_dst, |
| 786 | aom_memalign(32, MAX_SB_SIZE * MAX_SB_SIZE * sizeof(*x->tmp_conv_dst))); |
Urvang Joshi | e58f6ec | 2018-09-10 15:10:12 -0700 | [diff] [blame] | 787 | x->e_mbd.tmp_conv_dst = x->tmp_conv_dst; |
Urvang Joshi | 0a4cfad | 2018-09-07 11:10:39 -0700 | [diff] [blame] | 788 | } |
| 789 | for (int i = 0; i < 2; ++i) { |
chiyotsai | 2a897eb | 2020-04-28 19:22:13 -0700 | [diff] [blame] | 790 | if (x->tmp_pred_bufs[i] == NULL) { |
| 791 | CHECK_MEM_ERROR(cm, x->tmp_pred_bufs[i], |
wenyao.liu | 22d8ab3 | 2018-10-16 09:11:29 +0800 | [diff] [blame] | 792 | aom_memalign(32, 2 * MAX_MB_PLANE * MAX_SB_SQUARE * |
chiyotsai | 2a897eb | 2020-04-28 19:22:13 -0700 | [diff] [blame] | 793 | sizeof(*x->tmp_pred_bufs[i]))); |
| 794 | x->e_mbd.tmp_obmc_bufs[i] = x->tmp_pred_bufs[i]; |
Urvang Joshi | 0a4cfad | 2018-09-07 11:10:39 -0700 | [diff] [blame] | 795 | } |
| 796 | } |
| 797 | |
Marco Paniconi | 177b8c3 | 2020-01-26 20:37:29 -0800 | [diff] [blame] | 798 | av1_reset_segment_features(cm); |
Fyodor Kyslov | 64aaa09 | 2020-01-24 11:44:24 -0800 | [diff] [blame] | 799 | |
Debargha Mukherjee | a4c6f69 | 2021-03-16 19:45:46 -0700 | [diff] [blame] | 800 | #if CONFIG_NEW_INTER_MODES |
| 801 | // Add logic to choose this in the range [MIN_MAX_DRL_BITS, MAX_MAX_DRL_BITS] |
| 802 | set_max_drl_bits(cpi); |
| 803 | #endif // CONFIG_NEW_INTER_MODES |
| 804 | |
chiyotsai | c666b1f | 2019-12-20 10:44:58 -0800 | [diff] [blame] | 805 | av1_set_high_precision_mv(cpi, 1, 0); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 806 | |
Vishesh | 073fc96 | 2020-07-01 17:39:16 +0530 | [diff] [blame] | 807 | set_rc_buffer_sizes(rc, rc_cfg); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 808 | |
| 809 | // Under a configuration change, where maximum_buffer_size may change, |
| 810 | // keep buffer level clipped to the maximum allowed buffer size. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 811 | rc->bits_off_target = AOMMIN(rc->bits_off_target, rc->maximum_buffer_size); |
| 812 | rc->buffer_level = AOMMIN(rc->buffer_level, rc->maximum_buffer_size); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 813 | |
| 814 | // Set up frame rate and related parameters rate control values. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 815 | av1_new_framerate(cpi, cpi->framerate); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 816 | |
| 817 | // Set absolute upper and lower quality limits |
Vishesh | 073fc96 | 2020-07-01 17:39:16 +0530 | [diff] [blame] | 818 | rc->worst_quality = rc_cfg->worst_allowed_q; |
| 819 | rc->best_quality = rc_cfg->best_allowed_q; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 820 | |
Urvang Joshi | 6237b88 | 2020-03-26 15:02:26 -0700 | [diff] [blame] | 821 | cm->features.interp_filter = |
Vishesh | 0481a78 | 2020-06-11 14:32:46 +0530 | [diff] [blame] | 822 | oxcf->tile_cfg.enable_large_scale_tile ? EIGHTTAP_REGULAR : SWITCHABLE; |
Urvang Joshi | 6237b88 | 2020-03-26 15:02:26 -0700 | [diff] [blame] | 823 | cm->features.switchable_motion_mode = 1; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 824 | #if CONFIG_OPTFLOW_REFINEMENT |
| 825 | cm->features.opfl_refine_type = REFINE_SWITCHABLE; |
| 826 | #endif // CONFIG_OPTFLOW_REFINEMENT |
Yue Chen | 5380cb5 | 2018-02-23 15:33:21 -0800 | [diff] [blame] | 827 | |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 828 | if (frm_dim_cfg->render_width > 0 && frm_dim_cfg->render_height > 0) { |
| 829 | cm->render_width = frm_dim_cfg->render_width; |
| 830 | cm->render_height = frm_dim_cfg->render_height; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 831 | } else { |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 832 | cm->render_width = frm_dim_cfg->width; |
| 833 | cm->render_height = frm_dim_cfg->height; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 834 | } |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 835 | cm->width = frm_dim_cfg->width; |
| 836 | cm->height = frm_dim_cfg->height; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 837 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 838 | int sb_size = seq_params->sb_size; |
Urvang Joshi | e4530f8 | 2018-01-09 11:43:37 -0800 | [diff] [blame] | 839 | // Superblock size should not be updated after the first key frame. |
| 840 | if (!cpi->seq_params_locked) { |
Satish Kumar Suman | 36adf35 | 2020-06-26 11:20:10 +0530 | [diff] [blame] | 841 | set_sb_size(&cm->seq_params, av1_select_sb_size(cpi)); |
Hui Su | d909c2c | 2019-03-08 11:51:14 -0800 | [diff] [blame] | 842 | for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i) |
| 843 | seq_params->tier[i] = (oxcf->tier_mask >> i) & 1; |
Urvang Joshi | e4530f8 | 2018-01-09 11:43:37 -0800 | [diff] [blame] | 844 | } |
Dominic Symes | 917d6c0 | 2017-10-11 18:00:52 +0200 | [diff] [blame] | 845 | |
Jayasanker J | 44fdab7 | 2020-04-13 20:34:38 +0530 | [diff] [blame] | 846 | if (initial_dimensions->width || sb_size != seq_params->sb_size) { |
| 847 | if (cm->width > initial_dimensions->width || |
| 848 | cm->height > initial_dimensions->height || |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 849 | seq_params->sb_size != sb_size) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 850 | av1_free_context_buffers(cm); |
Yue Chen | eb62898 | 2019-08-29 15:17:13 -0700 | [diff] [blame] | 851 | av1_free_shared_coeff_buffer(&cpi->td.shared_coeff_buf); |
| 852 | av1_free_sms_tree(&cpi->td); |
Mufaddal Chakera | 6c3b6de | 2020-04-29 12:27:42 +0530 | [diff] [blame] | 853 | av1_free_pmc(cpi->td.firstpass_ctx, av1_num_planes(cm)); |
| 854 | cpi->td.firstpass_ctx = NULL; |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 855 | alloc_compressor_data(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 856 | realloc_segmentation_maps(cpi); |
Jayasanker J | 44fdab7 | 2020-04-13 20:34:38 +0530 | [diff] [blame] | 857 | initial_dimensions->width = initial_dimensions->height = 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 858 | } |
| 859 | } |
| 860 | update_frame_size(cpi); |
| 861 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 862 | rc->is_src_frame_alt_ref = 0; |
| 863 | |
Vishesh | 0481a78 | 2020-06-11 14:32:46 +0530 | [diff] [blame] | 864 | set_tile_info(cm, &cpi->oxcf.tile_cfg); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 865 | |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 866 | #if CONFIG_SVC_ENCODER |
Marco Paniconi | d8574e3 | 2019-08-04 21:30:12 -0700 | [diff] [blame] | 867 | if (!cpi->svc.external_ref_frame_config) |
Vishesh | 38c05d7 | 2020-04-14 12:19:14 +0530 | [diff] [blame] | 868 | cpi->ext_flags.refresh_frame.update_pending = 0; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 869 | #else |
| 870 | cpi->ext_flags.refresh_frame.update_pending = 0; |
| 871 | #endif // CONFIG_SVC_ENCODER |
Vishesh | a195ca3 | 2020-04-07 18:46:20 +0530 | [diff] [blame] | 872 | cpi->ext_flags.refresh_frame_context_pending = 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 873 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 874 | highbd_set_var_fns(cpi); |
Imdad Sardharwalla | bf2cc01 | 2018-02-09 17:32:10 +0000 | [diff] [blame] | 875 | |
Debargha Mukherjee | edd7725 | 2018-03-25 12:01:38 -0700 | [diff] [blame] | 876 | // Init sequence level coding tools |
Debargha Mukherjee | f2e5bb3 | 2018-03-26 14:35:24 -0700 | [diff] [blame] | 877 | // This should not be called after the first key frame. |
| 878 | if (!cpi->seq_params_locked) { |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 879 | seq_params->operating_points_cnt_minus_1 = |
Marco Paniconi | 6da983b | 2019-09-16 20:12:43 -0700 | [diff] [blame] | 880 | (cm->number_spatial_layers > 1 || cm->number_temporal_layers > 1) |
| 881 | ? cm->number_spatial_layers * cm->number_temporal_layers - 1 |
| 882 | : 0; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 883 | #if CONFIG_SVC_ENCODER |
Marco Paniconi | 2aa13c4 | 2020-06-01 11:18:38 -0700 | [diff] [blame] | 884 | av1_init_seq_coding_tools(&cm->seq_params, cm, oxcf, cpi->use_svc); |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 885 | #else |
| 886 | av1_init_seq_coding_tools(&cm->seq_params, cm, oxcf); |
| 887 | #endif // CONFIG_SVC_ENCODER |
Debargha Mukherjee | f2e5bb3 | 2018-03-26 14:35:24 -0700 | [diff] [blame] | 888 | } |
Marco Paniconi | 5b1e473 | 2019-08-08 18:57:53 -0700 | [diff] [blame] | 889 | |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 890 | #if CONFIG_SVC_ENCODER |
Marco Paniconi | 5b1e473 | 2019-08-08 18:57:53 -0700 | [diff] [blame] | 891 | if (cpi->use_svc) |
Vishesh | 073fc96 | 2020-07-01 17:39:16 +0530 | [diff] [blame] | 892 | av1_update_layer_context_change_config(cpi, rc_cfg->target_bandwidth); |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 893 | #endif // CONFIG_SVC_ENCODER |
Mufaddal Chakera | 48e1649 | 2020-05-04 16:07:18 +0530 | [diff] [blame] | 894 | |
| 895 | // restore the value of lag_in_frame for LAP stage. |
| 896 | if (lap_lag_in_frames != -1) { |
Vishesh | 5b50e6d | 2020-06-10 19:20:07 +0530 | [diff] [blame] | 897 | cpi->oxcf.gf_cfg.lag_in_frames = lap_lag_in_frames; |
Mufaddal Chakera | 48e1649 | 2020-05-04 16:07:18 +0530 | [diff] [blame] | 898 | } |
Debargha Mukherjee | c22e2c5 | 2020-07-07 00:06:58 -0700 | [diff] [blame] | 899 | |
Debargha Mukherjee | 5567170 | 2020-08-07 17:31:24 -0700 | [diff] [blame] | 900 | bool subgop_config_changed = false; |
| 901 | if (aom_strcmp(cpi->subgop_config_path, oxcf->subgop_config_path)) { |
| 902 | aom_free(cpi->subgop_config_path); |
Cherma Rajan A | c89a251 | 2020-11-20 12:18:20 +0530 | [diff] [blame] | 903 | cpi->subgop_config_path = NULL; |
Debargha Mukherjee | 5567170 | 2020-08-07 17:31:24 -0700 | [diff] [blame] | 904 | if (oxcf->subgop_config_path != NULL) { |
| 905 | cpi->subgop_config_path = |
| 906 | (char *)aom_malloc((strlen(oxcf->subgop_config_path) + 1) * |
| 907 | sizeof(*oxcf->subgop_config_path)); |
| 908 | strcpy(cpi->subgop_config_path, oxcf->subgop_config_path); |
| 909 | } |
| 910 | subgop_config_changed = true; |
| 911 | } |
| 912 | if (aom_strcmp(cpi->subgop_config_str, oxcf->subgop_config_str)) { |
Debargha Mukherjee | da89844 | 2020-07-10 14:45:20 -0700 | [diff] [blame] | 913 | aom_free(cpi->subgop_config_str); |
Cherma Rajan A | c89a251 | 2020-11-20 12:18:20 +0530 | [diff] [blame] | 914 | cpi->subgop_config_str = NULL; |
Debargha Mukherjee | da89844 | 2020-07-10 14:45:20 -0700 | [diff] [blame] | 915 | if (oxcf->subgop_config_str != NULL) { |
| 916 | cpi->subgop_config_str = |
| 917 | (char *)aom_malloc((strlen(oxcf->subgop_config_str) + 1) * |
| 918 | sizeof(*oxcf->subgop_config_str)); |
| 919 | strcpy(cpi->subgop_config_str, oxcf->subgop_config_str); |
Debargha Mukherjee | da89844 | 2020-07-10 14:45:20 -0700 | [diff] [blame] | 920 | } |
Debargha Mukherjee | 5567170 | 2020-08-07 17:31:24 -0700 | [diff] [blame] | 921 | subgop_config_changed = true; |
| 922 | } |
| 923 | if (subgop_config_changed && cpi->compressor_stage == ENCODE_STAGE) { |
| 924 | av1_init_subgop_config_set(&cpi->subgop_config_set); |
| 925 | // Parse config file first |
| 926 | av1_process_subgop_config_set_fromfile(cpi->subgop_config_path, |
| 927 | &cpi->subgop_config_set); |
| 928 | // Parse config string next, which may override config file configs |
| 929 | // or append to it. |
| 930 | av1_process_subgop_config_set(cpi->subgop_config_str, |
| 931 | &cpi->subgop_config_set); |
Urvang Joshi | eca7e6b | 2021-06-29 15:30:16 -0700 | [diff] [blame] | 932 | if (cpi->print_per_frame_stats) { |
| 933 | printf("Successfully processed %d subgop configs.\n", |
| 934 | cpi->subgop_config_set.num_configs); |
| 935 | // Print out the configuration. Note the printed configuration |
| 936 | // is in fact in the config file format that can be parsed back. |
| 937 | av1_print_subgop_config_set(&cpi->subgop_config_set); |
| 938 | } |
Debargha Mukherjee | da89844 | 2020-07-10 14:45:20 -0700 | [diff] [blame] | 939 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 940 | } |
| 941 | |
Urvang Joshi | 31a7aa5 | 2020-03-31 13:09:13 -0700 | [diff] [blame] | 942 | static INLINE void init_frame_info(FRAME_INFO *frame_info, |
| 943 | const AV1_COMMON *const cm) { |
| 944 | const CommonModeInfoParams *const mi_params = &cm->mi_params; |
| 945 | const SequenceHeader *const seq_params = &cm->seq_params; |
| 946 | frame_info->frame_width = cm->width; |
| 947 | frame_info->frame_height = cm->height; |
| 948 | frame_info->mi_cols = mi_params->mi_cols; |
| 949 | frame_info->mi_rows = mi_params->mi_rows; |
| 950 | frame_info->mb_cols = mi_params->mb_cols; |
| 951 | frame_info->mb_rows = mi_params->mb_rows; |
| 952 | frame_info->num_mbs = mi_params->MBs; |
| 953 | frame_info->bit_depth = seq_params->bit_depth; |
| 954 | frame_info->subsampling_x = seq_params->subsampling_x; |
| 955 | frame_info->subsampling_y = seq_params->subsampling_y; |
| 956 | } |
| 957 | |
Aasaipriya | bd659e4 | 2019-12-13 16:12:13 +0530 | [diff] [blame] | 958 | AV1_COMP *av1_create_compressor(AV1EncoderConfig *oxcf, BufferPool *const pool, |
Mufaddal Chakera | 5517b28 | 2019-12-13 16:39:56 +0530 | [diff] [blame] | 959 | FIRSTPASS_STATS *frame_stats_buf, |
Akshata Jadhav | a49be17 | 2019-12-18 00:03:53 +0530 | [diff] [blame] | 960 | COMPRESSOR_STAGE stage, int num_lap_buffers, |
Mufaddal Chakera | 412efe2 | 2020-01-17 14:35:01 +0530 | [diff] [blame] | 961 | int lap_lag_in_frames, |
Akshata Jadhav | a49be17 | 2019-12-18 00:03:53 +0530 | [diff] [blame] | 962 | STATS_BUFFER_CTX *stats_buf_context) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 963 | AV1_COMP *volatile const cpi = aom_memalign(32, sizeof(AV1_COMP)); |
| 964 | AV1_COMMON *volatile const cm = cpi != NULL ? &cpi->common : NULL; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 965 | |
| 966 | if (!cm) return NULL; |
| 967 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 968 | av1_zero(*cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 969 | |
Wan-Teh Chang | a2fad3e | 2018-07-19 16:55:19 -0700 | [diff] [blame] | 970 | // The jmp_buf is valid only for the duration of the function that calls |
| 971 | // setjmp(). Therefore, this function must reset the 'setjmp' field to 0 |
| 972 | // before it returns. |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 973 | if (setjmp(cm->error.jmp)) { |
| 974 | cm->error.setjmp = 0; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 975 | av1_remove_compressor(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 976 | return 0; |
| 977 | } |
| 978 | |
Ryan Lei | ccc6ea7 | 2021-01-06 11:43:56 -0800 | [diff] [blame] | 979 | #if DEBUG_EXTQUANT |
| 980 | cm->fEncCoeffLog = fopen("EncCoeffLog.txt", "wt"); |
| 981 | #endif |
| 982 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 983 | cm->error.setjmp = 1; |
Mufaddal Chakera | ed7b162 | 2020-04-06 12:30:23 +0530 | [diff] [blame] | 984 | cpi->lap_enabled = num_lap_buffers > 0; |
| 985 | cpi->compressor_stage = stage; |
chiyotsai | a7091f1 | 2019-08-09 16:48:27 -0700 | [diff] [blame] | 986 | |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 987 | CommonModeInfoParams *const mi_params = &cm->mi_params; |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 988 | mi_params->free_mi = enc_free_mi; |
| 989 | mi_params->setup_mi = enc_setup_mi; |
Debargha Mukherjee | 7118f42 | 2020-06-29 15:49:06 -0700 | [diff] [blame] | 990 | mi_params->set_mb_mi = (cpi->compressor_stage == LAP_STAGE) |
| 991 | ? stat_stage_set_mb_mi |
| 992 | : enc_set_mb_mi; |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 993 | |
| 994 | mi_params->mi_alloc_bsize = BLOCK_4X4; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 995 | |
Angie Chiang | a5d96c4 | 2016-10-21 16:16:56 -0700 | [diff] [blame] | 996 | CHECK_MEM_ERROR(cm, cm->fc, |
| 997 | (FRAME_CONTEXT *)aom_memalign(32, sizeof(*cm->fc))); |
David Turner | 1bcefb3 | 2018-11-19 17:54:00 +0000 | [diff] [blame] | 998 | CHECK_MEM_ERROR( |
| 999 | cm, cm->default_frame_context, |
| 1000 | (FRAME_CONTEXT *)aom_memalign(32, sizeof(*cm->default_frame_context))); |
Angie Chiang | a5d96c4 | 2016-10-21 16:16:56 -0700 | [diff] [blame] | 1001 | memset(cm->fc, 0, sizeof(*cm->fc)); |
David Turner | 1bcefb3 | 2018-11-19 17:54:00 +0000 | [diff] [blame] | 1002 | memset(cm->default_frame_context, 0, sizeof(*cm->default_frame_context)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1003 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1004 | cpi->common.buffer_pool = pool; |
| 1005 | |
Mufaddal Chakera | 7b5265f | 2020-03-27 10:32:34 +0530 | [diff] [blame] | 1006 | init_config(cpi, oxcf); |
Mufaddal Chakera | 11f284a | 2019-12-19 11:38:46 +0530 | [diff] [blame] | 1007 | if (cpi->compressor_stage == LAP_STAGE) { |
Vishesh | 5b50e6d | 2020-06-10 19:20:07 +0530 | [diff] [blame] | 1008 | cpi->oxcf.gf_cfg.lag_in_frames = lap_lag_in_frames; |
Mufaddal Chakera | 11f284a | 2019-12-19 11:38:46 +0530 | [diff] [blame] | 1009 | } |
Mufaddal Chakera | ac82868 | 2019-12-13 16:31:42 +0530 | [diff] [blame] | 1010 | |
Mufaddal Chakera | 7a090f2 | 2020-07-09 15:09:51 +0530 | [diff] [blame] | 1011 | cpi->frames_left = cpi->oxcf.input_cfg.limit; |
| 1012 | |
Debargha Mukherjee | 7118f42 | 2020-06-29 15:49:06 -0700 | [diff] [blame] | 1013 | av1_rc_init(&cpi->oxcf, 0, &cpi->rc); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1014 | |
Aasaipriya | 196c58a | 2020-04-23 19:05:45 +0530 | [diff] [blame] | 1015 | // For two pass and lag_in_frames > 33 in LAP. |
| 1016 | cpi->rc.enable_scenecut_detection = ENABLE_SCENECUT_MODE_2; |
| 1017 | if (cpi->lap_enabled) { |
| 1018 | if ((num_lap_buffers < |
| 1019 | (MAX_GF_LENGTH_LAP + SCENE_CUT_KEY_TEST_INTERVAL + 1)) && |
| 1020 | num_lap_buffers >= (MAX_GF_LENGTH_LAP + 3)) { |
| 1021 | /* |
| 1022 | * For lag in frames >= 19 and <33, enable scenecut |
| 1023 | * with limited future frame prediction. |
| 1024 | */ |
| 1025 | cpi->rc.enable_scenecut_detection = ENABLE_SCENECUT_MODE_1; |
| 1026 | } else if (num_lap_buffers < (MAX_GF_LENGTH_LAP + 3)) { |
| 1027 | // Disable scenecut when lag_in_frames < 19. |
| 1028 | cpi->rc.enable_scenecut_detection = DISABLE_SCENECUT; |
| 1029 | } |
| 1030 | } |
Jingning Han | 17af774 | 2019-09-17 16:58:03 -0700 | [diff] [blame] | 1031 | init_frame_info(&cpi->frame_info, cm); |
| 1032 | |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 1033 | cm->current_frame.frame_number = 0; |
liang zhao | 7aebbd1 | 2020-07-03 22:20:34 -0700 | [diff] [blame] | 1034 | cm->current_frame.key_frame_number = 0; |
David Turner | a4c9625 | 2019-01-11 16:36:39 +0000 | [diff] [blame] | 1035 | cm->current_frame_id = -1; |
Debargha Mukherjee | f2e5bb3 | 2018-03-26 14:35:24 -0700 | [diff] [blame] | 1036 | cpi->seq_params_locked = 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1037 | cpi->partition_search_skippable_frame = 0; |
| 1038 | cpi->tile_data = NULL; |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 1039 | cpi->last_show_frame_buf = NULL; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1040 | realloc_segmentation_maps(cpi); |
| 1041 | |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 1042 | #if !CONFIG_NEW_REF_SIGNALING |
Jayasanker J | 24cb9bc | 2020-04-15 13:43:10 +0530 | [diff] [blame] | 1043 | cpi->refresh_frame.alt_ref_frame = false; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 1044 | #endif // !CONFIG_NEW_REF_SIGNALING |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1045 | |
| 1046 | cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS; |
| 1047 | #if CONFIG_INTERNAL_STATS |
| 1048 | cpi->b_calculate_blockiness = 1; |
| 1049 | cpi->b_calculate_consistency = 1; |
| 1050 | cpi->total_inconsistency = 0; |
| 1051 | cpi->psnr.worst = 100.0; |
| 1052 | cpi->worst_ssim = 100.0; |
| 1053 | |
| 1054 | cpi->count = 0; |
| 1055 | cpi->bytes = 0; |
Debargha Mukherjee | 0857e66 | 2019-01-04 16:22:09 -0800 | [diff] [blame] | 1056 | #if CONFIG_SPEED_STATS |
| 1057 | cpi->tx_search_count = 0; |
| 1058 | #endif // CONFIG_SPEED_STATS |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1059 | |
| 1060 | if (cpi->b_calculate_psnr) { |
| 1061 | cpi->total_sq_error = 0; |
| 1062 | cpi->total_samples = 0; |
| 1063 | cpi->tot_recode_hits = 0; |
| 1064 | cpi->summed_quality = 0; |
| 1065 | cpi->summed_weights = 0; |
| 1066 | } |
| 1067 | |
| 1068 | cpi->fastssim.worst = 100.0; |
| 1069 | cpi->psnrhvs.worst = 100.0; |
| 1070 | |
| 1071 | if (cpi->b_calculate_blockiness) { |
| 1072 | cpi->total_blockiness = 0; |
| 1073 | cpi->worst_blockiness = 0.0; |
| 1074 | } |
| 1075 | |
| 1076 | if (cpi->b_calculate_consistency) { |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 1077 | CHECK_MEM_ERROR( |
| 1078 | cm, cpi->ssim_vars, |
| 1079 | aom_malloc(sizeof(*cpi->ssim_vars) * 4 * cpi->common.mi_params.mi_rows * |
| 1080 | cpi->common.mi_params.mi_cols)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1081 | cpi->worst_consistency = 100.0; |
| 1082 | } |
| 1083 | #endif |
Debargha Mukherjee | 5802ebe | 2016-12-21 04:17:24 -0800 | [diff] [blame] | 1084 | #if CONFIG_ENTROPY_STATS |
| 1085 | av1_zero(aggregate_fc); |
| 1086 | #endif // CONFIG_ENTROPY_STATS |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1087 | |
Deepa K G | fb89ce0 | 2020-04-06 13:34:42 +0530 | [diff] [blame] | 1088 | cpi->time_stamps.first_ever = INT64_MAX; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1089 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1090 | #ifdef OUTPUT_YUV_REC |
| 1091 | yuv_rec_file = fopen("rec.yuv", "wb"); |
| 1092 | #endif |
| 1093 | |
Mufaddal Chakera | 5517b28 | 2019-12-13 16:39:56 +0530 | [diff] [blame] | 1094 | assert(MAX_LAP_BUFFERS >= MAX_LAG_BUFFERS); |
Akshata Jadhav | 4be6511 | 2019-12-18 00:26:25 +0530 | [diff] [blame] | 1095 | int size = get_stats_buf_size(num_lap_buffers, MAX_LAG_BUFFERS); |
| 1096 | for (int i = 0; i < size; i++) |
Aasaipriya | bd659e4 | 2019-12-13 16:12:13 +0530 | [diff] [blame] | 1097 | cpi->twopass.frame_stats_arr[i] = &frame_stats_buf[i]; |
| 1098 | |
Akshata Jadhav | a49be17 | 2019-12-18 00:03:53 +0530 | [diff] [blame] | 1099 | cpi->twopass.stats_buf_ctx = stats_buf_context; |
| 1100 | cpi->twopass.stats_in = cpi->twopass.stats_buf_ctx->stats_in_start; |
| 1101 | |
Aasaipriya | eb417c1 | 2020-04-07 12:08:24 +0530 | [diff] [blame] | 1102 | if (is_stat_consumption_stage(cpi)) { |
Debargha Mukherjee | 0d0aaed | 2020-07-17 17:47:06 -0700 | [diff] [blame] | 1103 | av1_init_single_pass_lap(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1104 | } |
| 1105 | |
Remya | 0cce44c | 2019-08-16 11:57:24 +0530 | [diff] [blame] | 1106 | int sb_mi_size = av1_get_sb_mi_size(cm); |
| 1107 | |
Satish Kumar Suman | d3caa0d | 2020-06-16 14:02:50 +0530 | [diff] [blame] | 1108 | alloc_obmc_buffers(&cpi->td.mb.obmc_buffer, cm); |
Jingning Han | d064cf0 | 2017-06-01 10:00:39 -0700 | [diff] [blame] | 1109 | |
Ravi Chaudhary | 5d970f4 | 2018-09-25 11:25:32 +0530 | [diff] [blame] | 1110 | CHECK_MEM_ERROR( |
| 1111 | cm, cpi->td.mb.inter_modes_info, |
| 1112 | (InterModesInfo *)aom_malloc(sizeof(*cpi->td.mb.inter_modes_info))); |
Ravi Chaudhary | 5d970f4 | 2018-09-25 11:25:32 +0530 | [diff] [blame] | 1113 | |
Ravi Chaudhary | 783d6a3 | 2018-08-28 18:21:02 +0530 | [diff] [blame] | 1114 | for (int x = 0; x < 2; x++) |
| 1115 | for (int y = 0; y < 2; y++) |
| 1116 | CHECK_MEM_ERROR( |
chiyotsai | 82f36c9 | 2020-04-09 16:18:02 -0700 | [diff] [blame] | 1117 | cm, cpi->td.mb.intrabc_hash_info.hash_value_buffer[x][y], |
| 1118 | (uint32_t *)aom_malloc( |
| 1119 | AOM_BUFFER_SIZE_FOR_BLOCK_HASH * |
| 1120 | sizeof(*cpi->td.mb.intrabc_hash_info.hash_value_buffer[0][0]))); |
Ravi Chaudhary | 783d6a3 | 2018-08-28 18:21:02 +0530 | [diff] [blame] | 1121 | |
chiyotsai | 82f36c9 | 2020-04-09 16:18:02 -0700 | [diff] [blame] | 1122 | cpi->td.mb.intrabc_hash_info.g_crc_initialized = 0; |
Ravi Chaudhary | 783d6a3 | 2018-08-28 18:21:02 +0530 | [diff] [blame] | 1123 | |
Remya | 0cce44c | 2019-08-16 11:57:24 +0530 | [diff] [blame] | 1124 | CHECK_MEM_ERROR(cm, cpi->td.mb.mbmi_ext, |
| 1125 | aom_calloc(sb_mi_size, sizeof(*cpi->td.mb.mbmi_ext))); |
| 1126 | |
David Turner | 04b70d8 | 2019-01-24 15:39:19 +0000 | [diff] [blame] | 1127 | av1_set_speed_features_framesize_independent(cpi, oxcf->speed); |
| 1128 | av1_set_speed_features_framesize_dependent(cpi, oxcf->speed); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1129 | |
Fyodor Kyslov | 34b591f | 2020-06-24 20:13:58 -0700 | [diff] [blame] | 1130 | CHECK_MEM_ERROR(cm, cpi->consec_zero_mv, |
| 1131 | aom_calloc((mi_params->mi_rows * mi_params->mi_cols) >> 2, |
| 1132 | sizeof(*cpi->consec_zero_mv))); |
| 1133 | |
sdeng | c23c7f1 | 2019-06-11 16:56:50 -0700 | [diff] [blame] | 1134 | { |
| 1135 | const int bsize = BLOCK_16X16; |
| 1136 | const int w = mi_size_wide[bsize]; |
| 1137 | const int h = mi_size_high[bsize]; |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 1138 | const int num_cols = (mi_params->mi_cols + w - 1) / w; |
| 1139 | const int num_rows = (mi_params->mi_rows + h - 1) / h; |
sdeng | f46a106 | 2019-08-04 18:43:50 -0700 | [diff] [blame] | 1140 | CHECK_MEM_ERROR(cm, cpi->tpl_rdmult_scaling_factors, |
| 1141 | aom_calloc(num_rows * num_cols, |
| 1142 | sizeof(*cpi->tpl_rdmult_scaling_factors))); |
| 1143 | CHECK_MEM_ERROR(cm, cpi->tpl_sb_rdmult_scaling_factors, |
| 1144 | aom_calloc(num_rows * num_cols, |
| 1145 | sizeof(*cpi->tpl_sb_rdmult_scaling_factors))); |
| 1146 | } |
| 1147 | |
| 1148 | { |
| 1149 | const int bsize = BLOCK_16X16; |
| 1150 | const int w = mi_size_wide[bsize]; |
| 1151 | const int h = mi_size_high[bsize]; |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 1152 | const int num_cols = (mi_params->mi_cols + w - 1) / w; |
| 1153 | const int num_rows = (mi_params->mi_rows + h - 1) / h; |
sdeng | c23c7f1 | 2019-06-11 16:56:50 -0700 | [diff] [blame] | 1154 | CHECK_MEM_ERROR(cm, cpi->ssim_rdmult_scaling_factors, |
| 1155 | aom_calloc(num_rows * num_cols, |
| 1156 | sizeof(*cpi->ssim_rdmult_scaling_factors))); |
| 1157 | } |
| 1158 | |
sdeng | 0195916 | 2019-12-20 10:46:24 -0800 | [diff] [blame] | 1159 | #if CONFIG_TUNE_VMAF |
| 1160 | { |
| 1161 | const int bsize = BLOCK_64X64; |
| 1162 | const int w = mi_size_wide[bsize]; |
| 1163 | const int h = mi_size_high[bsize]; |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 1164 | const int num_cols = (mi_params->mi_cols + w - 1) / w; |
| 1165 | const int num_rows = (mi_params->mi_rows + h - 1) / h; |
Vishesh | f18766f | 2020-04-17 10:22:48 +0530 | [diff] [blame] | 1166 | CHECK_MEM_ERROR(cm, cpi->vmaf_info.rdmult_scaling_factors, |
sdeng | 0195916 | 2019-12-20 10:46:24 -0800 | [diff] [blame] | 1167 | aom_calloc(num_rows * num_cols, |
Vishesh | f18766f | 2020-04-17 10:22:48 +0530 | [diff] [blame] | 1168 | sizeof(*cpi->vmaf_info.rdmult_scaling_factors))); |
Sai Deng | 0cbf028 | 2020-09-17 16:25:52 -0700 | [diff] [blame] | 1169 | for (int i = 0; i < MAX_ARF_LAYERS; i++) { |
| 1170 | cpi->vmaf_info.last_frame_unsharp_amount[i] = -1.0; |
| 1171 | cpi->vmaf_info.last_frame_ysse[i] = -1.0; |
| 1172 | cpi->vmaf_info.last_frame_vmaf[i] = -1.0; |
| 1173 | cpi->vmaf_info.best_unsharp_amount[i] = -1.0; |
| 1174 | } |
Sai Deng | 48ebb28 | 2020-08-13 15:30:50 -0700 | [diff] [blame] | 1175 | cpi->vmaf_info.original_qindex = -1; |
Sai Deng | 7275a1a | 2020-08-31 12:06:09 -0700 | [diff] [blame] | 1176 | |
| 1177 | #if CONFIG_USE_VMAF_RC |
| 1178 | cpi->vmaf_info.vmaf_model = NULL; |
| 1179 | #endif |
sdeng | 0195916 | 2019-12-20 10:46:24 -0800 | [diff] [blame] | 1180 | } |
| 1181 | #endif |
| 1182 | |
Mufaddal Chakera | e11600c | 2020-03-26 12:20:12 +0530 | [diff] [blame] | 1183 | if (!is_stat_generation_stage(cpi)) { |
Vishesh | 39d0362 | 2020-03-31 15:18:16 +0530 | [diff] [blame] | 1184 | setup_tpl_buffers(cm, &cpi->tpl_data); |
Jingning Han | f83d681 | 2020-02-27 13:08:19 -0800 | [diff] [blame] | 1185 | } |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 1186 | |
chiyotsai | 9c484b3 | 2019-03-07 16:01:50 -0800 | [diff] [blame] | 1187 | #if CONFIG_COLLECT_PARTITION_STATS == 2 |
chiyotsai | 92ed0dd | 2019-01-25 14:50:14 -0800 | [diff] [blame] | 1188 | av1_zero(cpi->partition_stats); |
| 1189 | #endif |
| 1190 | |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1191 | #define BFP(BT, SDF, SDAF, VF, SVF, SVAF, SDX4DF, JSDAF, JSVAF) \ |
| 1192 | cpi->fn_ptr[BT].sdf = SDF; \ |
| 1193 | cpi->fn_ptr[BT].sdaf = SDAF; \ |
| 1194 | cpi->fn_ptr[BT].vf = VF; \ |
| 1195 | cpi->fn_ptr[BT].svf = SVF; \ |
| 1196 | cpi->fn_ptr[BT].svaf = SVAF; \ |
| 1197 | cpi->fn_ptr[BT].sdx4df = SDX4DF; \ |
| 1198 | cpi->fn_ptr[BT].jsdaf = JSDAF; \ |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1199 | cpi->fn_ptr[BT].jsvaf = JSVAF; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1200 | |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1201 | BFP(BLOCK_4X16, aom_sad4x16, aom_sad4x16_avg, aom_variance4x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1202 | aom_sub_pixel_variance4x16, aom_sub_pixel_avg_variance4x16, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1203 | aom_sad4x16x4d, aom_dist_wtd_sad4x16_avg, |
| 1204 | aom_dist_wtd_sub_pixel_avg_variance4x16) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1205 | |
| 1206 | BFP(BLOCK_16X4, aom_sad16x4, aom_sad16x4_avg, aom_variance16x4, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1207 | aom_sub_pixel_variance16x4, aom_sub_pixel_avg_variance16x4, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1208 | aom_sad16x4x4d, aom_dist_wtd_sad16x4_avg, |
| 1209 | aom_dist_wtd_sub_pixel_avg_variance16x4) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1210 | |
| 1211 | BFP(BLOCK_8X32, aom_sad8x32, aom_sad8x32_avg, aom_variance8x32, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1212 | aom_sub_pixel_variance8x32, aom_sub_pixel_avg_variance8x32, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1213 | aom_sad8x32x4d, aom_dist_wtd_sad8x32_avg, |
| 1214 | aom_dist_wtd_sub_pixel_avg_variance8x32) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1215 | |
| 1216 | BFP(BLOCK_32X8, aom_sad32x8, aom_sad32x8_avg, aom_variance32x8, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1217 | aom_sub_pixel_variance32x8, aom_sub_pixel_avg_variance32x8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1218 | aom_sad32x8x4d, aom_dist_wtd_sad32x8_avg, |
| 1219 | aom_dist_wtd_sub_pixel_avg_variance32x8) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1220 | |
| 1221 | BFP(BLOCK_16X64, aom_sad16x64, aom_sad16x64_avg, aom_variance16x64, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1222 | aom_sub_pixel_variance16x64, aom_sub_pixel_avg_variance16x64, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1223 | aom_sad16x64x4d, aom_dist_wtd_sad16x64_avg, |
| 1224 | aom_dist_wtd_sub_pixel_avg_variance16x64) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1225 | |
| 1226 | BFP(BLOCK_64X16, aom_sad64x16, aom_sad64x16_avg, aom_variance64x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1227 | aom_sub_pixel_variance64x16, aom_sub_pixel_avg_variance64x16, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1228 | aom_sad64x16x4d, aom_dist_wtd_sad64x16_avg, |
| 1229 | aom_dist_wtd_sub_pixel_avg_variance64x16) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1230 | |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1231 | BFP(BLOCK_128X128, aom_sad128x128, aom_sad128x128_avg, aom_variance128x128, |
| 1232 | aom_sub_pixel_variance128x128, aom_sub_pixel_avg_variance128x128, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1233 | aom_sad128x128x4d, aom_dist_wtd_sad128x128_avg, |
| 1234 | aom_dist_wtd_sub_pixel_avg_variance128x128) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1235 | |
| 1236 | BFP(BLOCK_128X64, aom_sad128x64, aom_sad128x64_avg, aom_variance128x64, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1237 | aom_sub_pixel_variance128x64, aom_sub_pixel_avg_variance128x64, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1238 | aom_sad128x64x4d, aom_dist_wtd_sad128x64_avg, |
| 1239 | aom_dist_wtd_sub_pixel_avg_variance128x64) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1240 | |
| 1241 | BFP(BLOCK_64X128, aom_sad64x128, aom_sad64x128_avg, aom_variance64x128, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1242 | aom_sub_pixel_variance64x128, aom_sub_pixel_avg_variance64x128, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1243 | aom_sad64x128x4d, aom_dist_wtd_sad64x128_avg, |
| 1244 | aom_dist_wtd_sub_pixel_avg_variance64x128) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1245 | |
| 1246 | BFP(BLOCK_32X16, aom_sad32x16, aom_sad32x16_avg, aom_variance32x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1247 | aom_sub_pixel_variance32x16, aom_sub_pixel_avg_variance32x16, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1248 | aom_sad32x16x4d, aom_dist_wtd_sad32x16_avg, |
| 1249 | aom_dist_wtd_sub_pixel_avg_variance32x16) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1250 | |
| 1251 | BFP(BLOCK_16X32, aom_sad16x32, aom_sad16x32_avg, aom_variance16x32, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1252 | aom_sub_pixel_variance16x32, aom_sub_pixel_avg_variance16x32, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1253 | aom_sad16x32x4d, aom_dist_wtd_sad16x32_avg, |
| 1254 | aom_dist_wtd_sub_pixel_avg_variance16x32) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1255 | |
| 1256 | BFP(BLOCK_64X32, aom_sad64x32, aom_sad64x32_avg, aom_variance64x32, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1257 | aom_sub_pixel_variance64x32, aom_sub_pixel_avg_variance64x32, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1258 | aom_sad64x32x4d, aom_dist_wtd_sad64x32_avg, |
| 1259 | aom_dist_wtd_sub_pixel_avg_variance64x32) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1260 | |
| 1261 | BFP(BLOCK_32X64, aom_sad32x64, aom_sad32x64_avg, aom_variance32x64, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1262 | aom_sub_pixel_variance32x64, aom_sub_pixel_avg_variance32x64, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1263 | aom_sad32x64x4d, aom_dist_wtd_sad32x64_avg, |
| 1264 | aom_dist_wtd_sub_pixel_avg_variance32x64) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1265 | |
| 1266 | BFP(BLOCK_32X32, aom_sad32x32, aom_sad32x32_avg, aom_variance32x32, |
| 1267 | aom_sub_pixel_variance32x32, aom_sub_pixel_avg_variance32x32, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1268 | aom_sad32x32x4d, aom_dist_wtd_sad32x32_avg, |
| 1269 | aom_dist_wtd_sub_pixel_avg_variance32x32) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1270 | |
| 1271 | BFP(BLOCK_64X64, aom_sad64x64, aom_sad64x64_avg, aom_variance64x64, |
| 1272 | aom_sub_pixel_variance64x64, aom_sub_pixel_avg_variance64x64, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1273 | aom_sad64x64x4d, aom_dist_wtd_sad64x64_avg, |
| 1274 | aom_dist_wtd_sub_pixel_avg_variance64x64) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1275 | |
| 1276 | BFP(BLOCK_16X16, aom_sad16x16, aom_sad16x16_avg, aom_variance16x16, |
| 1277 | aom_sub_pixel_variance16x16, aom_sub_pixel_avg_variance16x16, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1278 | aom_sad16x16x4d, aom_dist_wtd_sad16x16_avg, |
| 1279 | aom_dist_wtd_sub_pixel_avg_variance16x16) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1280 | |
| 1281 | BFP(BLOCK_16X8, aom_sad16x8, aom_sad16x8_avg, aom_variance16x8, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1282 | aom_sub_pixel_variance16x8, aom_sub_pixel_avg_variance16x8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1283 | aom_sad16x8x4d, aom_dist_wtd_sad16x8_avg, |
| 1284 | aom_dist_wtd_sub_pixel_avg_variance16x8) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1285 | |
| 1286 | BFP(BLOCK_8X16, aom_sad8x16, aom_sad8x16_avg, aom_variance8x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1287 | aom_sub_pixel_variance8x16, aom_sub_pixel_avg_variance8x16, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1288 | aom_sad8x16x4d, aom_dist_wtd_sad8x16_avg, |
| 1289 | aom_dist_wtd_sub_pixel_avg_variance8x16) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1290 | |
| 1291 | BFP(BLOCK_8X8, aom_sad8x8, aom_sad8x8_avg, aom_variance8x8, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1292 | aom_sub_pixel_variance8x8, aom_sub_pixel_avg_variance8x8, aom_sad8x8x4d, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1293 | aom_dist_wtd_sad8x8_avg, aom_dist_wtd_sub_pixel_avg_variance8x8) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1294 | |
| 1295 | BFP(BLOCK_8X4, aom_sad8x4, aom_sad8x4_avg, aom_variance8x4, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1296 | aom_sub_pixel_variance8x4, aom_sub_pixel_avg_variance8x4, aom_sad8x4x4d, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1297 | aom_dist_wtd_sad8x4_avg, aom_dist_wtd_sub_pixel_avg_variance8x4) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1298 | |
| 1299 | BFP(BLOCK_4X8, aom_sad4x8, aom_sad4x8_avg, aom_variance4x8, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1300 | aom_sub_pixel_variance4x8, aom_sub_pixel_avg_variance4x8, aom_sad4x8x4d, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1301 | aom_dist_wtd_sad4x8_avg, aom_dist_wtd_sub_pixel_avg_variance4x8) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1302 | |
| 1303 | BFP(BLOCK_4X4, aom_sad4x4, aom_sad4x4_avg, aom_variance4x4, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1304 | aom_sub_pixel_variance4x4, aom_sub_pixel_avg_variance4x4, aom_sad4x4x4d, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1305 | aom_dist_wtd_sad4x4_avg, aom_dist_wtd_sub_pixel_avg_variance4x4) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 1306 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1307 | #define OBFP(BT, OSDF, OVF, OSVF) \ |
| 1308 | cpi->fn_ptr[BT].osdf = OSDF; \ |
| 1309 | cpi->fn_ptr[BT].ovf = OVF; \ |
| 1310 | cpi->fn_ptr[BT].osvf = OSVF; |
| 1311 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1312 | OBFP(BLOCK_128X128, aom_obmc_sad128x128, aom_obmc_variance128x128, |
| 1313 | aom_obmc_sub_pixel_variance128x128) |
| 1314 | OBFP(BLOCK_128X64, aom_obmc_sad128x64, aom_obmc_variance128x64, |
| 1315 | aom_obmc_sub_pixel_variance128x64) |
| 1316 | OBFP(BLOCK_64X128, aom_obmc_sad64x128, aom_obmc_variance64x128, |
| 1317 | aom_obmc_sub_pixel_variance64x128) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1318 | OBFP(BLOCK_64X64, aom_obmc_sad64x64, aom_obmc_variance64x64, |
| 1319 | aom_obmc_sub_pixel_variance64x64) |
| 1320 | OBFP(BLOCK_64X32, aom_obmc_sad64x32, aom_obmc_variance64x32, |
| 1321 | aom_obmc_sub_pixel_variance64x32) |
| 1322 | OBFP(BLOCK_32X64, aom_obmc_sad32x64, aom_obmc_variance32x64, |
| 1323 | aom_obmc_sub_pixel_variance32x64) |
| 1324 | OBFP(BLOCK_32X32, aom_obmc_sad32x32, aom_obmc_variance32x32, |
| 1325 | aom_obmc_sub_pixel_variance32x32) |
| 1326 | OBFP(BLOCK_32X16, aom_obmc_sad32x16, aom_obmc_variance32x16, |
| 1327 | aom_obmc_sub_pixel_variance32x16) |
| 1328 | OBFP(BLOCK_16X32, aom_obmc_sad16x32, aom_obmc_variance16x32, |
| 1329 | aom_obmc_sub_pixel_variance16x32) |
| 1330 | OBFP(BLOCK_16X16, aom_obmc_sad16x16, aom_obmc_variance16x16, |
| 1331 | aom_obmc_sub_pixel_variance16x16) |
| 1332 | OBFP(BLOCK_16X8, aom_obmc_sad16x8, aom_obmc_variance16x8, |
| 1333 | aom_obmc_sub_pixel_variance16x8) |
| 1334 | OBFP(BLOCK_8X16, aom_obmc_sad8x16, aom_obmc_variance8x16, |
| 1335 | aom_obmc_sub_pixel_variance8x16) |
| 1336 | OBFP(BLOCK_8X8, aom_obmc_sad8x8, aom_obmc_variance8x8, |
| 1337 | aom_obmc_sub_pixel_variance8x8) |
| 1338 | OBFP(BLOCK_4X8, aom_obmc_sad4x8, aom_obmc_variance4x8, |
| 1339 | aom_obmc_sub_pixel_variance4x8) |
| 1340 | OBFP(BLOCK_8X4, aom_obmc_sad8x4, aom_obmc_variance8x4, |
| 1341 | aom_obmc_sub_pixel_variance8x4) |
| 1342 | OBFP(BLOCK_4X4, aom_obmc_sad4x4, aom_obmc_variance4x4, |
| 1343 | aom_obmc_sub_pixel_variance4x4) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1344 | OBFP(BLOCK_4X16, aom_obmc_sad4x16, aom_obmc_variance4x16, |
| 1345 | aom_obmc_sub_pixel_variance4x16) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1346 | OBFP(BLOCK_16X4, aom_obmc_sad16x4, aom_obmc_variance16x4, |
| 1347 | aom_obmc_sub_pixel_variance16x4) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1348 | OBFP(BLOCK_8X32, aom_obmc_sad8x32, aom_obmc_variance8x32, |
| 1349 | aom_obmc_sub_pixel_variance8x32) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1350 | OBFP(BLOCK_32X8, aom_obmc_sad32x8, aom_obmc_variance32x8, |
| 1351 | aom_obmc_sub_pixel_variance32x8) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 1352 | OBFP(BLOCK_16X64, aom_obmc_sad16x64, aom_obmc_variance16x64, |
| 1353 | aom_obmc_sub_pixel_variance16x64) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 1354 | OBFP(BLOCK_64X16, aom_obmc_sad64x16, aom_obmc_variance64x16, |
| 1355 | aom_obmc_sub_pixel_variance64x16) |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1356 | |
David Barker | f19f35f | 2017-05-22 16:33:22 +0100 | [diff] [blame] | 1357 | #define MBFP(BT, MCSDF, MCSVF) \ |
| 1358 | cpi->fn_ptr[BT].msdf = MCSDF; \ |
| 1359 | cpi->fn_ptr[BT].msvf = MCSVF; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1360 | |
David Barker | f19f35f | 2017-05-22 16:33:22 +0100 | [diff] [blame] | 1361 | MBFP(BLOCK_128X128, aom_masked_sad128x128, |
| 1362 | aom_masked_sub_pixel_variance128x128) |
| 1363 | MBFP(BLOCK_128X64, aom_masked_sad128x64, aom_masked_sub_pixel_variance128x64) |
| 1364 | MBFP(BLOCK_64X128, aom_masked_sad64x128, aom_masked_sub_pixel_variance64x128) |
David Barker | f19f35f | 2017-05-22 16:33:22 +0100 | [diff] [blame] | 1365 | MBFP(BLOCK_64X64, aom_masked_sad64x64, aom_masked_sub_pixel_variance64x64) |
| 1366 | MBFP(BLOCK_64X32, aom_masked_sad64x32, aom_masked_sub_pixel_variance64x32) |
| 1367 | MBFP(BLOCK_32X64, aom_masked_sad32x64, aom_masked_sub_pixel_variance32x64) |
| 1368 | MBFP(BLOCK_32X32, aom_masked_sad32x32, aom_masked_sub_pixel_variance32x32) |
| 1369 | MBFP(BLOCK_32X16, aom_masked_sad32x16, aom_masked_sub_pixel_variance32x16) |
| 1370 | MBFP(BLOCK_16X32, aom_masked_sad16x32, aom_masked_sub_pixel_variance16x32) |
| 1371 | MBFP(BLOCK_16X16, aom_masked_sad16x16, aom_masked_sub_pixel_variance16x16) |
| 1372 | MBFP(BLOCK_16X8, aom_masked_sad16x8, aom_masked_sub_pixel_variance16x8) |
| 1373 | MBFP(BLOCK_8X16, aom_masked_sad8x16, aom_masked_sub_pixel_variance8x16) |
| 1374 | MBFP(BLOCK_8X8, aom_masked_sad8x8, aom_masked_sub_pixel_variance8x8) |
| 1375 | MBFP(BLOCK_4X8, aom_masked_sad4x8, aom_masked_sub_pixel_variance4x8) |
| 1376 | MBFP(BLOCK_8X4, aom_masked_sad8x4, aom_masked_sub_pixel_variance8x4) |
| 1377 | MBFP(BLOCK_4X4, aom_masked_sad4x4, aom_masked_sub_pixel_variance4x4) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1378 | |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1379 | MBFP(BLOCK_4X16, aom_masked_sad4x16, aom_masked_sub_pixel_variance4x16) |
| 1380 | |
| 1381 | MBFP(BLOCK_16X4, aom_masked_sad16x4, aom_masked_sub_pixel_variance16x4) |
| 1382 | |
| 1383 | MBFP(BLOCK_8X32, aom_masked_sad8x32, aom_masked_sub_pixel_variance8x32) |
| 1384 | |
| 1385 | MBFP(BLOCK_32X8, aom_masked_sad32x8, aom_masked_sub_pixel_variance32x8) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 1386 | |
| 1387 | MBFP(BLOCK_16X64, aom_masked_sad16x64, aom_masked_sub_pixel_variance16x64) |
| 1388 | |
| 1389 | MBFP(BLOCK_64X16, aom_masked_sad64x16, aom_masked_sub_pixel_variance64x16) |
Rupert Swarbrick | 2fa6e1c | 2017-09-11 12:38:10 +0100 | [diff] [blame] | 1390 | |
chiyotsai | c814afb | 2020-08-04 13:12:35 -0700 | [diff] [blame] | 1391 | #define SDSFP(BT, SDSF, SDSX4DF) \ |
| 1392 | cpi->fn_ptr[BT].sdsf = SDSF; \ |
| 1393 | cpi->fn_ptr[BT].sdsx4df = SDSX4DF; |
| 1394 | |
| 1395 | SDSFP(BLOCK_128X128, aom_sad_skip_128x128, aom_sad_skip_128x128x4d); |
| 1396 | SDSFP(BLOCK_128X64, aom_sad_skip_128x64, aom_sad_skip_128x64x4d); |
| 1397 | SDSFP(BLOCK_64X128, aom_sad_skip_64x128, aom_sad_skip_64x128x4d); |
| 1398 | SDSFP(BLOCK_64X64, aom_sad_skip_64x64, aom_sad_skip_64x64x4d); |
| 1399 | SDSFP(BLOCK_64X32, aom_sad_skip_64x32, aom_sad_skip_64x32x4d); |
| 1400 | SDSFP(BLOCK_64X16, aom_sad_skip_64x16, aom_sad_skip_64x16x4d); |
| 1401 | SDSFP(BLOCK_32X64, aom_sad_skip_32x64, aom_sad_skip_32x64x4d); |
| 1402 | SDSFP(BLOCK_32X32, aom_sad_skip_32x32, aom_sad_skip_32x32x4d); |
| 1403 | SDSFP(BLOCK_32X16, aom_sad_skip_32x16, aom_sad_skip_32x16x4d); |
| 1404 | SDSFP(BLOCK_32X8, aom_sad_skip_32x8, aom_sad_skip_32x8x4d); |
| 1405 | |
| 1406 | SDSFP(BLOCK_16X64, aom_sad_skip_16x64, aom_sad_skip_16x64x4d); |
| 1407 | SDSFP(BLOCK_16X32, aom_sad_skip_16x32, aom_sad_skip_16x32x4d); |
| 1408 | SDSFP(BLOCK_16X16, aom_sad_skip_16x16, aom_sad_skip_16x16x4d); |
| 1409 | SDSFP(BLOCK_16X8, aom_sad_skip_16x8, aom_sad_skip_16x8x4d); |
| 1410 | SDSFP(BLOCK_8X16, aom_sad_skip_8x16, aom_sad_skip_8x16x4d); |
| 1411 | SDSFP(BLOCK_8X8, aom_sad_skip_8x8, aom_sad_skip_8x8x4d); |
| 1412 | SDSFP(BLOCK_4X16, aom_sad_skip_4x16, aom_sad_skip_4x16x4d); |
| 1413 | SDSFP(BLOCK_4X8, aom_sad_skip_4x8, aom_sad_skip_4x8x4d); |
chiyotsai | c814afb | 2020-08-04 13:12:35 -0700 | [diff] [blame] | 1414 | SDSFP(BLOCK_8X32, aom_sad_skip_8x32, aom_sad_skip_8x32x4d); |
chiyotsai | c814afb | 2020-08-04 13:12:35 -0700 | [diff] [blame] | 1415 | #undef SDSFP |
| 1416 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1417 | highbd_set_var_fns(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1418 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1419 | /* av1_init_quantizer() is first called here. Add check in |
| 1420 | * av1_frame_init_quantizer() so that av1_init_quantizer is only |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1421 | * called later when needed. This will avoid unnecessary calls of |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1422 | * av1_init_quantizer() for every frame. |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1423 | */ |
Ryan Lei | ccc6ea7 | 2021-01-06 11:43:56 -0800 | [diff] [blame] | 1424 | av1_init_quantizer(&cm->seq_params, &cpi->enc_quant_dequant_params, |
| 1425 | &cm->quant_params); |
Urvang Joshi | 1781462 | 2020-03-27 17:26:17 -0700 | [diff] [blame] | 1426 | av1_qm_init(&cm->quant_params, av1_num_planes(cm)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1427 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1428 | av1_loop_filter_init(cm); |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 1429 | cm->superres_scale_denominator = SCALE_NUMERATOR; |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 1430 | cm->superres_upscaled_width = oxcf->frm_dim_cfg.width; |
| 1431 | cm->superres_upscaled_height = oxcf->frm_dim_cfg.height; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1432 | av1_loop_restoration_precal(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1433 | |
| 1434 | cm->error.setjmp = 0; |
| 1435 | |
| 1436 | return cpi; |
| 1437 | } |
| 1438 | |
Urvang Joshi | ee2c811 | 2018-05-04 14:53:15 -0700 | [diff] [blame] | 1439 | #if CONFIG_INTERNAL_STATS |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1440 | #define SNPRINT(H, T) snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T)) |
| 1441 | |
| 1442 | #define SNPRINT2(H, T, V) \ |
| 1443 | snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T), (V)) |
Urvang Joshi | ee2c811 | 2018-05-04 14:53:15 -0700 | [diff] [blame] | 1444 | #endif // CONFIG_INTERNAL_STATS |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1445 | |
Sachin Kumar Garg | 700af53 | 2020-05-15 10:47:41 +0530 | [diff] [blame] | 1446 | // This function will change the state and free the mutex of corresponding |
| 1447 | // workers and terminate the object. The object can not be re-used unless a call |
| 1448 | // to reset() is made. |
| 1449 | static AOM_INLINE void terminate_worker_data(AV1_COMP *cpi) { |
| 1450 | MultiThreadInfo *const mt_info = &cpi->mt_info; |
| 1451 | for (int t = mt_info->num_workers - 1; t >= 0; --t) { |
| 1452 | AVxWorker *const worker = &mt_info->workers[t]; |
| 1453 | aom_get_worker_interface()->end(worker); |
| 1454 | } |
| 1455 | } |
| 1456 | |
| 1457 | // Deallocate allocated thread_data. |
| 1458 | static AOM_INLINE void free_thread_data(AV1_COMP *cpi) { |
| 1459 | MultiThreadInfo *const mt_info = &cpi->mt_info; |
| 1460 | AV1_COMMON *cm = &cpi->common; |
| 1461 | for (int t = 0; t < mt_info->num_workers; ++t) { |
| 1462 | EncWorkerData *const thread_data = &mt_info->tile_thr_data[t]; |
| 1463 | aom_free(thread_data->td->tctx); |
| 1464 | if (t == 0) continue; |
| 1465 | aom_free(thread_data->td->palette_buffer); |
| 1466 | aom_free(thread_data->td->tmp_conv_dst); |
Satish Kumar Suman | d3caa0d | 2020-06-16 14:02:50 +0530 | [diff] [blame] | 1467 | release_compound_type_rd_buffers(&thread_data->td->comp_rd_buffer); |
Sachin Kumar Garg | 700af53 | 2020-05-15 10:47:41 +0530 | [diff] [blame] | 1468 | for (int j = 0; j < 2; ++j) { |
| 1469 | aom_free(thread_data->td->tmp_pred_bufs[j]); |
| 1470 | } |
Satish Kumar Suman | d3caa0d | 2020-06-16 14:02:50 +0530 | [diff] [blame] | 1471 | release_obmc_buffers(&thread_data->td->obmc_buffer); |
Sachin Kumar Garg | 700af53 | 2020-05-15 10:47:41 +0530 | [diff] [blame] | 1472 | aom_free(thread_data->td->vt64x64); |
| 1473 | |
| 1474 | aom_free(thread_data->td->inter_modes_info); |
| 1475 | for (int x = 0; x < 2; x++) { |
| 1476 | for (int y = 0; y < 2; y++) { |
| 1477 | aom_free(thread_data->td->hash_value_buffer[x][y]); |
| 1478 | thread_data->td->hash_value_buffer[x][y] = NULL; |
| 1479 | } |
| 1480 | } |
| 1481 | aom_free(thread_data->td->counts); |
| 1482 | aom_free(thread_data->td->mbmi_ext); |
| 1483 | av1_free_pmc(thread_data->td->firstpass_ctx, av1_num_planes(cm)); |
| 1484 | thread_data->td->firstpass_ctx = NULL; |
| 1485 | av1_free_shared_coeff_buffer(&thread_data->td->shared_coeff_buf); |
| 1486 | av1_free_sms_tree(thread_data->td); |
| 1487 | aom_free(thread_data->td); |
| 1488 | } |
| 1489 | } |
| 1490 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1491 | void av1_remove_compressor(AV1_COMP *cpi) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1492 | if (!cpi) return; |
| 1493 | |
Yunqing Wang | 82f140a | 2020-06-03 18:40:50 -0700 | [diff] [blame] | 1494 | AV1_COMMON *cm = &cpi->common; |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 1495 | if (cm->current_frame.frame_number > 0) { |
Debargha Mukherjee | 5802ebe | 2016-12-21 04:17:24 -0800 | [diff] [blame] | 1496 | #if CONFIG_ENTROPY_STATS |
Mufaddal Chakera | e732612 | 2019-12-04 14:49:09 +0530 | [diff] [blame] | 1497 | if (!is_stat_generation_stage(cpi)) { |
Debargha Mukherjee | 5802ebe | 2016-12-21 04:17:24 -0800 | [diff] [blame] | 1498 | fprintf(stderr, "Writing counts.stt\n"); |
| 1499 | FILE *f = fopen("counts.stt", "wb"); |
| 1500 | fwrite(&aggregate_fc, sizeof(aggregate_fc), 1, f); |
| 1501 | fclose(f); |
| 1502 | } |
| 1503 | #endif // CONFIG_ENTROPY_STATS |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1504 | #if CONFIG_INTERNAL_STATS |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1505 | aom_clear_system_state(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1506 | |
Mufaddal Chakera | e732612 | 2019-12-04 14:49:09 +0530 | [diff] [blame] | 1507 | if (!is_stat_generation_stage(cpi)) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1508 | char headings[512] = { 0 }; |
| 1509 | char results[512] = { 0 }; |
| 1510 | FILE *f = fopen("opsnr.stt", "a"); |
| 1511 | double time_encoded = |
Deepa K G | fb89ce0 | 2020-04-06 13:34:42 +0530 | [diff] [blame] | 1512 | (cpi->time_stamps.prev_end_seen - cpi->time_stamps.first_ever) / |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1513 | 10000000.000; |
| 1514 | double total_encode_time = |
| 1515 | (cpi->time_receive_data + cpi->time_compress_data) / 1000.000; |
| 1516 | const double dr = |
| 1517 | (double)cpi->bytes * (double)8 / (double)1000 / time_encoded; |
Vishesh | 4342d7f | 2020-06-29 18:49:06 +0530 | [diff] [blame] | 1518 | const double peak = |
| 1519 | (double)((1 << cpi->oxcf.input_cfg.input_bit_depth) - 1); |
Vishesh | 073fc96 | 2020-07-01 17:39:16 +0530 | [diff] [blame] | 1520 | const double target_rate = |
| 1521 | (double)cpi->oxcf.rc_cfg.target_bandwidth / 1000; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1522 | const double rate_err = ((100.0 * (dr - target_rate)) / target_rate); |
| 1523 | |
| 1524 | if (cpi->b_calculate_psnr) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1525 | const double total_psnr = aom_sse_to_psnr( |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1526 | (double)cpi->total_samples, peak, (double)cpi->total_sq_error); |
| 1527 | const double total_ssim = |
| 1528 | 100 * pow(cpi->summed_quality / cpi->summed_weights, 8.0); |
| 1529 | snprintf(headings, sizeof(headings), |
Jingning Han | 87651b2 | 2017-11-28 20:02:26 -0800 | [diff] [blame] | 1530 | "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\t" |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1531 | "AOMSSIM\tVPSSIMP\tFASTSIM\tPSNRHVS\t" |
Jingning Han | be1ae3f | 2017-11-27 10:27:56 -0800 | [diff] [blame] | 1532 | "WstPsnr\tWstSsim\tWstFast\tWstHVS\t" |
Yue Chen | f0652ed | 2019-08-13 16:09:25 -0700 | [diff] [blame] | 1533 | "AVPsrnY\tAPsnrCb\tAPsnrCr"); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1534 | snprintf(results, sizeof(results), |
| 1535 | "%7.2f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t" |
| 1536 | "%7.3f\t%7.3f\t%7.3f\t%7.3f\t" |
Jingning Han | be1ae3f | 2017-11-27 10:27:56 -0800 | [diff] [blame] | 1537 | "%7.3f\t%7.3f\t%7.3f\t%7.3f\t" |
Yue Chen | f0652ed | 2019-08-13 16:09:25 -0700 | [diff] [blame] | 1538 | "%7.3f\t%7.3f\t%7.3f", |
Wan-Teh Chang | c25c92a | 2018-04-23 15:04:14 -0700 | [diff] [blame] | 1539 | dr, cpi->psnr.stat[STAT_ALL] / cpi->count, total_psnr, |
| 1540 | cpi->psnr.stat[STAT_ALL] / cpi->count, total_psnr, total_ssim, |
| 1541 | total_ssim, cpi->fastssim.stat[STAT_ALL] / cpi->count, |
| 1542 | cpi->psnrhvs.stat[STAT_ALL] / cpi->count, cpi->psnr.worst, |
Jingning Han | be1ae3f | 2017-11-27 10:27:56 -0800 | [diff] [blame] | 1543 | cpi->worst_ssim, cpi->fastssim.worst, cpi->psnrhvs.worst, |
Wan-Teh Chang | c25c92a | 2018-04-23 15:04:14 -0700 | [diff] [blame] | 1544 | cpi->psnr.stat[STAT_Y] / cpi->count, |
| 1545 | cpi->psnr.stat[STAT_U] / cpi->count, |
Yue Chen | f0652ed | 2019-08-13 16:09:25 -0700 | [diff] [blame] | 1546 | cpi->psnr.stat[STAT_V] / cpi->count); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1547 | |
| 1548 | if (cpi->b_calculate_blockiness) { |
| 1549 | SNPRINT(headings, "\t Block\tWstBlck"); |
| 1550 | SNPRINT2(results, "\t%7.3f", cpi->total_blockiness / cpi->count); |
| 1551 | SNPRINT2(results, "\t%7.3f", cpi->worst_blockiness); |
| 1552 | } |
| 1553 | |
| 1554 | if (cpi->b_calculate_consistency) { |
| 1555 | double consistency = |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1556 | aom_sse_to_psnr((double)cpi->total_samples, peak, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1557 | (double)cpi->total_inconsistency); |
| 1558 | |
| 1559 | SNPRINT(headings, "\tConsist\tWstCons"); |
| 1560 | SNPRINT2(results, "\t%7.3f", consistency); |
| 1561 | SNPRINT2(results, "\t%7.3f", cpi->worst_consistency); |
| 1562 | } |
Yue Chen | f0652ed | 2019-08-13 16:09:25 -0700 | [diff] [blame] | 1563 | |
| 1564 | SNPRINT(headings, "\t Time\tRcErr\tAbsErr"); |
| 1565 | SNPRINT2(results, "\t%8.0f", total_encode_time); |
| 1566 | SNPRINT2(results, "\t%7.2f", rate_err); |
| 1567 | SNPRINT2(results, "\t%7.2f", fabs(rate_err)); |
| 1568 | |
| 1569 | fprintf(f, "%s\tAPsnr611\n", headings); |
| 1570 | fprintf(f, "%s\t%7.3f\n", results, |
| 1571 | (6 * cpi->psnr.stat[STAT_Y] + cpi->psnr.stat[STAT_U] + |
| 1572 | cpi->psnr.stat[STAT_V]) / |
| 1573 | (cpi->count * 8)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1574 | } |
| 1575 | |
| 1576 | fclose(f); |
| 1577 | } |
Urvang Joshi | ee2c811 | 2018-05-04 14:53:15 -0700 | [diff] [blame] | 1578 | #endif // CONFIG_INTERNAL_STATS |
Debargha Mukherjee | 0857e66 | 2019-01-04 16:22:09 -0800 | [diff] [blame] | 1579 | #if CONFIG_SPEED_STATS |
Mufaddal Chakera | e732612 | 2019-12-04 14:49:09 +0530 | [diff] [blame] | 1580 | if (!is_stat_generation_stage(cpi)) { |
Debargha Mukherjee | 0857e66 | 2019-01-04 16:22:09 -0800 | [diff] [blame] | 1581 | fprintf(stdout, "tx_search_count = %d\n", cpi->tx_search_count); |
| 1582 | } |
| 1583 | #endif // CONFIG_SPEED_STATS |
chiyotsai | 92ed0dd | 2019-01-25 14:50:14 -0800 | [diff] [blame] | 1584 | |
chiyotsai | 9c484b3 | 2019-03-07 16:01:50 -0800 | [diff] [blame] | 1585 | #if CONFIG_COLLECT_PARTITION_STATS == 2 |
Mufaddal Chakera | e732612 | 2019-12-04 14:49:09 +0530 | [diff] [blame] | 1586 | if (!is_stat_generation_stage(cpi)) { |
chiyotsai | 92ed0dd | 2019-01-25 14:50:14 -0800 | [diff] [blame] | 1587 | av1_print_partition_stats(&cpi->partition_stats); |
| 1588 | } |
| 1589 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1590 | } |
| 1591 | |
Yunqing Wang | 82f140a | 2020-06-03 18:40:50 -0700 | [diff] [blame] | 1592 | TplParams *const tpl_data = &cpi->tpl_data; |
Jingning Han | f83d681 | 2020-02-27 13:08:19 -0800 | [diff] [blame] | 1593 | for (int frame = 0; frame < MAX_LAG_BUFFERS; ++frame) { |
Vishesh | 39d0362 | 2020-03-31 15:18:16 +0530 | [diff] [blame] | 1594 | aom_free(tpl_data->tpl_stats_pool[frame]); |
| 1595 | aom_free_frame_buffer(&tpl_data->tpl_rec_pool[frame]); |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 1596 | } |
| 1597 | |
Mufaddal Chakera | 9157925 | 2020-05-18 17:41:46 +0530 | [diff] [blame] | 1598 | if (cpi->compressor_stage != LAP_STAGE) { |
| 1599 | terminate_worker_data(cpi); |
| 1600 | free_thread_data(cpi); |
| 1601 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1602 | |
Yunqing Wang | 82f140a | 2020-06-03 18:40:50 -0700 | [diff] [blame] | 1603 | MultiThreadInfo *const mt_info = &cpi->mt_info; |
Ravi Chaudhary | 90a15f4 | 2018-10-11 18:56:35 +0530 | [diff] [blame] | 1604 | #if CONFIG_MULTITHREAD |
Yunqing Wang | 82f140a | 2020-06-03 18:40:50 -0700 | [diff] [blame] | 1605 | pthread_mutex_t *const enc_row_mt_mutex_ = mt_info->enc_row_mt.mutex_; |
| 1606 | pthread_mutex_t *const gm_mt_mutex_ = mt_info->gm_sync.mutex_; |
Deepa K G | 74de2a0 | 2020-04-11 13:09:11 +0530 | [diff] [blame] | 1607 | if (enc_row_mt_mutex_ != NULL) { |
| 1608 | pthread_mutex_destroy(enc_row_mt_mutex_); |
| 1609 | aom_free(enc_row_mt_mutex_); |
Ravi Chaudhary | 90a15f4 | 2018-10-11 18:56:35 +0530 | [diff] [blame] | 1610 | } |
Remya | 1a090d5 | 2020-05-04 11:52:10 +0530 | [diff] [blame] | 1611 | if (gm_mt_mutex_ != NULL) { |
| 1612 | pthread_mutex_destroy(gm_mt_mutex_); |
| 1613 | aom_free(gm_mt_mutex_); |
| 1614 | } |
Ravi Chaudhary | 90a15f4 | 2018-10-11 18:56:35 +0530 | [diff] [blame] | 1615 | #endif |
Ravi Chaudhary | c5e7469 | 2018-10-08 16:05:38 +0530 | [diff] [blame] | 1616 | av1_row_mt_mem_dealloc(cpi); |
Mufaddal Chakera | 9157925 | 2020-05-18 17:41:46 +0530 | [diff] [blame] | 1617 | if (cpi->compressor_stage != LAP_STAGE) { |
| 1618 | aom_free(mt_info->tile_thr_data); |
| 1619 | aom_free(mt_info->workers); |
| 1620 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1621 | |
Sachin Kumar Garg | 194c57b | 2020-05-06 08:50:13 +0530 | [diff] [blame] | 1622 | av1_tpl_dealloc(&tpl_data->tpl_mt_sync); |
Deepa K G | 74de2a0 | 2020-04-11 13:09:11 +0530 | [diff] [blame] | 1623 | if (mt_info->num_workers > 1) { |
| 1624 | av1_loop_filter_dealloc(&mt_info->lf_row_sync); |
| 1625 | av1_loop_restoration_dealloc(&mt_info->lr_row_sync, mt_info->num_workers); |
Remya | 1a090d5 | 2020-05-04 11:52:10 +0530 | [diff] [blame] | 1626 | av1_gm_dealloc(&mt_info->gm_sync); |
Deepa K G | 964e72e | 2018-05-16 16:56:01 +0530 | [diff] [blame] | 1627 | } |
| 1628 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1629 | dealloc_compressor_data(cpi); |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 1630 | #if CONFIG_IBP_DIR |
| 1631 | free_ibp_info(cm->ibp_directional_weights); |
| 1632 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1633 | |
Debargha Mukherjee | 5d15721 | 2017-01-10 14:44:47 -0800 | [diff] [blame] | 1634 | #if CONFIG_INTERNAL_STATS |
| 1635 | aom_free(cpi->ssim_vars); |
| 1636 | cpi->ssim_vars = NULL; |
| 1637 | #endif // CONFIG_INTERNAL_STATS |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1638 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1639 | av1_remove_common(cm); |
| 1640 | av1_free_ref_frame_buffers(cm->buffer_pool); |
Mufaddal Chakera | 74c9cbe | 2020-01-17 16:44:59 +0530 | [diff] [blame] | 1641 | |
Ryan Lei | ccc6ea7 | 2021-01-06 11:43:56 -0800 | [diff] [blame] | 1642 | #if DEBUG_EXTQUANT |
| 1643 | if (cpi->common.fEncCoeffLog != NULL) { |
| 1644 | fclose(cpi->common.fEncCoeffLog); |
| 1645 | } |
| 1646 | #endif |
| 1647 | |
Debargha Mukherjee | da89844 | 2020-07-10 14:45:20 -0700 | [diff] [blame] | 1648 | aom_free(cpi->subgop_config_str); |
Debargha Mukherjee | 5567170 | 2020-08-07 17:31:24 -0700 | [diff] [blame] | 1649 | aom_free(cpi->subgop_config_path); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1650 | aom_free(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1651 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1652 | #ifdef OUTPUT_YUV_REC |
| 1653 | fclose(yuv_rec_file); |
| 1654 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1655 | } |
| 1656 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1657 | static void generate_psnr_packet(AV1_COMP *cpi) { |
| 1658 | struct aom_codec_cx_pkt pkt; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1659 | int i; |
| 1660 | PSNR_STATS psnr; |
Vishesh | 4342d7f | 2020-06-29 18:49:06 +0530 | [diff] [blame] | 1661 | const uint32_t in_bit_depth = cpi->oxcf.input_cfg.input_bit_depth; |
Yaowu Xu | e75b58a | 2020-01-03 12:56:12 -0800 | [diff] [blame] | 1662 | const uint32_t bit_depth = cpi->td.mb.e_mbd.bd; |
| 1663 | aom_calc_highbd_psnr(cpi->source, &cpi->common.cur_frame->buf, &psnr, |
| 1664 | bit_depth, in_bit_depth); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1665 | |
| 1666 | for (i = 0; i < 4; ++i) { |
| 1667 | pkt.data.psnr.samples[i] = psnr.samples[i]; |
| 1668 | pkt.data.psnr.sse[i] = psnr.sse[i]; |
| 1669 | pkt.data.psnr.psnr[i] = psnr.psnr[i]; |
| 1670 | } |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1671 | pkt.kind = AOM_CODEC_PSNR_PKT; |
| 1672 | aom_codec_pkt_list_add(cpi->output_pkt_list, &pkt); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1673 | } |
| 1674 | |
Vishesh | a195ca3 | 2020-04-07 18:46:20 +0530 | [diff] [blame] | 1675 | int av1_use_as_reference(int *ext_ref_frame_flags, int ref_frame_flags) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1676 | if (ref_frame_flags > ((1 << INTER_REFS_PER_FRAME) - 1)) return -1; |
| 1677 | |
Vishesh | a195ca3 | 2020-04-07 18:46:20 +0530 | [diff] [blame] | 1678 | *ext_ref_frame_flags = ref_frame_flags; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1679 | return 0; |
| 1680 | } |
| 1681 | |
Thomas Daede | 497d195 | 2017-08-08 17:33:06 -0700 | [diff] [blame] | 1682 | int av1_copy_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd) { |
| 1683 | AV1_COMMON *const cm = &cpi->common; |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 1684 | const int num_planes = av1_num_planes(cm); |
Thomas Daede | 497d195 | 2017-08-08 17:33:06 -0700 | [diff] [blame] | 1685 | YV12_BUFFER_CONFIG *cfg = get_ref_frame(cm, idx); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1686 | if (cfg) { |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 1687 | aom_yv12_copy_frame(cfg, sd, num_planes); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1688 | return 0; |
| 1689 | } else { |
| 1690 | return -1; |
| 1691 | } |
| 1692 | } |
| 1693 | |
Thomas Daede | 497d195 | 2017-08-08 17:33:06 -0700 | [diff] [blame] | 1694 | int av1_set_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd) { |
| 1695 | AV1_COMMON *const cm = &cpi->common; |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 1696 | const int num_planes = av1_num_planes(cm); |
Thomas Daede | 497d195 | 2017-08-08 17:33:06 -0700 | [diff] [blame] | 1697 | YV12_BUFFER_CONFIG *cfg = get_ref_frame(cm, idx); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1698 | if (cfg) { |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 1699 | aom_yv12_copy_frame(sd, cfg, num_planes); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1700 | return 0; |
| 1701 | } else { |
| 1702 | return -1; |
| 1703 | } |
| 1704 | } |
| 1705 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1706 | #ifdef OUTPUT_YUV_REC |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1707 | void aom_write_one_yuv_frame(AV1_COMMON *cm, YV12_BUFFER_CONFIG *s) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1708 | uint8_t *src = s->y_buffer; |
| 1709 | int h = cm->height; |
Wei-Ting Lin | 01d4d8f | 2017-08-03 17:04:12 -0700 | [diff] [blame] | 1710 | if (yuv_rec_file == NULL) return; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1711 | if (s->flags & YV12_FLAG_HIGHBITDEPTH) { |
| 1712 | uint16_t *src16 = CONVERT_TO_SHORTPTR(s->y_buffer); |
| 1713 | |
| 1714 | do { |
| 1715 | fwrite(src16, s->y_width, 2, yuv_rec_file); |
| 1716 | src16 += s->y_stride; |
| 1717 | } while (--h); |
| 1718 | |
| 1719 | src16 = CONVERT_TO_SHORTPTR(s->u_buffer); |
| 1720 | h = s->uv_height; |
| 1721 | |
| 1722 | do { |
| 1723 | fwrite(src16, s->uv_width, 2, yuv_rec_file); |
| 1724 | src16 += s->uv_stride; |
| 1725 | } while (--h); |
| 1726 | |
| 1727 | src16 = CONVERT_TO_SHORTPTR(s->v_buffer); |
| 1728 | h = s->uv_height; |
| 1729 | |
| 1730 | do { |
| 1731 | fwrite(src16, s->uv_width, 2, yuv_rec_file); |
| 1732 | src16 += s->uv_stride; |
| 1733 | } while (--h); |
| 1734 | |
| 1735 | fflush(yuv_rec_file); |
| 1736 | return; |
| 1737 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1738 | |
| 1739 | do { |
| 1740 | fwrite(src, s->y_width, 1, yuv_rec_file); |
| 1741 | src += s->y_stride; |
| 1742 | } while (--h); |
| 1743 | |
| 1744 | src = s->u_buffer; |
| 1745 | h = s->uv_height; |
| 1746 | |
| 1747 | do { |
| 1748 | fwrite(src, s->uv_width, 1, yuv_rec_file); |
| 1749 | src += s->uv_stride; |
| 1750 | } while (--h); |
| 1751 | |
| 1752 | src = s->v_buffer; |
| 1753 | h = s->uv_height; |
| 1754 | |
| 1755 | do { |
| 1756 | fwrite(src, s->uv_width, 1, yuv_rec_file); |
| 1757 | src += s->uv_stride; |
| 1758 | } while (--h); |
| 1759 | |
| 1760 | fflush(yuv_rec_file); |
| 1761 | } |
| 1762 | #endif // OUTPUT_YUV_REC |
| 1763 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1764 | static void set_mv_search_params(AV1_COMP *cpi) { |
| 1765 | const AV1_COMMON *const cm = &cpi->common; |
Nithya V S | ace29f3 | 2020-04-07 16:15:12 +0530 | [diff] [blame] | 1766 | MotionVectorSearchParams *const mv_search_params = &cpi->mv_search_params; |
Yunqing Wang | 4b7bf40 | 2020-01-28 15:20:53 -0800 | [diff] [blame] | 1767 | const int max_mv_def = AOMMAX(cm->width, cm->height); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1768 | |
| 1769 | // Default based on max resolution. |
Nithya V S | ace29f3 | 2020-04-07 16:15:12 +0530 | [diff] [blame] | 1770 | mv_search_params->mv_step_param = av1_init_search_range(max_mv_def); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1771 | |
chiyotsai | 8cc054a | 2019-12-12 14:57:43 -0800 | [diff] [blame] | 1772 | if (cpi->sf.mv_sf.auto_mv_step_size) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1773 | if (frame_is_intra_only(cm)) { |
| 1774 | // Initialize max_mv_magnitude for use in the first INTER frame |
| 1775 | // after a key/intra-only frame. |
Nithya V S | ace29f3 | 2020-04-07 16:15:12 +0530 | [diff] [blame] | 1776 | mv_search_params->max_mv_magnitude = max_mv_def; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1777 | } else { |
Yunqing Wang | 4b7bf40 | 2020-01-28 15:20:53 -0800 | [diff] [blame] | 1778 | // Use cpi->max_mv_magnitude == -1 to exclude first pass case. |
Nithya V S | ace29f3 | 2020-04-07 16:15:12 +0530 | [diff] [blame] | 1779 | if (cm->show_frame && mv_search_params->max_mv_magnitude != -1) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1780 | // Allow mv_steps to correspond to twice the max mv magnitude found |
| 1781 | // in the previous frame, capped by the default max_mv_magnitude based |
| 1782 | // on resolution. |
Nithya V S | ace29f3 | 2020-04-07 16:15:12 +0530 | [diff] [blame] | 1783 | mv_search_params->mv_step_param = av1_init_search_range( |
| 1784 | AOMMIN(max_mv_def, 2 * mv_search_params->max_mv_magnitude)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1785 | } |
Nithya V S | ace29f3 | 2020-04-07 16:15:12 +0530 | [diff] [blame] | 1786 | mv_search_params->max_mv_magnitude = -1; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1787 | } |
| 1788 | } |
| 1789 | } |
| 1790 | |
Yaowu Xu | bca6190 | 2020-04-08 08:41:47 -0700 | [diff] [blame] | 1791 | void av1_set_screen_content_options(const AV1_COMP *cpi, |
| 1792 | FeatureFlags *features) { |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 1793 | const AV1_COMMON *const cm = &cpi->common; |
Hui Su | bdf0c99 | 2019-02-14 14:52:41 -0800 | [diff] [blame] | 1794 | |
| 1795 | if (cm->seq_params.force_screen_content_tools != 2) { |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 1796 | features->allow_screen_content_tools = features->allow_intrabc = |
Hui Su | bdf0c99 | 2019-02-14 14:52:41 -0800 | [diff] [blame] | 1797 | cm->seq_params.force_screen_content_tools; |
| 1798 | return; |
| 1799 | } |
| 1800 | |
Vishesh | 94a6529 | 2020-07-01 15:28:53 +0530 | [diff] [blame] | 1801 | if (cpi->oxcf.tune_cfg.content == AOM_CONTENT_SCREEN) { |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 1802 | features->allow_screen_content_tools = features->allow_intrabc = 1; |
Hui Su | bdf0c99 | 2019-02-14 14:52:41 -0800 | [diff] [blame] | 1803 | return; |
| 1804 | } |
| 1805 | |
| 1806 | // Estimate if the source frame is screen content, based on the portion of |
| 1807 | // blocks that have few luma colors. |
Cheng Chen | 4f666ca | 2019-11-18 17:05:03 -0800 | [diff] [blame] | 1808 | const uint8_t *src = cpi->unfiltered_source->y_buffer; |
Hui Su | bdf0c99 | 2019-02-14 14:52:41 -0800 | [diff] [blame] | 1809 | assert(src != NULL); |
Cheng Chen | 4f666ca | 2019-11-18 17:05:03 -0800 | [diff] [blame] | 1810 | const int use_hbd = cpi->unfiltered_source->flags & YV12_FLAG_HIGHBITDEPTH; |
| 1811 | const int stride = cpi->unfiltered_source->y_stride; |
| 1812 | const int width = cpi->unfiltered_source->y_width; |
| 1813 | const int height = cpi->unfiltered_source->y_height; |
Hui Su | bdf0c99 | 2019-02-14 14:52:41 -0800 | [diff] [blame] | 1814 | const int bd = cm->seq_params.bit_depth; |
| 1815 | const int blk_w = 16; |
| 1816 | const int blk_h = 16; |
| 1817 | // These threshold values are selected experimentally. |
| 1818 | const int color_thresh = 4; |
| 1819 | const unsigned int var_thresh = 0; |
| 1820 | // Counts of blocks with no more than color_thresh colors. |
| 1821 | int counts_1 = 0; |
| 1822 | // Counts of blocks with no more than color_thresh colors and variance larger |
| 1823 | // than var_thresh. |
| 1824 | int counts_2 = 0; |
| 1825 | |
| 1826 | for (int r = 0; r + blk_h <= height; r += blk_h) { |
| 1827 | for (int c = 0; c + blk_w <= width; c += blk_w) { |
Aasaipriya Chandran | fa3ecee | 2020-09-22 12:46:17 +0530 | [diff] [blame] | 1828 | int count_buf[1 << 8]; // Maximum (1 << 8) bins for hbd path. |
Hui Su | bdf0c99 | 2019-02-14 14:52:41 -0800 | [diff] [blame] | 1829 | const uint8_t *const this_src = src + r * stride + c; |
Aasaipriya chandran | 7c962c2 | 2020-10-08 12:37:42 +0530 | [diff] [blame] | 1830 | int n_colors; |
| 1831 | if (use_hbd) |
| 1832 | av1_count_colors_highbd(this_src, stride, blk_w, blk_h, bd, NULL, |
| 1833 | count_buf, &n_colors, NULL); |
| 1834 | else |
| 1835 | av1_count_colors(this_src, stride, blk_w, blk_h, count_buf, &n_colors); |
Hui Su | bdf0c99 | 2019-02-14 14:52:41 -0800 | [diff] [blame] | 1836 | if (n_colors > 1 && n_colors <= color_thresh) { |
| 1837 | ++counts_1; |
| 1838 | struct buf_2d buf; |
| 1839 | buf.stride = stride; |
| 1840 | buf.buf = (uint8_t *)this_src; |
| 1841 | const unsigned int var = |
| 1842 | use_hbd |
| 1843 | ? av1_high_get_sby_perpixel_variance(cpi, &buf, BLOCK_16X16, bd) |
| 1844 | : av1_get_sby_perpixel_variance(cpi, &buf, BLOCK_16X16); |
| 1845 | if (var > var_thresh) ++counts_2; |
| 1846 | } |
| 1847 | } |
| 1848 | } |
| 1849 | |
Debargha Mukherjee | 0a2f6d1 | 2021-07-13 15:50:15 -0700 | [diff] [blame] | 1850 | const int col_factor = 11; |
| 1851 | const int var_factor = 12; |
| 1852 | |
Hui Su | bdf0c99 | 2019-02-14 14:52:41 -0800 | [diff] [blame] | 1853 | // The threshold values are selected experimentally. |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 1854 | features->allow_screen_content_tools = |
Debargha Mukherjee | 0a2f6d1 | 2021-07-13 15:50:15 -0700 | [diff] [blame] | 1855 | counts_1 * blk_h * blk_w * col_factor > width * height; |
Hui Su | bdf0c99 | 2019-02-14 14:52:41 -0800 | [diff] [blame] | 1856 | // IntraBC would force loop filters off, so we use more strict rules that also |
| 1857 | // requires that the block has high variance. |
Debargha Mukherjee | 0a2f6d1 | 2021-07-13 15:50:15 -0700 | [diff] [blame] | 1858 | features->allow_intrabc = |
| 1859 | features->allow_screen_content_tools && |
| 1860 | counts_2 * blk_h * blk_w * var_factor > width * height; |
| 1861 | /* |
| 1862 | printf("allow_screen_content_tools = %d, allow_intrabc = %d\n", |
| 1863 | features->allow_screen_content_tools, features->allow_intrabc); |
| 1864 | printf("c1 %d > %f; c1 %d > %f\n", counts_1, |
| 1865 | width * height / ((float)(blk_h * blk_w * col_factor)), counts_2, |
| 1866 | width * height / ((float)(blk_h * blk_w * var_factor))); |
| 1867 | */ |
Hui Su | bdf0c99 | 2019-02-14 14:52:41 -0800 | [diff] [blame] | 1868 | } |
| 1869 | |
venkat sanampudi | 14affd0 | 2020-07-23 07:41:05 +0530 | [diff] [blame] | 1870 | // Function pointer to search site config initialization |
| 1871 | // of different search method functions. |
| 1872 | typedef void (*av1_init_search_site_config)(search_site_config *cfg, |
| 1873 | int stride); |
| 1874 | |
| 1875 | av1_init_search_site_config |
| 1876 | av1_init_motion_compensation[NUM_DISTINCT_SEARCH_METHODS] = { |
| 1877 | av1_init_dsmotion_compensation, av1_init_motion_compensation_nstep, |
| 1878 | av1_init_motion_compensation_hex, av1_init_motion_compensation_bigdia, |
| 1879 | av1_init_motion_compensation_square |
| 1880 | }; |
| 1881 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1882 | static void init_motion_estimation(AV1_COMP *cpi) { |
Urvang Joshi | 510d8f6 | 2019-01-10 12:11:50 -0800 | [diff] [blame] | 1883 | AV1_COMMON *const cm = &cpi->common; |
Nithya V S | ace29f3 | 2020-04-07 16:15:12 +0530 | [diff] [blame] | 1884 | MotionVectorSearchParams *const mv_search_params = &cpi->mv_search_params; |
chiyotsai | 836b69b | 2019-04-09 13:41:24 -0700 | [diff] [blame] | 1885 | const int y_stride = cpi->scaled_source.y_stride; |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 1886 | const int y_stride_src = ((cpi->oxcf.frm_dim_cfg.width != cm->width || |
| 1887 | cpi->oxcf.frm_dim_cfg.height != cm->height) || |
| 1888 | av1_superres_scaled(cm)) |
| 1889 | ? y_stride |
| 1890 | : cpi->lookahead->buf->img.y_stride; |
Mufaddal Chakera | 975f73a | 2020-03-31 13:22:25 +0530 | [diff] [blame] | 1891 | int fpf_y_stride = cm->cur_frame != NULL ? cm->cur_frame->buf.y_stride |
| 1892 | : cpi->scaled_source.y_stride; |
| 1893 | |
Cheng Chen | caf3351 | 2020-04-21 14:54:57 -0700 | [diff] [blame] | 1894 | // Update if search_site_cfg is uninitialized or the current frame has a new |
| 1895 | // stride |
Nithya V S | ace29f3 | 2020-04-07 16:15:12 +0530 | [diff] [blame] | 1896 | const int should_update = |
venkat sanampudi | 14affd0 | 2020-07-23 07:41:05 +0530 | [diff] [blame] | 1897 | !mv_search_params->search_site_cfg[SS_CFG_SRC][DIAMOND].stride || |
| 1898 | !mv_search_params->search_site_cfg[SS_CFG_LOOKAHEAD][DIAMOND].stride || |
| 1899 | (y_stride != |
| 1900 | mv_search_params->search_site_cfg[SS_CFG_SRC][DIAMOND].stride); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1901 | |
chiyotsai | 836b69b | 2019-04-09 13:41:24 -0700 | [diff] [blame] | 1902 | if (!should_update) { |
| 1903 | return; |
| 1904 | } |
| 1905 | |
venkat sanampudi | 14affd0 | 2020-07-23 07:41:05 +0530 | [diff] [blame] | 1906 | // Initialization of search_site_cfg for NUM_DISTINCT_SEARCH_METHODS. |
| 1907 | for (SEARCH_METHODS i = DIAMOND; i < NUM_DISTINCT_SEARCH_METHODS; i++) { |
| 1908 | av1_init_motion_compensation[i]( |
| 1909 | &mv_search_params->search_site_cfg[SS_CFG_SRC][i], y_stride); |
| 1910 | av1_init_motion_compensation[i]( |
| 1911 | &mv_search_params->search_site_cfg[SS_CFG_LOOKAHEAD][i], y_stride_src); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1912 | } |
venkat sanampudi | dc5371c | 2020-07-10 09:36:01 +0530 | [diff] [blame] | 1913 | |
venkat sanampudi | 14affd0 | 2020-07-23 07:41:05 +0530 | [diff] [blame] | 1914 | // First pass search site config initialization. |
| 1915 | av1_init_motion_fpf(&mv_search_params->search_site_cfg[SS_CFG_FPF][DIAMOND], |
Cheng Chen | caf3351 | 2020-04-21 14:54:57 -0700 | [diff] [blame] | 1916 | fpf_y_stride); |
venkat sanampudi | 14affd0 | 2020-07-23 07:41:05 +0530 | [diff] [blame] | 1917 | for (SEARCH_METHODS i = NSTEP; i < NUM_DISTINCT_SEARCH_METHODS; i++) { |
| 1918 | memcpy(&mv_search_params->search_site_cfg[SS_CFG_FPF][i], |
| 1919 | &mv_search_params->search_site_cfg[SS_CFG_FPF][DIAMOND], |
| 1920 | sizeof(search_site_config)); |
venkat sanampudi | dc5371c | 2020-07-10 09:36:01 +0530 | [diff] [blame] | 1921 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1922 | } |
| 1923 | |
Debargha Mukherjee | 84f567c | 2017-06-21 10:53:59 -0700 | [diff] [blame] | 1924 | #define COUPLED_CHROMA_FROM_LUMA_RESTORATION 0 |
Rupert Swarbrick | bcb65fe | 2017-10-25 17:15:28 +0100 | [diff] [blame] | 1925 | static void set_restoration_unit_size(int width, int height, int sx, int sy, |
| 1926 | RestorationInfo *rst) { |
Debargha Mukherjee | 1008c1e | 2017-03-06 19:18:43 -0800 | [diff] [blame] | 1927 | (void)width; |
| 1928 | (void)height; |
Debargha Mukherjee | 84f567c | 2017-06-21 10:53:59 -0700 | [diff] [blame] | 1929 | (void)sx; |
| 1930 | (void)sy; |
| 1931 | #if COUPLED_CHROMA_FROM_LUMA_RESTORATION |
| 1932 | int s = AOMMIN(sx, sy); |
| 1933 | #else |
| 1934 | int s = 0; |
| 1935 | #endif // !COUPLED_CHROMA_FROM_LUMA_RESTORATION |
| 1936 | |
Debargha Mukherjee | 5f7f367 | 2017-08-12 10:22:49 -0700 | [diff] [blame] | 1937 | if (width * height > 352 * 288) |
Urvang Joshi | 813186b | 2018-03-08 15:38:46 -0800 | [diff] [blame] | 1938 | rst[0].restoration_unit_size = RESTORATION_UNITSIZE_MAX; |
Debargha Mukherjee | 5f7f367 | 2017-08-12 10:22:49 -0700 | [diff] [blame] | 1939 | else |
Urvang Joshi | 813186b | 2018-03-08 15:38:46 -0800 | [diff] [blame] | 1940 | rst[0].restoration_unit_size = (RESTORATION_UNITSIZE_MAX >> 1); |
Rupert Swarbrick | bcb65fe | 2017-10-25 17:15:28 +0100 | [diff] [blame] | 1941 | rst[1].restoration_unit_size = rst[0].restoration_unit_size >> s; |
| 1942 | rst[2].restoration_unit_size = rst[1].restoration_unit_size; |
Debargha Mukherjee | 1008c1e | 2017-03-06 19:18:43 -0800 | [diff] [blame] | 1943 | } |
Debargha Mukherjee | 1008c1e | 2017-03-06 19:18:43 -0800 | [diff] [blame] | 1944 | |
Ravi Chaudhary | 783d6a3 | 2018-08-28 18:21:02 +0530 | [diff] [blame] | 1945 | static void init_ref_frame_bufs(AV1_COMP *cpi) { |
| 1946 | AV1_COMMON *const cm = &cpi->common; |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 1947 | int i; |
| 1948 | BufferPool *const pool = cm->buffer_pool; |
Jack Haughton | ddb8060 | 2018-11-21 16:41:49 +0000 | [diff] [blame] | 1949 | cm->cur_frame = NULL; |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 1950 | for (i = 0; i < REF_FRAMES; ++i) { |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 1951 | cm->ref_frame_map[i] = NULL; |
Wan-Teh Chang | d05e033 | 2018-10-03 12:00:43 -0700 | [diff] [blame] | 1952 | } |
| 1953 | for (i = 0; i < FRAME_BUFFERS; ++i) { |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 1954 | pool->frame_bufs[i].ref_count = 0; |
| 1955 | } |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 1956 | } |
| 1957 | |
Mufaddal Chakera | 02ac17f | 2019-12-09 18:09:55 +0530 | [diff] [blame] | 1958 | void av1_check_initial_width(AV1_COMP *cpi, int use_highbitdepth, |
| 1959 | int subsampling_x, int subsampling_y) { |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 1960 | AV1_COMMON *const cm = &cpi->common; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 1961 | SequenceHeader *const seq_params = &cm->seq_params; |
Jayasanker J | 44fdab7 | 2020-04-13 20:34:38 +0530 | [diff] [blame] | 1962 | InitialDimensions *const initial_dimensions = &cpi->initial_dimensions; |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 1963 | |
Jayasanker J | 44fdab7 | 2020-04-13 20:34:38 +0530 | [diff] [blame] | 1964 | if (!initial_dimensions->width || |
| 1965 | seq_params->use_highbitdepth != use_highbitdepth || |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 1966 | seq_params->subsampling_x != subsampling_x || |
| 1967 | seq_params->subsampling_y != subsampling_y) { |
| 1968 | seq_params->subsampling_x = subsampling_x; |
| 1969 | seq_params->subsampling_y = subsampling_y; |
| 1970 | seq_params->use_highbitdepth = use_highbitdepth; |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 1971 | |
Jingning Han | 183b2a8 | 2019-12-18 16:03:41 -0800 | [diff] [blame] | 1972 | av1_set_speed_features_framesize_independent(cpi, cpi->oxcf.speed); |
| 1973 | av1_set_speed_features_framesize_dependent(cpi, cpi->oxcf.speed); |
| 1974 | |
Mufaddal Chakera | 975f73a | 2020-03-31 13:22:25 +0530 | [diff] [blame] | 1975 | if (!is_stat_generation_stage(cpi)) { |
| 1976 | alloc_altref_frame_buffer(cpi); |
| 1977 | alloc_util_frame_buffers(cpi); |
| 1978 | } |
Ravi Chaudhary | 783d6a3 | 2018-08-28 18:21:02 +0530 | [diff] [blame] | 1979 | init_ref_frame_bufs(cpi); |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 1980 | |
| 1981 | init_motion_estimation(cpi); // TODO(agrange) This can be removed. |
| 1982 | |
Jayasanker J | 44fdab7 | 2020-04-13 20:34:38 +0530 | [diff] [blame] | 1983 | initial_dimensions->width = cm->width; |
| 1984 | initial_dimensions->height = cm->height; |
Urvang Joshi | 9dc909d | 2020-03-23 16:07:02 -0700 | [diff] [blame] | 1985 | cpi->initial_mbs = cm->mi_params.MBs; |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 1986 | } |
| 1987 | } |
| 1988 | |
| 1989 | // Returns 1 if the assigned width or height was <= 0. |
Marco Paniconi | 6397132 | 2019-08-15 21:32:05 -0700 | [diff] [blame] | 1990 | int av1_set_size_literal(AV1_COMP *cpi, int width, int height) { |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 1991 | AV1_COMMON *cm = &cpi->common; |
Jayasanker J | 44fdab7 | 2020-04-13 20:34:38 +0530 | [diff] [blame] | 1992 | InitialDimensions *const initial_dimensions = &cpi->initial_dimensions; |
Mufaddal Chakera | 02ac17f | 2019-12-09 18:09:55 +0530 | [diff] [blame] | 1993 | av1_check_initial_width(cpi, cm->seq_params.use_highbitdepth, |
| 1994 | cm->seq_params.subsampling_x, |
| 1995 | cm->seq_params.subsampling_y); |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 1996 | |
| 1997 | if (width <= 0 || height <= 0) return 1; |
| 1998 | |
| 1999 | cm->width = width; |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 2000 | cm->height = height; |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 2001 | |
Jayasanker J | 44fdab7 | 2020-04-13 20:34:38 +0530 | [diff] [blame] | 2002 | if (initial_dimensions->width && initial_dimensions->height && |
| 2003 | (cm->width > initial_dimensions->width || |
| 2004 | cm->height > initial_dimensions->height)) { |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 2005 | av1_free_context_buffers(cm); |
Yue Chen | eb62898 | 2019-08-29 15:17:13 -0700 | [diff] [blame] | 2006 | av1_free_shared_coeff_buffer(&cpi->td.shared_coeff_buf); |
| 2007 | av1_free_sms_tree(&cpi->td); |
Mufaddal Chakera | 6c3b6de | 2020-04-29 12:27:42 +0530 | [diff] [blame] | 2008 | av1_free_pmc(cpi->td.firstpass_ctx, av1_num_planes(cm)); |
| 2009 | cpi->td.firstpass_ctx = NULL; |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 2010 | alloc_compressor_data(cpi); |
| 2011 | realloc_segmentation_maps(cpi); |
Jayasanker J | 44fdab7 | 2020-04-13 20:34:38 +0530 | [diff] [blame] | 2012 | initial_dimensions->width = initial_dimensions->height = 0; |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 2013 | } |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 2014 | update_frame_size(cpi); |
| 2015 | |
| 2016 | return 0; |
| 2017 | } |
| 2018 | |
David Turner | 475a313 | 2019-01-18 15:17:17 +0000 | [diff] [blame] | 2019 | void av1_set_frame_size(AV1_COMP *cpi, int width, int height) { |
Fergus Simpson | bc18993 | 2017-05-16 17:02:39 -0700 | [diff] [blame] | 2020 | AV1_COMMON *const cm = &cpi->common; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 2021 | const SequenceHeader *const seq_params = &cm->seq_params; |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 2022 | const int num_planes = av1_num_planes(cm); |
Fergus Simpson | bc18993 | 2017-05-16 17:02:39 -0700 | [diff] [blame] | 2023 | MACROBLOCKD *const xd = &cpi->td.mb.e_mbd; |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 2024 | int ref_frame; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2025 | |
Fergus Simpson | bc18993 | 2017-05-16 17:02:39 -0700 | [diff] [blame] | 2026 | if (width != cm->width || height != cm->height) { |
Fergus Simpson | 3502d08 | 2017-04-10 12:25:07 -0700 | [diff] [blame] | 2027 | // There has been a change in the encoded frame size |
Marco Paniconi | 6397132 | 2019-08-15 21:32:05 -0700 | [diff] [blame] | 2028 | av1_set_size_literal(cpi, width, height); |
Urvang Joshi | c8b52d5 | 2018-03-23 13:16:51 -0700 | [diff] [blame] | 2029 | // Recalculate 'all_lossless' in case super-resolution was (un)selected. |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 2030 | cm->features.all_lossless = |
| 2031 | cm->features.coded_lossless && !av1_superres_scaled(cm); |
Fyodor Kyslov | 34b591f | 2020-06-24 20:13:58 -0700 | [diff] [blame] | 2032 | |
| 2033 | av1_noise_estimate_init(&cpi->noise_estimate, cm->width, cm->height); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2034 | } |
Yunqing Wang | 4b7bf40 | 2020-01-28 15:20:53 -0800 | [diff] [blame] | 2035 | set_mv_search_params(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2036 | |
Hamsalekha S | 37cc1d1 | 2019-12-12 19:27:41 +0530 | [diff] [blame] | 2037 | if (is_stat_consumption_stage(cpi)) { |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 2038 | av1_set_target_rate(cpi, cm->width, cm->height); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2039 | } |
| 2040 | |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 2041 | alloc_frame_mvs(cm, cm->cur_frame); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2042 | |
Cherma Rajan A | 71d20db | 2018-04-27 11:15:32 +0530 | [diff] [blame] | 2043 | // Allocate above context buffers |
Urvang Joshi | 5c8625a | 2020-03-30 13:16:37 -0700 | [diff] [blame] | 2044 | CommonContexts *const above_contexts = &cm->above_contexts; |
| 2045 | if (above_contexts->num_planes < av1_num_planes(cm) || |
| 2046 | above_contexts->num_mi_cols < cm->mi_params.mi_cols || |
| 2047 | above_contexts->num_tile_rows < cm->tiles.rows) { |
| 2048 | av1_free_above_context_buffers(above_contexts); |
| 2049 | if (av1_alloc_above_context_buffers(above_contexts, cm->tiles.rows, |
| 2050 | cm->mi_params.mi_cols, |
| 2051 | av1_num_planes(cm))) |
Cherma Rajan A | 71d20db | 2018-04-27 11:15:32 +0530 | [diff] [blame] | 2052 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
| 2053 | "Failed to allocate context buffers"); |
| 2054 | } |
| 2055 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2056 | // Reset the frame pointers to the current frame size. |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 2057 | if (aom_realloc_frame_buffer( |
Jack Haughton | ddb8060 | 2018-11-21 16:41:49 +0000 | [diff] [blame] | 2058 | &cm->cur_frame->buf, cm->width, cm->height, seq_params->subsampling_x, |
| 2059 | seq_params->subsampling_y, seq_params->use_highbitdepth, |
Urvang Joshi | 6237b88 | 2020-03-26 15:02:26 -0700 | [diff] [blame] | 2060 | cpi->oxcf.border_in_pixels, cm->features.byte_alignment, NULL, NULL, |
| 2061 | NULL)) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2062 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2063 | "Failed to allocate frame buffer"); |
| 2064 | |
Rupert Swarbrick | f88bc04 | 2017-10-18 10:45:51 +0100 | [diff] [blame] | 2065 | const int frame_width = cm->superres_upscaled_width; |
| 2066 | const int frame_height = cm->superres_upscaled_height; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 2067 | set_restoration_unit_size(frame_width, frame_height, |
| 2068 | seq_params->subsampling_x, |
| 2069 | seq_params->subsampling_y, cm->rst_info); |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 2070 | for (int i = 0; i < num_planes; ++i) |
Rupert Swarbrick | 1a96c3f | 2017-10-24 11:55:00 +0100 | [diff] [blame] | 2071 | cm->rst_info[i].frame_restoration_type = RESTORE_NONE; |
Rupert Swarbrick | f88bc04 | 2017-10-18 10:45:51 +0100 | [diff] [blame] | 2072 | |
| 2073 | av1_alloc_restoration_buffers(cm); |
Mufaddal Chakera | 975f73a | 2020-03-31 13:22:25 +0530 | [diff] [blame] | 2074 | if (!is_stat_generation_stage(cpi)) alloc_util_frame_buffers(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2075 | init_motion_estimation(cpi); |
| 2076 | |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2077 | #if CONFIG_NEW_REF_SIGNALING |
| 2078 | for (ref_frame = 0; ref_frame < INTER_REFS_PER_FRAME; ++ref_frame) { |
| 2079 | #else |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2080 | for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2081 | #endif // CONFIG_NEW_REF_SIGNALING |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 2082 | RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame); |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 2083 | if (buf != NULL) { |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 2084 | struct scale_factors *sf = get_ref_scale_factors(cm, ref_frame); |
| 2085 | av1_setup_scale_factors_for_frame(sf, buf->buf.y_crop_width, |
David Turner | 1bcefb3 | 2018-11-19 17:54:00 +0000 | [diff] [blame] | 2086 | buf->buf.y_crop_height, cm->width, |
Debargha Mukherjee | e242a81 | 2018-03-07 21:43:09 -0800 | [diff] [blame] | 2087 | cm->height); |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 2088 | if (av1_is_scaled(sf)) aom_extend_frame_borders(&buf->buf, num_planes); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2089 | } |
| 2090 | } |
Zoe Liu | 7b1ec7a | 2017-05-24 22:28:24 -0700 | [diff] [blame] | 2091 | |
Hui Su | 5ebd870 | 2018-01-08 18:09:20 -0800 | [diff] [blame] | 2092 | av1_setup_scale_factors_for_frame(&cm->sf_identity, cm->width, cm->height, |
Debargha Mukherjee | e242a81 | 2018-03-07 21:43:09 -0800 | [diff] [blame] | 2093 | cm->width, cm->height); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2094 | |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2095 | #if CONFIG_NEW_REF_SIGNALING |
| 2096 | set_ref_ptrs(cm, xd, 0, 0); |
| 2097 | #else |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2098 | set_ref_ptrs(cm, xd, LAST_FRAME, LAST_FRAME); |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2099 | #endif // CONFIG_NEW_REF_SIGNALING |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2100 | } |
| 2101 | |
Yue Chen | 2d8405c | 2020-06-10 14:42:05 -0700 | [diff] [blame] | 2102 | /*!\brief Select and apply cdef filters and switchable restoration filters |
| 2103 | * |
| 2104 | * \ingroup high_level_algo |
Yue Chen | 2d8405c | 2020-06-10 14:42:05 -0700 | [diff] [blame] | 2105 | */ |
Yue Chen | 92271e1 | 2019-07-09 16:28:02 -0700 | [diff] [blame] | 2106 | static void cdef_restoration_frame(AV1_COMP *cpi, AV1_COMMON *cm, |
| 2107 | MACROBLOCKD *xd, int use_restoration, |
| 2108 | int use_cdef) { |
yixindu | 368bde5 | 2021-06-04 18:30:53 -0700 | [diff] [blame] | 2109 | #if CONFIG_CCSO |
| 2110 | uint16_t *rec_uv[2]; |
| 2111 | uint16_t *org_uv[2]; |
| 2112 | uint16_t *ext_rec_y; |
| 2113 | uint8_t *ref_buffer; |
| 2114 | const YV12_BUFFER_CONFIG *ref = cpi->source; |
| 2115 | int ref_stride; |
| 2116 | const int use_ccso = !cm->features.coded_lossless && !cm->tiles.large_scale && |
| 2117 | cm->seq_params.enable_ccso; |
| 2118 | const int num_planes = av1_num_planes(cm); |
| 2119 | av1_setup_dst_planes(xd->plane, cm->seq_params.sb_size, &cm->cur_frame->buf, |
| 2120 | 0, 0, 0, num_planes); |
| 2121 | const int ccso_stride = xd->plane[0].dst.width; |
| 2122 | const int ccso_stride_ext = xd->plane[0].dst.width + (CCSO_PADDING_SIZE << 1); |
| 2123 | for (int pli = 0; pli < 2; pli++) { |
| 2124 | rec_uv[pli] = |
| 2125 | aom_malloc(sizeof(*rec_uv) * xd->plane[0].dst.height * ccso_stride); |
| 2126 | org_uv[pli] = |
| 2127 | aom_malloc(sizeof(*org_uv) * xd->plane[0].dst.height * ccso_stride); |
| 2128 | } |
| 2129 | if (use_ccso) { |
| 2130 | ext_rec_y = |
| 2131 | aom_malloc(sizeof(*ext_rec_y) * |
| 2132 | (xd->plane[0].dst.height + (CCSO_PADDING_SIZE << 1)) * |
| 2133 | (xd->plane[0].dst.width + (CCSO_PADDING_SIZE << 1))); |
| 2134 | for (int pli = 0; pli < 1; pli++) { |
| 2135 | const int pic_height = xd->plane[pli].dst.height; |
| 2136 | const int pic_width = xd->plane[pli].dst.width; |
| 2137 | const int dst_stride = xd->plane[pli].dst.stride; |
| 2138 | for (int r = 0; r < pic_height; ++r) { |
| 2139 | for (int c = 0; c < pic_width; ++c) { |
| 2140 | if (cm->seq_params.use_highbitdepth) { |
| 2141 | if (pli == 0) |
| 2142 | ext_rec_y[(r + CCSO_PADDING_SIZE) * ccso_stride_ext + c + |
| 2143 | CCSO_PADDING_SIZE] = |
| 2144 | CONVERT_TO_SHORTPTR( |
| 2145 | xd->plane[pli].dst.buf)[r * dst_stride + c]; |
| 2146 | } else { |
| 2147 | if (pli == 0) |
| 2148 | ext_rec_y[(r + CCSO_PADDING_SIZE) * ccso_stride_ext + c + |
| 2149 | CCSO_PADDING_SIZE] = |
| 2150 | xd->plane[pli].dst.buf[r * dst_stride + c]; |
| 2151 | } |
| 2152 | } |
| 2153 | } |
| 2154 | } |
| 2155 | extend_ccso_border(ext_rec_y, CCSO_PADDING_SIZE, xd); |
| 2156 | } |
| 2157 | #endif |
| 2158 | |
Deepa K G | 74de2a0 | 2020-04-11 13:09:11 +0530 | [diff] [blame] | 2159 | MultiThreadInfo *const mt_info = &cpi->mt_info; |
| 2160 | const int num_workers = mt_info->num_workers; |
logangw | f95c916 | 2019-02-20 12:02:32 -0800 | [diff] [blame] | 2161 | if (use_restoration) |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 2162 | av1_loop_restoration_save_boundary_lines(&cm->cur_frame->buf, cm, 0); |
Ola Hugosson | 1e7f2d0 | 2017-09-22 21:36:26 +0200 | [diff] [blame] | 2163 | |
logangw | f95c916 | 2019-02-20 12:02:32 -0800 | [diff] [blame] | 2164 | if (use_cdef) { |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 2165 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 2166 | start_timing(cpi, cdef_time); |
| 2167 | #endif |
Steinar Midtskogen | 5978212 | 2017-07-20 08:49:43 +0200 | [diff] [blame] | 2168 | // Find CDEF parameters |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 2169 | av1_cdef_search(&cm->cur_frame->buf, cpi->source, cm, xd, |
chiyotsai | d2f7b41 | 2019-12-18 10:16:42 -0800 | [diff] [blame] | 2170 | cpi->sf.lpf_sf.cdef_pick_method, cpi->td.mb.rdmult); |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 2171 | |
| 2172 | // Apply the filter |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 2173 | av1_cdef_frame(&cm->cur_frame->buf, cm, xd); |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 2174 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 2175 | end_timing(cpi, cdef_time); |
| 2176 | #endif |
logangw | f95c916 | 2019-02-20 12:02:32 -0800 | [diff] [blame] | 2177 | } else { |
| 2178 | cm->cdef_info.cdef_bits = 0; |
| 2179 | cm->cdef_info.cdef_strengths[0] = 0; |
| 2180 | cm->cdef_info.nb_cdef_strengths = 1; |
| 2181 | cm->cdef_info.cdef_uv_strengths[0] = 0; |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 2182 | } |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 2183 | |
yixindu | 368bde5 | 2021-06-04 18:30:53 -0700 | [diff] [blame] | 2184 | #if CONFIG_CCSO |
| 2185 | if (use_ccso) { |
| 2186 | av1_setup_dst_planes(xd->plane, cm->seq_params.sb_size, &cm->cur_frame->buf, |
| 2187 | 0, 0, 0, num_planes); |
| 2188 | // Reading original and reconstructed chroma samples as input |
| 2189 | for (int pli = 1; pli < 3; pli++) { |
| 2190 | const int pic_height = xd->plane[pli].dst.height; |
| 2191 | const int pic_width = xd->plane[pli].dst.width; |
| 2192 | const int dst_stride = xd->plane[pli].dst.stride; |
| 2193 | switch (pli) { |
| 2194 | case 1: |
| 2195 | ref_buffer = ref->u_buffer; |
| 2196 | ref_stride = ref->uv_stride; |
| 2197 | break; |
| 2198 | case 2: |
| 2199 | ref_buffer = ref->v_buffer; |
| 2200 | ref_stride = ref->uv_stride; |
| 2201 | break; |
| 2202 | default: ref_stride = 0; |
| 2203 | } |
| 2204 | for (int r = 0; r < pic_height; ++r) { |
| 2205 | for (int c = 0; c < pic_width; ++c) { |
| 2206 | if (cm->seq_params.use_highbitdepth) { |
| 2207 | rec_uv[pli - 1][r * ccso_stride + c] = |
| 2208 | CONVERT_TO_SHORTPTR(xd->plane[pli].dst.buf)[r * dst_stride + c]; |
| 2209 | org_uv[pli - 1][r * ccso_stride + c] = |
| 2210 | CONVERT_TO_SHORTPTR(ref_buffer)[r * ref_stride + c]; |
| 2211 | } else { |
| 2212 | rec_uv[pli - 1][r * ccso_stride + c] = |
| 2213 | xd->plane[pli].dst.buf[r * dst_stride + c]; |
| 2214 | org_uv[pli - 1][r * ccso_stride + c] = |
| 2215 | ref_buffer[r * ref_stride + c]; |
| 2216 | } |
| 2217 | } |
| 2218 | } |
| 2219 | } |
| 2220 | ccso_search(cm, xd, cpi->td.mb.rdmult, ext_rec_y, rec_uv, org_uv); |
| 2221 | ccso_frame(&cm->cur_frame->buf, cm, xd, ext_rec_y); |
| 2222 | aom_free(ext_rec_y); |
| 2223 | } |
| 2224 | for (int pli = 0; pli < 2; pli++) { |
| 2225 | aom_free(rec_uv[pli]); |
| 2226 | aom_free(org_uv[pli]); |
| 2227 | } |
| 2228 | #endif |
| 2229 | |
Satish Kumar Suman | 7a5f5f4 | 2020-06-09 14:20:47 +0530 | [diff] [blame] | 2230 | av1_superres_post_encode(cpi); |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 2231 | |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 2232 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 2233 | start_timing(cpi, loop_restoration_time); |
| 2234 | #endif |
yixindu | 368bde5 | 2021-06-04 18:30:53 -0700 | [diff] [blame] | 2235 | |
logangw | f95c916 | 2019-02-20 12:02:32 -0800 | [diff] [blame] | 2236 | if (use_restoration) { |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 2237 | av1_loop_restoration_save_boundary_lines(&cm->cur_frame->buf, cm, 1); |
Yaowu Xu | 35ee234 | 2017-11-08 11:50:46 -0800 | [diff] [blame] | 2238 | av1_pick_filter_restoration(cpi->source, cpi); |
| 2239 | if (cm->rst_info[0].frame_restoration_type != RESTORE_NONE || |
| 2240 | cm->rst_info[1].frame_restoration_type != RESTORE_NONE || |
| 2241 | cm->rst_info[2].frame_restoration_type != RESTORE_NONE) { |
Deepa K G | 74de2a0 | 2020-04-11 13:09:11 +0530 | [diff] [blame] | 2242 | if (num_workers > 1) |
| 2243 | av1_loop_restoration_filter_frame_mt( |
| 2244 | &cm->cur_frame->buf, cm, 0, mt_info->workers, num_workers, |
| 2245 | &mt_info->lr_row_sync, &cpi->lr_ctxt); |
Ravi Chaudhary | e2aa401 | 2018-06-04 14:20:00 +0530 | [diff] [blame] | 2246 | else |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 2247 | av1_loop_restoration_filter_frame(&cm->cur_frame->buf, cm, 0, |
Ravi Chaudhary | e2aa401 | 2018-06-04 14:20:00 +0530 | [diff] [blame] | 2248 | &cpi->lr_ctxt); |
Yaowu Xu | 35ee234 | 2017-11-08 11:50:46 -0800 | [diff] [blame] | 2249 | } |
logangw | f95c916 | 2019-02-20 12:02:32 -0800 | [diff] [blame] | 2250 | } else { |
| 2251 | cm->rst_info[0].frame_restoration_type = RESTORE_NONE; |
| 2252 | cm->rst_info[1].frame_restoration_type = RESTORE_NONE; |
| 2253 | cm->rst_info[2].frame_restoration_type = RESTORE_NONE; |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 2254 | } |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 2255 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 2256 | end_timing(cpi, loop_restoration_time); |
| 2257 | #endif |
Fergus Simpson | bc18993 | 2017-05-16 17:02:39 -0700 | [diff] [blame] | 2258 | } |
| 2259 | |
Yue Chen | 2d8405c | 2020-06-10 14:42:05 -0700 | [diff] [blame] | 2260 | /*!\brief Select and apply in-loop deblocking filters, cdef filters, and |
| 2261 | * restoration filters |
| 2262 | * |
| 2263 | * \ingroup high_level_algo |
Yue Chen | 2d8405c | 2020-06-10 14:42:05 -0700 | [diff] [blame] | 2264 | */ |
Yue Chen | 92271e1 | 2019-07-09 16:28:02 -0700 | [diff] [blame] | 2265 | static void loopfilter_frame(AV1_COMP *cpi, AV1_COMMON *cm) { |
Deepa K G | 74de2a0 | 2020-04-11 13:09:11 +0530 | [diff] [blame] | 2266 | MultiThreadInfo *const mt_info = &cpi->mt_info; |
| 2267 | const int num_workers = mt_info->num_workers; |
Yue Chen | 92271e1 | 2019-07-09 16:28:02 -0700 | [diff] [blame] | 2268 | const int num_planes = av1_num_planes(cm); |
| 2269 | MACROBLOCKD *xd = &cpi->td.mb.e_mbd; |
| 2270 | |
Vishesh | 39e7409 | 2020-06-16 17:13:48 +0530 | [diff] [blame] | 2271 | assert(IMPLIES(is_lossless_requested(&cpi->oxcf.rc_cfg), |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 2272 | cm->features.coded_lossless && cm->features.all_lossless)); |
Yue Chen | 92271e1 | 2019-07-09 16:28:02 -0700 | [diff] [blame] | 2273 | |
Ryan Lei | efc9166 | 2020-10-09 14:36:14 -0700 | [diff] [blame] | 2274 | const int use_loopfilter = !cm->features.coded_lossless && |
| 2275 | !cm->tiles.large_scale && |
| 2276 | cpi->oxcf.tool_cfg.enable_deblocking; |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 2277 | const int use_cdef = cm->seq_params.enable_cdef && |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 2278 | !cm->features.coded_lossless && !cm->tiles.large_scale; |
Yue Chen | 92271e1 | 2019-07-09 16:28:02 -0700 | [diff] [blame] | 2279 | const int use_restoration = cm->seq_params.enable_restoration && |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 2280 | !cm->features.all_lossless && |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 2281 | !cm->tiles.large_scale; |
Yue Chen | 92271e1 | 2019-07-09 16:28:02 -0700 | [diff] [blame] | 2282 | |
| 2283 | struct loopfilter *lf = &cm->lf; |
| 2284 | |
| 2285 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 2286 | start_timing(cpi, loop_filter_time); |
| 2287 | #endif |
| 2288 | if (use_loopfilter) { |
| 2289 | aom_clear_system_state(); |
chiyotsai | d2f7b41 | 2019-12-18 10:16:42 -0800 | [diff] [blame] | 2290 | av1_pick_filter_level(cpi->source, cpi, cpi->sf.lpf_sf.lpf_pick); |
Yue Chen | 92271e1 | 2019-07-09 16:28:02 -0700 | [diff] [blame] | 2291 | } else { |
| 2292 | lf->filter_level[0] = 0; |
| 2293 | lf->filter_level[1] = 0; |
| 2294 | } |
| 2295 | |
| 2296 | if (lf->filter_level[0] || lf->filter_level[1]) { |
Deepa K G | 74de2a0 | 2020-04-11 13:09:11 +0530 | [diff] [blame] | 2297 | if (num_workers > 1) |
Yue Chen | 92271e1 | 2019-07-09 16:28:02 -0700 | [diff] [blame] | 2298 | av1_loop_filter_frame_mt(&cm->cur_frame->buf, cm, xd, 0, num_planes, 0, |
| 2299 | #if CONFIG_LPF_MASK |
| 2300 | 0, |
| 2301 | #endif |
Deepa K G | 74de2a0 | 2020-04-11 13:09:11 +0530 | [diff] [blame] | 2302 | mt_info->workers, num_workers, |
| 2303 | &mt_info->lf_row_sync); |
Yue Chen | 92271e1 | 2019-07-09 16:28:02 -0700 | [diff] [blame] | 2304 | else |
| 2305 | av1_loop_filter_frame(&cm->cur_frame->buf, cm, xd, |
| 2306 | #if CONFIG_LPF_MASK |
| 2307 | 0, |
| 2308 | #endif |
| 2309 | 0, num_planes, 0); |
| 2310 | } |
| 2311 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 2312 | end_timing(cpi, loop_filter_time); |
| 2313 | #endif |
| 2314 | |
| 2315 | cdef_restoration_frame(cpi, cm, xd, use_restoration, use_cdef); |
| 2316 | } |
| 2317 | |
Yue Chen | 2d8405c | 2020-06-10 14:42:05 -0700 | [diff] [blame] | 2318 | /*!\brief Encode a frame without the recode loop, usually used in one-pass |
Fyodor Kyslov | f2a2eee | 2021-07-12 13:07:54 -0700 | [diff] [blame] | 2319 | * encoding. |
Yue Chen | 2d8405c | 2020-06-10 14:42:05 -0700 | [diff] [blame] | 2320 | * |
| 2321 | * \ingroup high_level_algo |
Yue Chen | 2d8405c | 2020-06-10 14:42:05 -0700 | [diff] [blame] | 2322 | * |
| 2323 | * \param[in] cpi Top-level encoder structure |
| 2324 | * |
| 2325 | * \return Returns a value to indicate if the encoding is done successfully. |
| 2326 | * \retval #AOM_CODEC_OK |
| 2327 | * \retval #AOM_CODEC_ERROR |
| 2328 | */ |
Marco Paniconi | c6cd72e | 2020-05-08 11:00:50 -0700 | [diff] [blame] | 2329 | static int encode_without_recode(AV1_COMP *cpi) { |
| 2330 | AV1_COMMON *const cm = &cpi->common; |
Vishesh | 734eff9 | 2020-06-20 21:46:36 +0530 | [diff] [blame] | 2331 | const QuantizationCfg *const q_cfg = &cpi->oxcf.q_cfg; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2332 | #if CONFIG_SVC_ENCODER |
Jerome Jiang | 790190e | 2020-06-12 16:47:45 -0700 | [diff] [blame] | 2333 | SVC *const svc = &cpi->svc; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2334 | #endif // CONFIG_SVC_ENCODER |
Fyodor Kyslov | 34b591f | 2020-06-24 20:13:58 -0700 | [diff] [blame] | 2335 | ResizePendingParams *const resize_pending_params = |
| 2336 | &cpi->resize_pending_params; |
| 2337 | const int resize_pending = |
| 2338 | (resize_pending_params->width && resize_pending_params->height && |
| 2339 | (cpi->common.width != resize_pending_params->width || |
| 2340 | cpi->common.height != resize_pending_params->height)); |
| 2341 | |
Marco Paniconi | c6cd72e | 2020-05-08 11:00:50 -0700 | [diff] [blame] | 2342 | int top_index = 0, bottom_index = 0, q = 0; |
Jerome Jiang | 790190e | 2020-06-12 16:47:45 -0700 | [diff] [blame] | 2343 | YV12_BUFFER_CONFIG *unscaled = cpi->unscaled_source; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2344 | #if CONFIG_SVC_ENCODER |
Jerome Jiang | dede293 | 2020-06-23 16:49:41 -0700 | [diff] [blame] | 2345 | InterpFilter filter_scaler = |
Jerome Jiang | 790190e | 2020-06-12 16:47:45 -0700 | [diff] [blame] | 2346 | cpi->use_svc ? svc->downsample_filter_type[svc->spatial_layer_id] |
Marco Paniconi | 327528a | 2020-06-30 21:19:09 -0700 | [diff] [blame] | 2347 | : EIGHTTAP_SMOOTH; |
Jerome Jiang | 790190e | 2020-06-12 16:47:45 -0700 | [diff] [blame] | 2348 | int phase_scaler = |
| 2349 | cpi->use_svc ? svc->downsample_filter_phase[svc->spatial_layer_id] : 0; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2350 | #else |
| 2351 | InterpFilter filter_scaler = EIGHTTAP_SMOOTH; |
| 2352 | int phase_scaler = 0; |
| 2353 | #endif // CONFIG_SVC_ENCODER |
Jerome Jiang | dede293 | 2020-06-23 16:49:41 -0700 | [diff] [blame] | 2354 | |
Marco Paniconi | c6cd72e | 2020-05-08 11:00:50 -0700 | [diff] [blame] | 2355 | set_size_independent_vars(cpi); |
Urvang Joshi | 007e18e | 2021-08-28 01:25:40 +0000 | [diff] [blame] | 2356 | cpi->source->buf_8bit_valid = 0; |
Marco Paniconi | c6cd72e | 2020-05-08 11:00:50 -0700 | [diff] [blame] | 2357 | av1_setup_frame_size(cpi); |
Satish Kumar Suman | 36adf35 | 2020-06-26 11:20:10 +0530 | [diff] [blame] | 2358 | av1_set_size_dependent_vars(cpi, &q, &bottom_index, &top_index); |
Marco Paniconi | c6cd72e | 2020-05-08 11:00:50 -0700 | [diff] [blame] | 2359 | |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2360 | #if CONFIG_SVC_ENCODER |
| 2361 | if (!cpi->use_svc) |
| 2362 | #endif // CONFIG_SVC_ENCODER |
| 2363 | { |
Jerome Jiang | dede293 | 2020-06-23 16:49:41 -0700 | [diff] [blame] | 2364 | phase_scaler = 8; |
Marco Paniconi | 5fffb44 | 2020-07-01 10:49:30 -0700 | [diff] [blame] | 2365 | // 2:1 scaling. |
Jerome Jiang | c1b1126 | 2020-06-25 13:53:55 -0700 | [diff] [blame] | 2366 | if ((cm->width << 1) == unscaled->y_crop_width && |
Marco Paniconi | 5fffb44 | 2020-07-01 10:49:30 -0700 | [diff] [blame] | 2367 | (cm->height << 1) == unscaled->y_crop_height) { |
Jerome Jiang | c1b1126 | 2020-06-25 13:53:55 -0700 | [diff] [blame] | 2368 | filter_scaler = BILINEAR; |
Marco Paniconi | 5fffb44 | 2020-07-01 10:49:30 -0700 | [diff] [blame] | 2369 | // For lower resolutions use eighttap_smooth. |
| 2370 | if (cm->width * cm->height <= 320 * 180) filter_scaler = EIGHTTAP_SMOOTH; |
| 2371 | } else if ((cm->width << 2) == unscaled->y_crop_width && |
| 2372 | (cm->height << 2) == unscaled->y_crop_height) { |
| 2373 | // 4:1 scaling. |
Jerome Jiang | c1b1126 | 2020-06-25 13:53:55 -0700 | [diff] [blame] | 2374 | filter_scaler = EIGHTTAP_SMOOTH; |
Marco Paniconi | 5fffb44 | 2020-07-01 10:49:30 -0700 | [diff] [blame] | 2375 | } else if ((cm->width << 2) == 3 * unscaled->y_crop_width && |
| 2376 | (cm->height << 2) == 3 * unscaled->y_crop_height) { |
| 2377 | // 4:3 scaling. |
Jerome Jiang | 0da8c24 | 2020-07-24 14:24:41 -0700 | [diff] [blame] | 2378 | // TODO(jianj): Neon optimization for 4:3 scaling for EIGHTTAP has issues. |
| 2379 | // See aomedia:2766. |
| 2380 | filter_scaler = BILINEAR; |
Marco Paniconi | 5fffb44 | 2020-07-01 10:49:30 -0700 | [diff] [blame] | 2381 | } |
Jerome Jiang | dede293 | 2020-06-23 16:49:41 -0700 | [diff] [blame] | 2382 | } |
| 2383 | |
Marco Paniconi | c6cd72e | 2020-05-08 11:00:50 -0700 | [diff] [blame] | 2384 | if (cm->current_frame.frame_type == KEY_FRAME) copy_frame_prob_info(cpi); |
| 2385 | |
| 2386 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 2387 | printf("\n Encoding a frame:"); |
| 2388 | #endif |
Marco Paniconi | d13853d | 2020-05-07 11:42:16 -0700 | [diff] [blame] | 2389 | |
| 2390 | aom_clear_system_state(); |
| 2391 | |
Jerome Jiang | 790190e | 2020-06-12 16:47:45 -0700 | [diff] [blame] | 2392 | cpi->source = av1_scale_if_required(cm, unscaled, &cpi->scaled_source, |
Urvang Joshi | bd95585 | 2020-10-06 16:05:26 -0700 | [diff] [blame] | 2393 | filter_scaler, phase_scaler, true, false); |
Fyodor Kyslov | 34b591f | 2020-06-24 20:13:58 -0700 | [diff] [blame] | 2394 | if (frame_is_intra_only(cm) || resize_pending != 0) { |
| 2395 | memset(cpi->consec_zero_mv, 0, |
| 2396 | ((cm->mi_params.mi_rows * cm->mi_params.mi_cols) >> 2) * |
| 2397 | sizeof(*cpi->consec_zero_mv)); |
| 2398 | } |
| 2399 | |
Marco Paniconi | d13853d | 2020-05-07 11:42:16 -0700 | [diff] [blame] | 2400 | if (cpi->unscaled_last_source != NULL) { |
Urvang Joshi | bd95585 | 2020-10-06 16:05:26 -0700 | [diff] [blame] | 2401 | cpi->last_source = av1_scale_if_required( |
| 2402 | cm, cpi->unscaled_last_source, &cpi->scaled_last_source, filter_scaler, |
| 2403 | phase_scaler, true, false); |
Marco Paniconi | d13853d | 2020-05-07 11:42:16 -0700 | [diff] [blame] | 2404 | } |
Marco Paniconi | 2b22a1f | 2020-06-22 21:55:02 -0700 | [diff] [blame] | 2405 | |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2406 | #if CONFIG_SVC_ENCODER |
Marco Paniconi | 69e6dcc | 2020-07-20 14:19:20 -0700 | [diff] [blame] | 2407 | // For 1 spatial layer encoding: if the (non-LAST) reference has different |
| 2408 | // resolution from the source then disable that reference. This is to avoid |
| 2409 | // significant increase in encode time from scaling the references in |
| 2410 | // av1_scale_references. Note GOLDEN is forced to update on the (first/tigger) |
| 2411 | // resized frame and ALTREF will be refreshed ~4 frames later, so both |
| 2412 | // references become available again after few frames. |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2413 | if (svc->number_spatial_layers == 1) |
| 2414 | #endif // CONFIG_SVC_ENCODER |
| 2415 | { |
| 2416 | #if CONFIG_NEW_REF_SIGNALING |
| 2417 | const MV_REFERENCE_FRAME golden_frame = get_best_past_ref_index(cm); |
| 2418 | const MV_REFERENCE_FRAME altref_frame = get_furthest_future_ref_index(cm); |
| 2419 | if (cm->ref_frame_flags & (1 << golden_frame)) { |
| 2420 | const YV12_BUFFER_CONFIG *const ref = |
| 2421 | get_ref_frame_yv12_buf(cm, golden_frame); |
| 2422 | if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) |
| 2423 | cm->ref_frame_flags ^= (1 << golden_frame); |
| 2424 | } |
| 2425 | if (cm->ref_frame_flags & (1 << altref_frame)) { |
| 2426 | const YV12_BUFFER_CONFIG *const ref = |
| 2427 | get_ref_frame_yv12_buf(cm, altref_frame); |
| 2428 | if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) |
| 2429 | cm->ref_frame_flags ^= (1 << altref_frame); |
| 2430 | } |
| 2431 | #else |
| 2432 | if (cm->ref_frame_flags & av1_ref_frame_flag_list[GOLDEN_FRAME]) { |
Marco Paniconi | 69e6dcc | 2020-07-20 14:19:20 -0700 | [diff] [blame] | 2433 | const YV12_BUFFER_CONFIG *const ref = |
| 2434 | get_ref_frame_yv12_buf(cm, GOLDEN_FRAME); |
| 2435 | if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2436 | cm->ref_frame_flags ^= AOM_GOLD_FLAG; |
Marco Paniconi | 69e6dcc | 2020-07-20 14:19:20 -0700 | [diff] [blame] | 2437 | } |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2438 | if (cm->ref_frame_flags & av1_ref_frame_flag_list[ALTREF_FRAME]) { |
Marco Paniconi | 69e6dcc | 2020-07-20 14:19:20 -0700 | [diff] [blame] | 2439 | const YV12_BUFFER_CONFIG *const ref = |
| 2440 | get_ref_frame_yv12_buf(cm, ALTREF_FRAME); |
| 2441 | if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2442 | cm->ref_frame_flags ^= AOM_ALT_FLAG; |
Marco Paniconi | 69e6dcc | 2020-07-20 14:19:20 -0700 | [diff] [blame] | 2443 | } |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2444 | #endif // CONFIG_NEW_REF_SIGNALING |
Marco Paniconi | 69e6dcc | 2020-07-20 14:19:20 -0700 | [diff] [blame] | 2445 | } |
| 2446 | |
Marco Paniconi | 2b22a1f | 2020-06-22 21:55:02 -0700 | [diff] [blame] | 2447 | // For SVC the inter-layer/spatial prediction is not done for newmv |
| 2448 | // (zero_mode is forced), and since the scaled references are only |
| 2449 | // use for newmv search, we can avoid scaling here. |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2450 | if (!frame_is_intra_only(cm) |
| 2451 | #if CONFIG_SVC_ENCODER |
| 2452 | && !(cpi->use_svc && cpi->svc.force_zero_mode_spatial_ref) |
| 2453 | #endif // CONFIG_SVC_ENCODER |
| 2454 | ) |
Jerome Jiang | 3dddc32 | 2020-06-29 16:59:58 -0700 | [diff] [blame] | 2455 | av1_scale_references(cpi, filter_scaler, phase_scaler, 1); |
Marco Paniconi | d13853d | 2020-05-07 11:42:16 -0700 | [diff] [blame] | 2456 | |
Vishesh | 734eff9 | 2020-06-20 21:46:36 +0530 | [diff] [blame] | 2457 | av1_set_quantizer(cm, q_cfg->qm_minlevel, q_cfg->qm_maxlevel, q, |
| 2458 | q_cfg->enable_chroma_deltaq); |
Marco Paniconi | d13853d | 2020-05-07 11:42:16 -0700 | [diff] [blame] | 2459 | av1_set_speed_features_qindex_dependent(cpi, cpi->oxcf.speed); |
Ryan Lei | ccc6ea7 | 2021-01-06 11:43:56 -0800 | [diff] [blame] | 2460 | #if !CONFIG_EXTQUANT |
| 2461 | if (q_cfg->deltaq_mode != NO_DELTA_Q || q_cfg->enable_chroma_deltaq) |
| 2462 | #endif |
| 2463 | av1_init_quantizer(&cm->seq_params, &cpi->enc_quant_dequant_params, |
| 2464 | &cm->quant_params); |
Satish Kumar Suman | 36adf35 | 2020-06-26 11:20:10 +0530 | [diff] [blame] | 2465 | av1_setup_frame(cpi); |
Marco Paniconi | d13853d | 2020-05-07 11:42:16 -0700 | [diff] [blame] | 2466 | |
Vishesh | 734eff9 | 2020-06-20 21:46:36 +0530 | [diff] [blame] | 2467 | if (q_cfg->aq_mode == CYCLIC_REFRESH_AQ) { |
Marco Paniconi | d13853d | 2020-05-07 11:42:16 -0700 | [diff] [blame] | 2468 | suppress_active_map(cpi); |
| 2469 | av1_cyclic_refresh_setup(cpi); |
Satish Kumar Suman | 36adf35 | 2020-06-26 11:20:10 +0530 | [diff] [blame] | 2470 | av1_apply_active_map(cpi); |
Marco Paniconi | d13853d | 2020-05-07 11:42:16 -0700 | [diff] [blame] | 2471 | } |
| 2472 | if (cm->seg.enabled) { |
| 2473 | if (!cm->seg.update_data && cm->prev_frame) { |
| 2474 | segfeatures_copy(&cm->seg, &cm->prev_frame->seg); |
| 2475 | cm->seg.enabled = cm->prev_frame->seg.enabled; |
| 2476 | } else { |
| 2477 | av1_calculate_segdata(&cm->seg); |
| 2478 | } |
| 2479 | } else { |
| 2480 | memset(&cm->seg, 0, sizeof(cm->seg)); |
| 2481 | } |
| 2482 | segfeatures_copy(&cm->cur_frame->seg, &cm->seg); |
| 2483 | cm->cur_frame->seg.enabled = cm->seg.enabled; |
| 2484 | |
| 2485 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 2486 | start_timing(cpi, av1_encode_frame_time); |
| 2487 | #endif |
| 2488 | |
| 2489 | // Set the motion vector precision based on mv stats from the last coded |
| 2490 | // frame. |
| 2491 | if (!frame_is_intra_only(cm)) av1_pick_and_set_high_precision_mv(cpi, q); |
| 2492 | |
| 2493 | // transform / motion compensation build reconstruction frame |
| 2494 | av1_encode_frame(cpi); |
| 2495 | |
| 2496 | // Update some stats from cyclic refresh. |
Vishesh | 734eff9 | 2020-06-20 21:46:36 +0530 | [diff] [blame] | 2497 | if (q_cfg->aq_mode == CYCLIC_REFRESH_AQ && !frame_is_intra_only(cm)) |
Marco Paniconi | d13853d | 2020-05-07 11:42:16 -0700 | [diff] [blame] | 2498 | av1_cyclic_refresh_postencode(cpi); |
| 2499 | |
| 2500 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 2501 | end_timing(cpi, av1_encode_frame_time); |
| 2502 | #endif |
| 2503 | #if CONFIG_INTERNAL_STATS |
| 2504 | ++cpi->tot_recode_hits; |
| 2505 | #endif |
Marco Paniconi | c6cd72e | 2020-05-08 11:00:50 -0700 | [diff] [blame] | 2506 | |
Marco Paniconi | e635eb6 | 2020-05-14 14:01:02 -0700 | [diff] [blame] | 2507 | aom_clear_system_state(); |
| 2508 | |
Marco Paniconi | c6cd72e | 2020-05-08 11:00:50 -0700 | [diff] [blame] | 2509 | return AOM_CODEC_OK; |
Marco Paniconi | d13853d | 2020-05-07 11:42:16 -0700 | [diff] [blame] | 2510 | } |
| 2511 | |
Yue Chen | 2d8405c | 2020-06-10 14:42:05 -0700 | [diff] [blame] | 2512 | /*!\brief Recode loop for encoding one frame. the purpose of encoding one frame |
| 2513 | * for multiple times can be approaching a target bitrate or adjusting the usage |
| 2514 | * of global motions. |
| 2515 | * |
| 2516 | * \ingroup high_level_algo |
Yue Chen | 2d8405c | 2020-06-10 14:42:05 -0700 | [diff] [blame] | 2517 | * |
| 2518 | * \param[in] cpi Top-level encoder structure |
| 2519 | * \param[in] size Bitstream size |
| 2520 | * \param[in] dest Bitstream output |
| 2521 | * |
| 2522 | * \return Returns a value to indicate if the encoding is done successfully. |
| 2523 | * \retval #AOM_CODEC_OK |
| 2524 | * \retval -1 |
| 2525 | * \retval #AOM_CODEC_ERROR |
| 2526 | */ |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 2527 | static int encode_with_recode_loop(AV1_COMP *cpi, size_t *size, uint8_t *dest) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2528 | AV1_COMMON *const cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2529 | RATE_CONTROL *const rc = &cpi->rc; |
Vishesh | 8ba8bfe | 2020-04-03 14:20:29 +0530 | [diff] [blame] | 2530 | GlobalMotionInfo *const gm_info = &cpi->gm_info; |
Vishesh | 734eff9 | 2020-06-20 21:46:36 +0530 | [diff] [blame] | 2531 | const AV1EncoderConfig *const oxcf = &cpi->oxcf; |
| 2532 | const QuantizationCfg *const q_cfg = &oxcf->q_cfg; |
chiyotsai | 6b43013 | 2019-12-18 10:33:51 -0800 | [diff] [blame] | 2533 | const int allow_recode = (cpi->sf.hl_sf.recode_loop != DISALLOW_RECODE); |
Hui Su | a1d7184 | 2019-07-31 12:02:24 -0700 | [diff] [blame] | 2534 | // Must allow recode if minimum compression ratio is set. |
Vishesh | 734eff9 | 2020-06-20 21:46:36 +0530 | [diff] [blame] | 2535 | assert(IMPLIES(oxcf->rc_cfg.min_cr > 0, allow_recode)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2536 | |
| 2537 | set_size_independent_vars(cpi); |
Yaowu Xu | 9b0f703 | 2017-07-31 11:01:19 -0700 | [diff] [blame] | 2538 | cpi->source->buf_8bit_valid = 0; |
Yaowu Xu | 9b0f703 | 2017-07-31 11:01:19 -0700 | [diff] [blame] | 2539 | |
David Turner | dedd8ff | 2019-01-23 13:59:46 +0000 | [diff] [blame] | 2540 | av1_setup_frame_size(cpi); |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 2541 | |
Satish Kumar Suman | 7a5f5f4 | 2020-06-09 14:20:47 +0530 | [diff] [blame] | 2542 | if (av1_superres_in_recode_allowed(cpi) && |
Urvang Joshi | 9d2606c | 2020-04-14 15:58:01 -0700 | [diff] [blame] | 2543 | cpi->superres_mode != AOM_SUPERRES_NONE && |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 2544 | cm->superres_scale_denominator == SCALE_NUMERATOR) { |
Urvang Joshi | db4551e | 2020-04-08 12:30:21 -0700 | [diff] [blame] | 2545 | // Superres mode is currently enabled, but the denominator selected will |
Urvang Joshi | f9c2bd7 | 2020-04-07 15:11:51 -0700 | [diff] [blame] | 2546 | // disable superres. So no need to continue, as we will go through another |
| 2547 | // recode loop for full-resolution after this anyway. |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 2548 | return -1; |
| 2549 | } |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 2550 | |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 2551 | int top_index = 0, bottom_index = 0; |
| 2552 | int q = 0, q_low = 0, q_high = 0; |
Satish Kumar Suman | 36adf35 | 2020-06-26 11:20:10 +0530 | [diff] [blame] | 2553 | av1_set_size_dependent_vars(cpi, &q, &bottom_index, &top_index); |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 2554 | q_low = bottom_index; |
| 2555 | q_high = top_index; |
| 2556 | |
Marco Paniconi | c6cd72e | 2020-05-08 11:00:50 -0700 | [diff] [blame] | 2557 | if (cm->current_frame.frame_type == KEY_FRAME) copy_frame_prob_info(cpi); |
Cheng Chen | 92a926a | 2020-01-30 17:57:33 -0800 | [diff] [blame] | 2558 | |
| 2559 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 2560 | printf("\n Encoding a frame:"); |
| 2561 | #endif |
| 2562 | |
Marco Paniconi | d13853d | 2020-05-07 11:42:16 -0700 | [diff] [blame] | 2563 | // Determine whether to use screen content tools using two fast encoding. |
Satish Kumar Suman | 36adf35 | 2020-06-26 11:20:10 +0530 | [diff] [blame] | 2564 | av1_determine_sc_tools_with_encoding(cpi, q); |
Marco Paniconi | d13853d | 2020-05-07 11:42:16 -0700 | [diff] [blame] | 2565 | |
Sai Deng | 7275a1a | 2020-08-31 12:06:09 -0700 | [diff] [blame] | 2566 | #if CONFIG_USE_VMAF_RC |
| 2567 | if (oxcf->tune_cfg.tuning == AOM_TUNE_VMAF_NEG_MAX_GAIN) { |
| 2568 | av1_vmaf_neg_preprocessing(cpi, cpi->unscaled_source); |
| 2569 | } |
| 2570 | #endif |
| 2571 | |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 2572 | // Loop variables |
Cheng Chen | 92a926a | 2020-01-30 17:57:33 -0800 | [diff] [blame] | 2573 | int loop = 0; |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 2574 | int loop_count = 0; |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 2575 | int overshoot_seen = 0; |
| 2576 | int undershoot_seen = 0; |
Hui Su | ef139e1 | 2019-05-20 15:51:22 -0700 | [diff] [blame] | 2577 | int low_cr_seen = 0; |
chiyotsai | 8b7cef8 | 2020-01-21 16:52:54 -0800 | [diff] [blame] | 2578 | int last_loop_allow_hp = 0; |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 2579 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2580 | do { |
Debargha Mukherjee | 9b70d1f | 2019-05-07 18:34:45 -0700 | [diff] [blame] | 2581 | loop = 0; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2582 | aom_clear_system_state(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2583 | |
Urvang Joshi | f1fa686 | 2018-01-08 16:39:33 -0800 | [diff] [blame] | 2584 | // if frame was scaled calculate global_motion_search again if already |
| 2585 | // done |
Vishesh | 8ba8bfe | 2020-04-03 14:20:29 +0530 | [diff] [blame] | 2586 | if (loop_count > 0 && cpi->source && gm_info->search_done) { |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 2587 | if (cpi->source->y_crop_width != cm->width || |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 2588 | cpi->source->y_crop_height != cm->height) { |
Vishesh | 8ba8bfe | 2020-04-03 14:20:29 +0530 | [diff] [blame] | 2589 | gm_info->search_done = 0; |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 2590 | } |
| 2591 | } |
Urvang Joshi | bd95585 | 2020-10-06 16:05:26 -0700 | [diff] [blame] | 2592 | cpi->source = |
| 2593 | av1_scale_if_required(cm, cpi->unscaled_source, &cpi->scaled_source, |
| 2594 | EIGHTTAP_REGULAR, 0, false, false); |
Jerome Jiang | dede293 | 2020-06-23 16:49:41 -0700 | [diff] [blame] | 2595 | |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 2596 | if (cpi->unscaled_last_source != NULL) { |
Urvang Joshi | bd95585 | 2020-10-06 16:05:26 -0700 | [diff] [blame] | 2597 | cpi->last_source = av1_scale_if_required( |
| 2598 | cm, cpi->unscaled_last_source, &cpi->scaled_last_source, |
| 2599 | EIGHTTAP_REGULAR, 0, false, false); |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 2600 | } |
Debargha Mukherjee | 17e7b08 | 2017-08-13 09:33:03 -0700 | [diff] [blame] | 2601 | |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 2602 | if (!frame_is_intra_only(cm)) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2603 | if (loop_count > 0) { |
| 2604 | release_scaled_references(cpi); |
| 2605 | } |
Jerome Jiang | 3dddc32 | 2020-06-29 16:59:58 -0700 | [diff] [blame] | 2606 | av1_scale_references(cpi, EIGHTTAP_REGULAR, 0, 0); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2607 | } |
sdeng | 3cd9eec | 2020-01-23 15:49:50 -0800 | [diff] [blame] | 2608 | #if CONFIG_TUNE_VMAF |
Sai Deng | 7275a1a | 2020-08-31 12:06:09 -0700 | [diff] [blame] | 2609 | if (oxcf->tune_cfg.tuning >= AOM_TUNE_VMAF_WITH_PREPROCESSING && |
| 2610 | oxcf->tune_cfg.tuning <= AOM_TUNE_VMAF_NEG_MAX_GAIN) { |
Sai Deng | 48ebb28 | 2020-08-13 15:30:50 -0700 | [diff] [blame] | 2611 | cpi->vmaf_info.original_qindex = q; |
| 2612 | q = av1_get_vmaf_base_qindex(cpi, q); |
sdeng | 3cd9eec | 2020-01-23 15:49:50 -0800 | [diff] [blame] | 2613 | } |
| 2614 | #endif |
Sai Deng | 48ebb28 | 2020-08-13 15:30:50 -0700 | [diff] [blame] | 2615 | av1_set_quantizer(cm, q_cfg->qm_minlevel, q_cfg->qm_maxlevel, q, |
| 2616 | q_cfg->enable_chroma_deltaq); |
Vishesh | 734eff9 | 2020-06-20 21:46:36 +0530 | [diff] [blame] | 2617 | av1_set_speed_features_qindex_dependent(cpi, oxcf->speed); |
sdeng | 3cd9eec | 2020-01-23 15:49:50 -0800 | [diff] [blame] | 2618 | |
Ryan Lei | ccc6ea7 | 2021-01-06 11:43:56 -0800 | [diff] [blame] | 2619 | #if !CONFIG_EXTQUANT |
Madhu Peringassery Krishnan | 5fa4fcf | 2021-02-19 15:48:34 -0800 | [diff] [blame] | 2620 | if (q_cfg->deltaq_mode != NO_DELTA_Q || q_cfg->enable_chroma_deltaq) |
Ryan Lei | ccc6ea7 | 2021-01-06 11:43:56 -0800 | [diff] [blame] | 2621 | #endif |
| 2622 | av1_init_quantizer(&cm->seq_params, &cpi->enc_quant_dequant_params, |
| 2623 | &cm->quant_params); |
kyslov | 7b9d0d6 | 2018-12-21 11:12:26 -0800 | [diff] [blame] | 2624 | |
Debargha Mukherjee | f48b0d2 | 2018-11-20 12:23:43 -0800 | [diff] [blame] | 2625 | // printf("Frame %d/%d: q = %d, frame_type = %d superres_denom = %d\n", |
| 2626 | // cm->current_frame.frame_number, cm->show_frame, q, |
| 2627 | // cm->current_frame.frame_type, cm->superres_scale_denominator); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2628 | |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 2629 | if (loop_count == 0) { |
Satish Kumar Suman | 36adf35 | 2020-06-26 11:20:10 +0530 | [diff] [blame] | 2630 | av1_setup_frame(cpi); |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 2631 | } else if (get_primary_ref_frame_buf(cm) == NULL) { |
| 2632 | // Base q-index may have changed, so we need to assign proper default coef |
| 2633 | // probs before every iteration. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2634 | av1_default_coef_probs(cm); |
Hui Su | 3694c83 | 2017-11-10 14:15:58 -0800 | [diff] [blame] | 2635 | av1_setup_frame_contexts(cm); |
David Barker | fc91b39 | 2018-03-09 15:32:03 +0000 | [diff] [blame] | 2636 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2637 | |
Vishesh | 734eff9 | 2020-06-20 21:46:36 +0530 | [diff] [blame] | 2638 | if (q_cfg->aq_mode == VARIANCE_AQ) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2639 | av1_vaq_frame_setup(cpi); |
Vishesh | 734eff9 | 2020-06-20 21:46:36 +0530 | [diff] [blame] | 2640 | } else if (q_cfg->aq_mode == COMPLEXITY_AQ) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2641 | av1_setup_in_frame_q_adj(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2642 | } |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 2643 | |
Rostislav Pehlivanov | 3a96462 | 2018-03-14 18:00:32 +0000 | [diff] [blame] | 2644 | if (cm->seg.enabled) { |
David Barker | cab3755 | 2018-03-21 11:56:24 +0000 | [diff] [blame] | 2645 | if (!cm->seg.update_data && cm->prev_frame) { |
Rostislav Pehlivanov | 3a96462 | 2018-03-14 18:00:32 +0000 | [diff] [blame] | 2646 | segfeatures_copy(&cm->seg, &cm->prev_frame->seg); |
Jerome Jiang | b23571d | 2019-10-23 14:15:55 -0700 | [diff] [blame] | 2647 | cm->seg.enabled = cm->prev_frame->seg.enabled; |
David Barker | 11c9356 | 2018-06-05 12:00:07 +0100 | [diff] [blame] | 2648 | } else { |
Yaowu Xu | 7e45088 | 2019-04-30 15:09:18 -0700 | [diff] [blame] | 2649 | av1_calculate_segdata(&cm->seg); |
Yue Chen | d90d343 | 2018-03-16 11:28:42 -0700 | [diff] [blame] | 2650 | } |
David Barker | cab3755 | 2018-03-21 11:56:24 +0000 | [diff] [blame] | 2651 | } else { |
| 2652 | memset(&cm->seg, 0, sizeof(cm->seg)); |
Rostislav Pehlivanov | 3a96462 | 2018-03-14 18:00:32 +0000 | [diff] [blame] | 2653 | } |
David Barker | cab3755 | 2018-03-21 11:56:24 +0000 | [diff] [blame] | 2654 | segfeatures_copy(&cm->cur_frame->seg, &cm->seg); |
Jerome Jiang | b23571d | 2019-10-23 14:15:55 -0700 | [diff] [blame] | 2655 | cm->cur_frame->seg.enabled = cm->seg.enabled; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2656 | |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 2657 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 2658 | start_timing(cpi, av1_encode_frame_time); |
| 2659 | #endif |
chiyotsai | 8b7cef8 | 2020-01-21 16:52:54 -0800 | [diff] [blame] | 2660 | // Set the motion vector precision based on mv stats from the last coded |
| 2661 | // frame. |
| 2662 | if (!frame_is_intra_only(cm)) { |
| 2663 | av1_pick_and_set_high_precision_mv(cpi, q); |
| 2664 | |
| 2665 | // If the precision has changed during different iteration of the loop, |
| 2666 | // then we need to reset the global motion vectors |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 2667 | if (loop_count > 0 && |
| 2668 | cm->features.allow_high_precision_mv != last_loop_allow_hp) { |
Vishesh | 8ba8bfe | 2020-04-03 14:20:29 +0530 | [diff] [blame] | 2669 | gm_info->search_done = 0; |
chiyotsai | 8b7cef8 | 2020-01-21 16:52:54 -0800 | [diff] [blame] | 2670 | } |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 2671 | last_loop_allow_hp = cm->features.allow_high_precision_mv; |
chiyotsai | 8b7cef8 | 2020-01-21 16:52:54 -0800 | [diff] [blame] | 2672 | } |
chiyotsai | c666b1f | 2019-12-20 10:44:58 -0800 | [diff] [blame] | 2673 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2674 | // transform / motion compensation build reconstruction frame |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2675 | av1_encode_frame(cpi); |
Marco Paniconi | c6cd72e | 2020-05-08 11:00:50 -0700 | [diff] [blame] | 2676 | |
chiyotsai | 51bd648 | 2019-12-20 10:49:34 -0800 | [diff] [blame] | 2677 | // Reset the mv_stats in case we are interrupted by an intraframe or an |
| 2678 | // overlay frame. |
| 2679 | if (cpi->mv_stats.valid) { |
| 2680 | av1_zero(cpi->mv_stats); |
| 2681 | } |
| 2682 | // Gather the mv_stats for the next frame |
| 2683 | if (cpi->sf.hl_sf.high_precision_mv_usage == LAST_MV_DATA && |
| 2684 | av1_frame_allows_smart_mv(cpi)) { |
| 2685 | av1_collect_mv_stats(cpi, q); |
| 2686 | } |
chiyotsai | 51bd648 | 2019-12-20 10:49:34 -0800 | [diff] [blame] | 2687 | |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 2688 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 2689 | end_timing(cpi, av1_encode_frame_time); |
| 2690 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2691 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2692 | aom_clear_system_state(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2693 | |
| 2694 | // Dummy pack of the bitstream using up to date stats to get an |
| 2695 | // accurate estimate of output frame size to determine if we need |
| 2696 | // to recode. |
chiyotsai | 6b43013 | 2019-12-18 10:33:51 -0800 | [diff] [blame] | 2697 | const int do_dummy_pack = |
| 2698 | (cpi->sf.hl_sf.recode_loop >= ALLOW_RECODE_KFARFGF && |
Vishesh | 734eff9 | 2020-06-20 21:46:36 +0530 | [diff] [blame] | 2699 | oxcf->rc_cfg.mode != AOM_Q) || |
| 2700 | oxcf->rc_cfg.min_cr > 0; |
Hui Su | a1d7184 | 2019-07-31 12:02:24 -0700 | [diff] [blame] | 2701 | if (do_dummy_pack) { |
Satish Kumar Suman | 36adf35 | 2020-06-26 11:20:10 +0530 | [diff] [blame] | 2702 | av1_finalize_encoded_frame(cpi); |
David Turner | 35cba13 | 2018-12-10 15:48:15 +0000 | [diff] [blame] | 2703 | int largest_tile_id = 0; // Output from bitstream: unused here |
chiyotsai | c666b1f | 2019-12-20 10:44:58 -0800 | [diff] [blame] | 2704 | if (av1_pack_bitstream(cpi, dest, size, &largest_tile_id) != |
| 2705 | AOM_CODEC_OK) { |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 2706 | return AOM_CODEC_ERROR; |
chiyotsai | c666b1f | 2019-12-20 10:44:58 -0800 | [diff] [blame] | 2707 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2708 | |
| 2709 | rc->projected_frame_size = (int)(*size) << 3; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2710 | } |
| 2711 | |
Sai Deng | 48ebb28 | 2020-08-13 15:30:50 -0700 | [diff] [blame] | 2712 | #if CONFIG_TUNE_VMAF |
Sai Deng | 7275a1a | 2020-08-31 12:06:09 -0700 | [diff] [blame] | 2713 | if (oxcf->tune_cfg.tuning >= AOM_TUNE_VMAF_WITH_PREPROCESSING && |
| 2714 | oxcf->tune_cfg.tuning <= AOM_TUNE_VMAF_NEG_MAX_GAIN) { |
Sai Deng | 48ebb28 | 2020-08-13 15:30:50 -0700 | [diff] [blame] | 2715 | q = cpi->vmaf_info.original_qindex; |
| 2716 | } |
| 2717 | #endif |
Hui Su | ef139e1 | 2019-05-20 15:51:22 -0700 | [diff] [blame] | 2718 | if (allow_recode) { |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 2719 | // Update q and decide whether to do a recode loop |
| 2720 | recode_loop_update_q(cpi, &loop, &q, &q_low, &q_high, top_index, |
| 2721 | bottom_index, &undershoot_seen, &overshoot_seen, |
Paul Wilkins | c8d3f11 | 2020-07-08 17:58:14 +0100 | [diff] [blame] | 2722 | &low_cr_seen, loop_count); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2723 | } |
| 2724 | |
| 2725 | // Special case for overlay frame. |
Hui Su | 7e3eeaa | 2019-09-11 15:50:41 -0700 | [diff] [blame] | 2726 | if (loop && rc->is_src_frame_alt_ref && |
| 2727 | rc->projected_frame_size < rc->max_frame_bandwidth) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2728 | loop = 0; |
Hui Su | 7e3eeaa | 2019-09-11 15:50:41 -0700 | [diff] [blame] | 2729 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2730 | |
chiyotsai | 76cd265 | 2019-12-18 10:26:36 -0800 | [diff] [blame] | 2731 | if (allow_recode && !cpi->sf.gm_sf.gm_disable_recode && |
Satish Kumar Suman | 36adf35 | 2020-06-26 11:20:10 +0530 | [diff] [blame] | 2732 | av1_recode_loop_test_global_motion(cm->global_motion, |
| 2733 | cpi->td.rd_counts.global_motion_used, |
| 2734 | gm_info->params_cost)) { |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 2735 | loop = 1; |
Debargha Mukherjee | b98a702 | 2016-11-15 16:07:12 -0800 | [diff] [blame] | 2736 | } |
Debargha Mukherjee | b98a702 | 2016-11-15 16:07:12 -0800 | [diff] [blame] | 2737 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2738 | if (loop) { |
| 2739 | ++loop_count; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2740 | |
| 2741 | #if CONFIG_INTERNAL_STATS |
| 2742 | ++cpi->tot_recode_hits; |
| 2743 | #endif |
| 2744 | } |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 2745 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 2746 | if (loop) printf("\n Recoding:"); |
| 2747 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2748 | } while (loop); |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 2749 | |
| 2750 | return AOM_CODEC_OK; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2751 | } |
| 2752 | |
Yue Chen | 2d8405c | 2020-06-10 14:42:05 -0700 | [diff] [blame] | 2753 | /*!\brief Recode loop or a single loop for encoding one frame, followed by |
| 2754 | * in-loop deblocking filters, CDEF filters, and restoration filters. |
| 2755 | * |
| 2756 | * \ingroup high_level_algo |
| 2757 | * \callgraph |
| 2758 | * \callergraph |
| 2759 | * |
| 2760 | * \param[in] cpi Top-level encoder structure |
| 2761 | * \param[in] size Bitstream size |
| 2762 | * \param[in] dest Bitstream output |
| 2763 | * \param[in] sse Total distortion of the frame |
| 2764 | * \param[in] rate Total rate of the frame |
| 2765 | * \param[in] largest_tile_id Tile id of the last tile |
| 2766 | * |
| 2767 | * \return Returns a value to indicate if the encoding is done successfully. |
| 2768 | * \retval #AOM_CODEC_OK |
| 2769 | * \retval #AOM_CODEC_ERROR |
| 2770 | */ |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 2771 | static int encode_with_recode_loop_and_filter(AV1_COMP *cpi, size_t *size, |
| 2772 | uint8_t *dest, int64_t *sse, |
| 2773 | int64_t *rate, |
| 2774 | int *largest_tile_id) { |
| 2775 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 2776 | start_timing(cpi, encode_with_recode_loop_time); |
| 2777 | #endif |
Marco Paniconi | c6cd72e | 2020-05-08 11:00:50 -0700 | [diff] [blame] | 2778 | int err; |
Jingning Han | 37af76d | 2020-07-27 23:17:26 -0700 | [diff] [blame] | 2779 | if (cpi->sf.hl_sf.recode_loop == DISALLOW_RECODE) |
Marco Paniconi | c6cd72e | 2020-05-08 11:00:50 -0700 | [diff] [blame] | 2780 | err = encode_without_recode(cpi); |
| 2781 | else |
| 2782 | err = encode_with_recode_loop(cpi, size, dest); |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 2783 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 2784 | end_timing(cpi, encode_with_recode_loop_time); |
| 2785 | #endif |
| 2786 | if (err != AOM_CODEC_OK) { |
| 2787 | if (err == -1) { |
| 2788 | // special case as described in encode_with_recode_loop(). |
| 2789 | // Encoding was skipped. |
| 2790 | err = AOM_CODEC_OK; |
| 2791 | if (sse != NULL) *sse = INT64_MAX; |
| 2792 | if (rate != NULL) *rate = INT64_MAX; |
| 2793 | *largest_tile_id = 0; |
| 2794 | } |
| 2795 | return err; |
| 2796 | } |
| 2797 | |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 2798 | AV1_COMMON *const cm = &cpi->common; |
| 2799 | SequenceHeader *const seq_params = &cm->seq_params; |
| 2800 | |
| 2801 | // Special case code to reduce pulsing when key frames are forced at a |
| 2802 | // fixed interval. Note the reconstruction error if it is the frame before |
| 2803 | // the force key frame |
| 2804 | if (cpi->rc.next_key_frame_forced && cpi->rc.frames_to_key == 1) { |
| 2805 | if (seq_params->use_highbitdepth) { |
| 2806 | cpi->ambient_err = aom_highbd_get_y_sse(cpi->source, &cm->cur_frame->buf); |
| 2807 | } else { |
| 2808 | cpi->ambient_err = aom_get_y_sse(cpi->source, &cm->cur_frame->buf); |
| 2809 | } |
| 2810 | } |
| 2811 | |
| 2812 | cm->cur_frame->buf.color_primaries = seq_params->color_primaries; |
| 2813 | cm->cur_frame->buf.transfer_characteristics = |
| 2814 | seq_params->transfer_characteristics; |
| 2815 | cm->cur_frame->buf.matrix_coefficients = seq_params->matrix_coefficients; |
| 2816 | cm->cur_frame->buf.monochrome = seq_params->monochrome; |
| 2817 | cm->cur_frame->buf.chroma_sample_position = |
| 2818 | seq_params->chroma_sample_position; |
| 2819 | cm->cur_frame->buf.color_range = seq_params->color_range; |
| 2820 | cm->cur_frame->buf.render_width = cm->render_width; |
| 2821 | cm->cur_frame->buf.render_height = cm->render_height; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 2822 | cm->cur_frame->buf.bit_depth = (unsigned int)seq_params->bit_depth; |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 2823 | |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 2824 | // Pick the loop filter level for the frame. |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 2825 | if (!cm->features.allow_intrabc) { |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 2826 | loopfilter_frame(cpi, cm); |
| 2827 | } else { |
| 2828 | cm->lf.filter_level[0] = 0; |
| 2829 | cm->lf.filter_level[1] = 0; |
| 2830 | cm->cdef_info.cdef_bits = 0; |
| 2831 | cm->cdef_info.cdef_strengths[0] = 0; |
| 2832 | cm->cdef_info.nb_cdef_strengths = 1; |
| 2833 | cm->cdef_info.cdef_uv_strengths[0] = 0; |
| 2834 | cm->rst_info[0].frame_restoration_type = RESTORE_NONE; |
| 2835 | cm->rst_info[1].frame_restoration_type = RESTORE_NONE; |
| 2836 | cm->rst_info[2].frame_restoration_type = RESTORE_NONE; |
| 2837 | } |
| 2838 | |
| 2839 | // TODO(debargha): Fix mv search range on encoder side |
| 2840 | // aom_extend_frame_inner_borders(&cm->cur_frame->buf, av1_num_planes(cm)); |
| 2841 | aom_extend_frame_borders(&cm->cur_frame->buf, av1_num_planes(cm)); |
| 2842 | |
| 2843 | #ifdef OUTPUT_YUV_REC |
| 2844 | aom_write_one_yuv_frame(cm, &cm->cur_frame->buf); |
| 2845 | #endif |
| 2846 | |
Satish Kumar Suman | 36adf35 | 2020-06-26 11:20:10 +0530 | [diff] [blame] | 2847 | av1_finalize_encoded_frame(cpi); |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 2848 | // Build the bitstream |
| 2849 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 2850 | start_timing(cpi, av1_pack_bitstream_final_time); |
| 2851 | #endif |
| 2852 | if (av1_pack_bitstream(cpi, dest, size, largest_tile_id) != AOM_CODEC_OK) |
| 2853 | return AOM_CODEC_ERROR; |
| 2854 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 2855 | end_timing(cpi, av1_pack_bitstream_final_time); |
| 2856 | #endif |
| 2857 | |
| 2858 | // Compute sse and rate. |
| 2859 | if (sse != NULL) { |
| 2860 | *sse = (seq_params->use_highbitdepth) |
| 2861 | ? aom_highbd_get_y_sse(cpi->source, &cm->cur_frame->buf) |
| 2862 | : aom_get_y_sse(cpi->source, &cm->cur_frame->buf); |
| 2863 | } |
| 2864 | if (rate != NULL) { |
| 2865 | const int64_t bits = (*size << 3); |
| 2866 | *rate = (bits << 5); // To match scale. |
| 2867 | } |
| 2868 | return AOM_CODEC_OK; |
| 2869 | } |
| 2870 | |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 2871 | static int encode_with_and_without_superres(AV1_COMP *cpi, size_t *size, |
| 2872 | uint8_t *dest, |
| 2873 | int *largest_tile_id) { |
| 2874 | const AV1_COMMON *const cm = &cpi->common; |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 2875 | assert(cm->seq_params.enable_superres); |
Satish Kumar Suman | 7a5f5f4 | 2020-06-09 14:20:47 +0530 | [diff] [blame] | 2876 | assert(av1_superres_in_recode_allowed(cpi)); |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 2877 | aom_codec_err_t err = AOM_CODEC_OK; |
Satish Kumar Suman | 36adf35 | 2020-06-26 11:20:10 +0530 | [diff] [blame] | 2878 | av1_save_all_coding_context(cpi); |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 2879 | |
Urvang Joshi | bc82d38 | 2019-11-01 17:59:20 -0700 | [diff] [blame] | 2880 | int64_t sse1 = INT64_MAX; |
| 2881 | int64_t rate1 = INT64_MAX; |
| 2882 | int largest_tile_id1 = 0; |
Debargha Mukherjee | 2f16e85 | 2020-10-19 16:57:30 -0700 | [diff] [blame] | 2883 | int64_t sse2 = INT64_MAX; |
| 2884 | int64_t rate2 = INT64_MAX; |
| 2885 | int largest_tile_id2; |
| 2886 | double proj_rdcost1 = DBL_MAX; |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 2887 | |
Debargha Mukherjee | 2f16e85 | 2020-10-19 16:57:30 -0700 | [diff] [blame] | 2888 | // Encode with superres. |
| 2889 | if (cpi->sf.hl_sf.superres_auto_search_type == SUPERRES_AUTO_ALL) { |
| 2890 | SuperResCfg *const superres_cfg = &cpi->oxcf.superres_cfg; |
| 2891 | int64_t superres_sses[SCALE_NUMERATOR]; |
| 2892 | int64_t superres_rates[SCALE_NUMERATOR]; |
| 2893 | int superres_largest_tile_ids[SCALE_NUMERATOR]; |
| 2894 | // Use superres for Key-frames and Alt-ref frames only. |
| 2895 | const GF_GROUP *const gf_group = &cpi->gf_group; |
| 2896 | if (gf_group->update_type[gf_group->index] != OVERLAY_UPDATE && |
| 2897 | gf_group->update_type[gf_group->index] != INTNL_OVERLAY_UPDATE) { |
| 2898 | for (int denom = SCALE_NUMERATOR + 1; denom <= 2 * SCALE_NUMERATOR; |
| 2899 | ++denom) { |
| 2900 | superres_cfg->superres_scale_denominator = denom; |
| 2901 | superres_cfg->superres_kf_scale_denominator = denom; |
| 2902 | const int this_index = denom - (SCALE_NUMERATOR + 1); |
| 2903 | |
| 2904 | cpi->superres_mode = AOM_SUPERRES_AUTO; // Super-res on for this loop. |
| 2905 | err = encode_with_recode_loop_and_filter( |
| 2906 | cpi, size, dest, &superres_sses[this_index], |
| 2907 | &superres_rates[this_index], |
| 2908 | &superres_largest_tile_ids[this_index]); |
| 2909 | cpi->superres_mode = AOM_SUPERRES_NONE; // Reset to default (full-res). |
| 2910 | if (err != AOM_CODEC_OK) return err; |
| 2911 | restore_all_coding_context(cpi); |
| 2912 | } |
| 2913 | // Reset. |
| 2914 | superres_cfg->superres_scale_denominator = SCALE_NUMERATOR; |
| 2915 | superres_cfg->superres_kf_scale_denominator = SCALE_NUMERATOR; |
| 2916 | } else { |
| 2917 | for (int denom = SCALE_NUMERATOR + 1; denom <= 2 * SCALE_NUMERATOR; |
| 2918 | ++denom) { |
| 2919 | const int this_index = denom - (SCALE_NUMERATOR + 1); |
| 2920 | superres_sses[this_index] = INT64_MAX; |
| 2921 | superres_rates[this_index] = INT64_MAX; |
| 2922 | } |
| 2923 | } |
| 2924 | // Encode without superres. |
| 2925 | assert(cpi->superres_mode == AOM_SUPERRES_NONE); |
| 2926 | err = encode_with_recode_loop_and_filter(cpi, size, dest, &sse2, &rate2, |
| 2927 | &largest_tile_id2); |
| 2928 | if (err != AOM_CODEC_OK) return err; |
| 2929 | |
| 2930 | // Note: Both use common rdmult based on base qindex of fullres. |
| 2931 | const int64_t rdmult = |
| 2932 | av1_compute_rd_mult_based_on_qindex(cpi, cm->quant_params.base_qindex); |
| 2933 | |
| 2934 | // Find the best rdcost among all superres denoms. |
| 2935 | int best_denom = -1; |
| 2936 | for (int denom = SCALE_NUMERATOR + 1; denom <= 2 * SCALE_NUMERATOR; |
| 2937 | ++denom) { |
| 2938 | const int this_index = denom - (SCALE_NUMERATOR + 1); |
| 2939 | const int64_t this_sse = superres_sses[this_index]; |
| 2940 | const int64_t this_rate = superres_rates[this_index]; |
| 2941 | const int this_largest_tile_id = superres_largest_tile_ids[this_index]; |
| 2942 | const double this_rdcost = RDCOST_DBL_WITH_NATIVE_BD_DIST( |
| 2943 | rdmult, this_rate, this_sse, cm->seq_params.bit_depth); |
| 2944 | if (this_rdcost < proj_rdcost1) { |
| 2945 | sse1 = this_sse; |
| 2946 | rate1 = this_rate; |
| 2947 | largest_tile_id1 = this_largest_tile_id; |
| 2948 | proj_rdcost1 = this_rdcost; |
| 2949 | best_denom = denom; |
| 2950 | } |
| 2951 | } |
| 2952 | const double proj_rdcost2 = RDCOST_DBL_WITH_NATIVE_BD_DIST( |
| 2953 | rdmult, rate2, sse2, cm->seq_params.bit_depth); |
| 2954 | // Re-encode with superres if it's better. |
| 2955 | if (proj_rdcost1 < proj_rdcost2) { |
| 2956 | restore_all_coding_context(cpi); |
| 2957 | // TODO(urvang): We should avoid rerunning the recode loop by saving |
| 2958 | // previous output+state, or running encode only for the selected 'q' in |
| 2959 | // previous step. |
| 2960 | // Again, temporarily force the best denom. |
| 2961 | superres_cfg->superres_scale_denominator = best_denom; |
| 2962 | superres_cfg->superres_kf_scale_denominator = best_denom; |
| 2963 | int64_t sse3 = INT64_MAX; |
| 2964 | int64_t rate3 = INT64_MAX; |
| 2965 | cpi->superres_mode = |
| 2966 | AOM_SUPERRES_AUTO; // Super-res on for this recode loop. |
| 2967 | err = encode_with_recode_loop_and_filter(cpi, size, dest, &sse3, &rate3, |
| 2968 | largest_tile_id); |
| 2969 | cpi->superres_mode = AOM_SUPERRES_NONE; // Reset to default (full-res). |
| 2970 | assert(sse1 == sse3); |
| 2971 | assert(rate1 == rate3); |
| 2972 | assert(largest_tile_id1 == *largest_tile_id); |
| 2973 | // Reset. |
| 2974 | superres_cfg->superres_scale_denominator = SCALE_NUMERATOR; |
| 2975 | superres_cfg->superres_kf_scale_denominator = SCALE_NUMERATOR; |
| 2976 | } else { |
| 2977 | *largest_tile_id = largest_tile_id2; |
| 2978 | } |
| 2979 | } else { |
| 2980 | assert(cpi->sf.hl_sf.superres_auto_search_type == SUPERRES_AUTO_DUAL); |
Urvang Joshi | df26571 | 2020-10-05 23:23:09 -0700 | [diff] [blame] | 2981 | cpi->superres_mode = |
| 2982 | AOM_SUPERRES_AUTO; // Super-res on for this recode loop. |
Debargha Mukherjee | 2f16e85 | 2020-10-19 16:57:30 -0700 | [diff] [blame] | 2983 | err = encode_with_recode_loop_and_filter(cpi, size, dest, &sse1, &rate1, |
| 2984 | &largest_tile_id1); |
Urvang Joshi | df26571 | 2020-10-05 23:23:09 -0700 | [diff] [blame] | 2985 | cpi->superres_mode = AOM_SUPERRES_NONE; // Reset to default (full-res). |
Debargha Mukherjee | 2f16e85 | 2020-10-19 16:57:30 -0700 | [diff] [blame] | 2986 | if (err != AOM_CODEC_OK) return err; |
| 2987 | restore_all_coding_context(cpi); |
| 2988 | // Encode without superres. |
| 2989 | assert(cpi->superres_mode == AOM_SUPERRES_NONE); |
| 2990 | err = encode_with_recode_loop_and_filter(cpi, size, dest, &sse2, &rate2, |
| 2991 | &largest_tile_id2); |
| 2992 | if (err != AOM_CODEC_OK) return err; |
| 2993 | |
| 2994 | // Note: Both use common rdmult based on base qindex of fullres. |
| 2995 | const int64_t rdmult = |
| 2996 | av1_compute_rd_mult_based_on_qindex(cpi, cm->quant_params.base_qindex); |
| 2997 | proj_rdcost1 = RDCOST_DBL_WITH_NATIVE_BD_DIST(rdmult, rate1, sse1, |
| 2998 | cm->seq_params.bit_depth); |
| 2999 | const double proj_rdcost2 = RDCOST_DBL_WITH_NATIVE_BD_DIST( |
| 3000 | rdmult, rate2, sse2, cm->seq_params.bit_depth); |
| 3001 | // Re-encode with superres if it's better. |
| 3002 | if (proj_rdcost1 < proj_rdcost2) { |
| 3003 | restore_all_coding_context(cpi); |
| 3004 | // TODO(urvang): We should avoid rerunning the recode loop by saving |
| 3005 | // previous output+state, or running encode only for the selected 'q' in |
| 3006 | // previous step. |
| 3007 | int64_t sse3 = INT64_MAX; |
| 3008 | int64_t rate3 = INT64_MAX; |
| 3009 | cpi->superres_mode = |
| 3010 | AOM_SUPERRES_AUTO; // Super-res on for this recode loop. |
| 3011 | err = encode_with_recode_loop_and_filter(cpi, size, dest, &sse3, &rate3, |
| 3012 | largest_tile_id); |
| 3013 | cpi->superres_mode = AOM_SUPERRES_NONE; // Reset to default (full-res). |
| 3014 | assert(sse1 == sse3); |
| 3015 | assert(rate1 == rate3); |
| 3016 | assert(largest_tile_id1 == *largest_tile_id); |
| 3017 | } else { |
| 3018 | *largest_tile_id = largest_tile_id2; |
| 3019 | } |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 3020 | } |
| 3021 | |
| 3022 | return err; |
| 3023 | } |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 3024 | |
Yunqing Wang | d8fd9e7 | 2019-12-26 15:36:31 -0800 | [diff] [blame] | 3025 | extern void av1_print_frame_contexts(const FRAME_CONTEXT *fc, |
| 3026 | const char *filename); |
| 3027 | |
Yue Chen | 2d8405c | 2020-06-10 14:42:05 -0700 | [diff] [blame] | 3028 | /*!\brief Run the final pass encoding for 1-pass/2-pass encoding mode, and pack |
| 3029 | * the bitstream |
| 3030 | * |
| 3031 | * \ingroup high_level_algo |
| 3032 | * \callgraph |
| 3033 | * \callergraph |
| 3034 | * |
| 3035 | * \param[in] cpi Top-level encoder structure |
| 3036 | * \param[in] size Bitstream size |
| 3037 | * \param[in] dest Bitstream output |
| 3038 | * |
| 3039 | * \return Returns a value to indicate if the encoding is done successfully. |
| 3040 | * \retval #AOM_CODEC_OK |
| 3041 | * \retval #AOM_CODEC_ERROR |
| 3042 | */ |
David Turner | 7324576 | 2019-02-11 16:42:34 +0000 | [diff] [blame] | 3043 | static int encode_frame_to_data_rate(AV1_COMP *cpi, size_t *size, |
| 3044 | uint8_t *dest) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3045 | AV1_COMMON *const cm = &cpi->common; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 3046 | SequenceHeader *const seq_params = &cm->seq_params; |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 3047 | CurrentFrame *const current_frame = &cm->current_frame; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3048 | const AV1EncoderConfig *const oxcf = &cpi->oxcf; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3049 | struct segmentation *const seg = &cm->seg; |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 3050 | FeatureFlags *const features = &cm->features; |
Vishesh | 0481a78 | 2020-06-11 14:32:46 +0530 | [diff] [blame] | 3051 | const TileConfig *const tile_cfg = &oxcf->tile_cfg; |
Thomas Davies | 4822e14 | 2017-10-10 11:30:36 +0100 | [diff] [blame] | 3052 | |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 3053 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 3054 | start_timing(cpi, encode_frame_to_data_rate_time); |
| 3055 | #endif |
| 3056 | |
chiyotsai | 8b8f8a2 | 2020-04-21 11:03:47 -0700 | [diff] [blame] | 3057 | if (frame_is_intra_only(cm)) { |
| 3058 | av1_set_screen_content_options(cpi, features); |
| 3059 | cpi->is_screen_content_type = features->allow_screen_content_tools; |
| 3060 | } |
| 3061 | |
Fangwen Fu | 8d164de | 2016-12-14 13:40:54 -0800 | [diff] [blame] | 3062 | // frame type has been decided outside of this function call |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 3063 | cm->cur_frame->frame_type = current_frame->frame_type; |
Debargha Mukherjee | 07a7c1f | 2018-03-21 17:39:13 -0700 | [diff] [blame] | 3064 | |
Vishesh | 0481a78 | 2020-06-11 14:32:46 +0530 | [diff] [blame] | 3065 | cm->tiles.large_scale = tile_cfg->enable_large_scale_tile; |
| 3066 | cm->tiles.single_tile_decoding = tile_cfg->enable_single_tile_decoding; |
Yunqing Wang | 9612d55 | 2018-05-15 14:58:30 -0700 | [diff] [blame] | 3067 | |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 3068 | features->allow_ref_frame_mvs &= frame_might_allow_ref_frame_mvs(cm); |
| 3069 | // features->allow_ref_frame_mvs needs to be written into the frame header |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 3070 | // while cm->tiles.large_scale is 1, therefore, "cm->tiles.large_scale=1" case |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 3071 | // is separated from frame_might_allow_ref_frame_mvs(). |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 3072 | features->allow_ref_frame_mvs &= !cm->tiles.large_scale; |
Yunqing Wang | d48fb16 | 2018-06-15 10:55:28 -0700 | [diff] [blame] | 3073 | |
Vishesh | 015b496 | 2020-06-15 14:19:55 +0530 | [diff] [blame] | 3074 | features->allow_warped_motion = oxcf->motion_mode_cfg.allow_warped_motion && |
| 3075 | frame_might_allow_warped_motion(cm); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3076 | |
Urvang Joshi | 1de67aa | 2020-03-20 11:21:57 -0700 | [diff] [blame] | 3077 | cpi->last_frame_type = current_frame->frame_type; |
Sachin Kumar Garg | fd39b23 | 2019-01-03 17:41:09 +0530 | [diff] [blame] | 3078 | |
Sarah Parker | 1a72a1c | 2020-04-24 15:49:47 -0700 | [diff] [blame] | 3079 | if (frame_is_sframe(cm)) { |
| 3080 | GF_GROUP *gf_group = &cpi->gf_group; |
Sarah Parker | 1a72a1c | 2020-04-24 15:49:47 -0700 | [diff] [blame] | 3081 | // S frame will wipe out any previously encoded altref so we cannot place |
| 3082 | // an overlay frame |
| 3083 | gf_group->update_type[gf_group->size] = GF_UPDATE; |
Sarah Parker | 1a72a1c | 2020-04-24 15:49:47 -0700 | [diff] [blame] | 3084 | } |
| 3085 | |
Sarah Parker | 3300552 | 2018-07-27 14:46:25 -0700 | [diff] [blame] | 3086 | if (encode_show_existing_frame(cm)) { |
Satish Kumar Suman | 36adf35 | 2020-06-26 11:20:10 +0530 | [diff] [blame] | 3087 | av1_finalize_encoded_frame(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3088 | // Build the bitstream |
David Turner | 35cba13 | 2018-12-10 15:48:15 +0000 | [diff] [blame] | 3089 | int largest_tile_id = 0; // Output from bitstream: unused here |
| 3090 | if (av1_pack_bitstream(cpi, dest, size, &largest_tile_id) != AOM_CODEC_OK) |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 3091 | return AOM_CODEC_ERROR; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3092 | |
David Turner | 9031186 | 2018-11-29 13:34:36 +0000 | [diff] [blame] | 3093 | if (seq_params->frame_id_numbers_present_flag && |
| 3094 | current_frame->frame_type == KEY_FRAME) { |
| 3095 | // Displaying a forward key-frame, so reset the ref buffer IDs |
| 3096 | int display_frame_id = cm->ref_frame_id[cpi->existing_fb_idx_to_show]; |
| 3097 | for (int i = 0; i < REF_FRAMES; i++) |
| 3098 | cm->ref_frame_id[i] = display_frame_id; |
| 3099 | } |
| 3100 | |
Debargha Mukherjee | f2e5bb3 | 2018-03-26 14:35:24 -0700 | [diff] [blame] | 3101 | cpi->seq_params_locked = 1; |
| 3102 | |
David Turner | 7324576 | 2019-02-11 16:42:34 +0000 | [diff] [blame] | 3103 | // NOTE: Save the new show frame buffer index for --test-code=warn, i.e., |
| 3104 | // for the purpose to verify no mismatch between encoder and decoder. |
| 3105 | if (cm->show_frame) cpi->last_show_frame_buf = cm->cur_frame; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3106 | |
David Turner | 7324576 | 2019-02-11 16:42:34 +0000 | [diff] [blame] | 3107 | refresh_reference_frames(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3108 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3109 | // Since we allocate a spot for the OVERLAY frame in the gf group, we need |
| 3110 | // to do post-encoding update accordingly. |
| 3111 | if (cpi->rc.is_src_frame_alt_ref) { |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 3112 | av1_set_target_rate(cpi, cm->width, cm->height); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3113 | av1_rc_postencode_update(cpi, *size); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3114 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3115 | |
Mufaddal Chakera | ea4c6d5 | 2020-06-12 15:09:14 +0530 | [diff] [blame] | 3116 | if (is_psnr_calc_enabled(cpi)) { |
| 3117 | cpi->source = |
| 3118 | realloc_and_scale_source(cpi, cm->cur_frame->buf.y_crop_width, |
| 3119 | cm->cur_frame->buf.y_crop_height); |
| 3120 | } |
bohanli | 9985250 | 2020-07-14 16:22:45 -0700 | [diff] [blame] | 3121 | |
| 3122 | // current_frame->frame_number is incremented already for |
| 3123 | // keyframe overlays. |
| 3124 | if (!av1_check_keyframe_overlay(cpi->gf_group.index, &cpi->gf_group, |
| 3125 | cpi->rc.frames_since_key)) |
| 3126 | ++current_frame->frame_number; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3127 | |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 3128 | return AOM_CODEC_OK; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3129 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3130 | |
David Turner | efed637 | 2019-01-11 15:14:11 +0000 | [diff] [blame] | 3131 | // Work out whether to force_integer_mv this frame |
Mufaddal Chakera | e732612 | 2019-12-04 14:49:09 +0530 | [diff] [blame] | 3132 | if (!is_stat_generation_stage(cpi) && |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 3133 | cpi->common.features.allow_screen_content_tools && |
| 3134 | !frame_is_intra_only(cm)) { |
David Turner | efed637 | 2019-01-11 15:14:11 +0000 | [diff] [blame] | 3135 | if (cpi->common.seq_params.force_integer_mv == 2) { |
| 3136 | // Adaptive mode: see what previous frame encoded did |
| 3137 | if (cpi->unscaled_last_source != NULL) { |
Satish Kumar Suman | 36adf35 | 2020-06-26 11:20:10 +0530 | [diff] [blame] | 3138 | features->cur_frame_force_integer_mv = av1_is_integer_mv( |
Vishesh | 2260a59 | 2020-04-06 15:34:51 +0530 | [diff] [blame] | 3139 | cpi->source, cpi->unscaled_last_source, &cpi->force_intpel_info); |
David Turner | efed637 | 2019-01-11 15:14:11 +0000 | [diff] [blame] | 3140 | } else { |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 3141 | cpi->common.features.cur_frame_force_integer_mv = 0; |
David Turner | efed637 | 2019-01-11 15:14:11 +0000 | [diff] [blame] | 3142 | } |
| 3143 | } else { |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 3144 | cpi->common.features.cur_frame_force_integer_mv = |
David Turner | efed637 | 2019-01-11 15:14:11 +0000 | [diff] [blame] | 3145 | cpi->common.seq_params.force_integer_mv; |
| 3146 | } |
| 3147 | } else { |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 3148 | cpi->common.features.cur_frame_force_integer_mv = 0; |
David Turner | efed637 | 2019-01-11 15:14:11 +0000 | [diff] [blame] | 3149 | } |
Debargha Mukherjee | a4c6f69 | 2021-03-16 19:45:46 -0700 | [diff] [blame] | 3150 | #if CONFIG_NEW_INTER_MODES |
| 3151 | set_max_drl_bits(cpi); |
| 3152 | #endif // CONFIG_NEW_INTER_MODES |
David Turner | efed637 | 2019-01-11 15:14:11 +0000 | [diff] [blame] | 3153 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3154 | // Set default state for segment based loop filter update flags. |
| 3155 | cm->lf.mode_ref_delta_update = 0; |
| 3156 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3157 | // Set various flags etc to special state if it is a key frame. |
Tarek AMARA | c981385 | 2018-03-05 18:40:18 -0500 | [diff] [blame] | 3158 | if (frame_is_intra_only(cm) || frame_is_sframe(cm)) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3159 | // Reset the loop filter deltas and segmentation map. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3160 | av1_reset_segment_features(cm); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3161 | |
| 3162 | // If segmentation is enabled force a map update for key frames. |
| 3163 | if (seg->enabled) { |
| 3164 | seg->update_map = 1; |
| 3165 | seg->update_data = 1; |
| 3166 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3167 | } |
Vishesh | 0481a78 | 2020-06-11 14:32:46 +0530 | [diff] [blame] | 3168 | if (tile_cfg->mtu == 0) { |
| 3169 | cpi->num_tg = tile_cfg->num_tile_groups; |
Thomas Davies | af6df17 | 2016-11-09 14:04:18 +0000 | [diff] [blame] | 3170 | } else { |
Yaowu Xu | 859a527 | 2016-11-10 15:32:21 -0800 | [diff] [blame] | 3171 | // Use a default value for the purposes of weighting costs in probability |
| 3172 | // updates |
Urvang Joshi | 1de67aa | 2020-03-20 11:21:57 -0700 | [diff] [blame] | 3173 | cpi->num_tg = DEFAULT_MAX_NUM_TG; |
Thomas Davies | af6df17 | 2016-11-09 14:04:18 +0000 | [diff] [blame] | 3174 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3175 | |
| 3176 | // For 1 pass CBR, check if we are dropping this frame. |
| 3177 | // Never drop on key frame. |
Vishesh | 39e7409 | 2020-06-16 17:13:48 +0530 | [diff] [blame] | 3178 | if (has_no_stats_stage(cpi) && oxcf->rc_cfg.mode == AOM_CBR && |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 3179 | current_frame->frame_type != KEY_FRAME) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3180 | if (av1_rc_drop_frame(cpi)) { |
bohanli | 1629a4b | 2020-06-11 16:15:14 -0700 | [diff] [blame] | 3181 | av1_setup_frame_size(cpi); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3182 | av1_rc_postencode_update_drop_frame(cpi); |
David Turner | a4c9625 | 2019-01-11 16:36:39 +0000 | [diff] [blame] | 3183 | release_scaled_references(cpi); |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 3184 | return AOM_CODEC_OK; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3185 | } |
| 3186 | } |
| 3187 | |
Jayasanker J | dee179d | 2020-07-10 23:47:37 +0530 | [diff] [blame] | 3188 | if (oxcf->tune_cfg.tuning == AOM_TUNE_SSIM) |
| 3189 | av1_set_mb_ssim_rdmult_scaling(cpi); |
sdeng | c23c7f1 | 2019-06-11 16:56:50 -0700 | [diff] [blame] | 3190 | |
sdeng | 0195916 | 2019-12-20 10:46:24 -0800 | [diff] [blame] | 3191 | #if CONFIG_TUNE_VMAF |
Vishesh | 94a6529 | 2020-07-01 15:28:53 +0530 | [diff] [blame] | 3192 | if (oxcf->tune_cfg.tuning == AOM_TUNE_VMAF_WITHOUT_PREPROCESSING || |
Sai Deng | 7275a1a | 2020-08-31 12:06:09 -0700 | [diff] [blame] | 3193 | oxcf->tune_cfg.tuning == AOM_TUNE_VMAF_MAX_GAIN || |
| 3194 | oxcf->tune_cfg.tuning == AOM_TUNE_VMAF_NEG_MAX_GAIN) { |
sdeng | 0195916 | 2019-12-20 10:46:24 -0800 | [diff] [blame] | 3195 | av1_set_mb_vmaf_rdmult_scaling(cpi); |
sdeng | 29c6215 | 2019-12-09 12:44:18 -0800 | [diff] [blame] | 3196 | } |
sdeng | 0195916 | 2019-12-20 10:46:24 -0800 | [diff] [blame] | 3197 | #endif |
sdeng | 29c6215 | 2019-12-09 12:44:18 -0800 | [diff] [blame] | 3198 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3199 | aom_clear_system_state(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3200 | |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3201 | #if CONFIG_INTERNAL_STATS && !CONFIG_NEW_REF_SIGNALING |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3202 | memset(cpi->mode_chosen_counts, 0, |
| 3203 | MAX_MODES * sizeof(*cpi->mode_chosen_counts)); |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3204 | #endif // CONFIG_INTERNAL_STATS && !CONFIG_NEW_REF_SIGNALING |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3205 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 3206 | if (seq_params->frame_id_numbers_present_flag) { |
Arild Fuldseth (arilfuld) | 5114b7b | 2016-11-09 13:32:54 +0100 | [diff] [blame] | 3207 | /* Non-normative definition of current_frame_id ("frame counter" with |
Johann | 123e8a6 | 2017-12-28 14:40:49 -0800 | [diff] [blame] | 3208 | * wraparound) */ |
Arild Fuldseth (arilfuld) | 5114b7b | 2016-11-09 13:32:54 +0100 | [diff] [blame] | 3209 | if (cm->current_frame_id == -1) { |
David Barker | 49a7656 | 2016-12-07 14:50:21 +0000 | [diff] [blame] | 3210 | int lsb, msb; |
Yaowu Xu | d3e7c68 | 2017-12-21 14:08:25 -0800 | [diff] [blame] | 3211 | /* quasi-random initialization of current_frame_id for a key frame */ |
Alex Converse | f77fd0b | 2017-04-20 11:00:24 -0700 | [diff] [blame] | 3212 | if (cpi->source->flags & YV12_FLAG_HIGHBITDEPTH) { |
| 3213 | lsb = CONVERT_TO_SHORTPTR(cpi->source->y_buffer)[0] & 0xff; |
| 3214 | msb = CONVERT_TO_SHORTPTR(cpi->source->y_buffer)[1] & 0xff; |
David Barker | 49a7656 | 2016-12-07 14:50:21 +0000 | [diff] [blame] | 3215 | } else { |
Alex Converse | f77fd0b | 2017-04-20 11:00:24 -0700 | [diff] [blame] | 3216 | lsb = cpi->source->y_buffer[0] & 0xff; |
| 3217 | msb = cpi->source->y_buffer[1] & 0xff; |
David Barker | 49a7656 | 2016-12-07 14:50:21 +0000 | [diff] [blame] | 3218 | } |
David Turner | 760a2f4 | 2018-12-07 15:25:36 +0000 | [diff] [blame] | 3219 | cm->current_frame_id = |
| 3220 | ((msb << 8) + lsb) % (1 << seq_params->frame_id_length); |
Tarek AMARA | c981385 | 2018-03-05 18:40:18 -0500 | [diff] [blame] | 3221 | |
| 3222 | // S_frame is meant for stitching different streams of different |
| 3223 | // resolutions together, so current_frame_id must be the |
| 3224 | // same across different streams of the same content current_frame_id |
| 3225 | // should be the same and not random. 0x37 is a chosen number as start |
| 3226 | // point |
Vishesh | 7e9873d | 2020-06-08 15:41:33 +0530 | [diff] [blame] | 3227 | if (oxcf->kf_cfg.sframe_dist != 0) cm->current_frame_id = 0x37; |
Arild Fuldseth (arilfuld) | 5114b7b | 2016-11-09 13:32:54 +0100 | [diff] [blame] | 3228 | } else { |
| 3229 | cm->current_frame_id = |
David Turner | 760a2f4 | 2018-12-07 15:25:36 +0000 | [diff] [blame] | 3230 | (cm->current_frame_id + 1 + (1 << seq_params->frame_id_length)) % |
| 3231 | (1 << seq_params->frame_id_length); |
Arild Fuldseth (arilfuld) | 5114b7b | 2016-11-09 13:32:54 +0100 | [diff] [blame] | 3232 | } |
| 3233 | } |
Arild Fuldseth (arilfuld) | 5114b7b | 2016-11-09 13:32:54 +0100 | [diff] [blame] | 3234 | |
Vishesh | a36c8d0 | 2020-06-30 15:42:35 +0530 | [diff] [blame] | 3235 | switch (oxcf->algo_cfg.cdf_update_mode) { |
Hui Su | 483a845 | 2018-02-26 12:28:48 -0800 | [diff] [blame] | 3236 | case 0: // No CDF update for any frames(4~6% compression loss). |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 3237 | features->disable_cdf_update = 1; |
Hui Su | 483a845 | 2018-02-26 12:28:48 -0800 | [diff] [blame] | 3238 | break; |
| 3239 | case 1: // Enable CDF update for all frames. |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 3240 | features->disable_cdf_update = 0; |
Hui Su | 483a845 | 2018-02-26 12:28:48 -0800 | [diff] [blame] | 3241 | break; |
| 3242 | case 2: |
| 3243 | // Strategically determine at which frames to do CDF update. |
| 3244 | // Currently only enable CDF update for all-intra and no-show frames(1.5% |
| 3245 | // compression loss). |
| 3246 | // TODO(huisu@google.com): design schemes for various trade-offs between |
| 3247 | // compression quality and decoding speed. |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 3248 | features->disable_cdf_update = |
Hui Su | b1b76b3 | 2018-02-27 15:24:48 -0800 | [diff] [blame] | 3249 | (frame_is_intra_only(cm) || !cm->show_frame) ? 0 : 1; |
Hui Su | 483a845 | 2018-02-26 12:28:48 -0800 | [diff] [blame] | 3250 | break; |
| 3251 | } |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 3252 | seq_params->timing_info_present &= !seq_params->reduced_still_picture_hdr; |
Hui Su | 483a845 | 2018-02-26 12:28:48 -0800 | [diff] [blame] | 3253 | |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 3254 | int largest_tile_id = 0; |
Satish Kumar Suman | 7a5f5f4 | 2020-06-09 14:20:47 +0530 | [diff] [blame] | 3255 | if (av1_superres_in_recode_allowed(cpi)) { |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 3256 | if (encode_with_and_without_superres(cpi, size, dest, &largest_tile_id) != |
| 3257 | AOM_CODEC_OK) { |
| 3258 | return AOM_CODEC_ERROR; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3259 | } |
Hui Su | 06463e4 | 2018-02-23 22:17:36 -0800 | [diff] [blame] | 3260 | } else { |
Urvang Joshi | 1e86b78 | 2020-10-20 11:25:45 -0700 | [diff] [blame] | 3261 | const aom_superres_mode orig_superres_mode = cpi->superres_mode; // save |
Urvang Joshi | df26571 | 2020-10-05 23:23:09 -0700 | [diff] [blame] | 3262 | cpi->superres_mode = cpi->oxcf.superres_cfg.superres_mode; |
Urvang Joshi | 0e8b6ed | 2019-06-20 15:36:21 -0700 | [diff] [blame] | 3263 | if (encode_with_recode_loop_and_filter(cpi, size, dest, NULL, NULL, |
| 3264 | &largest_tile_id) != AOM_CODEC_OK) { |
| 3265 | return AOM_CODEC_ERROR; |
| 3266 | } |
Urvang Joshi | 1e86b78 | 2020-10-20 11:25:45 -0700 | [diff] [blame] | 3267 | cpi->superres_mode = orig_superres_mode; // restore |
Hui Su | 06463e4 | 2018-02-23 22:17:36 -0800 | [diff] [blame] | 3268 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3269 | |
Debargha Mukherjee | f2e5bb3 | 2018-03-26 14:35:24 -0700 | [diff] [blame] | 3270 | cpi->seq_params_locked = 1; |
| 3271 | |
David Turner | 996b2c1 | 2018-12-07 15:52:30 +0000 | [diff] [blame] | 3272 | // Update reference frame ids for reference frames this frame will overwrite |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 3273 | if (seq_params->frame_id_numbers_present_flag) { |
David Turner | 996b2c1 | 2018-12-07 15:52:30 +0000 | [diff] [blame] | 3274 | for (int i = 0; i < REF_FRAMES; i++) { |
| 3275 | if ((current_frame->refresh_frame_flags >> i) & 1) { |
Arild Fuldseth (arilfuld) | 5114b7b | 2016-11-09 13:32:54 +0100 | [diff] [blame] | 3276 | cm->ref_frame_id[i] = cm->current_frame_id; |
| 3277 | } |
| 3278 | } |
| 3279 | } |
Arild Fuldseth (arilfuld) | 5114b7b | 2016-11-09 13:32:54 +0100 | [diff] [blame] | 3280 | |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3281 | #if CONFIG_SVC_ENCODER |
Fyodor Kyslov | 34b591f | 2020-06-24 20:13:58 -0700 | [diff] [blame] | 3282 | if (cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1) |
| 3283 | cpi->svc.num_encoded_top_layer++; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3284 | #endif // CONFIG_SVC_ENCODER |
Fyodor Kyslov | 34b591f | 2020-06-24 20:13:58 -0700 | [diff] [blame] | 3285 | |
Soo-Chul Han | 934af35 | 2017-10-15 15:21:51 -0400 | [diff] [blame] | 3286 | if (cm->seg.enabled) { |
| 3287 | if (cm->seg.update_map) { |
| 3288 | update_reference_segmentation_map(cpi); |
Yue Chen | d90d343 | 2018-03-16 11:28:42 -0700 | [diff] [blame] | 3289 | } else if (cm->last_frame_seg_map) { |
David Turner | b757ce0 | 2018-11-12 15:01:28 +0000 | [diff] [blame] | 3290 | memcpy(cm->cur_frame->seg_map, cm->last_frame_seg_map, |
Urvang Joshi | e5fd646 | 2020-10-30 09:58:36 -0700 | [diff] [blame] | 3291 | cm->cur_frame->mi_cols * cm->cur_frame->mi_rows * |
| 3292 | sizeof(*cm->cur_frame->seg_map)); |
Soo-Chul Han | 934af35 | 2017-10-15 15:21:51 -0400 | [diff] [blame] | 3293 | } |
| 3294 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3295 | |
| 3296 | if (frame_is_intra_only(cm) == 0) { |
| 3297 | release_scaled_references(cpi); |
| 3298 | } |
| 3299 | |
David Turner | 7324576 | 2019-02-11 16:42:34 +0000 | [diff] [blame] | 3300 | // NOTE: Save the new show frame buffer index for --test-code=warn, i.e., |
| 3301 | // for the purpose to verify no mismatch between encoder and decoder. |
| 3302 | if (cm->show_frame) cpi->last_show_frame_buf = cm->cur_frame; |
| 3303 | |
| 3304 | refresh_reference_frames(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3305 | |
Debargha Mukherjee | 5802ebe | 2016-12-21 04:17:24 -0800 | [diff] [blame] | 3306 | #if CONFIG_ENTROPY_STATS |
Yue Chen | cc6a6ef | 2018-05-21 16:21:05 -0700 | [diff] [blame] | 3307 | av1_accumulate_frame_counts(&aggregate_fc, &cpi->counts); |
Debargha Mukherjee | 5802ebe | 2016-12-21 04:17:24 -0800 | [diff] [blame] | 3308 | #endif // CONFIG_ENTROPY_STATS |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3309 | |
Urvang Joshi | 6237b88 | 2020-03-26 15:02:26 -0700 | [diff] [blame] | 3310 | if (features->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD) { |
David Turner | 35cba13 | 2018-12-10 15:48:15 +0000 | [diff] [blame] | 3311 | *cm->fc = cpi->tile_data[largest_tile_id].tctx; |
Hui Su | dc54be6 | 2018-03-14 19:14:28 -0700 | [diff] [blame] | 3312 | av1_reset_cdf_symbol_counters(cm->fc); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3313 | } |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 3314 | if (!cm->tiles.large_scale) { |
David Turner | a4c9625 | 2019-01-11 16:36:39 +0000 | [diff] [blame] | 3315 | cm->cur_frame->frame_context = *cm->fc; |
| 3316 | } |
Yunqing Wang | d8fd9e7 | 2019-12-26 15:36:31 -0800 | [diff] [blame] | 3317 | |
Vishesh | 0481a78 | 2020-06-11 14:32:46 +0530 | [diff] [blame] | 3318 | if (tile_cfg->enable_ext_tile_debug) { |
Yunqing Wang | d8fd9e7 | 2019-12-26 15:36:31 -0800 | [diff] [blame] | 3319 | // (yunqing) This test ensures the correctness of large scale tile coding. |
Urvang Joshi | 54ffae7 | 2020-03-23 13:37:10 -0700 | [diff] [blame] | 3320 | if (cm->tiles.large_scale && is_stat_consumption_stage(cpi)) { |
Yunqing Wang | d8fd9e7 | 2019-12-26 15:36:31 -0800 | [diff] [blame] | 3321 | char fn[20] = "./fc"; |
| 3322 | fn[4] = current_frame->frame_number / 100 + '0'; |
| 3323 | fn[5] = (current_frame->frame_number % 100) / 10 + '0'; |
| 3324 | fn[6] = (current_frame->frame_number % 10) + '0'; |
| 3325 | fn[7] = '\0'; |
| 3326 | av1_print_frame_contexts(cm->fc, fn); |
| 3327 | } |
David Turner | a4c9625 | 2019-01-11 16:36:39 +0000 | [diff] [blame] | 3328 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3329 | |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 3330 | #if CONFIG_COLLECT_COMPONENT_TIMING |
| 3331 | end_timing(cpi, encode_frame_to_data_rate_time); |
| 3332 | |
| 3333 | // Print out timing information. |
| 3334 | int i; |
chiyotsai | 9c484b3 | 2019-03-07 16:01:50 -0800 | [diff] [blame] | 3335 | fprintf(stderr, "\n Frame number: %d, Frame type: %s, Show Frame: %d\n", |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 3336 | cm->current_frame.frame_number, |
chiyotsai | 9c484b3 | 2019-03-07 16:01:50 -0800 | [diff] [blame] | 3337 | get_frame_type_enum(cm->current_frame.frame_type), cm->show_frame); |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 3338 | for (i = 0; i < kTimingComponents; i++) { |
| 3339 | cpi->component_time[i] += cpi->frame_component_time[i]; |
| 3340 | fprintf(stderr, " %s: %" PRId64 " us (total: %" PRId64 " us)\n", |
| 3341 | get_component_name(i), cpi->frame_component_time[i], |
| 3342 | cpi->component_time[i]); |
| 3343 | cpi->frame_component_time[i] = 0; |
| 3344 | } |
| 3345 | #endif |
| 3346 | |
Urvang Joshi | 1de67aa | 2020-03-20 11:21:57 -0700 | [diff] [blame] | 3347 | cpi->last_frame_type = current_frame->frame_type; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3348 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3349 | av1_rc_postencode_update(cpi, *size); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3350 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3351 | // Clear the one shot update flags for segmentation map and mode/ref loop |
| 3352 | // filter deltas. |
| 3353 | cm->seg.update_map = 0; |
| 3354 | cm->seg.update_data = 0; |
| 3355 | cm->lf.mode_ref_delta_update = 0; |
| 3356 | |
Wei-Ting Lin | fb7dc06 | 2018-06-28 18:26:13 -0700 | [diff] [blame] | 3357 | // A droppable frame might not be shown but it always |
| 3358 | // takes a space in the gf group. Therefore, even when |
| 3359 | // it is not shown, we still need update the count down. |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3360 | if (cm->show_frame) { |
bohanli | 9985250 | 2020-07-14 16:22:45 -0700 | [diff] [blame] | 3361 | // Don't increment frame counters if this is a key frame overlay |
| 3362 | if (!av1_check_keyframe_overlay(cpi->gf_group.index, &cpi->gf_group, |
| 3363 | cpi->rc.frames_since_key)) |
| 3364 | ++current_frame->frame_number; |
| 3365 | } else if (av1_check_keyframe_arf(cpi->gf_group.index, &cpi->gf_group, |
| 3366 | cpi->rc.frames_since_key)) { |
| 3367 | // TODO(bohanli) Hack here: increment kf overlay before it is encoded |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 3368 | ++current_frame->frame_number; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3369 | } |
| 3370 | |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 3371 | return AOM_CODEC_OK; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3372 | } |
| 3373 | |
David Turner | 056f7cd | 2019-01-07 17:48:13 +0000 | [diff] [blame] | 3374 | int av1_encode(AV1_COMP *const cpi, uint8_t *const dest, |
David Turner | cb5e36f | 2019-01-17 17:15:25 +0000 | [diff] [blame] | 3375 | const EncodeFrameInput *const frame_input, |
David Turner | 056f7cd | 2019-01-07 17:48:13 +0000 | [diff] [blame] | 3376 | const EncodeFrameParams *const frame_params, |
| 3377 | EncodeFrameResults *const frame_results) { |
David Turner | 07dbd8e | 2019-01-08 17:16:25 +0000 | [diff] [blame] | 3378 | AV1_COMMON *const cm = &cpi->common; |
David Turner | a7f133c | 2019-01-22 14:47:16 +0000 | [diff] [blame] | 3379 | CurrentFrame *const current_frame = &cm->current_frame; |
David Turner | 07dbd8e | 2019-01-08 17:16:25 +0000 | [diff] [blame] | 3380 | |
David Turner | cb5e36f | 2019-01-17 17:15:25 +0000 | [diff] [blame] | 3381 | cpi->unscaled_source = frame_input->source; |
| 3382 | cpi->source = frame_input->source; |
| 3383 | cpi->unscaled_last_source = frame_input->last_source; |
David Turner | 056f7cd | 2019-01-07 17:48:13 +0000 | [diff] [blame] | 3384 | |
David Turner | 6e8b4d9 | 2019-02-18 15:01:33 +0000 | [diff] [blame] | 3385 | current_frame->refresh_frame_flags = frame_params->refresh_frame_flags; |
Urvang Joshi | b6409e9 | 2020-03-23 11:23:27 -0700 | [diff] [blame] | 3386 | cm->features.error_resilient_mode = frame_params->error_resilient_mode; |
Urvang Joshi | 6237b88 | 2020-03-26 15:02:26 -0700 | [diff] [blame] | 3387 | cm->features.primary_ref_frame = frame_params->primary_ref_frame; |
David Turner | 475a313 | 2019-01-18 15:17:17 +0000 | [diff] [blame] | 3388 | cm->current_frame.frame_type = frame_params->frame_type; |
David Turner | dedd8ff | 2019-01-23 13:59:46 +0000 | [diff] [blame] | 3389 | cm->show_frame = frame_params->show_frame; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3390 | cm->ref_frame_flags = frame_params->ref_frame_flags; |
David Turner | 04b70d8 | 2019-01-24 15:39:19 +0000 | [diff] [blame] | 3391 | cpi->speed = frame_params->speed; |
David Turner | e86ee0d | 2019-02-18 17:16:28 +0000 | [diff] [blame] | 3392 | cm->show_existing_frame = frame_params->show_existing_frame; |
| 3393 | cpi->existing_fb_idx_to_show = frame_params->existing_fb_idx_to_show; |
David Turner | 07dbd8e | 2019-01-08 17:16:25 +0000 | [diff] [blame] | 3394 | |
David Turner | 7324576 | 2019-02-11 16:42:34 +0000 | [diff] [blame] | 3395 | memcpy(cm->remapped_ref_idx, frame_params->remapped_ref_idx, |
| 3396 | REF_FRAMES * sizeof(*cm->remapped_ref_idx)); |
| 3397 | |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3398 | #if !CONFIG_NEW_REF_SIGNALING |
Jayasanker J | 24cb9bc | 2020-04-15 13:43:10 +0530 | [diff] [blame] | 3399 | memcpy(&cpi->refresh_frame, &frame_params->refresh_frame, |
| 3400 | sizeof(cpi->refresh_frame)); |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3401 | #endif // !CONFIG_NEW_REF_SIGNALING |
David Turner | fe3aecb | 2019-02-06 14:42:42 +0000 | [diff] [blame] | 3402 | |
Urvang Joshi | 3fdaf5c | 2020-07-15 10:17:48 -0700 | [diff] [blame] | 3403 | if (current_frame->frame_type == KEY_FRAME && !cpi->no_show_fwd_kf) { |
liang zhao | 7aebbd1 | 2020-07-03 22:20:34 -0700 | [diff] [blame] | 3404 | current_frame->key_frame_number += current_frame->frame_number; |
David Turner | a7f133c | 2019-01-22 14:47:16 +0000 | [diff] [blame] | 3405 | current_frame->frame_number = 0; |
liang zhao | 7aebbd1 | 2020-07-03 22:20:34 -0700 | [diff] [blame] | 3406 | } |
David Turner | a7f133c | 2019-01-22 14:47:16 +0000 | [diff] [blame] | 3407 | |
Remya | fc03866 | 2020-02-06 11:46:11 +0530 | [diff] [blame] | 3408 | current_frame->order_hint = |
| 3409 | current_frame->frame_number + frame_params->order_offset; |
| 3410 | current_frame->display_order_hint = current_frame->order_hint; |
Sarah Parker | d9dc3fd | 2020-08-18 11:11:15 -0700 | [diff] [blame] | 3411 | current_frame->pyramid_level = get_true_pyr_level( |
| 3412 | cpi->gf_group.layer_depth[cpi->gf_group.index], |
| 3413 | current_frame->display_order_hint, cpi->gf_group.max_layer_depth); |
liang zhao | 7aebbd1 | 2020-07-03 22:20:34 -0700 | [diff] [blame] | 3414 | |
| 3415 | current_frame->absolute_poc = |
| 3416 | current_frame->key_frame_number + current_frame->display_order_hint; |
| 3417 | |
Remya | fc03866 | 2020-02-06 11:46:11 +0530 | [diff] [blame] | 3418 | current_frame->order_hint %= |
| 3419 | (1 << (cm->seq_params.order_hint_info.order_hint_bits_minus_1 + 1)); |
David Turner | a7f133c | 2019-01-22 14:47:16 +0000 | [diff] [blame] | 3420 | |
Debargha Mukherjee | 7118f42 | 2020-06-29 15:49:06 -0700 | [diff] [blame] | 3421 | if (is_stat_generation_stage(cpi)) { |
Debargha Mukherjee | 7118f42 | 2020-06-29 15:49:06 -0700 | [diff] [blame] | 3422 | av1_first_pass(cpi, frame_input->ts_duration); |
Debargha Mukherjee | 7118f42 | 2020-06-29 15:49:06 -0700 | [diff] [blame] | 3423 | } else { |
| 3424 | if (encode_frame_to_data_rate(cpi, &frame_results->size, dest) != |
| 3425 | AOM_CODEC_OK) { |
| 3426 | return AOM_CODEC_ERROR; |
| 3427 | } |
| 3428 | } |
David Turner | 056f7cd | 2019-01-07 17:48:13 +0000 | [diff] [blame] | 3429 | return AOM_CODEC_OK; |
| 3430 | } |
| 3431 | |
Neil Birkbeck | a2893ab | 2018-06-08 14:45:13 -0700 | [diff] [blame] | 3432 | #if CONFIG_DENOISE |
| 3433 | static int apply_denoise_2d(AV1_COMP *cpi, YV12_BUFFER_CONFIG *sd, |
| 3434 | int block_size, float noise_level, |
| 3435 | int64_t time_stamp, int64_t end_time) { |
| 3436 | AV1_COMMON *const cm = &cpi->common; |
| 3437 | if (!cpi->denoise_and_model) { |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 3438 | cpi->denoise_and_model = aom_denoise_and_model_alloc( |
| 3439 | cm->seq_params.bit_depth, block_size, noise_level); |
Neil Birkbeck | a2893ab | 2018-06-08 14:45:13 -0700 | [diff] [blame] | 3440 | if (!cpi->denoise_and_model) { |
| 3441 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
| 3442 | "Error allocating denoise and model"); |
| 3443 | return -1; |
| 3444 | } |
| 3445 | } |
| 3446 | if (!cpi->film_grain_table) { |
| 3447 | cpi->film_grain_table = aom_malloc(sizeof(*cpi->film_grain_table)); |
| 3448 | if (!cpi->film_grain_table) { |
| 3449 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
| 3450 | "Error allocating grain table"); |
| 3451 | return -1; |
| 3452 | } |
| 3453 | memset(cpi->film_grain_table, 0, sizeof(*cpi->film_grain_table)); |
| 3454 | } |
| 3455 | if (aom_denoise_and_model_run(cpi->denoise_and_model, sd, |
| 3456 | &cm->film_grain_params)) { |
| 3457 | if (cm->film_grain_params.apply_grain) { |
| 3458 | aom_film_grain_table_append(cpi->film_grain_table, time_stamp, end_time, |
| 3459 | &cm->film_grain_params); |
| 3460 | } |
| 3461 | } |
| 3462 | return 0; |
| 3463 | } |
| 3464 | #endif |
| 3465 | |
James Zern | 3e2613b | 2017-03-30 23:14:40 -0700 | [diff] [blame] | 3466 | 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] | 3467 | YV12_BUFFER_CONFIG *sd, int64_t time_stamp, |
| 3468 | int64_t end_time) { |
| 3469 | AV1_COMMON *const cm = &cpi->common; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 3470 | const SequenceHeader *const seq_params = &cm->seq_params; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3471 | int res = 0; |
| 3472 | const int subsampling_x = sd->subsampling_x; |
| 3473 | const int subsampling_y = sd->subsampling_y; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3474 | const int use_highbitdepth = (sd->flags & YV12_FLAG_HIGHBITDEPTH) != 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3475 | |
sdeng | e63f9fa | 2019-12-13 09:29:55 -0800 | [diff] [blame] | 3476 | #if CONFIG_TUNE_VMAF |
| 3477 | if (!is_stat_generation_stage(cpi) && |
Vishesh | 94a6529 | 2020-07-01 15:28:53 +0530 | [diff] [blame] | 3478 | cpi->oxcf.tune_cfg.tuning == AOM_TUNE_VMAF_WITH_PREPROCESSING) { |
sdeng | 615dc24 | 2020-02-04 16:06:14 -0800 | [diff] [blame] | 3479 | av1_vmaf_frame_preprocessing(cpi, sd); |
| 3480 | } |
| 3481 | if (!is_stat_generation_stage(cpi) && |
Vishesh | 94a6529 | 2020-07-01 15:28:53 +0530 | [diff] [blame] | 3482 | cpi->oxcf.tune_cfg.tuning == AOM_TUNE_VMAF_MAX_GAIN) { |
sdeng | 615dc24 | 2020-02-04 16:06:14 -0800 | [diff] [blame] | 3483 | av1_vmaf_blk_preprocessing(cpi, sd); |
sdeng | e63f9fa | 2019-12-13 09:29:55 -0800 | [diff] [blame] | 3484 | } |
| 3485 | #endif |
| 3486 | |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 3487 | #if CONFIG_INTERNAL_STATS |
| 3488 | struct aom_usec_timer timer; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3489 | aom_usec_timer_start(&timer); |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 3490 | #endif |
Neil Birkbeck | a2893ab | 2018-06-08 14:45:13 -0700 | [diff] [blame] | 3491 | #if CONFIG_DENOISE |
| 3492 | if (cpi->oxcf.noise_level > 0) |
| 3493 | if (apply_denoise_2d(cpi, sd, cpi->oxcf.noise_block_size, |
| 3494 | cpi->oxcf.noise_level, time_stamp, end_time) < 0) |
| 3495 | res = -1; |
| 3496 | #endif // CONFIG_DENOISE |
| 3497 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3498 | if (av1_lookahead_push(cpi->lookahead, sd, time_stamp, end_time, |
Yaowu Xu | d3e7c68 | 2017-12-21 14:08:25 -0800 | [diff] [blame] | 3499 | use_highbitdepth, frame_flags)) |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3500 | res = -1; |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 3501 | #if CONFIG_INTERNAL_STATS |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3502 | aom_usec_timer_mark(&timer); |
| 3503 | cpi->time_receive_data += aom_usec_timer_elapsed(&timer); |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 3504 | #endif |
Yunqing Wang | aae7a16 | 2020-07-09 16:03:01 -0700 | [diff] [blame] | 3505 | |
| 3506 | // Note: Regarding profile setting, the following checks are added to help |
| 3507 | // choose a proper profile for the input video. The criterion is that all |
| 3508 | // bitstreams must be designated as the lowest profile that match its content. |
| 3509 | // E.G. A bitstream that contains 4:4:4 video must be designated as High |
| 3510 | // Profile in the seq header, and likewise a bitstream that contains 4:2:2 |
| 3511 | // bitstream must be designated as Professional Profile in the sequence |
| 3512 | // header. |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 3513 | if ((seq_params->profile == PROFILE_0) && !seq_params->monochrome && |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3514 | (subsampling_x != 1 || subsampling_y != 1)) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3515 | aom_internal_error(&cm->error, AOM_CODEC_INVALID_PARAM, |
Debargha Mukherjee | f9a50ea | 2018-01-09 22:28:20 -0800 | [diff] [blame] | 3516 | "Non-4:2:0 color format requires profile 1 or 2"); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3517 | res = -1; |
| 3518 | } |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 3519 | if ((seq_params->profile == PROFILE_1) && |
Debargha Mukherjee | f9a50ea | 2018-01-09 22:28:20 -0800 | [diff] [blame] | 3520 | !(subsampling_x == 0 && subsampling_y == 0)) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3521 | aom_internal_error(&cm->error, AOM_CODEC_INVALID_PARAM, |
Debargha Mukherjee | f9a50ea | 2018-01-09 22:28:20 -0800 | [diff] [blame] | 3522 | "Profile 1 requires 4:4:4 color format"); |
| 3523 | res = -1; |
| 3524 | } |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 3525 | if ((seq_params->profile == PROFILE_2) && |
| 3526 | (seq_params->bit_depth <= AOM_BITS_10) && |
Debargha Mukherjee | f9a50ea | 2018-01-09 22:28:20 -0800 | [diff] [blame] | 3527 | !(subsampling_x == 1 && subsampling_y == 0)) { |
| 3528 | aom_internal_error(&cm->error, AOM_CODEC_INVALID_PARAM, |
Yunqing Wang | aae7a16 | 2020-07-09 16:03:01 -0700 | [diff] [blame] | 3529 | "Profile 2 bit-depth <= 10 requires 4:2:2 color format"); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3530 | res = -1; |
| 3531 | } |
| 3532 | |
| 3533 | return res; |
| 3534 | } |
| 3535 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3536 | #if CONFIG_INTERNAL_STATS |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3537 | extern double av1_get_blockiness(const unsigned char *img1, int img1_pitch, |
| 3538 | const unsigned char *img2, int img2_pitch, |
| 3539 | int width, int height); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3540 | |
| 3541 | static void adjust_image_stat(double y, double u, double v, double all, |
| 3542 | ImageStat *s) { |
Wan-Teh Chang | c25c92a | 2018-04-23 15:04:14 -0700 | [diff] [blame] | 3543 | s->stat[STAT_Y] += y; |
| 3544 | s->stat[STAT_U] += u; |
| 3545 | s->stat[STAT_V] += v; |
| 3546 | s->stat[STAT_ALL] += all; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3547 | s->worst = AOMMIN(s->worst, all); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3548 | } |
| 3549 | |
Angie Chiang | 08a22a6 | 2017-07-17 17:29:17 -0700 | [diff] [blame] | 3550 | static void compute_internal_stats(AV1_COMP *cpi, int frame_bytes) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3551 | AV1_COMMON *const cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3552 | double samples = 0.0; |
Vishesh | 4342d7f | 2020-06-29 18:49:06 +0530 | [diff] [blame] | 3553 | const uint32_t in_bit_depth = cpi->oxcf.input_cfg.input_bit_depth; |
Yaowu Xu | e75b58a | 2020-01-03 12:56:12 -0800 | [diff] [blame] | 3554 | const uint32_t bit_depth = cpi->td.mb.e_mbd.bd; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3555 | |
Angie Chiang | 08a22a6 | 2017-07-17 17:29:17 -0700 | [diff] [blame] | 3556 | #if CONFIG_INTER_STATS_ONLY |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 3557 | if (cm->current_frame.frame_type == KEY_FRAME) return; // skip key frame |
Angie Chiang | 08a22a6 | 2017-07-17 17:29:17 -0700 | [diff] [blame] | 3558 | #endif |
| 3559 | cpi->bytes += frame_bytes; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3560 | if (cm->show_frame) { |
Alex Converse | f77fd0b | 2017-04-20 11:00:24 -0700 | [diff] [blame] | 3561 | const YV12_BUFFER_CONFIG *orig = cpi->source; |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 3562 | const YV12_BUFFER_CONFIG *recon = &cpi->common.cur_frame->buf; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3563 | double y, u, v, frame_all; |
| 3564 | |
| 3565 | cpi->count++; |
| 3566 | if (cpi->b_calculate_psnr) { |
| 3567 | PSNR_STATS psnr; |
| 3568 | double frame_ssim2 = 0.0, weight = 0.0; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3569 | aom_clear_system_state(); |
Yaowu Xu | e75b58a | 2020-01-03 12:56:12 -0800 | [diff] [blame] | 3570 | aom_calc_highbd_psnr(orig, recon, &psnr, bit_depth, in_bit_depth); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3571 | adjust_image_stat(psnr.psnr[1], psnr.psnr[2], psnr.psnr[3], psnr.psnr[0], |
| 3572 | &cpi->psnr); |
| 3573 | cpi->total_sq_error += psnr.sse[0]; |
| 3574 | cpi->total_samples += psnr.samples[0]; |
| 3575 | samples = psnr.samples[0]; |
Yaowu Xu | d3e7c68 | 2017-12-21 14:08:25 -0800 | [diff] [blame] | 3576 | // TODO(yaowu): unify these two versions into one. |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 3577 | if (cm->seq_params.use_highbitdepth) |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3578 | frame_ssim2 = |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3579 | aom_highbd_calc_ssim(orig, recon, &weight, bit_depth, in_bit_depth); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3580 | else |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3581 | frame_ssim2 = aom_calc_ssim(orig, recon, &weight); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3582 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3583 | cpi->worst_ssim = AOMMIN(cpi->worst_ssim, frame_ssim2); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3584 | cpi->summed_quality += frame_ssim2 * weight; |
| 3585 | cpi->summed_weights += weight; |
| 3586 | |
| 3587 | #if 0 |
| 3588 | { |
| 3589 | FILE *f = fopen("q_used.stt", "a"); |
Zoe Liu | ee202be | 2017-11-17 12:14:33 -0800 | [diff] [blame] | 3590 | double y2 = psnr.psnr[1]; |
| 3591 | double u2 = psnr.psnr[2]; |
| 3592 | double v2 = psnr.psnr[3]; |
| 3593 | double frame_psnr2 = psnr.psnr[0]; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3594 | fprintf(f, "%5d : Y%f7.3:U%f7.3:V%f7.3:F%f7.3:S%7.3f\n", |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 3595 | cm->current_frame.frame_number, y2, u2, v2, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3596 | frame_psnr2, frame_ssim2); |
| 3597 | fclose(f); |
| 3598 | } |
| 3599 | #endif |
| 3600 | } |
| 3601 | if (cpi->b_calculate_blockiness) { |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 3602 | if (!cm->seq_params.use_highbitdepth) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3603 | const double frame_blockiness = |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3604 | av1_get_blockiness(orig->y_buffer, orig->y_stride, recon->y_buffer, |
| 3605 | recon->y_stride, orig->y_width, orig->y_height); |
| 3606 | cpi->worst_blockiness = AOMMAX(cpi->worst_blockiness, frame_blockiness); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3607 | cpi->total_blockiness += frame_blockiness; |
| 3608 | } |
| 3609 | |
| 3610 | if (cpi->b_calculate_consistency) { |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 3611 | if (!cm->seq_params.use_highbitdepth) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3612 | const double this_inconsistency = aom_get_ssim_metrics( |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3613 | orig->y_buffer, orig->y_stride, recon->y_buffer, recon->y_stride, |
| 3614 | orig->y_width, orig->y_height, cpi->ssim_vars, &cpi->metrics, 1); |
| 3615 | |
| 3616 | const double peak = (double)((1 << in_bit_depth) - 1); |
| 3617 | const double consistency = |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3618 | aom_sse_to_psnr(samples, peak, cpi->total_inconsistency); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3619 | if (consistency > 0.0) |
| 3620 | cpi->worst_consistency = |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3621 | AOMMIN(cpi->worst_consistency, consistency); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3622 | cpi->total_inconsistency += this_inconsistency; |
| 3623 | } |
| 3624 | } |
| 3625 | } |
| 3626 | |
| 3627 | frame_all = |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3628 | aom_calc_fastssim(orig, recon, &y, &u, &v, bit_depth, in_bit_depth); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3629 | adjust_image_stat(y, u, v, frame_all, &cpi->fastssim); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3630 | frame_all = aom_psnrhvs(orig, recon, &y, &u, &v, bit_depth, in_bit_depth); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3631 | adjust_image_stat(y, u, v, frame_all, &cpi->psnrhvs); |
| 3632 | } |
| 3633 | } |
| 3634 | #endif // CONFIG_INTERNAL_STATS |
Wan-Teh Chang | 1c52005 | 2020-06-11 10:17:56 -0700 | [diff] [blame] | 3635 | |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 3636 | int av1_get_compressed_data(AV1_COMP *cpi, unsigned int *frame_flags, |
| 3637 | size_t *size, uint8_t *dest, int64_t *time_stamp, |
| 3638 | int64_t *time_end, int flush, |
Yue Chen | 1bc5be6 | 2018-08-24 13:57:32 -0700 | [diff] [blame] | 3639 | const aom_rational64_t *timestamp_ratio) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3640 | const AV1EncoderConfig *const oxcf = &cpi->oxcf; |
| 3641 | AV1_COMMON *const cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3642 | |
| 3643 | #if CONFIG_BITSTREAM_DEBUG |
Urvang Joshi | e2b505b | 2020-06-19 11:39:49 -0700 | [diff] [blame] | 3644 | assert(cpi->oxcf.max_threads <= 1 && |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3645 | "bitstream debug tool does not support multithreading"); |
| 3646 | bitstream_queue_record_write(); |
angiebird | 1f7174f | 2020-06-27 16:23:16 -0700 | [diff] [blame] | 3647 | aom_bitstream_queue_set_frame_write(cm->current_frame.order_hint * 2 + |
Yaowu Xu | 63f2ea3 | 2019-04-29 10:47:42 -0700 | [diff] [blame] | 3648 | cm->show_frame); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3649 | #endif |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3650 | #if CONFIG_SVC_ENCODER |
Marco Paniconi | 6397132 | 2019-08-15 21:32:05 -0700 | [diff] [blame] | 3651 | if (cpi->use_svc && cm->number_spatial_layers > 1) { |
| 3652 | av1_one_pass_cbr_svc_start_layer(cpi); |
| 3653 | } |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3654 | #endif // CONFIG_SVC_ENCODER |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3655 | |
Dominic Symes | d492901 | 2018-01-31 17:32:01 +0100 | [diff] [blame] | 3656 | cm->showable_frame = 0; |
David Turner | e43f7fe | 2019-01-15 14:58:00 +0000 | [diff] [blame] | 3657 | *size = 0; |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 3658 | #if CONFIG_INTERNAL_STATS |
| 3659 | struct aom_usec_timer cmptimer; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3660 | aom_usec_timer_start(&cmptimer); |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 3661 | #endif |
chiyotsai | c666b1f | 2019-12-20 10:44:58 -0800 | [diff] [blame] | 3662 | av1_set_high_precision_mv(cpi, 1, 0); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3663 | |
Debargha Mukherjee | ba7b8fe | 2018-03-15 23:10:07 -0700 | [diff] [blame] | 3664 | // Normal defaults |
Vishesh | aa6a170 | 2020-06-30 19:27:22 +0530 | [diff] [blame] | 3665 | cm->features.refresh_frame_context = |
| 3666 | oxcf->tool_cfg.frame_parallel_decoding_mode |
| 3667 | ? REFRESH_FRAME_CONTEXT_DISABLED |
| 3668 | : REFRESH_FRAME_CONTEXT_BACKWARD; |
Vishesh | 0481a78 | 2020-06-11 14:32:46 +0530 | [diff] [blame] | 3669 | if (oxcf->tile_cfg.enable_large_scale_tile) |
Urvang Joshi | 6237b88 | 2020-03-26 15:02:26 -0700 | [diff] [blame] | 3670 | cm->features.refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3671 | |
Sarah Parker | b904161 | 2018-05-22 19:06:47 -0700 | [diff] [blame] | 3672 | // Initialize fields related to forward keyframes |
bohanli | 6f22c7a | 2020-07-14 10:52:50 -0700 | [diff] [blame] | 3673 | cpi->no_show_fwd_kf = 0; |
Zoe Liu | b499120 | 2017-12-21 15:31:06 -0800 | [diff] [blame] | 3674 | |
David Turner | dedd8ff | 2019-01-23 13:59:46 +0000 | [diff] [blame] | 3675 | if (assign_cur_frame_new_fb(cm) == NULL) return AOM_CODEC_ERROR; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3676 | |
Yue Chen | 1bc5be6 | 2018-08-24 13:57:32 -0700 | [diff] [blame] | 3677 | const int result = |
| 3678 | av1_encode_strategy(cpi, size, dest, frame_flags, time_stamp, time_end, |
| 3679 | timestamp_ratio, flush); |
Wan-Teh Chang | 1c52005 | 2020-06-11 10:17:56 -0700 | [diff] [blame] | 3680 | if (result == -1) { |
David Turner | dedd8ff | 2019-01-23 13:59:46 +0000 | [diff] [blame] | 3681 | // Returning -1 indicates no frame encoded; more input is required |
| 3682 | return -1; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3683 | } |
Wan-Teh Chang | 1c52005 | 2020-06-11 10:17:56 -0700 | [diff] [blame] | 3684 | if (result != AOM_CODEC_OK) { |
| 3685 | return AOM_CODEC_ERROR; |
| 3686 | } |
Yunqing Wang | d1f32e6 | 2019-02-20 10:37:51 -0800 | [diff] [blame] | 3687 | #if CONFIG_INTERNAL_STATS |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3688 | aom_usec_timer_mark(&cmptimer); |
| 3689 | cpi->time_compress_data += aom_usec_timer_elapsed(&cmptimer); |
Yue Chen | 1bc5be6 | 2018-08-24 13:57:32 -0700 | [diff] [blame] | 3690 | #endif // CONFIG_INTERNAL_STATS |
Debargha Mukherjee | dce68c5 | 2020-07-02 13:06:58 -0700 | [diff] [blame] | 3691 | // Note *size = 0 indicates a dropeed frame for which psnr is not calculated |
| 3692 | if (cpi->b_calculate_psnr && *size > 0) { |
Mufaddal Chakera | e732612 | 2019-12-04 14:49:09 +0530 | [diff] [blame] | 3693 | if (cm->show_existing_frame || |
| 3694 | (!is_stat_generation_stage(cpi) && cm->show_frame)) { |
David Turner | c4bf8c7 | 2019-01-15 13:14:37 +0000 | [diff] [blame] | 3695 | generate_psnr_packet(cpi); |
| 3696 | } |
| 3697 | } |
Hui Su | 8ea8732 | 2019-03-29 14:44:32 -0700 | [diff] [blame] | 3698 | |
Vishesh | 8ac928b | 2020-04-01 02:36:35 +0530 | [diff] [blame] | 3699 | if (cpi->level_params.keep_level_stats && !is_stat_generation_stage(cpi)) { |
Hui Su | 8ea8732 | 2019-03-29 14:44:32 -0700 | [diff] [blame] | 3700 | // Initialize level info. at the beginning of each sequence. |
bohanli | 6f22c7a | 2020-07-14 10:52:50 -0700 | [diff] [blame] | 3701 | if (cm->current_frame.frame_type == KEY_FRAME && !cpi->no_show_fwd_kf) { |
Hui Su | 58753d6 | 2019-05-29 09:56:19 -0700 | [diff] [blame] | 3702 | av1_init_level_info(cpi); |
Hui Su | 8ea8732 | 2019-03-29 14:44:32 -0700 | [diff] [blame] | 3703 | } |
kyslov | abeeb7c | 2019-03-06 18:35:04 -0800 | [diff] [blame] | 3704 | av1_update_level_info(cpi, *size, *time_stamp, *time_end); |
Hui Su | 8ea8732 | 2019-03-29 14:44:32 -0700 | [diff] [blame] | 3705 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3706 | |
| 3707 | #if CONFIG_INTERNAL_STATS |
Mufaddal Chakera | e732612 | 2019-12-04 14:49:09 +0530 | [diff] [blame] | 3708 | if (!is_stat_generation_stage(cpi)) { |
Angie Chiang | 08a22a6 | 2017-07-17 17:29:17 -0700 | [diff] [blame] | 3709 | compute_internal_stats(cpi, (int)(*size)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3710 | } |
| 3711 | #endif // CONFIG_INTERNAL_STATS |
Debargha Mukherjee | 0857e66 | 2019-01-04 16:22:09 -0800 | [diff] [blame] | 3712 | #if CONFIG_SPEED_STATS |
Mufaddal Chakera | e732612 | 2019-12-04 14:49:09 +0530 | [diff] [blame] | 3713 | if (!is_stat_generation_stage(cpi) && !cm->show_existing_frame) { |
chiyotsai | 4c1e5c6 | 2020-04-30 17:54:14 -0700 | [diff] [blame] | 3714 | cpi->tx_search_count += cpi->td.mb.txfm_search_info.tx_search_count; |
| 3715 | cpi->td.mb.txfm_search_info.tx_search_count = 0; |
Debargha Mukherjee | 0857e66 | 2019-01-04 16:22:09 -0800 | [diff] [blame] | 3716 | } |
| 3717 | #endif // CONFIG_SPEED_STATS |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3718 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3719 | aom_clear_system_state(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3720 | |
Hui Su | 0d0ee66 | 2019-07-29 14:38:36 -0700 | [diff] [blame] | 3721 | return AOM_CODEC_OK; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3722 | } |
| 3723 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3724 | int av1_get_preview_raw_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *dest) { |
| 3725 | AV1_COMMON *cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3726 | if (!cm->show_frame) { |
| 3727 | return -1; |
| 3728 | } else { |
| 3729 | int ret; |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 3730 | if (cm->cur_frame != NULL) { |
| 3731 | *dest = cm->cur_frame->buf; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3732 | dest->y_width = cm->width; |
| 3733 | dest->y_height = cm->height; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 3734 | dest->uv_width = cm->width >> cm->seq_params.subsampling_x; |
| 3735 | dest->uv_height = cm->height >> cm->seq_params.subsampling_y; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3736 | ret = 0; |
| 3737 | } else { |
| 3738 | ret = -1; |
| 3739 | } |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3740 | aom_clear_system_state(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3741 | return ret; |
| 3742 | } |
| 3743 | } |
| 3744 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3745 | int av1_get_last_show_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *frame) { |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3746 | if (cpi->last_show_frame_buf == NULL) return -1; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3747 | |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3748 | *frame = cpi->last_show_frame_buf->buf; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3749 | return 0; |
| 3750 | } |
| 3751 | |
Yunqing Wang | 93b18f3 | 2018-06-08 21:08:29 -0700 | [diff] [blame] | 3752 | aom_codec_err_t av1_copy_new_frame_enc(AV1_COMMON *cm, |
| 3753 | YV12_BUFFER_CONFIG *new_frame, |
| 3754 | YV12_BUFFER_CONFIG *sd) { |
Yunqing Wang | ff9bfca | 2018-06-06 11:46:08 -0700 | [diff] [blame] | 3755 | const int num_planes = av1_num_planes(cm); |
| 3756 | if (!equal_dimensions_and_border(new_frame, sd)) |
| 3757 | aom_internal_error(&cm->error, AOM_CODEC_ERROR, |
| 3758 | "Incorrect buffer dimensions"); |
| 3759 | else |
| 3760 | aom_yv12_copy_frame(new_frame, sd, num_planes); |
| 3761 | |
| 3762 | return cm->error.error_code; |
| 3763 | } |
| 3764 | |
Jayasanker J | 0b1dd29 | 2020-04-09 15:47:25 +0530 | [diff] [blame] | 3765 | int av1_set_internal_size(AV1EncoderConfig *const oxcf, |
| 3766 | ResizePendingParams *resize_pending_params, |
| 3767 | AOM_SCALING horiz_mode, AOM_SCALING vert_mode) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3768 | int hr = 0, hs = 0, vr = 0, vs = 0; |
| 3769 | |
| 3770 | if (horiz_mode > ONETWO || vert_mode > ONETWO) return -1; |
| 3771 | |
| 3772 | Scale2Ratio(horiz_mode, &hr, &hs); |
| 3773 | Scale2Ratio(vert_mode, &vr, &vs); |
| 3774 | |
| 3775 | // always go to the next whole number |
Vishesh | 2b8e479 | 2020-06-12 12:11:19 +0530 | [diff] [blame] | 3776 | resize_pending_params->width = (hs - 1 + oxcf->frm_dim_cfg.width * hr) / hs; |
| 3777 | resize_pending_params->height = (vs - 1 + oxcf->frm_dim_cfg.height * vr) / vs; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3778 | |
Deepa K G | 260c826 | 2020-07-08 19:13:54 +0530 | [diff] [blame] | 3779 | if (horiz_mode != NORMAL || vert_mode != NORMAL) { |
Marco Paniconi | 7205692 | 2020-06-24 12:31:25 -0700 | [diff] [blame] | 3780 | oxcf->resize_cfg.resize_mode = RESIZE_FIXED; |
Deepa K G | 260c826 | 2020-07-08 19:13:54 +0530 | [diff] [blame] | 3781 | oxcf->algo_cfg.enable_tpl_model = 0; |
| 3782 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3783 | return 0; |
| 3784 | } |
| 3785 | |
Urvang Joshi | 1781462 | 2020-03-27 17:26:17 -0700 | [diff] [blame] | 3786 | int av1_get_quantizer(AV1_COMP *cpi) { |
| 3787 | return cpi->common.quant_params.base_qindex; |
| 3788 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3789 | |
Soo-Chul Han | 29c46fb | 2018-03-23 16:02:00 -0400 | [diff] [blame] | 3790 | int av1_convert_sect5obus_to_annexb(uint8_t *buffer, size_t *frame_size) { |
| 3791 | size_t output_size = 0; |
| 3792 | size_t total_bytes_read = 0; |
| 3793 | size_t remaining_size = *frame_size; |
| 3794 | uint8_t *buff_ptr = buffer; |
| 3795 | |
| 3796 | // go through each OBUs |
| 3797 | while (total_bytes_read < *frame_size) { |
| 3798 | uint8_t saved_obu_header[2]; |
| 3799 | uint64_t obu_payload_size; |
| 3800 | size_t length_of_payload_size; |
| 3801 | size_t length_of_obu_size; |
| 3802 | uint32_t obu_header_size = (buff_ptr[0] >> 2) & 0x1 ? 2 : 1; |
| 3803 | size_t obu_bytes_read = obu_header_size; // bytes read for current obu |
| 3804 | |
| 3805 | // save the obu header (1 or 2 bytes) |
| 3806 | memmove(saved_obu_header, buff_ptr, obu_header_size); |
| 3807 | // clear the obu_has_size_field |
| 3808 | saved_obu_header[0] = saved_obu_header[0] & (~0x2); |
| 3809 | |
| 3810 | // get the payload_size and length of payload_size |
| 3811 | if (aom_uleb_decode(buff_ptr + obu_header_size, remaining_size, |
| 3812 | &obu_payload_size, &length_of_payload_size) != 0) { |
| 3813 | return AOM_CODEC_ERROR; |
| 3814 | } |
| 3815 | obu_bytes_read += length_of_payload_size; |
| 3816 | |
| 3817 | // calculate the length of size of the obu header plus payload |
| 3818 | length_of_obu_size = |
| 3819 | aom_uleb_size_in_bytes((uint64_t)(obu_header_size + obu_payload_size)); |
| 3820 | |
| 3821 | // move the rest of data to new location |
| 3822 | memmove(buff_ptr + length_of_obu_size + obu_header_size, |
| 3823 | buff_ptr + obu_bytes_read, remaining_size - obu_bytes_read); |
Yaowu Xu | 9e49420 | 2018-04-03 11:19:49 -0700 | [diff] [blame] | 3824 | obu_bytes_read += (size_t)obu_payload_size; |
Soo-Chul Han | 29c46fb | 2018-03-23 16:02:00 -0400 | [diff] [blame] | 3825 | |
| 3826 | // write the new obu size |
| 3827 | const uint64_t obu_size = obu_header_size + obu_payload_size; |
| 3828 | size_t coded_obu_size; |
| 3829 | if (aom_uleb_encode(obu_size, sizeof(obu_size), buff_ptr, |
| 3830 | &coded_obu_size) != 0) { |
| 3831 | return AOM_CODEC_ERROR; |
| 3832 | } |
| 3833 | |
| 3834 | // write the saved (modified) obu_header following obu size |
| 3835 | memmove(buff_ptr + length_of_obu_size, saved_obu_header, obu_header_size); |
| 3836 | |
| 3837 | total_bytes_read += obu_bytes_read; |
| 3838 | remaining_size -= obu_bytes_read; |
| 3839 | buff_ptr += length_of_obu_size + obu_size; |
Yaowu Xu | 9e49420 | 2018-04-03 11:19:49 -0700 | [diff] [blame] | 3840 | output_size += length_of_obu_size + (size_t)obu_size; |
Soo-Chul Han | 29c46fb | 2018-03-23 16:02:00 -0400 | [diff] [blame] | 3841 | } |
| 3842 | |
| 3843 | *frame_size = output_size; |
| 3844 | return AOM_CODEC_OK; |
| 3845 | } |
| 3846 | |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3847 | #if CONFIG_SVC_ENCODER |
Vishesh | a195ca3 | 2020-04-07 18:46:20 +0530 | [diff] [blame] | 3848 | static void svc_set_updates_external_ref_frame_config( |
Vishesh | 38c05d7 | 2020-04-14 12:19:14 +0530 | [diff] [blame] | 3849 | ExtRefreshFrameFlagsInfo *const ext_refresh_frame_flags, SVC *const svc) { |
| 3850 | ext_refresh_frame_flags->update_pending = 1; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3851 | #if !CONFIG_NEW_REF_SIGNALING |
Vishesh | 38c05d7 | 2020-04-14 12:19:14 +0530 | [diff] [blame] | 3852 | ext_refresh_frame_flags->last_frame = svc->refresh[svc->ref_idx[0]]; |
| 3853 | ext_refresh_frame_flags->golden_frame = svc->refresh[svc->ref_idx[3]]; |
| 3854 | ext_refresh_frame_flags->bwd_ref_frame = svc->refresh[svc->ref_idx[4]]; |
| 3855 | ext_refresh_frame_flags->alt2_ref_frame = svc->refresh[svc->ref_idx[5]]; |
| 3856 | ext_refresh_frame_flags->alt_ref_frame = svc->refresh[svc->ref_idx[6]]; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3857 | #endif // !CONFIG_NEW_REF_SIGNALING |
Vishesh | a195ca3 | 2020-04-07 18:46:20 +0530 | [diff] [blame] | 3858 | svc->non_reference_frame = 1; |
Marco Paniconi | d8574e3 | 2019-08-04 21:30:12 -0700 | [diff] [blame] | 3859 | for (int i = 0; i < REF_FRAMES; i++) { |
Vishesh | a195ca3 | 2020-04-07 18:46:20 +0530 | [diff] [blame] | 3860 | if (svc->refresh[i] == 1) { |
| 3861 | svc->non_reference_frame = 0; |
Marco Paniconi | d8574e3 | 2019-08-04 21:30:12 -0700 | [diff] [blame] | 3862 | break; |
| 3863 | } |
| 3864 | } |
| 3865 | } |
| 3866 | |
Marco Paniconi | ad4953a | 2020-04-02 09:52:58 -0700 | [diff] [blame] | 3867 | static int svc_set_references_external_ref_frame_config(AV1_COMP *cpi) { |
| 3868 | // LAST_FRAME (0), LAST2_FRAME(1), LAST3_FRAME(2), GOLDEN_FRAME(3), |
| 3869 | // BWDREF_FRAME(4), ALTREF2_FRAME(5), ALTREF_FRAME(6). |
| 3870 | int ref = AOM_REFFRAME_ALL; |
| 3871 | for (int i = 0; i < INTER_REFS_PER_FRAME; i++) { |
| 3872 | if (!cpi->svc.reference[i]) ref ^= (1 << i); |
| 3873 | } |
| 3874 | return ref; |
| 3875 | } |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3876 | #endif // CONFIG_SVC_ENCODER |
Marco Paniconi | ad4953a | 2020-04-02 09:52:58 -0700 | [diff] [blame] | 3877 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3878 | void av1_apply_encoding_flags(AV1_COMP *cpi, aom_enc_frame_flags_t flags) { |
Yunqing Wang | 9a50fec | 2017-11-02 17:02:00 -0700 | [diff] [blame] | 3879 | // TODO(yunqingwang): For what references to use, external encoding flags |
| 3880 | // should be consistent with internal reference frame selection. Need to |
| 3881 | // ensure that there is not conflict between the two. In AV1 encoder, the |
| 3882 | // priority rank for 7 reference frames are: LAST, ALTREF, LAST2, LAST3, |
Marco Paniconi | 60a4d7f | 2019-08-02 14:43:27 -0700 | [diff] [blame] | 3883 | // GOLDEN, BWDREF, ALTREF2. |
Vishesh | a195ca3 | 2020-04-07 18:46:20 +0530 | [diff] [blame] | 3884 | |
| 3885 | ExternalFlags *const ext_flags = &cpi->ext_flags; |
Vishesh | 38c05d7 | 2020-04-14 12:19:14 +0530 | [diff] [blame] | 3886 | ExtRefreshFrameFlagsInfo *const ext_refresh_frame_flags = |
| 3887 | &ext_flags->refresh_frame; |
Vishesh | a195ca3 | 2020-04-07 18:46:20 +0530 | [diff] [blame] | 3888 | ext_flags->ref_frame_flags = AOM_REFFRAME_ALL; |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3889 | #if CONFIG_NEW_REF_SIGNALING |
| 3890 | #if CONFIG_SVC_ENCODER |
| 3891 | if (cpi->svc.external_ref_frame_config) { |
| 3892 | int ref = svc_set_references_external_ref_frame_config(cpi); |
| 3893 | av1_use_as_reference(&ext_flags->ref_frame_flags, ref); |
| 3894 | svc_set_updates_external_ref_frame_config(ext_refresh_frame_flags, |
| 3895 | &cpi->svc); |
| 3896 | } else { |
| 3897 | ext_refresh_frame_flags->update_pending = 0; |
| 3898 | } |
| 3899 | #else |
| 3900 | ext_refresh_frame_flags->update_pending = 0; |
| 3901 | #endif |
| 3902 | #else |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3903 | if (flags & |
Yunqing Wang | 9a50fec | 2017-11-02 17:02:00 -0700 | [diff] [blame] | 3904 | (AOM_EFLAG_NO_REF_LAST | AOM_EFLAG_NO_REF_LAST2 | AOM_EFLAG_NO_REF_LAST3 | |
| 3905 | AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_REF_BWD | |
| 3906 | AOM_EFLAG_NO_REF_ARF2)) { |
Marco Paniconi | 60a4d7f | 2019-08-02 14:43:27 -0700 | [diff] [blame] | 3907 | int ref = AOM_REFFRAME_ALL; |
| 3908 | |
| 3909 | if (flags & AOM_EFLAG_NO_REF_LAST) ref ^= AOM_LAST_FLAG; |
| 3910 | if (flags & AOM_EFLAG_NO_REF_LAST2) ref ^= AOM_LAST2_FLAG; |
| 3911 | if (flags & AOM_EFLAG_NO_REF_LAST3) ref ^= AOM_LAST3_FLAG; |
| 3912 | |
| 3913 | if (flags & AOM_EFLAG_NO_REF_GF) ref ^= AOM_GOLD_FLAG; |
| 3914 | |
| 3915 | if (flags & AOM_EFLAG_NO_REF_ARF) { |
| 3916 | ref ^= AOM_ALT_FLAG; |
| 3917 | ref ^= AOM_BWD_FLAG; |
| 3918 | ref ^= AOM_ALT2_FLAG; |
Yunqing Wang | 9a50fec | 2017-11-02 17:02:00 -0700 | [diff] [blame] | 3919 | } else { |
Marco Paniconi | 60a4d7f | 2019-08-02 14:43:27 -0700 | [diff] [blame] | 3920 | if (flags & AOM_EFLAG_NO_REF_BWD) ref ^= AOM_BWD_FLAG; |
| 3921 | if (flags & AOM_EFLAG_NO_REF_ARF2) ref ^= AOM_ALT2_FLAG; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3922 | } |
Marco Paniconi | 60a4d7f | 2019-08-02 14:43:27 -0700 | [diff] [blame] | 3923 | |
Vishesh | a195ca3 | 2020-04-07 18:46:20 +0530 | [diff] [blame] | 3924 | av1_use_as_reference(&ext_flags->ref_frame_flags, ref); |
Marco Paniconi | ad4953a | 2020-04-02 09:52:58 -0700 | [diff] [blame] | 3925 | } else { |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3926 | #if CONFIG_SVC_ENCODER |
Marco Paniconi | ad4953a | 2020-04-02 09:52:58 -0700 | [diff] [blame] | 3927 | if (cpi->svc.external_ref_frame_config) { |
| 3928 | int ref = svc_set_references_external_ref_frame_config(cpi); |
Vishesh | a195ca3 | 2020-04-07 18:46:20 +0530 | [diff] [blame] | 3929 | av1_use_as_reference(&ext_flags->ref_frame_flags, ref); |
Marco Paniconi | ad4953a | 2020-04-02 09:52:58 -0700 | [diff] [blame] | 3930 | } |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3931 | #endif // CONFIG_SVC_ENCODER |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3932 | } |
| 3933 | |
| 3934 | if (flags & |
Yunqing Wang | 9a50fec | 2017-11-02 17:02:00 -0700 | [diff] [blame] | 3935 | (AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF)) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3936 | int upd = AOM_REFFRAME_ALL; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3937 | |
Yunqing Wang | 9a50fec | 2017-11-02 17:02:00 -0700 | [diff] [blame] | 3938 | // Refreshing LAST/LAST2/LAST3 is handled by 1 common flag. |
| 3939 | if (flags & AOM_EFLAG_NO_UPD_LAST) upd ^= AOM_LAST_FLAG; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3940 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3941 | if (flags & AOM_EFLAG_NO_UPD_GF) upd ^= AOM_GOLD_FLAG; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3942 | |
Yunqing Wang | 9a50fec | 2017-11-02 17:02:00 -0700 | [diff] [blame] | 3943 | if (flags & AOM_EFLAG_NO_UPD_ARF) { |
| 3944 | upd ^= AOM_ALT_FLAG; |
| 3945 | upd ^= AOM_BWD_FLAG; |
| 3946 | upd ^= AOM_ALT2_FLAG; |
| 3947 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3948 | |
Vishesh | 38c05d7 | 2020-04-14 12:19:14 +0530 | [diff] [blame] | 3949 | ext_refresh_frame_flags->last_frame = (upd & AOM_LAST_FLAG) != 0; |
| 3950 | ext_refresh_frame_flags->golden_frame = (upd & AOM_GOLD_FLAG) != 0; |
| 3951 | ext_refresh_frame_flags->alt_ref_frame = (upd & AOM_ALT_FLAG) != 0; |
| 3952 | ext_refresh_frame_flags->bwd_ref_frame = (upd & AOM_BWD_FLAG) != 0; |
| 3953 | ext_refresh_frame_flags->alt2_ref_frame = (upd & AOM_ALT2_FLAG) != 0; |
| 3954 | ext_refresh_frame_flags->update_pending = 1; |
David Turner | 4f1f181 | 2019-01-24 17:00:24 +0000 | [diff] [blame] | 3955 | } else { |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3956 | #if CONFIG_SVC_ENCODER |
Marco Paniconi | d8574e3 | 2019-08-04 21:30:12 -0700 | [diff] [blame] | 3957 | if (cpi->svc.external_ref_frame_config) |
Vishesh | 38c05d7 | 2020-04-14 12:19:14 +0530 | [diff] [blame] | 3958 | svc_set_updates_external_ref_frame_config(ext_refresh_frame_flags, |
| 3959 | &cpi->svc); |
Marco Paniconi | d8574e3 | 2019-08-04 21:30:12 -0700 | [diff] [blame] | 3960 | else |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3961 | #endif // CONFIG_SVC_ENCODER |
Vishesh | 38c05d7 | 2020-04-14 12:19:14 +0530 | [diff] [blame] | 3962 | ext_refresh_frame_flags->update_pending = 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3963 | } |
Lester Lu | 6bc30d6 | 2021-12-16 19:13:21 +0000 | [diff] [blame^] | 3964 | #endif // CONFIG_NEW_REF_SIGNALING |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3965 | |
Vishesh | aa6a170 | 2020-06-30 19:27:22 +0530 | [diff] [blame] | 3966 | ext_flags->use_ref_frame_mvs = cpi->oxcf.tool_cfg.enable_ref_frame_mvs & |
Vishesh | a195ca3 | 2020-04-07 18:46:20 +0530 | [diff] [blame] | 3967 | ((flags & AOM_EFLAG_NO_REF_FRAME_MVS) == 0); |
Vishesh | aa6a170 | 2020-06-30 19:27:22 +0530 | [diff] [blame] | 3968 | ext_flags->use_error_resilient = cpi->oxcf.tool_cfg.error_resilient_mode | |
Vishesh | a195ca3 | 2020-04-07 18:46:20 +0530 | [diff] [blame] | 3969 | ((flags & AOM_EFLAG_ERROR_RESILIENT) != 0); |
| 3970 | ext_flags->use_s_frame = |
Vishesh | 7e9873d | 2020-06-08 15:41:33 +0530 | [diff] [blame] | 3971 | cpi->oxcf.kf_cfg.enable_sframe | ((flags & AOM_EFLAG_SET_S_FRAME) != 0); |
Vishesh | a195ca3 | 2020-04-07 18:46:20 +0530 | [diff] [blame] | 3972 | ext_flags->use_primary_ref_none = |
| 3973 | (flags & AOM_EFLAG_SET_PRIMARY_REF_NONE) != 0; |
sarahparker | 21dbca4 | 2018-03-30 17:43:44 -0700 | [diff] [blame] | 3974 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3975 | if (flags & AOM_EFLAG_NO_UPD_ENTROPY) { |
Satish Kumar Suman | 329de4d | 2020-06-16 10:48:32 +0530 | [diff] [blame] | 3976 | update_entropy(&ext_flags->refresh_frame_context, |
| 3977 | &ext_flags->refresh_frame_context_pending, 0); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3978 | } |
| 3979 | } |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 3980 | |
Tom Finegan | f8d6a16 | 2018-08-21 10:47:55 -0700 | [diff] [blame] | 3981 | aom_fixed_buf_t *av1_get_global_headers(AV1_COMP *cpi) { |
| 3982 | if (!cpi) return NULL; |
| 3983 | |
| 3984 | uint8_t header_buf[512] = { 0 }; |
| 3985 | const uint32_t sequence_header_size = |
Urvang Joshi | 450a9a2 | 2020-03-31 16:00:22 -0700 | [diff] [blame] | 3986 | av1_write_sequence_header_obu(&cpi->common.seq_params, &header_buf[0]); |
Tom Finegan | f8d6a16 | 2018-08-21 10:47:55 -0700 | [diff] [blame] | 3987 | assert(sequence_header_size <= sizeof(header_buf)); |
| 3988 | if (sequence_header_size == 0) return NULL; |
| 3989 | |
| 3990 | const size_t obu_header_size = 1; |
| 3991 | const size_t size_field_size = aom_uleb_size_in_bytes(sequence_header_size); |
| 3992 | const size_t payload_offset = obu_header_size + size_field_size; |
| 3993 | |
| 3994 | if (payload_offset + sequence_header_size > sizeof(header_buf)) return NULL; |
| 3995 | memmove(&header_buf[payload_offset], &header_buf[0], sequence_header_size); |
| 3996 | |
Vishesh | 8ac928b | 2020-04-01 02:36:35 +0530 | [diff] [blame] | 3997 | if (av1_write_obu_header(&cpi->level_params, OBU_SEQUENCE_HEADER, 0, |
| 3998 | &header_buf[0]) != obu_header_size) { |
Tom Finegan | f8d6a16 | 2018-08-21 10:47:55 -0700 | [diff] [blame] | 3999 | return NULL; |
| 4000 | } |
| 4001 | |
| 4002 | size_t coded_size_field_size = 0; |
| 4003 | if (aom_uleb_encode(sequence_header_size, size_field_size, |
| 4004 | &header_buf[obu_header_size], |
| 4005 | &coded_size_field_size) != 0) { |
| 4006 | return NULL; |
| 4007 | } |
| 4008 | assert(coded_size_field_size == size_field_size); |
| 4009 | |
| 4010 | aom_fixed_buf_t *global_headers = |
| 4011 | (aom_fixed_buf_t *)malloc(sizeof(*global_headers)); |
| 4012 | if (!global_headers) return NULL; |
| 4013 | |
| 4014 | const size_t global_header_buf_size = |
| 4015 | obu_header_size + size_field_size + sequence_header_size; |
| 4016 | |
| 4017 | global_headers->buf = malloc(global_header_buf_size); |
| 4018 | if (!global_headers->buf) { |
| 4019 | free(global_headers); |
| 4020 | return NULL; |
| 4021 | } |
| 4022 | |
| 4023 | memcpy(global_headers->buf, &header_buf[0], global_header_buf_size); |
| 4024 | global_headers->sz = global_header_buf_size; |
| 4025 | return global_headers; |
| 4026 | } |