Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1 | /* |
Urvang Joshi | 8a02d76 | 2016-07-28 15:51:12 -0700 | [diff] [blame] | 2 | * Copyright (c) 2016, Alliance for Open Media. All rights reserved |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3 | * |
Urvang Joshi | 8a02d76 | 2016-07-28 15:51:12 -0700 | [diff] [blame] | 4 | * This source code is subject to the terms of the BSD 2 Clause License and |
| 5 | * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License |
| 6 | * was not distributed with this source code in the LICENSE file, you can |
| 7 | * obtain it at www.aomedia.org/license/software. If the Alliance for Open |
| 8 | * Media Patent License 1.0 was not distributed with this source code in the |
| 9 | * PATENTS file, you can obtain it at www.aomedia.org/license/patent. |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 10 | */ |
| 11 | |
| 12 | #include <limits.h> |
| 13 | #include <math.h> |
| 14 | #include <stdio.h> |
| 15 | |
Tom Finegan | 60e653d | 2018-05-22 11:34:58 -0700 | [diff] [blame] | 16 | #include "config/aom_config.h" |
Tom Finegan | 44702c8 | 2018-05-22 13:00:39 -0700 | [diff] [blame] | 17 | #include "config/aom_dsp_rtcd.h" |
| 18 | #include "config/aom_scale_rtcd.h" |
Yaowu Xu | fa3721d | 2018-07-30 14:38:49 -0700 | [diff] [blame] | 19 | #include "config/av1_rtcd.h" |
| 20 | |
| 21 | #include "aom_dsp/aom_dsp_common.h" |
| 22 | #include "aom_dsp/aom_filter.h" |
| 23 | #if CONFIG_DENOISE |
| 24 | #include "aom_dsp/grain_table.h" |
| 25 | #include "aom_dsp/noise_util.h" |
| 26 | #include "aom_dsp/noise_model.h" |
| 27 | #endif |
| 28 | #include "aom_dsp/psnr.h" |
| 29 | #if CONFIG_INTERNAL_STATS |
| 30 | #include "aom_dsp/ssim.h" |
| 31 | #endif |
| 32 | #include "aom_ports/aom_timer.h" |
| 33 | #include "aom_ports/mem.h" |
| 34 | #include "aom_ports/system_state.h" |
| 35 | #include "aom_scale/aom_scale.h" |
| 36 | #if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG |
| 37 | #include "aom_util/debug_util.h" |
| 38 | #endif // CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 39 | |
| 40 | #include "av1/common/alloccommon.h" |
Steinar Midtskogen | a9d41e8 | 2017-03-17 12:48:15 +0100 | [diff] [blame] | 41 | #include "av1/common/cdef.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 42 | #include "av1/common/filter.h" |
| 43 | #include "av1/common/idct.h" |
| 44 | #include "av1/common/reconinter.h" |
| 45 | #include "av1/common/reconintra.h" |
Fergus Simpson | d056500 | 2017-03-27 16:51:52 -0700 | [diff] [blame] | 46 | #include "av1/common/resize.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 47 | #include "av1/common/tile_common.h" |
| 48 | |
Ravi Chaudhary | c5e7469 | 2018-10-08 16:05:38 +0530 | [diff] [blame] | 49 | #include "av1/encoder/av1_multi_thread.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 50 | #include "av1/encoder/aq_complexity.h" |
| 51 | #include "av1/encoder/aq_cyclicrefresh.h" |
| 52 | #include "av1/encoder/aq_variance.h" |
| 53 | #include "av1/encoder/bitstream.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 54 | #include "av1/encoder/context_tree.h" |
| 55 | #include "av1/encoder/encodeframe.h" |
| 56 | #include "av1/encoder/encodemv.h" |
David Turner | 056f7cd | 2019-01-07 17:48:13 +0000 | [diff] [blame] | 57 | #include "av1/encoder/encode_strategy.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 58 | #include "av1/encoder/encoder.h" |
Angie Chiang | f0fbf9d | 2017-03-15 15:01:22 -0700 | [diff] [blame] | 59 | #include "av1/encoder/encodetxb.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 60 | #include "av1/encoder/ethread.h" |
| 61 | #include "av1/encoder/firstpass.h" |
Yaowu Xu | fa3721d | 2018-07-30 14:38:49 -0700 | [diff] [blame] | 62 | #include "av1/encoder/grain_test_vectors.h" |
RogerZhou | cc5d35d | 2017-08-07 22:20:15 -0700 | [diff] [blame] | 63 | #include "av1/encoder/hash_motion.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 64 | #include "av1/encoder/mbgraph.h" |
| 65 | #include "av1/encoder/picklpf.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 66 | #include "av1/encoder/pickrst.h" |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 67 | #include "av1/encoder/random.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 68 | #include "av1/encoder/ratectrl.h" |
| 69 | #include "av1/encoder/rd.h" |
Debargha Mukherjee | df71310 | 2018-10-02 12:33:32 -0700 | [diff] [blame] | 70 | #include "av1/encoder/rdopt.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 71 | #include "av1/encoder/segmentation.h" |
| 72 | #include "av1/encoder/speed_features.h" |
| 73 | #include "av1/encoder/temporal_filter.h" |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 74 | #include "av1/encoder/reconinter_enc.h" |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 75 | |
Imdad Sardharwalla | e68aa8a | 2018-03-07 18:52:54 +0000 | [diff] [blame] | 76 | #define DEFAULT_EXPLICIT_ORDER_HINT_BITS 7 |
Imdad Sardharwalla | e68aa8a | 2018-03-07 18:52:54 +0000 | [diff] [blame] | 77 | |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 78 | // av1 uses 10,000,000 ticks/second as time stamp |
| 79 | #define TICKS_PER_SEC 10000000LL |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 80 | |
Debargha Mukherjee | 5802ebe | 2016-12-21 04:17:24 -0800 | [diff] [blame] | 81 | #if CONFIG_ENTROPY_STATS |
| 82 | FRAME_COUNTS aggregate_fc; |
| 83 | #endif // CONFIG_ENTROPY_STATS |
| 84 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 85 | #define AM_SEGMENT_ID_INACTIVE 7 |
| 86 | #define AM_SEGMENT_ID_ACTIVE 0 |
| 87 | |
Johann | b0ef6ff | 2018-02-08 14:32:21 -0800 | [diff] [blame] | 88 | // Whether to use high precision mv for altref computation. |
| 89 | #define ALTREF_HIGH_PRECISION_MV 1 |
| 90 | |
| 91 | // Q threshold for high precision mv. Choose a very high value for now so that |
| 92 | // HIGH_PRECISION is always chosen. |
| 93 | #define HIGH_PRECISION_MV_QTHRESH 200 |
Wei-Ting Lin | 01d4d8f | 2017-08-03 17:04:12 -0700 | [diff] [blame] | 94 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 95 | // #define OUTPUT_YUV_REC |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 96 | #ifdef OUTPUT_YUV_SKINMAP |
| 97 | FILE *yuv_skinmap_file = NULL; |
| 98 | #endif |
| 99 | #ifdef OUTPUT_YUV_REC |
| 100 | FILE *yuv_rec_file; |
| 101 | #define FILE_NAME_LEN 100 |
| 102 | #endif |
| 103 | |
Debargha Mukherjee | df71310 | 2018-10-02 12:33:32 -0700 | [diff] [blame] | 104 | // Estimate if the source frame is screen content, based on the portion of |
| 105 | // blocks that have no more than 4 (experimentally selected) luma colors. |
| 106 | static int is_screen_content(const uint8_t *src, int use_hbd, int bd, |
| 107 | int stride, int width, int height) { |
| 108 | assert(src != NULL); |
| 109 | int counts = 0; |
| 110 | const int blk_w = 16; |
| 111 | const int blk_h = 16; |
| 112 | const int limit = 4; |
| 113 | for (int r = 0; r + blk_h <= height; r += blk_h) { |
| 114 | for (int c = 0; c + blk_w <= width; c += blk_w) { |
| 115 | int count_buf[1 << 12]; // Maximum (1 << 12) color levels. |
| 116 | const int n_colors = |
| 117 | use_hbd ? av1_count_colors_highbd(src + r * stride + c, stride, blk_w, |
| 118 | blk_h, bd, count_buf) |
| 119 | : av1_count_colors(src + r * stride + c, stride, blk_w, blk_h, |
| 120 | count_buf); |
| 121 | if (n_colors > 1 && n_colors <= limit) counts++; |
| 122 | } |
| 123 | } |
| 124 | // The threshold is 10%. |
| 125 | return counts * blk_h * blk_w * 10 > width * height; |
| 126 | } |
| 127 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 128 | static INLINE void Scale2Ratio(AOM_SCALING mode, int *hr, int *hs) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 129 | switch (mode) { |
| 130 | case NORMAL: |
| 131 | *hr = 1; |
| 132 | *hs = 1; |
| 133 | break; |
| 134 | case FOURFIVE: |
| 135 | *hr = 4; |
| 136 | *hs = 5; |
| 137 | break; |
| 138 | case THREEFIVE: |
| 139 | *hr = 3; |
| 140 | *hs = 5; |
| 141 | break; |
| 142 | case ONETWO: |
| 143 | *hr = 1; |
| 144 | *hs = 2; |
| 145 | break; |
| 146 | default: |
| 147 | *hr = 1; |
| 148 | *hs = 1; |
| 149 | assert(0); |
| 150 | break; |
| 151 | } |
| 152 | } |
| 153 | |
| 154 | // Mark all inactive blocks as active. Other segmentation features may be set |
| 155 | // so memset cannot be used, instead only inactive blocks should be reset. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 156 | static void suppress_active_map(AV1_COMP *cpi) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 157 | unsigned char *const seg_map = cpi->segmentation_map; |
| 158 | int i; |
| 159 | if (cpi->active_map.enabled || cpi->active_map.update) |
| 160 | for (i = 0; i < cpi->common.mi_rows * cpi->common.mi_cols; ++i) |
| 161 | if (seg_map[i] == AM_SEGMENT_ID_INACTIVE) |
| 162 | seg_map[i] = AM_SEGMENT_ID_ACTIVE; |
| 163 | } |
| 164 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 165 | static void apply_active_map(AV1_COMP *cpi) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 166 | struct segmentation *const seg = &cpi->common.seg; |
| 167 | unsigned char *const seg_map = cpi->segmentation_map; |
| 168 | const unsigned char *const active_map = cpi->active_map.map; |
| 169 | int i; |
| 170 | |
| 171 | assert(AM_SEGMENT_ID_ACTIVE == CR_SEGMENT_ID_BASE); |
| 172 | |
| 173 | if (frame_is_intra_only(&cpi->common)) { |
| 174 | cpi->active_map.enabled = 0; |
| 175 | cpi->active_map.update = 1; |
| 176 | } |
| 177 | |
| 178 | if (cpi->active_map.update) { |
| 179 | if (cpi->active_map.enabled) { |
| 180 | for (i = 0; i < cpi->common.mi_rows * cpi->common.mi_cols; ++i) |
| 181 | if (seg_map[i] == AM_SEGMENT_ID_ACTIVE) seg_map[i] = active_map[i]; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 182 | av1_enable_segmentation(seg); |
| 183 | av1_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_SKIP); |
Cheng Chen | d8184da | 2017-09-26 18:15:22 -0700 | [diff] [blame] | 184 | av1_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_Y_H); |
| 185 | av1_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_Y_V); |
| 186 | av1_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_U); |
| 187 | av1_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_V); |
| 188 | |
| 189 | av1_set_segdata(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_Y_H, |
| 190 | -MAX_LOOP_FILTER); |
| 191 | av1_set_segdata(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_Y_V, |
| 192 | -MAX_LOOP_FILTER); |
| 193 | av1_set_segdata(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_U, |
| 194 | -MAX_LOOP_FILTER); |
| 195 | av1_set_segdata(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_V, |
| 196 | -MAX_LOOP_FILTER); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 197 | } else { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 198 | av1_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_SKIP); |
Cheng Chen | d8184da | 2017-09-26 18:15:22 -0700 | [diff] [blame] | 199 | av1_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_Y_H); |
| 200 | av1_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_Y_V); |
| 201 | av1_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_U); |
| 202 | av1_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_V); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 203 | if (seg->enabled) { |
| 204 | seg->update_data = 1; |
| 205 | seg->update_map = 1; |
| 206 | } |
| 207 | } |
| 208 | cpi->active_map.update = 0; |
| 209 | } |
| 210 | } |
| 211 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 212 | int av1_set_active_map(AV1_COMP *cpi, unsigned char *new_map_16x16, int rows, |
| 213 | int cols) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 214 | if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols) { |
| 215 | unsigned char *const active_map_8x8 = cpi->active_map.map; |
| 216 | const int mi_rows = cpi->common.mi_rows; |
| 217 | const int mi_cols = cpi->common.mi_cols; |
Jingning Han | 9d53302 | 2017-04-07 10:14:42 -0700 | [diff] [blame] | 218 | const int row_scale = mi_size_high[BLOCK_16X16] == 2 ? 1 : 2; |
| 219 | const int col_scale = mi_size_wide[BLOCK_16X16] == 2 ? 1 : 2; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 220 | cpi->active_map.update = 1; |
| 221 | if (new_map_16x16) { |
| 222 | int r, c; |
| 223 | for (r = 0; r < mi_rows; ++r) { |
| 224 | for (c = 0; c < mi_cols; ++c) { |
| 225 | active_map_8x8[r * mi_cols + c] = |
Jingning Han | 9d53302 | 2017-04-07 10:14:42 -0700 | [diff] [blame] | 226 | new_map_16x16[(r >> row_scale) * cols + (c >> col_scale)] |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 227 | ? AM_SEGMENT_ID_ACTIVE |
| 228 | : AM_SEGMENT_ID_INACTIVE; |
| 229 | } |
| 230 | } |
| 231 | cpi->active_map.enabled = 1; |
| 232 | } else { |
| 233 | cpi->active_map.enabled = 0; |
| 234 | } |
| 235 | return 0; |
| 236 | } else { |
| 237 | return -1; |
| 238 | } |
| 239 | } |
| 240 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 241 | int av1_get_active_map(AV1_COMP *cpi, unsigned char *new_map_16x16, int rows, |
| 242 | int cols) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 243 | if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols && |
| 244 | new_map_16x16) { |
| 245 | unsigned char *const seg_map_8x8 = cpi->segmentation_map; |
| 246 | const int mi_rows = cpi->common.mi_rows; |
| 247 | const int mi_cols = cpi->common.mi_cols; |
Jingning Han | 9d53302 | 2017-04-07 10:14:42 -0700 | [diff] [blame] | 248 | const int row_scale = mi_size_high[BLOCK_16X16] == 2 ? 1 : 2; |
| 249 | const int col_scale = mi_size_wide[BLOCK_16X16] == 2 ? 1 : 2; |
| 250 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 251 | memset(new_map_16x16, !cpi->active_map.enabled, rows * cols); |
| 252 | if (cpi->active_map.enabled) { |
| 253 | int r, c; |
| 254 | for (r = 0; r < mi_rows; ++r) { |
| 255 | for (c = 0; c < mi_cols; ++c) { |
| 256 | // Cyclic refresh segments are considered active despite not having |
| 257 | // AM_SEGMENT_ID_ACTIVE |
Jingning Han | 9d53302 | 2017-04-07 10:14:42 -0700 | [diff] [blame] | 258 | new_map_16x16[(r >> row_scale) * cols + (c >> col_scale)] |= |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 259 | seg_map_8x8[r * mi_cols + c] != AM_SEGMENT_ID_INACTIVE; |
| 260 | } |
| 261 | } |
| 262 | } |
| 263 | return 0; |
| 264 | } else { |
| 265 | return -1; |
| 266 | } |
| 267 | } |
| 268 | |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 269 | // Compute the horizontal frequency components' energy in a frame |
| 270 | // by calculuating the 16x4 Horizontal DCT. This is to be used to |
| 271 | // decide the superresolution parameters. |
Debargha Mukherjee | f50fdce | 2018-11-13 11:13:00 -0800 | [diff] [blame] | 272 | void analyze_hor_freq(const AV1_COMP *cpi, double *energy) { |
Debargha Mukherjee | 21eb040 | 2018-12-03 12:10:59 -0800 | [diff] [blame] | 273 | uint64_t freq_energy[16] = { 0 }; |
Debargha Mukherjee | f50fdce | 2018-11-13 11:13:00 -0800 | [diff] [blame] | 274 | const YV12_BUFFER_CONFIG *buf = cpi->source; |
| 275 | const int bd = cpi->td.mb.e_mbd.bd; |
| 276 | const int width = buf->y_crop_width; |
| 277 | const int height = buf->y_crop_height; |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 278 | DECLARE_ALIGNED(16, int32_t, coeff[16 * 4]); |
Debargha Mukherjee | f50fdce | 2018-11-13 11:13:00 -0800 | [diff] [blame] | 279 | int n = 0; |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 280 | memset(freq_energy, 0, sizeof(freq_energy)); |
Debargha Mukherjee | f50fdce | 2018-11-13 11:13:00 -0800 | [diff] [blame] | 281 | if (buf->flags & YV12_FLAG_HIGHBITDEPTH) { |
| 282 | const int16_t *src16 = (const int16_t *)CONVERT_TO_SHORTPTR(buf->y_buffer); |
| 283 | for (int i = 0; i < height - 4; i += 4) { |
| 284 | for (int j = 0; j < width - 16; j += 16) { |
| 285 | av1_fwd_txfm2d_16x4(src16 + i * buf->y_stride + j, coeff, buf->y_stride, |
| 286 | H_DCT, bd); |
Debargha Mukherjee | 21eb040 | 2018-12-03 12:10:59 -0800 | [diff] [blame] | 287 | for (int k = 1; k < 16; ++k) { |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 288 | const uint64_t this_energy = |
| 289 | ((int64_t)coeff[k] * coeff[k]) + |
| 290 | ((int64_t)coeff[k + 16] * coeff[k + 16]) + |
| 291 | ((int64_t)coeff[k + 32] * coeff[k + 32]) + |
| 292 | ((int64_t)coeff[k + 48] * coeff[k + 48]); |
Debargha Mukherjee | 21eb040 | 2018-12-03 12:10:59 -0800 | [diff] [blame] | 293 | freq_energy[k] += ROUND_POWER_OF_TWO(this_energy, 2 + 2 * (bd - 8)); |
Debargha Mukherjee | f50fdce | 2018-11-13 11:13:00 -0800 | [diff] [blame] | 294 | } |
| 295 | n++; |
| 296 | } |
| 297 | } |
| 298 | } else { |
Debargha Mukherjee | ac28c72 | 2018-11-14 22:09:46 -0800 | [diff] [blame] | 299 | assert(bd == 8); |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 300 | DECLARE_ALIGNED(16, int16_t, src16[16 * 4]); |
Debargha Mukherjee | f50fdce | 2018-11-13 11:13:00 -0800 | [diff] [blame] | 301 | for (int i = 0; i < height - 4; i += 4) { |
| 302 | for (int j = 0; j < width - 16; j += 16) { |
| 303 | for (int ii = 0; ii < 4; ++ii) |
| 304 | for (int jj = 0; jj < 16; ++jj) |
| 305 | src16[ii * 16 + jj] = |
| 306 | buf->y_buffer[(i + ii) * buf->y_stride + (j + jj)]; |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 307 | av1_fwd_txfm2d_16x4(src16, coeff, 16, H_DCT, bd); |
Debargha Mukherjee | 21eb040 | 2018-12-03 12:10:59 -0800 | [diff] [blame] | 308 | for (int k = 1; k < 16; ++k) { |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 309 | const uint64_t this_energy = |
| 310 | ((int64_t)coeff[k] * coeff[k]) + |
| 311 | ((int64_t)coeff[k + 16] * coeff[k + 16]) + |
| 312 | ((int64_t)coeff[k + 32] * coeff[k + 32]) + |
| 313 | ((int64_t)coeff[k + 48] * coeff[k + 48]); |
Debargha Mukherjee | 21eb040 | 2018-12-03 12:10:59 -0800 | [diff] [blame] | 314 | freq_energy[k] += ROUND_POWER_OF_TWO(this_energy, 2); |
Debargha Mukherjee | f50fdce | 2018-11-13 11:13:00 -0800 | [diff] [blame] | 315 | } |
| 316 | n++; |
| 317 | } |
| 318 | } |
| 319 | } |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 320 | if (n) { |
Debargha Mukherjee | 21eb040 | 2018-12-03 12:10:59 -0800 | [diff] [blame] | 321 | for (int k = 1; k < 16; ++k) energy[k] = (double)freq_energy[k] / n; |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 322 | // Convert to cumulative energy |
Debargha Mukherjee | 21eb040 | 2018-12-03 12:10:59 -0800 | [diff] [blame] | 323 | for (int k = 14; k > 0; --k) energy[k] += energy[k + 1]; |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 324 | } else { |
Debargha Mukherjee | 21eb040 | 2018-12-03 12:10:59 -0800 | [diff] [blame] | 325 | for (int k = 1; k < 16; ++k) energy[k] = 1e+20; |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 326 | } |
Debargha Mukherjee | f50fdce | 2018-11-13 11:13:00 -0800 | [diff] [blame] | 327 | } |
| 328 | |
Yaowu Xu | 45295c3 | 2018-03-29 12:06:10 -0700 | [diff] [blame] | 329 | static void set_high_precision_mv(AV1_COMP *cpi, int allow_high_precision_mv, |
| 330 | int cur_frame_force_integer_mv) { |
James Zern | 01a9d70 | 2017-08-25 19:09:33 +0000 | [diff] [blame] | 331 | MACROBLOCK *const mb = &cpi->td.mb; |
Hui Su | 5036115 | 2018-03-02 11:01:42 -0800 | [diff] [blame] | 332 | cpi->common.allow_high_precision_mv = |
| 333 | allow_high_precision_mv && cur_frame_force_integer_mv == 0; |
Rupert Swarbrick | a84faf2 | 2017-12-11 13:56:40 +0000 | [diff] [blame] | 334 | const int copy_hp = |
| 335 | cpi->common.allow_high_precision_mv && cur_frame_force_integer_mv == 0; |
Jingning Han | f050fc1 | 2018-03-09 14:53:33 -0800 | [diff] [blame] | 336 | int *(*src)[2] = copy_hp ? &mb->nmvcost_hp : &mb->nmvcost; |
| 337 | mb->mv_cost_stack = *src; |
James Zern | 01a9d70 | 2017-08-25 19:09:33 +0000 | [diff] [blame] | 338 | } |
| 339 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 340 | static BLOCK_SIZE select_sb_size(const AV1_COMP *const cpi) { |
Urvang Joshi | e4530f8 | 2018-01-09 11:43:37 -0800 | [diff] [blame] | 341 | const AV1_COMMON *const cm = &cpi->common; |
| 342 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 343 | if (cpi->oxcf.superblock_size == AOM_SUPERBLOCK_SIZE_64X64) |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 344 | return BLOCK_64X64; |
Maxym Dmytrychenko | cc6e0e1 | 2018-02-05 16:35:37 +0100 | [diff] [blame] | 345 | #if CONFIG_FILEOPTIONS |
Urvang Joshi | e4530f8 | 2018-01-09 11:43:37 -0800 | [diff] [blame] | 346 | if (cm->options && cm->options->ext_partition) |
Maxym Dmytrychenko | cc6e0e1 | 2018-02-05 16:35:37 +0100 | [diff] [blame] | 347 | #endif |
| 348 | if (cpi->oxcf.superblock_size == AOM_SUPERBLOCK_SIZE_128X128) |
| 349 | return BLOCK_128X128; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 350 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 351 | assert(cpi->oxcf.superblock_size == AOM_SUPERBLOCK_SIZE_DYNAMIC); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 352 | |
Maxym Dmytrychenko | cc6e0e1 | 2018-02-05 16:35:37 +0100 | [diff] [blame] | 353 | // TODO(any): Possibly could improve this with a heuristic. |
| 354 | #if CONFIG_FILEOPTIONS |
Urvang Joshi | e4530f8 | 2018-01-09 11:43:37 -0800 | [diff] [blame] | 355 | if (cm->options && !cm->options->ext_partition) return BLOCK_64X64; |
Maxym Dmytrychenko | cc6e0e1 | 2018-02-05 16:35:37 +0100 | [diff] [blame] | 356 | #endif |
Urvang Joshi | e4530f8 | 2018-01-09 11:43:37 -0800 | [diff] [blame] | 357 | |
Urvang Joshi | aab7443 | 2018-06-01 12:06:22 -0700 | [diff] [blame] | 358 | // When superres / resize is on, 'cm->width / height' can change between |
| 359 | // calls, so we don't apply this heuristic there. Also, this heuristic gives |
| 360 | // compression gain for speed >= 2 only. |
| 361 | if (cpi->oxcf.superres_mode == SUPERRES_NONE && |
| 362 | cpi->oxcf.resize_mode == RESIZE_NONE && cpi->oxcf.speed >= 2) { |
Urvang Joshi | e4530f8 | 2018-01-09 11:43:37 -0800 | [diff] [blame] | 363 | return (cm->width >= 480 && cm->height >= 360) ? BLOCK_128X128 |
| 364 | : BLOCK_64X64; |
| 365 | } |
| 366 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 367 | return BLOCK_128X128; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 368 | } |
| 369 | |
David Turner | 99e990e | 2018-12-10 12:54:26 +0000 | [diff] [blame] | 370 | static int get_current_frame_ref_type(const AV1_COMP *const cpi) { |
| 371 | const AV1_COMMON *const cm = &cpi->common; |
| 372 | const GF_GROUP *const gf_group = &cpi->twopass.gf_group; |
| 373 | // We choose the reference "type" of this frame from the flags which indicate |
| 374 | // which reference frames will be refreshed by it. More than one of these |
| 375 | // flags may be set, so the order here implies an order of precedence. |
| 376 | |
| 377 | if (frame_is_intra_only(cm) || cm->error_resilient_mode || |
| 378 | cm->force_primary_ref_none) |
| 379 | return REGULAR_FRAME; |
| 380 | else if (gf_group->update_type[gf_group->index] == INTNL_ARF_UPDATE) |
| 381 | return EXT_ARF_FRAME; |
| 382 | else if (cpi->refresh_alt_ref_frame) |
| 383 | return ARF_FRAME; |
| 384 | else if (cpi->rc.is_src_frame_alt_ref) |
| 385 | return OVERLAY_FRAME; |
| 386 | else if (cpi->refresh_golden_frame) |
| 387 | return GLD_FRAME; |
| 388 | else if (cpi->refresh_bwd_ref_frame) |
| 389 | return BRF_FRAME; |
| 390 | else |
| 391 | return REGULAR_FRAME; |
| 392 | } |
| 393 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 394 | static void setup_frame(AV1_COMP *cpi) { |
| 395 | AV1_COMMON *const cm = &cpi->common; |
Johann | b0ef6ff | 2018-02-08 14:32:21 -0800 | [diff] [blame] | 396 | // Set up entropy context depending on frame type. The decoder mandates |
| 397 | // the use of the default context, index 0, for keyframes and inter |
| 398 | // frames where the error_resilient_mode or intra_only flag is set. For |
| 399 | // other inter-frames the encoder currently uses only two contexts; |
| 400 | // context 1 for ALTREF frames and context 0 for the others. |
Soo-Chul Han | 85e8c79 | 2018-01-21 01:58:15 -0500 | [diff] [blame] | 401 | |
Thomas Daede | 51020e1 | 2017-12-14 20:12:44 -0800 | [diff] [blame] | 402 | cm->primary_ref_frame = PRIMARY_REF_NONE; |
Sarah Parker | 50b6d6e | 2018-04-11 19:21:54 -0700 | [diff] [blame] | 403 | if (frame_is_intra_only(cm) || cm->error_resilient_mode || |
| 404 | cm->force_primary_ref_none) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 405 | av1_setup_past_independence(cm); |
Thomas Daede | 51020e1 | 2017-12-14 20:12:44 -0800 | [diff] [blame] | 406 | for (int i = 0; i < REF_FRAMES; i++) { |
David Turner | 99e990e | 2018-12-10 12:54:26 +0000 | [diff] [blame] | 407 | cpi->fb_of_context_type[i] = -1; |
Thomas Daede | 51020e1 | 2017-12-14 20:12:44 -0800 | [diff] [blame] | 408 | } |
David Turner | 99e990e | 2018-12-10 12:54:26 +0000 | [diff] [blame] | 409 | cpi->fb_of_context_type[REGULAR_FRAME] = |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 410 | cm->show_frame ? get_ref_frame_map_idx(cm, GOLDEN_FRAME) |
| 411 | : get_ref_frame_map_idx(cm, ALTREF_FRAME); |
Yunqing Wang | 19aefd1 | 2018-05-14 15:38:57 -0700 | [diff] [blame] | 412 | } else { |
David Turner | 99e990e | 2018-12-10 12:54:26 +0000 | [diff] [blame] | 413 | int wanted_fb = cpi->fb_of_context_type[get_current_frame_ref_type(cpi)]; |
Thomas Daede | 51020e1 | 2017-12-14 20:12:44 -0800 | [diff] [blame] | 414 | for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) { |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 415 | int fb = get_ref_frame_map_idx(cm, ref_frame); |
Thomas Daede | 51020e1 | 2017-12-14 20:12:44 -0800 | [diff] [blame] | 416 | if (fb == wanted_fb) { |
| 417 | cm->primary_ref_frame = ref_frame - LAST_FRAME; |
| 418 | } |
| 419 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 420 | } |
| 421 | |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 422 | if (cm->current_frame.frame_type == KEY_FRAME && cm->show_frame) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 423 | cpi->refresh_golden_frame = 1; |
| 424 | cpi->refresh_alt_ref_frame = 1; |
Yunqing Wang | 9538e4d | 2019-01-07 18:28:08 +0000 | [diff] [blame] | 425 | av1_zero(cpi->interp_filter_selected); |
Imdad Sardharwalla | 4ec84ab | 2018-02-06 12:20:18 +0000 | [diff] [blame] | 426 | set_sb_size(&cm->seq_params, select_sb_size(cpi)); |
Tarek AMARA | c981385 | 2018-03-05 18:40:18 -0500 | [diff] [blame] | 427 | } else if (frame_is_sframe(cm)) { |
| 428 | cpi->refresh_golden_frame = 1; |
| 429 | cpi->refresh_alt_ref_frame = 1; |
Yunqing Wang | 9538e4d | 2019-01-07 18:28:08 +0000 | [diff] [blame] | 430 | av1_zero(cpi->interp_filter_selected); |
Tarek AMARA | c981385 | 2018-03-05 18:40:18 -0500 | [diff] [blame] | 431 | set_sb_size(&cm->seq_params, select_sb_size(cpi)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 432 | } else { |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 433 | const RefCntBuffer *const primary_ref_buf = get_primary_ref_frame_buf(cm); |
| 434 | if (primary_ref_buf == NULL) { |
David Barker | cc615a8 | 2018-03-19 14:38:51 +0000 | [diff] [blame] | 435 | av1_setup_past_independence(cm); |
| 436 | cm->seg.update_map = 1; |
| 437 | cm->seg.update_data = 1; |
Thomas Daede | da4d8b9 | 2017-06-05 15:44:14 -0700 | [diff] [blame] | 438 | } else { |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 439 | *cm->fc = primary_ref_buf->frame_context; |
Thomas Daede | da4d8b9 | 2017-06-05 15:44:14 -0700 | [diff] [blame] | 440 | } |
Yunqing Wang | 9538e4d | 2019-01-07 18:28:08 +0000 | [diff] [blame] | 441 | av1_zero(cpi->interp_filter_selected[0]); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 442 | } |
| 443 | |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 444 | cm->prev_frame = get_primary_ref_frame_buf(cm); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 445 | cpi->vaq_refresh = 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 446 | } |
| 447 | |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 448 | static void enc_setup_mi(AV1_COMMON *cm) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 449 | int i; |
Ravi Chaudhary | 75c4c5f | 2018-07-17 16:32:08 +0530 | [diff] [blame] | 450 | int mi_rows_sb_aligned = calc_mi_size(cm->mi_rows); |
Yunqing Wang | 19b9f72 | 2018-02-20 16:22:01 -0800 | [diff] [blame] | 451 | cm->mi = cm->mip; |
Ravi Chaudhary | 75c4c5f | 2018-07-17 16:32:08 +0530 | [diff] [blame] | 452 | memset(cm->mip, 0, cm->mi_stride * mi_rows_sb_aligned * sizeof(*cm->mip)); |
Yunqing Wang | 19b9f72 | 2018-02-20 16:22:01 -0800 | [diff] [blame] | 453 | cm->prev_mi = cm->prev_mip; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 454 | // Clear top border row |
| 455 | memset(cm->prev_mip, 0, sizeof(*cm->prev_mip) * cm->mi_stride); |
| 456 | // Clear left border column |
Ravi Chaudhary | 75c4c5f | 2018-07-17 16:32:08 +0530 | [diff] [blame] | 457 | for (i = 0; i < mi_rows_sb_aligned; ++i) |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 458 | memset(&cm->prev_mip[i * cm->mi_stride], 0, sizeof(*cm->prev_mip)); |
Yunqing Wang | 19b9f72 | 2018-02-20 16:22:01 -0800 | [diff] [blame] | 459 | cm->mi_grid_visible = cm->mi_grid_base; |
| 460 | cm->prev_mi_grid_visible = cm->prev_mi_grid_base; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 461 | |
| 462 | memset(cm->mi_grid_base, 0, |
Ravi Chaudhary | 75c4c5f | 2018-07-17 16:32:08 +0530 | [diff] [blame] | 463 | cm->mi_stride * mi_rows_sb_aligned * sizeof(*cm->mi_grid_base)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 464 | } |
| 465 | |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 466 | static int enc_alloc_mi(AV1_COMMON *cm, int mi_size) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 467 | cm->mip = aom_calloc(mi_size, sizeof(*cm->mip)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 468 | if (!cm->mip) return 1; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 469 | cm->prev_mip = aom_calloc(mi_size, sizeof(*cm->prev_mip)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 470 | if (!cm->prev_mip) return 1; |
| 471 | cm->mi_alloc_size = mi_size; |
| 472 | |
Yue Chen | 53b53f0 | 2018-03-29 14:31:23 -0700 | [diff] [blame] | 473 | cm->mi_grid_base = |
| 474 | (MB_MODE_INFO **)aom_calloc(mi_size, sizeof(MB_MODE_INFO *)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 475 | if (!cm->mi_grid_base) return 1; |
| 476 | cm->prev_mi_grid_base = |
Yue Chen | 53b53f0 | 2018-03-29 14:31:23 -0700 | [diff] [blame] | 477 | (MB_MODE_INFO **)aom_calloc(mi_size, sizeof(MB_MODE_INFO *)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 478 | if (!cm->prev_mi_grid_base) return 1; |
| 479 | |
| 480 | return 0; |
| 481 | } |
| 482 | |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 483 | static void enc_free_mi(AV1_COMMON *cm) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 484 | aom_free(cm->mip); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 485 | cm->mip = NULL; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 486 | aom_free(cm->prev_mip); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 487 | cm->prev_mip = NULL; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 488 | aom_free(cm->mi_grid_base); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 489 | cm->mi_grid_base = NULL; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 490 | aom_free(cm->prev_mi_grid_base); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 491 | cm->prev_mi_grid_base = NULL; |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 492 | cm->mi_alloc_size = 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 493 | } |
| 494 | |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 495 | static void swap_mi_and_prev_mi(AV1_COMMON *cm) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 496 | // Current mip will be the prev_mip for the next frame. |
Yue Chen | 53b53f0 | 2018-03-29 14:31:23 -0700 | [diff] [blame] | 497 | MB_MODE_INFO **temp_base = cm->prev_mi_grid_base; |
| 498 | MB_MODE_INFO *temp = cm->prev_mip; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 499 | cm->prev_mip = cm->mip; |
| 500 | cm->mip = temp; |
| 501 | |
| 502 | // Update the upper left visible macroblock ptrs. |
Yunqing Wang | 19b9f72 | 2018-02-20 16:22:01 -0800 | [diff] [blame] | 503 | cm->mi = cm->mip; |
| 504 | cm->prev_mi = cm->prev_mip; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 505 | |
| 506 | cm->prev_mi_grid_base = cm->mi_grid_base; |
| 507 | cm->mi_grid_base = temp_base; |
Yunqing Wang | 19b9f72 | 2018-02-20 16:22:01 -0800 | [diff] [blame] | 508 | cm->mi_grid_visible = cm->mi_grid_base; |
| 509 | cm->prev_mi_grid_visible = cm->prev_mi_grid_base; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 510 | } |
| 511 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 512 | void av1_initialize_enc(void) { |
Wan-Teh Chang | 3cac454 | 2018-06-29 10:21:39 -0700 | [diff] [blame] | 513 | av1_rtcd(); |
| 514 | aom_dsp_rtcd(); |
| 515 | aom_scale_rtcd(); |
| 516 | av1_init_intra_predictors(); |
| 517 | av1_init_me_luts(); |
| 518 | av1_rc_init_minq_luts(); |
| 519 | av1_init_wedge_masks(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 520 | } |
| 521 | |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 522 | static void dealloc_context_buffers_ext(AV1_COMP *cpi) { |
| 523 | if (cpi->mbmi_ext_base) { |
| 524 | aom_free(cpi->mbmi_ext_base); |
| 525 | cpi->mbmi_ext_base = NULL; |
| 526 | } |
| 527 | } |
| 528 | |
| 529 | static void alloc_context_buffers_ext(AV1_COMP *cpi) { |
| 530 | AV1_COMMON *cm = &cpi->common; |
| 531 | int mi_size = cm->mi_cols * cm->mi_rows; |
| 532 | |
| 533 | dealloc_context_buffers_ext(cpi); |
| 534 | CHECK_MEM_ERROR(cm, cpi->mbmi_ext_base, |
| 535 | aom_calloc(mi_size, sizeof(*cpi->mbmi_ext_base))); |
| 536 | } |
| 537 | |
Andrey Norkin | 6f1c2f7 | 2018-01-15 20:08:52 -0800 | [diff] [blame] | 538 | static void update_film_grain_parameters(struct AV1_COMP *cpi, |
| 539 | const AV1EncoderConfig *oxcf) { |
| 540 | AV1_COMMON *const cm = &cpi->common; |
| 541 | cpi->oxcf = *oxcf; |
| 542 | |
Neil Birkbeck | a2893ab | 2018-06-08 14:45:13 -0700 | [diff] [blame] | 543 | if (cpi->film_grain_table) { |
| 544 | aom_film_grain_table_free(cpi->film_grain_table); |
| 545 | aom_free(cpi->film_grain_table); |
| 546 | cpi->film_grain_table = NULL; |
Neil Birkbeck | eb895ef | 2018-03-14 17:51:03 -0700 | [diff] [blame] | 547 | } |
Neil Birkbeck | eb895ef | 2018-03-14 17:51:03 -0700 | [diff] [blame] | 548 | |
Andrey Norkin | 6f1c2f7 | 2018-01-15 20:08:52 -0800 | [diff] [blame] | 549 | if (oxcf->film_grain_test_vector) { |
Urvang Joshi | 8d5a4ba | 2018-07-19 16:26:34 -0700 | [diff] [blame] | 550 | cm->seq_params.film_grain_params_present = 1; |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 551 | if (cm->current_frame.frame_type == KEY_FRAME) { |
Andrey Norkin | 6f1c2f7 | 2018-01-15 20:08:52 -0800 | [diff] [blame] | 552 | memcpy(&cm->film_grain_params, |
| 553 | film_grain_test_vectors + oxcf->film_grain_test_vector - 1, |
| 554 | sizeof(cm->film_grain_params)); |
| 555 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 556 | cm->film_grain_params.bit_depth = cm->seq_params.bit_depth; |
| 557 | if (cm->seq_params.color_range == AOM_CR_FULL_RANGE) { |
Andrey Norkin | 6f1c2f7 | 2018-01-15 20:08:52 -0800 | [diff] [blame] | 558 | cm->film_grain_params.clip_to_restricted_range = 0; |
| 559 | } |
| 560 | } |
Neil Birkbeck | eb895ef | 2018-03-14 17:51:03 -0700 | [diff] [blame] | 561 | } else if (oxcf->film_grain_table_filename) { |
Neil Birkbeck | a2893ab | 2018-06-08 14:45:13 -0700 | [diff] [blame] | 562 | cpi->film_grain_table = aom_malloc(sizeof(*cpi->film_grain_table)); |
| 563 | memset(cpi->film_grain_table, 0, sizeof(aom_film_grain_table_t)); |
Neil Birkbeck | eb895ef | 2018-03-14 17:51:03 -0700 | [diff] [blame] | 564 | |
Neil Birkbeck | a2893ab | 2018-06-08 14:45:13 -0700 | [diff] [blame] | 565 | aom_film_grain_table_read(cpi->film_grain_table, |
Neil Birkbeck | eb895ef | 2018-03-14 17:51:03 -0700 | [diff] [blame] | 566 | oxcf->film_grain_table_filename, &cm->error); |
Andrey Norkin | 6f1c2f7 | 2018-01-15 20:08:52 -0800 | [diff] [blame] | 567 | } else { |
Urvang Joshi | 8d5a4ba | 2018-07-19 16:26:34 -0700 | [diff] [blame] | 568 | cm->seq_params.film_grain_params_present = 0; |
Andrey Norkin | 6f1c2f7 | 2018-01-15 20:08:52 -0800 | [diff] [blame] | 569 | memset(&cm->film_grain_params, 0, sizeof(cm->film_grain_params)); |
| 570 | } |
| 571 | } |
Andrey Norkin | 6f1c2f7 | 2018-01-15 20:08:52 -0800 | [diff] [blame] | 572 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 573 | static void dealloc_compressor_data(AV1_COMP *cpi) { |
| 574 | AV1_COMMON *const cm = &cpi->common; |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 575 | const int num_planes = av1_num_planes(cm); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 576 | |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 577 | dealloc_context_buffers_ext(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 578 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 579 | aom_free(cpi->tile_data); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 580 | cpi->tile_data = NULL; |
| 581 | |
| 582 | // Delete sementation map |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 583 | aom_free(cpi->segmentation_map); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 584 | cpi->segmentation_map = NULL; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 585 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 586 | av1_cyclic_refresh_free(cpi->cyclic_refresh); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 587 | cpi->cyclic_refresh = NULL; |
| 588 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 589 | aom_free(cpi->active_map.map); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 590 | cpi->active_map.map = NULL; |
| 591 | |
Jingning Han | d064cf0 | 2017-06-01 10:00:39 -0700 | [diff] [blame] | 592 | aom_free(cpi->td.mb.above_pred_buf); |
| 593 | cpi->td.mb.above_pred_buf = NULL; |
| 594 | |
| 595 | aom_free(cpi->td.mb.left_pred_buf); |
| 596 | cpi->td.mb.left_pred_buf = NULL; |
| 597 | |
| 598 | aom_free(cpi->td.mb.wsrc_buf); |
| 599 | cpi->td.mb.wsrc_buf = NULL; |
| 600 | |
Ravi Chaudhary | 5d970f4 | 2018-09-25 11:25:32 +0530 | [diff] [blame] | 601 | #if CONFIG_COLLECT_INTER_MODE_RD_STATS |
| 602 | aom_free(cpi->td.mb.inter_modes_info); |
| 603 | cpi->td.mb.inter_modes_info = NULL; |
| 604 | #endif |
| 605 | |
Ravi Chaudhary | 783d6a3 | 2018-08-28 18:21:02 +0530 | [diff] [blame] | 606 | for (int i = 0; i < 2; i++) |
| 607 | for (int j = 0; j < 2; j++) { |
| 608 | aom_free(cpi->td.mb.hash_value_buffer[i][j]); |
| 609 | cpi->td.mb.hash_value_buffer[i][j] = NULL; |
| 610 | } |
Jingning Han | d064cf0 | 2017-06-01 10:00:39 -0700 | [diff] [blame] | 611 | aom_free(cpi->td.mb.mask_buf); |
| 612 | cpi->td.mb.mask_buf = NULL; |
Jingning Han | d064cf0 | 2017-06-01 10:00:39 -0700 | [diff] [blame] | 613 | |
Jingning Han | 6cc1fd3 | 2017-10-13 09:05:36 -0700 | [diff] [blame] | 614 | aom_free(cm->tpl_mvs); |
| 615 | cm->tpl_mvs = NULL; |
Jingning Han | 6cc1fd3 | 2017-10-13 09:05:36 -0700 | [diff] [blame] | 616 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 617 | av1_free_ref_frame_buffers(cm->buffer_pool); |
Angie Chiang | f0fbf9d | 2017-03-15 15:01:22 -0700 | [diff] [blame] | 618 | av1_free_txb_buf(cpi); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 619 | av1_free_context_buffers(cm); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 620 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 621 | aom_free_frame_buffer(&cpi->last_frame_uf); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 622 | av1_free_restoration_buffers(cm); |
Debargha Mukherjee | 999d2f6 | 2016-12-15 13:23:21 -0800 | [diff] [blame] | 623 | aom_free_frame_buffer(&cpi->trial_frame_rst); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 624 | aom_free_frame_buffer(&cpi->scaled_source); |
| 625 | aom_free_frame_buffer(&cpi->scaled_last_source); |
| 626 | aom_free_frame_buffer(&cpi->alt_ref_buffer); |
| 627 | av1_lookahead_destroy(cpi->lookahead); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 628 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 629 | aom_free(cpi->tile_tok[0][0]); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 630 | cpi->tile_tok[0][0] = 0; |
| 631 | |
Ravi Chaudhary | 73cf15b | 2018-08-30 10:52:51 +0530 | [diff] [blame] | 632 | aom_free(cpi->tplist[0][0]); |
| 633 | cpi->tplist[0][0] = NULL; |
| 634 | |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 635 | av1_free_pc_tree(&cpi->td, num_planes); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 636 | |
hui su | d9a812b | 2017-07-06 14:34:37 -0700 | [diff] [blame] | 637 | aom_free(cpi->td.mb.palette_buffer); |
Neil Birkbeck | a2893ab | 2018-06-08 14:45:13 -0700 | [diff] [blame] | 638 | |
Urvang Joshi | 0a4cfad | 2018-09-07 11:10:39 -0700 | [diff] [blame] | 639 | aom_free(cpi->td.mb.tmp_conv_dst); |
| 640 | for (int j = 0; j < 2; ++j) { |
| 641 | aom_free(cpi->td.mb.tmp_obmc_bufs[j]); |
| 642 | } |
| 643 | |
Neil Birkbeck | a2893ab | 2018-06-08 14:45:13 -0700 | [diff] [blame] | 644 | #if CONFIG_DENOISE |
| 645 | if (cpi->denoise_and_model) { |
| 646 | aom_denoise_and_model_free(cpi->denoise_and_model); |
| 647 | cpi->denoise_and_model = NULL; |
| 648 | } |
| 649 | #endif |
| 650 | if (cpi->film_grain_table) { |
| 651 | aom_film_grain_table_free(cpi->film_grain_table); |
| 652 | cpi->film_grain_table = NULL; |
| 653 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 654 | } |
| 655 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 656 | static void save_coding_context(AV1_COMP *cpi) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 657 | CODING_CONTEXT *const cc = &cpi->coding_context; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 658 | AV1_COMMON *cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 659 | |
Sebastien Alaiwan | e140c50 | 2017-04-27 09:52:34 +0200 | [diff] [blame] | 660 | // Stores a snapshot of key state variables which can subsequently be |
| 661 | // restored with a call to av1_restore_coding_context. These functions are |
| 662 | // intended for use in a re-code loop in av1_compress_frame where the |
| 663 | // quantizer value is adjusted between loop iterations. |
Jingning Han | f050fc1 | 2018-03-09 14:53:33 -0800 | [diff] [blame] | 664 | av1_copy(cc->nmv_vec_cost, cpi->td.mb.nmv_vec_cost); |
| 665 | av1_copy(cc->nmv_costs, cpi->nmv_costs); |
| 666 | av1_copy(cc->nmv_costs_hp, cpi->nmv_costs_hp); |
James Zern | 01a9d70 | 2017-08-25 19:09:33 +0000 | [diff] [blame] | 667 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 668 | cc->fc = *cm->fc; |
| 669 | } |
| 670 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 671 | static void restore_coding_context(AV1_COMP *cpi) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 672 | CODING_CONTEXT *const cc = &cpi->coding_context; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 673 | AV1_COMMON *cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 674 | |
Sebastien Alaiwan | e140c50 | 2017-04-27 09:52:34 +0200 | [diff] [blame] | 675 | // Restore key state variables to the snapshot state stored in the |
| 676 | // previous call to av1_save_coding_context. |
Jingning Han | f050fc1 | 2018-03-09 14:53:33 -0800 | [diff] [blame] | 677 | av1_copy(cpi->td.mb.nmv_vec_cost, cc->nmv_vec_cost); |
| 678 | av1_copy(cpi->nmv_costs, cc->nmv_costs); |
| 679 | av1_copy(cpi->nmv_costs_hp, cc->nmv_costs_hp); |
James Zern | 01a9d70 | 2017-08-25 19:09:33 +0000 | [diff] [blame] | 680 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 681 | *cm->fc = cc->fc; |
| 682 | } |
| 683 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 684 | static void configure_static_seg_features(AV1_COMP *cpi) { |
| 685 | AV1_COMMON *const cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 686 | const RATE_CONTROL *const rc = &cpi->rc; |
| 687 | struct segmentation *const seg = &cm->seg; |
| 688 | |
| 689 | int high_q = (int)(rc->avg_q > 48.0); |
| 690 | int qi_delta; |
| 691 | |
| 692 | // Disable and clear down for KF |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 693 | if (cm->current_frame.frame_type == KEY_FRAME) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 694 | // Clear down the global segmentation map |
| 695 | memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols); |
| 696 | seg->update_map = 0; |
| 697 | seg->update_data = 0; |
| 698 | cpi->static_mb_pct = 0; |
| 699 | |
| 700 | // Disable segmentation |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 701 | av1_disable_segmentation(seg); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 702 | |
| 703 | // Clear down the segment features. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 704 | av1_clearall_segfeatures(seg); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 705 | } else if (cpi->refresh_alt_ref_frame) { |
| 706 | // If this is an alt ref frame |
| 707 | // Clear down the global segmentation map |
| 708 | memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols); |
| 709 | seg->update_map = 0; |
| 710 | seg->update_data = 0; |
| 711 | cpi->static_mb_pct = 0; |
| 712 | |
| 713 | // Disable segmentation and individual segment features by default |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 714 | av1_disable_segmentation(seg); |
| 715 | av1_clearall_segfeatures(seg); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 716 | |
| 717 | // Scan frames from current to arf frame. |
| 718 | // This function re-enables segmentation if appropriate. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 719 | av1_update_mbgraph_stats(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 720 | |
| 721 | // If segmentation was enabled set those features needed for the |
| 722 | // arf itself. |
| 723 | if (seg->enabled) { |
| 724 | seg->update_map = 1; |
| 725 | seg->update_data = 1; |
| 726 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 727 | qi_delta = av1_compute_qdelta(rc, rc->avg_q, rc->avg_q * 0.875, |
| 728 | cm->seq_params.bit_depth); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 729 | av1_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta - 2); |
Cheng Chen | d8184da | 2017-09-26 18:15:22 -0700 | [diff] [blame] | 730 | av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_Y_H, -2); |
| 731 | av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_Y_V, -2); |
| 732 | av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_U, -2); |
| 733 | av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_V, -2); |
| 734 | |
| 735 | av1_enable_segfeature(seg, 1, SEG_LVL_ALT_LF_Y_H); |
| 736 | av1_enable_segfeature(seg, 1, SEG_LVL_ALT_LF_Y_V); |
| 737 | av1_enable_segfeature(seg, 1, SEG_LVL_ALT_LF_U); |
| 738 | av1_enable_segfeature(seg, 1, SEG_LVL_ALT_LF_V); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 739 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 740 | av1_enable_segfeature(seg, 1, SEG_LVL_ALT_Q); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 741 | } |
| 742 | } else if (seg->enabled) { |
| 743 | // All other frames if segmentation has been enabled |
| 744 | |
| 745 | // First normal frame in a valid gf or alt ref group |
| 746 | if (rc->frames_since_golden == 0) { |
| 747 | // Set up segment features for normal frames in an arf group |
| 748 | if (rc->source_alt_ref_active) { |
| 749 | seg->update_map = 0; |
| 750 | seg->update_data = 1; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 751 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 752 | qi_delta = av1_compute_qdelta(rc, rc->avg_q, rc->avg_q * 1.125, |
| 753 | cm->seq_params.bit_depth); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 754 | av1_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta + 2); |
| 755 | av1_enable_segfeature(seg, 1, SEG_LVL_ALT_Q); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 756 | |
Cheng Chen | d8184da | 2017-09-26 18:15:22 -0700 | [diff] [blame] | 757 | av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_Y_H, -2); |
| 758 | av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_Y_V, -2); |
| 759 | av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_U, -2); |
| 760 | av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_V, -2); |
| 761 | |
| 762 | av1_enable_segfeature(seg, 1, SEG_LVL_ALT_LF_Y_H); |
| 763 | av1_enable_segfeature(seg, 1, SEG_LVL_ALT_LF_Y_V); |
| 764 | av1_enable_segfeature(seg, 1, SEG_LVL_ALT_LF_U); |
| 765 | av1_enable_segfeature(seg, 1, SEG_LVL_ALT_LF_V); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 766 | |
| 767 | // Segment coding disabled for compred testing |
| 768 | if (high_q || (cpi->static_mb_pct == 100)) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 769 | av1_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME); |
| 770 | av1_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME); |
| 771 | av1_enable_segfeature(seg, 1, SEG_LVL_SKIP); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 772 | } |
| 773 | } else { |
| 774 | // Disable segmentation and clear down features if alt ref |
| 775 | // is not active for this group |
| 776 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 777 | av1_disable_segmentation(seg); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 778 | |
| 779 | memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols); |
| 780 | |
| 781 | seg->update_map = 0; |
| 782 | seg->update_data = 0; |
| 783 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 784 | av1_clearall_segfeatures(seg); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 785 | } |
| 786 | } else if (rc->is_src_frame_alt_ref) { |
| 787 | // Special case where we are coding over the top of a previous |
| 788 | // alt ref frame. |
| 789 | // Segment coding disabled for compred testing |
| 790 | |
| 791 | // Enable ref frame features for segment 0 as well |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 792 | av1_enable_segfeature(seg, 0, SEG_LVL_REF_FRAME); |
| 793 | av1_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 794 | |
| 795 | // All mbs should use ALTREF_FRAME |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 796 | av1_clear_segdata(seg, 0, SEG_LVL_REF_FRAME); |
| 797 | av1_set_segdata(seg, 0, SEG_LVL_REF_FRAME, ALTREF_FRAME); |
| 798 | av1_clear_segdata(seg, 1, SEG_LVL_REF_FRAME); |
| 799 | av1_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 800 | |
| 801 | // Skip all MBs if high Q (0,0 mv and skip coeffs) |
| 802 | if (high_q) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 803 | av1_enable_segfeature(seg, 0, SEG_LVL_SKIP); |
| 804 | av1_enable_segfeature(seg, 1, SEG_LVL_SKIP); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 805 | } |
| 806 | // Enable data update |
| 807 | seg->update_data = 1; |
| 808 | } else { |
| 809 | // All other frames. |
| 810 | |
| 811 | // No updates.. leave things as they are. |
| 812 | seg->update_map = 0; |
| 813 | seg->update_data = 0; |
| 814 | } |
| 815 | } |
| 816 | } |
| 817 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 818 | static void update_reference_segmentation_map(AV1_COMP *cpi) { |
| 819 | AV1_COMMON *const cm = &cpi->common; |
Yushin Cho | a7f6592 | 2018-04-04 16:06:11 -0700 | [diff] [blame] | 820 | MB_MODE_INFO **mi_4x4_ptr = cm->mi_grid_visible; |
David Turner | b757ce0 | 2018-11-12 15:01:28 +0000 | [diff] [blame] | 821 | uint8_t *cache_ptr = cm->cur_frame->seg_map; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 822 | int row, col; |
| 823 | |
| 824 | for (row = 0; row < cm->mi_rows; row++) { |
Yushin Cho | a7f6592 | 2018-04-04 16:06:11 -0700 | [diff] [blame] | 825 | MB_MODE_INFO **mi_4x4 = mi_4x4_ptr; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 826 | uint8_t *cache = cache_ptr; |
Yushin Cho | a7f6592 | 2018-04-04 16:06:11 -0700 | [diff] [blame] | 827 | for (col = 0; col < cm->mi_cols; col++, mi_4x4++, cache++) |
| 828 | cache[0] = mi_4x4[0]->segment_id; |
| 829 | mi_4x4_ptr += cm->mi_stride; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 830 | cache_ptr += cm->mi_cols; |
| 831 | } |
| 832 | } |
| 833 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 834 | static void alloc_raw_frame_buffers(AV1_COMP *cpi) { |
| 835 | AV1_COMMON *cm = &cpi->common; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 836 | const SequenceHeader *const seq_params = &cm->seq_params; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 837 | const AV1EncoderConfig *oxcf = &cpi->oxcf; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 838 | |
| 839 | if (!cpi->lookahead) |
Satish Kumar Suman | 2990996 | 2019-01-09 10:31:21 +0530 | [diff] [blame] | 840 | cpi->lookahead = av1_lookahead_init( |
| 841 | oxcf->width, oxcf->height, seq_params->subsampling_x, |
| 842 | seq_params->subsampling_y, seq_params->use_highbitdepth, |
| 843 | oxcf->lag_in_frames, oxcf->border_in_pixels); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 844 | if (!cpi->lookahead) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 845 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 846 | "Failed to allocate lag buffers"); |
| 847 | |
| 848 | // TODO(agrange) Check if ARF is enabled and skip allocation if not. |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 849 | if (aom_realloc_frame_buffer( |
| 850 | &cpi->alt_ref_buffer, oxcf->width, oxcf->height, |
| 851 | seq_params->subsampling_x, seq_params->subsampling_y, |
Satish Kumar Suman | 2990996 | 2019-01-09 10:31:21 +0530 | [diff] [blame] | 852 | seq_params->use_highbitdepth, oxcf->border_in_pixels, |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 853 | cm->byte_alignment, NULL, NULL, NULL)) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 854 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 855 | "Failed to allocate altref buffer"); |
| 856 | } |
| 857 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 858 | static void alloc_util_frame_buffers(AV1_COMP *cpi) { |
| 859 | AV1_COMMON *const cm = &cpi->common; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 860 | const SequenceHeader *const seq_params = &cm->seq_params; |
| 861 | if (aom_realloc_frame_buffer( |
| 862 | &cpi->last_frame_uf, cm->width, cm->height, seq_params->subsampling_x, |
| 863 | seq_params->subsampling_y, seq_params->use_highbitdepth, |
Satish Kumar Suman | 2990996 | 2019-01-09 10:31:21 +0530 | [diff] [blame] | 864 | cpi->oxcf.border_in_pixels, cm->byte_alignment, NULL, NULL, NULL)) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 865 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 866 | "Failed to allocate last frame buffer"); |
| 867 | |
Fergus Simpson | 9cd57cf | 2017-06-12 17:02:03 -0700 | [diff] [blame] | 868 | if (aom_realloc_frame_buffer( |
Debargha Mukherjee | 3a4959f | 2018-02-26 15:34:03 -0800 | [diff] [blame] | 869 | &cpi->trial_frame_rst, cm->superres_upscaled_width, |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 870 | cm->superres_upscaled_height, seq_params->subsampling_x, |
| 871 | seq_params->subsampling_y, seq_params->use_highbitdepth, |
Satish Kumar Suman | 3b12c00 | 2018-12-19 15:27:20 +0530 | [diff] [blame] | 872 | AOM_RESTORATION_FRAME_BORDER, cm->byte_alignment, NULL, NULL, NULL)) |
Debargha Mukherjee | 874d36d | 2016-12-14 16:53:17 -0800 | [diff] [blame] | 873 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
Debargha Mukherjee | 999d2f6 | 2016-12-15 13:23:21 -0800 | [diff] [blame] | 874 | "Failed to allocate trial restored frame buffer"); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 875 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 876 | if (aom_realloc_frame_buffer( |
| 877 | &cpi->scaled_source, cm->width, cm->height, seq_params->subsampling_x, |
| 878 | seq_params->subsampling_y, seq_params->use_highbitdepth, |
Satish Kumar Suman | 2990996 | 2019-01-09 10:31:21 +0530 | [diff] [blame] | 879 | cpi->oxcf.border_in_pixels, cm->byte_alignment, NULL, NULL, NULL)) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 880 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 881 | "Failed to allocate scaled source buffer"); |
| 882 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 883 | if (aom_realloc_frame_buffer( |
| 884 | &cpi->scaled_last_source, cm->width, cm->height, |
| 885 | seq_params->subsampling_x, seq_params->subsampling_y, |
Satish Kumar Suman | 2990996 | 2019-01-09 10:31:21 +0530 | [diff] [blame] | 886 | seq_params->use_highbitdepth, cpi->oxcf.border_in_pixels, |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 887 | cm->byte_alignment, NULL, NULL, NULL)) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 888 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 889 | "Failed to allocate scaled last source buffer"); |
| 890 | } |
| 891 | |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 892 | static void alloc_compressor_data(AV1_COMP *cpi) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 893 | AV1_COMMON *cm = &cpi->common; |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 894 | const int num_planes = av1_num_planes(cm); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 895 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 896 | av1_alloc_context_buffers(cm, cm->width, cm->height); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 897 | |
Ravi Chaudhary | 73cf15b | 2018-08-30 10:52:51 +0530 | [diff] [blame] | 898 | int mi_rows_aligned_to_sb = |
| 899 | ALIGN_POWER_OF_TWO(cm->mi_rows, cm->seq_params.mib_size_log2); |
| 900 | int sb_rows = mi_rows_aligned_to_sb >> cm->seq_params.mib_size_log2; |
| 901 | |
Angie Chiang | f0fbf9d | 2017-03-15 15:01:22 -0700 | [diff] [blame] | 902 | av1_alloc_txb_buf(cpi); |
Angie Chiang | f0fbf9d | 2017-03-15 15:01:22 -0700 | [diff] [blame] | 903 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 904 | alloc_context_buffers_ext(cpi); |
| 905 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 906 | aom_free(cpi->tile_tok[0][0]); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 907 | |
| 908 | { |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 909 | unsigned int tokens = |
| 910 | get_token_alloc(cm->mb_rows, cm->mb_cols, MAX_SB_SIZE_LOG2, num_planes); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 911 | CHECK_MEM_ERROR(cm, cpi->tile_tok[0][0], |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 912 | aom_calloc(tokens, sizeof(*cpi->tile_tok[0][0]))); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 913 | } |
Ravi Chaudhary | 73cf15b | 2018-08-30 10:52:51 +0530 | [diff] [blame] | 914 | aom_free(cpi->tplist[0][0]); |
| 915 | |
| 916 | CHECK_MEM_ERROR(cm, cpi->tplist[0][0], |
| 917 | aom_calloc(sb_rows * MAX_TILE_ROWS * MAX_TILE_COLS, |
| 918 | sizeof(*cpi->tplist[0][0]))); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 919 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 920 | av1_setup_pc_tree(&cpi->common, &cpi->td); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 921 | } |
| 922 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 923 | void av1_new_framerate(AV1_COMP *cpi, double framerate) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 924 | cpi->framerate = framerate < 0.1 ? 30 : framerate; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 925 | av1_rc_update_framerate(cpi, cpi->common.width, cpi->common.height); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 926 | } |
| 927 | |
Yunqing Wang | 75e20e8 | 2018-06-16 12:10:48 -0700 | [diff] [blame] | 928 | static void set_tile_info(AV1_COMP *cpi) { |
Dominic Symes | db5d66f | 2017-08-18 18:11:34 +0200 | [diff] [blame] | 929 | AV1_COMMON *const cm = &cpi->common; |
Dominic Symes | f58f111 | 2017-09-25 12:47:40 +0200 | [diff] [blame] | 930 | int i, start_sb; |
Dominic Symes | db5d66f | 2017-08-18 18:11:34 +0200 | [diff] [blame] | 931 | |
| 932 | av1_get_tile_limits(cm); |
Dominic Symes | db5d66f | 2017-08-18 18:11:34 +0200 | [diff] [blame] | 933 | |
| 934 | // configure tile columns |
Dominic Symes | 26ad0b2 | 2017-10-01 16:35:13 +0200 | [diff] [blame] | 935 | if (cpi->oxcf.tile_width_count == 0 || cpi->oxcf.tile_height_count == 0) { |
Dominic Symes | f58f111 | 2017-09-25 12:47:40 +0200 | [diff] [blame] | 936 | cm->uniform_tile_spacing_flag = 1; |
Dominic Symes | db5d66f | 2017-08-18 18:11:34 +0200 | [diff] [blame] | 937 | cm->log2_tile_cols = AOMMAX(cpi->oxcf.tile_columns, cm->min_log2_tile_cols); |
| 938 | cm->log2_tile_cols = AOMMIN(cm->log2_tile_cols, cm->max_log2_tile_cols); |
Dominic Symes | f58f111 | 2017-09-25 12:47:40 +0200 | [diff] [blame] | 939 | } else { |
Imdad Sardharwalla | 4ec84ab | 2018-02-06 12:20:18 +0000 | [diff] [blame] | 940 | int mi_cols = ALIGN_POWER_OF_TWO(cm->mi_cols, cm->seq_params.mib_size_log2); |
| 941 | int sb_cols = mi_cols >> cm->seq_params.mib_size_log2; |
Dominic Symes | 26ad0b2 | 2017-10-01 16:35:13 +0200 | [diff] [blame] | 942 | int size_sb, j = 0; |
Dominic Symes | f58f111 | 2017-09-25 12:47:40 +0200 | [diff] [blame] | 943 | cm->uniform_tile_spacing_flag = 0; |
| 944 | for (i = 0, start_sb = 0; start_sb < sb_cols && i < MAX_TILE_COLS; i++) { |
| 945 | cm->tile_col_start_sb[i] = start_sb; |
Dominic Symes | 26ad0b2 | 2017-10-01 16:35:13 +0200 | [diff] [blame] | 946 | size_sb = cpi->oxcf.tile_widths[j++]; |
| 947 | if (j >= cpi->oxcf.tile_width_count) j = 0; |
David Barker | 6cd5a82 | 2018-03-05 16:19:28 +0000 | [diff] [blame] | 948 | start_sb += AOMMIN(size_sb, cm->max_tile_width_sb); |
Dominic Symes | f58f111 | 2017-09-25 12:47:40 +0200 | [diff] [blame] | 949 | } |
| 950 | cm->tile_cols = i; |
| 951 | cm->tile_col_start_sb[i] = sb_cols; |
Dominic Symes | db5d66f | 2017-08-18 18:11:34 +0200 | [diff] [blame] | 952 | } |
| 953 | av1_calculate_tile_cols(cm); |
| 954 | |
| 955 | // configure tile rows |
| 956 | if (cm->uniform_tile_spacing_flag) { |
| 957 | cm->log2_tile_rows = AOMMAX(cpi->oxcf.tile_rows, cm->min_log2_tile_rows); |
| 958 | cm->log2_tile_rows = AOMMIN(cm->log2_tile_rows, cm->max_log2_tile_rows); |
Dominic Symes | f58f111 | 2017-09-25 12:47:40 +0200 | [diff] [blame] | 959 | } else { |
Imdad Sardharwalla | 4ec84ab | 2018-02-06 12:20:18 +0000 | [diff] [blame] | 960 | int mi_rows = ALIGN_POWER_OF_TWO(cm->mi_rows, cm->seq_params.mib_size_log2); |
| 961 | int sb_rows = mi_rows >> cm->seq_params.mib_size_log2; |
Dominic Symes | 26ad0b2 | 2017-10-01 16:35:13 +0200 | [diff] [blame] | 962 | int size_sb, j = 0; |
Dominic Symes | f58f111 | 2017-09-25 12:47:40 +0200 | [diff] [blame] | 963 | for (i = 0, start_sb = 0; start_sb < sb_rows && i < MAX_TILE_ROWS; i++) { |
| 964 | cm->tile_row_start_sb[i] = start_sb; |
Dominic Symes | 26ad0b2 | 2017-10-01 16:35:13 +0200 | [diff] [blame] | 965 | size_sb = cpi->oxcf.tile_heights[j++]; |
| 966 | if (j >= cpi->oxcf.tile_height_count) j = 0; |
| 967 | start_sb += AOMMIN(size_sb, cm->max_tile_height_sb); |
Dominic Symes | f58f111 | 2017-09-25 12:47:40 +0200 | [diff] [blame] | 968 | } |
| 969 | cm->tile_rows = i; |
| 970 | cm->tile_row_start_sb[i] = sb_rows; |
Dominic Symes | db5d66f | 2017-08-18 18:11:34 +0200 | [diff] [blame] | 971 | } |
| 972 | av1_calculate_tile_rows(cm); |
| 973 | } |
| 974 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 975 | static void update_frame_size(AV1_COMP *cpi) { |
| 976 | AV1_COMMON *const cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 977 | MACROBLOCKD *const xd = &cpi->td.mb.e_mbd; |
| 978 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 979 | av1_set_mb_mi(cm, cm->width, cm->height); |
| 980 | av1_init_context_buffers(cm); |
Luc Trudeau | 1e84af5 | 2017-11-25 15:00:28 -0500 | [diff] [blame] | 981 | av1_init_macroblockd(cm, xd, NULL); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 982 | memset(cpi->mbmi_ext_base, 0, |
| 983 | cm->mi_rows * cm->mi_cols * sizeof(*cpi->mbmi_ext_base)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 984 | set_tile_info(cpi); |
| 985 | } |
| 986 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 987 | static void init_buffer_indices(AV1_COMP *cpi) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 988 | int fb_idx; |
Zoe Liu | 5989a72 | 2018-03-29 13:37:36 -0700 | [diff] [blame] | 989 | for (fb_idx = 0; fb_idx < REF_FRAMES; ++fb_idx) |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 990 | cpi->common.remapped_ref_idx[fb_idx] = fb_idx; |
RogerZhou | 3b63524 | 2017-09-19 10:06:46 -0700 | [diff] [blame] | 991 | cpi->rate_index = 0; |
| 992 | cpi->rate_size = 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 993 | } |
| 994 | |
Debargha Mukherjee | 5749869 | 2018-05-11 13:29:31 -0700 | [diff] [blame] | 995 | static INLINE int does_level_match(int width, int height, double fps, |
| 996 | int lvl_width, int lvl_height, |
| 997 | double lvl_fps, int lvl_dim_mult) { |
| 998 | const int64_t lvl_luma_pels = lvl_width * lvl_height; |
| 999 | const double lvl_display_sample_rate = lvl_luma_pels * lvl_fps; |
| 1000 | const int64_t luma_pels = width * height; |
| 1001 | const double display_sample_rate = luma_pels * fps; |
| 1002 | return luma_pels <= lvl_luma_pels && |
| 1003 | display_sample_rate <= lvl_display_sample_rate && |
| 1004 | width <= lvl_width * lvl_dim_mult && |
| 1005 | height <= lvl_height * lvl_dim_mult; |
| 1006 | } |
| 1007 | |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 1008 | static void set_bitstream_level_tier(SequenceHeader *seq, AV1_COMMON *cm, |
Andrey Norkin | f481d98 | 2018-05-15 12:05:31 -0700 | [diff] [blame] | 1009 | const AV1EncoderConfig *oxcf) { |
Debargha Mukherjee | 5749869 | 2018-05-11 13:29:31 -0700 | [diff] [blame] | 1010 | // TODO(any): This is a placeholder function that only addresses dimensions |
| 1011 | // and max display sample rates. |
| 1012 | // Need to add checks for max bit rate, max decoded luma sample rate, header |
| 1013 | // rate, etc. that are not covered by this function. |
Debargha Mukherjee | ea67540 | 2018-05-10 16:10:41 -0700 | [diff] [blame] | 1014 | (void)oxcf; |
Debargha Mukherjee | 5749869 | 2018-05-11 13:29:31 -0700 | [diff] [blame] | 1015 | BitstreamLevel bl = { 9, 3 }; |
| 1016 | if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate, 512, |
| 1017 | 288, 30.0, 4)) { |
| 1018 | bl.major = 2; |
| 1019 | bl.minor = 0; |
| 1020 | } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate, |
| 1021 | 704, 396, 30.0, 4)) { |
| 1022 | bl.major = 2; |
| 1023 | bl.minor = 1; |
| 1024 | } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate, |
| 1025 | 1088, 612, 30.0, 4)) { |
| 1026 | bl.major = 3; |
| 1027 | bl.minor = 0; |
| 1028 | } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate, |
| 1029 | 1376, 774, 30.0, 4)) { |
| 1030 | bl.major = 3; |
| 1031 | bl.minor = 1; |
| 1032 | } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate, |
| 1033 | 2048, 1152, 30.0, 3)) { |
| 1034 | bl.major = 4; |
| 1035 | bl.minor = 0; |
| 1036 | } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate, |
| 1037 | 2048, 1152, 60.0, 3)) { |
| 1038 | bl.major = 4; |
| 1039 | bl.minor = 1; |
| 1040 | } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate, |
| 1041 | 4096, 2176, 30.0, 2)) { |
| 1042 | bl.major = 5; |
| 1043 | bl.minor = 0; |
| 1044 | } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate, |
| 1045 | 4096, 2176, 60.0, 2)) { |
| 1046 | bl.major = 5; |
| 1047 | bl.minor = 1; |
| 1048 | } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate, |
| 1049 | 4096, 2176, 120.0, 2)) { |
| 1050 | bl.major = 5; |
| 1051 | bl.minor = 2; |
| 1052 | } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate, |
| 1053 | 8192, 4352, 30.0, 2)) { |
| 1054 | bl.major = 6; |
| 1055 | bl.minor = 0; |
| 1056 | } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate, |
| 1057 | 8192, 4352, 60.0, 2)) { |
| 1058 | bl.major = 6; |
| 1059 | bl.minor = 1; |
| 1060 | } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate, |
| 1061 | 8192, 4352, 120.0, 2)) { |
| 1062 | bl.major = 6; |
| 1063 | bl.minor = 2; |
| 1064 | } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate, |
| 1065 | 16384, 8704, 30.0, 2)) { |
| 1066 | bl.major = 7; |
| 1067 | bl.minor = 0; |
| 1068 | } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate, |
| 1069 | 16384, 8704, 60.0, 2)) { |
| 1070 | bl.major = 7; |
| 1071 | bl.minor = 1; |
| 1072 | } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate, |
| 1073 | 16384, 8704, 120.0, 2)) { |
| 1074 | bl.major = 7; |
| 1075 | bl.minor = 2; |
| 1076 | } |
Debargha Mukherjee | ea67540 | 2018-05-10 16:10:41 -0700 | [diff] [blame] | 1077 | for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i) { |
Debargha Mukherjee | 5749869 | 2018-05-11 13:29:31 -0700 | [diff] [blame] | 1078 | seq->level[i] = bl; |
Andrey Norkin | f481d98 | 2018-05-15 12:05:31 -0700 | [diff] [blame] | 1079 | seq->tier[i] = 0; // setting main tier by default |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 1080 | // Set the maximum parameters for bitrate and buffer size for this profile, |
| 1081 | // level, and tier |
| 1082 | cm->op_params[i].bitrate = max_level_bitrate( |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 1083 | cm->seq_params.profile, major_minor_to_seq_level_idx(seq->level[i]), |
| 1084 | seq->tier[i]); |
Andrey Norkin | c7511de | 2018-06-22 12:31:06 -0700 | [diff] [blame] | 1085 | // Level with seq_level_idx = 31 returns a high "dummy" bitrate to pass the |
| 1086 | // check |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 1087 | if (cm->op_params[i].bitrate == 0) |
| 1088 | aom_internal_error( |
| 1089 | &cm->error, AOM_CODEC_UNSUP_BITSTREAM, |
| 1090 | "AV1 does not support this combination of profile, level, and tier."); |
Andrey Norkin | c7511de | 2018-06-22 12:31:06 -0700 | [diff] [blame] | 1091 | // Buffer size in bits/s is bitrate in bits/s * 1 s |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 1092 | cm->op_params[i].buffer_size = cm->op_params[i].bitrate; |
Debargha Mukherjee | ea67540 | 2018-05-10 16:10:41 -0700 | [diff] [blame] | 1093 | } |
| 1094 | } |
| 1095 | |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 1096 | static void init_seq_coding_tools(SequenceHeader *seq, AV1_COMMON *cm, |
| 1097 | const AV1EncoderConfig *oxcf) { |
Debargha Mukherjee | c6f24c2 | 2018-04-07 08:43:08 -0700 | [diff] [blame] | 1098 | seq->still_picture = (oxcf->limit == 1); |
| 1099 | seq->reduced_still_picture_hdr = seq->still_picture; |
Debargha Mukherjee | 9713ccb | 2018-04-08 19:09:17 -0700 | [diff] [blame] | 1100 | seq->reduced_still_picture_hdr &= !oxcf->full_still_picture_hdr; |
Debargha Mukherjee | edd7725 | 2018-03-25 12:01:38 -0700 | [diff] [blame] | 1101 | seq->force_screen_content_tools = 2; |
Debargha Mukherjee | edd7725 | 2018-03-25 12:01:38 -0700 | [diff] [blame] | 1102 | seq->force_integer_mv = 2; |
David Turner | ebf96f4 | 2018-11-14 16:57:57 +0000 | [diff] [blame] | 1103 | seq->order_hint_info.enable_order_hint = oxcf->enable_order_hint; |
David Turner | 936235c | 2018-11-28 13:42:01 +0000 | [diff] [blame] | 1104 | seq->frame_id_numbers_present_flag = |
| 1105 | !(seq->still_picture && seq->reduced_still_picture_hdr) && |
| 1106 | !oxcf->large_scale_tile && oxcf->error_resilient_mode; |
Debargha Mukherjee | c6f24c2 | 2018-04-07 08:43:08 -0700 | [diff] [blame] | 1107 | if (seq->still_picture && seq->reduced_still_picture_hdr) { |
David Turner | ebf96f4 | 2018-11-14 16:57:57 +0000 | [diff] [blame] | 1108 | seq->order_hint_info.enable_order_hint = 0; |
Debargha Mukherjee | c6f24c2 | 2018-04-07 08:43:08 -0700 | [diff] [blame] | 1109 | seq->force_screen_content_tools = 2; |
| 1110 | seq->force_integer_mv = 2; |
| 1111 | } |
David Turner | ebf96f4 | 2018-11-14 16:57:57 +0000 | [diff] [blame] | 1112 | seq->order_hint_info.order_hint_bits_minus_1 = |
| 1113 | seq->order_hint_info.enable_order_hint |
| 1114 | ? DEFAULT_EXPLICIT_ORDER_HINT_BITS - 1 |
| 1115 | : -1; |
Debargha Mukherjee | c6f24c2 | 2018-04-07 08:43:08 -0700 | [diff] [blame] | 1116 | |
David Turner | 760a2f4 | 2018-12-07 15:25:36 +0000 | [diff] [blame] | 1117 | seq->max_frame_width = |
| 1118 | oxcf->forced_max_frame_width ? oxcf->forced_max_frame_width : oxcf->width; |
| 1119 | seq->max_frame_height = oxcf->forced_max_frame_height |
| 1120 | ? oxcf->forced_max_frame_height |
| 1121 | : oxcf->height; |
| 1122 | seq->num_bits_width = |
| 1123 | (seq->max_frame_width > 1) ? get_msb(seq->max_frame_width - 1) + 1 : 1; |
| 1124 | seq->num_bits_height = |
| 1125 | (seq->max_frame_height > 1) ? get_msb(seq->max_frame_height - 1) + 1 : 1; |
| 1126 | assert(seq->num_bits_width <= 16); |
| 1127 | assert(seq->num_bits_height <= 16); |
| 1128 | |
| 1129 | seq->frame_id_length = FRAME_ID_LENGTH; |
| 1130 | seq->delta_frame_id_length = DELTA_FRAME_ID_LENGTH; |
| 1131 | |
Debargha Mukherjee | c6f24c2 | 2018-04-07 08:43:08 -0700 | [diff] [blame] | 1132 | seq->enable_dual_filter = oxcf->enable_dual_filter; |
Debargha Mukherjee | 7ac3eb1 | 2018-12-12 10:26:50 -0800 | [diff] [blame] | 1133 | seq->order_hint_info.enable_dist_wtd_comp = oxcf->enable_dist_wtd_comp; |
| 1134 | seq->order_hint_info.enable_dist_wtd_comp &= |
David Turner | ebf96f4 | 2018-11-14 16:57:57 +0000 | [diff] [blame] | 1135 | seq->order_hint_info.enable_order_hint; |
| 1136 | seq->order_hint_info.enable_ref_frame_mvs = oxcf->enable_ref_frame_mvs; |
| 1137 | seq->order_hint_info.enable_ref_frame_mvs &= |
| 1138 | seq->order_hint_info.enable_order_hint; |
Debargha Mukherjee | edd7725 | 2018-03-25 12:01:38 -0700 | [diff] [blame] | 1139 | seq->enable_superres = oxcf->enable_superres; |
| 1140 | seq->enable_cdef = oxcf->enable_cdef; |
| 1141 | seq->enable_restoration = oxcf->enable_restoration; |
Debargha Mukherjee | 37df916 | 2018-03-25 12:48:24 -0700 | [diff] [blame] | 1142 | seq->enable_warped_motion = oxcf->enable_warped_motion; |
Debargha Mukherjee | 16ea6ba | 2018-12-10 12:01:38 -0800 | [diff] [blame] | 1143 | seq->enable_interintra_compound = oxcf->enable_interintra_comp; |
| 1144 | seq->enable_masked_compound = oxcf->enable_masked_comp; |
Debargha Mukherjee | 03c43ba | 2018-12-14 13:08:08 -0800 | [diff] [blame] | 1145 | seq->enable_intra_edge_filter = oxcf->enable_intra_edge_filter; |
Yue Chen | 8f9ca58 | 2018-12-12 15:11:47 -0800 | [diff] [blame] | 1146 | seq->enable_filter_intra = oxcf->enable_filter_intra; |
Debargha Mukherjee | 5749869 | 2018-05-11 13:29:31 -0700 | [diff] [blame] | 1147 | |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 1148 | set_bitstream_level_tier(seq, cm, oxcf); |
Adrian Grange | c56f6ec | 2018-05-31 14:19:32 -0700 | [diff] [blame] | 1149 | |
| 1150 | if (seq->operating_points_cnt_minus_1 == 0) { |
| 1151 | seq->operating_point_idc[0] = 0; |
| 1152 | } else { |
| 1153 | // Set operating_point_idc[] such that for the i-th operating point the |
| 1154 | // first (operating_points_cnt-i) spatial layers and the first temporal |
| 1155 | // layer are decoded Note that highest quality operating point should come |
| 1156 | // first |
| 1157 | for (int i = 0; i < seq->operating_points_cnt_minus_1 + 1; i++) |
| 1158 | seq->operating_point_idc[i] = |
| 1159 | (~(~0u << (seq->operating_points_cnt_minus_1 + 1 - i)) << 8) | 1; |
| 1160 | } |
Debargha Mukherjee | edd7725 | 2018-03-25 12:01:38 -0700 | [diff] [blame] | 1161 | } |
| 1162 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1163 | static void init_config(struct AV1_COMP *cpi, AV1EncoderConfig *oxcf) { |
| 1164 | AV1_COMMON *const cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1165 | |
| 1166 | cpi->oxcf = *oxcf; |
| 1167 | cpi->framerate = oxcf->init_framerate; |
| 1168 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 1169 | cm->seq_params.profile = oxcf->profile; |
| 1170 | cm->seq_params.bit_depth = oxcf->bit_depth; |
| 1171 | cm->seq_params.use_highbitdepth = oxcf->use_highbitdepth; |
| 1172 | cm->seq_params.color_primaries = oxcf->color_primaries; |
| 1173 | cm->seq_params.transfer_characteristics = oxcf->transfer_characteristics; |
| 1174 | cm->seq_params.matrix_coefficients = oxcf->matrix_coefficients; |
Debargha Mukherjee | f340fec | 2018-01-10 18:12:22 -0800 | [diff] [blame] | 1175 | cm->seq_params.monochrome = oxcf->monochrome; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 1176 | cm->seq_params.chroma_sample_position = oxcf->chroma_sample_position; |
| 1177 | cm->seq_params.color_range = oxcf->color_range; |
Andrey Norkin | 28e9ce2 | 2018-01-08 10:11:21 -0800 | [diff] [blame] | 1178 | cm->timing_info_present = oxcf->timing_info_present; |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 1179 | cm->timing_info.num_units_in_display_tick = |
| 1180 | oxcf->timing_info.num_units_in_display_tick; |
| 1181 | cm->timing_info.time_scale = oxcf->timing_info.time_scale; |
| 1182 | cm->timing_info.equal_picture_interval = |
| 1183 | oxcf->timing_info.equal_picture_interval; |
| 1184 | cm->timing_info.num_ticks_per_picture = |
| 1185 | oxcf->timing_info.num_ticks_per_picture; |
| 1186 | |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 1187 | cm->seq_params.display_model_info_present_flag = |
| 1188 | oxcf->display_model_info_present_flag; |
Adrian Grange | c56f6ec | 2018-05-31 14:19:32 -0700 | [diff] [blame] | 1189 | cm->seq_params.decoder_model_info_present_flag = |
| 1190 | oxcf->decoder_model_info_present_flag; |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 1191 | if (oxcf->decoder_model_info_present_flag) { |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 1192 | // set the decoder model parameters in schedule mode |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 1193 | cm->buffer_model.num_units_in_decoding_tick = |
| 1194 | oxcf->buffer_model.num_units_in_decoding_tick; |
Wan-Teh Chang | f64b3bc | 2018-07-02 09:42:39 -0700 | [diff] [blame] | 1195 | cm->buffer_removal_time_present = 1; |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 1196 | set_aom_dec_model_info(&cm->buffer_model); |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 1197 | set_dec_model_op_parameters(&cm->op_params[0]); |
| 1198 | } else if (cm->timing_info_present && |
| 1199 | cm->timing_info.equal_picture_interval && |
| 1200 | !cm->seq_params.decoder_model_info_present_flag) { |
| 1201 | // set the decoder model parameters in resource availability mode |
| 1202 | set_resource_availability_parameters(&cm->op_params[0]); |
Andrey Norkin | c7511de | 2018-06-22 12:31:06 -0700 | [diff] [blame] | 1203 | } else { |
| 1204 | cm->op_params[0].initial_display_delay = |
| 1205 | 10; // Default value (not signaled) |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 1206 | } |
Andrey Norkin | c7511de | 2018-06-22 12:31:06 -0700 | [diff] [blame] | 1207 | |
Tom Finegan | f8d6a16 | 2018-08-21 10:47:55 -0700 | [diff] [blame] | 1208 | if (cm->seq_params.monochrome) { |
| 1209 | cm->seq_params.subsampling_x = 1; |
| 1210 | cm->seq_params.subsampling_y = 1; |
| 1211 | } else if (cm->seq_params.color_primaries == AOM_CICP_CP_BT_709 && |
| 1212 | cm->seq_params.transfer_characteristics == AOM_CICP_TC_SRGB && |
| 1213 | cm->seq_params.matrix_coefficients == AOM_CICP_MC_IDENTITY) { |
| 1214 | cm->seq_params.subsampling_x = 0; |
| 1215 | cm->seq_params.subsampling_y = 0; |
| 1216 | } else { |
| 1217 | if (cm->seq_params.profile == 0) { |
| 1218 | cm->seq_params.subsampling_x = 1; |
| 1219 | cm->seq_params.subsampling_y = 1; |
| 1220 | } else if (cm->seq_params.profile == 1) { |
| 1221 | cm->seq_params.subsampling_x = 0; |
| 1222 | cm->seq_params.subsampling_y = 0; |
| 1223 | } else { |
| 1224 | if (cm->seq_params.bit_depth == AOM_BITS_12) { |
| 1225 | cm->seq_params.subsampling_x = oxcf->chroma_subsampling_x; |
| 1226 | cm->seq_params.subsampling_y = oxcf->chroma_subsampling_y; |
| 1227 | } else { |
| 1228 | cm->seq_params.subsampling_x = 1; |
| 1229 | cm->seq_params.subsampling_y = 0; |
| 1230 | } |
| 1231 | } |
Tom Finegan | 02b2a84 | 2018-08-24 13:50:00 -0700 | [diff] [blame] | 1232 | } |
| 1233 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1234 | cm->width = oxcf->width; |
| 1235 | cm->height = oxcf->height; |
Imdad Sardharwalla | 4ec84ab | 2018-02-06 12:20:18 +0000 | [diff] [blame] | 1236 | set_sb_size(&cm->seq_params, |
| 1237 | select_sb_size(cpi)); // set sb size before allocations |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 1238 | alloc_compressor_data(cpi); |
Yaowu Xu | c7119a7 | 2018-03-29 09:59:37 -0700 | [diff] [blame] | 1239 | |
Andrey Norkin | 6f1c2f7 | 2018-01-15 20:08:52 -0800 | [diff] [blame] | 1240 | update_film_grain_parameters(cpi, oxcf); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1241 | |
| 1242 | // Single thread case: use counts in common. |
Yue Chen | cc6a6ef | 2018-05-21 16:21:05 -0700 | [diff] [blame] | 1243 | cpi->td.counts = &cpi->counts; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1244 | |
| 1245 | // change includes all joint functionality |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1246 | av1_change_config(cpi, oxcf); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1247 | |
| 1248 | cpi->static_mb_pct = 0; |
| 1249 | cpi->ref_frame_flags = 0; |
| 1250 | |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 1251 | // Reset resize pending flags |
| 1252 | cpi->resize_pending_width = 0; |
| 1253 | cpi->resize_pending_height = 0; |
| 1254 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1255 | init_buffer_indices(cpi); |
| 1256 | } |
| 1257 | |
| 1258 | static void set_rc_buffer_sizes(RATE_CONTROL *rc, |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1259 | const AV1EncoderConfig *oxcf) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1260 | const int64_t bandwidth = oxcf->target_bandwidth; |
| 1261 | const int64_t starting = oxcf->starting_buffer_level_ms; |
| 1262 | const int64_t optimal = oxcf->optimal_buffer_level_ms; |
| 1263 | const int64_t maximum = oxcf->maximum_buffer_size_ms; |
| 1264 | |
| 1265 | rc->starting_buffer_level = starting * bandwidth / 1000; |
| 1266 | rc->optimal_buffer_level = |
| 1267 | (optimal == 0) ? bandwidth / 8 : optimal * bandwidth / 1000; |
| 1268 | rc->maximum_buffer_size = |
| 1269 | (maximum == 0) ? bandwidth / 8 : maximum * bandwidth / 1000; |
| 1270 | } |
| 1271 | |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1272 | #define HIGHBD_BFP(BT, SDF, SDAF, VF, SVF, SVAF, SDX4DF, JSDAF, JSVAF) \ |
| 1273 | cpi->fn_ptr[BT].sdf = SDF; \ |
| 1274 | cpi->fn_ptr[BT].sdaf = SDAF; \ |
| 1275 | cpi->fn_ptr[BT].vf = VF; \ |
| 1276 | cpi->fn_ptr[BT].svf = SVF; \ |
| 1277 | cpi->fn_ptr[BT].svaf = SVAF; \ |
| 1278 | cpi->fn_ptr[BT].sdx4df = SDX4DF; \ |
| 1279 | cpi->fn_ptr[BT].jsdaf = JSDAF; \ |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1280 | cpi->fn_ptr[BT].jsvaf = JSVAF; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1281 | |
| 1282 | #define MAKE_BFP_SAD_WRAPPER(fnname) \ |
| 1283 | static unsigned int fnname##_bits8(const uint8_t *src_ptr, \ |
| 1284 | int source_stride, \ |
| 1285 | const uint8_t *ref_ptr, int ref_stride) { \ |
| 1286 | return fnname(src_ptr, source_stride, ref_ptr, ref_stride); \ |
| 1287 | } \ |
| 1288 | static unsigned int fnname##_bits10( \ |
| 1289 | const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \ |
| 1290 | int ref_stride) { \ |
| 1291 | return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 2; \ |
| 1292 | } \ |
| 1293 | static unsigned int fnname##_bits12( \ |
| 1294 | const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \ |
| 1295 | int ref_stride) { \ |
| 1296 | return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 4; \ |
| 1297 | } |
| 1298 | |
| 1299 | #define MAKE_BFP_SADAVG_WRAPPER(fnname) \ |
| 1300 | static unsigned int fnname##_bits8( \ |
| 1301 | const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \ |
| 1302 | int ref_stride, const uint8_t *second_pred) { \ |
| 1303 | return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred); \ |
| 1304 | } \ |
| 1305 | static unsigned int fnname##_bits10( \ |
| 1306 | const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \ |
| 1307 | int ref_stride, const uint8_t *second_pred) { \ |
| 1308 | return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred) >> \ |
| 1309 | 2; \ |
| 1310 | } \ |
| 1311 | static unsigned int fnname##_bits12( \ |
| 1312 | const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \ |
| 1313 | int ref_stride, const uint8_t *second_pred) { \ |
| 1314 | return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred) >> \ |
| 1315 | 4; \ |
| 1316 | } |
| 1317 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1318 | #define MAKE_BFP_SAD4D_WRAPPER(fnname) \ |
| 1319 | static void fnname##_bits8(const uint8_t *src_ptr, int source_stride, \ |
| 1320 | const uint8_t *const ref_ptr[], int ref_stride, \ |
| 1321 | unsigned int *sad_array) { \ |
| 1322 | fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array); \ |
| 1323 | } \ |
| 1324 | static void fnname##_bits10(const uint8_t *src_ptr, int source_stride, \ |
| 1325 | const uint8_t *const ref_ptr[], int ref_stride, \ |
| 1326 | unsigned int *sad_array) { \ |
| 1327 | int i; \ |
| 1328 | fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array); \ |
| 1329 | for (i = 0; i < 4; i++) sad_array[i] >>= 2; \ |
| 1330 | } \ |
| 1331 | static void fnname##_bits12(const uint8_t *src_ptr, int source_stride, \ |
| 1332 | const uint8_t *const ref_ptr[], int ref_stride, \ |
| 1333 | unsigned int *sad_array) { \ |
| 1334 | int i; \ |
| 1335 | fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array); \ |
| 1336 | for (i = 0; i < 4; i++) sad_array[i] >>= 4; \ |
| 1337 | } |
| 1338 | |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1339 | #define MAKE_BFP_JSADAVG_WRAPPER(fnname) \ |
| 1340 | static unsigned int fnname##_bits8( \ |
| 1341 | const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \ |
| 1342 | int ref_stride, const uint8_t *second_pred, \ |
Debargha Mukherjee | f90004a | 2018-12-20 13:35:06 -0800 | [diff] [blame] | 1343 | const DIST_WTD_COMP_PARAMS *jcp_param) { \ |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1344 | return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred, \ |
| 1345 | jcp_param); \ |
| 1346 | } \ |
| 1347 | static unsigned int fnname##_bits10( \ |
| 1348 | const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \ |
| 1349 | int ref_stride, const uint8_t *second_pred, \ |
Debargha Mukherjee | f90004a | 2018-12-20 13:35:06 -0800 | [diff] [blame] | 1350 | const DIST_WTD_COMP_PARAMS *jcp_param) { \ |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1351 | return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred, \ |
| 1352 | jcp_param) >> \ |
| 1353 | 2; \ |
| 1354 | } \ |
| 1355 | static unsigned int fnname##_bits12( \ |
| 1356 | const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \ |
| 1357 | int ref_stride, const uint8_t *second_pred, \ |
Debargha Mukherjee | f90004a | 2018-12-20 13:35:06 -0800 | [diff] [blame] | 1358 | const DIST_WTD_COMP_PARAMS *jcp_param) { \ |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1359 | return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred, \ |
| 1360 | jcp_param) >> \ |
| 1361 | 4; \ |
| 1362 | } |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1363 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1364 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad128x128) |
| 1365 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad128x128_avg) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1366 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad128x128x4d) |
| 1367 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad128x64) |
| 1368 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad128x64_avg) |
| 1369 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad128x64x4d) |
| 1370 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad64x128) |
| 1371 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad64x128_avg) |
| 1372 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad64x128x4d) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1373 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad32x16) |
| 1374 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad32x16_avg) |
| 1375 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad32x16x4d) |
| 1376 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad16x32) |
| 1377 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad16x32_avg) |
| 1378 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad16x32x4d) |
| 1379 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad64x32) |
| 1380 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad64x32_avg) |
| 1381 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad64x32x4d) |
| 1382 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad32x64) |
| 1383 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad32x64_avg) |
| 1384 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad32x64x4d) |
| 1385 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad32x32) |
| 1386 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad32x32_avg) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1387 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad32x32x4d) |
| 1388 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad64x64) |
| 1389 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad64x64_avg) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1390 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad64x64x4d) |
| 1391 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad16x16) |
| 1392 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad16x16_avg) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1393 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad16x16x4d) |
| 1394 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad16x8) |
| 1395 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad16x8_avg) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1396 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad16x8x4d) |
| 1397 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad8x16) |
| 1398 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad8x16_avg) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1399 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad8x16x4d) |
| 1400 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad8x8) |
| 1401 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad8x8_avg) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1402 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad8x8x4d) |
| 1403 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad8x4) |
| 1404 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad8x4_avg) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1405 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad8x4x4d) |
| 1406 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad4x8) |
| 1407 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad4x8_avg) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1408 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad4x8x4d) |
| 1409 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad4x4) |
| 1410 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad4x4_avg) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1411 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad4x4x4d) |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1412 | |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1413 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad4x16) |
| 1414 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad4x16_avg) |
| 1415 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad4x16x4d) |
| 1416 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad16x4) |
| 1417 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad16x4_avg) |
| 1418 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad16x4x4d) |
| 1419 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad8x32) |
| 1420 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad8x32_avg) |
| 1421 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad8x32x4d) |
| 1422 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad32x8) |
| 1423 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad32x8_avg) |
| 1424 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad32x8x4d) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 1425 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad16x64) |
| 1426 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad16x64_avg) |
| 1427 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad16x64x4d) |
| 1428 | MAKE_BFP_SAD_WRAPPER(aom_highbd_sad64x16) |
| 1429 | MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad64x16_avg) |
| 1430 | MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad64x16x4d) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1431 | |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1432 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad128x128_avg) |
| 1433 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad128x64_avg) |
| 1434 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad64x128_avg) |
| 1435 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad32x16_avg) |
| 1436 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad16x32_avg) |
| 1437 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad64x32_avg) |
| 1438 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad32x64_avg) |
| 1439 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad32x32_avg) |
| 1440 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad64x64_avg) |
| 1441 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad16x16_avg) |
| 1442 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad16x8_avg) |
| 1443 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad8x16_avg) |
| 1444 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad8x8_avg) |
| 1445 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad8x4_avg) |
| 1446 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad4x8_avg) |
| 1447 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad4x4_avg) |
| 1448 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad4x16_avg) |
| 1449 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad16x4_avg) |
| 1450 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad8x32_avg) |
| 1451 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad32x8_avg) |
| 1452 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad16x64_avg) |
| 1453 | MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad64x16_avg) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1454 | |
David Barker | 0f3c94e | 2017-05-16 15:21:50 +0100 | [diff] [blame] | 1455 | #define HIGHBD_MBFP(BT, MCSDF, MCSVF) \ |
David Barker | f19f35f | 2017-05-22 16:33:22 +0100 | [diff] [blame] | 1456 | cpi->fn_ptr[BT].msdf = MCSDF; \ |
| 1457 | cpi->fn_ptr[BT].msvf = MCSVF; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1458 | |
David Barker | c155e01 | 2017-05-11 13:54:54 +0100 | [diff] [blame] | 1459 | #define MAKE_MBFP_COMPOUND_SAD_WRAPPER(fnname) \ |
| 1460 | static unsigned int fnname##_bits8( \ |
| 1461 | const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \ |
| 1462 | int ref_stride, const uint8_t *second_pred_ptr, const uint8_t *m, \ |
| 1463 | int m_stride, int invert_mask) { \ |
| 1464 | return fnname(src_ptr, source_stride, ref_ptr, ref_stride, \ |
| 1465 | second_pred_ptr, m, m_stride, invert_mask); \ |
| 1466 | } \ |
| 1467 | static unsigned int fnname##_bits10( \ |
| 1468 | const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \ |
| 1469 | int ref_stride, const uint8_t *second_pred_ptr, const uint8_t *m, \ |
| 1470 | int m_stride, int invert_mask) { \ |
| 1471 | return fnname(src_ptr, source_stride, ref_ptr, ref_stride, \ |
| 1472 | second_pred_ptr, m, m_stride, invert_mask) >> \ |
| 1473 | 2; \ |
| 1474 | } \ |
| 1475 | static unsigned int fnname##_bits12( \ |
| 1476 | const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \ |
| 1477 | int ref_stride, const uint8_t *second_pred_ptr, const uint8_t *m, \ |
| 1478 | int m_stride, int invert_mask) { \ |
| 1479 | return fnname(src_ptr, source_stride, ref_ptr, ref_stride, \ |
| 1480 | second_pred_ptr, m, m_stride, invert_mask) >> \ |
| 1481 | 4; \ |
| 1482 | } |
| 1483 | |
David Barker | f19f35f | 2017-05-22 16:33:22 +0100 | [diff] [blame] | 1484 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad128x128) |
| 1485 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad128x64) |
| 1486 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad64x128) |
David Barker | f19f35f | 2017-05-22 16:33:22 +0100 | [diff] [blame] | 1487 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad64x64) |
| 1488 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad64x32) |
| 1489 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad32x64) |
| 1490 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad32x32) |
| 1491 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad32x16) |
| 1492 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad16x32) |
| 1493 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad16x16) |
| 1494 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad16x8) |
| 1495 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad8x16) |
| 1496 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad8x8) |
| 1497 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad8x4) |
| 1498 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad4x8) |
| 1499 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad4x4) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1500 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad4x16) |
| 1501 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad16x4) |
| 1502 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad8x32) |
| 1503 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad32x8) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 1504 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad16x64) |
| 1505 | MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad64x16) |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1506 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1507 | #define HIGHBD_OBFP(BT, OSDF, OVF, OSVF) \ |
| 1508 | cpi->fn_ptr[BT].osdf = OSDF; \ |
| 1509 | cpi->fn_ptr[BT].ovf = OVF; \ |
| 1510 | cpi->fn_ptr[BT].osvf = OSVF; |
| 1511 | |
| 1512 | #define MAKE_OBFP_SAD_WRAPPER(fnname) \ |
| 1513 | static unsigned int fnname##_bits8(const uint8_t *ref, int ref_stride, \ |
| 1514 | const int32_t *wsrc, \ |
| 1515 | const int32_t *msk) { \ |
| 1516 | return fnname(ref, ref_stride, wsrc, msk); \ |
| 1517 | } \ |
| 1518 | static unsigned int fnname##_bits10(const uint8_t *ref, int ref_stride, \ |
| 1519 | const int32_t *wsrc, \ |
| 1520 | const int32_t *msk) { \ |
| 1521 | return fnname(ref, ref_stride, wsrc, msk) >> 2; \ |
| 1522 | } \ |
| 1523 | static unsigned int fnname##_bits12(const uint8_t *ref, int ref_stride, \ |
| 1524 | const int32_t *wsrc, \ |
| 1525 | const int32_t *msk) { \ |
| 1526 | return fnname(ref, ref_stride, wsrc, msk) >> 4; \ |
| 1527 | } |
| 1528 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1529 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad128x128) |
| 1530 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad128x64) |
| 1531 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad64x128) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1532 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad64x64) |
| 1533 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad64x32) |
| 1534 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad32x64) |
| 1535 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad32x32) |
| 1536 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad32x16) |
| 1537 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad16x32) |
| 1538 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad16x16) |
| 1539 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad16x8) |
| 1540 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad8x16) |
| 1541 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad8x8) |
| 1542 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad8x4) |
| 1543 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad4x8) |
| 1544 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad4x4) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1545 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad4x16) |
| 1546 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad16x4) |
| 1547 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad8x32) |
| 1548 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad32x8) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 1549 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad16x64) |
| 1550 | MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad64x16) |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1551 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1552 | static void highbd_set_var_fns(AV1_COMP *const cpi) { |
| 1553 | AV1_COMMON *const cm = &cpi->common; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 1554 | if (cm->seq_params.use_highbitdepth) { |
| 1555 | switch (cm->seq_params.bit_depth) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1556 | case AOM_BITS_8: |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1557 | HIGHBD_BFP(BLOCK_64X16, aom_highbd_sad64x16_bits8, |
| 1558 | aom_highbd_sad64x16_avg_bits8, aom_highbd_8_variance64x16, |
| 1559 | aom_highbd_8_sub_pixel_variance64x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1560 | aom_highbd_8_sub_pixel_avg_variance64x16, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1561 | aom_highbd_sad64x16x4d_bits8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1562 | aom_highbd_dist_wtd_sad64x16_avg_bits8, |
| 1563 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance64x16) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1564 | |
| 1565 | HIGHBD_BFP(BLOCK_16X64, aom_highbd_sad16x64_bits8, |
| 1566 | aom_highbd_sad16x64_avg_bits8, aom_highbd_8_variance16x64, |
| 1567 | aom_highbd_8_sub_pixel_variance16x64, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1568 | aom_highbd_8_sub_pixel_avg_variance16x64, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1569 | aom_highbd_sad16x64x4d_bits8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1570 | aom_highbd_dist_wtd_sad16x64_avg_bits8, |
| 1571 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance16x64) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1572 | |
| 1573 | HIGHBD_BFP( |
| 1574 | BLOCK_32X8, aom_highbd_sad32x8_bits8, aom_highbd_sad32x8_avg_bits8, |
| 1575 | aom_highbd_8_variance32x8, aom_highbd_8_sub_pixel_variance32x8, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1576 | aom_highbd_8_sub_pixel_avg_variance32x8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1577 | aom_highbd_sad32x8x4d_bits8, aom_highbd_dist_wtd_sad32x8_avg_bits8, |
| 1578 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance32x8) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1579 | |
| 1580 | HIGHBD_BFP( |
| 1581 | BLOCK_8X32, aom_highbd_sad8x32_bits8, aom_highbd_sad8x32_avg_bits8, |
| 1582 | aom_highbd_8_variance8x32, aom_highbd_8_sub_pixel_variance8x32, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1583 | aom_highbd_8_sub_pixel_avg_variance8x32, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1584 | aom_highbd_sad8x32x4d_bits8, aom_highbd_dist_wtd_sad8x32_avg_bits8, |
| 1585 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance8x32) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1586 | |
| 1587 | HIGHBD_BFP( |
| 1588 | BLOCK_16X4, aom_highbd_sad16x4_bits8, aom_highbd_sad16x4_avg_bits8, |
| 1589 | aom_highbd_8_variance16x4, aom_highbd_8_sub_pixel_variance16x4, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1590 | aom_highbd_8_sub_pixel_avg_variance16x4, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1591 | aom_highbd_sad16x4x4d_bits8, aom_highbd_dist_wtd_sad16x4_avg_bits8, |
| 1592 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance16x4) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1593 | |
| 1594 | HIGHBD_BFP( |
| 1595 | BLOCK_4X16, aom_highbd_sad4x16_bits8, aom_highbd_sad4x16_avg_bits8, |
| 1596 | aom_highbd_8_variance4x16, aom_highbd_8_sub_pixel_variance4x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1597 | aom_highbd_8_sub_pixel_avg_variance4x16, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1598 | aom_highbd_sad4x16x4d_bits8, aom_highbd_dist_wtd_sad4x16_avg_bits8, |
| 1599 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance4x16) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1600 | |
| 1601 | HIGHBD_BFP(BLOCK_32X16, aom_highbd_sad32x16_bits8, |
| 1602 | aom_highbd_sad32x16_avg_bits8, aom_highbd_8_variance32x16, |
| 1603 | aom_highbd_8_sub_pixel_variance32x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1604 | aom_highbd_8_sub_pixel_avg_variance32x16, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1605 | aom_highbd_sad32x16x4d_bits8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1606 | aom_highbd_dist_wtd_sad32x16_avg_bits8, |
| 1607 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance32x16) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1608 | |
| 1609 | HIGHBD_BFP(BLOCK_16X32, aom_highbd_sad16x32_bits8, |
| 1610 | aom_highbd_sad16x32_avg_bits8, aom_highbd_8_variance16x32, |
| 1611 | aom_highbd_8_sub_pixel_variance16x32, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1612 | aom_highbd_8_sub_pixel_avg_variance16x32, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1613 | aom_highbd_sad16x32x4d_bits8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1614 | aom_highbd_dist_wtd_sad16x32_avg_bits8, |
| 1615 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance16x32) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1616 | |
| 1617 | HIGHBD_BFP(BLOCK_64X32, aom_highbd_sad64x32_bits8, |
| 1618 | aom_highbd_sad64x32_avg_bits8, aom_highbd_8_variance64x32, |
| 1619 | aom_highbd_8_sub_pixel_variance64x32, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1620 | aom_highbd_8_sub_pixel_avg_variance64x32, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1621 | aom_highbd_sad64x32x4d_bits8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1622 | aom_highbd_dist_wtd_sad64x32_avg_bits8, |
| 1623 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance64x32) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1624 | |
| 1625 | HIGHBD_BFP(BLOCK_32X64, aom_highbd_sad32x64_bits8, |
| 1626 | aom_highbd_sad32x64_avg_bits8, aom_highbd_8_variance32x64, |
| 1627 | aom_highbd_8_sub_pixel_variance32x64, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1628 | aom_highbd_8_sub_pixel_avg_variance32x64, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1629 | aom_highbd_sad32x64x4d_bits8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1630 | aom_highbd_dist_wtd_sad32x64_avg_bits8, |
| 1631 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance32x64) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1632 | |
| 1633 | HIGHBD_BFP(BLOCK_32X32, aom_highbd_sad32x32_bits8, |
| 1634 | aom_highbd_sad32x32_avg_bits8, aom_highbd_8_variance32x32, |
| 1635 | aom_highbd_8_sub_pixel_variance32x32, |
| 1636 | aom_highbd_8_sub_pixel_avg_variance32x32, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1637 | aom_highbd_sad32x32x4d_bits8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1638 | aom_highbd_dist_wtd_sad32x32_avg_bits8, |
| 1639 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance32x32) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1640 | |
| 1641 | HIGHBD_BFP(BLOCK_64X64, aom_highbd_sad64x64_bits8, |
| 1642 | aom_highbd_sad64x64_avg_bits8, aom_highbd_8_variance64x64, |
| 1643 | aom_highbd_8_sub_pixel_variance64x64, |
| 1644 | aom_highbd_8_sub_pixel_avg_variance64x64, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1645 | aom_highbd_sad64x64x4d_bits8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1646 | aom_highbd_dist_wtd_sad64x64_avg_bits8, |
| 1647 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance64x64) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1648 | |
| 1649 | HIGHBD_BFP(BLOCK_16X16, aom_highbd_sad16x16_bits8, |
| 1650 | aom_highbd_sad16x16_avg_bits8, aom_highbd_8_variance16x16, |
| 1651 | aom_highbd_8_sub_pixel_variance16x16, |
| 1652 | aom_highbd_8_sub_pixel_avg_variance16x16, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1653 | aom_highbd_sad16x16x4d_bits8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1654 | aom_highbd_dist_wtd_sad16x16_avg_bits8, |
| 1655 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance16x16) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1656 | |
| 1657 | HIGHBD_BFP( |
| 1658 | BLOCK_16X8, aom_highbd_sad16x8_bits8, aom_highbd_sad16x8_avg_bits8, |
| 1659 | aom_highbd_8_variance16x8, aom_highbd_8_sub_pixel_variance16x8, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1660 | aom_highbd_8_sub_pixel_avg_variance16x8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1661 | aom_highbd_sad16x8x4d_bits8, aom_highbd_dist_wtd_sad16x8_avg_bits8, |
| 1662 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance16x8) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1663 | |
| 1664 | HIGHBD_BFP( |
| 1665 | BLOCK_8X16, aom_highbd_sad8x16_bits8, aom_highbd_sad8x16_avg_bits8, |
| 1666 | aom_highbd_8_variance8x16, aom_highbd_8_sub_pixel_variance8x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1667 | aom_highbd_8_sub_pixel_avg_variance8x16, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1668 | aom_highbd_sad8x16x4d_bits8, aom_highbd_dist_wtd_sad8x16_avg_bits8, |
| 1669 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance8x16) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1670 | |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1671 | HIGHBD_BFP( |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1672 | BLOCK_8X8, aom_highbd_sad8x8_bits8, aom_highbd_sad8x8_avg_bits8, |
| 1673 | aom_highbd_8_variance8x8, aom_highbd_8_sub_pixel_variance8x8, |
| 1674 | aom_highbd_8_sub_pixel_avg_variance8x8, aom_highbd_sad8x8x4d_bits8, |
| 1675 | aom_highbd_dist_wtd_sad8x8_avg_bits8, |
| 1676 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance8x8) |
| 1677 | |
| 1678 | HIGHBD_BFP( |
| 1679 | BLOCK_8X4, aom_highbd_sad8x4_bits8, aom_highbd_sad8x4_avg_bits8, |
| 1680 | aom_highbd_8_variance8x4, aom_highbd_8_sub_pixel_variance8x4, |
| 1681 | aom_highbd_8_sub_pixel_avg_variance8x4, aom_highbd_sad8x4x4d_bits8, |
| 1682 | aom_highbd_dist_wtd_sad8x4_avg_bits8, |
| 1683 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance8x4) |
| 1684 | |
| 1685 | HIGHBD_BFP( |
| 1686 | BLOCK_4X8, aom_highbd_sad4x8_bits8, aom_highbd_sad4x8_avg_bits8, |
| 1687 | aom_highbd_8_variance4x8, aom_highbd_8_sub_pixel_variance4x8, |
| 1688 | aom_highbd_8_sub_pixel_avg_variance4x8, aom_highbd_sad4x8x4d_bits8, |
| 1689 | aom_highbd_dist_wtd_sad4x8_avg_bits8, |
| 1690 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance4x8) |
| 1691 | |
| 1692 | HIGHBD_BFP( |
| 1693 | BLOCK_4X4, aom_highbd_sad4x4_bits8, aom_highbd_sad4x4_avg_bits8, |
| 1694 | aom_highbd_8_variance4x4, aom_highbd_8_sub_pixel_variance4x4, |
| 1695 | aom_highbd_8_sub_pixel_avg_variance4x4, aom_highbd_sad4x4x4d_bits8, |
| 1696 | aom_highbd_dist_wtd_sad4x4_avg_bits8, |
| 1697 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance4x4) |
| 1698 | |
| 1699 | HIGHBD_BFP(BLOCK_128X128, aom_highbd_sad128x128_bits8, |
| 1700 | aom_highbd_sad128x128_avg_bits8, |
| 1701 | aom_highbd_8_variance128x128, |
| 1702 | aom_highbd_8_sub_pixel_variance128x128, |
| 1703 | aom_highbd_8_sub_pixel_avg_variance128x128, |
| 1704 | aom_highbd_sad128x128x4d_bits8, |
| 1705 | aom_highbd_dist_wtd_sad128x128_avg_bits8, |
| 1706 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance128x128) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1707 | |
| 1708 | HIGHBD_BFP(BLOCK_128X64, aom_highbd_sad128x64_bits8, |
| 1709 | aom_highbd_sad128x64_avg_bits8, aom_highbd_8_variance128x64, |
| 1710 | aom_highbd_8_sub_pixel_variance128x64, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1711 | aom_highbd_8_sub_pixel_avg_variance128x64, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1712 | aom_highbd_sad128x64x4d_bits8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1713 | aom_highbd_dist_wtd_sad128x64_avg_bits8, |
| 1714 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance128x64) |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1715 | |
| 1716 | HIGHBD_BFP(BLOCK_64X128, aom_highbd_sad64x128_bits8, |
| 1717 | aom_highbd_sad64x128_avg_bits8, aom_highbd_8_variance64x128, |
| 1718 | aom_highbd_8_sub_pixel_variance64x128, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1719 | aom_highbd_8_sub_pixel_avg_variance64x128, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1720 | aom_highbd_sad64x128x4d_bits8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1721 | aom_highbd_dist_wtd_sad64x128_avg_bits8, |
| 1722 | aom_highbd_8_dist_wtd_sub_pixel_avg_variance64x128) |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1723 | |
David Barker | f19f35f | 2017-05-22 16:33:22 +0100 | [diff] [blame] | 1724 | HIGHBD_MBFP(BLOCK_128X128, aom_highbd_masked_sad128x128_bits8, |
| 1725 | aom_highbd_8_masked_sub_pixel_variance128x128) |
| 1726 | HIGHBD_MBFP(BLOCK_128X64, aom_highbd_masked_sad128x64_bits8, |
| 1727 | aom_highbd_8_masked_sub_pixel_variance128x64) |
| 1728 | HIGHBD_MBFP(BLOCK_64X128, aom_highbd_masked_sad64x128_bits8, |
| 1729 | aom_highbd_8_masked_sub_pixel_variance64x128) |
David Barker | f19f35f | 2017-05-22 16:33:22 +0100 | [diff] [blame] | 1730 | HIGHBD_MBFP(BLOCK_64X64, aom_highbd_masked_sad64x64_bits8, |
| 1731 | aom_highbd_8_masked_sub_pixel_variance64x64) |
| 1732 | HIGHBD_MBFP(BLOCK_64X32, aom_highbd_masked_sad64x32_bits8, |
| 1733 | aom_highbd_8_masked_sub_pixel_variance64x32) |
| 1734 | HIGHBD_MBFP(BLOCK_32X64, aom_highbd_masked_sad32x64_bits8, |
| 1735 | aom_highbd_8_masked_sub_pixel_variance32x64) |
| 1736 | HIGHBD_MBFP(BLOCK_32X32, aom_highbd_masked_sad32x32_bits8, |
| 1737 | aom_highbd_8_masked_sub_pixel_variance32x32) |
| 1738 | HIGHBD_MBFP(BLOCK_32X16, aom_highbd_masked_sad32x16_bits8, |
| 1739 | aom_highbd_8_masked_sub_pixel_variance32x16) |
| 1740 | HIGHBD_MBFP(BLOCK_16X32, aom_highbd_masked_sad16x32_bits8, |
| 1741 | aom_highbd_8_masked_sub_pixel_variance16x32) |
| 1742 | HIGHBD_MBFP(BLOCK_16X16, aom_highbd_masked_sad16x16_bits8, |
| 1743 | aom_highbd_8_masked_sub_pixel_variance16x16) |
| 1744 | HIGHBD_MBFP(BLOCK_8X16, aom_highbd_masked_sad8x16_bits8, |
| 1745 | aom_highbd_8_masked_sub_pixel_variance8x16) |
| 1746 | HIGHBD_MBFP(BLOCK_16X8, aom_highbd_masked_sad16x8_bits8, |
| 1747 | aom_highbd_8_masked_sub_pixel_variance16x8) |
| 1748 | HIGHBD_MBFP(BLOCK_8X8, aom_highbd_masked_sad8x8_bits8, |
| 1749 | aom_highbd_8_masked_sub_pixel_variance8x8) |
| 1750 | HIGHBD_MBFP(BLOCK_4X8, aom_highbd_masked_sad4x8_bits8, |
| 1751 | aom_highbd_8_masked_sub_pixel_variance4x8) |
| 1752 | HIGHBD_MBFP(BLOCK_8X4, aom_highbd_masked_sad8x4_bits8, |
| 1753 | aom_highbd_8_masked_sub_pixel_variance8x4) |
| 1754 | HIGHBD_MBFP(BLOCK_4X4, aom_highbd_masked_sad4x4_bits8, |
| 1755 | aom_highbd_8_masked_sub_pixel_variance4x4) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 1756 | HIGHBD_MBFP(BLOCK_64X16, aom_highbd_masked_sad64x16_bits8, |
| 1757 | aom_highbd_8_masked_sub_pixel_variance64x16) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 1758 | HIGHBD_MBFP(BLOCK_16X64, aom_highbd_masked_sad16x64_bits8, |
| 1759 | aom_highbd_8_masked_sub_pixel_variance16x64) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1760 | HIGHBD_MBFP(BLOCK_32X8, aom_highbd_masked_sad32x8_bits8, |
| 1761 | aom_highbd_8_masked_sub_pixel_variance32x8) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1762 | HIGHBD_MBFP(BLOCK_8X32, aom_highbd_masked_sad8x32_bits8, |
| 1763 | aom_highbd_8_masked_sub_pixel_variance8x32) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1764 | HIGHBD_MBFP(BLOCK_16X4, aom_highbd_masked_sad16x4_bits8, |
| 1765 | aom_highbd_8_masked_sub_pixel_variance16x4) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1766 | HIGHBD_MBFP(BLOCK_4X16, aom_highbd_masked_sad4x16_bits8, |
| 1767 | aom_highbd_8_masked_sub_pixel_variance4x16) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1768 | HIGHBD_OBFP(BLOCK_128X128, aom_highbd_obmc_sad128x128_bits8, |
| 1769 | aom_highbd_obmc_variance128x128, |
| 1770 | aom_highbd_obmc_sub_pixel_variance128x128) |
| 1771 | HIGHBD_OBFP(BLOCK_128X64, aom_highbd_obmc_sad128x64_bits8, |
| 1772 | aom_highbd_obmc_variance128x64, |
| 1773 | aom_highbd_obmc_sub_pixel_variance128x64) |
| 1774 | HIGHBD_OBFP(BLOCK_64X128, aom_highbd_obmc_sad64x128_bits8, |
| 1775 | aom_highbd_obmc_variance64x128, |
| 1776 | aom_highbd_obmc_sub_pixel_variance64x128) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1777 | HIGHBD_OBFP(BLOCK_64X64, aom_highbd_obmc_sad64x64_bits8, |
| 1778 | aom_highbd_obmc_variance64x64, |
| 1779 | aom_highbd_obmc_sub_pixel_variance64x64) |
| 1780 | HIGHBD_OBFP(BLOCK_64X32, aom_highbd_obmc_sad64x32_bits8, |
| 1781 | aom_highbd_obmc_variance64x32, |
| 1782 | aom_highbd_obmc_sub_pixel_variance64x32) |
| 1783 | HIGHBD_OBFP(BLOCK_32X64, aom_highbd_obmc_sad32x64_bits8, |
| 1784 | aom_highbd_obmc_variance32x64, |
| 1785 | aom_highbd_obmc_sub_pixel_variance32x64) |
| 1786 | HIGHBD_OBFP(BLOCK_32X32, aom_highbd_obmc_sad32x32_bits8, |
| 1787 | aom_highbd_obmc_variance32x32, |
| 1788 | aom_highbd_obmc_sub_pixel_variance32x32) |
| 1789 | HIGHBD_OBFP(BLOCK_32X16, aom_highbd_obmc_sad32x16_bits8, |
| 1790 | aom_highbd_obmc_variance32x16, |
| 1791 | aom_highbd_obmc_sub_pixel_variance32x16) |
| 1792 | HIGHBD_OBFP(BLOCK_16X32, aom_highbd_obmc_sad16x32_bits8, |
| 1793 | aom_highbd_obmc_variance16x32, |
| 1794 | aom_highbd_obmc_sub_pixel_variance16x32) |
| 1795 | HIGHBD_OBFP(BLOCK_16X16, aom_highbd_obmc_sad16x16_bits8, |
| 1796 | aom_highbd_obmc_variance16x16, |
| 1797 | aom_highbd_obmc_sub_pixel_variance16x16) |
| 1798 | HIGHBD_OBFP(BLOCK_8X16, aom_highbd_obmc_sad8x16_bits8, |
| 1799 | aom_highbd_obmc_variance8x16, |
| 1800 | aom_highbd_obmc_sub_pixel_variance8x16) |
| 1801 | HIGHBD_OBFP(BLOCK_16X8, aom_highbd_obmc_sad16x8_bits8, |
| 1802 | aom_highbd_obmc_variance16x8, |
| 1803 | aom_highbd_obmc_sub_pixel_variance16x8) |
| 1804 | HIGHBD_OBFP(BLOCK_8X8, aom_highbd_obmc_sad8x8_bits8, |
| 1805 | aom_highbd_obmc_variance8x8, |
| 1806 | aom_highbd_obmc_sub_pixel_variance8x8) |
| 1807 | HIGHBD_OBFP(BLOCK_4X8, aom_highbd_obmc_sad4x8_bits8, |
| 1808 | aom_highbd_obmc_variance4x8, |
| 1809 | aom_highbd_obmc_sub_pixel_variance4x8) |
| 1810 | HIGHBD_OBFP(BLOCK_8X4, aom_highbd_obmc_sad8x4_bits8, |
| 1811 | aom_highbd_obmc_variance8x4, |
| 1812 | aom_highbd_obmc_sub_pixel_variance8x4) |
| 1813 | HIGHBD_OBFP(BLOCK_4X4, aom_highbd_obmc_sad4x4_bits8, |
| 1814 | aom_highbd_obmc_variance4x4, |
| 1815 | aom_highbd_obmc_sub_pixel_variance4x4) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 1816 | HIGHBD_OBFP(BLOCK_64X16, aom_highbd_obmc_sad64x16_bits8, |
| 1817 | aom_highbd_obmc_variance64x16, |
| 1818 | aom_highbd_obmc_sub_pixel_variance64x16) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 1819 | HIGHBD_OBFP(BLOCK_16X64, aom_highbd_obmc_sad16x64_bits8, |
| 1820 | aom_highbd_obmc_variance16x64, |
| 1821 | aom_highbd_obmc_sub_pixel_variance16x64) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1822 | HIGHBD_OBFP(BLOCK_32X8, aom_highbd_obmc_sad32x8_bits8, |
| 1823 | aom_highbd_obmc_variance32x8, |
| 1824 | aom_highbd_obmc_sub_pixel_variance32x8) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1825 | HIGHBD_OBFP(BLOCK_8X32, aom_highbd_obmc_sad8x32_bits8, |
| 1826 | aom_highbd_obmc_variance8x32, |
| 1827 | aom_highbd_obmc_sub_pixel_variance8x32) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1828 | HIGHBD_OBFP(BLOCK_16X4, aom_highbd_obmc_sad16x4_bits8, |
| 1829 | aom_highbd_obmc_variance16x4, |
| 1830 | aom_highbd_obmc_sub_pixel_variance16x4) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 1831 | HIGHBD_OBFP(BLOCK_4X16, aom_highbd_obmc_sad4x16_bits8, |
| 1832 | aom_highbd_obmc_variance4x16, |
| 1833 | aom_highbd_obmc_sub_pixel_variance4x16) |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 1834 | break; |
| 1835 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 1836 | case AOM_BITS_10: |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1837 | HIGHBD_BFP(BLOCK_64X16, aom_highbd_sad64x16_bits10, |
| 1838 | aom_highbd_sad64x16_avg_bits10, aom_highbd_10_variance64x16, |
| 1839 | aom_highbd_10_sub_pixel_variance64x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1840 | aom_highbd_10_sub_pixel_avg_variance64x16, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1841 | aom_highbd_sad64x16x4d_bits10, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1842 | aom_highbd_dist_wtd_sad64x16_avg_bits10, |
| 1843 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance64x16); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1844 | |
| 1845 | HIGHBD_BFP(BLOCK_16X64, aom_highbd_sad16x64_bits10, |
| 1846 | aom_highbd_sad16x64_avg_bits10, aom_highbd_10_variance16x64, |
| 1847 | aom_highbd_10_sub_pixel_variance16x64, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1848 | aom_highbd_10_sub_pixel_avg_variance16x64, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1849 | aom_highbd_sad16x64x4d_bits10, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1850 | aom_highbd_dist_wtd_sad16x64_avg_bits10, |
| 1851 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance16x64); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1852 | |
| 1853 | HIGHBD_BFP(BLOCK_32X8, aom_highbd_sad32x8_bits10, |
| 1854 | aom_highbd_sad32x8_avg_bits10, aom_highbd_10_variance32x8, |
| 1855 | aom_highbd_10_sub_pixel_variance32x8, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1856 | aom_highbd_10_sub_pixel_avg_variance32x8, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1857 | aom_highbd_sad32x8x4d_bits10, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1858 | aom_highbd_dist_wtd_sad32x8_avg_bits10, |
| 1859 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance32x8); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1860 | |
| 1861 | HIGHBD_BFP(BLOCK_8X32, aom_highbd_sad8x32_bits10, |
| 1862 | aom_highbd_sad8x32_avg_bits10, aom_highbd_10_variance8x32, |
| 1863 | aom_highbd_10_sub_pixel_variance8x32, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1864 | aom_highbd_10_sub_pixel_avg_variance8x32, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1865 | aom_highbd_sad8x32x4d_bits10, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1866 | aom_highbd_dist_wtd_sad8x32_avg_bits10, |
| 1867 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance8x32); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1868 | |
| 1869 | HIGHBD_BFP(BLOCK_16X4, aom_highbd_sad16x4_bits10, |
| 1870 | aom_highbd_sad16x4_avg_bits10, aom_highbd_10_variance16x4, |
| 1871 | aom_highbd_10_sub_pixel_variance16x4, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1872 | aom_highbd_10_sub_pixel_avg_variance16x4, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1873 | aom_highbd_sad16x4x4d_bits10, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1874 | aom_highbd_dist_wtd_sad16x4_avg_bits10, |
| 1875 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance16x4); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1876 | |
| 1877 | HIGHBD_BFP(BLOCK_4X16, aom_highbd_sad4x16_bits10, |
| 1878 | aom_highbd_sad4x16_avg_bits10, aom_highbd_10_variance4x16, |
| 1879 | aom_highbd_10_sub_pixel_variance4x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1880 | aom_highbd_10_sub_pixel_avg_variance4x16, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1881 | aom_highbd_sad4x16x4d_bits10, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1882 | aom_highbd_dist_wtd_sad4x16_avg_bits10, |
| 1883 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance4x16); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1884 | |
| 1885 | HIGHBD_BFP(BLOCK_32X16, aom_highbd_sad32x16_bits10, |
| 1886 | aom_highbd_sad32x16_avg_bits10, aom_highbd_10_variance32x16, |
| 1887 | aom_highbd_10_sub_pixel_variance32x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1888 | aom_highbd_10_sub_pixel_avg_variance32x16, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1889 | aom_highbd_sad32x16x4d_bits10, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1890 | aom_highbd_dist_wtd_sad32x16_avg_bits10, |
| 1891 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance32x16); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1892 | |
| 1893 | HIGHBD_BFP(BLOCK_16X32, aom_highbd_sad16x32_bits10, |
| 1894 | aom_highbd_sad16x32_avg_bits10, aom_highbd_10_variance16x32, |
| 1895 | aom_highbd_10_sub_pixel_variance16x32, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1896 | aom_highbd_10_sub_pixel_avg_variance16x32, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1897 | aom_highbd_sad16x32x4d_bits10, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1898 | aom_highbd_dist_wtd_sad16x32_avg_bits10, |
| 1899 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance16x32); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1900 | |
| 1901 | HIGHBD_BFP(BLOCK_64X32, aom_highbd_sad64x32_bits10, |
| 1902 | aom_highbd_sad64x32_avg_bits10, aom_highbd_10_variance64x32, |
| 1903 | aom_highbd_10_sub_pixel_variance64x32, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1904 | aom_highbd_10_sub_pixel_avg_variance64x32, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1905 | aom_highbd_sad64x32x4d_bits10, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1906 | aom_highbd_dist_wtd_sad64x32_avg_bits10, |
| 1907 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance64x32); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1908 | |
| 1909 | HIGHBD_BFP(BLOCK_32X64, aom_highbd_sad32x64_bits10, |
| 1910 | aom_highbd_sad32x64_avg_bits10, aom_highbd_10_variance32x64, |
| 1911 | aom_highbd_10_sub_pixel_variance32x64, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1912 | aom_highbd_10_sub_pixel_avg_variance32x64, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1913 | aom_highbd_sad32x64x4d_bits10, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1914 | aom_highbd_dist_wtd_sad32x64_avg_bits10, |
| 1915 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance32x64); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1916 | |
| 1917 | HIGHBD_BFP(BLOCK_32X32, aom_highbd_sad32x32_bits10, |
| 1918 | aom_highbd_sad32x32_avg_bits10, aom_highbd_10_variance32x32, |
| 1919 | aom_highbd_10_sub_pixel_variance32x32, |
| 1920 | aom_highbd_10_sub_pixel_avg_variance32x32, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1921 | aom_highbd_sad32x32x4d_bits10, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1922 | aom_highbd_dist_wtd_sad32x32_avg_bits10, |
| 1923 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance32x32); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1924 | |
| 1925 | HIGHBD_BFP(BLOCK_64X64, aom_highbd_sad64x64_bits10, |
| 1926 | aom_highbd_sad64x64_avg_bits10, aom_highbd_10_variance64x64, |
| 1927 | aom_highbd_10_sub_pixel_variance64x64, |
| 1928 | aom_highbd_10_sub_pixel_avg_variance64x64, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1929 | aom_highbd_sad64x64x4d_bits10, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1930 | aom_highbd_dist_wtd_sad64x64_avg_bits10, |
| 1931 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance64x64); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1932 | |
| 1933 | HIGHBD_BFP(BLOCK_16X16, aom_highbd_sad16x16_bits10, |
| 1934 | aom_highbd_sad16x16_avg_bits10, aom_highbd_10_variance16x16, |
| 1935 | aom_highbd_10_sub_pixel_variance16x16, |
| 1936 | aom_highbd_10_sub_pixel_avg_variance16x16, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1937 | aom_highbd_sad16x16x4d_bits10, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1938 | aom_highbd_dist_wtd_sad16x16_avg_bits10, |
| 1939 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance16x16); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1940 | |
| 1941 | HIGHBD_BFP(BLOCK_16X8, aom_highbd_sad16x8_bits10, |
| 1942 | aom_highbd_sad16x8_avg_bits10, aom_highbd_10_variance16x8, |
| 1943 | aom_highbd_10_sub_pixel_variance16x8, |
| 1944 | aom_highbd_10_sub_pixel_avg_variance16x8, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1945 | aom_highbd_sad16x8x4d_bits10, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1946 | aom_highbd_dist_wtd_sad16x8_avg_bits10, |
| 1947 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance16x8); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1948 | |
| 1949 | HIGHBD_BFP(BLOCK_8X16, aom_highbd_sad8x16_bits10, |
| 1950 | aom_highbd_sad8x16_avg_bits10, aom_highbd_10_variance8x16, |
| 1951 | aom_highbd_10_sub_pixel_variance8x16, |
| 1952 | aom_highbd_10_sub_pixel_avg_variance8x16, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1953 | aom_highbd_sad8x16x4d_bits10, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1954 | aom_highbd_dist_wtd_sad8x16_avg_bits10, |
| 1955 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance8x16); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1956 | |
| 1957 | HIGHBD_BFP( |
| 1958 | BLOCK_8X8, aom_highbd_sad8x8_bits10, aom_highbd_sad8x8_avg_bits10, |
| 1959 | aom_highbd_10_variance8x8, aom_highbd_10_sub_pixel_variance8x8, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1960 | aom_highbd_10_sub_pixel_avg_variance8x8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1961 | aom_highbd_sad8x8x4d_bits10, aom_highbd_dist_wtd_sad8x8_avg_bits10, |
| 1962 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance8x8); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1963 | |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1964 | HIGHBD_BFP( |
| 1965 | BLOCK_8X4, aom_highbd_sad8x4_bits10, aom_highbd_sad8x4_avg_bits10, |
| 1966 | aom_highbd_10_variance8x4, aom_highbd_10_sub_pixel_variance8x4, |
| 1967 | aom_highbd_10_sub_pixel_avg_variance8x4, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1968 | aom_highbd_sad8x4x4d_bits10, aom_highbd_dist_wtd_sad8x4_avg_bits10, |
| 1969 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance8x4); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1970 | |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1971 | HIGHBD_BFP( |
| 1972 | BLOCK_4X8, aom_highbd_sad4x8_bits10, aom_highbd_sad4x8_avg_bits10, |
| 1973 | aom_highbd_10_variance4x8, aom_highbd_10_sub_pixel_variance4x8, |
| 1974 | aom_highbd_10_sub_pixel_avg_variance4x8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1975 | aom_highbd_sad4x8x4d_bits10, aom_highbd_dist_wtd_sad4x8_avg_bits10, |
| 1976 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance4x8); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1977 | |
| 1978 | HIGHBD_BFP( |
| 1979 | BLOCK_4X4, aom_highbd_sad4x4_bits10, aom_highbd_sad4x4_avg_bits10, |
| 1980 | aom_highbd_10_variance4x4, aom_highbd_10_sub_pixel_variance4x4, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1981 | aom_highbd_10_sub_pixel_avg_variance4x4, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1982 | aom_highbd_sad4x4x4d_bits10, aom_highbd_dist_wtd_sad4x4_avg_bits10, |
| 1983 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance4x4); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1984 | |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 1985 | HIGHBD_BFP(BLOCK_128X128, aom_highbd_sad128x128_bits10, |
| 1986 | aom_highbd_sad128x128_avg_bits10, |
| 1987 | aom_highbd_10_variance128x128, |
| 1988 | aom_highbd_10_sub_pixel_variance128x128, |
| 1989 | aom_highbd_10_sub_pixel_avg_variance128x128, |
| 1990 | aom_highbd_sad128x128x4d_bits10, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1991 | aom_highbd_dist_wtd_sad128x128_avg_bits10, |
| 1992 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance128x128); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 1993 | |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 1994 | HIGHBD_BFP(BLOCK_128X64, aom_highbd_sad128x64_bits10, |
| 1995 | aom_highbd_sad128x64_avg_bits10, |
| 1996 | aom_highbd_10_variance128x64, |
| 1997 | aom_highbd_10_sub_pixel_variance128x64, |
| 1998 | aom_highbd_10_sub_pixel_avg_variance128x64, |
| 1999 | aom_highbd_sad128x64x4d_bits10, |
| 2000 | aom_highbd_dist_wtd_sad128x64_avg_bits10, |
| 2001 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance128x64); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2002 | |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2003 | HIGHBD_BFP(BLOCK_64X128, aom_highbd_sad64x128_bits10, |
| 2004 | aom_highbd_sad64x128_avg_bits10, |
| 2005 | aom_highbd_10_variance64x128, |
| 2006 | aom_highbd_10_sub_pixel_variance64x128, |
| 2007 | aom_highbd_10_sub_pixel_avg_variance64x128, |
| 2008 | aom_highbd_sad64x128x4d_bits10, |
| 2009 | aom_highbd_dist_wtd_sad64x128_avg_bits10, |
| 2010 | aom_highbd_10_dist_wtd_sub_pixel_avg_variance64x128); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2011 | |
David Barker | f19f35f | 2017-05-22 16:33:22 +0100 | [diff] [blame] | 2012 | HIGHBD_MBFP(BLOCK_128X128, aom_highbd_masked_sad128x128_bits10, |
| 2013 | aom_highbd_10_masked_sub_pixel_variance128x128) |
| 2014 | HIGHBD_MBFP(BLOCK_128X64, aom_highbd_masked_sad128x64_bits10, |
| 2015 | aom_highbd_10_masked_sub_pixel_variance128x64) |
| 2016 | HIGHBD_MBFP(BLOCK_64X128, aom_highbd_masked_sad64x128_bits10, |
| 2017 | aom_highbd_10_masked_sub_pixel_variance64x128) |
David Barker | f19f35f | 2017-05-22 16:33:22 +0100 | [diff] [blame] | 2018 | HIGHBD_MBFP(BLOCK_64X64, aom_highbd_masked_sad64x64_bits10, |
| 2019 | aom_highbd_10_masked_sub_pixel_variance64x64) |
| 2020 | HIGHBD_MBFP(BLOCK_64X32, aom_highbd_masked_sad64x32_bits10, |
| 2021 | aom_highbd_10_masked_sub_pixel_variance64x32) |
| 2022 | HIGHBD_MBFP(BLOCK_32X64, aom_highbd_masked_sad32x64_bits10, |
| 2023 | aom_highbd_10_masked_sub_pixel_variance32x64) |
| 2024 | HIGHBD_MBFP(BLOCK_32X32, aom_highbd_masked_sad32x32_bits10, |
| 2025 | aom_highbd_10_masked_sub_pixel_variance32x32) |
| 2026 | HIGHBD_MBFP(BLOCK_32X16, aom_highbd_masked_sad32x16_bits10, |
| 2027 | aom_highbd_10_masked_sub_pixel_variance32x16) |
| 2028 | HIGHBD_MBFP(BLOCK_16X32, aom_highbd_masked_sad16x32_bits10, |
| 2029 | aom_highbd_10_masked_sub_pixel_variance16x32) |
| 2030 | HIGHBD_MBFP(BLOCK_16X16, aom_highbd_masked_sad16x16_bits10, |
| 2031 | aom_highbd_10_masked_sub_pixel_variance16x16) |
| 2032 | HIGHBD_MBFP(BLOCK_8X16, aom_highbd_masked_sad8x16_bits10, |
| 2033 | aom_highbd_10_masked_sub_pixel_variance8x16) |
| 2034 | HIGHBD_MBFP(BLOCK_16X8, aom_highbd_masked_sad16x8_bits10, |
| 2035 | aom_highbd_10_masked_sub_pixel_variance16x8) |
| 2036 | HIGHBD_MBFP(BLOCK_8X8, aom_highbd_masked_sad8x8_bits10, |
| 2037 | aom_highbd_10_masked_sub_pixel_variance8x8) |
| 2038 | HIGHBD_MBFP(BLOCK_4X8, aom_highbd_masked_sad4x8_bits10, |
| 2039 | aom_highbd_10_masked_sub_pixel_variance4x8) |
| 2040 | HIGHBD_MBFP(BLOCK_8X4, aom_highbd_masked_sad8x4_bits10, |
| 2041 | aom_highbd_10_masked_sub_pixel_variance8x4) |
| 2042 | HIGHBD_MBFP(BLOCK_4X4, aom_highbd_masked_sad4x4_bits10, |
| 2043 | aom_highbd_10_masked_sub_pixel_variance4x4) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 2044 | HIGHBD_MBFP(BLOCK_64X16, aom_highbd_masked_sad64x16_bits10, |
| 2045 | aom_highbd_10_masked_sub_pixel_variance64x16) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 2046 | HIGHBD_MBFP(BLOCK_16X64, aom_highbd_masked_sad16x64_bits10, |
| 2047 | aom_highbd_10_masked_sub_pixel_variance16x64) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2048 | HIGHBD_MBFP(BLOCK_32X8, aom_highbd_masked_sad32x8_bits10, |
| 2049 | aom_highbd_10_masked_sub_pixel_variance32x8) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2050 | HIGHBD_MBFP(BLOCK_8X32, aom_highbd_masked_sad8x32_bits10, |
| 2051 | aom_highbd_10_masked_sub_pixel_variance8x32) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2052 | HIGHBD_MBFP(BLOCK_16X4, aom_highbd_masked_sad16x4_bits10, |
| 2053 | aom_highbd_10_masked_sub_pixel_variance16x4) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2054 | HIGHBD_MBFP(BLOCK_4X16, aom_highbd_masked_sad4x16_bits10, |
| 2055 | aom_highbd_10_masked_sub_pixel_variance4x16) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2056 | HIGHBD_OBFP(BLOCK_128X128, aom_highbd_obmc_sad128x128_bits10, |
| 2057 | aom_highbd_10_obmc_variance128x128, |
| 2058 | aom_highbd_10_obmc_sub_pixel_variance128x128) |
| 2059 | HIGHBD_OBFP(BLOCK_128X64, aom_highbd_obmc_sad128x64_bits10, |
| 2060 | aom_highbd_10_obmc_variance128x64, |
| 2061 | aom_highbd_10_obmc_sub_pixel_variance128x64) |
| 2062 | HIGHBD_OBFP(BLOCK_64X128, aom_highbd_obmc_sad64x128_bits10, |
| 2063 | aom_highbd_10_obmc_variance64x128, |
| 2064 | aom_highbd_10_obmc_sub_pixel_variance64x128) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2065 | HIGHBD_OBFP(BLOCK_64X64, aom_highbd_obmc_sad64x64_bits10, |
| 2066 | aom_highbd_10_obmc_variance64x64, |
| 2067 | aom_highbd_10_obmc_sub_pixel_variance64x64) |
| 2068 | HIGHBD_OBFP(BLOCK_64X32, aom_highbd_obmc_sad64x32_bits10, |
| 2069 | aom_highbd_10_obmc_variance64x32, |
| 2070 | aom_highbd_10_obmc_sub_pixel_variance64x32) |
| 2071 | HIGHBD_OBFP(BLOCK_32X64, aom_highbd_obmc_sad32x64_bits10, |
| 2072 | aom_highbd_10_obmc_variance32x64, |
| 2073 | aom_highbd_10_obmc_sub_pixel_variance32x64) |
| 2074 | HIGHBD_OBFP(BLOCK_32X32, aom_highbd_obmc_sad32x32_bits10, |
| 2075 | aom_highbd_10_obmc_variance32x32, |
| 2076 | aom_highbd_10_obmc_sub_pixel_variance32x32) |
| 2077 | HIGHBD_OBFP(BLOCK_32X16, aom_highbd_obmc_sad32x16_bits10, |
| 2078 | aom_highbd_10_obmc_variance32x16, |
| 2079 | aom_highbd_10_obmc_sub_pixel_variance32x16) |
| 2080 | HIGHBD_OBFP(BLOCK_16X32, aom_highbd_obmc_sad16x32_bits10, |
| 2081 | aom_highbd_10_obmc_variance16x32, |
| 2082 | aom_highbd_10_obmc_sub_pixel_variance16x32) |
| 2083 | HIGHBD_OBFP(BLOCK_16X16, aom_highbd_obmc_sad16x16_bits10, |
| 2084 | aom_highbd_10_obmc_variance16x16, |
| 2085 | aom_highbd_10_obmc_sub_pixel_variance16x16) |
| 2086 | HIGHBD_OBFP(BLOCK_8X16, aom_highbd_obmc_sad8x16_bits10, |
| 2087 | aom_highbd_10_obmc_variance8x16, |
| 2088 | aom_highbd_10_obmc_sub_pixel_variance8x16) |
| 2089 | HIGHBD_OBFP(BLOCK_16X8, aom_highbd_obmc_sad16x8_bits10, |
| 2090 | aom_highbd_10_obmc_variance16x8, |
| 2091 | aom_highbd_10_obmc_sub_pixel_variance16x8) |
| 2092 | HIGHBD_OBFP(BLOCK_8X8, aom_highbd_obmc_sad8x8_bits10, |
| 2093 | aom_highbd_10_obmc_variance8x8, |
| 2094 | aom_highbd_10_obmc_sub_pixel_variance8x8) |
| 2095 | HIGHBD_OBFP(BLOCK_4X8, aom_highbd_obmc_sad4x8_bits10, |
| 2096 | aom_highbd_10_obmc_variance4x8, |
| 2097 | aom_highbd_10_obmc_sub_pixel_variance4x8) |
| 2098 | HIGHBD_OBFP(BLOCK_8X4, aom_highbd_obmc_sad8x4_bits10, |
| 2099 | aom_highbd_10_obmc_variance8x4, |
| 2100 | aom_highbd_10_obmc_sub_pixel_variance8x4) |
| 2101 | HIGHBD_OBFP(BLOCK_4X4, aom_highbd_obmc_sad4x4_bits10, |
| 2102 | aom_highbd_10_obmc_variance4x4, |
| 2103 | aom_highbd_10_obmc_sub_pixel_variance4x4) |
Rupert Swarbrick | 2fa6e1c | 2017-09-11 12:38:10 +0100 | [diff] [blame] | 2104 | |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 2105 | HIGHBD_OBFP(BLOCK_64X16, aom_highbd_obmc_sad64x16_bits10, |
| 2106 | aom_highbd_10_obmc_variance64x16, |
| 2107 | aom_highbd_10_obmc_sub_pixel_variance64x16) |
| 2108 | |
| 2109 | HIGHBD_OBFP(BLOCK_16X64, aom_highbd_obmc_sad16x64_bits10, |
| 2110 | aom_highbd_10_obmc_variance16x64, |
| 2111 | aom_highbd_10_obmc_sub_pixel_variance16x64) |
| 2112 | |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2113 | HIGHBD_OBFP(BLOCK_32X8, aom_highbd_obmc_sad32x8_bits10, |
| 2114 | aom_highbd_10_obmc_variance32x8, |
| 2115 | aom_highbd_10_obmc_sub_pixel_variance32x8) |
| 2116 | |
| 2117 | HIGHBD_OBFP(BLOCK_8X32, aom_highbd_obmc_sad8x32_bits10, |
| 2118 | aom_highbd_10_obmc_variance8x32, |
| 2119 | aom_highbd_10_obmc_sub_pixel_variance8x32) |
| 2120 | |
| 2121 | HIGHBD_OBFP(BLOCK_16X4, aom_highbd_obmc_sad16x4_bits10, |
| 2122 | aom_highbd_10_obmc_variance16x4, |
| 2123 | aom_highbd_10_obmc_sub_pixel_variance16x4) |
| 2124 | |
| 2125 | HIGHBD_OBFP(BLOCK_4X16, aom_highbd_obmc_sad4x16_bits10, |
| 2126 | aom_highbd_10_obmc_variance4x16, |
| 2127 | aom_highbd_10_obmc_sub_pixel_variance4x16) |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2128 | break; |
| 2129 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2130 | case AOM_BITS_12: |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2131 | HIGHBD_BFP(BLOCK_64X16, aom_highbd_sad64x16_bits12, |
| 2132 | aom_highbd_sad64x16_avg_bits12, aom_highbd_12_variance64x16, |
| 2133 | aom_highbd_12_sub_pixel_variance64x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2134 | aom_highbd_12_sub_pixel_avg_variance64x16, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2135 | aom_highbd_sad64x16x4d_bits12, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2136 | aom_highbd_dist_wtd_sad64x16_avg_bits12, |
| 2137 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance64x16); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2138 | |
| 2139 | HIGHBD_BFP(BLOCK_16X64, aom_highbd_sad16x64_bits12, |
| 2140 | aom_highbd_sad16x64_avg_bits12, aom_highbd_12_variance16x64, |
| 2141 | aom_highbd_12_sub_pixel_variance16x64, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2142 | aom_highbd_12_sub_pixel_avg_variance16x64, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2143 | aom_highbd_sad16x64x4d_bits12, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2144 | aom_highbd_dist_wtd_sad16x64_avg_bits12, |
| 2145 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance16x64); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2146 | |
| 2147 | HIGHBD_BFP(BLOCK_32X8, aom_highbd_sad32x8_bits12, |
| 2148 | aom_highbd_sad32x8_avg_bits12, aom_highbd_12_variance32x8, |
| 2149 | aom_highbd_12_sub_pixel_variance32x8, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2150 | aom_highbd_12_sub_pixel_avg_variance32x8, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2151 | aom_highbd_sad32x8x4d_bits12, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2152 | aom_highbd_dist_wtd_sad32x8_avg_bits12, |
| 2153 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance32x8); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2154 | |
| 2155 | HIGHBD_BFP(BLOCK_8X32, aom_highbd_sad8x32_bits12, |
| 2156 | aom_highbd_sad8x32_avg_bits12, aom_highbd_12_variance8x32, |
| 2157 | aom_highbd_12_sub_pixel_variance8x32, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2158 | aom_highbd_12_sub_pixel_avg_variance8x32, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2159 | aom_highbd_sad8x32x4d_bits12, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2160 | aom_highbd_dist_wtd_sad8x32_avg_bits12, |
| 2161 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance8x32); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2162 | |
| 2163 | HIGHBD_BFP(BLOCK_16X4, aom_highbd_sad16x4_bits12, |
| 2164 | aom_highbd_sad16x4_avg_bits12, aom_highbd_12_variance16x4, |
| 2165 | aom_highbd_12_sub_pixel_variance16x4, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2166 | aom_highbd_12_sub_pixel_avg_variance16x4, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2167 | aom_highbd_sad16x4x4d_bits12, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2168 | aom_highbd_dist_wtd_sad16x4_avg_bits12, |
| 2169 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance16x4); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2170 | |
| 2171 | HIGHBD_BFP(BLOCK_4X16, aom_highbd_sad4x16_bits12, |
| 2172 | aom_highbd_sad4x16_avg_bits12, aom_highbd_12_variance4x16, |
| 2173 | aom_highbd_12_sub_pixel_variance4x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2174 | aom_highbd_12_sub_pixel_avg_variance4x16, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2175 | aom_highbd_sad4x16x4d_bits12, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2176 | aom_highbd_dist_wtd_sad4x16_avg_bits12, |
| 2177 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance4x16); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2178 | |
| 2179 | HIGHBD_BFP(BLOCK_32X16, aom_highbd_sad32x16_bits12, |
| 2180 | aom_highbd_sad32x16_avg_bits12, aom_highbd_12_variance32x16, |
| 2181 | aom_highbd_12_sub_pixel_variance32x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2182 | aom_highbd_12_sub_pixel_avg_variance32x16, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2183 | aom_highbd_sad32x16x4d_bits12, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2184 | aom_highbd_dist_wtd_sad32x16_avg_bits12, |
| 2185 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance32x16); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2186 | |
| 2187 | HIGHBD_BFP(BLOCK_16X32, aom_highbd_sad16x32_bits12, |
| 2188 | aom_highbd_sad16x32_avg_bits12, aom_highbd_12_variance16x32, |
| 2189 | aom_highbd_12_sub_pixel_variance16x32, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2190 | aom_highbd_12_sub_pixel_avg_variance16x32, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2191 | aom_highbd_sad16x32x4d_bits12, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2192 | aom_highbd_dist_wtd_sad16x32_avg_bits12, |
| 2193 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance16x32); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2194 | |
| 2195 | HIGHBD_BFP(BLOCK_64X32, aom_highbd_sad64x32_bits12, |
| 2196 | aom_highbd_sad64x32_avg_bits12, aom_highbd_12_variance64x32, |
| 2197 | aom_highbd_12_sub_pixel_variance64x32, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2198 | aom_highbd_12_sub_pixel_avg_variance64x32, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2199 | aom_highbd_sad64x32x4d_bits12, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2200 | aom_highbd_dist_wtd_sad64x32_avg_bits12, |
| 2201 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance64x32); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2202 | |
| 2203 | HIGHBD_BFP(BLOCK_32X64, aom_highbd_sad32x64_bits12, |
| 2204 | aom_highbd_sad32x64_avg_bits12, aom_highbd_12_variance32x64, |
| 2205 | aom_highbd_12_sub_pixel_variance32x64, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2206 | aom_highbd_12_sub_pixel_avg_variance32x64, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2207 | aom_highbd_sad32x64x4d_bits12, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2208 | aom_highbd_dist_wtd_sad32x64_avg_bits12, |
| 2209 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance32x64); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2210 | |
| 2211 | HIGHBD_BFP(BLOCK_32X32, aom_highbd_sad32x32_bits12, |
| 2212 | aom_highbd_sad32x32_avg_bits12, aom_highbd_12_variance32x32, |
| 2213 | aom_highbd_12_sub_pixel_variance32x32, |
| 2214 | aom_highbd_12_sub_pixel_avg_variance32x32, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2215 | aom_highbd_sad32x32x4d_bits12, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2216 | aom_highbd_dist_wtd_sad32x32_avg_bits12, |
| 2217 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance32x32); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2218 | |
| 2219 | HIGHBD_BFP(BLOCK_64X64, aom_highbd_sad64x64_bits12, |
| 2220 | aom_highbd_sad64x64_avg_bits12, aom_highbd_12_variance64x64, |
| 2221 | aom_highbd_12_sub_pixel_variance64x64, |
| 2222 | aom_highbd_12_sub_pixel_avg_variance64x64, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2223 | aom_highbd_sad64x64x4d_bits12, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2224 | aom_highbd_dist_wtd_sad64x64_avg_bits12, |
| 2225 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance64x64); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2226 | |
| 2227 | HIGHBD_BFP(BLOCK_16X16, aom_highbd_sad16x16_bits12, |
| 2228 | aom_highbd_sad16x16_avg_bits12, aom_highbd_12_variance16x16, |
| 2229 | aom_highbd_12_sub_pixel_variance16x16, |
| 2230 | aom_highbd_12_sub_pixel_avg_variance16x16, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2231 | aom_highbd_sad16x16x4d_bits12, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2232 | aom_highbd_dist_wtd_sad16x16_avg_bits12, |
| 2233 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance16x16); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2234 | |
| 2235 | HIGHBD_BFP(BLOCK_16X8, aom_highbd_sad16x8_bits12, |
| 2236 | aom_highbd_sad16x8_avg_bits12, aom_highbd_12_variance16x8, |
| 2237 | aom_highbd_12_sub_pixel_variance16x8, |
| 2238 | aom_highbd_12_sub_pixel_avg_variance16x8, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2239 | aom_highbd_sad16x8x4d_bits12, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2240 | aom_highbd_dist_wtd_sad16x8_avg_bits12, |
| 2241 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance16x8); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2242 | |
| 2243 | HIGHBD_BFP(BLOCK_8X16, aom_highbd_sad8x16_bits12, |
| 2244 | aom_highbd_sad8x16_avg_bits12, aom_highbd_12_variance8x16, |
| 2245 | aom_highbd_12_sub_pixel_variance8x16, |
| 2246 | aom_highbd_12_sub_pixel_avg_variance8x16, |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2247 | aom_highbd_sad8x16x4d_bits12, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2248 | aom_highbd_dist_wtd_sad8x16_avg_bits12, |
| 2249 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance8x16); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2250 | |
| 2251 | HIGHBD_BFP( |
| 2252 | BLOCK_8X8, aom_highbd_sad8x8_bits12, aom_highbd_sad8x8_avg_bits12, |
| 2253 | aom_highbd_12_variance8x8, aom_highbd_12_sub_pixel_variance8x8, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2254 | aom_highbd_12_sub_pixel_avg_variance8x8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2255 | aom_highbd_sad8x8x4d_bits12, aom_highbd_dist_wtd_sad8x8_avg_bits12, |
| 2256 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance8x8); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2257 | |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2258 | HIGHBD_BFP( |
| 2259 | BLOCK_8X4, aom_highbd_sad8x4_bits12, aom_highbd_sad8x4_avg_bits12, |
| 2260 | aom_highbd_12_variance8x4, aom_highbd_12_sub_pixel_variance8x4, |
| 2261 | aom_highbd_12_sub_pixel_avg_variance8x4, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2262 | aom_highbd_sad8x4x4d_bits12, aom_highbd_dist_wtd_sad8x4_avg_bits12, |
| 2263 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance8x4); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2264 | |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2265 | HIGHBD_BFP( |
| 2266 | BLOCK_4X8, aom_highbd_sad4x8_bits12, aom_highbd_sad4x8_avg_bits12, |
| 2267 | aom_highbd_12_variance4x8, aom_highbd_12_sub_pixel_variance4x8, |
| 2268 | aom_highbd_12_sub_pixel_avg_variance4x8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2269 | aom_highbd_sad4x8x4d_bits12, aom_highbd_dist_wtd_sad4x8_avg_bits12, |
| 2270 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance4x8); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2271 | |
| 2272 | HIGHBD_BFP( |
| 2273 | BLOCK_4X4, aom_highbd_sad4x4_bits12, aom_highbd_sad4x4_avg_bits12, |
| 2274 | aom_highbd_12_variance4x4, aom_highbd_12_sub_pixel_variance4x4, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2275 | aom_highbd_12_sub_pixel_avg_variance4x4, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2276 | aom_highbd_sad4x4x4d_bits12, aom_highbd_dist_wtd_sad4x4_avg_bits12, |
| 2277 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance4x4); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2278 | |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2279 | HIGHBD_BFP(BLOCK_128X128, aom_highbd_sad128x128_bits12, |
| 2280 | aom_highbd_sad128x128_avg_bits12, |
| 2281 | aom_highbd_12_variance128x128, |
| 2282 | aom_highbd_12_sub_pixel_variance128x128, |
| 2283 | aom_highbd_12_sub_pixel_avg_variance128x128, |
| 2284 | aom_highbd_sad128x128x4d_bits12, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2285 | aom_highbd_dist_wtd_sad128x128_avg_bits12, |
| 2286 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance128x128); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2287 | |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2288 | HIGHBD_BFP(BLOCK_128X64, aom_highbd_sad128x64_bits12, |
| 2289 | aom_highbd_sad128x64_avg_bits12, |
| 2290 | aom_highbd_12_variance128x64, |
| 2291 | aom_highbd_12_sub_pixel_variance128x64, |
| 2292 | aom_highbd_12_sub_pixel_avg_variance128x64, |
| 2293 | aom_highbd_sad128x64x4d_bits12, |
| 2294 | aom_highbd_dist_wtd_sad128x64_avg_bits12, |
| 2295 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance128x64); |
Cheng Chen | bf3d496 | 2017-11-01 14:48:52 -0700 | [diff] [blame] | 2296 | |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2297 | HIGHBD_BFP(BLOCK_64X128, aom_highbd_sad64x128_bits12, |
| 2298 | aom_highbd_sad64x128_avg_bits12, |
| 2299 | aom_highbd_12_variance64x128, |
| 2300 | aom_highbd_12_sub_pixel_variance64x128, |
| 2301 | aom_highbd_12_sub_pixel_avg_variance64x128, |
| 2302 | aom_highbd_sad64x128x4d_bits12, |
| 2303 | aom_highbd_dist_wtd_sad64x128_avg_bits12, |
| 2304 | aom_highbd_12_dist_wtd_sub_pixel_avg_variance64x128); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2305 | |
David Barker | f19f35f | 2017-05-22 16:33:22 +0100 | [diff] [blame] | 2306 | HIGHBD_MBFP(BLOCK_128X128, aom_highbd_masked_sad128x128_bits12, |
| 2307 | aom_highbd_12_masked_sub_pixel_variance128x128) |
| 2308 | HIGHBD_MBFP(BLOCK_128X64, aom_highbd_masked_sad128x64_bits12, |
| 2309 | aom_highbd_12_masked_sub_pixel_variance128x64) |
| 2310 | HIGHBD_MBFP(BLOCK_64X128, aom_highbd_masked_sad64x128_bits12, |
| 2311 | aom_highbd_12_masked_sub_pixel_variance64x128) |
David Barker | f19f35f | 2017-05-22 16:33:22 +0100 | [diff] [blame] | 2312 | HIGHBD_MBFP(BLOCK_64X64, aom_highbd_masked_sad64x64_bits12, |
| 2313 | aom_highbd_12_masked_sub_pixel_variance64x64) |
| 2314 | HIGHBD_MBFP(BLOCK_64X32, aom_highbd_masked_sad64x32_bits12, |
| 2315 | aom_highbd_12_masked_sub_pixel_variance64x32) |
| 2316 | HIGHBD_MBFP(BLOCK_32X64, aom_highbd_masked_sad32x64_bits12, |
| 2317 | aom_highbd_12_masked_sub_pixel_variance32x64) |
| 2318 | HIGHBD_MBFP(BLOCK_32X32, aom_highbd_masked_sad32x32_bits12, |
| 2319 | aom_highbd_12_masked_sub_pixel_variance32x32) |
| 2320 | HIGHBD_MBFP(BLOCK_32X16, aom_highbd_masked_sad32x16_bits12, |
| 2321 | aom_highbd_12_masked_sub_pixel_variance32x16) |
| 2322 | HIGHBD_MBFP(BLOCK_16X32, aom_highbd_masked_sad16x32_bits12, |
| 2323 | aom_highbd_12_masked_sub_pixel_variance16x32) |
| 2324 | HIGHBD_MBFP(BLOCK_16X16, aom_highbd_masked_sad16x16_bits12, |
| 2325 | aom_highbd_12_masked_sub_pixel_variance16x16) |
| 2326 | HIGHBD_MBFP(BLOCK_8X16, aom_highbd_masked_sad8x16_bits12, |
| 2327 | aom_highbd_12_masked_sub_pixel_variance8x16) |
| 2328 | HIGHBD_MBFP(BLOCK_16X8, aom_highbd_masked_sad16x8_bits12, |
| 2329 | aom_highbd_12_masked_sub_pixel_variance16x8) |
| 2330 | HIGHBD_MBFP(BLOCK_8X8, aom_highbd_masked_sad8x8_bits12, |
| 2331 | aom_highbd_12_masked_sub_pixel_variance8x8) |
| 2332 | HIGHBD_MBFP(BLOCK_4X8, aom_highbd_masked_sad4x8_bits12, |
| 2333 | aom_highbd_12_masked_sub_pixel_variance4x8) |
| 2334 | HIGHBD_MBFP(BLOCK_8X4, aom_highbd_masked_sad8x4_bits12, |
| 2335 | aom_highbd_12_masked_sub_pixel_variance8x4) |
| 2336 | HIGHBD_MBFP(BLOCK_4X4, aom_highbd_masked_sad4x4_bits12, |
| 2337 | aom_highbd_12_masked_sub_pixel_variance4x4) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 2338 | HIGHBD_MBFP(BLOCK_64X16, aom_highbd_masked_sad64x16_bits12, |
| 2339 | aom_highbd_12_masked_sub_pixel_variance64x16) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 2340 | HIGHBD_MBFP(BLOCK_16X64, aom_highbd_masked_sad16x64_bits12, |
| 2341 | aom_highbd_12_masked_sub_pixel_variance16x64) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2342 | HIGHBD_MBFP(BLOCK_32X8, aom_highbd_masked_sad32x8_bits12, |
| 2343 | aom_highbd_12_masked_sub_pixel_variance32x8) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2344 | HIGHBD_MBFP(BLOCK_8X32, aom_highbd_masked_sad8x32_bits12, |
| 2345 | aom_highbd_12_masked_sub_pixel_variance8x32) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2346 | HIGHBD_MBFP(BLOCK_16X4, aom_highbd_masked_sad16x4_bits12, |
| 2347 | aom_highbd_12_masked_sub_pixel_variance16x4) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2348 | HIGHBD_MBFP(BLOCK_4X16, aom_highbd_masked_sad4x16_bits12, |
| 2349 | aom_highbd_12_masked_sub_pixel_variance4x16) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2350 | HIGHBD_OBFP(BLOCK_128X128, aom_highbd_obmc_sad128x128_bits12, |
| 2351 | aom_highbd_12_obmc_variance128x128, |
| 2352 | aom_highbd_12_obmc_sub_pixel_variance128x128) |
| 2353 | HIGHBD_OBFP(BLOCK_128X64, aom_highbd_obmc_sad128x64_bits12, |
| 2354 | aom_highbd_12_obmc_variance128x64, |
| 2355 | aom_highbd_12_obmc_sub_pixel_variance128x64) |
| 2356 | HIGHBD_OBFP(BLOCK_64X128, aom_highbd_obmc_sad64x128_bits12, |
| 2357 | aom_highbd_12_obmc_variance64x128, |
| 2358 | aom_highbd_12_obmc_sub_pixel_variance64x128) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2359 | HIGHBD_OBFP(BLOCK_64X64, aom_highbd_obmc_sad64x64_bits12, |
| 2360 | aom_highbd_12_obmc_variance64x64, |
| 2361 | aom_highbd_12_obmc_sub_pixel_variance64x64) |
| 2362 | HIGHBD_OBFP(BLOCK_64X32, aom_highbd_obmc_sad64x32_bits12, |
| 2363 | aom_highbd_12_obmc_variance64x32, |
| 2364 | aom_highbd_12_obmc_sub_pixel_variance64x32) |
| 2365 | HIGHBD_OBFP(BLOCK_32X64, aom_highbd_obmc_sad32x64_bits12, |
| 2366 | aom_highbd_12_obmc_variance32x64, |
| 2367 | aom_highbd_12_obmc_sub_pixel_variance32x64) |
| 2368 | HIGHBD_OBFP(BLOCK_32X32, aom_highbd_obmc_sad32x32_bits12, |
| 2369 | aom_highbd_12_obmc_variance32x32, |
| 2370 | aom_highbd_12_obmc_sub_pixel_variance32x32) |
| 2371 | HIGHBD_OBFP(BLOCK_32X16, aom_highbd_obmc_sad32x16_bits12, |
| 2372 | aom_highbd_12_obmc_variance32x16, |
| 2373 | aom_highbd_12_obmc_sub_pixel_variance32x16) |
| 2374 | HIGHBD_OBFP(BLOCK_16X32, aom_highbd_obmc_sad16x32_bits12, |
| 2375 | aom_highbd_12_obmc_variance16x32, |
| 2376 | aom_highbd_12_obmc_sub_pixel_variance16x32) |
| 2377 | HIGHBD_OBFP(BLOCK_16X16, aom_highbd_obmc_sad16x16_bits12, |
| 2378 | aom_highbd_12_obmc_variance16x16, |
| 2379 | aom_highbd_12_obmc_sub_pixel_variance16x16) |
| 2380 | HIGHBD_OBFP(BLOCK_8X16, aom_highbd_obmc_sad8x16_bits12, |
| 2381 | aom_highbd_12_obmc_variance8x16, |
| 2382 | aom_highbd_12_obmc_sub_pixel_variance8x16) |
| 2383 | HIGHBD_OBFP(BLOCK_16X8, aom_highbd_obmc_sad16x8_bits12, |
| 2384 | aom_highbd_12_obmc_variance16x8, |
| 2385 | aom_highbd_12_obmc_sub_pixel_variance16x8) |
| 2386 | HIGHBD_OBFP(BLOCK_8X8, aom_highbd_obmc_sad8x8_bits12, |
| 2387 | aom_highbd_12_obmc_variance8x8, |
| 2388 | aom_highbd_12_obmc_sub_pixel_variance8x8) |
| 2389 | HIGHBD_OBFP(BLOCK_4X8, aom_highbd_obmc_sad4x8_bits12, |
| 2390 | aom_highbd_12_obmc_variance4x8, |
| 2391 | aom_highbd_12_obmc_sub_pixel_variance4x8) |
| 2392 | HIGHBD_OBFP(BLOCK_8X4, aom_highbd_obmc_sad8x4_bits12, |
| 2393 | aom_highbd_12_obmc_variance8x4, |
| 2394 | aom_highbd_12_obmc_sub_pixel_variance8x4) |
| 2395 | HIGHBD_OBFP(BLOCK_4X4, aom_highbd_obmc_sad4x4_bits12, |
| 2396 | aom_highbd_12_obmc_variance4x4, |
| 2397 | aom_highbd_12_obmc_sub_pixel_variance4x4) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 2398 | HIGHBD_OBFP(BLOCK_64X16, aom_highbd_obmc_sad64x16_bits12, |
| 2399 | aom_highbd_12_obmc_variance64x16, |
| 2400 | aom_highbd_12_obmc_sub_pixel_variance64x16) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 2401 | HIGHBD_OBFP(BLOCK_16X64, aom_highbd_obmc_sad16x64_bits12, |
| 2402 | aom_highbd_12_obmc_variance16x64, |
| 2403 | aom_highbd_12_obmc_sub_pixel_variance16x64) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2404 | HIGHBD_OBFP(BLOCK_32X8, aom_highbd_obmc_sad32x8_bits12, |
| 2405 | aom_highbd_12_obmc_variance32x8, |
| 2406 | aom_highbd_12_obmc_sub_pixel_variance32x8) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2407 | HIGHBD_OBFP(BLOCK_8X32, aom_highbd_obmc_sad8x32_bits12, |
| 2408 | aom_highbd_12_obmc_variance8x32, |
| 2409 | aom_highbd_12_obmc_sub_pixel_variance8x32) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2410 | HIGHBD_OBFP(BLOCK_16X4, aom_highbd_obmc_sad16x4_bits12, |
| 2411 | aom_highbd_12_obmc_variance16x4, |
| 2412 | aom_highbd_12_obmc_sub_pixel_variance16x4) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2413 | HIGHBD_OBFP(BLOCK_4X16, aom_highbd_obmc_sad4x16_bits12, |
| 2414 | aom_highbd_12_obmc_variance4x16, |
| 2415 | aom_highbd_12_obmc_sub_pixel_variance4x16) |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2416 | break; |
| 2417 | |
| 2418 | default: |
| 2419 | assert(0 && |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 2420 | "cm->seq_params.bit_depth should be AOM_BITS_8, " |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2421 | "AOM_BITS_10 or AOM_BITS_12"); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2422 | } |
| 2423 | } |
| 2424 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2425 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2426 | static void realloc_segmentation_maps(AV1_COMP *cpi) { |
| 2427 | AV1_COMMON *const cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2428 | |
| 2429 | // Create the encoder segmentation map and set all entries to 0 |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2430 | aom_free(cpi->segmentation_map); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2431 | CHECK_MEM_ERROR(cm, cpi->segmentation_map, |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2432 | aom_calloc(cm->mi_rows * cm->mi_cols, 1)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2433 | |
| 2434 | // Create a map used for cyclic background refresh. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2435 | if (cpi->cyclic_refresh) av1_cyclic_refresh_free(cpi->cyclic_refresh); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2436 | CHECK_MEM_ERROR(cm, cpi->cyclic_refresh, |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2437 | av1_cyclic_refresh_alloc(cm->mi_rows, cm->mi_cols)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2438 | |
| 2439 | // Create a map used to mark inactive areas. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2440 | aom_free(cpi->active_map.map); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2441 | CHECK_MEM_ERROR(cm, cpi->active_map.map, |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2442 | aom_calloc(cm->mi_rows * cm->mi_cols, 1)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2443 | } |
| 2444 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2445 | void av1_change_config(struct AV1_COMP *cpi, const AV1EncoderConfig *oxcf) { |
| 2446 | AV1_COMMON *const cm = &cpi->common; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 2447 | SequenceHeader *const seq_params = &cm->seq_params; |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 2448 | const int num_planes = av1_num_planes(cm); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2449 | RATE_CONTROL *const rc = &cpi->rc; |
hui su | d9a812b | 2017-07-06 14:34:37 -0700 | [diff] [blame] | 2450 | MACROBLOCK *const x = &cpi->td.mb; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2451 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 2452 | if (seq_params->profile != oxcf->profile) seq_params->profile = oxcf->profile; |
| 2453 | seq_params->bit_depth = oxcf->bit_depth; |
| 2454 | seq_params->color_primaries = oxcf->color_primaries; |
| 2455 | seq_params->transfer_characteristics = oxcf->transfer_characteristics; |
| 2456 | seq_params->matrix_coefficients = oxcf->matrix_coefficients; |
| 2457 | seq_params->monochrome = oxcf->monochrome; |
| 2458 | seq_params->chroma_sample_position = oxcf->chroma_sample_position; |
| 2459 | seq_params->color_range = oxcf->color_range; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2460 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 2461 | assert(IMPLIES(seq_params->profile <= PROFILE_1, |
| 2462 | seq_params->bit_depth <= AOM_BITS_10)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2463 | |
Andrey Norkin | 28e9ce2 | 2018-01-08 10:11:21 -0800 | [diff] [blame] | 2464 | cm->timing_info_present = oxcf->timing_info_present; |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 2465 | cm->timing_info.num_units_in_display_tick = |
| 2466 | oxcf->timing_info.num_units_in_display_tick; |
| 2467 | cm->timing_info.time_scale = oxcf->timing_info.time_scale; |
| 2468 | cm->timing_info.equal_picture_interval = |
| 2469 | oxcf->timing_info.equal_picture_interval; |
| 2470 | cm->timing_info.num_ticks_per_picture = |
| 2471 | oxcf->timing_info.num_ticks_per_picture; |
| 2472 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 2473 | seq_params->display_model_info_present_flag = |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 2474 | oxcf->display_model_info_present_flag; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 2475 | seq_params->decoder_model_info_present_flag = |
Adrian Grange | c56f6ec | 2018-05-31 14:19:32 -0700 | [diff] [blame] | 2476 | oxcf->decoder_model_info_present_flag; |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 2477 | if (oxcf->decoder_model_info_present_flag) { |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 2478 | // set the decoder model parameters in schedule mode |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 2479 | cm->buffer_model.num_units_in_decoding_tick = |
| 2480 | oxcf->buffer_model.num_units_in_decoding_tick; |
Wan-Teh Chang | f64b3bc | 2018-07-02 09:42:39 -0700 | [diff] [blame] | 2481 | cm->buffer_removal_time_present = 1; |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 2482 | set_aom_dec_model_info(&cm->buffer_model); |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 2483 | set_dec_model_op_parameters(&cm->op_params[0]); |
| 2484 | } else if (cm->timing_info_present && |
| 2485 | cm->timing_info.equal_picture_interval && |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 2486 | !seq_params->decoder_model_info_present_flag) { |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 2487 | // set the decoder model parameters in resource availability mode |
| 2488 | set_resource_availability_parameters(&cm->op_params[0]); |
Andrey Norkin | c7511de | 2018-06-22 12:31:06 -0700 | [diff] [blame] | 2489 | } else { |
| 2490 | cm->op_params[0].initial_display_delay = |
| 2491 | 10; // Default value (not signaled) |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 2492 | } |
Andrey Norkin | 28e9ce2 | 2018-01-08 10:11:21 -0800 | [diff] [blame] | 2493 | |
Andrey Norkin | 6f1c2f7 | 2018-01-15 20:08:52 -0800 | [diff] [blame] | 2494 | update_film_grain_parameters(cpi, oxcf); |
Andrey Norkin | 6f1c2f7 | 2018-01-15 20:08:52 -0800 | [diff] [blame] | 2495 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2496 | cpi->oxcf = *oxcf; |
Maxym Dmytrychenko | cc6e0e1 | 2018-02-05 16:35:37 +0100 | [diff] [blame] | 2497 | cpi->common.options = oxcf->cfg; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 2498 | x->e_mbd.bd = (int)seq_params->bit_depth; |
hui su | d9a812b | 2017-07-06 14:34:37 -0700 | [diff] [blame] | 2499 | x->e_mbd.global_motion = cm->global_motion; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2500 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2501 | if ((oxcf->pass == 0) && (oxcf->rc_mode == AOM_Q)) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2502 | rc->baseline_gf_interval = FIXED_GF_INTERVAL; |
| 2503 | } else { |
| 2504 | rc->baseline_gf_interval = (MIN_GF_INTERVAL + MAX_GF_INTERVAL) / 2; |
| 2505 | } |
| 2506 | |
| 2507 | cpi->refresh_last_frame = 1; |
| 2508 | cpi->refresh_golden_frame = 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2509 | cpi->refresh_bwd_ref_frame = 0; |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 2510 | cpi->refresh_alt2_ref_frame = 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2511 | |
Debargha Mukherjee | 229fdc8 | 2018-03-10 07:45:33 -0800 | [diff] [blame] | 2512 | cm->refresh_frame_context = (oxcf->frame_parallel_decoding_mode) |
| 2513 | ? REFRESH_FRAME_CONTEXT_DISABLED |
| 2514 | : REFRESH_FRAME_CONTEXT_BACKWARD; |
Rupert Swarbrick | 84b05ac | 2017-10-27 18:10:53 +0100 | [diff] [blame] | 2515 | if (oxcf->large_scale_tile) |
James Zern | f34dfc8 | 2018-02-23 16:53:33 -0800 | [diff] [blame] | 2516 | cm->refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED; |
Rupert Swarbrick | 84b05ac | 2017-10-27 18:10:53 +0100 | [diff] [blame] | 2517 | |
Alex Converse | 74ad091 | 2017-07-18 10:22:58 -0700 | [diff] [blame] | 2518 | if (x->palette_buffer == NULL) { |
hui su | d9a812b | 2017-07-06 14:34:37 -0700 | [diff] [blame] | 2519 | CHECK_MEM_ERROR(cm, x->palette_buffer, |
| 2520 | aom_memalign(16, sizeof(*x->palette_buffer))); |
| 2521 | } |
Urvang Joshi | 0a4cfad | 2018-09-07 11:10:39 -0700 | [diff] [blame] | 2522 | |
| 2523 | if (x->tmp_conv_dst == NULL) { |
| 2524 | CHECK_MEM_ERROR( |
| 2525 | cm, x->tmp_conv_dst, |
| 2526 | 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] | 2527 | x->e_mbd.tmp_conv_dst = x->tmp_conv_dst; |
Urvang Joshi | 0a4cfad | 2018-09-07 11:10:39 -0700 | [diff] [blame] | 2528 | } |
| 2529 | for (int i = 0; i < 2; ++i) { |
| 2530 | if (x->tmp_obmc_bufs[i] == NULL) { |
| 2531 | CHECK_MEM_ERROR(cm, x->tmp_obmc_bufs[i], |
wenyao.liu | 22d8ab3 | 2018-10-16 09:11:29 +0800 | [diff] [blame] | 2532 | aom_memalign(32, 2 * MAX_MB_PLANE * MAX_SB_SQUARE * |
Urvang Joshi | 0a4cfad | 2018-09-07 11:10:39 -0700 | [diff] [blame] | 2533 | sizeof(*x->tmp_obmc_bufs[i]))); |
Urvang Joshi | e58f6ec | 2018-09-10 15:10:12 -0700 | [diff] [blame] | 2534 | x->e_mbd.tmp_obmc_bufs[i] = x->tmp_obmc_bufs[i]; |
Urvang Joshi | 0a4cfad | 2018-09-07 11:10:39 -0700 | [diff] [blame] | 2535 | } |
| 2536 | } |
| 2537 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2538 | av1_reset_segment_features(cm); |
Debargha Mukherjee | b214775 | 2017-11-01 07:00:45 -0700 | [diff] [blame] | 2539 | set_high_precision_mv(cpi, 1, 0); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2540 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2541 | set_rc_buffer_sizes(rc, &cpi->oxcf); |
| 2542 | |
| 2543 | // Under a configuration change, where maximum_buffer_size may change, |
| 2544 | // keep buffer level clipped to the maximum allowed buffer size. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2545 | rc->bits_off_target = AOMMIN(rc->bits_off_target, rc->maximum_buffer_size); |
| 2546 | rc->buffer_level = AOMMIN(rc->buffer_level, rc->maximum_buffer_size); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2547 | |
| 2548 | // Set up frame rate and related parameters rate control values. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2549 | av1_new_framerate(cpi, cpi->framerate); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2550 | |
| 2551 | // Set absolute upper and lower quality limits |
| 2552 | rc->worst_quality = cpi->oxcf.worst_allowed_q; |
| 2553 | rc->best_quality = cpi->oxcf.best_allowed_q; |
| 2554 | |
Urvang Joshi | b55cb5e | 2018-09-12 14:50:21 -0700 | [diff] [blame] | 2555 | cm->interp_filter = oxcf->large_scale_tile ? EIGHTTAP_REGULAR : SWITCHABLE; |
Yue Chen | 5380cb5 | 2018-02-23 15:33:21 -0800 | [diff] [blame] | 2556 | cm->switchable_motion_mode = 1; |
| 2557 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2558 | if (cpi->oxcf.render_width > 0 && cpi->oxcf.render_height > 0) { |
| 2559 | cm->render_width = cpi->oxcf.render_width; |
| 2560 | cm->render_height = cpi->oxcf.render_height; |
| 2561 | } else { |
| 2562 | cm->render_width = cpi->oxcf.width; |
| 2563 | cm->render_height = cpi->oxcf.height; |
| 2564 | } |
| 2565 | cm->width = cpi->oxcf.width; |
| 2566 | cm->height = cpi->oxcf.height; |
| 2567 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 2568 | int sb_size = seq_params->sb_size; |
Urvang Joshi | e4530f8 | 2018-01-09 11:43:37 -0800 | [diff] [blame] | 2569 | // Superblock size should not be updated after the first key frame. |
| 2570 | if (!cpi->seq_params_locked) { |
| 2571 | set_sb_size(&cm->seq_params, select_sb_size(cpi)); |
| 2572 | } |
Dominic Symes | 917d6c0 | 2017-10-11 18:00:52 +0200 | [diff] [blame] | 2573 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 2574 | if (cpi->initial_width || sb_size != seq_params->sb_size) { |
Dominic Symes | 917d6c0 | 2017-10-11 18:00:52 +0200 | [diff] [blame] | 2575 | if (cm->width > cpi->initial_width || cm->height > cpi->initial_height || |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 2576 | seq_params->sb_size != sb_size) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2577 | av1_free_context_buffers(cm); |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 2578 | av1_free_pc_tree(&cpi->td, num_planes); |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 2579 | alloc_compressor_data(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2580 | realloc_segmentation_maps(cpi); |
| 2581 | cpi->initial_width = cpi->initial_height = 0; |
| 2582 | } |
| 2583 | } |
| 2584 | update_frame_size(cpi); |
| 2585 | |
| 2586 | cpi->alt_ref_source = NULL; |
| 2587 | rc->is_src_frame_alt_ref = 0; |
| 2588 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2589 | rc->is_bwd_ref_frame = 0; |
| 2590 | rc->is_last_bipred_frame = 0; |
| 2591 | rc->is_bipred_frame = 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2592 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2593 | set_tile_info(cpi); |
| 2594 | |
| 2595 | cpi->ext_refresh_frame_flags_pending = 0; |
| 2596 | cpi->ext_refresh_frame_context_pending = 0; |
| 2597 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2598 | highbd_set_var_fns(cpi); |
Imdad Sardharwalla | bf2cc01 | 2018-02-09 17:32:10 +0000 | [diff] [blame] | 2599 | |
Debargha Mukherjee | edd7725 | 2018-03-25 12:01:38 -0700 | [diff] [blame] | 2600 | // Init sequence level coding tools |
Debargha Mukherjee | f2e5bb3 | 2018-03-26 14:35:24 -0700 | [diff] [blame] | 2601 | // This should not be called after the first key frame. |
| 2602 | if (!cpi->seq_params_locked) { |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 2603 | seq_params->operating_points_cnt_minus_1 = |
Adrian Grange | c56f6ec | 2018-05-31 14:19:32 -0700 | [diff] [blame] | 2604 | cm->number_spatial_layers > 1 ? cm->number_spatial_layers - 1 : 0; |
Andrey Norkin | 2649551 | 2018-06-20 17:13:11 -0700 | [diff] [blame] | 2605 | init_seq_coding_tools(&cm->seq_params, cm, oxcf); |
Debargha Mukherjee | f2e5bb3 | 2018-03-26 14:35:24 -0700 | [diff] [blame] | 2606 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2607 | } |
| 2608 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2609 | AV1_COMP *av1_create_compressor(AV1EncoderConfig *oxcf, |
| 2610 | BufferPool *const pool) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2611 | unsigned int i; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2612 | AV1_COMP *volatile const cpi = aom_memalign(32, sizeof(AV1_COMP)); |
| 2613 | AV1_COMMON *volatile const cm = cpi != NULL ? &cpi->common : NULL; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2614 | |
| 2615 | if (!cm) return NULL; |
| 2616 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2617 | av1_zero(*cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2618 | |
Wan-Teh Chang | a2fad3e | 2018-07-19 16:55:19 -0700 | [diff] [blame] | 2619 | // The jmp_buf is valid only for the duration of the function that calls |
| 2620 | // setjmp(). Therefore, this function must reset the 'setjmp' field to 0 |
| 2621 | // before it returns. |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2622 | if (setjmp(cm->error.jmp)) { |
| 2623 | cm->error.setjmp = 0; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2624 | av1_remove_compressor(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2625 | return 0; |
| 2626 | } |
| 2627 | |
| 2628 | cm->error.setjmp = 1; |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 2629 | cm->alloc_mi = enc_alloc_mi; |
| 2630 | cm->free_mi = enc_free_mi; |
| 2631 | cm->setup_mi = enc_setup_mi; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2632 | |
Angie Chiang | a5d96c4 | 2016-10-21 16:16:56 -0700 | [diff] [blame] | 2633 | CHECK_MEM_ERROR(cm, cm->fc, |
| 2634 | (FRAME_CONTEXT *)aom_memalign(32, sizeof(*cm->fc))); |
David Turner | 1bcefb3 | 2018-11-19 17:54:00 +0000 | [diff] [blame] | 2635 | CHECK_MEM_ERROR( |
| 2636 | cm, cm->default_frame_context, |
| 2637 | (FRAME_CONTEXT *)aom_memalign(32, sizeof(*cm->default_frame_context))); |
Angie Chiang | a5d96c4 | 2016-10-21 16:16:56 -0700 | [diff] [blame] | 2638 | memset(cm->fc, 0, sizeof(*cm->fc)); |
David Turner | 1bcefb3 | 2018-11-19 17:54:00 +0000 | [diff] [blame] | 2639 | memset(cm->default_frame_context, 0, sizeof(*cm->default_frame_context)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2640 | |
| 2641 | cpi->resize_state = 0; |
| 2642 | cpi->resize_avg_qp = 0; |
| 2643 | cpi->resize_buffer_underflow = 0; |
Fergus Simpson | ddc846e | 2017-04-24 18:09:13 -0700 | [diff] [blame] | 2644 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2645 | cpi->common.buffer_pool = pool; |
| 2646 | |
| 2647 | init_config(cpi, oxcf); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2648 | av1_rc_init(&cpi->oxcf, oxcf->pass, &cpi->rc); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2649 | |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 2650 | cm->current_frame.frame_number = 0; |
Debargha Mukherjee | f2e5bb3 | 2018-03-26 14:35:24 -0700 | [diff] [blame] | 2651 | cpi->seq_params_locked = 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2652 | cpi->partition_search_skippable_frame = 0; |
| 2653 | cpi->tile_data = NULL; |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 2654 | cpi->last_show_frame_buf = NULL; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2655 | realloc_segmentation_maps(cpi); |
| 2656 | |
Jingning Han | f050fc1 | 2018-03-09 14:53:33 -0800 | [diff] [blame] | 2657 | memset(cpi->nmv_costs, 0, sizeof(cpi->nmv_costs)); |
| 2658 | memset(cpi->nmv_costs_hp, 0, sizeof(cpi->nmv_costs_hp)); |
James Zern | 01a9d70 | 2017-08-25 19:09:33 +0000 | [diff] [blame] | 2659 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2660 | for (i = 0; i < (sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0])); |
| 2661 | i++) { |
| 2662 | CHECK_MEM_ERROR( |
| 2663 | cm, cpi->mbgraph_stats[i].mb_stats, |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2664 | aom_calloc(cm->MBs * sizeof(*cpi->mbgraph_stats[i].mb_stats), 1)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2665 | } |
| 2666 | |
| 2667 | #if CONFIG_FP_MB_STATS |
| 2668 | cpi->use_fp_mb_stats = 0; |
| 2669 | if (cpi->use_fp_mb_stats) { |
| 2670 | // a place holder used to store the first pass mb stats in the first pass |
| 2671 | CHECK_MEM_ERROR(cm, cpi->twopass.frame_mb_stats_buf, |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2672 | aom_calloc(cm->MBs * sizeof(uint8_t), 1)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2673 | } else { |
| 2674 | cpi->twopass.frame_mb_stats_buf = NULL; |
| 2675 | } |
| 2676 | #endif |
| 2677 | |
| 2678 | cpi->refresh_alt_ref_frame = 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2679 | |
| 2680 | cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS; |
| 2681 | #if CONFIG_INTERNAL_STATS |
| 2682 | cpi->b_calculate_blockiness = 1; |
| 2683 | cpi->b_calculate_consistency = 1; |
| 2684 | cpi->total_inconsistency = 0; |
| 2685 | cpi->psnr.worst = 100.0; |
| 2686 | cpi->worst_ssim = 100.0; |
| 2687 | |
| 2688 | cpi->count = 0; |
| 2689 | cpi->bytes = 0; |
Debargha Mukherjee | 0857e66 | 2019-01-04 16:22:09 -0800 | [diff] [blame] | 2690 | #if CONFIG_SPEED_STATS |
| 2691 | cpi->tx_search_count = 0; |
| 2692 | #endif // CONFIG_SPEED_STATS |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2693 | |
| 2694 | if (cpi->b_calculate_psnr) { |
| 2695 | cpi->total_sq_error = 0; |
| 2696 | cpi->total_samples = 0; |
| 2697 | cpi->tot_recode_hits = 0; |
| 2698 | cpi->summed_quality = 0; |
| 2699 | cpi->summed_weights = 0; |
| 2700 | } |
| 2701 | |
| 2702 | cpi->fastssim.worst = 100.0; |
| 2703 | cpi->psnrhvs.worst = 100.0; |
| 2704 | |
| 2705 | if (cpi->b_calculate_blockiness) { |
| 2706 | cpi->total_blockiness = 0; |
| 2707 | cpi->worst_blockiness = 0.0; |
| 2708 | } |
| 2709 | |
| 2710 | if (cpi->b_calculate_consistency) { |
| 2711 | CHECK_MEM_ERROR(cm, cpi->ssim_vars, |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2712 | aom_malloc(sizeof(*cpi->ssim_vars) * 4 * |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2713 | cpi->common.mi_rows * cpi->common.mi_cols)); |
| 2714 | cpi->worst_consistency = 100.0; |
| 2715 | } |
| 2716 | #endif |
Debargha Mukherjee | 5802ebe | 2016-12-21 04:17:24 -0800 | [diff] [blame] | 2717 | #if CONFIG_ENTROPY_STATS |
| 2718 | av1_zero(aggregate_fc); |
| 2719 | #endif // CONFIG_ENTROPY_STATS |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2720 | |
| 2721 | cpi->first_time_stamp_ever = INT64_MAX; |
| 2722 | |
Jingning Han | f050fc1 | 2018-03-09 14:53:33 -0800 | [diff] [blame] | 2723 | cpi->td.mb.nmvcost[0] = &cpi->nmv_costs[0][MV_MAX]; |
| 2724 | cpi->td.mb.nmvcost[1] = &cpi->nmv_costs[1][MV_MAX]; |
| 2725 | cpi->td.mb.nmvcost_hp[0] = &cpi->nmv_costs_hp[0][MV_MAX]; |
| 2726 | cpi->td.mb.nmvcost_hp[1] = &cpi->nmv_costs_hp[1][MV_MAX]; |
James Zern | 01a9d70 | 2017-08-25 19:09:33 +0000 | [diff] [blame] | 2727 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2728 | #ifdef OUTPUT_YUV_SKINMAP |
| 2729 | yuv_skinmap_file = fopen("skinmap.yuv", "ab"); |
| 2730 | #endif |
| 2731 | #ifdef OUTPUT_YUV_REC |
| 2732 | yuv_rec_file = fopen("rec.yuv", "wb"); |
| 2733 | #endif |
| 2734 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2735 | if (oxcf->pass == 1) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2736 | av1_init_first_pass(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2737 | } else if (oxcf->pass == 2) { |
| 2738 | const size_t packet_sz = sizeof(FIRSTPASS_STATS); |
| 2739 | const int packets = (int)(oxcf->two_pass_stats_in.sz / packet_sz); |
| 2740 | |
| 2741 | #if CONFIG_FP_MB_STATS |
| 2742 | if (cpi->use_fp_mb_stats) { |
| 2743 | const size_t psz = cpi->common.MBs * sizeof(uint8_t); |
| 2744 | const int ps = (int)(oxcf->firstpass_mb_stats_in.sz / psz); |
| 2745 | |
| 2746 | cpi->twopass.firstpass_mb_stats.mb_stats_start = |
| 2747 | oxcf->firstpass_mb_stats_in.buf; |
| 2748 | cpi->twopass.firstpass_mb_stats.mb_stats_end = |
| 2749 | cpi->twopass.firstpass_mb_stats.mb_stats_start + |
| 2750 | (ps - 1) * cpi->common.MBs * sizeof(uint8_t); |
| 2751 | } |
| 2752 | #endif |
| 2753 | |
| 2754 | cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf; |
| 2755 | cpi->twopass.stats_in = cpi->twopass.stats_in_start; |
| 2756 | cpi->twopass.stats_in_end = &cpi->twopass.stats_in[packets - 1]; |
| 2757 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2758 | av1_init_second_pass(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2759 | } |
| 2760 | |
Jingning Han | d064cf0 | 2017-06-01 10:00:39 -0700 | [diff] [blame] | 2761 | CHECK_MEM_ERROR( |
| 2762 | cm, cpi->td.mb.above_pred_buf, |
Yue Chen | 1a79925 | 2018-03-01 16:47:41 -0800 | [diff] [blame] | 2763 | (uint8_t *)aom_memalign(16, MAX_MB_PLANE * MAX_SB_SQUARE * |
Johann | b0ef6ff | 2018-02-08 14:32:21 -0800 | [diff] [blame] | 2764 | sizeof(*cpi->td.mb.above_pred_buf))); |
Jingning Han | d064cf0 | 2017-06-01 10:00:39 -0700 | [diff] [blame] | 2765 | CHECK_MEM_ERROR( |
| 2766 | cm, cpi->td.mb.left_pred_buf, |
Yue Chen | 1a79925 | 2018-03-01 16:47:41 -0800 | [diff] [blame] | 2767 | (uint8_t *)aom_memalign(16, MAX_MB_PLANE * MAX_SB_SQUARE * |
Johann | b0ef6ff | 2018-02-08 14:32:21 -0800 | [diff] [blame] | 2768 | sizeof(*cpi->td.mb.left_pred_buf))); |
Jingning Han | d064cf0 | 2017-06-01 10:00:39 -0700 | [diff] [blame] | 2769 | |
| 2770 | CHECK_MEM_ERROR(cm, cpi->td.mb.wsrc_buf, |
| 2771 | (int32_t *)aom_memalign( |
| 2772 | 16, MAX_SB_SQUARE * sizeof(*cpi->td.mb.wsrc_buf))); |
| 2773 | |
Ravi Chaudhary | 5d970f4 | 2018-09-25 11:25:32 +0530 | [diff] [blame] | 2774 | #if CONFIG_COLLECT_INTER_MODE_RD_STATS |
| 2775 | CHECK_MEM_ERROR( |
| 2776 | cm, cpi->td.mb.inter_modes_info, |
| 2777 | (InterModesInfo *)aom_malloc(sizeof(*cpi->td.mb.inter_modes_info))); |
| 2778 | #endif |
| 2779 | |
Ravi Chaudhary | 783d6a3 | 2018-08-28 18:21:02 +0530 | [diff] [blame] | 2780 | for (int x = 0; x < 2; x++) |
| 2781 | for (int y = 0; y < 2; y++) |
| 2782 | CHECK_MEM_ERROR( |
| 2783 | cm, cpi->td.mb.hash_value_buffer[x][y], |
| 2784 | (uint32_t *)aom_malloc(AOM_BUFFER_SIZE_FOR_BLOCK_HASH * |
| 2785 | sizeof(*cpi->td.mb.hash_value_buffer[0][0]))); |
| 2786 | |
| 2787 | cpi->td.mb.g_crc_initialized = 0; |
| 2788 | |
Jingning Han | d064cf0 | 2017-06-01 10:00:39 -0700 | [diff] [blame] | 2789 | CHECK_MEM_ERROR(cm, cpi->td.mb.mask_buf, |
| 2790 | (int32_t *)aom_memalign( |
| 2791 | 16, MAX_SB_SQUARE * sizeof(*cpi->td.mb.mask_buf))); |
| 2792 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2793 | av1_set_speed_features_framesize_independent(cpi); |
| 2794 | av1_set_speed_features_framesize_dependent(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2795 | |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 2796 | for (int frame = 0; frame < MAX_LAG_BUFFERS; ++frame) { |
| 2797 | int mi_cols = ALIGN_POWER_OF_TWO(cm->mi_cols, MAX_MIB_SIZE_LOG2); |
| 2798 | int mi_rows = ALIGN_POWER_OF_TWO(cm->mi_rows, MAX_MIB_SIZE_LOG2); |
| 2799 | |
| 2800 | CHECK_MEM_ERROR(cm, cpi->tpl_stats[frame].tpl_stats_ptr, |
| 2801 | aom_calloc(mi_rows * mi_cols, |
| 2802 | sizeof(*cpi->tpl_stats[frame].tpl_stats_ptr))); |
| 2803 | cpi->tpl_stats[frame].is_valid = 0; |
| 2804 | cpi->tpl_stats[frame].width = mi_cols; |
| 2805 | cpi->tpl_stats[frame].height = mi_rows; |
| 2806 | cpi->tpl_stats[frame].stride = mi_cols; |
| 2807 | cpi->tpl_stats[frame].mi_rows = cm->mi_rows; |
| 2808 | cpi->tpl_stats[frame].mi_cols = cm->mi_cols; |
| 2809 | } |
| 2810 | |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2811 | #define BFP(BT, SDF, SDAF, VF, SVF, SVAF, SDX4DF, JSDAF, JSVAF) \ |
| 2812 | cpi->fn_ptr[BT].sdf = SDF; \ |
| 2813 | cpi->fn_ptr[BT].sdaf = SDAF; \ |
| 2814 | cpi->fn_ptr[BT].vf = VF; \ |
| 2815 | cpi->fn_ptr[BT].svf = SVF; \ |
| 2816 | cpi->fn_ptr[BT].svaf = SVAF; \ |
| 2817 | cpi->fn_ptr[BT].sdx4df = SDX4DF; \ |
| 2818 | cpi->fn_ptr[BT].jsdaf = JSDAF; \ |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2819 | cpi->fn_ptr[BT].jsvaf = JSVAF; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2820 | |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2821 | BFP(BLOCK_4X16, aom_sad4x16, aom_sad4x16_avg, aom_variance4x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2822 | aom_sub_pixel_variance4x16, aom_sub_pixel_avg_variance4x16, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2823 | aom_sad4x16x4d, aom_dist_wtd_sad4x16_avg, |
| 2824 | aom_dist_wtd_sub_pixel_avg_variance4x16) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2825 | |
| 2826 | BFP(BLOCK_16X4, aom_sad16x4, aom_sad16x4_avg, aom_variance16x4, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2827 | aom_sub_pixel_variance16x4, aom_sub_pixel_avg_variance16x4, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2828 | aom_sad16x4x4d, aom_dist_wtd_sad16x4_avg, |
| 2829 | aom_dist_wtd_sub_pixel_avg_variance16x4) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2830 | |
| 2831 | BFP(BLOCK_8X32, aom_sad8x32, aom_sad8x32_avg, aom_variance8x32, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2832 | aom_sub_pixel_variance8x32, aom_sub_pixel_avg_variance8x32, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2833 | aom_sad8x32x4d, aom_dist_wtd_sad8x32_avg, |
| 2834 | aom_dist_wtd_sub_pixel_avg_variance8x32) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2835 | |
| 2836 | BFP(BLOCK_32X8, aom_sad32x8, aom_sad32x8_avg, aom_variance32x8, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2837 | aom_sub_pixel_variance32x8, aom_sub_pixel_avg_variance32x8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2838 | aom_sad32x8x4d, aom_dist_wtd_sad32x8_avg, |
| 2839 | aom_dist_wtd_sub_pixel_avg_variance32x8) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2840 | |
| 2841 | BFP(BLOCK_16X64, aom_sad16x64, aom_sad16x64_avg, aom_variance16x64, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2842 | aom_sub_pixel_variance16x64, aom_sub_pixel_avg_variance16x64, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2843 | aom_sad16x64x4d, aom_dist_wtd_sad16x64_avg, |
| 2844 | aom_dist_wtd_sub_pixel_avg_variance16x64) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2845 | |
| 2846 | BFP(BLOCK_64X16, aom_sad64x16, aom_sad64x16_avg, aom_variance64x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2847 | aom_sub_pixel_variance64x16, aom_sub_pixel_avg_variance64x16, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2848 | aom_sad64x16x4d, aom_dist_wtd_sad64x16_avg, |
| 2849 | aom_dist_wtd_sub_pixel_avg_variance64x16) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2850 | |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2851 | BFP(BLOCK_128X128, aom_sad128x128, aom_sad128x128_avg, aom_variance128x128, |
| 2852 | aom_sub_pixel_variance128x128, aom_sub_pixel_avg_variance128x128, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2853 | aom_sad128x128x4d, aom_dist_wtd_sad128x128_avg, |
| 2854 | aom_dist_wtd_sub_pixel_avg_variance128x128) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2855 | |
| 2856 | BFP(BLOCK_128X64, aom_sad128x64, aom_sad128x64_avg, aom_variance128x64, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2857 | aom_sub_pixel_variance128x64, aom_sub_pixel_avg_variance128x64, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2858 | aom_sad128x64x4d, aom_dist_wtd_sad128x64_avg, |
| 2859 | aom_dist_wtd_sub_pixel_avg_variance128x64) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2860 | |
| 2861 | BFP(BLOCK_64X128, aom_sad64x128, aom_sad64x128_avg, aom_variance64x128, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2862 | aom_sub_pixel_variance64x128, aom_sub_pixel_avg_variance64x128, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2863 | aom_sad64x128x4d, aom_dist_wtd_sad64x128_avg, |
| 2864 | aom_dist_wtd_sub_pixel_avg_variance64x128) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2865 | |
| 2866 | BFP(BLOCK_32X16, aom_sad32x16, aom_sad32x16_avg, aom_variance32x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2867 | aom_sub_pixel_variance32x16, aom_sub_pixel_avg_variance32x16, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2868 | aom_sad32x16x4d, aom_dist_wtd_sad32x16_avg, |
| 2869 | aom_dist_wtd_sub_pixel_avg_variance32x16) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2870 | |
| 2871 | BFP(BLOCK_16X32, aom_sad16x32, aom_sad16x32_avg, aom_variance16x32, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2872 | aom_sub_pixel_variance16x32, aom_sub_pixel_avg_variance16x32, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2873 | aom_sad16x32x4d, aom_dist_wtd_sad16x32_avg, |
| 2874 | aom_dist_wtd_sub_pixel_avg_variance16x32) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2875 | |
| 2876 | BFP(BLOCK_64X32, aom_sad64x32, aom_sad64x32_avg, aom_variance64x32, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2877 | aom_sub_pixel_variance64x32, aom_sub_pixel_avg_variance64x32, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2878 | aom_sad64x32x4d, aom_dist_wtd_sad64x32_avg, |
| 2879 | aom_dist_wtd_sub_pixel_avg_variance64x32) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2880 | |
| 2881 | BFP(BLOCK_32X64, aom_sad32x64, aom_sad32x64_avg, aom_variance32x64, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2882 | aom_sub_pixel_variance32x64, aom_sub_pixel_avg_variance32x64, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2883 | aom_sad32x64x4d, aom_dist_wtd_sad32x64_avg, |
| 2884 | aom_dist_wtd_sub_pixel_avg_variance32x64) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2885 | |
| 2886 | BFP(BLOCK_32X32, aom_sad32x32, aom_sad32x32_avg, aom_variance32x32, |
| 2887 | aom_sub_pixel_variance32x32, aom_sub_pixel_avg_variance32x32, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2888 | aom_sad32x32x4d, aom_dist_wtd_sad32x32_avg, |
| 2889 | aom_dist_wtd_sub_pixel_avg_variance32x32) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2890 | |
| 2891 | BFP(BLOCK_64X64, aom_sad64x64, aom_sad64x64_avg, aom_variance64x64, |
| 2892 | aom_sub_pixel_variance64x64, aom_sub_pixel_avg_variance64x64, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2893 | aom_sad64x64x4d, aom_dist_wtd_sad64x64_avg, |
| 2894 | aom_dist_wtd_sub_pixel_avg_variance64x64) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2895 | |
| 2896 | BFP(BLOCK_16X16, aom_sad16x16, aom_sad16x16_avg, aom_variance16x16, |
| 2897 | aom_sub_pixel_variance16x16, aom_sub_pixel_avg_variance16x16, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2898 | aom_sad16x16x4d, aom_dist_wtd_sad16x16_avg, |
| 2899 | aom_dist_wtd_sub_pixel_avg_variance16x16) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2900 | |
| 2901 | BFP(BLOCK_16X8, aom_sad16x8, aom_sad16x8_avg, aom_variance16x8, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2902 | aom_sub_pixel_variance16x8, aom_sub_pixel_avg_variance16x8, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2903 | aom_sad16x8x4d, aom_dist_wtd_sad16x8_avg, |
| 2904 | aom_dist_wtd_sub_pixel_avg_variance16x8) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2905 | |
| 2906 | BFP(BLOCK_8X16, aom_sad8x16, aom_sad8x16_avg, aom_variance8x16, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2907 | aom_sub_pixel_variance8x16, aom_sub_pixel_avg_variance8x16, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2908 | aom_sad8x16x4d, aom_dist_wtd_sad8x16_avg, |
| 2909 | aom_dist_wtd_sub_pixel_avg_variance8x16) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2910 | |
| 2911 | BFP(BLOCK_8X8, aom_sad8x8, aom_sad8x8_avg, aom_variance8x8, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2912 | aom_sub_pixel_variance8x8, aom_sub_pixel_avg_variance8x8, aom_sad8x8x4d, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2913 | aom_dist_wtd_sad8x8_avg, aom_dist_wtd_sub_pixel_avg_variance8x8) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2914 | |
| 2915 | BFP(BLOCK_8X4, aom_sad8x4, aom_sad8x4_avg, aom_variance8x4, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2916 | aom_sub_pixel_variance8x4, aom_sub_pixel_avg_variance8x4, aom_sad8x4x4d, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2917 | aom_dist_wtd_sad8x4_avg, aom_dist_wtd_sub_pixel_avg_variance8x4) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2918 | |
| 2919 | BFP(BLOCK_4X8, aom_sad4x8, aom_sad4x8_avg, aom_variance4x8, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2920 | aom_sub_pixel_variance4x8, aom_sub_pixel_avg_variance4x8, aom_sad4x8x4d, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2921 | aom_dist_wtd_sad4x8_avg, aom_dist_wtd_sub_pixel_avg_variance4x8) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2922 | |
| 2923 | BFP(BLOCK_4X4, aom_sad4x4, aom_sad4x4_avg, aom_variance4x4, |
Kyle Siefring | ef6e2df | 2018-04-10 14:51:35 -0400 | [diff] [blame] | 2924 | aom_sub_pixel_variance4x4, aom_sub_pixel_avg_variance4x4, aom_sad4x4x4d, |
Debargha Mukherjee | 0c96c11 | 2018-12-20 16:04:18 -0800 | [diff] [blame] | 2925 | aom_dist_wtd_sad4x4_avg, aom_dist_wtd_sub_pixel_avg_variance4x4) |
Cheng Chen | f78632e | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 2926 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2927 | #define OBFP(BT, OSDF, OVF, OSVF) \ |
| 2928 | cpi->fn_ptr[BT].osdf = OSDF; \ |
| 2929 | cpi->fn_ptr[BT].ovf = OVF; \ |
| 2930 | cpi->fn_ptr[BT].osvf = OSVF; |
| 2931 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2932 | OBFP(BLOCK_128X128, aom_obmc_sad128x128, aom_obmc_variance128x128, |
| 2933 | aom_obmc_sub_pixel_variance128x128) |
| 2934 | OBFP(BLOCK_128X64, aom_obmc_sad128x64, aom_obmc_variance128x64, |
| 2935 | aom_obmc_sub_pixel_variance128x64) |
| 2936 | OBFP(BLOCK_64X128, aom_obmc_sad64x128, aom_obmc_variance64x128, |
| 2937 | aom_obmc_sub_pixel_variance64x128) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 2938 | OBFP(BLOCK_64X64, aom_obmc_sad64x64, aom_obmc_variance64x64, |
| 2939 | aom_obmc_sub_pixel_variance64x64) |
| 2940 | OBFP(BLOCK_64X32, aom_obmc_sad64x32, aom_obmc_variance64x32, |
| 2941 | aom_obmc_sub_pixel_variance64x32) |
| 2942 | OBFP(BLOCK_32X64, aom_obmc_sad32x64, aom_obmc_variance32x64, |
| 2943 | aom_obmc_sub_pixel_variance32x64) |
| 2944 | OBFP(BLOCK_32X32, aom_obmc_sad32x32, aom_obmc_variance32x32, |
| 2945 | aom_obmc_sub_pixel_variance32x32) |
| 2946 | OBFP(BLOCK_32X16, aom_obmc_sad32x16, aom_obmc_variance32x16, |
| 2947 | aom_obmc_sub_pixel_variance32x16) |
| 2948 | OBFP(BLOCK_16X32, aom_obmc_sad16x32, aom_obmc_variance16x32, |
| 2949 | aom_obmc_sub_pixel_variance16x32) |
| 2950 | OBFP(BLOCK_16X16, aom_obmc_sad16x16, aom_obmc_variance16x16, |
| 2951 | aom_obmc_sub_pixel_variance16x16) |
| 2952 | OBFP(BLOCK_16X8, aom_obmc_sad16x8, aom_obmc_variance16x8, |
| 2953 | aom_obmc_sub_pixel_variance16x8) |
| 2954 | OBFP(BLOCK_8X16, aom_obmc_sad8x16, aom_obmc_variance8x16, |
| 2955 | aom_obmc_sub_pixel_variance8x16) |
| 2956 | OBFP(BLOCK_8X8, aom_obmc_sad8x8, aom_obmc_variance8x8, |
| 2957 | aom_obmc_sub_pixel_variance8x8) |
| 2958 | OBFP(BLOCK_4X8, aom_obmc_sad4x8, aom_obmc_variance4x8, |
| 2959 | aom_obmc_sub_pixel_variance4x8) |
| 2960 | OBFP(BLOCK_8X4, aom_obmc_sad8x4, aom_obmc_variance8x4, |
| 2961 | aom_obmc_sub_pixel_variance8x4) |
| 2962 | OBFP(BLOCK_4X4, aom_obmc_sad4x4, aom_obmc_variance4x4, |
| 2963 | aom_obmc_sub_pixel_variance4x4) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2964 | OBFP(BLOCK_4X16, aom_obmc_sad4x16, aom_obmc_variance4x16, |
| 2965 | aom_obmc_sub_pixel_variance4x16) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2966 | OBFP(BLOCK_16X4, aom_obmc_sad16x4, aom_obmc_variance16x4, |
| 2967 | aom_obmc_sub_pixel_variance16x4) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2968 | OBFP(BLOCK_8X32, aom_obmc_sad8x32, aom_obmc_variance8x32, |
| 2969 | aom_obmc_sub_pixel_variance8x32) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2970 | OBFP(BLOCK_32X8, aom_obmc_sad32x8, aom_obmc_variance32x8, |
| 2971 | aom_obmc_sub_pixel_variance32x8) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 2972 | OBFP(BLOCK_16X64, aom_obmc_sad16x64, aom_obmc_variance16x64, |
| 2973 | aom_obmc_sub_pixel_variance16x64) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 2974 | OBFP(BLOCK_64X16, aom_obmc_sad64x16, aom_obmc_variance64x16, |
| 2975 | aom_obmc_sub_pixel_variance64x16) |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2976 | |
David Barker | f19f35f | 2017-05-22 16:33:22 +0100 | [diff] [blame] | 2977 | #define MBFP(BT, MCSDF, MCSVF) \ |
| 2978 | cpi->fn_ptr[BT].msdf = MCSDF; \ |
| 2979 | cpi->fn_ptr[BT].msvf = MCSVF; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 2980 | |
David Barker | f19f35f | 2017-05-22 16:33:22 +0100 | [diff] [blame] | 2981 | MBFP(BLOCK_128X128, aom_masked_sad128x128, |
| 2982 | aom_masked_sub_pixel_variance128x128) |
| 2983 | MBFP(BLOCK_128X64, aom_masked_sad128x64, aom_masked_sub_pixel_variance128x64) |
| 2984 | MBFP(BLOCK_64X128, aom_masked_sad64x128, aom_masked_sub_pixel_variance64x128) |
David Barker | f19f35f | 2017-05-22 16:33:22 +0100 | [diff] [blame] | 2985 | MBFP(BLOCK_64X64, aom_masked_sad64x64, aom_masked_sub_pixel_variance64x64) |
| 2986 | MBFP(BLOCK_64X32, aom_masked_sad64x32, aom_masked_sub_pixel_variance64x32) |
| 2987 | MBFP(BLOCK_32X64, aom_masked_sad32x64, aom_masked_sub_pixel_variance32x64) |
| 2988 | MBFP(BLOCK_32X32, aom_masked_sad32x32, aom_masked_sub_pixel_variance32x32) |
| 2989 | MBFP(BLOCK_32X16, aom_masked_sad32x16, aom_masked_sub_pixel_variance32x16) |
| 2990 | MBFP(BLOCK_16X32, aom_masked_sad16x32, aom_masked_sub_pixel_variance16x32) |
| 2991 | MBFP(BLOCK_16X16, aom_masked_sad16x16, aom_masked_sub_pixel_variance16x16) |
| 2992 | MBFP(BLOCK_16X8, aom_masked_sad16x8, aom_masked_sub_pixel_variance16x8) |
| 2993 | MBFP(BLOCK_8X16, aom_masked_sad8x16, aom_masked_sub_pixel_variance8x16) |
| 2994 | MBFP(BLOCK_8X8, aom_masked_sad8x8, aom_masked_sub_pixel_variance8x8) |
| 2995 | MBFP(BLOCK_4X8, aom_masked_sad4x8, aom_masked_sub_pixel_variance4x8) |
| 2996 | MBFP(BLOCK_8X4, aom_masked_sad8x4, aom_masked_sub_pixel_variance8x4) |
| 2997 | MBFP(BLOCK_4X4, aom_masked_sad4x4, aom_masked_sub_pixel_variance4x4) |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2998 | |
Rupert Swarbrick | 93c39e9 | 2017-07-12 11:11:02 +0100 | [diff] [blame] | 2999 | MBFP(BLOCK_4X16, aom_masked_sad4x16, aom_masked_sub_pixel_variance4x16) |
| 3000 | |
| 3001 | MBFP(BLOCK_16X4, aom_masked_sad16x4, aom_masked_sub_pixel_variance16x4) |
| 3002 | |
| 3003 | MBFP(BLOCK_8X32, aom_masked_sad8x32, aom_masked_sub_pixel_variance8x32) |
| 3004 | |
| 3005 | MBFP(BLOCK_32X8, aom_masked_sad32x8, aom_masked_sub_pixel_variance32x8) |
Rupert Swarbrick | 7267857 | 2017-08-02 12:05:26 +0100 | [diff] [blame] | 3006 | |
| 3007 | MBFP(BLOCK_16X64, aom_masked_sad16x64, aom_masked_sub_pixel_variance16x64) |
| 3008 | |
| 3009 | MBFP(BLOCK_64X16, aom_masked_sad64x16, aom_masked_sub_pixel_variance64x16) |
Rupert Swarbrick | 2fa6e1c | 2017-09-11 12:38:10 +0100 | [diff] [blame] | 3010 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3011 | highbd_set_var_fns(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3012 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3013 | /* av1_init_quantizer() is first called here. Add check in |
| 3014 | * av1_frame_init_quantizer() so that av1_init_quantizer is only |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3015 | * called later when needed. This will avoid unnecessary calls of |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3016 | * av1_init_quantizer() for every frame. |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3017 | */ |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3018 | av1_init_quantizer(cpi); |
Zoe Liu | d902b74 | 2018-02-19 17:02:41 -0800 | [diff] [blame] | 3019 | av1_qm_init(cm); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3020 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3021 | av1_loop_filter_init(cm); |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 3022 | cm->superres_scale_denominator = SCALE_NUMERATOR; |
Debargha Mukherjee | 29e40a6 | 2017-06-14 09:37:12 -0700 | [diff] [blame] | 3023 | cm->superres_upscaled_width = oxcf->width; |
| 3024 | cm->superres_upscaled_height = oxcf->height; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3025 | av1_loop_restoration_precal(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3026 | |
| 3027 | cm->error.setjmp = 0; |
| 3028 | |
| 3029 | return cpi; |
| 3030 | } |
| 3031 | |
Urvang Joshi | ee2c811 | 2018-05-04 14:53:15 -0700 | [diff] [blame] | 3032 | #if CONFIG_INTERNAL_STATS |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3033 | #define SNPRINT(H, T) snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T)) |
| 3034 | |
| 3035 | #define SNPRINT2(H, T, V) \ |
| 3036 | snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T), (V)) |
Urvang Joshi | ee2c811 | 2018-05-04 14:53:15 -0700 | [diff] [blame] | 3037 | #endif // CONFIG_INTERNAL_STATS |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3038 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3039 | void av1_remove_compressor(AV1_COMP *cpi) { |
| 3040 | AV1_COMMON *cm; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3041 | unsigned int i; |
| 3042 | int t; |
| 3043 | |
| 3044 | if (!cpi) return; |
| 3045 | |
| 3046 | cm = &cpi->common; |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 3047 | const int num_planes = av1_num_planes(cm); |
| 3048 | |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 3049 | if (cm->current_frame.frame_number > 0) { |
Debargha Mukherjee | 5802ebe | 2016-12-21 04:17:24 -0800 | [diff] [blame] | 3050 | #if CONFIG_ENTROPY_STATS |
| 3051 | if (cpi->oxcf.pass != 1) { |
| 3052 | fprintf(stderr, "Writing counts.stt\n"); |
| 3053 | FILE *f = fopen("counts.stt", "wb"); |
| 3054 | fwrite(&aggregate_fc, sizeof(aggregate_fc), 1, f); |
| 3055 | fclose(f); |
| 3056 | } |
| 3057 | #endif // CONFIG_ENTROPY_STATS |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3058 | #if CONFIG_INTERNAL_STATS |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3059 | aom_clear_system_state(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3060 | |
| 3061 | if (cpi->oxcf.pass != 1) { |
| 3062 | char headings[512] = { 0 }; |
| 3063 | char results[512] = { 0 }; |
| 3064 | FILE *f = fopen("opsnr.stt", "a"); |
| 3065 | double time_encoded = |
| 3066 | (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) / |
| 3067 | 10000000.000; |
| 3068 | double total_encode_time = |
| 3069 | (cpi->time_receive_data + cpi->time_compress_data) / 1000.000; |
| 3070 | const double dr = |
| 3071 | (double)cpi->bytes * (double)8 / (double)1000 / time_encoded; |
| 3072 | const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1); |
| 3073 | const double target_rate = (double)cpi->oxcf.target_bandwidth / 1000; |
| 3074 | const double rate_err = ((100.0 * (dr - target_rate)) / target_rate); |
| 3075 | |
| 3076 | if (cpi->b_calculate_psnr) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3077 | const double total_psnr = aom_sse_to_psnr( |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3078 | (double)cpi->total_samples, peak, (double)cpi->total_sq_error); |
| 3079 | const double total_ssim = |
| 3080 | 100 * pow(cpi->summed_quality / cpi->summed_weights, 8.0); |
| 3081 | snprintf(headings, sizeof(headings), |
Jingning Han | 87651b2 | 2017-11-28 20:02:26 -0800 | [diff] [blame] | 3082 | "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\t" |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3083 | "AOMSSIM\tVPSSIMP\tFASTSIM\tPSNRHVS\t" |
Jingning Han | be1ae3f | 2017-11-27 10:27:56 -0800 | [diff] [blame] | 3084 | "WstPsnr\tWstSsim\tWstFast\tWstHVS\t" |
Jingning Han | 87651b2 | 2017-11-28 20:02:26 -0800 | [diff] [blame] | 3085 | "AVPsrnY\tAPsnrCb\tAPsnrCr"); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3086 | snprintf(results, sizeof(results), |
| 3087 | "%7.2f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t" |
| 3088 | "%7.3f\t%7.3f\t%7.3f\t%7.3f\t" |
Jingning Han | be1ae3f | 2017-11-27 10:27:56 -0800 | [diff] [blame] | 3089 | "%7.3f\t%7.3f\t%7.3f\t%7.3f\t" |
Jingning Han | 87651b2 | 2017-11-28 20:02:26 -0800 | [diff] [blame] | 3090 | "%7.3f\t%7.3f\t%7.3f", |
Wan-Teh Chang | c25c92a | 2018-04-23 15:04:14 -0700 | [diff] [blame] | 3091 | dr, cpi->psnr.stat[STAT_ALL] / cpi->count, total_psnr, |
| 3092 | cpi->psnr.stat[STAT_ALL] / cpi->count, total_psnr, total_ssim, |
| 3093 | total_ssim, cpi->fastssim.stat[STAT_ALL] / cpi->count, |
| 3094 | cpi->psnrhvs.stat[STAT_ALL] / cpi->count, cpi->psnr.worst, |
Jingning Han | be1ae3f | 2017-11-27 10:27:56 -0800 | [diff] [blame] | 3095 | cpi->worst_ssim, cpi->fastssim.worst, cpi->psnrhvs.worst, |
Wan-Teh Chang | c25c92a | 2018-04-23 15:04:14 -0700 | [diff] [blame] | 3096 | cpi->psnr.stat[STAT_Y] / cpi->count, |
| 3097 | cpi->psnr.stat[STAT_U] / cpi->count, |
| 3098 | cpi->psnr.stat[STAT_V] / cpi->count); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3099 | |
| 3100 | if (cpi->b_calculate_blockiness) { |
| 3101 | SNPRINT(headings, "\t Block\tWstBlck"); |
| 3102 | SNPRINT2(results, "\t%7.3f", cpi->total_blockiness / cpi->count); |
| 3103 | SNPRINT2(results, "\t%7.3f", cpi->worst_blockiness); |
| 3104 | } |
| 3105 | |
| 3106 | if (cpi->b_calculate_consistency) { |
| 3107 | double consistency = |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3108 | aom_sse_to_psnr((double)cpi->total_samples, peak, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3109 | (double)cpi->total_inconsistency); |
| 3110 | |
| 3111 | SNPRINT(headings, "\tConsist\tWstCons"); |
| 3112 | SNPRINT2(results, "\t%7.3f", consistency); |
| 3113 | SNPRINT2(results, "\t%7.3f", cpi->worst_consistency); |
| 3114 | } |
Sarah Parker | f97b786 | 2016-08-25 17:42:57 -0700 | [diff] [blame] | 3115 | fprintf(f, "%s\t Time\tRcErr\tAbsErr\n", headings); |
| 3116 | fprintf(f, "%s\t%8.0f\t%7.2f\t%7.2f\n", results, total_encode_time, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3117 | rate_err, fabs(rate_err)); |
| 3118 | } |
| 3119 | |
| 3120 | fclose(f); |
| 3121 | } |
Urvang Joshi | ee2c811 | 2018-05-04 14:53:15 -0700 | [diff] [blame] | 3122 | #endif // CONFIG_INTERNAL_STATS |
Debargha Mukherjee | 0857e66 | 2019-01-04 16:22:09 -0800 | [diff] [blame] | 3123 | #if CONFIG_SPEED_STATS |
| 3124 | if (cpi->oxcf.pass != 1) { |
| 3125 | fprintf(stdout, "tx_search_count = %d\n", cpi->tx_search_count); |
| 3126 | } |
| 3127 | #endif // CONFIG_SPEED_STATS |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3128 | } |
| 3129 | |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 3130 | for (int frame = 0; frame < MAX_LAG_BUFFERS; ++frame) { |
| 3131 | aom_free(cpi->tpl_stats[frame].tpl_stats_ptr); |
| 3132 | cpi->tpl_stats[frame].is_valid = 0; |
| 3133 | } |
| 3134 | |
Ravi Chaudhary | 1f58dd8 | 2018-12-07 17:24:15 +0530 | [diff] [blame] | 3135 | for (t = cpi->num_workers - 1; t >= 0; --t) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3136 | AVxWorker *const worker = &cpi->workers[t]; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3137 | EncWorkerData *const thread_data = &cpi->tile_thr_data[t]; |
| 3138 | |
| 3139 | // Deallocate allocated threads. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3140 | aom_get_worker_interface()->end(worker); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3141 | |
| 3142 | // Deallocate allocated thread data. |
Ravi Chaudhary | 1cf7d16 | 2018-10-09 17:00:43 +0530 | [diff] [blame] | 3143 | if (cpi->row_mt == 1) aom_free(thread_data->td->tctx); |
Ravi Chaudhary | 1f58dd8 | 2018-12-07 17:24:15 +0530 | [diff] [blame] | 3144 | if (t > 0) { |
hui su | d9a812b | 2017-07-06 14:34:37 -0700 | [diff] [blame] | 3145 | aom_free(thread_data->td->palette_buffer); |
Urvang Joshi | 0a4cfad | 2018-09-07 11:10:39 -0700 | [diff] [blame] | 3146 | aom_free(thread_data->td->tmp_conv_dst); |
| 3147 | for (int j = 0; j < 2; ++j) { |
| 3148 | aom_free(thread_data->td->tmp_obmc_bufs[j]); |
| 3149 | } |
Jingning Han | d064cf0 | 2017-06-01 10:00:39 -0700 | [diff] [blame] | 3150 | aom_free(thread_data->td->above_pred_buf); |
| 3151 | aom_free(thread_data->td->left_pred_buf); |
| 3152 | aom_free(thread_data->td->wsrc_buf); |
wenyao.liu | 22d8ab3 | 2018-10-16 09:11:29 +0800 | [diff] [blame] | 3153 | |
Ravi Chaudhary | 5d970f4 | 2018-09-25 11:25:32 +0530 | [diff] [blame] | 3154 | #if CONFIG_COLLECT_INTER_MODE_RD_STATS |
| 3155 | aom_free(thread_data->td->inter_modes_info); |
| 3156 | #endif |
Urvang Joshi | 0a4cfad | 2018-09-07 11:10:39 -0700 | [diff] [blame] | 3157 | for (int x = 0; x < 2; x++) { |
Ravi Chaudhary | 783d6a3 | 2018-08-28 18:21:02 +0530 | [diff] [blame] | 3158 | for (int y = 0; y < 2; y++) { |
| 3159 | aom_free(thread_data->td->hash_value_buffer[x][y]); |
| 3160 | thread_data->td->hash_value_buffer[x][y] = NULL; |
| 3161 | } |
Urvang Joshi | 0a4cfad | 2018-09-07 11:10:39 -0700 | [diff] [blame] | 3162 | } |
Jingning Han | d064cf0 | 2017-06-01 10:00:39 -0700 | [diff] [blame] | 3163 | aom_free(thread_data->td->mask_buf); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3164 | aom_free(thread_data->td->counts); |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 3165 | av1_free_pc_tree(thread_data->td, num_planes); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3166 | aom_free(thread_data->td); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3167 | } |
| 3168 | } |
Ravi Chaudhary | 90a15f4 | 2018-10-11 18:56:35 +0530 | [diff] [blame] | 3169 | #if CONFIG_MULTITHREAD |
| 3170 | if (cpi->row_mt == 1) { |
| 3171 | if (cpi->row_mt_mutex_ != NULL) { |
| 3172 | pthread_mutex_destroy(cpi->row_mt_mutex_); |
| 3173 | aom_free(cpi->row_mt_mutex_); |
| 3174 | } |
| 3175 | } |
| 3176 | #endif |
Ravi Chaudhary | c5e7469 | 2018-10-08 16:05:38 +0530 | [diff] [blame] | 3177 | av1_row_mt_mem_dealloc(cpi); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3178 | aom_free(cpi->tile_thr_data); |
| 3179 | aom_free(cpi->workers); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3180 | |
Deepa K G | 964e72e | 2018-05-16 16:56:01 +0530 | [diff] [blame] | 3181 | if (cpi->num_workers > 1) { |
| 3182 | av1_loop_filter_dealloc(&cpi->lf_row_sync); |
Ravi Chaudhary | e2aa401 | 2018-06-04 14:20:00 +0530 | [diff] [blame] | 3183 | av1_loop_restoration_dealloc(&cpi->lr_row_sync, cpi->num_workers); |
Deepa K G | 964e72e | 2018-05-16 16:56:01 +0530 | [diff] [blame] | 3184 | } |
| 3185 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3186 | dealloc_compressor_data(cpi); |
| 3187 | |
| 3188 | for (i = 0; i < sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]); |
| 3189 | ++i) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3190 | aom_free(cpi->mbgraph_stats[i].mb_stats); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3191 | } |
| 3192 | |
| 3193 | #if CONFIG_FP_MB_STATS |
| 3194 | if (cpi->use_fp_mb_stats) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3195 | aom_free(cpi->twopass.frame_mb_stats_buf); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3196 | cpi->twopass.frame_mb_stats_buf = NULL; |
| 3197 | } |
| 3198 | #endif |
Debargha Mukherjee | 5d15721 | 2017-01-10 14:44:47 -0800 | [diff] [blame] | 3199 | #if CONFIG_INTERNAL_STATS |
| 3200 | aom_free(cpi->ssim_vars); |
| 3201 | cpi->ssim_vars = NULL; |
| 3202 | #endif // CONFIG_INTERNAL_STATS |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3203 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3204 | av1_remove_common(cm); |
RogerZhou | 80d5234 | 2017-11-20 10:56:26 -0800 | [diff] [blame] | 3205 | for (i = 0; i < FRAME_BUFFERS; ++i) { |
| 3206 | av1_hash_table_destroy(&cm->buffer_pool->frame_bufs[i].hash_table); |
| 3207 | } |
Michelle Findlay-Olynyk | dea531d | 2017-12-13 14:10:56 -0800 | [diff] [blame] | 3208 | if (cpi->sf.use_hash_based_trellis) hbt_destroy(); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3209 | av1_free_ref_frame_buffers(cm->buffer_pool); |
| 3210 | aom_free(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3211 | |
| 3212 | #ifdef OUTPUT_YUV_SKINMAP |
| 3213 | fclose(yuv_skinmap_file); |
| 3214 | #endif |
| 3215 | #ifdef OUTPUT_YUV_REC |
| 3216 | fclose(yuv_rec_file); |
| 3217 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3218 | } |
| 3219 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3220 | static void generate_psnr_packet(AV1_COMP *cpi) { |
| 3221 | struct aom_codec_cx_pkt pkt; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3222 | int i; |
| 3223 | PSNR_STATS psnr; |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 3224 | aom_calc_highbd_psnr(cpi->source, &cpi->common.cur_frame->buf, &psnr, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3225 | cpi->td.mb.e_mbd.bd, cpi->oxcf.input_bit_depth); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3226 | |
| 3227 | for (i = 0; i < 4; ++i) { |
| 3228 | pkt.data.psnr.samples[i] = psnr.samples[i]; |
| 3229 | pkt.data.psnr.sse[i] = psnr.sse[i]; |
| 3230 | pkt.data.psnr.psnr[i] = psnr.psnr[i]; |
| 3231 | } |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3232 | pkt.kind = AOM_CODEC_PSNR_PKT; |
| 3233 | aom_codec_pkt_list_add(cpi->output_pkt_list, &pkt); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3234 | } |
| 3235 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3236 | int av1_use_as_reference(AV1_COMP *cpi, int ref_frame_flags) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3237 | if (ref_frame_flags > ((1 << INTER_REFS_PER_FRAME) - 1)) return -1; |
| 3238 | |
Yunqing Wang | f2e7a39 | 2017-11-08 00:27:21 -0800 | [diff] [blame] | 3239 | cpi->ext_ref_frame_flags = ref_frame_flags; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3240 | return 0; |
| 3241 | } |
| 3242 | |
Yunqing Wang | 9a50fec | 2017-11-02 17:02:00 -0700 | [diff] [blame] | 3243 | void av1_update_reference(AV1_COMP *cpi, int ref_frame_upd_flags) { |
| 3244 | cpi->ext_refresh_last_frame = (ref_frame_upd_flags & AOM_LAST_FLAG) != 0; |
| 3245 | cpi->ext_refresh_golden_frame = (ref_frame_upd_flags & AOM_GOLD_FLAG) != 0; |
| 3246 | cpi->ext_refresh_alt_ref_frame = (ref_frame_upd_flags & AOM_ALT_FLAG) != 0; |
| 3247 | cpi->ext_refresh_bwd_ref_frame = (ref_frame_upd_flags & AOM_BWD_FLAG) != 0; |
| 3248 | cpi->ext_refresh_alt2_ref_frame = (ref_frame_upd_flags & AOM_ALT2_FLAG) != 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3249 | cpi->ext_refresh_frame_flags_pending = 1; |
| 3250 | } |
| 3251 | |
Thomas Daede | 497d195 | 2017-08-08 17:33:06 -0700 | [diff] [blame] | 3252 | int av1_copy_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd) { |
| 3253 | AV1_COMMON *const cm = &cpi->common; |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 3254 | const int num_planes = av1_num_planes(cm); |
Thomas Daede | 497d195 | 2017-08-08 17:33:06 -0700 | [diff] [blame] | 3255 | YV12_BUFFER_CONFIG *cfg = get_ref_frame(cm, idx); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3256 | if (cfg) { |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 3257 | aom_yv12_copy_frame(cfg, sd, num_planes); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3258 | return 0; |
| 3259 | } else { |
| 3260 | return -1; |
| 3261 | } |
| 3262 | } |
| 3263 | |
Thomas Daede | 497d195 | 2017-08-08 17:33:06 -0700 | [diff] [blame] | 3264 | int av1_set_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd) { |
| 3265 | AV1_COMMON *const cm = &cpi->common; |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 3266 | const int num_planes = av1_num_planes(cm); |
Thomas Daede | 497d195 | 2017-08-08 17:33:06 -0700 | [diff] [blame] | 3267 | YV12_BUFFER_CONFIG *cfg = get_ref_frame(cm, idx); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3268 | if (cfg) { |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 3269 | aom_yv12_copy_frame(sd, cfg, num_planes); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3270 | return 0; |
| 3271 | } else { |
| 3272 | return -1; |
| 3273 | } |
| 3274 | } |
| 3275 | |
| 3276 | int av1_update_entropy(AV1_COMP *cpi, int update) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3277 | cpi->ext_refresh_frame_context = update; |
| 3278 | cpi->ext_refresh_frame_context_pending = 1; |
| 3279 | return 0; |
| 3280 | } |
| 3281 | |
| 3282 | #if defined(OUTPUT_YUV_DENOISED) || defined(OUTPUT_YUV_SKINMAP) |
| 3283 | // The denoiser buffer is allocated as a YUV 440 buffer. This function writes it |
| 3284 | // as YUV 420. We simply use the top-left pixels of the UV buffers, since we do |
| 3285 | // not denoise the UV channels at this time. If ever we implement UV channel |
| 3286 | // denoising we will have to modify this. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3287 | void aom_write_yuv_frame_420(YV12_BUFFER_CONFIG *s, FILE *f) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3288 | uint8_t *src = s->y_buffer; |
| 3289 | int h = s->y_height; |
| 3290 | |
| 3291 | do { |
| 3292 | fwrite(src, s->y_width, 1, f); |
| 3293 | src += s->y_stride; |
| 3294 | } while (--h); |
| 3295 | |
| 3296 | src = s->u_buffer; |
| 3297 | h = s->uv_height; |
| 3298 | |
| 3299 | do { |
| 3300 | fwrite(src, s->uv_width, 1, f); |
| 3301 | src += s->uv_stride; |
| 3302 | } while (--h); |
| 3303 | |
| 3304 | src = s->v_buffer; |
| 3305 | h = s->uv_height; |
| 3306 | |
| 3307 | do { |
| 3308 | fwrite(src, s->uv_width, 1, f); |
| 3309 | src += s->uv_stride; |
| 3310 | } while (--h); |
| 3311 | } |
| 3312 | #endif |
| 3313 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3314 | static void check_show_existing_frame(AV1_COMP *cpi) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3315 | const GF_GROUP *const gf_group = &cpi->twopass.gf_group; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3316 | AV1_COMMON *const cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3317 | const FRAME_UPDATE_TYPE next_frame_update_type = |
| 3318 | gf_group->update_type[gf_group->index]; |
Wei-Ting Lin | bafa11c | 2018-07-10 13:20:59 -0700 | [diff] [blame] | 3319 | #if USE_SYMM_MULTI_LAYER |
| 3320 | const int which_arf = (cpi->new_bwdref_update_rule == 1) |
| 3321 | ? gf_group->arf_update_idx[gf_group->index] > 0 |
| 3322 | : gf_group->arf_update_idx[gf_group->index]; |
| 3323 | #else |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3324 | const int which_arf = gf_group->arf_update_idx[gf_group->index]; |
Wei-Ting Lin | bafa11c | 2018-07-10 13:20:59 -0700 | [diff] [blame] | 3325 | #endif |
Zoe Liu | 5fca724 | 2016-10-10 17:18:57 -0700 | [diff] [blame] | 3326 | |
| 3327 | if (cm->show_existing_frame == 1) { |
| 3328 | cm->show_existing_frame = 0; |
| 3329 | } else if (cpi->rc.is_last_bipred_frame) { |
Wei-Ting Lin | bafa11c | 2018-07-10 13:20:59 -0700 | [diff] [blame] | 3330 | #if USE_SYMM_MULTI_LAYER |
| 3331 | // NOTE: When new structure is used, every bwdref will have one overlay |
| 3332 | // frame. Therefore, there is no need to find out which frame to |
| 3333 | // show in advance. |
| 3334 | if (cpi->new_bwdref_update_rule == 0) { |
| 3335 | #endif |
| 3336 | // NOTE: If the current frame is a last bi-predictive frame, it is |
| 3337 | // needed next to show the BWDREF_FRAME, which is pointed by |
| 3338 | // the last_fb_idxes[0] after reference frame buffer update |
| 3339 | cpi->rc.is_last_bipred_frame = 0; |
| 3340 | cm->show_existing_frame = 1; |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3341 | cpi->existing_fb_idx_to_show = cm->remapped_ref_idx[0]; |
Wei-Ting Lin | bafa11c | 2018-07-10 13:20:59 -0700 | [diff] [blame] | 3342 | #if USE_SYMM_MULTI_LAYER |
| 3343 | } |
| 3344 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3345 | } else if (cpi->is_arf_filter_off[which_arf] && |
| 3346 | (next_frame_update_type == OVERLAY_UPDATE || |
| 3347 | next_frame_update_type == INTNL_OVERLAY_UPDATE)) { |
Wei-Ting Lin | bafa11c | 2018-07-10 13:20:59 -0700 | [diff] [blame] | 3348 | #if USE_SYMM_MULTI_LAYER |
| 3349 | const int bwdref_to_show = |
| 3350 | (cpi->new_bwdref_update_rule == 1) ? BWDREF_FRAME : ALTREF2_FRAME; |
| 3351 | #else |
| 3352 | const int bwdref_to_show = ALTREF2_FRAME; |
| 3353 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3354 | // Other parameters related to OVERLAY_UPDATE will be taken care of |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3355 | // in av1_rc_get_second_pass_params(cpi) |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3356 | cm->show_existing_frame = 1; |
| 3357 | cpi->rc.is_src_frame_alt_ref = 1; |
Urvang Joshi | 4d9f15f | 2018-11-05 15:26:22 -0800 | [diff] [blame] | 3358 | cpi->existing_fb_idx_to_show = |
| 3359 | (next_frame_update_type == OVERLAY_UPDATE) |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3360 | ? get_ref_frame_map_idx(cm, ALTREF_FRAME) |
| 3361 | : get_ref_frame_map_idx(cm, bwdref_to_show); |
Wei-Ting Lin | bafa11c | 2018-07-10 13:20:59 -0700 | [diff] [blame] | 3362 | #if USE_SYMM_MULTI_LAYER |
| 3363 | if (cpi->new_bwdref_update_rule == 0) |
| 3364 | #endif |
| 3365 | cpi->is_arf_filter_off[which_arf] = 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3366 | } |
| 3367 | cpi->rc.is_src_frame_ext_arf = 0; |
| 3368 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3369 | |
| 3370 | #ifdef OUTPUT_YUV_REC |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3371 | 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] | 3372 | uint8_t *src = s->y_buffer; |
| 3373 | int h = cm->height; |
Wei-Ting Lin | 01d4d8f | 2017-08-03 17:04:12 -0700 | [diff] [blame] | 3374 | if (yuv_rec_file == NULL) return; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3375 | if (s->flags & YV12_FLAG_HIGHBITDEPTH) { |
| 3376 | uint16_t *src16 = CONVERT_TO_SHORTPTR(s->y_buffer); |
| 3377 | |
| 3378 | do { |
| 3379 | fwrite(src16, s->y_width, 2, yuv_rec_file); |
| 3380 | src16 += s->y_stride; |
| 3381 | } while (--h); |
| 3382 | |
| 3383 | src16 = CONVERT_TO_SHORTPTR(s->u_buffer); |
| 3384 | h = s->uv_height; |
| 3385 | |
| 3386 | do { |
| 3387 | fwrite(src16, s->uv_width, 2, yuv_rec_file); |
| 3388 | src16 += s->uv_stride; |
| 3389 | } while (--h); |
| 3390 | |
| 3391 | src16 = CONVERT_TO_SHORTPTR(s->v_buffer); |
| 3392 | h = s->uv_height; |
| 3393 | |
| 3394 | do { |
| 3395 | fwrite(src16, s->uv_width, 2, yuv_rec_file); |
| 3396 | src16 += s->uv_stride; |
| 3397 | } while (--h); |
| 3398 | |
| 3399 | fflush(yuv_rec_file); |
| 3400 | return; |
| 3401 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3402 | |
| 3403 | do { |
| 3404 | fwrite(src, s->y_width, 1, yuv_rec_file); |
| 3405 | src += s->y_stride; |
| 3406 | } while (--h); |
| 3407 | |
| 3408 | src = s->u_buffer; |
| 3409 | h = s->uv_height; |
| 3410 | |
| 3411 | do { |
| 3412 | fwrite(src, s->uv_width, 1, yuv_rec_file); |
| 3413 | src += s->uv_stride; |
| 3414 | } while (--h); |
| 3415 | |
| 3416 | src = s->v_buffer; |
| 3417 | h = s->uv_height; |
| 3418 | |
| 3419 | do { |
| 3420 | fwrite(src, s->uv_width, 1, yuv_rec_file); |
| 3421 | src += s->uv_stride; |
| 3422 | } while (--h); |
| 3423 | |
| 3424 | fflush(yuv_rec_file); |
| 3425 | } |
| 3426 | #endif // OUTPUT_YUV_REC |
| 3427 | |
Debargha Mukherjee | 11f0e40 | 2017-03-29 07:42:40 -0700 | [diff] [blame] | 3428 | #define GM_RECODE_LOOP_NUM4X4_FACTOR 192 |
Debargha Mukherjee | b98a702 | 2016-11-15 16:07:12 -0800 | [diff] [blame] | 3429 | static int recode_loop_test_global_motion(AV1_COMP *cpi) { |
| 3430 | int i; |
| 3431 | int recode = 0; |
Debargha Mukherjee | a575d23 | 2017-04-28 17:46:47 -0700 | [diff] [blame] | 3432 | RD_COUNTS *const rdc = &cpi->td.rd_counts; |
Debargha Mukherjee | b98a702 | 2016-11-15 16:07:12 -0800 | [diff] [blame] | 3433 | AV1_COMMON *const cm = &cpi->common; |
| 3434 | for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) { |
| 3435 | if (cm->global_motion[i].wmtype != IDENTITY && |
Debargha Mukherjee | a575d23 | 2017-04-28 17:46:47 -0700 | [diff] [blame] | 3436 | rdc->global_motion_used[i] * GM_RECODE_LOOP_NUM4X4_FACTOR < |
Debargha Mukherjee | 265db6d | 2017-03-28 11:15:27 -0700 | [diff] [blame] | 3437 | cpi->gmparams_cost[i]) { |
David Barker | d7c8bd5 | 2017-09-25 14:47:29 +0100 | [diff] [blame] | 3438 | cm->global_motion[i] = default_warp_params; |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 3439 | assert(cm->global_motion[i].wmtype == IDENTITY); |
Debargha Mukherjee | 265db6d | 2017-03-28 11:15:27 -0700 | [diff] [blame] | 3440 | cpi->gmparams_cost[i] = 0; |
David Barker | 43479c6 | 2016-11-30 10:34:20 +0000 | [diff] [blame] | 3441 | recode = 1; |
Urvang Joshi | 02aade8 | 2017-12-18 17:18:16 -0800 | [diff] [blame] | 3442 | // TODO(sarahparker): The earlier condition for recoding here was: |
| 3443 | // "recode |= (rdc->global_motion_used[i] > 0);". Can we bring something |
| 3444 | // similar to that back to speed up global motion? |
Debargha Mukherjee | b98a702 | 2016-11-15 16:07:12 -0800 | [diff] [blame] | 3445 | } |
| 3446 | } |
| 3447 | return recode; |
| 3448 | } |
Debargha Mukherjee | b98a702 | 2016-11-15 16:07:12 -0800 | [diff] [blame] | 3449 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3450 | // Function to test for conditions that indicate we should loop |
| 3451 | // back and recode a frame. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3452 | static int recode_loop_test(AV1_COMP *cpi, int high_limit, int low_limit, int q, |
| 3453 | int maxq, int minq) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3454 | const RATE_CONTROL *const rc = &cpi->rc; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3455 | const AV1EncoderConfig *const oxcf = &cpi->oxcf; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3456 | const int frame_is_kfgfarf = frame_is_kf_gf_arf(cpi); |
| 3457 | int force_recode = 0; |
| 3458 | |
| 3459 | if ((rc->projected_frame_size >= rc->max_frame_bandwidth) || |
| 3460 | (cpi->sf.recode_loop == ALLOW_RECODE) || |
| 3461 | (frame_is_kfgfarf && (cpi->sf.recode_loop == ALLOW_RECODE_KFARFGF))) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3462 | // TODO(agrange) high_limit could be greater than the scale-down threshold. |
| 3463 | if ((rc->projected_frame_size > high_limit && q < maxq) || |
| 3464 | (rc->projected_frame_size < low_limit && q > minq)) { |
| 3465 | force_recode = 1; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3466 | } else if (cpi->oxcf.rc_mode == AOM_CQ) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3467 | // Deal with frame undershoot and whether or not we are |
| 3468 | // below the automatically set cq level. |
| 3469 | if (q > oxcf->cq_level && |
| 3470 | rc->projected_frame_size < ((rc->this_frame_target * 7) >> 3)) { |
| 3471 | force_recode = 1; |
| 3472 | } |
| 3473 | } |
| 3474 | } |
| 3475 | return force_recode; |
| 3476 | } |
| 3477 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3478 | #define DUMP_REF_FRAME_IMAGES 0 |
| 3479 | |
| 3480 | #if DUMP_REF_FRAME_IMAGES == 1 |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3481 | static int dump_one_image(AV1_COMMON *cm, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3482 | const YV12_BUFFER_CONFIG *const ref_buf, |
| 3483 | char *file_name) { |
| 3484 | int h; |
| 3485 | FILE *f_ref = NULL; |
| 3486 | |
| 3487 | if (ref_buf == NULL) { |
| 3488 | printf("Frame data buffer is NULL.\n"); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3489 | return AOM_CODEC_MEM_ERROR; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3490 | } |
| 3491 | |
| 3492 | if ((f_ref = fopen(file_name, "wb")) == NULL) { |
| 3493 | printf("Unable to open file %s to write.\n", file_name); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3494 | return AOM_CODEC_MEM_ERROR; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3495 | } |
| 3496 | |
| 3497 | // --- Y --- |
| 3498 | for (h = 0; h < cm->height; ++h) { |
| 3499 | fwrite(&ref_buf->y_buffer[h * ref_buf->y_stride], 1, cm->width, f_ref); |
| 3500 | } |
| 3501 | // --- U --- |
| 3502 | for (h = 0; h < (cm->height >> 1); ++h) { |
| 3503 | fwrite(&ref_buf->u_buffer[h * ref_buf->uv_stride], 1, (cm->width >> 1), |
| 3504 | f_ref); |
| 3505 | } |
| 3506 | // --- V --- |
| 3507 | for (h = 0; h < (cm->height >> 1); ++h) { |
| 3508 | fwrite(&ref_buf->v_buffer[h * ref_buf->uv_stride], 1, (cm->width >> 1), |
| 3509 | f_ref); |
| 3510 | } |
| 3511 | |
| 3512 | fclose(f_ref); |
| 3513 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3514 | return AOM_CODEC_OK; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3515 | } |
| 3516 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3517 | static void dump_ref_frame_images(AV1_COMP *cpi) { |
| 3518 | AV1_COMMON *const cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3519 | MV_REFERENCE_FRAME ref_frame; |
| 3520 | |
| 3521 | for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { |
| 3522 | char file_name[256] = ""; |
| 3523 | snprintf(file_name, sizeof(file_name), "/tmp/enc_F%d_ref_%d.yuv", |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 3524 | cm->current_frame.frame_number, ref_frame); |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3525 | dump_one_image(cm, get_ref_frame_yv12_buf(cpi, ref_frame), file_name); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3526 | } |
| 3527 | } |
| 3528 | #endif // DUMP_REF_FRAME_IMAGES == 1 |
| 3529 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3530 | // This function is used to shift the virtual indices of last reference frames |
| 3531 | // as follows: |
| 3532 | // LAST_FRAME -> LAST2_FRAME -> LAST3_FRAME |
| 3533 | // when the LAST_FRAME is updated. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3534 | static INLINE void shift_last_ref_frames(AV1_COMP *cpi) { |
Imdad Sardharwalla | dadaba6 | 2018-02-23 12:06:56 +0000 | [diff] [blame] | 3535 | // TODO(isbs): shift the scaled indices as well |
Urvang Joshi | a130dcc | 2018-11-06 10:27:35 -0800 | [diff] [blame] | 3536 | for (int ref_frame = LAST3_FRAME; ref_frame > LAST_FRAME; --ref_frame) { |
| 3537 | const int ref_idx = ref_frame - LAST_FRAME; |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3538 | cpi->common.remapped_ref_idx[ref_idx] = |
| 3539 | cpi->common.remapped_ref_idx[ref_idx - 1]; |
Yunqing Wang | 9538e4d | 2019-01-07 18:28:08 +0000 | [diff] [blame] | 3540 | |
| 3541 | if (!cpi->rc.is_src_frame_alt_ref) { |
| 3542 | memcpy(cpi->interp_filter_selected[ref_frame], |
| 3543 | cpi->interp_filter_selected[ref_frame - 1], |
| 3544 | sizeof(cpi->interp_filter_selected[ref_frame - 1])); |
| 3545 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3546 | } |
| 3547 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3548 | |
Wei-Ting Lin | 240d9b4 | 2018-07-12 11:48:02 -0700 | [diff] [blame] | 3549 | #if USE_SYMM_MULTI_LAYER |
Wei-Ting Lin | cc75ca7 | 2018-07-10 15:36:32 -0700 | [diff] [blame] | 3550 | // This function is used to shift the virtual indices of bwd reference |
| 3551 | // frames as follows: |
| 3552 | // BWD_REF -> ALT2_REF -> EXT_REF |
| 3553 | // to clear a space to store the closest bwdref |
| 3554 | static INLINE void rshift_bwd_ref_frames(AV1_COMP *cpi) { |
| 3555 | // TODO(isbs): shift the scaled indices as well |
Urvang Joshi | 03d8ebe | 2018-11-08 17:13:44 -0800 | [diff] [blame] | 3556 | static const int ordered_bwd[3] = { BWDREF_FRAME, ALTREF2_FRAME, |
| 3557 | EXTREF_FRAME }; |
Wei-Ting Lin | cc75ca7 | 2018-07-10 15:36:32 -0700 | [diff] [blame] | 3558 | |
| 3559 | for (int i = 2; i > 0; --i) { |
Yunqing Wang | 9538e4d | 2019-01-07 18:28:08 +0000 | [diff] [blame] | 3560 | // [0] is allocated to the current coded frame, i.e. bwdref |
| 3561 | memcpy(cpi->interp_filter_selected[ordered_bwd[i]], |
| 3562 | cpi->interp_filter_selected[ordered_bwd[i - 1]], |
| 3563 | sizeof(cpi->interp_filter_selected[ordered_bwd[i - 1]])); |
| 3564 | |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3565 | cpi->common.remapped_ref_idx[ordered_bwd[i] - LAST_FRAME] = |
| 3566 | cpi->common.remapped_ref_idx[ordered_bwd[i - 1] - LAST_FRAME]; |
Wei-Ting Lin | cc75ca7 | 2018-07-10 15:36:32 -0700 | [diff] [blame] | 3567 | } |
| 3568 | } |
| 3569 | |
| 3570 | // This function is used to shift the virtual indices of bwd reference |
| 3571 | // frames as follows: |
| 3572 | // BWD_REF <- ALT2_REF <- EXT_REF |
| 3573 | // to update the bwd reference frame for coding the next frame. |
| 3574 | static INLINE void lshift_bwd_ref_frames(AV1_COMP *cpi) { |
| 3575 | // TODO(isbs): shift the scaled indices as well |
Urvang Joshi | 03d8ebe | 2018-11-08 17:13:44 -0800 | [diff] [blame] | 3576 | static const int ordered_bwd[3] = { BWDREF_FRAME, ALTREF2_FRAME, |
| 3577 | EXTREF_FRAME }; |
Wei-Ting Lin | cc75ca7 | 2018-07-10 15:36:32 -0700 | [diff] [blame] | 3578 | |
| 3579 | for (int i = 0; i < 2; ++i) { |
Yunqing Wang | 9538e4d | 2019-01-07 18:28:08 +0000 | [diff] [blame] | 3580 | // [0] is allocated to the current coded frame, i.e. bwdref |
| 3581 | memcpy(cpi->interp_filter_selected[ordered_bwd[i]], |
| 3582 | cpi->interp_filter_selected[ordered_bwd[i + 1]], |
| 3583 | sizeof(cpi->interp_filter_selected[ordered_bwd[i + 1]])); |
| 3584 | |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3585 | cpi->common.remapped_ref_idx[ordered_bwd[i] - LAST_FRAME] = |
| 3586 | cpi->common.remapped_ref_idx[ordered_bwd[i + 1] - LAST_FRAME]; |
Wei-Ting Lin | cc75ca7 | 2018-07-10 15:36:32 -0700 | [diff] [blame] | 3587 | } |
| 3588 | } |
Wei-Ting Lin | 240d9b4 | 2018-07-12 11:48:02 -0700 | [diff] [blame] | 3589 | #endif // USE_SYMM_MULTI_LAYER |
Wei-Ting Lin | cc75ca7 | 2018-07-10 15:36:32 -0700 | [diff] [blame] | 3590 | |
Zoe Liu | 8dd1c98 | 2017-09-11 10:14:35 -0700 | [diff] [blame] | 3591 | static void update_reference_frames(AV1_COMP *cpi) { |
| 3592 | AV1_COMMON *const cm = &cpi->common; |
| 3593 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3594 | // NOTE: Save the new show frame buffer index for --test-code=warn, i.e., |
| 3595 | // for the purpose to verify no mismatch between encoder and decoder. |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3596 | if (cm->show_frame) cpi->last_show_frame_buf = cm->cur_frame; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3597 | |
Sarah Parker | 3300552 | 2018-07-27 14:46:25 -0700 | [diff] [blame] | 3598 | // In the case of show_existing frame, we will not send fresh flag |
| 3599 | // to decoder. Any change in the reference frame buffer can be done by |
| 3600 | // switching the virtual indices. |
| 3601 | if (cm->show_existing_frame) { |
Sarah Parker | 29147cf | 2018-10-16 20:34:51 -0700 | [diff] [blame] | 3602 | // If we are not indicating to the decoder that this frame is |
| 3603 | // a show_existing_frame, which occurs in error_resilient mode, |
Sarah Parker | a9e1905 | 2018-10-18 17:49:26 -0700 | [diff] [blame] | 3604 | // we still want to refresh the LAST_FRAME when the current frame |
| 3605 | // was the source of an ext_arf. |
| 3606 | cpi->refresh_last_frame = |
| 3607 | !encode_show_existing_frame(cm) && cpi->rc.is_src_frame_ext_arf; |
Sarah Parker | 3300552 | 2018-07-27 14:46:25 -0700 | [diff] [blame] | 3608 | cpi->refresh_golden_frame = 0; |
| 3609 | cpi->refresh_bwd_ref_frame = 0; |
| 3610 | cpi->refresh_alt2_ref_frame = 0; |
| 3611 | cpi->refresh_alt_ref_frame = 0; |
| 3612 | |
| 3613 | cpi->rc.is_bwd_ref_frame = 0; |
| 3614 | cpi->rc.is_last_bipred_frame = 0; |
| 3615 | cpi->rc.is_bipred_frame = 0; |
| 3616 | } |
| 3617 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3618 | // At this point the new frame has been encoded. |
| 3619 | // If any buffer copy / swapping is signaled it should be done here. |
Zoe Liu | bcef1e6 | 2018-04-06 20:56:11 -0700 | [diff] [blame] | 3620 | |
Sarah Parker | b904161 | 2018-05-22 19:06:47 -0700 | [diff] [blame] | 3621 | // Only update all of the reference buffers if a KEY_FRAME is also a |
| 3622 | // show_frame. This ensures a fwd keyframe does not update all of the buffers |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 3623 | if ((cm->current_frame.frame_type == KEY_FRAME && cm->show_frame) || |
| 3624 | frame_is_sframe(cm)) { |
Zoe Liu | bcef1e6 | 2018-04-06 20:56:11 -0700 | [diff] [blame] | 3625 | for (int ref_frame = 0; ref_frame < REF_FRAMES; ++ref_frame) { |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3626 | assign_frame_buffer_p(&cm->ref_frame_map[cm->remapped_ref_idx[ref_frame]], |
| 3627 | cm->cur_frame); |
Zoe Liu | bcef1e6 | 2018-04-06 20:56:11 -0700 | [diff] [blame] | 3628 | } |
| 3629 | return; |
| 3630 | } |
| 3631 | |
| 3632 | if (av1_preserve_existing_gf(cpi)) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3633 | // We have decided to preserve the previously existing golden frame as our |
| 3634 | // new ARF frame. However, in the short term in function |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3635 | // av1_bitstream.c::get_refresh_mask() we left it in the GF slot and, if |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3636 | // we're updating the GF with the current decoded frame, we save it to the |
| 3637 | // ARF slot instead. |
| 3638 | // We now have to update the ARF with the current frame and swap gld_fb_idx |
| 3639 | // and alt_fb_idx so that, overall, we've stored the old GF in the new ARF |
| 3640 | // slot and, if we're updating the GF, the current frame becomes the new GF. |
| 3641 | int tmp; |
| 3642 | |
Wei-Ting Lin | a8c0245 | 2018-08-13 11:04:06 -0700 | [diff] [blame] | 3643 | // ARF in general is a better reference than overlay. We shouldkeep ARF as |
| 3644 | // reference instead of replacing it with overlay. |
| 3645 | |
| 3646 | if (!cpi->preserve_arf_as_gld) { |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3647 | assign_frame_buffer_p( |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3648 | &cm->ref_frame_map[get_ref_frame_map_idx(cm, ALTREF_FRAME)], |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3649 | cm->cur_frame); |
Wei-Ting Lin | a8c0245 | 2018-08-13 11:04:06 -0700 | [diff] [blame] | 3650 | } |
| 3651 | |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3652 | tmp = get_ref_frame_map_idx(cm, ALTREF_FRAME); |
| 3653 | cm->remapped_ref_idx[ALTREF_FRAME - LAST_FRAME] = |
| 3654 | get_ref_frame_map_idx(cm, GOLDEN_FRAME); |
| 3655 | cm->remapped_ref_idx[GOLDEN_FRAME - LAST_FRAME] = tmp; |
Yunqing Wang | 9538e4d | 2019-01-07 18:28:08 +0000 | [diff] [blame] | 3656 | |
| 3657 | // TODO(zoeliu): Do we need to copy cpi->interp_filter_selected[0] over to |
| 3658 | // cpi->interp_filter_selected[GOLDEN_FRAME]? |
Sarah Parker | 7a9bb78 | 2018-10-11 14:52:42 -0700 | [diff] [blame] | 3659 | } else if (cpi->rc.is_src_frame_ext_arf && encode_show_existing_frame(cm)) { |
Wei-Ting Lin | b72453f | 2018-06-26 14:05:38 -0700 | [diff] [blame] | 3660 | #if CONFIG_DEBUG |
| 3661 | const GF_GROUP *const gf_group = &cpi->twopass.gf_group; |
| 3662 | assert(gf_group->update_type[gf_group->index] == INTNL_OVERLAY_UPDATE); |
| 3663 | #endif |
Wei-Ting Lin | bafa11c | 2018-07-10 13:20:59 -0700 | [diff] [blame] | 3664 | #if USE_SYMM_MULTI_LAYER |
| 3665 | const int bwdref_to_show = |
| 3666 | (cpi->new_bwdref_update_rule == 1) ? BWDREF_FRAME : ALTREF2_FRAME; |
| 3667 | #else |
| 3668 | const int bwdref_to_show = ALTREF2_FRAME; |
| 3669 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3670 | // Deal with the special case for showing existing internal ALTREF_FRAME |
| 3671 | // Refresh the LAST_FRAME with the ALTREF_FRAME and retire the LAST3_FRAME |
| 3672 | // by updating the virtual indices. |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3673 | const int last3_remapped_idx = get_ref_frame_map_idx(cm, LAST3_FRAME); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3674 | shift_last_ref_frames(cpi); |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 3675 | |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3676 | cm->remapped_ref_idx[LAST_FRAME - LAST_FRAME] = |
| 3677 | get_ref_frame_map_idx(cm, bwdref_to_show); |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 3678 | |
Yunqing Wang | 9538e4d | 2019-01-07 18:28:08 +0000 | [diff] [blame] | 3679 | memcpy(cpi->interp_filter_selected[LAST_FRAME], |
| 3680 | cpi->interp_filter_selected[bwdref_to_show], |
| 3681 | sizeof(cpi->interp_filter_selected[bwdref_to_show])); |
Wei-Ting Lin | 240d9b4 | 2018-07-12 11:48:02 -0700 | [diff] [blame] | 3682 | #if USE_SYMM_MULTI_LAYER |
Wei-Ting Lin | cc75ca7 | 2018-07-10 15:36:32 -0700 | [diff] [blame] | 3683 | if (cpi->new_bwdref_update_rule == 1) { |
| 3684 | lshift_bwd_ref_frames(cpi); |
| 3685 | // pass outdated forward reference frame (previous LAST3) to the |
| 3686 | // spared space |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3687 | cm->remapped_ref_idx[EXTREF_FRAME - LAST_FRAME] = last3_remapped_idx; |
Wei-Ting Lin | cc75ca7 | 2018-07-10 15:36:32 -0700 | [diff] [blame] | 3688 | } else { |
| 3689 | #endif |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3690 | cm->remapped_ref_idx[bwdref_to_show - LAST_FRAME] = last3_remapped_idx; |
Wei-Ting Lin | 240d9b4 | 2018-07-12 11:48:02 -0700 | [diff] [blame] | 3691 | #if USE_SYMM_MULTI_LAYER |
Wei-Ting Lin | cc75ca7 | 2018-07-10 15:36:32 -0700 | [diff] [blame] | 3692 | } |
| 3693 | #endif |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3694 | } else { /* For non key/golden frames */ |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 3695 | // === ALTREF_FRAME === |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3696 | if (cpi->refresh_alt_ref_frame) { |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3697 | int arf_idx = get_ref_frame_map_idx(cm, ALTREF_FRAME); |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3698 | assign_frame_buffer_p(&cm->ref_frame_map[arf_idx], cm->cur_frame); |
Yunqing Wang | 9538e4d | 2019-01-07 18:28:08 +0000 | [diff] [blame] | 3699 | |
| 3700 | memcpy(cpi->interp_filter_selected[ALTREF_FRAME], |
| 3701 | cpi->interp_filter_selected[0], |
| 3702 | sizeof(cpi->interp_filter_selected[0])); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3703 | } |
| 3704 | |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 3705 | // === GOLDEN_FRAME === |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3706 | if (cpi->refresh_golden_frame) { |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3707 | assign_frame_buffer_p( |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3708 | &cm->ref_frame_map[get_ref_frame_map_idx(cm, GOLDEN_FRAME)], |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3709 | cm->cur_frame); |
Yunqing Wang | 9538e4d | 2019-01-07 18:28:08 +0000 | [diff] [blame] | 3710 | |
| 3711 | memcpy(cpi->interp_filter_selected[GOLDEN_FRAME], |
| 3712 | cpi->interp_filter_selected[0], |
| 3713 | sizeof(cpi->interp_filter_selected[0])); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3714 | } |
| 3715 | |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 3716 | // === BWDREF_FRAME === |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3717 | if (cpi->refresh_bwd_ref_frame) { |
Wei-Ting Lin | 240d9b4 | 2018-07-12 11:48:02 -0700 | [diff] [blame] | 3718 | #if USE_SYMM_MULTI_LAYER |
Wei-Ting Lin | cc75ca7 | 2018-07-10 15:36:32 -0700 | [diff] [blame] | 3719 | if (cpi->new_bwdref_update_rule) { |
| 3720 | // We shift the backward reference frame as follows: |
| 3721 | // BWDREF -> ALTREF2 -> EXTREF |
| 3722 | // and assign the newly coded frame to BWDREF so that it always |
| 3723 | // keeps the nearest future frame |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3724 | const int tmp = get_ref_frame_map_idx(cm, EXTREF_FRAME); |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3725 | assign_frame_buffer_p(&cm->ref_frame_map[tmp], cm->cur_frame); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3726 | |
Wei-Ting Lin | cc75ca7 | 2018-07-10 15:36:32 -0700 | [diff] [blame] | 3727 | rshift_bwd_ref_frames(cpi); |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3728 | cm->remapped_ref_idx[BWDREF_FRAME - LAST_FRAME] = tmp; |
Wei-Ting Lin | cc75ca7 | 2018-07-10 15:36:32 -0700 | [diff] [blame] | 3729 | } else { |
Wei-Ting Lin | 240d9b4 | 2018-07-12 11:48:02 -0700 | [diff] [blame] | 3730 | #endif // USE_SYMM_MULTI_LAYER |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3731 | assign_frame_buffer_p( |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3732 | &cm->ref_frame_map[get_ref_frame_map_idx(cm, BWDREF_FRAME)], |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3733 | cm->cur_frame); |
Wei-Ting Lin | 240d9b4 | 2018-07-12 11:48:02 -0700 | [diff] [blame] | 3734 | #if USE_SYMM_MULTI_LAYER |
Wei-Ting Lin | cc75ca7 | 2018-07-10 15:36:32 -0700 | [diff] [blame] | 3735 | } |
| 3736 | #endif |
Yunqing Wang | 9538e4d | 2019-01-07 18:28:08 +0000 | [diff] [blame] | 3737 | memcpy(cpi->interp_filter_selected[BWDREF_FRAME], |
| 3738 | cpi->interp_filter_selected[0], |
| 3739 | sizeof(cpi->interp_filter_selected[0])); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3740 | } |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 3741 | |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 3742 | // === ALTREF2_FRAME === |
| 3743 | if (cpi->refresh_alt2_ref_frame) { |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3744 | assign_frame_buffer_p( |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3745 | &cm->ref_frame_map[get_ref_frame_map_idx(cm, ALTREF2_FRAME)], |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3746 | cm->cur_frame); |
Yunqing Wang | 9538e4d | 2019-01-07 18:28:08 +0000 | [diff] [blame] | 3747 | |
| 3748 | memcpy(cpi->interp_filter_selected[ALTREF2_FRAME], |
| 3749 | cpi->interp_filter_selected[0], |
| 3750 | sizeof(cpi->interp_filter_selected[0])); |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 3751 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3752 | } |
| 3753 | |
| 3754 | if (cpi->refresh_last_frame) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3755 | // NOTE(zoeliu): We have two layers of mapping (1) from the per-frame |
| 3756 | // reference to the reference frame buffer virtual index; and then (2) from |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3757 | // the virtual index to the reference frame buffer (RefCntBuffer): |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3758 | // |
Urvang Joshi | 4d9f15f | 2018-11-05 15:26:22 -0800 | [diff] [blame] | 3759 | // LAST_FRAME, ..., EXTREF_FRAME |
| 3760 | // | | |
| 3761 | // v v |
| 3762 | // remapped_ref_idx[LAST_FRAME - 1], ..., remapped_ref_idx[EXTREF_FRAME - 1] |
| 3763 | // | | |
| 3764 | // v v |
| 3765 | // ref_frame_map[], ..., ref_frame_map[] |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3766 | // |
| 3767 | // When refresh_last_frame is set, it is intended to retire LAST3_FRAME, |
| 3768 | // have the other 2 LAST reference frames shifted as follows: |
| 3769 | // LAST_FRAME -> LAST2_FRAME -> LAST3_FRAME |
| 3770 | // , and then have LAST_FRAME refreshed by the newly coded frame. |
| 3771 | // |
| 3772 | // To fulfill it, the decoder will be notified to execute following 2 steps: |
| 3773 | // |
| 3774 | // (a) To change ref_frame_map[] and have the virtual index of LAST3_FRAME |
| 3775 | // to point to the newly coded frame, i.e. |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3776 | // ref_frame_map[lst_fb_idexes[2]] => cur_frame; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3777 | // |
| 3778 | // (b) To change the 1st layer mapping to have LAST_FRAME mapped to the |
| 3779 | // original virtual index of LAST3_FRAME and have the other mappings |
| 3780 | // shifted as follows: |
Urvang Joshi | 4d9f15f | 2018-11-05 15:26:22 -0800 | [diff] [blame] | 3781 | // LAST_FRAME, LAST2_FRAME, LAST3_FRAME |
| 3782 | // | | | |
| 3783 | // v v v |
| 3784 | // remapped_ref_idx[2], remapped_ref_idx[0], remapped_ref_idx[1] |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3785 | assign_frame_buffer_p( |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3786 | &cm->ref_frame_map[get_ref_frame_map_idx(cm, LAST3_FRAME)], |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3787 | cm->cur_frame); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3788 | |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3789 | int last3_remapped_idx = get_ref_frame_map_idx(cm, LAST3_FRAME); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3790 | |
Zoe Liu | bcef1e6 | 2018-04-06 20:56:11 -0700 | [diff] [blame] | 3791 | shift_last_ref_frames(cpi); |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3792 | cm->remapped_ref_idx[LAST_FRAME - LAST_FRAME] = last3_remapped_idx; |
Zoe Liu | bcef1e6 | 2018-04-06 20:56:11 -0700 | [diff] [blame] | 3793 | |
Sarah Parker | 5336b9c | 2018-10-18 11:34:20 -0700 | [diff] [blame] | 3794 | assert(!encode_show_existing_frame(cm)); |
Yunqing Wang | 9538e4d | 2019-01-07 18:28:08 +0000 | [diff] [blame] | 3795 | memcpy(cpi->interp_filter_selected[LAST_FRAME], |
| 3796 | cpi->interp_filter_selected[0], |
| 3797 | sizeof(cpi->interp_filter_selected[0])); |
Zoe Liu | bcef1e6 | 2018-04-06 20:56:11 -0700 | [diff] [blame] | 3798 | |
Wei-Ting Lin | bafa11c | 2018-07-10 13:20:59 -0700 | [diff] [blame] | 3799 | // If the new structure is used, we will always have overlay frames coupled |
| 3800 | // with bwdref frames. Therefore, we won't have to perform this update |
| 3801 | // in advance (we do this update when the overlay frame shows up). |
| 3802 | #if USE_SYMM_MULTI_LAYER |
| 3803 | if (cpi->new_bwdref_update_rule == 0 && cpi->rc.is_last_bipred_frame) { |
| 3804 | #else |
Zoe Liu | bcef1e6 | 2018-04-06 20:56:11 -0700 | [diff] [blame] | 3805 | if (cpi->rc.is_last_bipred_frame) { |
Wei-Ting Lin | bafa11c | 2018-07-10 13:20:59 -0700 | [diff] [blame] | 3806 | #endif |
Zoe Liu | bcef1e6 | 2018-04-06 20:56:11 -0700 | [diff] [blame] | 3807 | // Refresh the LAST_FRAME with the BWDREF_FRAME and retire the |
| 3808 | // LAST3_FRAME by updating the virtual indices. |
| 3809 | // |
| 3810 | // NOTE: The source frame for BWDREF does not have a holding position as |
| 3811 | // the OVERLAY frame for ALTREF's. Hence, to resolve the reference |
| 3812 | // virtual index reshuffling for BWDREF, the encoder always |
| 3813 | // specifies a LAST_BIPRED right before BWDREF and completes the |
| 3814 | // reshuffling job accordingly. |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3815 | last3_remapped_idx = get_ref_frame_map_idx(cm, LAST3_FRAME); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3816 | |
| 3817 | shift_last_ref_frames(cpi); |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3818 | cm->remapped_ref_idx[LAST_FRAME - LAST_FRAME] = |
| 3819 | get_ref_frame_map_idx(cm, BWDREF_FRAME); |
| 3820 | cm->remapped_ref_idx[BWDREF_FRAME - LAST_FRAME] = last3_remapped_idx; |
Yunqing Wang | 9538e4d | 2019-01-07 18:28:08 +0000 | [diff] [blame] | 3821 | |
| 3822 | memcpy(cpi->interp_filter_selected[LAST_FRAME], |
| 3823 | cpi->interp_filter_selected[BWDREF_FRAME], |
| 3824 | sizeof(cpi->interp_filter_selected[BWDREF_FRAME])); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3825 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3826 | } |
| 3827 | |
| 3828 | #if DUMP_REF_FRAME_IMAGES == 1 |
| 3829 | // Dump out all reference frame images. |
| 3830 | dump_ref_frame_images(cpi); |
| 3831 | #endif // DUMP_REF_FRAME_IMAGES |
| 3832 | } |
| 3833 | |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3834 | static INLINE void alloc_frame_mvs(AV1_COMMON *const cm, RefCntBuffer *buf) { |
| 3835 | assert(buf != NULL); |
| 3836 | ensure_mv_buffer(buf, cm); |
| 3837 | buf->width = cm->width; |
| 3838 | buf->height = cm->height; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3839 | } |
| 3840 | |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 3841 | static void scale_references(AV1_COMP *cpi) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3842 | AV1_COMMON *cm = &cpi->common; |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 3843 | const int num_planes = av1_num_planes(cm); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3844 | MV_REFERENCE_FRAME ref_frame; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3845 | const AOM_REFFRAME ref_mask[INTER_REFS_PER_FRAME] = { |
Sebastien Alaiwan | 365e644 | 2017-10-16 11:35:00 +0200 | [diff] [blame] | 3846 | AOM_LAST_FLAG, AOM_LAST2_FLAG, AOM_LAST3_FLAG, AOM_GOLD_FLAG, |
| 3847 | AOM_BWD_FLAG, AOM_ALT2_FLAG, AOM_ALT_FLAG |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3848 | }; |
| 3849 | |
| 3850 | for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3851 | // Need to convert from AOM_REFFRAME to index into ref_mask (subtract 1). |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3852 | if (cpi->ref_frame_flags & ref_mask[ref_frame - 1]) { |
| 3853 | BufferPool *const pool = cm->buffer_pool; |
| 3854 | const YV12_BUFFER_CONFIG *const ref = |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3855 | get_ref_frame_yv12_buf(cm, ref_frame); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3856 | |
| 3857 | if (ref == NULL) { |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3858 | cpi->scaled_ref_buf[ref_frame - 1] = NULL; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3859 | continue; |
| 3860 | } |
| 3861 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3862 | if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3863 | int force_scaling = 0; |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3864 | RefCntBuffer *new_fb = cpi->scaled_ref_buf[ref_frame - 1]; |
| 3865 | if (new_fb == NULL) { |
| 3866 | const int new_fb_idx = get_free_fb(cm); |
| 3867 | if (new_fb_idx == INVALID_IDX) { |
Wan-Teh Chang | 4a8c004 | 2018-10-05 09:41:52 -0700 | [diff] [blame] | 3868 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
| 3869 | "Unable to find free frame buffer"); |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3870 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3871 | force_scaling = 1; |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3872 | new_fb = &pool->frame_bufs[new_fb_idx]; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3873 | } |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3874 | |
| 3875 | if (force_scaling || new_fb->buf.y_crop_width != cm->width || |
| 3876 | new_fb->buf.y_crop_height != cm->height) { |
Yaowu Xu | 671f2bd | 2016-09-30 15:07:57 -0700 | [diff] [blame] | 3877 | if (aom_realloc_frame_buffer( |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3878 | &new_fb->buf, cm->width, cm->height, |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 3879 | cm->seq_params.subsampling_x, cm->seq_params.subsampling_y, |
Satish Kumar Suman | 2990996 | 2019-01-09 10:31:21 +0530 | [diff] [blame] | 3880 | cm->seq_params.use_highbitdepth, cpi->oxcf.border_in_pixels, |
Wan-Teh Chang | 41d286f | 2018-10-03 11:43:03 -0700 | [diff] [blame] | 3881 | cm->byte_alignment, NULL, NULL, NULL)) { |
| 3882 | if (force_scaling) { |
| 3883 | // Release the reference acquired in the get_free_fb() call above. |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3884 | --new_fb->ref_count; |
Wan-Teh Chang | 41d286f | 2018-10-03 11:43:03 -0700 | [diff] [blame] | 3885 | } |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3886 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3887 | "Failed to allocate frame buffer"); |
Wan-Teh Chang | 41d286f | 2018-10-03 11:43:03 -0700 | [diff] [blame] | 3888 | } |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 3889 | av1_resize_and_extend_frame( |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3890 | ref, &new_fb->buf, (int)cm->seq_params.bit_depth, num_planes); |
| 3891 | cpi->scaled_ref_buf[ref_frame - 1] = new_fb; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3892 | alloc_frame_mvs(cm, new_fb); |
| 3893 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3894 | } else { |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 3895 | RefCntBuffer *buf = get_ref_frame_buf(cm, ref_frame); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3896 | buf->buf.y_crop_width = ref->y_crop_width; |
| 3897 | buf->buf.y_crop_height = ref->y_crop_height; |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3898 | cpi->scaled_ref_buf[ref_frame - 1] = buf; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3899 | ++buf->ref_count; |
| 3900 | } |
| 3901 | } else { |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3902 | if (cpi->oxcf.pass != 0) cpi->scaled_ref_buf[ref_frame - 1] = NULL; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3903 | } |
| 3904 | } |
| 3905 | } |
| 3906 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3907 | static void release_scaled_references(AV1_COMP *cpi) { |
Imdad Sardharwalla | dadaba6 | 2018-02-23 12:06:56 +0000 | [diff] [blame] | 3908 | // TODO(isbs): only refresh the necessary frames, rather than all of them |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3909 | for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { |
| 3910 | RefCntBuffer *const buf = cpi->scaled_ref_buf[i]; |
| 3911 | if (buf != NULL) { |
Imdad Sardharwalla | dadaba6 | 2018-02-23 12:06:56 +0000 | [diff] [blame] | 3912 | --buf->ref_count; |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 3913 | cpi->scaled_ref_buf[i] = NULL; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3914 | } |
| 3915 | } |
| 3916 | } |
| 3917 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3918 | static void set_mv_search_params(AV1_COMP *cpi) { |
| 3919 | const AV1_COMMON *const cm = &cpi->common; |
| 3920 | const unsigned int max_mv_def = AOMMIN(cm->width, cm->height); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3921 | |
| 3922 | // Default based on max resolution. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3923 | cpi->mv_step_param = av1_init_search_range(max_mv_def); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3924 | |
| 3925 | if (cpi->sf.mv.auto_mv_step_size) { |
| 3926 | if (frame_is_intra_only(cm)) { |
| 3927 | // Initialize max_mv_magnitude for use in the first INTER frame |
| 3928 | // after a key/intra-only frame. |
| 3929 | cpi->max_mv_magnitude = max_mv_def; |
| 3930 | } else { |
| 3931 | if (cm->show_frame) { |
| 3932 | // Allow mv_steps to correspond to twice the max mv magnitude found |
| 3933 | // in the previous frame, capped by the default max_mv_magnitude based |
| 3934 | // on resolution. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3935 | cpi->mv_step_param = av1_init_search_range( |
| 3936 | AOMMIN(max_mv_def, 2 * cpi->max_mv_magnitude)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3937 | } |
| 3938 | cpi->max_mv_magnitude = 0; |
| 3939 | } |
| 3940 | } |
| 3941 | } |
| 3942 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3943 | static void set_size_independent_vars(AV1_COMP *cpi) { |
Debargha Mukherjee | b98a702 | 2016-11-15 16:07:12 -0800 | [diff] [blame] | 3944 | int i; |
Debargha Mukherjee | df71310 | 2018-10-02 12:33:32 -0700 | [diff] [blame] | 3945 | AV1_COMMON *cm = &cpi->common; |
Debargha Mukherjee | b98a702 | 2016-11-15 16:07:12 -0800 | [diff] [blame] | 3946 | for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) { |
Debargha Mukherjee | df71310 | 2018-10-02 12:33:32 -0700 | [diff] [blame] | 3947 | cm->global_motion[i] = default_warp_params; |
Debargha Mukherjee | b98a702 | 2016-11-15 16:07:12 -0800 | [diff] [blame] | 3948 | } |
| 3949 | cpi->global_motion_search_done = 0; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3950 | av1_set_speed_features_framesize_independent(cpi); |
| 3951 | av1_set_rd_speed_thresholds(cpi); |
| 3952 | av1_set_rd_speed_thresholds_sub8x8(cpi); |
Debargha Mukherjee | df71310 | 2018-10-02 12:33:32 -0700 | [diff] [blame] | 3953 | cm->interp_filter = SWITCHABLE; |
| 3954 | cm->switchable_motion_mode = 1; |
| 3955 | |
| 3956 | if (frame_is_intra_only(cm)) { |
| 3957 | if (cm->seq_params.force_screen_content_tools == 2) { |
| 3958 | cm->allow_screen_content_tools = |
| 3959 | cpi->oxcf.content == AOM_CONTENT_SCREEN || |
| 3960 | is_screen_content(cpi->source->y_buffer, |
| 3961 | cpi->source->flags & YV12_FLAG_HIGHBITDEPTH, |
| 3962 | cm->seq_params.bit_depth, cpi->source->y_stride, |
| 3963 | cpi->source->y_width, cpi->source->y_height); |
| 3964 | } else { |
| 3965 | cm->allow_screen_content_tools = |
| 3966 | cm->seq_params.force_screen_content_tools; |
| 3967 | } |
| 3968 | } |
Aniket Dhok | f6d7ed8 | 2019-01-04 14:05:57 +0530 | [diff] [blame] | 3969 | cpi->is_screen_content_type = (cm->allow_screen_content_tools != 0); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3970 | } |
| 3971 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3972 | static void set_size_dependent_vars(AV1_COMP *cpi, int *q, int *bottom_index, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3973 | int *top_index) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3974 | AV1_COMMON *const cm = &cpi->common; |
| 3975 | const AV1EncoderConfig *const oxcf = &cpi->oxcf; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3976 | |
| 3977 | // Setup variables that depend on the dimensions of the frame. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3978 | av1_set_speed_features_framesize_dependent(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3979 | |
Sebastien Alaiwan | 41cae6a | 2018-01-12 12:22:29 +0100 | [diff] [blame] | 3980 | // Decide q and q bounds. |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 3981 | *q = av1_rc_pick_q_and_bounds(cpi, cm->width, cm->height, bottom_index, |
| 3982 | top_index); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3983 | |
James Zern | 01a9d70 | 2017-08-25 19:09:33 +0000 | [diff] [blame] | 3984 | if (!frame_is_intra_only(cm)) { |
RogerZhou | 3b63524 | 2017-09-19 10:06:46 -0700 | [diff] [blame] | 3985 | set_high_precision_mv(cpi, (*q) < HIGH_PRECISION_MV_QTHRESH, |
RogerZhou | 10a0380 | 2017-10-26 11:49:48 -0700 | [diff] [blame] | 3986 | cpi->common.cur_frame_force_integer_mv); |
James Zern | 01a9d70 | 2017-08-25 19:09:33 +0000 | [diff] [blame] | 3987 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3988 | |
| 3989 | // Configure experimental use of segmentation for enhanced coding of |
| 3990 | // static regions if indicated. |
| 3991 | // Only allowed in the second pass of a two pass encode, as it requires |
| 3992 | // lagged coding, and if the relevant speed feature flag is set. |
| 3993 | if (oxcf->pass == 2 && cpi->sf.static_segmentation) |
| 3994 | configure_static_seg_features(cpi); |
| 3995 | } |
| 3996 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 3997 | static void init_motion_estimation(AV1_COMP *cpi) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 3998 | int y_stride = cpi->scaled_source.y_stride; |
| 3999 | |
| 4000 | if (cpi->sf.mv.search_method == NSTEP) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 4001 | av1_init3smotion_compensation(&cpi->ss_cfg, y_stride); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4002 | } else if (cpi->sf.mv.search_method == DIAMOND) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 4003 | av1_init_dsmotion_compensation(&cpi->ss_cfg, y_stride); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4004 | } |
| 4005 | } |
| 4006 | |
Debargha Mukherjee | 84f567c | 2017-06-21 10:53:59 -0700 | [diff] [blame] | 4007 | #define COUPLED_CHROMA_FROM_LUMA_RESTORATION 0 |
Rupert Swarbrick | bcb65fe | 2017-10-25 17:15:28 +0100 | [diff] [blame] | 4008 | static void set_restoration_unit_size(int width, int height, int sx, int sy, |
| 4009 | RestorationInfo *rst) { |
Debargha Mukherjee | 1008c1e | 2017-03-06 19:18:43 -0800 | [diff] [blame] | 4010 | (void)width; |
| 4011 | (void)height; |
Debargha Mukherjee | 84f567c | 2017-06-21 10:53:59 -0700 | [diff] [blame] | 4012 | (void)sx; |
| 4013 | (void)sy; |
| 4014 | #if COUPLED_CHROMA_FROM_LUMA_RESTORATION |
| 4015 | int s = AOMMIN(sx, sy); |
| 4016 | #else |
| 4017 | int s = 0; |
| 4018 | #endif // !COUPLED_CHROMA_FROM_LUMA_RESTORATION |
| 4019 | |
Debargha Mukherjee | 5f7f367 | 2017-08-12 10:22:49 -0700 | [diff] [blame] | 4020 | if (width * height > 352 * 288) |
Urvang Joshi | 813186b | 2018-03-08 15:38:46 -0800 | [diff] [blame] | 4021 | rst[0].restoration_unit_size = RESTORATION_UNITSIZE_MAX; |
Debargha Mukherjee | 5f7f367 | 2017-08-12 10:22:49 -0700 | [diff] [blame] | 4022 | else |
Urvang Joshi | 813186b | 2018-03-08 15:38:46 -0800 | [diff] [blame] | 4023 | rst[0].restoration_unit_size = (RESTORATION_UNITSIZE_MAX >> 1); |
Rupert Swarbrick | bcb65fe | 2017-10-25 17:15:28 +0100 | [diff] [blame] | 4024 | rst[1].restoration_unit_size = rst[0].restoration_unit_size >> s; |
| 4025 | rst[2].restoration_unit_size = rst[1].restoration_unit_size; |
Debargha Mukherjee | 1008c1e | 2017-03-06 19:18:43 -0800 | [diff] [blame] | 4026 | } |
Debargha Mukherjee | 1008c1e | 2017-03-06 19:18:43 -0800 | [diff] [blame] | 4027 | |
Ravi Chaudhary | 783d6a3 | 2018-08-28 18:21:02 +0530 | [diff] [blame] | 4028 | static void init_ref_frame_bufs(AV1_COMP *cpi) { |
| 4029 | AV1_COMMON *const cm = &cpi->common; |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 4030 | int i; |
| 4031 | BufferPool *const pool = cm->buffer_pool; |
Jack Haughton | ddb8060 | 2018-11-21 16:41:49 +0000 | [diff] [blame] | 4032 | cm->cur_frame = NULL; |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 4033 | for (i = 0; i < REF_FRAMES; ++i) { |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 4034 | cm->ref_frame_map[i] = NULL; |
Wan-Teh Chang | d05e033 | 2018-10-03 12:00:43 -0700 | [diff] [blame] | 4035 | } |
| 4036 | for (i = 0; i < FRAME_BUFFERS; ++i) { |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 4037 | pool->frame_bufs[i].ref_count = 0; |
| 4038 | } |
RogerZhou | 86902d0 | 2018-02-28 15:29:16 -0800 | [diff] [blame] | 4039 | if (cm->seq_params.force_screen_content_tools) { |
Hui Su | 2d5fd74 | 2018-02-21 18:10:37 -0800 | [diff] [blame] | 4040 | for (i = 0; i < FRAME_BUFFERS; ++i) { |
Ravi Chaudhary | 783d6a3 | 2018-08-28 18:21:02 +0530 | [diff] [blame] | 4041 | av1_hash_table_init(&pool->frame_bufs[i].hash_table, &cpi->td.mb); |
Hui Su | 2d5fd74 | 2018-02-21 18:10:37 -0800 | [diff] [blame] | 4042 | } |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 4043 | } |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 4044 | } |
| 4045 | |
Yaowu Xu | d3e7c68 | 2017-12-21 14:08:25 -0800 | [diff] [blame] | 4046 | static void check_initial_width(AV1_COMP *cpi, int use_highbitdepth, |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 4047 | int subsampling_x, int subsampling_y) { |
| 4048 | AV1_COMMON *const cm = &cpi->common; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 4049 | SequenceHeader *const seq_params = &cm->seq_params; |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 4050 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 4051 | if (!cpi->initial_width || seq_params->use_highbitdepth != use_highbitdepth || |
| 4052 | seq_params->subsampling_x != subsampling_x || |
| 4053 | seq_params->subsampling_y != subsampling_y) { |
| 4054 | seq_params->subsampling_x = subsampling_x; |
| 4055 | seq_params->subsampling_y = subsampling_y; |
| 4056 | seq_params->use_highbitdepth = use_highbitdepth; |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 4057 | |
| 4058 | alloc_raw_frame_buffers(cpi); |
Ravi Chaudhary | 783d6a3 | 2018-08-28 18:21:02 +0530 | [diff] [blame] | 4059 | init_ref_frame_bufs(cpi); |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 4060 | alloc_util_frame_buffers(cpi); |
| 4061 | |
| 4062 | init_motion_estimation(cpi); // TODO(agrange) This can be removed. |
| 4063 | |
| 4064 | cpi->initial_width = cm->width; |
| 4065 | cpi->initial_height = cm->height; |
| 4066 | cpi->initial_mbs = cm->MBs; |
| 4067 | } |
| 4068 | } |
| 4069 | |
| 4070 | // Returns 1 if the assigned width or height was <= 0. |
| 4071 | static int set_size_literal(AV1_COMP *cpi, int width, int height) { |
| 4072 | AV1_COMMON *cm = &cpi->common; |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 4073 | const int num_planes = av1_num_planes(cm); |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 4074 | check_initial_width(cpi, cm->seq_params.use_highbitdepth, |
| 4075 | cm->seq_params.subsampling_x, |
| 4076 | cm->seq_params.subsampling_y); |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 4077 | |
| 4078 | if (width <= 0 || height <= 0) return 1; |
| 4079 | |
| 4080 | cm->width = width; |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 4081 | cm->height = height; |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 4082 | |
| 4083 | if (cpi->initial_width && cpi->initial_height && |
| 4084 | (cm->width > cpi->initial_width || cm->height > cpi->initial_height)) { |
| 4085 | av1_free_context_buffers(cm); |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 4086 | av1_free_pc_tree(&cpi->td, num_planes); |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 4087 | alloc_compressor_data(cpi); |
| 4088 | realloc_segmentation_maps(cpi); |
| 4089 | cpi->initial_width = cpi->initial_height = 0; |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 4090 | } |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 4091 | update_frame_size(cpi); |
| 4092 | |
| 4093 | return 0; |
| 4094 | } |
| 4095 | |
Fergus Simpson | bc18993 | 2017-05-16 17:02:39 -0700 | [diff] [blame] | 4096 | static void set_frame_size(AV1_COMP *cpi, int width, int height) { |
Fergus Simpson | bc18993 | 2017-05-16 17:02:39 -0700 | [diff] [blame] | 4097 | AV1_COMMON *const cm = &cpi->common; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 4098 | const SequenceHeader *const seq_params = &cm->seq_params; |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 4099 | const int num_planes = av1_num_planes(cm); |
Fergus Simpson | bc18993 | 2017-05-16 17:02:39 -0700 | [diff] [blame] | 4100 | MACROBLOCKD *const xd = &cpi->td.mb.e_mbd; |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4101 | int ref_frame; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4102 | |
Fergus Simpson | bc18993 | 2017-05-16 17:02:39 -0700 | [diff] [blame] | 4103 | if (width != cm->width || height != cm->height) { |
Fergus Simpson | 3502d08 | 2017-04-10 12:25:07 -0700 | [diff] [blame] | 4104 | // There has been a change in the encoded frame size |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 4105 | set_size_literal(cpi, width, height); |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4106 | set_mv_search_params(cpi); |
Urvang Joshi | c8b52d5 | 2018-03-23 13:16:51 -0700 | [diff] [blame] | 4107 | // Recalculate 'all_lossless' in case super-resolution was (un)selected. |
Cheng Chen | 09c83a5 | 2018-06-05 12:27:36 -0700 | [diff] [blame] | 4108 | cm->all_lossless = cm->coded_lossless && !av1_superres_scaled(cm); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4109 | } |
| 4110 | |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4111 | if (cpi->oxcf.pass == 2) { |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4112 | av1_set_target_rate(cpi, cm->width, cm->height); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4113 | } |
| 4114 | |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 4115 | alloc_frame_mvs(cm, cm->cur_frame); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4116 | |
Cherma Rajan A | 71d20db | 2018-04-27 11:15:32 +0530 | [diff] [blame] | 4117 | // Allocate above context buffers |
Cherma Rajan A | f147908 | 2018-05-09 14:26:34 +0530 | [diff] [blame] | 4118 | if (cm->num_allocated_above_context_planes < av1_num_planes(cm) || |
| 4119 | cm->num_allocated_above_context_mi_col < cm->mi_cols || |
Cherma Rajan A | 71d20db | 2018-04-27 11:15:32 +0530 | [diff] [blame] | 4120 | cm->num_allocated_above_contexts < cm->tile_rows) { |
| 4121 | av1_free_above_context_buffers(cm, cm->num_allocated_above_contexts); |
| 4122 | if (av1_alloc_above_context_buffers(cm, cm->tile_rows)) |
| 4123 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
| 4124 | "Failed to allocate context buffers"); |
| 4125 | } |
| 4126 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4127 | // Reset the frame pointers to the current frame size. |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 4128 | if (aom_realloc_frame_buffer( |
Jack Haughton | ddb8060 | 2018-11-21 16:41:49 +0000 | [diff] [blame] | 4129 | &cm->cur_frame->buf, cm->width, cm->height, seq_params->subsampling_x, |
| 4130 | seq_params->subsampling_y, seq_params->use_highbitdepth, |
Satish Kumar Suman | 2990996 | 2019-01-09 10:31:21 +0530 | [diff] [blame] | 4131 | cpi->oxcf.border_in_pixels, cm->byte_alignment, NULL, NULL, NULL)) |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 4132 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4133 | "Failed to allocate frame buffer"); |
| 4134 | |
Rupert Swarbrick | f88bc04 | 2017-10-18 10:45:51 +0100 | [diff] [blame] | 4135 | const int frame_width = cm->superres_upscaled_width; |
| 4136 | const int frame_height = cm->superres_upscaled_height; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 4137 | set_restoration_unit_size(frame_width, frame_height, |
| 4138 | seq_params->subsampling_x, |
| 4139 | seq_params->subsampling_y, cm->rst_info); |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 4140 | for (int i = 0; i < num_planes; ++i) |
Rupert Swarbrick | 1a96c3f | 2017-10-24 11:55:00 +0100 | [diff] [blame] | 4141 | cm->rst_info[i].frame_restoration_type = RESTORE_NONE; |
Rupert Swarbrick | f88bc04 | 2017-10-18 10:45:51 +0100 | [diff] [blame] | 4142 | |
| 4143 | av1_alloc_restoration_buffers(cm); |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 4144 | alloc_util_frame_buffers(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4145 | init_motion_estimation(cpi); |
| 4146 | |
| 4147 | for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 4148 | RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame); |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 4149 | if (buf != NULL) { |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 4150 | struct scale_factors *sf = get_ref_scale_factors(cm, ref_frame); |
| 4151 | av1_setup_scale_factors_for_frame(sf, buf->buf.y_crop_width, |
David Turner | 1bcefb3 | 2018-11-19 17:54:00 +0000 | [diff] [blame] | 4152 | buf->buf.y_crop_height, cm->width, |
Debargha Mukherjee | e242a81 | 2018-03-07 21:43:09 -0800 | [diff] [blame] | 4153 | cm->height); |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 4154 | 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] | 4155 | } |
| 4156 | } |
Zoe Liu | 7b1ec7a | 2017-05-24 22:28:24 -0700 | [diff] [blame] | 4157 | |
Hui Su | 5ebd870 | 2018-01-08 18:09:20 -0800 | [diff] [blame] | 4158 | 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] | 4159 | cm->width, cm->height); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4160 | |
| 4161 | set_ref_ptrs(cm, xd, LAST_FRAME, LAST_FRAME); |
| 4162 | } |
| 4163 | |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4164 | static uint8_t calculate_next_resize_scale(const AV1_COMP *cpi) { |
| 4165 | // Choose an arbitrary random number |
| 4166 | static unsigned int seed = 56789; |
| 4167 | const AV1EncoderConfig *oxcf = &cpi->oxcf; |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4168 | if (oxcf->pass == 1) return SCALE_NUMERATOR; |
| 4169 | uint8_t new_denom = SCALE_NUMERATOR; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4170 | |
Debargha Mukherjee | 2b7c2b3 | 2018-04-10 07:35:28 -0700 | [diff] [blame] | 4171 | if (cpi->common.seq_params.reduced_still_picture_hdr) return SCALE_NUMERATOR; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4172 | switch (oxcf->resize_mode) { |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4173 | case RESIZE_NONE: new_denom = SCALE_NUMERATOR; break; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4174 | case RESIZE_FIXED: |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 4175 | if (cpi->common.current_frame.frame_type == KEY_FRAME) |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4176 | new_denom = oxcf->resize_kf_scale_denominator; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4177 | else |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4178 | new_denom = oxcf->resize_scale_denominator; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4179 | break; |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4180 | case RESIZE_RANDOM: new_denom = lcg_rand16(&seed) % 9 + 8; break; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4181 | default: assert(0); |
| 4182 | } |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4183 | return new_denom; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4184 | } |
| 4185 | |
Debargha Mukherjee | e3cd5a5 | 2018-11-29 11:05:22 -0800 | [diff] [blame] | 4186 | #define ENERGY_BY_Q2_THRESH 0.01 |
Debargha Mukherjee | 21eb040 | 2018-12-03 12:10:59 -0800 | [diff] [blame] | 4187 | #define ENERGY_BY_AC_THRESH 0.2 |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 4188 | |
| 4189 | static uint8_t get_superres_denom_from_qindex_energy(int qindex, double *energy, |
Debargha Mukherjee | 21eb040 | 2018-12-03 12:10:59 -0800 | [diff] [blame] | 4190 | double threshq, |
| 4191 | double threshp) { |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 4192 | const double q = av1_convert_qindex_to_q(qindex, AOM_BITS_8); |
Debargha Mukherjee | 21eb040 | 2018-12-03 12:10:59 -0800 | [diff] [blame] | 4193 | const double tq = threshq * q * q; |
| 4194 | const double tp = threshp * energy[1]; |
| 4195 | const double thresh = AOMMIN(tq, tp); |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 4196 | int k; |
Debargha Mukherjee | 21eb040 | 2018-12-03 12:10:59 -0800 | [diff] [blame] | 4197 | for (k = 16; k > 8; --k) { |
| 4198 | if (energy[k - 1] > thresh) break; |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 4199 | } |
Debargha Mukherjee | 21eb040 | 2018-12-03 12:10:59 -0800 | [diff] [blame] | 4200 | return 3 * SCALE_NUMERATOR - k; |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 4201 | } |
| 4202 | |
| 4203 | static uint8_t get_superres_denom_for_qindex(const AV1_COMP *cpi, int qindex) { |
Debargha Mukherjee | 21eb040 | 2018-12-03 12:10:59 -0800 | [diff] [blame] | 4204 | double energy[16]; |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 4205 | analyze_hor_freq(cpi, energy); |
Debargha Mukherjee | 21eb040 | 2018-12-03 12:10:59 -0800 | [diff] [blame] | 4206 | /* |
| 4207 | printf("\nenergy = ["); |
| 4208 | for (int k = 1; k < 16; ++k) printf("%f, ", energy[k]); |
| 4209 | printf("]\n"); |
| 4210 | */ |
| 4211 | return get_superres_denom_from_qindex_energy( |
| 4212 | qindex, energy, ENERGY_BY_Q2_THRESH, ENERGY_BY_AC_THRESH); |
Debargha Mukherjee | f48b0d2 | 2018-11-20 12:23:43 -0800 | [diff] [blame] | 4213 | } |
| 4214 | |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4215 | static uint8_t calculate_next_superres_scale(AV1_COMP *cpi) { |
| 4216 | // Choose an arbitrary random number |
| 4217 | static unsigned int seed = 34567; |
| 4218 | const AV1EncoderConfig *oxcf = &cpi->oxcf; |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4219 | if (oxcf->pass == 1) return SCALE_NUMERATOR; |
| 4220 | uint8_t new_denom = SCALE_NUMERATOR; |
Urvang Joshi | 2c92b07 | 2018-03-19 17:23:31 -0700 | [diff] [blame] | 4221 | |
| 4222 | // Make sure that superres mode of the frame is consistent with the |
| 4223 | // sequence-level flag. |
| 4224 | assert(IMPLIES(oxcf->superres_mode != SUPERRES_NONE, |
| 4225 | cpi->common.seq_params.enable_superres)); |
| 4226 | assert(IMPLIES(!cpi->common.seq_params.enable_superres, |
| 4227 | oxcf->superres_mode == SUPERRES_NONE)); |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4228 | |
| 4229 | switch (oxcf->superres_mode) { |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4230 | case SUPERRES_NONE: new_denom = SCALE_NUMERATOR; break; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4231 | case SUPERRES_FIXED: |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 4232 | if (cpi->common.current_frame.frame_type == KEY_FRAME) |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4233 | new_denom = oxcf->superres_kf_scale_denominator; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4234 | else |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4235 | new_denom = oxcf->superres_scale_denominator; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4236 | break; |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4237 | case SUPERRES_RANDOM: new_denom = lcg_rand16(&seed) % 9 + 8; break; |
Urvang Joshi | f1fa686 | 2018-01-08 16:39:33 -0800 | [diff] [blame] | 4238 | case SUPERRES_QTHRESH: { |
Debargha Mukherjee | df71310 | 2018-10-02 12:33:32 -0700 | [diff] [blame] | 4239 | // Do not use superres when screen content tools are used. |
| 4240 | if (cpi->common.allow_screen_content_tools) break; |
Debargha Mukherjee | 2b2c5fd | 2018-11-14 13:21:24 -0800 | [diff] [blame] | 4241 | if (oxcf->rc_mode == AOM_VBR || oxcf->rc_mode == AOM_CQ) |
| 4242 | av1_set_target_rate(cpi, cpi->oxcf.width, cpi->oxcf.height); |
Urvang Joshi | 2c92b07 | 2018-03-19 17:23:31 -0700 | [diff] [blame] | 4243 | int bottom_index, top_index; |
| 4244 | const int q = av1_rc_pick_q_and_bounds( |
| 4245 | cpi, cpi->oxcf.width, cpi->oxcf.height, &bottom_index, &top_index); |
Debargha Mukherjee | f48b0d2 | 2018-11-20 12:23:43 -0800 | [diff] [blame] | 4246 | |
Debargha Mukherjee | acd9b7d | 2018-11-26 15:15:05 -0800 | [diff] [blame] | 4247 | const int qthresh = (frame_is_intra_only(&cpi->common)) |
| 4248 | ? oxcf->superres_kf_qthresh |
| 4249 | : oxcf->superres_qthresh; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4250 | if (q < qthresh) { |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4251 | new_denom = SCALE_NUMERATOR; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4252 | } else { |
Debargha Mukherjee | e3cd5a5 | 2018-11-29 11:05:22 -0800 | [diff] [blame] | 4253 | new_denom = get_superres_denom_for_qindex(cpi, q); |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4254 | } |
| 4255 | break; |
Urvang Joshi | f1fa686 | 2018-01-08 16:39:33 -0800 | [diff] [blame] | 4256 | } |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4257 | default: assert(0); |
| 4258 | } |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4259 | return new_denom; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4260 | } |
| 4261 | |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4262 | static int dimension_is_ok(int orig_dim, int resized_dim, int denom) { |
| 4263 | return (resized_dim * SCALE_NUMERATOR >= orig_dim * denom / 2); |
| 4264 | } |
| 4265 | |
| 4266 | static int dimensions_are_ok(int owidth, int oheight, size_params_type *rsz) { |
Urvang Joshi | 94ad370 | 2017-12-06 11:38:08 -0800 | [diff] [blame] | 4267 | // Only need to check the width, as scaling is horizontal only. |
| 4268 | (void)oheight; |
| 4269 | return dimension_is_ok(owidth, rsz->resize_width, rsz->superres_denom); |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4270 | } |
| 4271 | |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4272 | static int validate_size_scales(RESIZE_MODE resize_mode, |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 4273 | SUPERRES_MODE superres_mode, int owidth, |
| 4274 | int oheight, size_params_type *rsz) { |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4275 | if (dimensions_are_ok(owidth, oheight, rsz)) { // Nothing to do. |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4276 | return 1; |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4277 | } |
| 4278 | |
Urvang Joshi | 69fde2e | 2017-10-09 15:34:18 -0700 | [diff] [blame] | 4279 | // Calculate current resize scale. |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4280 | int resize_denom = |
| 4281 | AOMMAX(DIVIDE_AND_ROUND(owidth * SCALE_NUMERATOR, rsz->resize_width), |
| 4282 | DIVIDE_AND_ROUND(oheight * SCALE_NUMERATOR, rsz->resize_height)); |
| 4283 | |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4284 | if (resize_mode != RESIZE_RANDOM && superres_mode == SUPERRES_RANDOM) { |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4285 | // Alter superres scale as needed to enforce conformity. |
| 4286 | rsz->superres_denom = |
| 4287 | (2 * SCALE_NUMERATOR * SCALE_NUMERATOR) / resize_denom; |
| 4288 | if (!dimensions_are_ok(owidth, oheight, rsz)) { |
| 4289 | if (rsz->superres_denom > SCALE_NUMERATOR) --rsz->superres_denom; |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 4290 | } |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4291 | } else if (resize_mode == RESIZE_RANDOM && superres_mode != SUPERRES_RANDOM) { |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4292 | // Alter resize scale as needed to enforce conformity. |
| 4293 | resize_denom = |
| 4294 | (2 * SCALE_NUMERATOR * SCALE_NUMERATOR) / rsz->superres_denom; |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 4295 | rsz->resize_width = owidth; |
| 4296 | rsz->resize_height = oheight; |
| 4297 | av1_calculate_scaled_size(&rsz->resize_width, &rsz->resize_height, |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4298 | resize_denom); |
| 4299 | if (!dimensions_are_ok(owidth, oheight, rsz)) { |
| 4300 | if (resize_denom > SCALE_NUMERATOR) { |
| 4301 | --resize_denom; |
| 4302 | rsz->resize_width = owidth; |
| 4303 | rsz->resize_height = oheight; |
| 4304 | av1_calculate_scaled_size(&rsz->resize_width, &rsz->resize_height, |
| 4305 | resize_denom); |
| 4306 | } |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 4307 | } |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4308 | } else if (resize_mode == RESIZE_RANDOM && superres_mode == SUPERRES_RANDOM) { |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4309 | // Alter both resize and superres scales as needed to enforce conformity. |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4310 | do { |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4311 | if (resize_denom > rsz->superres_denom) |
| 4312 | --resize_denom; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4313 | else |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4314 | --rsz->superres_denom; |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 4315 | rsz->resize_width = owidth; |
| 4316 | rsz->resize_height = oheight; |
| 4317 | av1_calculate_scaled_size(&rsz->resize_width, &rsz->resize_height, |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4318 | resize_denom); |
| 4319 | } while (!dimensions_are_ok(owidth, oheight, rsz) && |
| 4320 | (resize_denom > SCALE_NUMERATOR || |
| 4321 | rsz->superres_denom > SCALE_NUMERATOR)); |
Urvang Joshi | f1fa686 | 2018-01-08 16:39:33 -0800 | [diff] [blame] | 4322 | } else { // We are allowed to alter neither resize scale nor superres |
| 4323 | // scale. |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4324 | return 0; |
| 4325 | } |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4326 | return dimensions_are_ok(owidth, oheight, rsz); |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4327 | } |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4328 | |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 4329 | // Calculates resize and superres params for next frame |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4330 | size_params_type av1_calculate_next_size_params(AV1_COMP *cpi) { |
| 4331 | const AV1EncoderConfig *oxcf = &cpi->oxcf; |
Debargha Mukherjee | 3a4959f | 2018-02-26 15:34:03 -0800 | [diff] [blame] | 4332 | size_params_type rsz = { oxcf->width, oxcf->height, SCALE_NUMERATOR }; |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4333 | int resize_denom; |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4334 | if (oxcf->pass == 1) return rsz; |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 4335 | if (cpi->resize_pending_width && cpi->resize_pending_height) { |
| 4336 | rsz.resize_width = cpi->resize_pending_width; |
| 4337 | rsz.resize_height = cpi->resize_pending_height; |
| 4338 | cpi->resize_pending_width = cpi->resize_pending_height = 0; |
| 4339 | } else { |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4340 | resize_denom = calculate_next_resize_scale(cpi); |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 4341 | rsz.resize_width = cpi->oxcf.width; |
| 4342 | rsz.resize_height = cpi->oxcf.height; |
| 4343 | av1_calculate_scaled_size(&rsz.resize_width, &rsz.resize_height, |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4344 | resize_denom); |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 4345 | } |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4346 | rsz.superres_denom = calculate_next_superres_scale(cpi); |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 4347 | if (!validate_size_scales(oxcf->resize_mode, oxcf->superres_mode, oxcf->width, |
| 4348 | oxcf->height, &rsz)) |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4349 | assert(0 && "Invalid scale parameters"); |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4350 | return rsz; |
| 4351 | } |
| 4352 | |
Urvang Joshi | 22b150b | 2019-01-10 14:32:32 -0800 | [diff] [blame] | 4353 | static void setup_frame_size_from_params(AV1_COMP *cpi, |
| 4354 | const size_params_type *rsz) { |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 4355 | int encode_width = rsz->resize_width; |
| 4356 | int encode_height = rsz->resize_height; |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4357 | |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4358 | AV1_COMMON *cm = &cpi->common; |
| 4359 | cm->superres_upscaled_width = encode_width; |
| 4360 | cm->superres_upscaled_height = encode_height; |
Urvang Joshi | de71d14 | 2017-10-05 12:12:15 -0700 | [diff] [blame] | 4361 | cm->superres_scale_denominator = rsz->superres_denom; |
Urvang Joshi | 69fde2e | 2017-10-09 15:34:18 -0700 | [diff] [blame] | 4362 | av1_calculate_scaled_superres_size(&encode_width, &encode_height, |
| 4363 | rsz->superres_denom); |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4364 | set_frame_size(cpi, encode_width, encode_height); |
| 4365 | } |
| 4366 | |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4367 | static void setup_frame_size(AV1_COMP *cpi) { |
Urvang Joshi | 22b150b | 2019-01-10 14:32:32 -0800 | [diff] [blame] | 4368 | // Reset superres params from previous frame. |
| 4369 | cpi->common.superres_scale_denominator = SCALE_NUMERATOR; |
| 4370 | const size_params_type rsz = av1_calculate_next_size_params(cpi); |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4371 | setup_frame_size_from_params(cpi, &rsz); |
| 4372 | } |
| 4373 | |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4374 | static void superres_post_encode(AV1_COMP *cpi) { |
| 4375 | AV1_COMMON *cm = &cpi->common; |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 4376 | const int num_planes = av1_num_planes(cm); |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4377 | |
Cheng Chen | 09c83a5 | 2018-06-05 12:27:36 -0700 | [diff] [blame] | 4378 | if (!av1_superres_scaled(cm)) return; |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4379 | |
Urvang Joshi | d6b5d51 | 2018-03-20 13:34:38 -0700 | [diff] [blame] | 4380 | assert(cpi->oxcf.enable_superres); |
| 4381 | assert(!is_lossless_requested(&cpi->oxcf)); |
Urvang Joshi | c8b52d5 | 2018-03-23 13:16:51 -0700 | [diff] [blame] | 4382 | assert(!cm->all_lossless); |
Urvang Joshi | d6b5d51 | 2018-03-20 13:34:38 -0700 | [diff] [blame] | 4383 | |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4384 | av1_superres_upscale(cm, NULL); |
| 4385 | |
| 4386 | // If regular resizing is occurring the source will need to be downscaled to |
| 4387 | // match the upscaled superres resolution. Otherwise the original source is |
| 4388 | // used. |
Cheng Chen | 09c83a5 | 2018-06-05 12:27:36 -0700 | [diff] [blame] | 4389 | if (!av1_resize_scaled(cm)) { |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4390 | cpi->source = cpi->unscaled_source; |
| 4391 | if (cpi->last_source != NULL) cpi->last_source = cpi->unscaled_last_source; |
| 4392 | } else { |
Fergus Simpson | abd4343 | 2017-06-12 15:54:43 -0700 | [diff] [blame] | 4393 | assert(cpi->unscaled_source->y_crop_width != cm->superres_upscaled_width); |
| 4394 | assert(cpi->unscaled_source->y_crop_height != cm->superres_upscaled_height); |
Urvang Joshi | f1fa686 | 2018-01-08 16:39:33 -0800 | [diff] [blame] | 4395 | // Do downscale. cm->(width|height) has been updated by |
| 4396 | // av1_superres_upscale |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4397 | if (aom_realloc_frame_buffer( |
| 4398 | &cpi->scaled_source, cm->superres_upscaled_width, |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 4399 | cm->superres_upscaled_height, cm->seq_params.subsampling_x, |
| 4400 | cm->seq_params.subsampling_y, cm->seq_params.use_highbitdepth, |
| 4401 | AOM_BORDER_IN_PIXELS, cm->byte_alignment, NULL, NULL, NULL)) |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4402 | aom_internal_error( |
| 4403 | &cm->error, AOM_CODEC_MEM_ERROR, |
| 4404 | "Failed to reallocate scaled source buffer for superres"); |
| 4405 | assert(cpi->scaled_source.y_crop_width == cm->superres_upscaled_width); |
| 4406 | assert(cpi->scaled_source.y_crop_height == cm->superres_upscaled_height); |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4407 | av1_resize_and_extend_frame(cpi->unscaled_source, &cpi->scaled_source, |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 4408 | (int)cm->seq_params.bit_depth, num_planes); |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4409 | cpi->source = &cpi->scaled_source; |
| 4410 | } |
| 4411 | } |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4412 | |
| 4413 | static void loopfilter_frame(AV1_COMP *cpi, AV1_COMMON *cm) { |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 4414 | const int num_planes = av1_num_planes(cm); |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4415 | MACROBLOCKD *xd = &cpi->td.mb.e_mbd; |
Urvang Joshi | 14072aa | 2018-03-21 17:43:36 -0700 | [diff] [blame] | 4416 | |
Urvang Joshi | c8b52d5 | 2018-03-23 13:16:51 -0700 | [diff] [blame] | 4417 | assert(IMPLIES(is_lossless_requested(&cpi->oxcf), |
| 4418 | cm->coded_lossless && cm->all_lossless)); |
| 4419 | |
| 4420 | const int no_loopfilter = cm->coded_lossless || cm->large_scale_tile; |
| 4421 | const int no_cdef = |
Debargha Mukherjee | 98a311c | 2018-03-25 16:33:11 -0700 | [diff] [blame] | 4422 | !cm->seq_params.enable_cdef || cm->coded_lossless || cm->large_scale_tile; |
| 4423 | const int no_restoration = !cm->seq_params.enable_restoration || |
| 4424 | cm->all_lossless || cm->large_scale_tile; |
Urvang Joshi | 14072aa | 2018-03-21 17:43:36 -0700 | [diff] [blame] | 4425 | |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4426 | struct loopfilter *lf = &cm->lf; |
Yunqing Wang | eeb08a9 | 2017-07-07 21:25:18 -0700 | [diff] [blame] | 4427 | |
| 4428 | if (no_loopfilter) { |
Cheng Chen | 179479f | 2017-08-04 10:56:39 -0700 | [diff] [blame] | 4429 | lf->filter_level[0] = 0; |
| 4430 | lf->filter_level[1] = 0; |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4431 | } else { |
| 4432 | struct aom_usec_timer timer; |
| 4433 | |
| 4434 | aom_clear_system_state(); |
| 4435 | |
| 4436 | aom_usec_timer_start(&timer); |
| 4437 | |
| 4438 | av1_pick_filter_level(cpi->source, cpi, cpi->sf.lpf_pick); |
| 4439 | |
| 4440 | aom_usec_timer_mark(&timer); |
| 4441 | cpi->time_pick_lpf += aom_usec_timer_elapsed(&timer); |
| 4442 | } |
| 4443 | |
Debargha Mukherjee | 2382b14 | 2018-02-26 14:31:32 -0800 | [diff] [blame] | 4444 | if (lf->filter_level[0] || lf->filter_level[1]) { |
Deepa K G | 964e72e | 2018-05-16 16:56:01 +0530 | [diff] [blame] | 4445 | if (cpi->num_workers > 1) |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 4446 | av1_loop_filter_frame_mt(&cm->cur_frame->buf, cm, xd, 0, num_planes, 0, |
Cheng Chen | e3600cd | 2018-09-21 18:45:42 -0700 | [diff] [blame] | 4447 | #if LOOP_FILTER_BITMASK |
| 4448 | 0, |
| 4449 | #endif |
Deepa K G | 964e72e | 2018-05-16 16:56:01 +0530 | [diff] [blame] | 4450 | cpi->workers, cpi->num_workers, |
| 4451 | &cpi->lf_row_sync); |
| 4452 | else |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 4453 | av1_loop_filter_frame(&cm->cur_frame->buf, cm, xd, |
Cheng Chen | 84b0993 | 2018-08-12 17:35:13 -0700 | [diff] [blame] | 4454 | #if LOOP_FILTER_BITMASK |
| 4455 | 0, |
Cheng Chen | 8ab1f44 | 2018-04-27 18:01:52 -0700 | [diff] [blame] | 4456 | #endif |
Cheng Chen | 84b0993 | 2018-08-12 17:35:13 -0700 | [diff] [blame] | 4457 | 0, num_planes, 0); |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4458 | } |
Debargha Mukherjee | e168a78 | 2017-08-31 12:30:10 -0700 | [diff] [blame] | 4459 | |
Yaowu Xu | 35ee234 | 2017-11-08 11:50:46 -0800 | [diff] [blame] | 4460 | if (!no_restoration) |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 4461 | av1_loop_restoration_save_boundary_lines(&cm->cur_frame->buf, cm, 0); |
Ola Hugosson | 1e7f2d0 | 2017-09-22 21:36:26 +0200 | [diff] [blame] | 4462 | |
Yaowu Xu | 35ee234 | 2017-11-08 11:50:46 -0800 | [diff] [blame] | 4463 | if (no_cdef) { |
David Turner | ebf96f4 | 2018-11-14 16:57:57 +0000 | [diff] [blame] | 4464 | cm->cdef_info.cdef_bits = 0; |
| 4465 | cm->cdef_info.cdef_strengths[0] = 0; |
| 4466 | cm->cdef_info.nb_cdef_strengths = 1; |
| 4467 | cm->cdef_info.cdef_uv_strengths[0] = 0; |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4468 | } else { |
Steinar Midtskogen | 5978212 | 2017-07-20 08:49:43 +0200 | [diff] [blame] | 4469 | // Find CDEF parameters |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 4470 | av1_cdef_search(&cm->cur_frame->buf, cpi->source, cm, xd, |
Debargha Mukherjee | d7338aa | 2017-11-04 07:34:50 -0700 | [diff] [blame] | 4471 | cpi->sf.fast_cdef_search); |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4472 | |
| 4473 | // Apply the filter |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 4474 | av1_cdef_frame(&cm->cur_frame->buf, cm, xd); |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4475 | } |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4476 | |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4477 | superres_post_encode(cpi); |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4478 | |
Yaowu Xu | 35ee234 | 2017-11-08 11:50:46 -0800 | [diff] [blame] | 4479 | if (no_restoration) { |
| 4480 | cm->rst_info[0].frame_restoration_type = RESTORE_NONE; |
| 4481 | cm->rst_info[1].frame_restoration_type = RESTORE_NONE; |
| 4482 | cm->rst_info[2].frame_restoration_type = RESTORE_NONE; |
| 4483 | } else { |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 4484 | av1_loop_restoration_save_boundary_lines(&cm->cur_frame->buf, cm, 1); |
Yaowu Xu | 35ee234 | 2017-11-08 11:50:46 -0800 | [diff] [blame] | 4485 | av1_pick_filter_restoration(cpi->source, cpi); |
| 4486 | if (cm->rst_info[0].frame_restoration_type != RESTORE_NONE || |
| 4487 | cm->rst_info[1].frame_restoration_type != RESTORE_NONE || |
| 4488 | cm->rst_info[2].frame_restoration_type != RESTORE_NONE) { |
Ravi Chaudhary | e2aa401 | 2018-06-04 14:20:00 +0530 | [diff] [blame] | 4489 | if (cpi->num_workers > 1) |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 4490 | av1_loop_restoration_filter_frame_mt(&cm->cur_frame->buf, cm, 0, |
Ravi Chaudhary | e2aa401 | 2018-06-04 14:20:00 +0530 | [diff] [blame] | 4491 | cpi->workers, cpi->num_workers, |
| 4492 | &cpi->lr_row_sync, &cpi->lr_ctxt); |
| 4493 | else |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 4494 | av1_loop_restoration_filter_frame(&cm->cur_frame->buf, cm, 0, |
Ravi Chaudhary | e2aa401 | 2018-06-04 14:20:00 +0530 | [diff] [blame] | 4495 | &cpi->lr_ctxt); |
Yaowu Xu | 35ee234 | 2017-11-08 11:50:46 -0800 | [diff] [blame] | 4496 | } |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 4497 | } |
Fergus Simpson | bc18993 | 2017-05-16 17:02:39 -0700 | [diff] [blame] | 4498 | } |
| 4499 | |
David Turner | 996b2c1 | 2018-12-07 15:52:30 +0000 | [diff] [blame] | 4500 | static int get_refresh_frame_flags(const AV1_COMP *const cpi) { |
| 4501 | const AV1_COMMON *const cm = &cpi->common; |
| 4502 | |
| 4503 | // Switch frames and shown key-frames overwrite all reference slots |
| 4504 | if ((cm->current_frame.frame_type == KEY_FRAME && cm->show_frame) || |
| 4505 | frame_is_sframe(cm)) |
| 4506 | return 0xFF; |
| 4507 | |
| 4508 | int refresh_mask = 0; |
| 4509 | |
| 4510 | // NOTE(zoeliu): When LAST_FRAME is to get refreshed, the decoder will be |
| 4511 | // notified to get LAST3_FRAME refreshed and then the virtual indexes for all |
| 4512 | // the 3 LAST reference frames will be updated accordingly, i.e.: |
| 4513 | // (1) The original virtual index for LAST3_FRAME will become the new virtual |
| 4514 | // index for LAST_FRAME; and |
| 4515 | // (2) The original virtual indexes for LAST_FRAME and LAST2_FRAME will be |
| 4516 | // shifted and become the new virtual indexes for LAST2_FRAME and |
| 4517 | // LAST3_FRAME. |
| 4518 | refresh_mask |= |
| 4519 | (cpi->refresh_last_frame << get_ref_frame_map_idx(cm, LAST3_FRAME)); |
| 4520 | |
| 4521 | #if USE_SYMM_MULTI_LAYER |
| 4522 | const int bwd_ref_frame = |
| 4523 | (cpi->new_bwdref_update_rule == 1) ? EXTREF_FRAME : BWDREF_FRAME; |
| 4524 | #else |
| 4525 | const int bwd_ref_frame = BWDREF_FRAME; |
| 4526 | #endif |
| 4527 | refresh_mask |= |
| 4528 | (cpi->refresh_bwd_ref_frame << get_ref_frame_map_idx(cm, bwd_ref_frame)); |
| 4529 | |
| 4530 | refresh_mask |= |
| 4531 | (cpi->refresh_alt2_ref_frame << get_ref_frame_map_idx(cm, ALTREF2_FRAME)); |
| 4532 | |
| 4533 | if (av1_preserve_existing_gf(cpi)) { |
| 4534 | // We have decided to preserve the previously existing golden frame as our |
| 4535 | // new ARF frame. However, in the short term we leave it in the GF slot and, |
| 4536 | // if we're updating the GF with the current decoded frame, we save it |
| 4537 | // instead to the ARF slot. |
| 4538 | // Later, in the function av1_encoder.c:av1_update_reference_frames() we |
| 4539 | // will swap gld_fb_idx and alt_fb_idx to achieve our objective. We do it |
| 4540 | // there so that it can be done outside of the recode loop. |
| 4541 | // Note: This is highly specific to the use of ARF as a forward reference, |
| 4542 | // and this needs to be generalized as other uses are implemented |
| 4543 | // (like RTC/temporal scalability). |
| 4544 | |
| 4545 | if (!cpi->preserve_arf_as_gld) { |
| 4546 | refresh_mask |= (cpi->refresh_golden_frame |
| 4547 | << get_ref_frame_map_idx(cm, ALTREF_FRAME)); |
| 4548 | } |
| 4549 | } else { |
| 4550 | refresh_mask |= |
| 4551 | (cpi->refresh_golden_frame << get_ref_frame_map_idx(cm, GOLDEN_FRAME)); |
| 4552 | refresh_mask |= |
| 4553 | (cpi->refresh_alt_ref_frame << get_ref_frame_map_idx(cm, ALTREF_FRAME)); |
| 4554 | } |
| 4555 | return refresh_mask; |
| 4556 | } |
| 4557 | |
David Turner | f2b334c | 2018-12-13 13:00:55 +0000 | [diff] [blame] | 4558 | static void fix_interp_filter(InterpFilter *const interp_filter, |
| 4559 | const FRAME_COUNTS *const counts) { |
| 4560 | if (*interp_filter == SWITCHABLE) { |
| 4561 | // Check to see if only one of the filters is actually used |
| 4562 | int count[SWITCHABLE_FILTERS] = { 0 }; |
| 4563 | int num_filters_used = 0; |
| 4564 | for (int i = 0; i < SWITCHABLE_FILTERS; ++i) { |
| 4565 | for (int j = 0; j < SWITCHABLE_FILTER_CONTEXTS; ++j) |
| 4566 | count[i] += counts->switchable_interp[j][i]; |
| 4567 | num_filters_used += (count[i] > 0); |
| 4568 | } |
| 4569 | if (num_filters_used == 1) { |
| 4570 | // Only one filter is used. So set the filter at frame level |
| 4571 | for (int i = 0; i < SWITCHABLE_FILTERS; ++i) { |
| 4572 | if (count[i]) { |
| 4573 | if (i == EIGHTTAP_REGULAR) *interp_filter = i; |
| 4574 | break; |
| 4575 | } |
| 4576 | } |
| 4577 | } |
| 4578 | } |
| 4579 | } |
| 4580 | |
David Turner | 996b2c1 | 2018-12-07 15:52:30 +0000 | [diff] [blame] | 4581 | static void finalize_encoded_frame(AV1_COMP *const cpi) { |
| 4582 | AV1_COMMON *const cm = &cpi->common; |
David Turner | 99e990e | 2018-12-10 12:54:26 +0000 | [diff] [blame] | 4583 | CurrentFrame *const current_frame = &cm->current_frame; |
David Turner | 996b2c1 | 2018-12-07 15:52:30 +0000 | [diff] [blame] | 4584 | |
| 4585 | // This bitfield indicates which reference frame slots will be overwritten by |
| 4586 | // the current frame |
David Turner | 99e990e | 2018-12-10 12:54:26 +0000 | [diff] [blame] | 4587 | current_frame->refresh_frame_flags = get_refresh_frame_flags(cpi); |
| 4588 | |
| 4589 | if (!encode_show_existing_frame(cm)) { |
| 4590 | // Refresh fb_of_context_type[]: see encoder.h for explanation |
| 4591 | if (current_frame->frame_type == KEY_FRAME) { |
| 4592 | // All ref frames are refreshed, pick one that will live long enough |
| 4593 | cpi->fb_of_context_type[REGULAR_FRAME] = 0; |
| 4594 | } else { |
| 4595 | // If more than one frame is refreshed, it doesn't matter which one we |
| 4596 | // pick so pick the first. LST sometimes doesn't refresh any: this is ok |
| 4597 | const int current_frame_ref_type = get_current_frame_ref_type(cpi); |
| 4598 | for (int i = 0; i < REF_FRAMES; i++) { |
| 4599 | if (current_frame->refresh_frame_flags & (1 << i)) { |
| 4600 | cpi->fb_of_context_type[current_frame_ref_type] = i; |
| 4601 | break; |
| 4602 | } |
| 4603 | } |
| 4604 | } |
| 4605 | } |
| 4606 | |
| 4607 | if (!cm->seq_params.reduced_still_picture_hdr && |
| 4608 | encode_show_existing_frame(cm)) { |
| 4609 | RefCntBuffer *const frame_to_show = |
| 4610 | cm->ref_frame_map[cpi->existing_fb_idx_to_show]; |
| 4611 | |
| 4612 | if (frame_to_show == NULL || frame_to_show->ref_count < 1) { |
| 4613 | aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, |
| 4614 | "Buffer does not contain a reconstructed frame"); |
| 4615 | } |
| 4616 | assign_frame_buffer_p(&cm->cur_frame, frame_to_show); |
| 4617 | if (cm->reset_decoder_state && frame_to_show->frame_type != KEY_FRAME) { |
| 4618 | aom_internal_error( |
| 4619 | &cm->error, AOM_CODEC_UNSUP_BITSTREAM, |
| 4620 | "show_existing_frame to reset state on KEY_FRAME only"); |
| 4621 | } |
| 4622 | } |
David Turner | 08f909c | 2018-12-18 13:29:14 +0000 | [diff] [blame] | 4623 | |
| 4624 | if (!encode_show_existing_frame(cm) && |
| 4625 | cm->seq_params.film_grain_params_present && |
| 4626 | (cm->show_frame || cm->showable_frame)) { |
| 4627 | // Copy the current frame's film grain params to the its corresponding |
| 4628 | // RefCntBuffer slot. |
| 4629 | cm->cur_frame->film_grain_params = cm->film_grain_params; |
| 4630 | |
| 4631 | // We must update the parameters if this is not an INTER_FRAME |
| 4632 | if (current_frame->frame_type != INTER_FRAME) |
| 4633 | cm->cur_frame->film_grain_params.update_parameters = 1; |
| 4634 | |
| 4635 | // Iterate the random seed for the next frame. |
| 4636 | cm->film_grain_params.random_seed += 3381; |
| 4637 | if (cm->film_grain_params.random_seed == 0) |
| 4638 | cm->film_grain_params.random_seed = 7391; |
| 4639 | } |
David Turner | f2b334c | 2018-12-13 13:00:55 +0000 | [diff] [blame] | 4640 | |
| 4641 | // Initialise all tiles' contexts from the global frame context |
| 4642 | for (int tile_col = 0; tile_col < cm->tile_cols; tile_col++) { |
| 4643 | for (int tile_row = 0; tile_row < cm->tile_rows; tile_row++) { |
| 4644 | const int tile_idx = tile_row * cm->tile_cols + tile_col; |
| 4645 | cpi->tile_data[tile_idx].tctx = *cm->fc; |
| 4646 | } |
| 4647 | } |
| 4648 | |
| 4649 | fix_interp_filter(&cm->interp_filter, cpi->td.counts); |
David Turner | 996b2c1 | 2018-12-07 15:52:30 +0000 | [diff] [blame] | 4650 | } |
| 4651 | |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 4652 | // Called after encode_with_recode_loop() has just encoded a frame and packed |
| 4653 | // its bitstream. This function works out whether we under- or over-shot |
| 4654 | // our bitrate target and adjusts q as appropriate. Also decides whether |
| 4655 | // or not we should do another recode loop, indicated by *loop |
| 4656 | static void recode_loop_update_q(AV1_COMP *const cpi, int *const loop, |
| 4657 | int *const q, int *const q_low, |
| 4658 | int *const q_high, const int top_index, |
| 4659 | const int bottom_index, |
| 4660 | int *const undershoot_seen, |
| 4661 | int *const overshoot_seen, |
| 4662 | const int loop_at_this_size) { |
| 4663 | AV1_COMMON *const cm = &cpi->common; |
| 4664 | RATE_CONTROL *const rc = &cpi->rc; |
| 4665 | |
| 4666 | int frame_over_shoot_limit = 0, frame_under_shoot_limit = 0; |
| 4667 | av1_rc_compute_frame_size_bounds(cpi, rc->this_frame_target, |
| 4668 | &frame_under_shoot_limit, |
| 4669 | &frame_over_shoot_limit); |
| 4670 | if (frame_over_shoot_limit == 0) frame_over_shoot_limit = 1; |
| 4671 | |
| 4672 | if ((cm->current_frame.frame_type == KEY_FRAME) && |
| 4673 | rc->this_key_frame_forced && |
| 4674 | (rc->projected_frame_size < rc->max_frame_bandwidth)) { |
| 4675 | int last_q = *q; |
| 4676 | int64_t kf_err; |
| 4677 | |
| 4678 | int64_t high_err_target = cpi->ambient_err; |
| 4679 | int64_t low_err_target = cpi->ambient_err >> 1; |
| 4680 | |
| 4681 | if (cm->seq_params.use_highbitdepth) { |
| 4682 | kf_err = aom_highbd_get_y_sse(cpi->source, &cm->cur_frame->buf); |
| 4683 | } else { |
| 4684 | kf_err = aom_get_y_sse(cpi->source, &cm->cur_frame->buf); |
| 4685 | } |
| 4686 | // Prevent possible divide by zero error below for perfect KF |
| 4687 | kf_err += !kf_err; |
| 4688 | |
| 4689 | // The key frame is not good enough or we can afford |
| 4690 | // to make it better without undue risk of popping. |
| 4691 | if ((kf_err > high_err_target && |
| 4692 | rc->projected_frame_size <= frame_over_shoot_limit) || |
| 4693 | (kf_err > low_err_target && |
| 4694 | rc->projected_frame_size <= frame_under_shoot_limit)) { |
| 4695 | // Lower q_high |
| 4696 | *q_high = *q > *q_low ? *q - 1 : *q_low; |
| 4697 | |
| 4698 | // Adjust Q |
| 4699 | *q = (int)((*q * high_err_target) / kf_err); |
| 4700 | *q = AOMMIN(*q, (*q_high + *q_low) >> 1); |
| 4701 | } else if (kf_err < low_err_target && |
| 4702 | rc->projected_frame_size >= frame_under_shoot_limit) { |
| 4703 | // The key frame is much better than the previous frame |
| 4704 | // Raise q_low |
| 4705 | *q_low = *q < *q_high ? *q + 1 : *q_high; |
| 4706 | |
| 4707 | // Adjust Q |
| 4708 | *q = (int)((*q * low_err_target) / kf_err); |
| 4709 | *q = AOMMIN(*q, (*q_high + *q_low + 1) >> 1); |
| 4710 | } |
| 4711 | |
| 4712 | // Clamp Q to upper and lower limits: |
| 4713 | *q = clamp(*q, *q_low, *q_high); |
| 4714 | |
| 4715 | *loop = *q != last_q; |
| 4716 | } else if (recode_loop_test(cpi, frame_over_shoot_limit, |
| 4717 | frame_under_shoot_limit, *q, |
| 4718 | AOMMAX(*q_high, top_index), bottom_index)) { |
| 4719 | // Is the projected frame size out of range and are we allowed |
| 4720 | // to attempt to recode. |
| 4721 | int last_q = *q; |
| 4722 | int retries = 0; |
| 4723 | |
| 4724 | // Frame size out of permitted range: |
| 4725 | // Update correction factor & compute new Q to try... |
| 4726 | // Frame is too large |
| 4727 | if (rc->projected_frame_size > rc->this_frame_target) { |
| 4728 | // Special case if the projected size is > the max allowed. |
| 4729 | if (rc->projected_frame_size >= rc->max_frame_bandwidth) |
| 4730 | *q_high = rc->worst_quality; |
| 4731 | |
| 4732 | // Raise Qlow as to at least the current value |
| 4733 | *q_low = *q < *q_high ? *q + 1 : *q_high; |
| 4734 | |
| 4735 | if (*undershoot_seen || loop_at_this_size > 1) { |
| 4736 | // Update rate_correction_factor unless |
| 4737 | av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height); |
| 4738 | |
| 4739 | *q = (*q_high + *q_low + 1) / 2; |
| 4740 | } else { |
| 4741 | // Update rate_correction_factor unless |
| 4742 | av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height); |
| 4743 | |
| 4744 | *q = av1_rc_regulate_q(cpi, rc->this_frame_target, bottom_index, |
| 4745 | AOMMAX(*q_high, top_index), cm->width, |
| 4746 | cm->height); |
| 4747 | |
| 4748 | while (*q < *q_low && retries < 10) { |
| 4749 | av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height); |
| 4750 | *q = av1_rc_regulate_q(cpi, rc->this_frame_target, bottom_index, |
| 4751 | AOMMAX(*q_high, top_index), cm->width, |
| 4752 | cm->height); |
| 4753 | retries++; |
| 4754 | } |
| 4755 | } |
| 4756 | |
| 4757 | *overshoot_seen = 1; |
| 4758 | } else { |
| 4759 | // Frame is too small |
| 4760 | *q_high = *q > *q_low ? *q - 1 : *q_low; |
| 4761 | |
| 4762 | if (*overshoot_seen || loop_at_this_size > 1) { |
| 4763 | av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height); |
| 4764 | *q = (*q_high + *q_low) / 2; |
| 4765 | } else { |
| 4766 | av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height); |
| 4767 | *q = av1_rc_regulate_q(cpi, rc->this_frame_target, bottom_index, |
| 4768 | top_index, cm->width, cm->height); |
| 4769 | // Special case reset for qlow for constrained quality. |
| 4770 | // This should only trigger where there is very substantial |
| 4771 | // undershoot on a frame and the auto cq level is above |
| 4772 | // the user passsed in value. |
| 4773 | if (cpi->oxcf.rc_mode == AOM_CQ && *q < *q_low) { |
| 4774 | *q_low = *q; |
| 4775 | } |
| 4776 | |
| 4777 | while (*q > *q_high && retries < 10) { |
| 4778 | av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height); |
| 4779 | *q = av1_rc_regulate_q(cpi, rc->this_frame_target, bottom_index, |
| 4780 | top_index, cm->width, cm->height); |
| 4781 | retries++; |
| 4782 | } |
| 4783 | } |
| 4784 | |
| 4785 | *undershoot_seen = 1; |
| 4786 | } |
| 4787 | |
| 4788 | // Clamp Q to upper and lower limits: |
| 4789 | *q = clamp(*q, *q_low, *q_high); |
| 4790 | |
| 4791 | *loop = (*q != last_q); |
| 4792 | } else { |
| 4793 | *loop = 0; |
| 4794 | } |
| 4795 | } |
| 4796 | |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 4797 | 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] | 4798 | AV1_COMMON *const cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4799 | RATE_CONTROL *const rc = &cpi->rc; |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 4800 | const int allow_recode = cpi->sf.recode_loop != DISALLOW_RECODE; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4801 | |
| 4802 | set_size_independent_vars(cpi); |
| 4803 | |
Yaowu Xu | 9b0f703 | 2017-07-31 11:01:19 -0700 | [diff] [blame] | 4804 | cpi->source->buf_8bit_valid = 0; |
Yaowu Xu | 9b0f703 | 2017-07-31 11:01:19 -0700 | [diff] [blame] | 4805 | |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4806 | setup_frame_size(cpi); |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 4807 | |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 4808 | int top_index = 0, bottom_index = 0; |
| 4809 | int q = 0, q_low = 0, q_high = 0; |
| 4810 | set_size_dependent_vars(cpi, &q, &bottom_index, &top_index); |
| 4811 | q_low = bottom_index; |
| 4812 | q_high = top_index; |
| 4813 | |
| 4814 | // Loop variables |
| 4815 | int loop_count = 0; |
| 4816 | int loop_at_this_size = 0; |
| 4817 | int loop = 0; |
| 4818 | int overshoot_seen = 0; |
| 4819 | int undershoot_seen = 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4820 | do { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 4821 | aom_clear_system_state(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4822 | |
Urvang Joshi | f1fa686 | 2018-01-08 16:39:33 -0800 | [diff] [blame] | 4823 | // if frame was scaled calculate global_motion_search again if already |
| 4824 | // done |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 4825 | if (loop_count > 0 && cpi->source && cpi->global_motion_search_done) { |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 4826 | if (cpi->source->y_crop_width != cm->width || |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 4827 | cpi->source->y_crop_height != cm->height) { |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 4828 | cpi->global_motion_search_done = 0; |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 4829 | } |
| 4830 | } |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 4831 | cpi->source = |
| 4832 | av1_scale_if_required(cm, cpi->unscaled_source, &cpi->scaled_source); |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 4833 | if (cpi->unscaled_last_source != NULL) { |
Debargha Mukherjee | 17e7b08 | 2017-08-13 09:33:03 -0700 | [diff] [blame] | 4834 | cpi->last_source = av1_scale_if_required(cm, cpi->unscaled_last_source, |
| 4835 | &cpi->scaled_last_source); |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 4836 | } |
Debargha Mukherjee | 17e7b08 | 2017-08-13 09:33:03 -0700 | [diff] [blame] | 4837 | |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 4838 | if (!frame_is_intra_only(cm)) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4839 | if (loop_count > 0) { |
| 4840 | release_scaled_references(cpi); |
| 4841 | } |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 4842 | scale_references(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4843 | } |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 4844 | av1_set_quantizer(cm, q); |
Debargha Mukherjee | f48b0d2 | 2018-11-20 12:23:43 -0800 | [diff] [blame] | 4845 | // printf("Frame %d/%d: q = %d, frame_type = %d superres_denom = %d\n", |
| 4846 | // cm->current_frame.frame_number, cm->show_frame, q, |
| 4847 | // cm->current_frame.frame_type, cm->superres_scale_denominator); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4848 | |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 4849 | if (loop_count == 0) { |
| 4850 | setup_frame(cpi); |
| 4851 | } else if (get_primary_ref_frame_buf(cm) == NULL) { |
| 4852 | // Base q-index may have changed, so we need to assign proper default coef |
| 4853 | // probs before every iteration. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 4854 | av1_default_coef_probs(cm); |
Hui Su | 3694c83 | 2017-11-10 14:15:58 -0800 | [diff] [blame] | 4855 | av1_setup_frame_contexts(cm); |
David Barker | fc91b39 | 2018-03-09 15:32:03 +0000 | [diff] [blame] | 4856 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4857 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4858 | if (cpi->oxcf.aq_mode == VARIANCE_AQ) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 4859 | av1_vaq_frame_setup(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4860 | } else if (cpi->oxcf.aq_mode == COMPLEXITY_AQ) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 4861 | av1_setup_in_frame_q_adj(cpi); |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 4862 | } else if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && !allow_recode) { |
| 4863 | suppress_active_map(cpi); |
| 4864 | av1_cyclic_refresh_setup(cpi); |
| 4865 | apply_active_map(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4866 | } |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 4867 | |
Rostislav Pehlivanov | 3a96462 | 2018-03-14 18:00:32 +0000 | [diff] [blame] | 4868 | if (cm->seg.enabled) { |
David Barker | cab3755 | 2018-03-21 11:56:24 +0000 | [diff] [blame] | 4869 | if (!cm->seg.update_data && cm->prev_frame) { |
Rostislav Pehlivanov | 3a96462 | 2018-03-14 18:00:32 +0000 | [diff] [blame] | 4870 | segfeatures_copy(&cm->seg, &cm->prev_frame->seg); |
David Barker | 11c9356 | 2018-06-05 12:00:07 +0100 | [diff] [blame] | 4871 | } else { |
| 4872 | calculate_segdata(&cm->seg); |
Yue Chen | d90d343 | 2018-03-16 11:28:42 -0700 | [diff] [blame] | 4873 | } |
David Barker | cab3755 | 2018-03-21 11:56:24 +0000 | [diff] [blame] | 4874 | } else { |
| 4875 | memset(&cm->seg, 0, sizeof(cm->seg)); |
Rostislav Pehlivanov | 3a96462 | 2018-03-14 18:00:32 +0000 | [diff] [blame] | 4876 | } |
David Barker | cab3755 | 2018-03-21 11:56:24 +0000 | [diff] [blame] | 4877 | segfeatures_copy(&cm->cur_frame->seg, &cm->seg); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4878 | |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 4879 | if (allow_recode) save_coding_context(cpi); |
| 4880 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4881 | // transform / motion compensation build reconstruction frame |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 4882 | av1_encode_frame(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4883 | |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 4884 | // Update some stats from cyclic refresh, and check if we should not update |
| 4885 | // golden reference, for 1 pass CBR. |
| 4886 | if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && |
| 4887 | cm->current_frame.frame_type != KEY_FRAME && |
| 4888 | (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == AOM_CBR)) { |
| 4889 | av1_cyclic_refresh_check_golden_update(cpi); |
| 4890 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4891 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 4892 | aom_clear_system_state(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4893 | |
| 4894 | // Dummy pack of the bitstream using up to date stats to get an |
| 4895 | // accurate estimate of output frame size to determine if we need |
| 4896 | // to recode. |
| 4897 | if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF) { |
Jingning Han | 8f66160 | 2017-08-19 08:16:50 -0700 | [diff] [blame] | 4898 | restore_coding_context(cpi); |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 4899 | |
David Turner | 996b2c1 | 2018-12-07 15:52:30 +0000 | [diff] [blame] | 4900 | finalize_encoded_frame(cpi); |
David Turner | 35cba13 | 2018-12-10 15:48:15 +0000 | [diff] [blame] | 4901 | int largest_tile_id = 0; // Output from bitstream: unused here |
| 4902 | 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] | 4903 | return AOM_CODEC_ERROR; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4904 | |
| 4905 | rc->projected_frame_size = (int)(*size) << 3; |
| 4906 | restore_coding_context(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4907 | } |
| 4908 | |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 4909 | if (allow_recode && cpi->oxcf.rc_mode != AOM_Q) { |
| 4910 | // Update q and decide whether to do a recode loop |
| 4911 | recode_loop_update_q(cpi, &loop, &q, &q_low, &q_high, top_index, |
| 4912 | bottom_index, &undershoot_seen, &overshoot_seen, |
| 4913 | loop_at_this_size); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4914 | } |
| 4915 | |
| 4916 | // Special case for overlay frame. |
| 4917 | if (rc->is_src_frame_alt_ref && |
| 4918 | rc->projected_frame_size < rc->max_frame_bandwidth) |
| 4919 | loop = 0; |
| 4920 | |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 4921 | if (allow_recode && !cpi->sf.gm_disable_recode && |
| 4922 | recode_loop_test_global_motion(cpi)) { |
| 4923 | loop = 1; |
Debargha Mukherjee | b98a702 | 2016-11-15 16:07:12 -0800 | [diff] [blame] | 4924 | } |
Debargha Mukherjee | b98a702 | 2016-11-15 16:07:12 -0800 | [diff] [blame] | 4925 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4926 | if (loop) { |
| 4927 | ++loop_count; |
| 4928 | ++loop_at_this_size; |
| 4929 | |
| 4930 | #if CONFIG_INTERNAL_STATS |
| 4931 | ++cpi->tot_recode_hits; |
| 4932 | #endif |
| 4933 | } |
| 4934 | } while (loop); |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 4935 | |
| 4936 | return AOM_CODEC_OK; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4937 | } |
| 4938 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4939 | #define DUMP_RECON_FRAMES 0 |
| 4940 | |
| 4941 | #if DUMP_RECON_FRAMES == 1 |
| 4942 | // NOTE(zoeliu): For debug - Output the filtered reconstructed video. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 4943 | static void dump_filtered_recon_frames(AV1_COMP *cpi) { |
| 4944 | AV1_COMMON *const cm = &cpi->common; |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 4945 | const CurrentFrame *const current_frame = &cm->current_frame; |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 4946 | const YV12_BUFFER_CONFIG *recon_buf = &cm->cur_frame->buf; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4947 | |
Zoe Liu | b4f3103 | 2017-11-03 23:48:35 -0700 | [diff] [blame] | 4948 | if (recon_buf == NULL) { |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 4949 | printf("Frame %d is not ready.\n", current_frame->frame_number); |
Zoe Liu | b4f3103 | 2017-11-03 23:48:35 -0700 | [diff] [blame] | 4950 | return; |
| 4951 | } |
| 4952 | |
Zoe Liu | 27deb38 | 2018-03-27 15:13:56 -0700 | [diff] [blame] | 4953 | static const int flag_list[REF_FRAMES] = { 0, |
| 4954 | AOM_LAST_FLAG, |
| 4955 | AOM_LAST2_FLAG, |
| 4956 | AOM_LAST3_FLAG, |
| 4957 | AOM_GOLD_FLAG, |
| 4958 | AOM_BWD_FLAG, |
| 4959 | AOM_ALT2_FLAG, |
| 4960 | AOM_ALT_FLAG }; |
Zoe Liu | b4f3103 | 2017-11-03 23:48:35 -0700 | [diff] [blame] | 4961 | printf( |
| 4962 | "\n***Frame=%d (frame_offset=%d, show_frame=%d, " |
| 4963 | "show_existing_frame=%d) " |
| 4964 | "[LAST LAST2 LAST3 GOLDEN BWD ALT2 ALT]=[", |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 4965 | current_frame->frame_number, current_frame->order_hint, cm->show_frame, |
Zoe Liu | b4f3103 | 2017-11-03 23:48:35 -0700 | [diff] [blame] | 4966 | cm->show_existing_frame); |
| 4967 | for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 4968 | const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame); |
| 4969 | const int ref_offset = buf != NULL ? (int)buf->order_hint : -1; |
David Turner | 1bcefb3 | 2018-11-19 17:54:00 +0000 | [diff] [blame] | 4970 | printf(" %d(%c-%d-%4.2f)", ref_offset, |
| 4971 | (cpi->ref_frame_flags & flag_list[ref_frame]) ? 'Y' : 'N', |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 4972 | buf ? (int)buf->frame_rf_level : -1, |
| 4973 | buf ? rate_factor_deltas[buf->frame_rf_level] : -1); |
Zoe Liu | b4f3103 | 2017-11-03 23:48:35 -0700 | [diff] [blame] | 4974 | } |
| 4975 | printf(" ]\n"); |
Zoe Liu | b4f3103 | 2017-11-03 23:48:35 -0700 | [diff] [blame] | 4976 | |
| 4977 | if (!cm->show_frame) { |
| 4978 | printf("Frame %d is a no show frame, so no image dump.\n", |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 4979 | current_frame->frame_number); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4980 | return; |
| 4981 | } |
| 4982 | |
Zoe Liu | b4f3103 | 2017-11-03 23:48:35 -0700 | [diff] [blame] | 4983 | int h; |
| 4984 | char file_name[256] = "/tmp/enc_filtered_recon.yuv"; |
| 4985 | FILE *f_recon = NULL; |
| 4986 | |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 4987 | if (current_frame->frame_number == 0) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 4988 | if ((f_recon = fopen(file_name, "wb")) == NULL) { |
| 4989 | printf("Unable to open file %s to write.\n", file_name); |
| 4990 | return; |
| 4991 | } |
| 4992 | } else { |
| 4993 | if ((f_recon = fopen(file_name, "ab")) == NULL) { |
| 4994 | printf("Unable to open file %s to append.\n", file_name); |
| 4995 | return; |
| 4996 | } |
| 4997 | } |
| 4998 | printf( |
Zoe Liu | f40a957 | 2017-10-13 12:37:19 -0700 | [diff] [blame] | 4999 | "\nFrame=%5d, encode_update_type[%5d]=%1d, frame_offset=%d, " |
| 5000 | "show_frame=%d, show_existing_frame=%d, source_alt_ref_active=%d, " |
| 5001 | "refresh_alt_ref_frame=%d, rf_level=%d, " |
| 5002 | "y_stride=%4d, uv_stride=%4d, cm->width=%4d, cm->height=%4d\n\n", |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 5003 | current_frame->frame_number, cpi->twopass.gf_group.index, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5004 | cpi->twopass.gf_group.update_type[cpi->twopass.gf_group.index], |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 5005 | current_frame->order_hint, cm->show_frame, cm->show_existing_frame, |
Zoe Liu | f40a957 | 2017-10-13 12:37:19 -0700 | [diff] [blame] | 5006 | cpi->rc.source_alt_ref_active, cpi->refresh_alt_ref_frame, |
| 5007 | cpi->twopass.gf_group.rf_level[cpi->twopass.gf_group.index], |
| 5008 | recon_buf->y_stride, recon_buf->uv_stride, cm->width, cm->height); |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 5009 | #if 0 |
| 5010 | int ref_frame; |
| 5011 | printf("get_ref_frame_map_idx: ["); |
| 5012 | for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 5013 | printf(" %d", get_ref_frame_map_idx(cm, ref_frame)); |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 5014 | printf(" ]\n"); |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 5015 | #endif // 0 |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5016 | |
| 5017 | // --- Y --- |
| 5018 | for (h = 0; h < cm->height; ++h) { |
| 5019 | fwrite(&recon_buf->y_buffer[h * recon_buf->y_stride], 1, cm->width, |
| 5020 | f_recon); |
| 5021 | } |
| 5022 | // --- U --- |
| 5023 | for (h = 0; h < (cm->height >> 1); ++h) { |
| 5024 | fwrite(&recon_buf->u_buffer[h * recon_buf->uv_stride], 1, (cm->width >> 1), |
| 5025 | f_recon); |
| 5026 | } |
| 5027 | // --- V --- |
| 5028 | for (h = 0; h < (cm->height >> 1); ++h) { |
| 5029 | fwrite(&recon_buf->v_buffer[h * recon_buf->uv_stride], 1, (cm->width >> 1), |
| 5030 | f_recon); |
| 5031 | } |
| 5032 | |
| 5033 | fclose(f_recon); |
| 5034 | } |
| 5035 | #endif // DUMP_RECON_FRAMES |
| 5036 | |
Wei-Ting Lin | fb7dc06 | 2018-06-28 18:26:13 -0700 | [diff] [blame] | 5037 | static INLINE int is_frame_droppable(AV1_COMP *cpi) { |
| 5038 | return !(cpi->refresh_alt_ref_frame || cpi->refresh_alt2_ref_frame || |
| 5039 | cpi->refresh_bwd_ref_frame || cpi->refresh_golden_frame || |
| 5040 | cpi->refresh_last_frame); |
| 5041 | } |
| 5042 | |
Sachin Kumar Garg | fd39b23 | 2019-01-03 17:41:09 +0530 | [diff] [blame] | 5043 | static int setup_interp_filter_search_mask(AV1_COMP *cpi) { |
| 5044 | InterpFilters ifilter; |
| 5045 | int ref_total[REF_FRAMES] = { 0 }; |
| 5046 | MV_REFERENCE_FRAME ref; |
| 5047 | int mask = 0; |
| 5048 | int arf_idx = ALTREF_FRAME; |
| 5049 | if (cpi->common.last_frame_type == KEY_FRAME || cpi->refresh_alt_ref_frame) |
| 5050 | return mask; |
| 5051 | for (ref = LAST_FRAME; ref <= ALTREF_FRAME; ++ref) |
| 5052 | for (ifilter = EIGHTTAP_REGULAR; ifilter <= MULTITAP_SHARP; ++ifilter) |
| 5053 | ref_total[ref] += cpi->interp_filter_selected[ref][ifilter]; |
| 5054 | |
| 5055 | for (ifilter = EIGHTTAP_REGULAR; ifilter <= MULTITAP_SHARP; ++ifilter) { |
| 5056 | if ((ref_total[LAST_FRAME] && |
| 5057 | cpi->interp_filter_selected[LAST_FRAME][ifilter] * 30 <= |
| 5058 | ref_total[LAST_FRAME]) && |
| 5059 | (((cpi->interp_filter_selected[LAST2_FRAME][ifilter] * 20) + |
| 5060 | (cpi->interp_filter_selected[LAST3_FRAME][ifilter] * 20) + |
| 5061 | (cpi->interp_filter_selected[GOLDEN_FRAME][ifilter] * 20) + |
| 5062 | (cpi->interp_filter_selected[BWDREF_FRAME][ifilter] * 10) + |
| 5063 | (cpi->interp_filter_selected[ALTREF2_FRAME][ifilter] * 10) + |
| 5064 | (cpi->interp_filter_selected[arf_idx][ifilter] * 10)) < |
| 5065 | (ref_total[LAST2_FRAME] + ref_total[LAST3_FRAME] + |
| 5066 | ref_total[GOLDEN_FRAME] + ref_total[BWDREF_FRAME] + |
| 5067 | ref_total[ALTREF2_FRAME] + ref_total[ALTREF_FRAME]))) |
| 5068 | mask |= 1 << ifilter; |
| 5069 | } |
| 5070 | return mask; |
| 5071 | } |
| 5072 | |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 5073 | static int encode_frame_to_data_rate(AV1_COMP *cpi, size_t *size, uint8_t *dest, |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 5074 | unsigned int *frame_flags) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5075 | AV1_COMMON *const cm = &cpi->common; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 5076 | SequenceHeader *const seq_params = &cm->seq_params; |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 5077 | CurrentFrame *const current_frame = &cm->current_frame; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5078 | const AV1EncoderConfig *const oxcf = &cpi->oxcf; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5079 | struct segmentation *const seg = &cm->seg; |
Thomas Davies | 4822e14 | 2017-10-10 11:30:36 +0100 | [diff] [blame] | 5080 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5081 | aom_clear_system_state(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5082 | |
Fangwen Fu | 8d164de | 2016-12-14 13:40:54 -0800 | [diff] [blame] | 5083 | // frame type has been decided outside of this function call |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 5084 | cm->cur_frame->frame_type = current_frame->frame_type; |
Debargha Mukherjee | 07a7c1f | 2018-03-21 17:39:13 -0700 | [diff] [blame] | 5085 | |
Yunqing Wang | 9612d55 | 2018-05-15 14:58:30 -0700 | [diff] [blame] | 5086 | cm->large_scale_tile = cpi->oxcf.large_scale_tile; |
| 5087 | cm->single_tile_decoding = cpi->oxcf.single_tile_decoding; |
Yunqing Wang | 9612d55 | 2018-05-15 14:58:30 -0700 | [diff] [blame] | 5088 | |
sarahparker | 21dbca4 | 2018-03-30 17:43:44 -0700 | [diff] [blame] | 5089 | cm->allow_ref_frame_mvs &= frame_might_allow_ref_frame_mvs(cm); |
Yunqing Wang | d48fb16 | 2018-06-15 10:55:28 -0700 | [diff] [blame] | 5090 | // cm->allow_ref_frame_mvs needs to be written into the frame header while |
| 5091 | // cm->large_scale_tile is 1, therefore, "cm->large_scale_tile=1" case is |
| 5092 | // separated from frame_might_allow_ref_frame_mvs(). |
| 5093 | cm->allow_ref_frame_mvs &= !cm->large_scale_tile; |
| 5094 | |
Debargha Mukherjee | 1d7217e | 2018-03-26 13:32:13 -0700 | [diff] [blame] | 5095 | cm->allow_warped_motion = |
Debargha Mukherjee | a5b810a | 2018-03-26 19:19:55 -0700 | [diff] [blame] | 5096 | cpi->oxcf.allow_warped_motion && frame_might_allow_warped_motion(cm); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5097 | |
Jingning Han | d8a15a6 | 2017-10-30 10:53:42 -0700 | [diff] [blame] | 5098 | // Reset the frame packet stamp index. |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 5099 | if (current_frame->frame_type == KEY_FRAME && cm->show_frame) |
| 5100 | current_frame->frame_number = 0; |
Jingning Han | d8a15a6 | 2017-10-30 10:53:42 -0700 | [diff] [blame] | 5101 | |
Sachin Kumar Garg | fd39b23 | 2019-01-03 17:41:09 +0530 | [diff] [blame] | 5102 | cm->last_frame_type = current_frame->frame_type; |
| 5103 | if (cpi->oxcf.pass == 2 && cpi->sf.adaptive_interp_filter_search) |
| 5104 | cpi->sf.interp_filter_search_mask = setup_interp_filter_search_mask(cpi); |
| 5105 | |
Sarah Parker | 3300552 | 2018-07-27 14:46:25 -0700 | [diff] [blame] | 5106 | if (encode_show_existing_frame(cm)) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5107 | // NOTE(zoeliu): In BIDIR_PRED, the existing frame to show is the current |
| 5108 | // BWDREF_FRAME in the reference frame buffer. |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 5109 | if (current_frame->frame_type == KEY_FRAME) { |
Sarah Parker | b904161 | 2018-05-22 19:06:47 -0700 | [diff] [blame] | 5110 | cm->reset_decoder_state = 1; |
| 5111 | } else { |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 5112 | current_frame->frame_type = INTER_FRAME; |
Sarah Parker | b904161 | 2018-05-22 19:06:47 -0700 | [diff] [blame] | 5113 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5114 | cm->show_frame = 1; |
| 5115 | cpi->frame_flags = *frame_flags; |
| 5116 | |
Jingning Han | 8f66160 | 2017-08-19 08:16:50 -0700 | [diff] [blame] | 5117 | restore_coding_context(cpi); |
Zoe Liu | b4f3103 | 2017-11-03 23:48:35 -0700 | [diff] [blame] | 5118 | |
David Turner | 996b2c1 | 2018-12-07 15:52:30 +0000 | [diff] [blame] | 5119 | finalize_encoded_frame(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5120 | // Build the bitstream |
David Turner | 35cba13 | 2018-12-10 15:48:15 +0000 | [diff] [blame] | 5121 | int largest_tile_id = 0; // Output from bitstream: unused here |
| 5122 | 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] | 5123 | return AOM_CODEC_ERROR; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5124 | |
David Turner | 9031186 | 2018-11-29 13:34:36 +0000 | [diff] [blame] | 5125 | if (seq_params->frame_id_numbers_present_flag && |
| 5126 | current_frame->frame_type == KEY_FRAME) { |
| 5127 | // Displaying a forward key-frame, so reset the ref buffer IDs |
| 5128 | int display_frame_id = cm->ref_frame_id[cpi->existing_fb_idx_to_show]; |
| 5129 | for (int i = 0; i < REF_FRAMES; i++) |
| 5130 | cm->ref_frame_id[i] = display_frame_id; |
| 5131 | } |
| 5132 | |
Debargha Mukherjee | f2e5bb3 | 2018-03-26 14:35:24 -0700 | [diff] [blame] | 5133 | cpi->seq_params_locked = 1; |
| 5134 | |
Zoe Liu | b4f3103 | 2017-11-03 23:48:35 -0700 | [diff] [blame] | 5135 | // Update current frame offset. |
Jack Haughton | ddb8060 | 2018-11-21 16:41:49 +0000 | [diff] [blame] | 5136 | current_frame->order_hint = cm->cur_frame->order_hint; |
Zoe Liu | b4f3103 | 2017-11-03 23:48:35 -0700 | [diff] [blame] | 5137 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5138 | #if DUMP_RECON_FRAMES == 1 |
| 5139 | // NOTE(zoeliu): For debug - Output the filtered reconstructed video. |
| 5140 | dump_filtered_recon_frames(cpi); |
| 5141 | #endif // DUMP_RECON_FRAMES |
| 5142 | |
| 5143 | // Update the LAST_FRAME in the reference frame buffer. |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 5144 | // NOTE: |
| 5145 | // (1) For BWDREF_FRAME as the show_existing_frame, the reference frame |
| 5146 | // update has been done previously when handling the LAST_BIPRED_FRAME |
| 5147 | // right before BWDREF_FRAME (in the display order); |
| 5148 | // (2) For INTNL_OVERLAY as the show_existing_frame, the reference frame |
Urvang Joshi | f1fa686 | 2018-01-08 16:39:33 -0800 | [diff] [blame] | 5149 | // update will be done when the following is called, which will |
| 5150 | // exchange |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 5151 | // the virtual indexes between LAST_FRAME and ALTREF2_FRAME, so that |
Urvang Joshi | f1fa686 | 2018-01-08 16:39:33 -0800 | [diff] [blame] | 5152 | // LAST3 will get retired, LAST2 becomes LAST3, LAST becomes LAST2, |
| 5153 | // and |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 5154 | // ALTREF2_FRAME will serve as the new LAST_FRAME. |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 5155 | update_reference_frames(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5156 | |
| 5157 | // Update frame flags |
| 5158 | cpi->frame_flags &= ~FRAMEFLAGS_GOLDEN; |
| 5159 | cpi->frame_flags &= ~FRAMEFLAGS_BWDREF; |
| 5160 | cpi->frame_flags &= ~FRAMEFLAGS_ALTREF; |
| 5161 | |
| 5162 | *frame_flags = cpi->frame_flags & ~FRAMEFLAGS_KEY; |
| 5163 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5164 | // Since we allocate a spot for the OVERLAY frame in the gf group, we need |
| 5165 | // to do post-encoding update accordingly. |
| 5166 | if (cpi->rc.is_src_frame_alt_ref) { |
Debargha Mukherjee | 7166f22 | 2017-09-05 21:32:42 -0700 | [diff] [blame] | 5167 | av1_set_target_rate(cpi, cm->width, cm->height); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5168 | av1_rc_postencode_update(cpi, *size); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5169 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5170 | |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 5171 | ++current_frame->frame_number; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5172 | |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 5173 | return AOM_CODEC_OK; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5174 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5175 | |
| 5176 | // Set default state for segment based loop filter update flags. |
| 5177 | cm->lf.mode_ref_delta_update = 0; |
| 5178 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5179 | // 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] | 5180 | if (frame_is_intra_only(cm) || frame_is_sframe(cm)) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5181 | // Reset the loop filter deltas and segmentation map. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5182 | av1_reset_segment_features(cm); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5183 | |
| 5184 | // If segmentation is enabled force a map update for key frames. |
| 5185 | if (seg->enabled) { |
| 5186 | seg->update_map = 1; |
| 5187 | seg->update_data = 1; |
| 5188 | } |
| 5189 | |
| 5190 | // The alternate reference frame cannot be active for a key frame. |
| 5191 | cpi->rc.source_alt_ref_active = 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5192 | } |
Thomas Davies | af6df17 | 2016-11-09 14:04:18 +0000 | [diff] [blame] | 5193 | if (cpi->oxcf.mtu == 0) { |
| 5194 | cm->num_tg = cpi->oxcf.num_tile_groups; |
| 5195 | } else { |
Yaowu Xu | 859a527 | 2016-11-10 15:32:21 -0800 | [diff] [blame] | 5196 | // Use a default value for the purposes of weighting costs in probability |
| 5197 | // updates |
Thomas Davies | af6df17 | 2016-11-09 14:04:18 +0000 | [diff] [blame] | 5198 | cm->num_tg = DEFAULT_MAX_NUM_TG; |
| 5199 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5200 | |
| 5201 | // For 1 pass CBR, check if we are dropping this frame. |
| 5202 | // Never drop on key frame. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5203 | if (oxcf->pass == 0 && oxcf->rc_mode == AOM_CBR && |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 5204 | current_frame->frame_type != KEY_FRAME) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5205 | if (av1_rc_drop_frame(cpi)) { |
| 5206 | av1_rc_postencode_update_drop_frame(cpi); |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 5207 | return AOM_CODEC_OK; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5208 | } |
| 5209 | } |
| 5210 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5211 | aom_clear_system_state(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5212 | |
| 5213 | #if CONFIG_INTERNAL_STATS |
| 5214 | memset(cpi->mode_chosen_counts, 0, |
| 5215 | MAX_MODES * sizeof(*cpi->mode_chosen_counts)); |
| 5216 | #endif |
| 5217 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 5218 | if (seq_params->frame_id_numbers_present_flag) { |
Arild Fuldseth (arilfuld) | 5114b7b | 2016-11-09 13:32:54 +0100 | [diff] [blame] | 5219 | /* Non-normative definition of current_frame_id ("frame counter" with |
Johann | 123e8a6 | 2017-12-28 14:40:49 -0800 | [diff] [blame] | 5220 | * wraparound) */ |
Arild Fuldseth (arilfuld) | 5114b7b | 2016-11-09 13:32:54 +0100 | [diff] [blame] | 5221 | if (cm->current_frame_id == -1) { |
David Barker | 49a7656 | 2016-12-07 14:50:21 +0000 | [diff] [blame] | 5222 | int lsb, msb; |
Yaowu Xu | d3e7c68 | 2017-12-21 14:08:25 -0800 | [diff] [blame] | 5223 | /* quasi-random initialization of current_frame_id for a key frame */ |
Alex Converse | f77fd0b | 2017-04-20 11:00:24 -0700 | [diff] [blame] | 5224 | if (cpi->source->flags & YV12_FLAG_HIGHBITDEPTH) { |
| 5225 | lsb = CONVERT_TO_SHORTPTR(cpi->source->y_buffer)[0] & 0xff; |
| 5226 | msb = CONVERT_TO_SHORTPTR(cpi->source->y_buffer)[1] & 0xff; |
David Barker | 49a7656 | 2016-12-07 14:50:21 +0000 | [diff] [blame] | 5227 | } else { |
Alex Converse | f77fd0b | 2017-04-20 11:00:24 -0700 | [diff] [blame] | 5228 | lsb = cpi->source->y_buffer[0] & 0xff; |
| 5229 | msb = cpi->source->y_buffer[1] & 0xff; |
David Barker | 49a7656 | 2016-12-07 14:50:21 +0000 | [diff] [blame] | 5230 | } |
David Turner | 760a2f4 | 2018-12-07 15:25:36 +0000 | [diff] [blame] | 5231 | cm->current_frame_id = |
| 5232 | ((msb << 8) + lsb) % (1 << seq_params->frame_id_length); |
Tarek AMARA | c981385 | 2018-03-05 18:40:18 -0500 | [diff] [blame] | 5233 | |
| 5234 | // S_frame is meant for stitching different streams of different |
| 5235 | // resolutions together, so current_frame_id must be the |
| 5236 | // same across different streams of the same content current_frame_id |
| 5237 | // should be the same and not random. 0x37 is a chosen number as start |
| 5238 | // point |
| 5239 | if (cpi->oxcf.sframe_enabled) cm->current_frame_id = 0x37; |
Arild Fuldseth (arilfuld) | 5114b7b | 2016-11-09 13:32:54 +0100 | [diff] [blame] | 5240 | } else { |
| 5241 | cm->current_frame_id = |
David Turner | 760a2f4 | 2018-12-07 15:25:36 +0000 | [diff] [blame] | 5242 | (cm->current_frame_id + 1 + (1 << seq_params->frame_id_length)) % |
| 5243 | (1 << seq_params->frame_id_length); |
Arild Fuldseth (arilfuld) | 5114b7b | 2016-11-09 13:32:54 +0100 | [diff] [blame] | 5244 | } |
| 5245 | } |
Arild Fuldseth (arilfuld) | 5114b7b | 2016-11-09 13:32:54 +0100 | [diff] [blame] | 5246 | |
Hui Su | 483a845 | 2018-02-26 12:28:48 -0800 | [diff] [blame] | 5247 | switch (cpi->oxcf.cdf_update_mode) { |
| 5248 | case 0: // No CDF update for any frames(4~6% compression loss). |
| 5249 | cm->disable_cdf_update = 1; |
| 5250 | break; |
| 5251 | case 1: // Enable CDF update for all frames. |
| 5252 | cm->disable_cdf_update = 0; |
| 5253 | break; |
| 5254 | case 2: |
| 5255 | // Strategically determine at which frames to do CDF update. |
| 5256 | // Currently only enable CDF update for all-intra and no-show frames(1.5% |
| 5257 | // compression loss). |
| 5258 | // TODO(huisu@google.com): design schemes for various trade-offs between |
| 5259 | // compression quality and decoding speed. |
Hui Su | b1b76b3 | 2018-02-27 15:24:48 -0800 | [diff] [blame] | 5260 | cm->disable_cdf_update = |
| 5261 | (frame_is_intra_only(cm) || !cm->show_frame) ? 0 : 1; |
Hui Su | 483a845 | 2018-02-26 12:28:48 -0800 | [diff] [blame] | 5262 | break; |
| 5263 | } |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 5264 | cm->timing_info_present &= !seq_params->reduced_still_picture_hdr; |
Hui Su | 483a845 | 2018-02-26 12:28:48 -0800 | [diff] [blame] | 5265 | |
David Turner | 2f3b5df | 2019-01-02 14:30:50 +0000 | [diff] [blame] | 5266 | if (encode_with_recode_loop(cpi, size, dest) != AOM_CODEC_OK) |
| 5267 | return AOM_CODEC_ERROR; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5268 | |
| 5269 | #ifdef OUTPUT_YUV_SKINMAP |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 5270 | if (cpi->common.current_frame.frame_number > 1) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5271 | av1_compute_skin_map(cpi, yuv_skinmap_file); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5272 | } |
| 5273 | #endif // OUTPUT_YUV_SKINMAP |
| 5274 | |
| 5275 | // Special case code to reduce pulsing when key frames are forced at a |
| 5276 | // fixed interval. Note the reconstruction error if it is the frame before |
| 5277 | // the force key frame |
| 5278 | if (cpi->rc.next_key_frame_forced && cpi->rc.frames_to_key == 1) { |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 5279 | if (seq_params->use_highbitdepth) { |
Jack Haughton | ddb8060 | 2018-11-21 16:41:49 +0000 | [diff] [blame] | 5280 | cpi->ambient_err = aom_highbd_get_y_sse(cpi->source, &cm->cur_frame->buf); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5281 | } else { |
Jack Haughton | ddb8060 | 2018-11-21 16:41:49 +0000 | [diff] [blame] | 5282 | cpi->ambient_err = aom_get_y_sse(cpi->source, &cm->cur_frame->buf); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5283 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5284 | } |
| 5285 | |
Tarek AMARA | c981385 | 2018-03-05 18:40:18 -0500 | [diff] [blame] | 5286 | // If the encoder forced a KEY_FRAME decision or if frame is an S_FRAME |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 5287 | if ((current_frame->frame_type == KEY_FRAME && cm->show_frame) || |
| 5288 | frame_is_sframe(cm)) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5289 | cpi->refresh_last_frame = 1; |
| 5290 | } |
| 5291 | |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 5292 | cm->cur_frame->buf.color_primaries = seq_params->color_primaries; |
| 5293 | cm->cur_frame->buf.transfer_characteristics = |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 5294 | seq_params->transfer_characteristics; |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 5295 | cm->cur_frame->buf.matrix_coefficients = seq_params->matrix_coefficients; |
| 5296 | cm->cur_frame->buf.monochrome = seq_params->monochrome; |
| 5297 | cm->cur_frame->buf.chroma_sample_position = |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 5298 | seq_params->chroma_sample_position; |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 5299 | cm->cur_frame->buf.color_range = seq_params->color_range; |
| 5300 | cm->cur_frame->buf.render_width = cm->render_width; |
| 5301 | cm->cur_frame->buf.render_height = cm->render_height; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5302 | |
Sebastien Alaiwan | 365e644 | 2017-10-16 11:35:00 +0200 | [diff] [blame] | 5303 | // TODO(zoeliu): For non-ref frames, loop filtering may need to be turned |
| 5304 | // off. |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5305 | |
| 5306 | // Pick the loop filter level for the frame. |
Cheng Chen | 68dc914 | 2018-05-02 17:46:28 -0700 | [diff] [blame] | 5307 | if (!cm->allow_intrabc) { |
David Barker | 218556e | 2018-02-14 14:23:12 +0000 | [diff] [blame] | 5308 | loopfilter_frame(cpi, cm); |
Hui Su | 06463e4 | 2018-02-23 22:17:36 -0800 | [diff] [blame] | 5309 | } else { |
Hui Su | 06463e4 | 2018-02-23 22:17:36 -0800 | [diff] [blame] | 5310 | cm->lf.filter_level[0] = 0; |
| 5311 | cm->lf.filter_level[1] = 0; |
David Turner | ebf96f4 | 2018-11-14 16:57:57 +0000 | [diff] [blame] | 5312 | cm->cdef_info.cdef_bits = 0; |
| 5313 | cm->cdef_info.cdef_strengths[0] = 0; |
| 5314 | cm->cdef_info.nb_cdef_strengths = 1; |
| 5315 | cm->cdef_info.cdef_uv_strengths[0] = 0; |
Hui Su | 06463e4 | 2018-02-23 22:17:36 -0800 | [diff] [blame] | 5316 | cm->rst_info[0].frame_restoration_type = RESTORE_NONE; |
| 5317 | cm->rst_info[1].frame_restoration_type = RESTORE_NONE; |
| 5318 | cm->rst_info[2].frame_restoration_type = RESTORE_NONE; |
Hui Su | 06463e4 | 2018-02-23 22:17:36 -0800 | [diff] [blame] | 5319 | } |
David Barker | 218556e | 2018-02-14 14:23:12 +0000 | [diff] [blame] | 5320 | |
| 5321 | // TODO(debargha): Fix mv search range on encoder side |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 5322 | // aom_extend_frame_inner_borders(&cm->cur_frame->buf, av1_num_planes(cm)); |
| 5323 | aom_extend_frame_borders(&cm->cur_frame->buf, av1_num_planes(cm)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5324 | |
Wei-Ting Lin | 01d4d8f | 2017-08-03 17:04:12 -0700 | [diff] [blame] | 5325 | #ifdef OUTPUT_YUV_REC |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 5326 | aom_write_one_yuv_frame(cm, &cm->cur_frame->buf); |
Wei-Ting Lin | 01d4d8f | 2017-08-03 17:04:12 -0700 | [diff] [blame] | 5327 | #endif |
| 5328 | |
David Turner | 996b2c1 | 2018-12-07 15:52:30 +0000 | [diff] [blame] | 5329 | finalize_encoded_frame(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5330 | // Build the bitstream |
David Turner | 35cba13 | 2018-12-10 15:48:15 +0000 | [diff] [blame] | 5331 | int largest_tile_id = 0; // Output from pack_bitstream |
| 5332 | 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] | 5333 | return AOM_CODEC_ERROR; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5334 | |
Debargha Mukherjee | f2e5bb3 | 2018-03-26 14:35:24 -0700 | [diff] [blame] | 5335 | cpi->seq_params_locked = 1; |
| 5336 | |
David Turner | 996b2c1 | 2018-12-07 15:52:30 +0000 | [diff] [blame] | 5337 | // Update reference frame ids for reference frames this frame will overwrite |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 5338 | if (seq_params->frame_id_numbers_present_flag) { |
David Turner | 996b2c1 | 2018-12-07 15:52:30 +0000 | [diff] [blame] | 5339 | for (int i = 0; i < REF_FRAMES; i++) { |
| 5340 | if ((current_frame->refresh_frame_flags >> i) & 1) { |
Arild Fuldseth (arilfuld) | 5114b7b | 2016-11-09 13:32:54 +0100 | [diff] [blame] | 5341 | cm->ref_frame_id[i] = cm->current_frame_id; |
| 5342 | } |
| 5343 | } |
| 5344 | } |
Arild Fuldseth (arilfuld) | 5114b7b | 2016-11-09 13:32:54 +0100 | [diff] [blame] | 5345 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5346 | #if DUMP_RECON_FRAMES == 1 |
| 5347 | // NOTE(zoeliu): For debug - Output the filtered reconstructed video. |
Zoe Liu | b4f3103 | 2017-11-03 23:48:35 -0700 | [diff] [blame] | 5348 | dump_filtered_recon_frames(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5349 | #endif // DUMP_RECON_FRAMES |
| 5350 | |
Soo-Chul Han | 934af35 | 2017-10-15 15:21:51 -0400 | [diff] [blame] | 5351 | if (cm->seg.enabled) { |
| 5352 | if (cm->seg.update_map) { |
| 5353 | update_reference_segmentation_map(cpi); |
Yue Chen | d90d343 | 2018-03-16 11:28:42 -0700 | [diff] [blame] | 5354 | } else if (cm->last_frame_seg_map) { |
David Turner | b757ce0 | 2018-11-12 15:01:28 +0000 | [diff] [blame] | 5355 | memcpy(cm->cur_frame->seg_map, cm->last_frame_seg_map, |
Soo-Chul Han | 934af35 | 2017-10-15 15:21:51 -0400 | [diff] [blame] | 5356 | cm->mi_cols * cm->mi_rows * sizeof(uint8_t)); |
| 5357 | } |
| 5358 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5359 | |
| 5360 | if (frame_is_intra_only(cm) == 0) { |
| 5361 | release_scaled_references(cpi); |
| 5362 | } |
| 5363 | |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 5364 | update_reference_frames(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5365 | |
Debargha Mukherjee | 5802ebe | 2016-12-21 04:17:24 -0800 | [diff] [blame] | 5366 | #if CONFIG_ENTROPY_STATS |
Yue Chen | cc6a6ef | 2018-05-21 16:21:05 -0700 | [diff] [blame] | 5367 | av1_accumulate_frame_counts(&aggregate_fc, &cpi->counts); |
Debargha Mukherjee | 5802ebe | 2016-12-21 04:17:24 -0800 | [diff] [blame] | 5368 | #endif // CONFIG_ENTROPY_STATS |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5369 | |
Hui Su | dc54be6 | 2018-03-14 19:14:28 -0700 | [diff] [blame] | 5370 | if (cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD) { |
David Turner | 35cba13 | 2018-12-10 15:48:15 +0000 | [diff] [blame] | 5371 | *cm->fc = cpi->tile_data[largest_tile_id].tctx; |
Hui Su | dc54be6 | 2018-03-14 19:14:28 -0700 | [diff] [blame] | 5372 | av1_reset_cdf_symbol_counters(cm->fc); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5373 | } |
| 5374 | |
| 5375 | if (cpi->refresh_golden_frame == 1) |
| 5376 | cpi->frame_flags |= FRAMEFLAGS_GOLDEN; |
| 5377 | else |
| 5378 | cpi->frame_flags &= ~FRAMEFLAGS_GOLDEN; |
| 5379 | |
| 5380 | if (cpi->refresh_alt_ref_frame == 1) |
| 5381 | cpi->frame_flags |= FRAMEFLAGS_ALTREF; |
| 5382 | else |
| 5383 | cpi->frame_flags &= ~FRAMEFLAGS_ALTREF; |
| 5384 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5385 | if (cpi->refresh_bwd_ref_frame == 1) |
| 5386 | cpi->frame_flags |= FRAMEFLAGS_BWDREF; |
| 5387 | else |
| 5388 | cpi->frame_flags &= ~FRAMEFLAGS_BWDREF; |
Sachin Kumar Garg | fd39b23 | 2019-01-03 17:41:09 +0530 | [diff] [blame] | 5389 | cm->last_frame_type = current_frame->frame_type; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5390 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5391 | av1_rc_postencode_update(cpi, *size); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5392 | |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 5393 | if (current_frame->frame_type == KEY_FRAME) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5394 | // Tell the caller that the frame was coded as a key frame |
| 5395 | *frame_flags = cpi->frame_flags | FRAMEFLAGS_KEY; |
| 5396 | } else { |
| 5397 | *frame_flags = cpi->frame_flags & ~FRAMEFLAGS_KEY; |
| 5398 | } |
| 5399 | |
| 5400 | // Clear the one shot update flags for segmentation map and mode/ref loop |
| 5401 | // filter deltas. |
| 5402 | cm->seg.update_map = 0; |
| 5403 | cm->seg.update_data = 0; |
| 5404 | cm->lf.mode_ref_delta_update = 0; |
| 5405 | |
Wei-Ting Lin | fb7dc06 | 2018-06-28 18:26:13 -0700 | [diff] [blame] | 5406 | // A droppable frame might not be shown but it always |
| 5407 | // takes a space in the gf group. Therefore, even when |
| 5408 | // it is not shown, we still need update the count down. |
| 5409 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5410 | if (cm->show_frame) { |
Urvang Joshi | f1fa686 | 2018-01-08 16:39:33 -0800 | [diff] [blame] | 5411 | // TODO(zoeliu): We may only swamp mi and prev_mi for those frames that |
| 5412 | // are |
Sebastien Alaiwan | 365e644 | 2017-10-16 11:35:00 +0200 | [diff] [blame] | 5413 | // being used as reference. |
Cheng Chen | 46f30c7 | 2017-09-07 11:13:33 -0700 | [diff] [blame] | 5414 | swap_mi_and_prev_mi(cm); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5415 | // Don't increment frame counters if this was an altref buffer |
| 5416 | // update not a real frame |
Wei-Ting Lin | 96ee0eb | 2018-06-22 15:27:22 -0700 | [diff] [blame] | 5417 | |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 5418 | ++current_frame->frame_number; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5419 | } |
| 5420 | |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 5421 | return AOM_CODEC_OK; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5422 | } |
| 5423 | |
David Turner | 056f7cd | 2019-01-07 17:48:13 +0000 | [diff] [blame] | 5424 | int av1_encode(AV1_COMP *const cpi, uint8_t *const dest, |
| 5425 | const EncodeFrameParams *const frame_params, |
| 5426 | EncodeFrameResults *const frame_results) { |
David Turner | 07dbd8e | 2019-01-08 17:16:25 +0000 | [diff] [blame] | 5427 | AV1_COMMON *const cm = &cpi->common; |
| 5428 | |
David Turner | 056f7cd | 2019-01-07 17:48:13 +0000 | [diff] [blame] | 5429 | // TODO(david.turner@argondesign.com): Copy data from frame_params to cpi and |
| 5430 | // cm as appropriate |
| 5431 | |
David Turner | 07dbd8e | 2019-01-08 17:16:25 +0000 | [diff] [blame] | 5432 | cm->error_resilient_mode = frame_params->error_resilient_mode; |
| 5433 | cpi->ref_frame_flags = frame_params->ref_frame_flags; |
| 5434 | |
David Turner | 056f7cd | 2019-01-07 17:48:13 +0000 | [diff] [blame] | 5435 | if (encode_frame_to_data_rate(cpi, &frame_results->size, dest, |
| 5436 | frame_params->frame_flags) != AOM_CODEC_OK) { |
| 5437 | return AOM_CODEC_ERROR; |
| 5438 | } |
| 5439 | |
| 5440 | return AOM_CODEC_OK; |
| 5441 | } |
| 5442 | |
Sarah Parker | 3491dd2 | 2018-08-08 18:38:31 -0700 | [diff] [blame] | 5443 | static INLINE void update_keyframe_counters(AV1_COMP *cpi) { |
| 5444 | // TODO(zoeliu): To investigate whether we should treat BWDREF_FRAME |
| 5445 | // differently here for rc->avg_frame_bandwidth. |
| 5446 | if (cpi->common.show_frame || cpi->rc.is_bwd_ref_frame) { |
| 5447 | if (!cpi->common.show_existing_frame || cpi->rc.is_src_frame_alt_ref || |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 5448 | cpi->common.current_frame.frame_type == KEY_FRAME) { |
Sarah Parker | 3491dd2 | 2018-08-08 18:38:31 -0700 | [diff] [blame] | 5449 | // If this is a show_existing_frame with a source other than altref, |
| 5450 | // or if it is not a displayed forward keyframe, the keyframe update |
| 5451 | // counters were incremented when it was originally encoded. |
| 5452 | cpi->rc.frames_since_key++; |
| 5453 | cpi->rc.frames_to_key--; |
| 5454 | } |
| 5455 | } |
| 5456 | } |
| 5457 | |
| 5458 | static INLINE void update_frames_till_gf_update(AV1_COMP *cpi) { |
| 5459 | // TODO(weitinglin): Updating this counter for is_frame_droppable |
| 5460 | // is a work-around to handle the condition when a frame is drop. |
| 5461 | // We should fix the cpi->common.show_frame flag |
| 5462 | // instead of checking the other condition to update the counter properly. |
| 5463 | if (cpi->common.show_frame || is_frame_droppable(cpi)) { |
| 5464 | // Decrement count down till next gf |
| 5465 | if (cpi->rc.frames_till_gf_update_due > 0) |
| 5466 | cpi->rc.frames_till_gf_update_due--; |
| 5467 | } |
| 5468 | } |
| 5469 | |
| 5470 | static INLINE void update_twopass_gf_group_index(AV1_COMP *cpi) { |
| 5471 | // Increment the gf group index ready for the next frame. If this is |
| 5472 | // a show_existing_frame with a source other than altref, or if it is not |
| 5473 | // a displayed forward keyframe, the index was incremented when it was |
| 5474 | // originally encoded. |
| 5475 | if (!cpi->common.show_existing_frame || cpi->rc.is_src_frame_alt_ref || |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 5476 | cpi->common.current_frame.frame_type == KEY_FRAME) { |
Sarah Parker | 3491dd2 | 2018-08-08 18:38:31 -0700 | [diff] [blame] | 5477 | ++cpi->twopass.gf_group.index; |
| 5478 | } |
| 5479 | } |
| 5480 | |
| 5481 | static void update_rc_counts(AV1_COMP *cpi) { |
| 5482 | update_keyframe_counters(cpi); |
| 5483 | update_frames_till_gf_update(cpi); |
| 5484 | if (cpi->oxcf.pass == 2) update_twopass_gf_group_index(cpi); |
| 5485 | } |
| 5486 | |
Debargha Mukherjee | 5737825 | 2018-09-21 18:29:37 -0700 | [diff] [blame] | 5487 | static void set_additional_frame_flags(AV1_COMMON *const cm, |
| 5488 | unsigned int *frame_flags) { |
| 5489 | if (frame_is_intra_only(cm)) *frame_flags |= FRAMEFLAGS_INTRAONLY; |
| 5490 | if (frame_is_sframe(cm)) *frame_flags |= FRAMEFLAGS_SWITCH; |
| 5491 | if (cm->error_resilient_mode) *frame_flags |= FRAMEFLAGS_ERROR_RESILIENT; |
| 5492 | } |
| 5493 | |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 5494 | static int Pass0Encode(AV1_COMP *cpi, size_t *size, uint8_t *dest, |
David Turner | 056f7cd | 2019-01-07 17:48:13 +0000 | [diff] [blame] | 5495 | unsigned int *frame_flags) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5496 | if (cpi->oxcf.rc_mode == AOM_CBR) { |
| 5497 | av1_rc_get_one_pass_cbr_params(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5498 | } else { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5499 | av1_rc_get_one_pass_vbr_params(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5500 | } |
David Turner | 056f7cd | 2019-01-07 17:48:13 +0000 | [diff] [blame] | 5501 | if (av1_encode_strategy(cpi, size, dest, frame_flags) != AOM_CODEC_OK) { |
Debargha Mukherjee | ff48c09 | 2018-04-04 23:53:40 -0700 | [diff] [blame] | 5502 | return AOM_CODEC_ERROR; |
| 5503 | } |
Debargha Mukherjee | 5737825 | 2018-09-21 18:29:37 -0700 | [diff] [blame] | 5504 | set_additional_frame_flags(&cpi->common, frame_flags); |
| 5505 | |
Sarah Parker | 3491dd2 | 2018-08-08 18:38:31 -0700 | [diff] [blame] | 5506 | update_rc_counts(cpi); |
Debargha Mukherjee | ff48c09 | 2018-04-04 23:53:40 -0700 | [diff] [blame] | 5507 | check_show_existing_frame(cpi); |
| 5508 | return AOM_CODEC_OK; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5509 | } |
| 5510 | |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 5511 | static int Pass2Encode(AV1_COMP *cpi, size_t *size, uint8_t *dest, |
| 5512 | unsigned int *frame_flags) { |
Angie Chiang | 5b5f4df | 2017-12-06 10:41:12 -0800 | [diff] [blame] | 5513 | #if CONFIG_MISMATCH_DEBUG |
| 5514 | mismatch_move_frame_idx_w(); |
| 5515 | #endif |
Angie Chiang | 4d55d76 | 2017-12-13 16:18:37 -0800 | [diff] [blame] | 5516 | #if TXCOEFF_COST_TIMER |
| 5517 | AV1_COMMON *cm = &cpi->common; |
| 5518 | cm->txcoeff_cost_timer = 0; |
| 5519 | cm->txcoeff_cost_count = 0; |
| 5520 | #endif |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 5521 | |
David Turner | 056f7cd | 2019-01-07 17:48:13 +0000 | [diff] [blame] | 5522 | if (av1_encode_strategy(cpi, size, dest, frame_flags) != AOM_CODEC_OK) { |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 5523 | return AOM_CODEC_ERROR; |
| 5524 | } |
Debargha Mukherjee | 5737825 | 2018-09-21 18:29:37 -0700 | [diff] [blame] | 5525 | set_additional_frame_flags(&cpi->common, frame_flags); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5526 | |
Angie Chiang | 4d55d76 | 2017-12-13 16:18:37 -0800 | [diff] [blame] | 5527 | #if TXCOEFF_COST_TIMER |
| 5528 | cm->cum_txcoeff_cost_timer += cm->txcoeff_cost_timer; |
| 5529 | fprintf(stderr, |
| 5530 | "\ntxb coeff cost block number: %ld, frame time: %ld, cum time %ld " |
| 5531 | "in us\n", |
| 5532 | cm->txcoeff_cost_count, cm->txcoeff_cost_timer, |
| 5533 | cm->cum_txcoeff_cost_timer); |
| 5534 | #endif |
| 5535 | |
Sarah Parker | 3491dd2 | 2018-08-08 18:38:31 -0700 | [diff] [blame] | 5536 | av1_twopass_postencode_update(cpi); |
| 5537 | update_rc_counts(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5538 | check_show_existing_frame(cpi); |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 5539 | return AOM_CODEC_OK; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5540 | } |
| 5541 | |
Neil Birkbeck | a2893ab | 2018-06-08 14:45:13 -0700 | [diff] [blame] | 5542 | #if CONFIG_DENOISE |
| 5543 | static int apply_denoise_2d(AV1_COMP *cpi, YV12_BUFFER_CONFIG *sd, |
| 5544 | int block_size, float noise_level, |
| 5545 | int64_t time_stamp, int64_t end_time) { |
| 5546 | AV1_COMMON *const cm = &cpi->common; |
| 5547 | if (!cpi->denoise_and_model) { |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 5548 | cpi->denoise_and_model = aom_denoise_and_model_alloc( |
| 5549 | cm->seq_params.bit_depth, block_size, noise_level); |
Neil Birkbeck | a2893ab | 2018-06-08 14:45:13 -0700 | [diff] [blame] | 5550 | if (!cpi->denoise_and_model) { |
| 5551 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
| 5552 | "Error allocating denoise and model"); |
| 5553 | return -1; |
| 5554 | } |
| 5555 | } |
| 5556 | if (!cpi->film_grain_table) { |
| 5557 | cpi->film_grain_table = aom_malloc(sizeof(*cpi->film_grain_table)); |
| 5558 | if (!cpi->film_grain_table) { |
| 5559 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
| 5560 | "Error allocating grain table"); |
| 5561 | return -1; |
| 5562 | } |
| 5563 | memset(cpi->film_grain_table, 0, sizeof(*cpi->film_grain_table)); |
| 5564 | } |
| 5565 | if (aom_denoise_and_model_run(cpi->denoise_and_model, sd, |
| 5566 | &cm->film_grain_params)) { |
| 5567 | if (cm->film_grain_params.apply_grain) { |
| 5568 | aom_film_grain_table_append(cpi->film_grain_table, time_stamp, end_time, |
| 5569 | &cm->film_grain_params); |
| 5570 | } |
| 5571 | } |
| 5572 | return 0; |
| 5573 | } |
| 5574 | #endif |
| 5575 | |
James Zern | 3e2613b | 2017-03-30 23:14:40 -0700 | [diff] [blame] | 5576 | 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] | 5577 | YV12_BUFFER_CONFIG *sd, int64_t time_stamp, |
| 5578 | int64_t end_time) { |
| 5579 | AV1_COMMON *const cm = &cpi->common; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 5580 | const SequenceHeader *const seq_params = &cm->seq_params; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5581 | struct aom_usec_timer timer; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5582 | int res = 0; |
| 5583 | const int subsampling_x = sd->subsampling_x; |
| 5584 | const int subsampling_y = sd->subsampling_y; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5585 | const int use_highbitdepth = (sd->flags & YV12_FLAG_HIGHBITDEPTH) != 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5586 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5587 | check_initial_width(cpi, use_highbitdepth, subsampling_x, subsampling_y); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5588 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5589 | aom_usec_timer_start(&timer); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5590 | |
Neil Birkbeck | a2893ab | 2018-06-08 14:45:13 -0700 | [diff] [blame] | 5591 | #if CONFIG_DENOISE |
| 5592 | if (cpi->oxcf.noise_level > 0) |
| 5593 | if (apply_denoise_2d(cpi, sd, cpi->oxcf.noise_block_size, |
| 5594 | cpi->oxcf.noise_level, time_stamp, end_time) < 0) |
| 5595 | res = -1; |
| 5596 | #endif // CONFIG_DENOISE |
| 5597 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5598 | if (av1_lookahead_push(cpi->lookahead, sd, time_stamp, end_time, |
Yaowu Xu | d3e7c68 | 2017-12-21 14:08:25 -0800 | [diff] [blame] | 5599 | use_highbitdepth, frame_flags)) |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5600 | res = -1; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5601 | aom_usec_timer_mark(&timer); |
| 5602 | cpi->time_receive_data += aom_usec_timer_elapsed(&timer); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5603 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 5604 | if ((seq_params->profile == PROFILE_0) && !seq_params->monochrome && |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5605 | (subsampling_x != 1 || subsampling_y != 1)) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5606 | aom_internal_error(&cm->error, AOM_CODEC_INVALID_PARAM, |
Debargha Mukherjee | f9a50ea | 2018-01-09 22:28:20 -0800 | [diff] [blame] | 5607 | "Non-4:2:0 color format requires profile 1 or 2"); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5608 | res = -1; |
| 5609 | } |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 5610 | if ((seq_params->profile == PROFILE_1) && |
Debargha Mukherjee | f9a50ea | 2018-01-09 22:28:20 -0800 | [diff] [blame] | 5611 | !(subsampling_x == 0 && subsampling_y == 0)) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5612 | aom_internal_error(&cm->error, AOM_CODEC_INVALID_PARAM, |
Debargha Mukherjee | f9a50ea | 2018-01-09 22:28:20 -0800 | [diff] [blame] | 5613 | "Profile 1 requires 4:4:4 color format"); |
| 5614 | res = -1; |
| 5615 | } |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 5616 | if ((seq_params->profile == PROFILE_2) && |
| 5617 | (seq_params->bit_depth <= AOM_BITS_10) && |
Debargha Mukherjee | f9a50ea | 2018-01-09 22:28:20 -0800 | [diff] [blame] | 5618 | !(subsampling_x == 1 && subsampling_y == 0)) { |
| 5619 | aom_internal_error(&cm->error, AOM_CODEC_INVALID_PARAM, |
| 5620 | "Profile 2 bit-depth < 10 requires 4:2:2 color format"); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5621 | res = -1; |
| 5622 | } |
| 5623 | |
| 5624 | return res; |
| 5625 | } |
| 5626 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5627 | static void adjust_frame_rate(AV1_COMP *cpi, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5628 | const struct lookahead_entry *source) { |
| 5629 | int64_t this_duration; |
| 5630 | int step = 0; |
| 5631 | |
| 5632 | if (source->ts_start == cpi->first_time_stamp_ever) { |
| 5633 | this_duration = source->ts_end - source->ts_start; |
| 5634 | step = 1; |
| 5635 | } else { |
| 5636 | int64_t last_duration = |
| 5637 | cpi->last_end_time_stamp_seen - cpi->last_time_stamp_seen; |
| 5638 | |
| 5639 | this_duration = source->ts_end - cpi->last_end_time_stamp_seen; |
| 5640 | |
| 5641 | // do a step update if the duration changes by 10% |
| 5642 | if (last_duration) |
| 5643 | step = (int)((this_duration - last_duration) * 10 / last_duration); |
| 5644 | } |
| 5645 | |
| 5646 | if (this_duration) { |
| 5647 | if (step) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5648 | av1_new_framerate(cpi, 10000000.0 / this_duration); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5649 | } else { |
| 5650 | // Average this frame's rate into the last second's average |
| 5651 | // frame rate. If we haven't seen 1 second yet, then average |
| 5652 | // over the whole interval seen. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5653 | const double interval = AOMMIN( |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5654 | (double)(source->ts_end - cpi->first_time_stamp_ever), 10000000.0); |
| 5655 | double avg_duration = 10000000.0 / cpi->framerate; |
| 5656 | avg_duration *= (interval - avg_duration + this_duration); |
| 5657 | avg_duration /= interval; |
| 5658 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5659 | av1_new_framerate(cpi, 10000000.0 / avg_duration); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5660 | } |
| 5661 | } |
| 5662 | cpi->last_time_stamp_seen = source->ts_start; |
| 5663 | cpi->last_end_time_stamp_seen = source->ts_end; |
| 5664 | } |
| 5665 | |
| 5666 | // Returns 0 if this is not an alt ref else the offset of the source frame |
| 5667 | // used as the arf midpoint. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5668 | static int get_arf_src_index(AV1_COMP *cpi) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5669 | RATE_CONTROL *const rc = &cpi->rc; |
| 5670 | int arf_src_index = 0; |
| 5671 | if (is_altref_enabled(cpi)) { |
| 5672 | if (cpi->oxcf.pass == 2) { |
| 5673 | const GF_GROUP *const gf_group = &cpi->twopass.gf_group; |
| 5674 | if (gf_group->update_type[gf_group->index] == ARF_UPDATE) { |
| 5675 | arf_src_index = gf_group->arf_src_offset[gf_group->index]; |
| 5676 | } |
| 5677 | } else if (rc->source_alt_ref_pending) { |
| 5678 | arf_src_index = rc->frames_till_gf_update_due; |
| 5679 | } |
| 5680 | } |
| 5681 | return arf_src_index; |
| 5682 | } |
| 5683 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5684 | static int get_brf_src_index(AV1_COMP *cpi) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5685 | int brf_src_index = 0; |
| 5686 | const GF_GROUP *const gf_group = &cpi->twopass.gf_group; |
| 5687 | |
| 5688 | // TODO(zoeliu): We need to add the check on the -bwd_ref command line setup |
| 5689 | // flag. |
| 5690 | if (gf_group->bidir_pred_enabled[gf_group->index]) { |
| 5691 | if (cpi->oxcf.pass == 2) { |
| 5692 | if (gf_group->update_type[gf_group->index] == BRF_UPDATE) |
| 5693 | brf_src_index = gf_group->brf_src_offset[gf_group->index]; |
| 5694 | } else { |
| 5695 | // TODO(zoeliu): To re-visit the setup for this scenario |
| 5696 | brf_src_index = cpi->rc.bipred_group_interval - 1; |
| 5697 | } |
| 5698 | } |
| 5699 | |
| 5700 | return brf_src_index; |
| 5701 | } |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 5702 | |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 5703 | // Returns 0 if this is not an alt ref else the offset of the source frame |
| 5704 | // used as the arf midpoint. |
| 5705 | static int get_arf2_src_index(AV1_COMP *cpi) { |
| 5706 | int arf2_src_index = 0; |
| 5707 | if (is_altref_enabled(cpi) && cpi->num_extra_arfs) { |
| 5708 | if (cpi->oxcf.pass == 2) { |
| 5709 | const GF_GROUP *const gf_group = &cpi->twopass.gf_group; |
| 5710 | if (gf_group->update_type[gf_group->index] == INTNL_ARF_UPDATE) { |
| 5711 | arf2_src_index = gf_group->arf_src_offset[gf_group->index]; |
| 5712 | } |
| 5713 | } |
| 5714 | } |
| 5715 | return arf2_src_index; |
| 5716 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5717 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5718 | static void check_src_altref(AV1_COMP *cpi, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5719 | const struct lookahead_entry *source) { |
| 5720 | RATE_CONTROL *const rc = &cpi->rc; |
| 5721 | |
| 5722 | // If pass == 2, the parameters set here will be reset in |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5723 | // av1_rc_get_second_pass_params() |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5724 | |
| 5725 | if (cpi->oxcf.pass == 2) { |
| 5726 | const GF_GROUP *const gf_group = &cpi->twopass.gf_group; |
| 5727 | rc->is_src_frame_alt_ref = |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5728 | (gf_group->update_type[gf_group->index] == INTNL_OVERLAY_UPDATE) || |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5729 | (gf_group->update_type[gf_group->index] == OVERLAY_UPDATE); |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 5730 | rc->is_src_frame_ext_arf = |
| 5731 | gf_group->update_type[gf_group->index] == INTNL_OVERLAY_UPDATE; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5732 | } else { |
| 5733 | rc->is_src_frame_alt_ref = |
| 5734 | cpi->alt_ref_source && (source == cpi->alt_ref_source); |
| 5735 | } |
| 5736 | |
| 5737 | if (rc->is_src_frame_alt_ref) { |
| 5738 | // Current frame is an ARF overlay frame. |
| 5739 | cpi->alt_ref_source = NULL; |
| 5740 | |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 5741 | if (rc->is_src_frame_ext_arf && !cpi->common.show_existing_frame) { |
| 5742 | // For INTNL_OVERLAY, when show_existing_frame == 0, they do need to |
| 5743 | // refresh the LAST_FRAME, i.e. LAST3 gets retired, LAST2 becomes LAST3, |
| 5744 | // LAST becomes LAST2, and INTNL_OVERLAY becomes LAST. |
| 5745 | cpi->refresh_last_frame = 1; |
| 5746 | } else { |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 5747 | // Don't refresh the last buffer for an ARF overlay frame. It will |
| 5748 | // become the GF so preserve last as an alternative prediction option. |
| 5749 | cpi->refresh_last_frame = 0; |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 5750 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5751 | } |
| 5752 | } |
| 5753 | |
| 5754 | #if CONFIG_INTERNAL_STATS |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5755 | extern double av1_get_blockiness(const unsigned char *img1, int img1_pitch, |
| 5756 | const unsigned char *img2, int img2_pitch, |
| 5757 | int width, int height); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5758 | |
| 5759 | static void adjust_image_stat(double y, double u, double v, double all, |
| 5760 | ImageStat *s) { |
Wan-Teh Chang | c25c92a | 2018-04-23 15:04:14 -0700 | [diff] [blame] | 5761 | s->stat[STAT_Y] += y; |
| 5762 | s->stat[STAT_U] += u; |
| 5763 | s->stat[STAT_V] += v; |
| 5764 | s->stat[STAT_ALL] += all; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5765 | s->worst = AOMMIN(s->worst, all); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5766 | } |
| 5767 | |
Angie Chiang | 08a22a6 | 2017-07-17 17:29:17 -0700 | [diff] [blame] | 5768 | static void compute_internal_stats(AV1_COMP *cpi, int frame_bytes) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5769 | AV1_COMMON *const cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5770 | double samples = 0.0; |
| 5771 | uint32_t in_bit_depth = 8; |
| 5772 | uint32_t bit_depth = 8; |
| 5773 | |
Angie Chiang | 08a22a6 | 2017-07-17 17:29:17 -0700 | [diff] [blame] | 5774 | #if CONFIG_INTER_STATS_ONLY |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 5775 | if (cm->current_frame.frame_type == KEY_FRAME) return; // skip key frame |
Angie Chiang | 08a22a6 | 2017-07-17 17:29:17 -0700 | [diff] [blame] | 5776 | #endif |
| 5777 | cpi->bytes += frame_bytes; |
| 5778 | |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 5779 | if (cm->seq_params.use_highbitdepth) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5780 | in_bit_depth = cpi->oxcf.input_bit_depth; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 5781 | bit_depth = cm->seq_params.bit_depth; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5782 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5783 | if (cm->show_frame) { |
Alex Converse | f77fd0b | 2017-04-20 11:00:24 -0700 | [diff] [blame] | 5784 | const YV12_BUFFER_CONFIG *orig = cpi->source; |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 5785 | const YV12_BUFFER_CONFIG *recon = &cpi->common.cur_frame->buf; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5786 | double y, u, v, frame_all; |
| 5787 | |
| 5788 | cpi->count++; |
| 5789 | if (cpi->b_calculate_psnr) { |
| 5790 | PSNR_STATS psnr; |
| 5791 | double frame_ssim2 = 0.0, weight = 0.0; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5792 | aom_clear_system_state(); |
Yaowu Xu | d3e7c68 | 2017-12-21 14:08:25 -0800 | [diff] [blame] | 5793 | // TODO(yaowu): unify these two versions into one. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5794 | aom_calc_highbd_psnr(orig, recon, &psnr, bit_depth, in_bit_depth); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5795 | |
| 5796 | adjust_image_stat(psnr.psnr[1], psnr.psnr[2], psnr.psnr[3], psnr.psnr[0], |
| 5797 | &cpi->psnr); |
| 5798 | cpi->total_sq_error += psnr.sse[0]; |
| 5799 | cpi->total_samples += psnr.samples[0]; |
| 5800 | samples = psnr.samples[0]; |
Yaowu Xu | d3e7c68 | 2017-12-21 14:08:25 -0800 | [diff] [blame] | 5801 | // TODO(yaowu): unify these two versions into one. |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 5802 | if (cm->seq_params.use_highbitdepth) |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5803 | frame_ssim2 = |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5804 | aom_highbd_calc_ssim(orig, recon, &weight, bit_depth, in_bit_depth); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5805 | else |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5806 | frame_ssim2 = aom_calc_ssim(orig, recon, &weight); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5807 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5808 | cpi->worst_ssim = AOMMIN(cpi->worst_ssim, frame_ssim2); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5809 | cpi->summed_quality += frame_ssim2 * weight; |
| 5810 | cpi->summed_weights += weight; |
| 5811 | |
| 5812 | #if 0 |
| 5813 | { |
| 5814 | FILE *f = fopen("q_used.stt", "a"); |
Zoe Liu | ee202be | 2017-11-17 12:14:33 -0800 | [diff] [blame] | 5815 | double y2 = psnr.psnr[1]; |
| 5816 | double u2 = psnr.psnr[2]; |
| 5817 | double v2 = psnr.psnr[3]; |
| 5818 | double frame_psnr2 = psnr.psnr[0]; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5819 | 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] | 5820 | cm->current_frame.frame_number, y2, u2, v2, |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5821 | frame_psnr2, frame_ssim2); |
| 5822 | fclose(f); |
| 5823 | } |
| 5824 | #endif |
| 5825 | } |
| 5826 | if (cpi->b_calculate_blockiness) { |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 5827 | if (!cm->seq_params.use_highbitdepth) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5828 | const double frame_blockiness = |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5829 | av1_get_blockiness(orig->y_buffer, orig->y_stride, recon->y_buffer, |
| 5830 | recon->y_stride, orig->y_width, orig->y_height); |
| 5831 | cpi->worst_blockiness = AOMMAX(cpi->worst_blockiness, frame_blockiness); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5832 | cpi->total_blockiness += frame_blockiness; |
| 5833 | } |
| 5834 | |
| 5835 | if (cpi->b_calculate_consistency) { |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 5836 | if (!cm->seq_params.use_highbitdepth) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5837 | const double this_inconsistency = aom_get_ssim_metrics( |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5838 | orig->y_buffer, orig->y_stride, recon->y_buffer, recon->y_stride, |
| 5839 | orig->y_width, orig->y_height, cpi->ssim_vars, &cpi->metrics, 1); |
| 5840 | |
| 5841 | const double peak = (double)((1 << in_bit_depth) - 1); |
| 5842 | const double consistency = |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5843 | aom_sse_to_psnr(samples, peak, cpi->total_inconsistency); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5844 | if (consistency > 0.0) |
| 5845 | cpi->worst_consistency = |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5846 | AOMMIN(cpi->worst_consistency, consistency); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 5847 | cpi->total_inconsistency += this_inconsistency; |
| 5848 | } |
| 5849 | } |
| 5850 | } |
| 5851 | |
| 5852 | frame_all = |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5853 | 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] | 5854 | adjust_image_stat(y, u, v, frame_all, &cpi->fastssim); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 5855 | 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] | 5856 | adjust_image_stat(y, u, v, frame_all, &cpi->psnrhvs); |
| 5857 | } |
| 5858 | } |
| 5859 | #endif // CONFIG_INTERNAL_STATS |
| 5860 | |
RogerZhou | 3b63524 | 2017-09-19 10:06:46 -0700 | [diff] [blame] | 5861 | static int is_integer_mv(AV1_COMP *cpi, const YV12_BUFFER_CONFIG *cur_picture, |
| 5862 | const YV12_BUFFER_CONFIG *last_picture, |
| 5863 | hash_table *last_hash_table) { |
| 5864 | aom_clear_system_state(); |
| 5865 | // check use hash ME |
| 5866 | int k; |
| 5867 | uint32_t hash_value_1; |
| 5868 | uint32_t hash_value_2; |
| 5869 | |
| 5870 | const int block_size = 8; |
| 5871 | const double threshold_current = 0.8; |
| 5872 | const double threshold_average = 0.95; |
| 5873 | const int max_history_size = 32; |
| 5874 | int T = 0; // total block |
| 5875 | int C = 0; // match with collocated block |
| 5876 | int S = 0; // smooth region but not match with collocated block |
| 5877 | int M = 0; // match with other block |
| 5878 | |
| 5879 | const int pic_width = cur_picture->y_width; |
| 5880 | const int pic_height = cur_picture->y_height; |
| 5881 | for (int i = 0; i + block_size <= pic_height; i += block_size) { |
| 5882 | for (int j = 0; j + block_size <= pic_width; j += block_size) { |
| 5883 | const int x_pos = j; |
| 5884 | const int y_pos = i; |
| 5885 | int match = 1; |
| 5886 | T++; |
| 5887 | |
| 5888 | // check whether collocated block match with current |
| 5889 | uint8_t *p_cur = cur_picture->y_buffer; |
| 5890 | uint8_t *p_ref = last_picture->y_buffer; |
| 5891 | int stride_cur = cur_picture->y_stride; |
| 5892 | int stride_ref = last_picture->y_stride; |
| 5893 | p_cur += (y_pos * stride_cur + x_pos); |
| 5894 | p_ref += (y_pos * stride_ref + x_pos); |
| 5895 | |
Debargha Mukherjee | 1c58301 | 2018-02-28 22:16:16 -0800 | [diff] [blame] | 5896 | if (cur_picture->flags & YV12_FLAG_HIGHBITDEPTH) { |
| 5897 | uint16_t *p16_cur = CONVERT_TO_SHORTPTR(p_cur); |
| 5898 | uint16_t *p16_ref = CONVERT_TO_SHORTPTR(p_ref); |
| 5899 | for (int tmpY = 0; tmpY < block_size && match; tmpY++) { |
| 5900 | for (int tmpX = 0; tmpX < block_size && match; tmpX++) { |
| 5901 | if (p16_cur[tmpX] != p16_ref[tmpX]) { |
| 5902 | match = 0; |
| 5903 | } |
RogerZhou | 3b63524 | 2017-09-19 10:06:46 -0700 | [diff] [blame] | 5904 | } |
Debargha Mukherjee | 1c58301 | 2018-02-28 22:16:16 -0800 | [diff] [blame] | 5905 | p16_cur += stride_cur; |
| 5906 | p16_ref += stride_ref; |
RogerZhou | 3b63524 | 2017-09-19 10:06:46 -0700 | [diff] [blame] | 5907 | } |
Debargha Mukherjee | 1c58301 | 2018-02-28 22:16:16 -0800 | [diff] [blame] | 5908 | } else { |
| 5909 | for (int tmpY = 0; tmpY < block_size && match; tmpY++) { |
| 5910 | for (int tmpX = 0; tmpX < block_size && match; tmpX++) { |
| 5911 | if (p_cur[tmpX] != p_ref[tmpX]) { |
| 5912 | match = 0; |
| 5913 | } |
| 5914 | } |
| 5915 | p_cur += stride_cur; |
| 5916 | p_ref += stride_ref; |
| 5917 | } |
RogerZhou | 3b63524 | 2017-09-19 10:06:46 -0700 | [diff] [blame] | 5918 | } |
| 5919 | |
| 5920 | if (match) { |
| 5921 | C++; |
| 5922 | continue; |
| 5923 | } |
| 5924 | |
| 5925 | if (av1_hash_is_horizontal_perfect(cur_picture, block_size, x_pos, |
| 5926 | y_pos) || |
| 5927 | av1_hash_is_vertical_perfect(cur_picture, block_size, x_pos, y_pos)) { |
| 5928 | S++; |
| 5929 | continue; |
| 5930 | } |
| 5931 | |
| 5932 | av1_get_block_hash_value( |
| 5933 | cur_picture->y_buffer + y_pos * stride_cur + x_pos, stride_cur, |
Debargha Mukherjee | 1c58301 | 2018-02-28 22:16:16 -0800 | [diff] [blame] | 5934 | block_size, &hash_value_1, &hash_value_2, |
Ravi Chaudhary | 783d6a3 | 2018-08-28 18:21:02 +0530 | [diff] [blame] | 5935 | (cur_picture->flags & YV12_FLAG_HIGHBITDEPTH), &cpi->td.mb); |
Debargha Mukherjee | 1c58301 | 2018-02-28 22:16:16 -0800 | [diff] [blame] | 5936 | // Hashing does not work for highbitdepth currently. |
| 5937 | // TODO(Roger): Make it work for highbitdepth. |
| 5938 | if (av1_use_hash_me(&cpi->common)) { |
| 5939 | if (av1_has_exact_match(last_hash_table, hash_value_1, hash_value_2)) { |
| 5940 | M++; |
| 5941 | } |
RogerZhou | 3b63524 | 2017-09-19 10:06:46 -0700 | [diff] [blame] | 5942 | } |
| 5943 | } |
| 5944 | } |
| 5945 | |
| 5946 | assert(T > 0); |
| 5947 | double csm_rate = ((double)(C + S + M)) / ((double)(T)); |
| 5948 | double m_rate = ((double)(M)) / ((double)(T)); |
| 5949 | |
| 5950 | cpi->csm_rate_array[cpi->rate_index] = csm_rate; |
| 5951 | cpi->m_rate_array[cpi->rate_index] = m_rate; |
| 5952 | |
| 5953 | cpi->rate_index = (cpi->rate_index + 1) % max_history_size; |
| 5954 | cpi->rate_size++; |
| 5955 | cpi->rate_size = AOMMIN(cpi->rate_size, max_history_size); |
| 5956 | |
| 5957 | if (csm_rate < threshold_current) { |
| 5958 | return 0; |
| 5959 | } |
| 5960 | |
| 5961 | if (C == T) { |
| 5962 | return 1; |
| 5963 | } |
| 5964 | |
| 5965 | double csm_average = 0.0; |
| 5966 | double m_average = 0.0; |
| 5967 | |
| 5968 | for (k = 0; k < cpi->rate_size; k++) { |
| 5969 | csm_average += cpi->csm_rate_array[k]; |
| 5970 | m_average += cpi->m_rate_array[k]; |
| 5971 | } |
| 5972 | csm_average /= cpi->rate_size; |
| 5973 | m_average /= cpi->rate_size; |
| 5974 | |
| 5975 | if (csm_average < threshold_average) { |
| 5976 | return 0; |
| 5977 | } |
| 5978 | |
| 5979 | if (M > (T - C - S) / 3) { |
| 5980 | return 1; |
| 5981 | } |
| 5982 | |
| 5983 | if (csm_rate > 0.99 && m_rate > 0.01) { |
| 5984 | return 1; |
| 5985 | } |
| 5986 | |
| 5987 | if (csm_average + m_average > 1.01) { |
| 5988 | return 1; |
| 5989 | } |
| 5990 | |
| 5991 | return 0; |
| 5992 | } |
RogerZhou | 3b63524 | 2017-09-19 10:06:46 -0700 | [diff] [blame] | 5993 | |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 5994 | // Code for temporal dependency model |
| 5995 | typedef struct GF_PICTURE { |
| 5996 | YV12_BUFFER_CONFIG *frame; |
| 5997 | int ref_frame[7]; |
| 5998 | } GF_PICTURE; |
| 5999 | |
Sarah Parker | cf64444 | 2018-10-11 15:23:44 -0700 | [diff] [blame] | 6000 | static void init_gop_frames(AV1_COMP *cpi, GF_PICTURE *gf_picture, |
| 6001 | const GF_GROUP *gf_group, int *tpl_group_frames) { |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 6002 | AV1_COMMON *cm = &cpi->common; |
| 6003 | const SequenceHeader *const seq_params = &cm->seq_params; |
| 6004 | int frame_idx = 0; |
| 6005 | int i; |
| 6006 | int gld_index = -1; |
| 6007 | int alt_index = -1; |
| 6008 | int lst_index = -1; |
| 6009 | int extend_frame_count = 0; |
| 6010 | int pframe_qindex = cpi->tpl_stats[2].base_qindex; |
| 6011 | |
| 6012 | RefCntBuffer *frame_bufs = cm->buffer_pool->frame_bufs; |
| 6013 | int recon_frame_index[INTER_REFS_PER_FRAME + 1] = { -1, -1, -1, -1, |
| 6014 | -1, -1, -1, -1 }; |
| 6015 | |
| 6016 | // TODO(jingning): To be used later for gf frame type parsing. |
| 6017 | (void)gf_group; |
| 6018 | |
| 6019 | for (i = 0; i < FRAME_BUFFERS && frame_idx < INTER_REFS_PER_FRAME + 1; ++i) { |
| 6020 | if (frame_bufs[i].ref_count == 0) { |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 6021 | alloc_frame_mvs(cm, &frame_bufs[i]); |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 6022 | if (aom_realloc_frame_buffer( |
| 6023 | &frame_bufs[i].buf, cm->width, cm->height, |
| 6024 | seq_params->subsampling_x, seq_params->subsampling_y, |
Satish Kumar Suman | 2990996 | 2019-01-09 10:31:21 +0530 | [diff] [blame] | 6025 | seq_params->use_highbitdepth, cpi->oxcf.border_in_pixels, |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 6026 | cm->byte_alignment, NULL, NULL, NULL)) |
| 6027 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
| 6028 | "Failed to allocate frame buffer"); |
| 6029 | |
| 6030 | recon_frame_index[frame_idx] = i; |
| 6031 | ++frame_idx; |
| 6032 | } |
| 6033 | } |
| 6034 | |
| 6035 | for (i = 0; i < INTER_REFS_PER_FRAME + 1; ++i) { |
| 6036 | assert(recon_frame_index[i] >= 0); |
| 6037 | cpi->tpl_recon_frames[i] = &frame_bufs[recon_frame_index[i]].buf; |
| 6038 | } |
| 6039 | |
| 6040 | *tpl_group_frames = 0; |
| 6041 | |
| 6042 | // Initialize Golden reference frame. |
David Turner | a21966b | 2018-12-05 14:48:49 +0000 | [diff] [blame] | 6043 | gf_picture[0].frame = NULL; |
| 6044 | RefCntBuffer *ref_buf = get_ref_frame_buf(cm, GOLDEN_FRAME); |
| 6045 | if (ref_buf) gf_picture[0].frame = &ref_buf->buf; |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 6046 | for (i = 0; i < 7; ++i) gf_picture[0].ref_frame[i] = -1; |
| 6047 | gld_index = 0; |
| 6048 | ++*tpl_group_frames; |
| 6049 | |
| 6050 | // Initialize ARF frame |
| 6051 | gf_picture[1].frame = cpi->source; |
| 6052 | gf_picture[1].ref_frame[0] = gld_index; |
| 6053 | gf_picture[1].ref_frame[1] = lst_index; |
| 6054 | gf_picture[1].ref_frame[2] = alt_index; |
| 6055 | // TODO(yuec) Need o figure out full AV1 reference model |
| 6056 | for (i = 3; i < 7; ++i) gf_picture[1].ref_frame[i] = -1; |
| 6057 | alt_index = 1; |
| 6058 | ++*tpl_group_frames; |
| 6059 | |
| 6060 | // Initialize P frames |
| 6061 | for (frame_idx = 2; frame_idx < MAX_LAG_BUFFERS; ++frame_idx) { |
| 6062 | struct lookahead_entry *buf = |
| 6063 | av1_lookahead_peek(cpi->lookahead, frame_idx - 2); |
| 6064 | |
| 6065 | if (buf == NULL) break; |
| 6066 | |
| 6067 | gf_picture[frame_idx].frame = &buf->img; |
| 6068 | gf_picture[frame_idx].ref_frame[0] = gld_index; |
| 6069 | gf_picture[frame_idx].ref_frame[1] = lst_index; |
| 6070 | gf_picture[frame_idx].ref_frame[2] = alt_index; |
| 6071 | for (i = 3; i < 7; ++i) gf_picture[frame_idx].ref_frame[i] = -1; |
| 6072 | |
| 6073 | ++*tpl_group_frames; |
| 6074 | lst_index = frame_idx; |
| 6075 | |
| 6076 | if (frame_idx == cpi->rc.baseline_gf_interval + 1) break; |
| 6077 | } |
| 6078 | |
| 6079 | gld_index = frame_idx; |
| 6080 | lst_index = AOMMAX(0, frame_idx - 1); |
| 6081 | alt_index = -1; |
| 6082 | ++frame_idx; |
| 6083 | |
| 6084 | // Extend two frames outside the current gf group. |
| 6085 | for (; frame_idx < MAX_LAG_BUFFERS && extend_frame_count < 2; ++frame_idx) { |
| 6086 | struct lookahead_entry *buf = |
| 6087 | av1_lookahead_peek(cpi->lookahead, frame_idx - 2); |
| 6088 | |
| 6089 | if (buf == NULL) break; |
| 6090 | |
| 6091 | cpi->tpl_stats[frame_idx].base_qindex = pframe_qindex; |
| 6092 | |
| 6093 | gf_picture[frame_idx].frame = &buf->img; |
| 6094 | gf_picture[frame_idx].ref_frame[0] = gld_index; |
| 6095 | gf_picture[frame_idx].ref_frame[1] = lst_index; |
| 6096 | gf_picture[frame_idx].ref_frame[2] = alt_index; |
| 6097 | for (i = 3; i < 7; ++i) gf_picture[frame_idx].ref_frame[i] = -1; |
| 6098 | lst_index = frame_idx; |
| 6099 | ++*tpl_group_frames; |
| 6100 | ++extend_frame_count; |
| 6101 | } |
| 6102 | } |
| 6103 | |
Sarah Parker | cf64444 | 2018-10-11 15:23:44 -0700 | [diff] [blame] | 6104 | static void init_tpl_stats(AV1_COMP *cpi) { |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 6105 | int frame_idx; |
| 6106 | for (frame_idx = 0; frame_idx < MAX_LAG_BUFFERS; ++frame_idx) { |
| 6107 | TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx]; |
| 6108 | memset(tpl_frame->tpl_stats_ptr, 0, |
| 6109 | tpl_frame->height * tpl_frame->width * |
| 6110 | sizeof(*tpl_frame->tpl_stats_ptr)); |
| 6111 | tpl_frame->is_valid = 0; |
| 6112 | } |
| 6113 | } |
| 6114 | |
Sarah Parker | cf64444 | 2018-10-11 15:23:44 -0700 | [diff] [blame] | 6115 | static uint32_t motion_compensated_prediction(AV1_COMP *cpi, ThreadData *td, |
| 6116 | uint8_t *cur_frame_buf, |
| 6117 | uint8_t *ref_frame_buf, |
| 6118 | int stride, BLOCK_SIZE bsize, |
| 6119 | int mi_row, int mi_col) { |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 6120 | AV1_COMMON *cm = &cpi->common; |
| 6121 | MACROBLOCK *const x = &td->mb; |
| 6122 | MACROBLOCKD *const xd = &x->e_mbd; |
| 6123 | MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv; |
| 6124 | const SEARCH_METHODS search_method = NSTEP; |
| 6125 | int step_param; |
| 6126 | int sadpb = x->sadperbit16; |
| 6127 | uint32_t bestsme = UINT_MAX; |
| 6128 | int distortion; |
| 6129 | uint32_t sse; |
| 6130 | int cost_list[5]; |
| 6131 | const MvLimits tmp_mv_limits = x->mv_limits; |
| 6132 | |
| 6133 | MV best_ref_mv1 = { 0, 0 }; |
| 6134 | MV best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */ |
| 6135 | |
| 6136 | best_ref_mv1_full.col = best_ref_mv1.col >> 3; |
| 6137 | best_ref_mv1_full.row = best_ref_mv1.row >> 3; |
| 6138 | |
| 6139 | // Setup frame pointers |
| 6140 | x->plane[0].src.buf = cur_frame_buf; |
| 6141 | x->plane[0].src.stride = stride; |
| 6142 | xd->plane[0].pre[0].buf = ref_frame_buf; |
| 6143 | xd->plane[0].pre[0].stride = stride; |
| 6144 | |
| 6145 | step_param = mv_sf->reduce_first_step_size; |
| 6146 | step_param = AOMMIN(step_param, MAX_MVSEARCH_STEPS - 2); |
| 6147 | |
| 6148 | av1_set_mv_search_range(&x->mv_limits, &best_ref_mv1); |
| 6149 | |
| 6150 | av1_full_pixel_search(cpi, x, bsize, &best_ref_mv1_full, step_param, |
| 6151 | search_method, 0, sadpb, cond_cost_list(cpi, cost_list), |
| 6152 | &best_ref_mv1, INT_MAX, 0, (MI_SIZE * mi_col), |
| 6153 | (MI_SIZE * mi_row), 0); |
| 6154 | |
| 6155 | /* restore UMV window */ |
| 6156 | x->mv_limits = tmp_mv_limits; |
| 6157 | |
| 6158 | const int pw = block_size_wide[bsize]; |
| 6159 | const int ph = block_size_high[bsize]; |
| 6160 | bestsme = cpi->find_fractional_mv_step( |
| 6161 | x, cm, mi_row, mi_col, &best_ref_mv1, cpi->common.allow_high_precision_mv, |
| 6162 | x->errorperbit, &cpi->fn_ptr[bsize], 0, mv_sf->subpel_iters_per_step, |
| 6163 | cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL, NULL, |
| 6164 | 0, 0, pw, ph, 1, 1); |
| 6165 | |
| 6166 | return bestsme; |
| 6167 | } |
| 6168 | |
Sarah Parker | cf64444 | 2018-10-11 15:23:44 -0700 | [diff] [blame] | 6169 | static int get_overlap_area(int grid_pos_row, int grid_pos_col, int ref_pos_row, |
| 6170 | int ref_pos_col, int block, BLOCK_SIZE bsize) { |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 6171 | int width = 0, height = 0; |
| 6172 | int bw = 4 << mi_size_wide_log2[bsize]; |
| 6173 | int bh = 4 << mi_size_high_log2[bsize]; |
| 6174 | |
| 6175 | switch (block) { |
| 6176 | case 0: |
| 6177 | width = grid_pos_col + bw - ref_pos_col; |
| 6178 | height = grid_pos_row + bh - ref_pos_row; |
| 6179 | break; |
| 6180 | case 1: |
| 6181 | width = ref_pos_col + bw - grid_pos_col; |
| 6182 | height = grid_pos_row + bh - ref_pos_row; |
| 6183 | break; |
| 6184 | case 2: |
| 6185 | width = grid_pos_col + bw - ref_pos_col; |
| 6186 | height = ref_pos_row + bh - grid_pos_row; |
| 6187 | break; |
| 6188 | case 3: |
| 6189 | width = ref_pos_col + bw - grid_pos_col; |
| 6190 | height = ref_pos_row + bh - grid_pos_row; |
| 6191 | break; |
| 6192 | default: assert(0); |
| 6193 | } |
| 6194 | |
| 6195 | return width * height; |
| 6196 | } |
| 6197 | |
Sarah Parker | cf64444 | 2018-10-11 15:23:44 -0700 | [diff] [blame] | 6198 | static int round_floor(int ref_pos, int bsize_pix) { |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 6199 | int round; |
| 6200 | if (ref_pos < 0) |
| 6201 | round = -(1 + (-ref_pos - 1) / bsize_pix); |
| 6202 | else |
| 6203 | round = ref_pos / bsize_pix; |
| 6204 | |
| 6205 | return round; |
| 6206 | } |
| 6207 | |
Sarah Parker | cf64444 | 2018-10-11 15:23:44 -0700 | [diff] [blame] | 6208 | static void tpl_model_store(TplDepStats *tpl_stats, int mi_row, int mi_col, |
| 6209 | BLOCK_SIZE bsize, int stride, |
| 6210 | const TplDepStats *src_stats) { |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 6211 | const int mi_height = mi_size_high[bsize]; |
| 6212 | const int mi_width = mi_size_wide[bsize]; |
| 6213 | int idx, idy; |
| 6214 | |
| 6215 | int64_t intra_cost = src_stats->intra_cost / (mi_height * mi_width); |
| 6216 | int64_t inter_cost = src_stats->inter_cost / (mi_height * mi_width); |
| 6217 | |
| 6218 | TplDepStats *tpl_ptr; |
| 6219 | |
| 6220 | intra_cost = AOMMAX(1, intra_cost); |
| 6221 | inter_cost = AOMMAX(1, inter_cost); |
| 6222 | |
| 6223 | for (idy = 0; idy < mi_height; ++idy) { |
| 6224 | tpl_ptr = &tpl_stats[(mi_row + idy) * stride + mi_col]; |
| 6225 | for (idx = 0; idx < mi_width; ++idx) { |
| 6226 | tpl_ptr->intra_cost = intra_cost; |
| 6227 | tpl_ptr->inter_cost = inter_cost; |
| 6228 | tpl_ptr->mc_dep_cost = tpl_ptr->intra_cost + tpl_ptr->mc_flow; |
| 6229 | tpl_ptr->ref_frame_index = src_stats->ref_frame_index; |
| 6230 | tpl_ptr->mv.as_int = src_stats->mv.as_int; |
| 6231 | ++tpl_ptr; |
| 6232 | } |
| 6233 | } |
| 6234 | } |
| 6235 | |
Sarah Parker | cf64444 | 2018-10-11 15:23:44 -0700 | [diff] [blame] | 6236 | static void tpl_model_update_b(TplDepFrame *tpl_frame, TplDepStats *tpl_stats, |
| 6237 | int mi_row, int mi_col, const BLOCK_SIZE bsize) { |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 6238 | TplDepFrame *ref_tpl_frame = &tpl_frame[tpl_stats->ref_frame_index]; |
| 6239 | TplDepStats *ref_stats = ref_tpl_frame->tpl_stats_ptr; |
| 6240 | MV mv = tpl_stats->mv.as_mv; |
| 6241 | int mv_row = mv.row >> 3; |
| 6242 | int mv_col = mv.col >> 3; |
| 6243 | |
| 6244 | int ref_pos_row = mi_row * MI_SIZE + mv_row; |
| 6245 | int ref_pos_col = mi_col * MI_SIZE + mv_col; |
| 6246 | |
| 6247 | const int bw = 4 << mi_size_wide_log2[bsize]; |
| 6248 | const int bh = 4 << mi_size_high_log2[bsize]; |
| 6249 | const int mi_height = mi_size_high[bsize]; |
| 6250 | const int mi_width = mi_size_wide[bsize]; |
| 6251 | const int pix_num = bw * bh; |
| 6252 | |
| 6253 | // top-left on grid block location in pixel |
| 6254 | int grid_pos_row_base = round_floor(ref_pos_row, bh) * bh; |
| 6255 | int grid_pos_col_base = round_floor(ref_pos_col, bw) * bw; |
| 6256 | int block; |
| 6257 | |
| 6258 | for (block = 0; block < 4; ++block) { |
| 6259 | int grid_pos_row = grid_pos_row_base + bh * (block >> 1); |
| 6260 | int grid_pos_col = grid_pos_col_base + bw * (block & 0x01); |
| 6261 | |
| 6262 | if (grid_pos_row >= 0 && grid_pos_row < ref_tpl_frame->mi_rows * MI_SIZE && |
| 6263 | grid_pos_col >= 0 && grid_pos_col < ref_tpl_frame->mi_cols * MI_SIZE) { |
| 6264 | int overlap_area = get_overlap_area( |
| 6265 | grid_pos_row, grid_pos_col, ref_pos_row, ref_pos_col, block, bsize); |
| 6266 | int ref_mi_row = round_floor(grid_pos_row, bh) * mi_height; |
| 6267 | int ref_mi_col = round_floor(grid_pos_col, bw) * mi_width; |
| 6268 | |
| 6269 | int64_t mc_flow = tpl_stats->mc_dep_cost - |
| 6270 | (tpl_stats->mc_dep_cost * tpl_stats->inter_cost) / |
| 6271 | tpl_stats->intra_cost; |
| 6272 | |
| 6273 | int idx, idy; |
| 6274 | |
| 6275 | for (idy = 0; idy < mi_height; ++idy) { |
| 6276 | for (idx = 0; idx < mi_width; ++idx) { |
| 6277 | TplDepStats *des_stats = |
| 6278 | &ref_stats[(ref_mi_row + idy) * ref_tpl_frame->stride + |
| 6279 | (ref_mi_col + idx)]; |
| 6280 | |
| 6281 | des_stats->mc_flow += (mc_flow * overlap_area) / pix_num; |
| 6282 | des_stats->mc_ref_cost += |
| 6283 | ((tpl_stats->intra_cost - tpl_stats->inter_cost) * overlap_area) / |
| 6284 | pix_num; |
| 6285 | assert(overlap_area >= 0); |
| 6286 | } |
| 6287 | } |
| 6288 | } |
| 6289 | } |
| 6290 | } |
| 6291 | |
Sarah Parker | cf64444 | 2018-10-11 15:23:44 -0700 | [diff] [blame] | 6292 | static void tpl_model_update(TplDepFrame *tpl_frame, TplDepStats *tpl_stats, |
| 6293 | int mi_row, int mi_col, const BLOCK_SIZE bsize) { |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 6294 | int idx, idy; |
| 6295 | const int mi_height = mi_size_high[bsize]; |
| 6296 | const int mi_width = mi_size_wide[bsize]; |
| 6297 | |
| 6298 | for (idy = 0; idy < mi_height; ++idy) { |
| 6299 | for (idx = 0; idx < mi_width; ++idx) { |
| 6300 | TplDepStats *tpl_ptr = |
| 6301 | &tpl_stats[(mi_row + idy) * tpl_frame->stride + (mi_col + idx)]; |
| 6302 | tpl_model_update_b(tpl_frame, tpl_ptr, mi_row + idy, mi_col + idx, |
| 6303 | BLOCK_4X4); |
| 6304 | } |
| 6305 | } |
| 6306 | } |
| 6307 | |
Sarah Parker | cf64444 | 2018-10-11 15:23:44 -0700 | [diff] [blame] | 6308 | static void get_quantize_error(MACROBLOCK *x, int plane, tran_low_t *coeff, |
| 6309 | tran_low_t *qcoeff, tran_low_t *dqcoeff, |
| 6310 | TX_SIZE tx_size, int64_t *recon_error, |
| 6311 | int64_t *sse) { |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 6312 | const struct macroblock_plane *const p = &x->plane[plane]; |
| 6313 | const SCAN_ORDER *const scan_order = &av1_default_scan_orders[tx_size]; |
| 6314 | uint16_t eob; |
| 6315 | int pix_num = 1 << num_pels_log2_lookup[txsize_to_bsize[tx_size]]; |
| 6316 | const int shift = tx_size == TX_32X32 ? 0 : 2; |
| 6317 | |
| 6318 | av1_quantize_fp_32x32(coeff, pix_num, p->zbin_QTX, p->round_fp_QTX, |
| 6319 | p->quant_fp_QTX, p->quant_shift_QTX, qcoeff, dqcoeff, |
| 6320 | p->dequant_QTX, &eob, scan_order->scan, |
| 6321 | scan_order->iscan); |
| 6322 | |
| 6323 | *recon_error = av1_block_error(coeff, dqcoeff, pix_num, sse) >> shift; |
| 6324 | *recon_error = AOMMAX(*recon_error, 1); |
| 6325 | |
| 6326 | *sse = (*sse) >> shift; |
| 6327 | *sse = AOMMAX(*sse, 1); |
| 6328 | } |
| 6329 | |
Sarah Parker | cf64444 | 2018-10-11 15:23:44 -0700 | [diff] [blame] | 6330 | static void wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff, |
| 6331 | TX_SIZE tx_size) { |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 6332 | switch (tx_size) { |
| 6333 | case TX_8X8: aom_hadamard_8x8(src_diff, bw, coeff); break; |
| 6334 | case TX_16X16: aom_hadamard_16x16(src_diff, bw, coeff); break; |
| 6335 | case TX_32X32: aom_hadamard_32x32(src_diff, bw, coeff); break; |
| 6336 | default: assert(0); |
| 6337 | } |
| 6338 | } |
| 6339 | |
Sarah Parker | cf64444 | 2018-10-11 15:23:44 -0700 | [diff] [blame] | 6340 | static void mode_estimation(AV1_COMP *cpi, MACROBLOCK *x, MACROBLOCKD *xd, |
| 6341 | struct scale_factors *sf, GF_PICTURE *gf_picture, |
| 6342 | int frame_idx, int16_t *src_diff, tran_low_t *coeff, |
| 6343 | tran_low_t *qcoeff, tran_low_t *dqcoeff, int mi_row, |
| 6344 | int mi_col, BLOCK_SIZE bsize, TX_SIZE tx_size, |
| 6345 | YV12_BUFFER_CONFIG *ref_frame[], uint8_t *predictor, |
| 6346 | int64_t *recon_error, int64_t *sse, |
| 6347 | TplDepStats *tpl_stats) { |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 6348 | AV1_COMMON *cm = &cpi->common; |
| 6349 | ThreadData *td = &cpi->td; |
| 6350 | |
| 6351 | const int bw = 4 << mi_size_wide_log2[bsize]; |
| 6352 | const int bh = 4 << mi_size_high_log2[bsize]; |
| 6353 | const int pix_num = bw * bh; |
| 6354 | int best_rf_idx = -1; |
| 6355 | int_mv best_mv; |
| 6356 | int64_t best_inter_cost = INT64_MAX; |
| 6357 | int64_t inter_cost; |
| 6358 | int rf_idx; |
| 6359 | const InterpFilters kernel = |
| 6360 | av1_make_interp_filters(EIGHTTAP_REGULAR, EIGHTTAP_REGULAR); |
| 6361 | |
| 6362 | int64_t best_intra_cost = INT64_MAX; |
| 6363 | int64_t intra_cost; |
| 6364 | PREDICTION_MODE mode; |
| 6365 | int mb_y_offset = mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE; |
| 6366 | MB_MODE_INFO mi_above, mi_left; |
| 6367 | |
| 6368 | memset(tpl_stats, 0, sizeof(*tpl_stats)); |
| 6369 | |
| 6370 | xd->mb_to_top_edge = -((mi_row * MI_SIZE) * 8); |
| 6371 | xd->mb_to_bottom_edge = ((cm->mi_rows - 1 - mi_row) * MI_SIZE) * 8; |
| 6372 | xd->mb_to_left_edge = -((mi_col * MI_SIZE) * 8); |
| 6373 | xd->mb_to_right_edge = ((cm->mi_cols - 1 - mi_col) * MI_SIZE) * 8; |
| 6374 | xd->above_mbmi = (mi_row > 0) ? &mi_above : NULL; |
| 6375 | xd->left_mbmi = (mi_col > 0) ? &mi_left : NULL; |
| 6376 | |
| 6377 | // Intra prediction search |
| 6378 | for (mode = DC_PRED; mode <= PAETH_PRED; ++mode) { |
| 6379 | uint8_t *src, *dst; |
| 6380 | int src_stride, dst_stride; |
| 6381 | |
| 6382 | src = xd->cur_buf->y_buffer + mb_y_offset; |
| 6383 | src_stride = xd->cur_buf->y_stride; |
| 6384 | |
| 6385 | dst = &predictor[0]; |
| 6386 | dst_stride = bw; |
| 6387 | |
| 6388 | xd->mi[0]->sb_type = bsize; |
| 6389 | xd->mi[0]->ref_frame[0] = INTRA_FRAME; |
| 6390 | |
| 6391 | av1_predict_intra_block( |
| 6392 | cm, xd, block_size_wide[bsize], block_size_high[bsize], tx_size, mode, |
| 6393 | 0, 0, FILTER_INTRA_MODES, src, src_stride, dst, dst_stride, 0, 0, 0); |
| 6394 | |
| 6395 | if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { |
| 6396 | aom_highbd_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst, |
| 6397 | dst_stride, xd->bd); |
| 6398 | } else { |
| 6399 | aom_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst, |
| 6400 | dst_stride); |
| 6401 | } |
| 6402 | |
| 6403 | wht_fwd_txfm(src_diff, bw, coeff, tx_size); |
| 6404 | |
| 6405 | intra_cost = aom_satd(coeff, pix_num); |
| 6406 | |
| 6407 | if (intra_cost < best_intra_cost) best_intra_cost = intra_cost; |
| 6408 | } |
| 6409 | |
| 6410 | // Motion compensated prediction |
| 6411 | best_mv.as_int = 0; |
| 6412 | |
| 6413 | (void)mb_y_offset; |
| 6414 | // Motion estimation column boundary |
| 6415 | x->mv_limits.col_min = -((mi_col * MI_SIZE) + (17 - 2 * AOM_INTERP_EXTEND)); |
| 6416 | x->mv_limits.col_max = |
| 6417 | ((cm->mi_cols - 1 - mi_col) * MI_SIZE) + (17 - 2 * AOM_INTERP_EXTEND); |
| 6418 | |
| 6419 | for (rf_idx = 0; rf_idx < 7; ++rf_idx) { |
| 6420 | if (ref_frame[rf_idx] == NULL) continue; |
| 6421 | |
| 6422 | motion_compensated_prediction(cpi, td, xd->cur_buf->y_buffer + mb_y_offset, |
| 6423 | ref_frame[rf_idx]->y_buffer + mb_y_offset, |
| 6424 | xd->cur_buf->y_stride, bsize, mi_row, mi_col); |
| 6425 | |
| 6426 | // TODO(jingning): Not yet support high bit-depth in the next three |
| 6427 | // steps. |
| 6428 | ConvolveParams conv_params = get_conv_params(0, 0, xd->bd); |
| 6429 | WarpTypesAllowed warp_types; |
| 6430 | memset(&warp_types, 0, sizeof(WarpTypesAllowed)); |
| 6431 | |
| 6432 | av1_build_inter_predictor( |
| 6433 | ref_frame[rf_idx]->y_buffer + mb_y_offset, ref_frame[rf_idx]->y_stride, |
| 6434 | &predictor[0], bw, &x->best_mv.as_mv, sf, bw, bh, &conv_params, kernel, |
| 6435 | &warp_types, mi_col * MI_SIZE, mi_row * MI_SIZE, 0, 0, MV_PRECISION_Q3, |
| 6436 | mi_col * MI_SIZE, mi_row * MI_SIZE, xd, 0); |
| 6437 | if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { |
| 6438 | aom_highbd_subtract_block( |
| 6439 | bh, bw, src_diff, bw, xd->cur_buf->y_buffer + mb_y_offset, |
| 6440 | xd->cur_buf->y_stride, &predictor[0], bw, xd->bd); |
| 6441 | } else { |
| 6442 | aom_subtract_block(bh, bw, src_diff, bw, |
| 6443 | xd->cur_buf->y_buffer + mb_y_offset, |
| 6444 | xd->cur_buf->y_stride, &predictor[0], bw); |
| 6445 | } |
| 6446 | wht_fwd_txfm(src_diff, bw, coeff, tx_size); |
| 6447 | |
| 6448 | inter_cost = aom_satd(coeff, pix_num); |
| 6449 | if (inter_cost < best_inter_cost) { |
| 6450 | best_rf_idx = rf_idx; |
| 6451 | best_inter_cost = inter_cost; |
| 6452 | best_mv.as_int = x->best_mv.as_int; |
| 6453 | get_quantize_error(x, 0, coeff, qcoeff, dqcoeff, tx_size, recon_error, |
| 6454 | sse); |
| 6455 | } |
| 6456 | } |
| 6457 | best_intra_cost = AOMMAX(best_intra_cost, 1); |
| 6458 | best_inter_cost = AOMMIN(best_intra_cost, best_inter_cost); |
| 6459 | tpl_stats->inter_cost = best_inter_cost << TPL_DEP_COST_SCALE_LOG2; |
| 6460 | tpl_stats->intra_cost = best_intra_cost << TPL_DEP_COST_SCALE_LOG2; |
| 6461 | tpl_stats->mc_dep_cost = tpl_stats->intra_cost + tpl_stats->mc_flow; |
| 6462 | |
| 6463 | tpl_stats->ref_frame_index = gf_picture[frame_idx].ref_frame[best_rf_idx]; |
| 6464 | tpl_stats->mv.as_int = best_mv.as_int; |
| 6465 | } |
| 6466 | |
Sarah Parker | cf64444 | 2018-10-11 15:23:44 -0700 | [diff] [blame] | 6467 | static void mc_flow_dispenser(AV1_COMP *cpi, GF_PICTURE *gf_picture, |
| 6468 | int frame_idx) { |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 6469 | TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx]; |
| 6470 | YV12_BUFFER_CONFIG *this_frame = gf_picture[frame_idx].frame; |
| 6471 | YV12_BUFFER_CONFIG *ref_frame[7] = { |
| 6472 | NULL, NULL, NULL, NULL, NULL, NULL, NULL |
| 6473 | }; |
| 6474 | |
| 6475 | AV1_COMMON *cm = &cpi->common; |
| 6476 | struct scale_factors sf; |
| 6477 | int rdmult, idx; |
| 6478 | ThreadData *td = &cpi->td; |
| 6479 | MACROBLOCK *x = &td->mb; |
| 6480 | MACROBLOCKD *xd = &x->e_mbd; |
| 6481 | int mi_row, mi_col; |
| 6482 | |
| 6483 | DECLARE_ALIGNED(16, uint16_t, predictor16[32 * 32 * 3]); |
| 6484 | DECLARE_ALIGNED(16, uint8_t, predictor8[32 * 32 * 3]); |
| 6485 | uint8_t *predictor; |
| 6486 | DECLARE_ALIGNED(16, int16_t, src_diff[32 * 32]); |
| 6487 | DECLARE_ALIGNED(16, tran_low_t, coeff[32 * 32]); |
| 6488 | DECLARE_ALIGNED(16, tran_low_t, qcoeff[32 * 32]); |
| 6489 | DECLARE_ALIGNED(16, tran_low_t, dqcoeff[32 * 32]); |
| 6490 | |
| 6491 | const BLOCK_SIZE bsize = BLOCK_32X32; |
| 6492 | const TX_SIZE tx_size = max_txsize_lookup[bsize]; |
| 6493 | const int mi_height = mi_size_high[bsize]; |
| 6494 | const int mi_width = mi_size_wide[bsize]; |
| 6495 | int64_t recon_error, sse; |
| 6496 | |
| 6497 | // Setup scaling factor |
| 6498 | av1_setup_scale_factors_for_frame( |
| 6499 | &sf, this_frame->y_crop_width, this_frame->y_crop_height, |
| 6500 | this_frame->y_crop_width, this_frame->y_crop_height); |
| 6501 | |
| 6502 | if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) |
| 6503 | predictor = CONVERT_TO_BYTEPTR(predictor16); |
| 6504 | else |
| 6505 | predictor = predictor8; |
| 6506 | |
| 6507 | // Prepare reference frame pointers. If any reference frame slot is |
| 6508 | // unavailable, the pointer will be set to Null. |
| 6509 | for (idx = 0; idx < 7; ++idx) { |
| 6510 | int rf_idx = gf_picture[frame_idx].ref_frame[idx]; |
| 6511 | if (rf_idx != -1) ref_frame[idx] = gf_picture[rf_idx].frame; |
| 6512 | } |
| 6513 | |
| 6514 | xd->mi = cm->mi_grid_visible; |
| 6515 | xd->mi[0] = cm->mi; |
| 6516 | xd->cur_buf = this_frame; |
| 6517 | |
| 6518 | // Get rd multiplier set up. |
| 6519 | rdmult = (int)av1_compute_rd_mult(cpi, tpl_frame->base_qindex); |
| 6520 | if (rdmult < 1) rdmult = 1; |
| 6521 | set_error_per_bit(&cpi->td.mb, rdmult); |
| 6522 | av1_initialize_me_consts(cpi, &cpi->td.mb, tpl_frame->base_qindex); |
| 6523 | |
| 6524 | tpl_frame->is_valid = 1; |
| 6525 | |
| 6526 | cm->base_qindex = tpl_frame->base_qindex; |
| 6527 | av1_frame_init_quantizer(cpi); |
| 6528 | |
| 6529 | for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) { |
| 6530 | // Motion estimation row boundary |
| 6531 | x->mv_limits.row_min = -((mi_row * MI_SIZE) + (17 - 2 * AOM_INTERP_EXTEND)); |
| 6532 | x->mv_limits.row_max = |
| 6533 | (cm->mi_rows - 1 - mi_row) * MI_SIZE + (17 - 2 * AOM_INTERP_EXTEND); |
| 6534 | for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) { |
| 6535 | TplDepStats tpl_stats; |
| 6536 | mode_estimation(cpi, x, xd, &sf, gf_picture, frame_idx, src_diff, coeff, |
| 6537 | qcoeff, dqcoeff, mi_row, mi_col, bsize, tx_size, |
| 6538 | ref_frame, predictor, &recon_error, &sse, &tpl_stats); |
| 6539 | |
| 6540 | // Motion flow dependency dispenser. |
| 6541 | tpl_model_store(tpl_frame->tpl_stats_ptr, mi_row, mi_col, bsize, |
| 6542 | tpl_frame->stride, &tpl_stats); |
| 6543 | |
| 6544 | tpl_model_update(cpi->tpl_stats, tpl_frame->tpl_stats_ptr, mi_row, mi_col, |
| 6545 | bsize); |
| 6546 | } |
| 6547 | } |
| 6548 | } |
| 6549 | |
| 6550 | static void setup_tpl_stats(AV1_COMP *cpi) { |
| 6551 | GF_PICTURE gf_picture[MAX_LAG_BUFFERS]; |
| 6552 | const GF_GROUP *gf_group = &cpi->twopass.gf_group; |
| 6553 | int tpl_group_frames = 0; |
| 6554 | int frame_idx; |
| 6555 | |
| 6556 | init_gop_frames(cpi, gf_picture, gf_group, &tpl_group_frames); |
| 6557 | |
| 6558 | init_tpl_stats(cpi); |
| 6559 | |
| 6560 | // Backward propagation from tpl_group_frames to 1. |
| 6561 | for (frame_idx = tpl_group_frames - 1; frame_idx > 0; --frame_idx) |
| 6562 | mc_flow_dispenser(cpi, gf_picture, frame_idx); |
| 6563 | } |
| 6564 | |
David Turner | 0308a5a | 2019-01-07 10:36:16 +0000 | [diff] [blame^] | 6565 | // Determine whether there is a forced keyframe pending in the lookahead buffer |
| 6566 | static int is_forced_keyframe_pending(struct lookahead_ctx *lookahead, |
| 6567 | const int up_to_index) { |
| 6568 | for (int i = 0; i <= up_to_index; i++) { |
| 6569 | const struct lookahead_entry *e = av1_lookahead_peek(lookahead, i); |
| 6570 | if (e == NULL) { |
| 6571 | // We have reached the end of the lookahead buffer and not early-returned |
| 6572 | // so there isn't a forced key-frame pending. |
| 6573 | return 0; |
| 6574 | } else if (e->flags == AOM_EFLAG_FORCE_KF) { |
| 6575 | return 1; |
| 6576 | } else { |
| 6577 | continue; |
| 6578 | } |
| 6579 | } |
| 6580 | return 0; // Never reached |
| 6581 | } |
| 6582 | |
| 6583 | // Don't allow a show_existing_frame to coincide with an error resilient or |
| 6584 | // S-Frame. An exception can be made in the case of a keyframe, since it does |
| 6585 | // not depend on any previous frames. |
| 6586 | static int allow_show_existing(const AV1_COMP *const cpi) { |
| 6587 | if (cpi->common.current_frame.frame_number == 0) return 0; |
| 6588 | |
| 6589 | const struct lookahead_entry *lookahead_src = |
| 6590 | av1_lookahead_peek(cpi->lookahead, 0); |
| 6591 | if (lookahead_src == NULL) return 1; |
| 6592 | |
| 6593 | const int is_error_resilient = |
| 6594 | cpi->oxcf.error_resilient_mode || |
| 6595 | (lookahead_src->flags & AOM_EFLAG_ERROR_RESILIENT); |
| 6596 | const int is_s_frame = |
| 6597 | cpi->oxcf.s_frame_mode || (lookahead_src->flags & AOM_EFLAG_SET_S_FRAME); |
| 6598 | const int is_key_frame = |
| 6599 | (cpi->rc.frames_to_key == 0) || (cpi->frame_flags & FRAMEFLAGS_KEY); |
| 6600 | return !(is_error_resilient || is_s_frame) || is_key_frame; |
| 6601 | } |
| 6602 | |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 6603 | int av1_get_compressed_data(AV1_COMP *cpi, unsigned int *frame_flags, |
| 6604 | size_t *size, uint8_t *dest, int64_t *time_stamp, |
| 6605 | int64_t *time_end, int flush, |
| 6606 | const aom_rational_t *timebase) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6607 | const AV1EncoderConfig *const oxcf = &cpi->oxcf; |
| 6608 | AV1_COMMON *const cm = &cpi->common; |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 6609 | CurrentFrame *const current_frame = &cm->current_frame; |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 6610 | const int num_planes = av1_num_planes(cm); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6611 | RATE_CONTROL *const rc = &cpi->rc; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6612 | struct aom_usec_timer cmptimer; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6613 | YV12_BUFFER_CONFIG *force_src_buffer = NULL; |
| 6614 | struct lookahead_entry *last_source = NULL; |
| 6615 | struct lookahead_entry *source = NULL; |
| 6616 | int arf_src_index; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6617 | int brf_src_index; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6618 | int i; |
| 6619 | |
| 6620 | #if CONFIG_BITSTREAM_DEBUG |
| 6621 | assert(cpi->oxcf.max_threads == 0 && |
| 6622 | "bitstream debug tool does not support multithreading"); |
| 6623 | bitstream_queue_record_write(); |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 6624 | bitstream_queue_set_frame_write(current_frame->frame_number * 2 + |
| 6625 | cm->show_frame); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6626 | #endif |
| 6627 | |
Dominic Symes | d492901 | 2018-01-31 17:32:01 +0100 | [diff] [blame] | 6628 | cm->showable_frame = 0; |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6629 | aom_usec_timer_start(&cmptimer); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6630 | |
RogerZhou | 3b63524 | 2017-09-19 10:06:46 -0700 | [diff] [blame] | 6631 | set_high_precision_mv(cpi, ALTREF_HIGH_PRECISION_MV, 0); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6632 | |
Debargha Mukherjee | ba7b8fe | 2018-03-15 23:10:07 -0700 | [diff] [blame] | 6633 | // Normal defaults |
sarahparker | 27d686a | 2018-03-30 17:43:44 -0700 | [diff] [blame] | 6634 | cm->refresh_frame_context = oxcf->frame_parallel_decoding_mode |
| 6635 | ? REFRESH_FRAME_CONTEXT_DISABLED |
| 6636 | : REFRESH_FRAME_CONTEXT_BACKWARD; |
Rupert Swarbrick | 84b05ac | 2017-10-27 18:10:53 +0100 | [diff] [blame] | 6637 | if (oxcf->large_scale_tile) |
James Zern | f34dfc8 | 2018-02-23 16:53:33 -0800 | [diff] [blame] | 6638 | cm->refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6639 | |
Wei-Ting Lin | 2e8d045 | 2018-06-27 09:32:39 -0700 | [diff] [blame] | 6640 | // default reference buffers update config |
| 6641 | av1_configure_buffer_updates_firstpass(cpi, LF_UPDATE); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6642 | |
Sarah Parker | b904161 | 2018-05-22 19:06:47 -0700 | [diff] [blame] | 6643 | // Initialize fields related to forward keyframes |
Sarah Parker | af32a7b | 2018-06-29 14:59:05 -0700 | [diff] [blame] | 6644 | cpi->no_show_kf = 0; |
Zoe Liu | b499120 | 2017-12-21 15:31:06 -0800 | [diff] [blame] | 6645 | cm->reset_decoder_state = 0; |
Zoe Liu | b499120 | 2017-12-21 15:31:06 -0800 | [diff] [blame] | 6646 | |
David Turner | 0308a5a | 2019-01-07 10:36:16 +0000 | [diff] [blame^] | 6647 | if (oxcf->pass == 2 && cm->show_existing_frame && allow_show_existing(cpi)) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6648 | // Manage the source buffer and flush out the source frame that has been |
| 6649 | // coded already; Also get prepared for PSNR calculation if needed. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6650 | if ((source = av1_lookahead_pop(cpi->lookahead, flush)) == NULL) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6651 | *size = 0; |
| 6652 | return -1; |
| 6653 | } |
sarahparker | 21dbca4 | 2018-03-30 17:43:44 -0700 | [diff] [blame] | 6654 | av1_apply_encoding_flags(cpi, source->flags); |
Alex Converse | f77fd0b | 2017-04-20 11:00:24 -0700 | [diff] [blame] | 6655 | cpi->source = &source->img; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6656 | // TODO(zoeliu): To track down to determine whether it's needed to adjust |
| 6657 | // the frame rate. |
| 6658 | *time_stamp = source->ts_start; |
| 6659 | *time_end = source->ts_end; |
| 6660 | |
| 6661 | // We need to adjust frame rate for an overlay frame |
Zoe Liu | e04abf7 | 2017-04-19 15:37:11 -0700 | [diff] [blame] | 6662 | if (cpi->rc.is_src_frame_alt_ref) adjust_frame_rate(cpi, source); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6663 | |
David Turner | 0308a5a | 2019-01-07 10:36:16 +0000 | [diff] [blame^] | 6664 | if (assign_cur_frame_new_fb(cm) == NULL) return -1; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6665 | |
| 6666 | // Clear down mmx registers |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6667 | aom_clear_system_state(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6668 | |
| 6669 | // Start with a 0 size frame. |
| 6670 | *size = 0; |
| 6671 | |
| 6672 | // We need to update the gf_group for show_existing overlay frame |
Zoe Liu | e04abf7 | 2017-04-19 15:37:11 -0700 | [diff] [blame] | 6673 | if (cpi->rc.is_src_frame_alt_ref) av1_rc_get_second_pass_params(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6674 | |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 6675 | if (Pass2Encode(cpi, size, dest, frame_flags) != AOM_CODEC_OK) |
| 6676 | return AOM_CODEC_ERROR; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6677 | |
| 6678 | if (cpi->b_calculate_psnr) generate_psnr_packet(cpi); |
| 6679 | |
| 6680 | #if CONFIG_INTERNAL_STATS |
Angie Chiang | 08a22a6 | 2017-07-17 17:29:17 -0700 | [diff] [blame] | 6681 | compute_internal_stats(cpi, (int)(*size)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6682 | #endif // CONFIG_INTERNAL_STATS |
| 6683 | |
| 6684 | // Clear down mmx registers |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6685 | aom_clear_system_state(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6686 | |
| 6687 | cm->show_existing_frame = 0; |
| 6688 | return 0; |
| 6689 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6690 | |
| 6691 | // Should we encode an arf frame. |
| 6692 | arf_src_index = get_arf_src_index(cpi); |
David Turner | 0308a5a | 2019-01-07 10:36:16 +0000 | [diff] [blame^] | 6693 | if (arf_src_index && |
| 6694 | is_forced_keyframe_pending(cpi->lookahead, arf_src_index)) { |
| 6695 | arf_src_index = 0; |
| 6696 | flush = 1; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6697 | } |
| 6698 | |
| 6699 | if (arf_src_index) { |
| 6700 | assert(arf_src_index <= rc->frames_to_key); |
| 6701 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6702 | if ((source = av1_lookahead_peek(cpi->lookahead, arf_src_index)) != NULL) { |
Dominic Symes | d492901 | 2018-01-31 17:32:01 +0100 | [diff] [blame] | 6703 | cm->showable_frame = 1; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6704 | cpi->alt_ref_source = source; |
Sarah Parker | af32a7b | 2018-06-29 14:59:05 -0700 | [diff] [blame] | 6705 | // When arf_src_index == rc->frames_to_key, it indicates a fwd_kf |
Sarah Parker | b904161 | 2018-05-22 19:06:47 -0700 | [diff] [blame] | 6706 | if (arf_src_index == rc->frames_to_key) { |
| 6707 | // Skip temporal filtering and mark as intra_only if we have a fwd_kf |
| 6708 | const GF_GROUP *const gf_group = &cpi->twopass.gf_group; |
| 6709 | int which_arf = gf_group->arf_update_idx[gf_group->index]; |
| 6710 | cpi->is_arf_filter_off[which_arf] = 1; |
Sarah Parker | af32a7b | 2018-06-29 14:59:05 -0700 | [diff] [blame] | 6711 | cpi->no_show_kf = 1; |
Sarah Parker | b904161 | 2018-05-22 19:06:47 -0700 | [diff] [blame] | 6712 | } else { |
| 6713 | if (oxcf->arnr_max_frames > 0) { |
| 6714 | // Produce the filtered ARF frame. |
| 6715 | av1_temporal_filter(cpi, arf_src_index); |
| 6716 | aom_extend_frame_borders(&cpi->alt_ref_buffer, num_planes); |
| 6717 | force_src_buffer = &cpi->alt_ref_buffer; |
| 6718 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6719 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6720 | cm->show_frame = 0; |
Wei-Ting Lin | 2e8d045 | 2018-06-27 09:32:39 -0700 | [diff] [blame] | 6721 | |
| 6722 | if (oxcf->pass < 2) { |
| 6723 | // In second pass, the buffer updates configure will be set |
| 6724 | // in the function av1_rc_get_second_pass_params |
| 6725 | av1_configure_buffer_updates_firstpass(cpi, ARF_UPDATE); |
| 6726 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6727 | } |
| 6728 | rc->source_alt_ref_pending = 0; |
| 6729 | } |
| 6730 | |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 6731 | // Should we encode an arf2 frame. |
| 6732 | arf_src_index = get_arf2_src_index(cpi); |
David Turner | 0308a5a | 2019-01-07 10:36:16 +0000 | [diff] [blame^] | 6733 | if (arf_src_index && |
| 6734 | is_forced_keyframe_pending(cpi->lookahead, arf_src_index)) { |
| 6735 | arf_src_index = 0; |
| 6736 | flush = 1; |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 6737 | } |
| 6738 | |
| 6739 | if (arf_src_index) { |
| 6740 | assert(arf_src_index <= rc->frames_to_key); |
| 6741 | |
| 6742 | if ((source = av1_lookahead_peek(cpi->lookahead, arf_src_index)) != NULL) { |
Dominic Symes | d492901 | 2018-01-31 17:32:01 +0100 | [diff] [blame] | 6743 | cm->showable_frame = 1; |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 6744 | cpi->alt_ref_source = source; |
| 6745 | |
| 6746 | if (oxcf->arnr_max_frames > 0) { |
| 6747 | // Produce the filtered ARF frame. |
Sebastien Alaiwan | 6697acf | 2018-02-21 16:59:17 +0100 | [diff] [blame] | 6748 | av1_temporal_filter(cpi, arf_src_index); |
Imdad Sardharwalla | af8e264 | 2018-01-19 11:46:34 +0000 | [diff] [blame] | 6749 | aom_extend_frame_borders(&cpi->alt_ref_buffer, num_planes); |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 6750 | force_src_buffer = &cpi->alt_ref_buffer; |
| 6751 | } |
| 6752 | |
| 6753 | cm->show_frame = 0; |
Wei-Ting Lin | 2e8d045 | 2018-06-27 09:32:39 -0700 | [diff] [blame] | 6754 | |
| 6755 | if (oxcf->pass < 2) { |
| 6756 | // In second pass, the buffer updates configure will be set |
| 6757 | // in the function av1_rc_get_second_pass_params |
| 6758 | av1_configure_buffer_updates_firstpass(cpi, INTNL_ARF_UPDATE); |
| 6759 | } |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 6760 | } |
| 6761 | rc->source_alt_ref_pending = 0; |
| 6762 | } |
Zoe Liu | e9b15e2 | 2017-07-19 15:53:01 -0700 | [diff] [blame] | 6763 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6764 | rc->is_bwd_ref_frame = 0; |
| 6765 | brf_src_index = get_brf_src_index(cpi); |
| 6766 | if (brf_src_index) { |
| 6767 | assert(brf_src_index <= rc->frames_to_key); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6768 | if ((source = av1_lookahead_peek(cpi->lookahead, brf_src_index)) != NULL) { |
Dominic Symes | d492901 | 2018-01-31 17:32:01 +0100 | [diff] [blame] | 6769 | cm->showable_frame = 1; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6770 | cm->show_frame = 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6771 | |
Wei-Ting Lin | 2e8d045 | 2018-06-27 09:32:39 -0700 | [diff] [blame] | 6772 | if (oxcf->pass < 2) { |
| 6773 | // In second pass, the buffer updates configure will be set |
| 6774 | // in the function av1_rc_get_second_pass_params |
| 6775 | av1_configure_buffer_updates_firstpass(cpi, BIPRED_UPDATE); |
| 6776 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6777 | } |
| 6778 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6779 | |
| 6780 | if (!source) { |
| 6781 | // Get last frame source. |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 6782 | if (current_frame->frame_number > 0) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6783 | if ((last_source = av1_lookahead_peek(cpi->lookahead, -1)) == NULL) |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6784 | return -1; |
| 6785 | } |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 6786 | if (current_frame->frame_number > 0) assert(last_source != NULL); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6787 | // Read in the source frame. |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6788 | source = av1_lookahead_pop(cpi->lookahead, flush); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6789 | |
| 6790 | if (source != NULL) { |
| 6791 | cm->show_frame = 1; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6792 | |
| 6793 | // Check to see if the frame should be encoded as an arf overlay. |
| 6794 | check_src_altref(cpi, source); |
| 6795 | } |
| 6796 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6797 | if (source) { |
Fergus Simpson | d2bcbb5 | 2017-05-22 23:15:05 -0700 | [diff] [blame] | 6798 | cpi->unscaled_source = cpi->source = |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6799 | force_src_buffer ? force_src_buffer : &source->img; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6800 | cpi->unscaled_last_source = last_source != NULL ? &last_source->img : NULL; |
| 6801 | |
| 6802 | *time_stamp = source->ts_start; |
| 6803 | *time_end = source->ts_end; |
Sarah Parker | 7355677 | 2018-03-28 18:28:05 -0700 | [diff] [blame] | 6804 | av1_apply_encoding_flags(cpi, source->flags); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6805 | *frame_flags = (source->flags & AOM_EFLAG_FORCE_KF) ? FRAMEFLAGS_KEY : 0; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6806 | |
| 6807 | } else { |
| 6808 | *size = 0; |
| 6809 | if (flush && oxcf->pass == 1 && !cpi->twopass.first_pass_done) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6810 | av1_end_first_pass(cpi); /* get last stats packet */ |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6811 | cpi->twopass.first_pass_done = 1; |
| 6812 | } |
| 6813 | return -1; |
| 6814 | } |
| 6815 | |
| 6816 | if (source->ts_start < cpi->first_time_stamp_ever) { |
| 6817 | cpi->first_time_stamp_ever = source->ts_start; |
| 6818 | cpi->last_end_time_stamp_seen = source->ts_start; |
| 6819 | } |
| 6820 | |
| 6821 | // Clear down mmx registers |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6822 | aom_clear_system_state(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6823 | |
| 6824 | // adjust frame rates based on timestamps given |
| 6825 | if (cm->show_frame) adjust_frame_rate(cpi, source); |
| 6826 | |
David Turner | 0308a5a | 2019-01-07 10:36:16 +0000 | [diff] [blame^] | 6827 | if (assign_cur_frame_new_fb(cm) == NULL) return -1; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6828 | |
Zoe Liu | f452fdf | 2017-11-02 23:08:12 -0700 | [diff] [blame] | 6829 | // Retain the RF_LEVEL for the current newly coded frame. |
David Turner | 1bcefb3 | 2018-11-19 17:54:00 +0000 | [diff] [blame] | 6830 | cm->cur_frame->frame_rf_level = |
Zoe Liu | f452fdf | 2017-11-02 23:08:12 -0700 | [diff] [blame] | 6831 | cpi->twopass.gf_group.rf_level[cpi->twopass.gf_group.index]; |
Zoe Liu | f452fdf | 2017-11-02 23:08:12 -0700 | [diff] [blame] | 6832 | |
Yaowu Xu | 9b0f703 | 2017-07-31 11:01:19 -0700 | [diff] [blame] | 6833 | cm->cur_frame->buf.buf_8bit_valid = 0; |
Neil Birkbeck | eb895ef | 2018-03-14 17:51:03 -0700 | [diff] [blame] | 6834 | |
Neil Birkbeck | a2893ab | 2018-06-08 14:45:13 -0700 | [diff] [blame] | 6835 | if (cpi->film_grain_table) { |
Urvang Joshi | 8d5a4ba | 2018-07-19 16:26:34 -0700 | [diff] [blame] | 6836 | cm->seq_params.film_grain_params_present = aom_film_grain_table_lookup( |
Neil Birkbeck | a2893ab | 2018-06-08 14:45:13 -0700 | [diff] [blame] | 6837 | cpi->film_grain_table, *time_stamp, *time_end, 0 /* =erase */, |
Neil Birkbeck | eb895ef | 2018-03-14 17:51:03 -0700 | [diff] [blame] | 6838 | &cm->film_grain_params); |
| 6839 | } |
Urvang Joshi | 8d5a4ba | 2018-07-19 16:26:34 -0700 | [diff] [blame] | 6840 | cm->cur_frame->film_grain_params_present = |
| 6841 | cm->seq_params.film_grain_params_present; |
Zoe Liu | 6cfaff9 | 2016-10-18 17:12:11 -0700 | [diff] [blame] | 6842 | |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 6843 | // only one operating point supported now |
Wan-Teh Chang | f64b3bc | 2018-07-02 09:42:39 -0700 | [diff] [blame] | 6844 | const int64_t pts64 = ticks_to_timebase_units(timebase, *time_stamp); |
| 6845 | if (pts64 < 0 || pts64 > UINT32_MAX) return AOM_CODEC_ERROR; |
| 6846 | cpi->common.frame_presentation_time = (uint32_t)pts64; |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 6847 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6848 | // Start with a 0 size frame. |
| 6849 | *size = 0; |
| 6850 | |
| 6851 | cpi->frame_flags = *frame_flags; |
| 6852 | |
| 6853 | if (oxcf->pass == 2) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6854 | av1_rc_get_second_pass_params(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6855 | } else if (oxcf->pass == 1) { |
Fergus Simpson | bc18993 | 2017-05-16 17:02:39 -0700 | [diff] [blame] | 6856 | setup_frame_size(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6857 | } |
| 6858 | |
| 6859 | if (cpi->oxcf.pass != 0 || frame_is_intra_only(cm) == 1) { |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 6860 | for (i = 0; i < INTER_REFS_PER_FRAME; ++i) cpi->scaled_ref_buf[i] = NULL; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6861 | } |
| 6862 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6863 | cm->using_qmatrix = cpi->oxcf.using_qm; |
| 6864 | cm->min_qmlevel = cpi->oxcf.qm_minlevel; |
| 6865 | cm->max_qmlevel = cpi->oxcf.qm_maxlevel; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6866 | |
David Turner | 936235c | 2018-11-28 13:42:01 +0000 | [diff] [blame] | 6867 | if (cm->seq_params.frame_id_numbers_present_flag && *time_stamp == 0) { |
| 6868 | cpi->common.current_frame_id = -1; |
Arild Fuldseth (arilfuld) | 5114b7b | 2016-11-09 13:32:54 +0100 | [diff] [blame] | 6869 | } |
Zoe Liu | ca0cd3f | 2018-02-26 15:07:50 -0800 | [diff] [blame] | 6870 | |
Debargha Mukherjee | e41a667 | 2018-02-27 11:56:31 -0800 | [diff] [blame] | 6871 | if (oxcf->pass != 1 && cpi->common.allow_screen_content_tools && |
| 6872 | !frame_is_intra_only(cm)) { |
Imdad Sardharwalla | bf2cc01 | 2018-02-09 17:32:10 +0000 | [diff] [blame] | 6873 | if (cpi->common.seq_params.force_integer_mv == 2) { |
RogerZhou | 3b63524 | 2017-09-19 10:06:46 -0700 | [diff] [blame] | 6874 | struct lookahead_entry *previous_entry = |
Debargha Mukherjee | a71e3db | 2018-02-28 07:47:17 -0800 | [diff] [blame] | 6875 | av1_lookahead_peek(cpi->lookahead, cpi->previous_index); |
| 6876 | if (!previous_entry) |
| 6877 | cpi->common.cur_frame_force_integer_mv = 0; |
| 6878 | else |
| 6879 | cpi->common.cur_frame_force_integer_mv = is_integer_mv( |
| 6880 | cpi, cpi->source, &previous_entry->img, cpi->previous_hash_table); |
RogerZhou | 3b63524 | 2017-09-19 10:06:46 -0700 | [diff] [blame] | 6881 | } else { |
Imdad Sardharwalla | bf2cc01 | 2018-02-09 17:32:10 +0000 | [diff] [blame] | 6882 | cpi->common.cur_frame_force_integer_mv = |
| 6883 | cpi->common.seq_params.force_integer_mv; |
RogerZhou | 3b63524 | 2017-09-19 10:06:46 -0700 | [diff] [blame] | 6884 | } |
| 6885 | } else { |
RogerZhou | 10a0380 | 2017-10-26 11:49:48 -0700 | [diff] [blame] | 6886 | cpi->common.cur_frame_force_integer_mv = 0; |
RogerZhou | 3b63524 | 2017-09-19 10:06:46 -0700 | [diff] [blame] | 6887 | } |
Arild Fuldseth (arilfuld) | 5114b7b | 2016-11-09 13:32:54 +0100 | [diff] [blame] | 6888 | |
Yue Chen | 7cae98f | 2018-08-24 10:43:16 -0700 | [diff] [blame] | 6889 | if (cpi->twopass.gf_group.index == 1 && cpi->oxcf.enable_tpl_model) { |
| 6890 | set_frame_size(cpi, cm->width, cm->height); |
| 6891 | setup_tpl_stats(cpi); |
| 6892 | } |
| 6893 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6894 | if (oxcf->pass == 1) { |
| 6895 | cpi->td.mb.e_mbd.lossless[0] = is_lossless_requested(oxcf); |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6896 | av1_first_pass(cpi, source); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6897 | } else if (oxcf->pass == 2) { |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 6898 | if (Pass2Encode(cpi, size, dest, frame_flags) != AOM_CODEC_OK) |
| 6899 | return AOM_CODEC_ERROR; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6900 | } else { |
| 6901 | // One pass encode |
David Turner | 056f7cd | 2019-01-07 17:48:13 +0000 | [diff] [blame] | 6902 | if (Pass0Encode(cpi, size, dest, frame_flags) != AOM_CODEC_OK) |
Tom Finegan | e4099e3 | 2018-01-23 12:01:51 -0800 | [diff] [blame] | 6903 | return AOM_CODEC_ERROR; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6904 | } |
RogerZhou | cc5d35d | 2017-08-07 22:20:15 -0700 | [diff] [blame] | 6905 | if (oxcf->pass != 1 && cpi->common.allow_screen_content_tools) { |
Debargha Mukherjee | e41a667 | 2018-02-27 11:56:31 -0800 | [diff] [blame] | 6906 | cpi->previous_hash_table = &cm->cur_frame->hash_table; |
RogerZhou | 3b63524 | 2017-09-19 10:06:46 -0700 | [diff] [blame] | 6907 | { |
| 6908 | int l; |
| 6909 | for (l = -MAX_PRE_FRAMES; l < cpi->lookahead->max_sz; l++) { |
| 6910 | if ((cpi->lookahead->buf + l) == source) { |
Debargha Mukherjee | e41a667 | 2018-02-27 11:56:31 -0800 | [diff] [blame] | 6911 | cpi->previous_index = l; |
RogerZhou | 3b63524 | 2017-09-19 10:06:46 -0700 | [diff] [blame] | 6912 | break; |
| 6913 | } |
| 6914 | } |
| 6915 | |
| 6916 | if (l == cpi->lookahead->max_sz) { |
| 6917 | aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
| 6918 | "Failed to find last frame original buffer"); |
| 6919 | } |
| 6920 | } |
RogerZhou | cc5d35d | 2017-08-07 22:20:15 -0700 | [diff] [blame] | 6921 | } |
| 6922 | |
Yunqing Wang | 267e327 | 2017-11-09 14:23:22 -0800 | [diff] [blame] | 6923 | if (!cm->large_scale_tile) { |
David Turner | 1bcefb3 | 2018-11-19 17:54:00 +0000 | [diff] [blame] | 6924 | cm->cur_frame->frame_context = *cm->fc; |
Yunqing Wang | 267e327 | 2017-11-09 14:23:22 -0800 | [diff] [blame] | 6925 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6926 | |
Yunqing Wang | b041d8a | 2017-11-15 12:31:18 -0800 | [diff] [blame] | 6927 | #define EXT_TILE_DEBUG 0 |
| 6928 | #if EXT_TILE_DEBUG |
| 6929 | if (cm->large_scale_tile && oxcf->pass == 2) { |
| 6930 | char fn[20] = "./fc"; |
David Turner | d2a592e | 2018-11-16 14:59:31 +0000 | [diff] [blame] | 6931 | fn[4] = current_frame->frame_number / 100 + '0'; |
| 6932 | fn[5] = (current_frame->frame_number % 100) / 10 + '0'; |
| 6933 | fn[6] = (current_frame->frame_number % 10) + '0'; |
Yunqing Wang | b041d8a | 2017-11-15 12:31:18 -0800 | [diff] [blame] | 6934 | fn[7] = '\0'; |
| 6935 | av1_print_frame_contexts(cm->fc, fn); |
| 6936 | } |
| 6937 | #endif // EXT_TILE_DEBUG |
| 6938 | #undef EXT_TILE_DEBUG |
Yaowu Xu | c7119a7 | 2018-03-29 09:59:37 -0700 | [diff] [blame] | 6939 | |
Dominic Symes | d492901 | 2018-01-31 17:32:01 +0100 | [diff] [blame] | 6940 | cm->showable_frame = !cm->show_frame && cm->showable_frame; |
Yunqing Wang | b041d8a | 2017-11-15 12:31:18 -0800 | [diff] [blame] | 6941 | |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6942 | // No frame encoded, or frame was dropped, release scaled references. |
| 6943 | if ((*size == 0) && (frame_is_intra_only(cm) == 0)) { |
| 6944 | release_scaled_references(cpi); |
| 6945 | } |
| 6946 | |
| 6947 | if (*size > 0) { |
Debargha Mukherjee | 8adee10 | 2018-09-25 11:01:00 -0700 | [diff] [blame] | 6948 | cpi->droppable = is_frame_droppable(cpi); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6949 | } |
| 6950 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6951 | aom_usec_timer_mark(&cmptimer); |
| 6952 | cpi->time_compress_data += aom_usec_timer_elapsed(&cmptimer); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6953 | |
| 6954 | if (cpi->b_calculate_psnr && oxcf->pass != 1 && cm->show_frame) |
| 6955 | generate_psnr_packet(cpi); |
| 6956 | |
| 6957 | #if CONFIG_INTERNAL_STATS |
| 6958 | if (oxcf->pass != 1) { |
Angie Chiang | 08a22a6 | 2017-07-17 17:29:17 -0700 | [diff] [blame] | 6959 | compute_internal_stats(cpi, (int)(*size)); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6960 | } |
| 6961 | #endif // CONFIG_INTERNAL_STATS |
Debargha Mukherjee | 0857e66 | 2019-01-04 16:22:09 -0800 | [diff] [blame] | 6962 | #if CONFIG_SPEED_STATS |
| 6963 | if (cpi->oxcf.pass != 1) { |
| 6964 | cpi->tx_search_count += cpi->td.mb.tx_search_count; |
| 6965 | cpi->td.mb.tx_search_count = 0; |
| 6966 | } |
| 6967 | #endif // CONFIG_SPEED_STATS |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6968 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6969 | aom_clear_system_state(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6970 | |
| 6971 | return 0; |
| 6972 | } |
| 6973 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6974 | int av1_get_preview_raw_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *dest) { |
| 6975 | AV1_COMMON *cm = &cpi->common; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6976 | if (!cm->show_frame) { |
| 6977 | return -1; |
| 6978 | } else { |
| 6979 | int ret; |
David Turner | c29e1a9 | 2018-12-06 14:10:14 +0000 | [diff] [blame] | 6980 | if (cm->cur_frame != NULL) { |
| 6981 | *dest = cm->cur_frame->buf; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6982 | dest->y_width = cm->width; |
| 6983 | dest->y_height = cm->height; |
Urvang Joshi | 20cf30e | 2018-07-19 02:33:58 -0700 | [diff] [blame] | 6984 | dest->uv_width = cm->width >> cm->seq_params.subsampling_x; |
| 6985 | dest->uv_height = cm->height >> cm->seq_params.subsampling_y; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6986 | ret = 0; |
| 6987 | } else { |
| 6988 | ret = -1; |
| 6989 | } |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6990 | aom_clear_system_state(); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6991 | return ret; |
| 6992 | } |
| 6993 | } |
| 6994 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 6995 | 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] | 6996 | if (cpi->last_show_frame_buf == NULL) return -1; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6997 | |
David Turner | e7ebf90 | 2018-12-04 14:04:55 +0000 | [diff] [blame] | 6998 | *frame = cpi->last_show_frame_buf->buf; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 6999 | return 0; |
| 7000 | } |
| 7001 | |
Yunqing Wang | ff9bfca | 2018-06-06 11:46:08 -0700 | [diff] [blame] | 7002 | static int equal_dimensions_and_border(const YV12_BUFFER_CONFIG *a, |
| 7003 | const YV12_BUFFER_CONFIG *b) { |
| 7004 | return a->y_height == b->y_height && a->y_width == b->y_width && |
| 7005 | a->uv_height == b->uv_height && a->uv_width == b->uv_width && |
| 7006 | a->y_stride == b->y_stride && a->uv_stride == b->uv_stride && |
| 7007 | a->border == b->border && |
| 7008 | (a->flags & YV12_FLAG_HIGHBITDEPTH) == |
| 7009 | (b->flags & YV12_FLAG_HIGHBITDEPTH); |
| 7010 | } |
| 7011 | |
Yunqing Wang | 93b18f3 | 2018-06-08 21:08:29 -0700 | [diff] [blame] | 7012 | aom_codec_err_t av1_copy_new_frame_enc(AV1_COMMON *cm, |
| 7013 | YV12_BUFFER_CONFIG *new_frame, |
| 7014 | YV12_BUFFER_CONFIG *sd) { |
Yunqing Wang | ff9bfca | 2018-06-06 11:46:08 -0700 | [diff] [blame] | 7015 | const int num_planes = av1_num_planes(cm); |
| 7016 | if (!equal_dimensions_and_border(new_frame, sd)) |
| 7017 | aom_internal_error(&cm->error, AOM_CODEC_ERROR, |
| 7018 | "Incorrect buffer dimensions"); |
| 7019 | else |
| 7020 | aom_yv12_copy_frame(new_frame, sd, num_planes); |
| 7021 | |
| 7022 | return cm->error.error_code; |
| 7023 | } |
| 7024 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 7025 | int av1_set_internal_size(AV1_COMP *cpi, AOM_SCALING horiz_mode, |
| 7026 | AOM_SCALING vert_mode) { |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 7027 | int hr = 0, hs = 0, vr = 0, vs = 0; |
| 7028 | |
| 7029 | if (horiz_mode > ONETWO || vert_mode > ONETWO) return -1; |
| 7030 | |
| 7031 | Scale2Ratio(horiz_mode, &hr, &hs); |
| 7032 | Scale2Ratio(vert_mode, &vr, &vs); |
| 7033 | |
| 7034 | // always go to the next whole number |
Debargha Mukherjee | ccb2726 | 2017-09-25 14:19:46 -0700 | [diff] [blame] | 7035 | cpi->resize_pending_width = (hs - 1 + cpi->oxcf.width * hr) / hs; |
| 7036 | cpi->resize_pending_height = (vs - 1 + cpi->oxcf.height * vr) / vs; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 7037 | |
| 7038 | return 0; |
| 7039 | } |
| 7040 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 7041 | int av1_get_quantizer(AV1_COMP *cpi) { return cpi->common.base_qindex; } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 7042 | |
Soo-Chul Han | 29c46fb | 2018-03-23 16:02:00 -0400 | [diff] [blame] | 7043 | int av1_convert_sect5obus_to_annexb(uint8_t *buffer, size_t *frame_size) { |
| 7044 | size_t output_size = 0; |
| 7045 | size_t total_bytes_read = 0; |
| 7046 | size_t remaining_size = *frame_size; |
| 7047 | uint8_t *buff_ptr = buffer; |
| 7048 | |
| 7049 | // go through each OBUs |
| 7050 | while (total_bytes_read < *frame_size) { |
| 7051 | uint8_t saved_obu_header[2]; |
| 7052 | uint64_t obu_payload_size; |
| 7053 | size_t length_of_payload_size; |
| 7054 | size_t length_of_obu_size; |
| 7055 | uint32_t obu_header_size = (buff_ptr[0] >> 2) & 0x1 ? 2 : 1; |
| 7056 | size_t obu_bytes_read = obu_header_size; // bytes read for current obu |
| 7057 | |
| 7058 | // save the obu header (1 or 2 bytes) |
| 7059 | memmove(saved_obu_header, buff_ptr, obu_header_size); |
| 7060 | // clear the obu_has_size_field |
| 7061 | saved_obu_header[0] = saved_obu_header[0] & (~0x2); |
| 7062 | |
| 7063 | // get the payload_size and length of payload_size |
| 7064 | if (aom_uleb_decode(buff_ptr + obu_header_size, remaining_size, |
| 7065 | &obu_payload_size, &length_of_payload_size) != 0) { |
| 7066 | return AOM_CODEC_ERROR; |
| 7067 | } |
| 7068 | obu_bytes_read += length_of_payload_size; |
| 7069 | |
| 7070 | // calculate the length of size of the obu header plus payload |
| 7071 | length_of_obu_size = |
| 7072 | aom_uleb_size_in_bytes((uint64_t)(obu_header_size + obu_payload_size)); |
| 7073 | |
| 7074 | // move the rest of data to new location |
| 7075 | memmove(buff_ptr + length_of_obu_size + obu_header_size, |
| 7076 | buff_ptr + obu_bytes_read, remaining_size - obu_bytes_read); |
Yaowu Xu | 9e49420 | 2018-04-03 11:19:49 -0700 | [diff] [blame] | 7077 | obu_bytes_read += (size_t)obu_payload_size; |
Soo-Chul Han | 29c46fb | 2018-03-23 16:02:00 -0400 | [diff] [blame] | 7078 | |
| 7079 | // write the new obu size |
| 7080 | const uint64_t obu_size = obu_header_size + obu_payload_size; |
| 7081 | size_t coded_obu_size; |
| 7082 | if (aom_uleb_encode(obu_size, sizeof(obu_size), buff_ptr, |
| 7083 | &coded_obu_size) != 0) { |
| 7084 | return AOM_CODEC_ERROR; |
| 7085 | } |
| 7086 | |
| 7087 | // write the saved (modified) obu_header following obu size |
| 7088 | memmove(buff_ptr + length_of_obu_size, saved_obu_header, obu_header_size); |
| 7089 | |
| 7090 | total_bytes_read += obu_bytes_read; |
| 7091 | remaining_size -= obu_bytes_read; |
| 7092 | buff_ptr += length_of_obu_size + obu_size; |
Yaowu Xu | 9e49420 | 2018-04-03 11:19:49 -0700 | [diff] [blame] | 7093 | output_size += length_of_obu_size + (size_t)obu_size; |
Soo-Chul Han | 29c46fb | 2018-03-23 16:02:00 -0400 | [diff] [blame] | 7094 | } |
| 7095 | |
| 7096 | *frame_size = output_size; |
| 7097 | return AOM_CODEC_OK; |
| 7098 | } |
| 7099 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 7100 | 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] | 7101 | // TODO(yunqingwang): For what references to use, external encoding flags |
| 7102 | // should be consistent with internal reference frame selection. Need to |
| 7103 | // ensure that there is not conflict between the two. In AV1 encoder, the |
| 7104 | // priority rank for 7 reference frames are: LAST, ALTREF, LAST2, LAST3, |
| 7105 | // GOLDEN, BWDREF, ALTREF2. If only one reference frame is used, it must be |
| 7106 | // LAST. |
Yunqing Wang | f2e7a39 | 2017-11-08 00:27:21 -0800 | [diff] [blame] | 7107 | cpi->ext_ref_frame_flags = AOM_REFFRAME_ALL; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 7108 | if (flags & |
Yunqing Wang | 9a50fec | 2017-11-02 17:02:00 -0700 | [diff] [blame] | 7109 | (AOM_EFLAG_NO_REF_LAST | AOM_EFLAG_NO_REF_LAST2 | AOM_EFLAG_NO_REF_LAST3 | |
| 7110 | AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_REF_BWD | |
| 7111 | AOM_EFLAG_NO_REF_ARF2)) { |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 7112 | if (flags & AOM_EFLAG_NO_REF_LAST) { |
Yunqing Wang | f2e7a39 | 2017-11-08 00:27:21 -0800 | [diff] [blame] | 7113 | cpi->ext_ref_frame_flags = 0; |
Yunqing Wang | 9a50fec | 2017-11-02 17:02:00 -0700 | [diff] [blame] | 7114 | } else { |
| 7115 | int ref = AOM_REFFRAME_ALL; |
| 7116 | |
| 7117 | if (flags & AOM_EFLAG_NO_REF_LAST2) ref ^= AOM_LAST2_FLAG; |
| 7118 | if (flags & AOM_EFLAG_NO_REF_LAST3) ref ^= AOM_LAST3_FLAG; |
| 7119 | |
| 7120 | if (flags & AOM_EFLAG_NO_REF_GF) ref ^= AOM_GOLD_FLAG; |
| 7121 | |
| 7122 | if (flags & AOM_EFLAG_NO_REF_ARF) { |
| 7123 | ref ^= AOM_ALT_FLAG; |
| 7124 | ref ^= AOM_BWD_FLAG; |
| 7125 | ref ^= AOM_ALT2_FLAG; |
| 7126 | } else { |
| 7127 | if (flags & AOM_EFLAG_NO_REF_BWD) ref ^= AOM_BWD_FLAG; |
| 7128 | if (flags & AOM_EFLAG_NO_REF_ARF2) ref ^= AOM_ALT2_FLAG; |
| 7129 | } |
| 7130 | |
| 7131 | av1_use_as_reference(cpi, ref); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 7132 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 7133 | } |
| 7134 | |
| 7135 | if (flags & |
Yunqing Wang | 9a50fec | 2017-11-02 17:02:00 -0700 | [diff] [blame] | 7136 | (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] | 7137 | int upd = AOM_REFFRAME_ALL; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 7138 | |
Yunqing Wang | 9a50fec | 2017-11-02 17:02:00 -0700 | [diff] [blame] | 7139 | // Refreshing LAST/LAST2/LAST3 is handled by 1 common flag. |
| 7140 | if (flags & AOM_EFLAG_NO_UPD_LAST) upd ^= AOM_LAST_FLAG; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 7141 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 7142 | if (flags & AOM_EFLAG_NO_UPD_GF) upd ^= AOM_GOLD_FLAG; |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 7143 | |
Yunqing Wang | 9a50fec | 2017-11-02 17:02:00 -0700 | [diff] [blame] | 7144 | if (flags & AOM_EFLAG_NO_UPD_ARF) { |
| 7145 | upd ^= AOM_ALT_FLAG; |
| 7146 | upd ^= AOM_BWD_FLAG; |
| 7147 | upd ^= AOM_ALT2_FLAG; |
| 7148 | } |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 7149 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 7150 | av1_update_reference(cpi, upd); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 7151 | } |
| 7152 | |
sarahparker | 21dbca4 | 2018-03-30 17:43:44 -0700 | [diff] [blame] | 7153 | cpi->ext_use_ref_frame_mvs = cpi->oxcf.allow_ref_frame_mvs & |
| 7154 | ((flags & AOM_EFLAG_NO_REF_FRAME_MVS) == 0); |
sarahparker | 27d686a | 2018-03-30 17:43:44 -0700 | [diff] [blame] | 7155 | cpi->ext_use_error_resilient = cpi->oxcf.error_resilient_mode | |
| 7156 | ((flags & AOM_EFLAG_ERROR_RESILIENT) != 0); |
sarahparker | 9806fed | 2018-03-30 17:43:44 -0700 | [diff] [blame] | 7157 | cpi->ext_use_s_frame = |
| 7158 | cpi->oxcf.s_frame_mode | ((flags & AOM_EFLAG_SET_S_FRAME) != 0); |
Sarah Parker | 50b6d6e | 2018-04-11 19:21:54 -0700 | [diff] [blame] | 7159 | cpi->ext_use_primary_ref_none = (flags & AOM_EFLAG_SET_PRIMARY_REF_NONE) != 0; |
sarahparker | 21dbca4 | 2018-03-30 17:43:44 -0700 | [diff] [blame] | 7160 | |
Yaowu Xu | f883b42 | 2016-08-30 14:01:10 -0700 | [diff] [blame] | 7161 | if (flags & AOM_EFLAG_NO_UPD_ENTROPY) { |
| 7162 | av1_update_entropy(cpi, 0); |
Yaowu Xu | c27fc14 | 2016-08-22 16:08:15 -0700 | [diff] [blame] | 7163 | } |
| 7164 | } |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 7165 | |
Andrey Norkin | 795ba87 | 2018-03-06 13:24:14 -0800 | [diff] [blame] | 7166 | int64_t timebase_units_to_ticks(const aom_rational_t *timebase, int64_t n) { |
| 7167 | return n * TICKS_PER_SEC * timebase->num / timebase->den; |
| 7168 | } |
| 7169 | |
| 7170 | int64_t ticks_to_timebase_units(const aom_rational_t *timebase, int64_t n) { |
| 7171 | const int64_t round = TICKS_PER_SEC * timebase->num / 2 - 1; |
| 7172 | return (n * timebase->den + round) / timebase->num / TICKS_PER_SEC; |
| 7173 | } |
Tom Finegan | f8d6a16 | 2018-08-21 10:47:55 -0700 | [diff] [blame] | 7174 | |
| 7175 | aom_fixed_buf_t *av1_get_global_headers(AV1_COMP *cpi) { |
| 7176 | if (!cpi) return NULL; |
| 7177 | |
| 7178 | uint8_t header_buf[512] = { 0 }; |
| 7179 | const uint32_t sequence_header_size = |
| 7180 | write_sequence_header_obu(cpi, &header_buf[0]); |
| 7181 | assert(sequence_header_size <= sizeof(header_buf)); |
| 7182 | if (sequence_header_size == 0) return NULL; |
| 7183 | |
| 7184 | const size_t obu_header_size = 1; |
| 7185 | const size_t size_field_size = aom_uleb_size_in_bytes(sequence_header_size); |
| 7186 | const size_t payload_offset = obu_header_size + size_field_size; |
| 7187 | |
| 7188 | if (payload_offset + sequence_header_size > sizeof(header_buf)) return NULL; |
| 7189 | memmove(&header_buf[payload_offset], &header_buf[0], sequence_header_size); |
| 7190 | |
| 7191 | if (write_obu_header(OBU_SEQUENCE_HEADER, 0, &header_buf[0]) != |
| 7192 | obu_header_size) { |
| 7193 | return NULL; |
| 7194 | } |
| 7195 | |
| 7196 | size_t coded_size_field_size = 0; |
| 7197 | if (aom_uleb_encode(sequence_header_size, size_field_size, |
| 7198 | &header_buf[obu_header_size], |
| 7199 | &coded_size_field_size) != 0) { |
| 7200 | return NULL; |
| 7201 | } |
| 7202 | assert(coded_size_field_size == size_field_size); |
| 7203 | |
| 7204 | aom_fixed_buf_t *global_headers = |
| 7205 | (aom_fixed_buf_t *)malloc(sizeof(*global_headers)); |
| 7206 | if (!global_headers) return NULL; |
| 7207 | |
| 7208 | const size_t global_header_buf_size = |
| 7209 | obu_header_size + size_field_size + sequence_header_size; |
| 7210 | |
| 7211 | global_headers->buf = malloc(global_header_buf_size); |
| 7212 | if (!global_headers->buf) { |
| 7213 | free(global_headers); |
| 7214 | return NULL; |
| 7215 | } |
| 7216 | |
| 7217 | memcpy(global_headers->buf, &header_buf[0], global_header_buf_size); |
| 7218 | global_headers->sz = global_header_buf_size; |
| 7219 | return global_headers; |
| 7220 | } |