blob: c0a33dfe47844cfa571469c5e9f7c1b565c450ca [file] [log] [blame]
Yaowu Xuc27fc142016-08-22 16:08:15 -07001/*
Urvang Joshi8a02d762016-07-28 15:51:12 -07002 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
Yaowu Xuc27fc142016-08-22 16:08:15 -07003 *
Urvang Joshi8a02d762016-07-28 15:51:12 -07004 * 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 Xuc27fc142016-08-22 16:08:15 -070010 */
11
12#include <limits.h>
13#include <math.h>
14#include <stdio.h>
15
Tom Finegan60e653d2018-05-22 11:34:58 -070016#include "config/aom_config.h"
Tom Finegan44702c82018-05-22 13:00:39 -070017#include "config/aom_dsp_rtcd.h"
18#include "config/aom_scale_rtcd.h"
Yaowu Xufa3721d2018-07-30 14:38:49 -070019#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"
David Turner1539bb02019-01-24 15:28:13 +000036#if CONFIG_BITSTREAM_DEBUG
Yaowu Xufa3721d2018-07-30 14:38:49 -070037#include "aom_util/debug_util.h"
David Turner1539bb02019-01-24 15:28:13 +000038#endif // CONFIG_BITSTREAM_DEBUG
Yaowu Xuc27fc142016-08-22 16:08:15 -070039
40#include "av1/common/alloccommon.h"
Steinar Midtskogena9d41e82017-03-17 12:48:15 +010041#include "av1/common/cdef.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070042#include "av1/common/filter.h"
43#include "av1/common/idct.h"
44#include "av1/common/reconinter.h"
45#include "av1/common/reconintra.h"
Fergus Simpsond0565002017-03-27 16:51:52 -070046#include "av1/common/resize.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070047#include "av1/common/tile_common.h"
48
Ravi Chaudharyc5e74692018-10-08 16:05:38 +053049#include "av1/encoder/av1_multi_thread.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070050#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 Xuc27fc142016-08-22 16:08:15 -070054#include "av1/encoder/context_tree.h"
55#include "av1/encoder/encodeframe.h"
56#include "av1/encoder/encodemv.h"
David Turner056f7cd2019-01-07 17:48:13 +000057#include "av1/encoder/encode_strategy.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070058#include "av1/encoder/encoder.h"
Angie Chiangf0fbf9d2017-03-15 15:01:22 -070059#include "av1/encoder/encodetxb.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070060#include "av1/encoder/ethread.h"
61#include "av1/encoder/firstpass.h"
Yaowu Xufa3721d2018-07-30 14:38:49 -070062#include "av1/encoder/grain_test_vectors.h"
RogerZhoucc5d35d2017-08-07 22:20:15 -070063#include "av1/encoder/hash_motion.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070064#include "av1/encoder/mbgraph.h"
David Turner0fa8c492019-02-06 16:38:13 +000065#include "av1/encoder/pass2_strategy.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070066#include "av1/encoder/picklpf.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070067#include "av1/encoder/pickrst.h"
Debargha Mukherjee7166f222017-09-05 21:32:42 -070068#include "av1/encoder/random.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070069#include "av1/encoder/ratectrl.h"
70#include "av1/encoder/rd.h"
Debargha Mukherjeedf713102018-10-02 12:33:32 -070071#include "av1/encoder/rdopt.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070072#include "av1/encoder/segmentation.h"
73#include "av1/encoder/speed_features.h"
Yue Chen7cae98f2018-08-24 10:43:16 -070074#include "av1/encoder/reconinter_enc.h"
kyslov7b9d0d62018-12-21 11:12:26 -080075#include "av1/encoder/var_based_part.h"
Yaowu Xuc27fc142016-08-22 16:08:15 -070076
Imdad Sardharwallae68aa8a2018-03-07 18:52:54 +000077#define DEFAULT_EXPLICIT_ORDER_HINT_BITS 7
Imdad Sardharwallae68aa8a2018-03-07 18:52:54 +000078
Debargha Mukherjee5802ebe2016-12-21 04:17:24 -080079#if CONFIG_ENTROPY_STATS
80FRAME_COUNTS aggregate_fc;
81#endif // CONFIG_ENTROPY_STATS
82
Yaowu Xuc27fc142016-08-22 16:08:15 -070083#define AM_SEGMENT_ID_INACTIVE 7
84#define AM_SEGMENT_ID_ACTIVE 0
85
Johannb0ef6ff2018-02-08 14:32:21 -080086// Whether to use high precision mv for altref computation.
87#define ALTREF_HIGH_PRECISION_MV 1
88
89// Q threshold for high precision mv. Choose a very high value for now so that
90// HIGH_PRECISION is always chosen.
91#define HIGH_PRECISION_MV_QTHRESH 200
Wei-Ting Lin01d4d8f2017-08-03 17:04:12 -070092
Yaowu Xuc27fc142016-08-22 16:08:15 -070093// #define OUTPUT_YUV_REC
Yaowu Xuc27fc142016-08-22 16:08:15 -070094#ifdef OUTPUT_YUV_SKINMAP
95FILE *yuv_skinmap_file = NULL;
96#endif
97#ifdef OUTPUT_YUV_REC
98FILE *yuv_rec_file;
99#define FILE_NAME_LEN 100
100#endif
101
Yaowu Xuf883b422016-08-30 14:01:10 -0700102static INLINE void Scale2Ratio(AOM_SCALING mode, int *hr, int *hs) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700103 switch (mode) {
104 case NORMAL:
105 *hr = 1;
106 *hs = 1;
107 break;
108 case FOURFIVE:
109 *hr = 4;
110 *hs = 5;
111 break;
112 case THREEFIVE:
113 *hr = 3;
114 *hs = 5;
115 break;
116 case ONETWO:
117 *hr = 1;
118 *hs = 2;
119 break;
120 default:
121 *hr = 1;
122 *hs = 1;
123 assert(0);
124 break;
125 }
126}
127
128// Mark all inactive blocks as active. Other segmentation features may be set
129// so memset cannot be used, instead only inactive blocks should be reset.
Yaowu Xuf883b422016-08-30 14:01:10 -0700130static void suppress_active_map(AV1_COMP *cpi) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700131 unsigned char *const seg_map = cpi->segmentation_map;
132 int i;
133 if (cpi->active_map.enabled || cpi->active_map.update)
134 for (i = 0; i < cpi->common.mi_rows * cpi->common.mi_cols; ++i)
135 if (seg_map[i] == AM_SEGMENT_ID_INACTIVE)
136 seg_map[i] = AM_SEGMENT_ID_ACTIVE;
137}
138
Yaowu Xuf883b422016-08-30 14:01:10 -0700139static void apply_active_map(AV1_COMP *cpi) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700140 struct segmentation *const seg = &cpi->common.seg;
141 unsigned char *const seg_map = cpi->segmentation_map;
142 const unsigned char *const active_map = cpi->active_map.map;
143 int i;
144
145 assert(AM_SEGMENT_ID_ACTIVE == CR_SEGMENT_ID_BASE);
146
147 if (frame_is_intra_only(&cpi->common)) {
148 cpi->active_map.enabled = 0;
149 cpi->active_map.update = 1;
150 }
151
152 if (cpi->active_map.update) {
153 if (cpi->active_map.enabled) {
154 for (i = 0; i < cpi->common.mi_rows * cpi->common.mi_cols; ++i)
155 if (seg_map[i] == AM_SEGMENT_ID_ACTIVE) seg_map[i] = active_map[i];
Yaowu Xuf883b422016-08-30 14:01:10 -0700156 av1_enable_segmentation(seg);
157 av1_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_SKIP);
Cheng Chend8184da2017-09-26 18:15:22 -0700158 av1_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_Y_H);
159 av1_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_Y_V);
160 av1_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_U);
161 av1_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_V);
162
163 av1_set_segdata(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_Y_H,
164 -MAX_LOOP_FILTER);
165 av1_set_segdata(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_Y_V,
166 -MAX_LOOP_FILTER);
167 av1_set_segdata(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_U,
168 -MAX_LOOP_FILTER);
169 av1_set_segdata(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_V,
170 -MAX_LOOP_FILTER);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700171 } else {
Yaowu Xuf883b422016-08-30 14:01:10 -0700172 av1_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_SKIP);
Cheng Chend8184da2017-09-26 18:15:22 -0700173 av1_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_Y_H);
174 av1_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_Y_V);
175 av1_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_U);
176 av1_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF_V);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700177 if (seg->enabled) {
178 seg->update_data = 1;
179 seg->update_map = 1;
180 }
181 }
182 cpi->active_map.update = 0;
183 }
184}
185
Yaowu Xuf883b422016-08-30 14:01:10 -0700186int av1_set_active_map(AV1_COMP *cpi, unsigned char *new_map_16x16, int rows,
187 int cols) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700188 if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols) {
189 unsigned char *const active_map_8x8 = cpi->active_map.map;
190 const int mi_rows = cpi->common.mi_rows;
191 const int mi_cols = cpi->common.mi_cols;
Jingning Han9d533022017-04-07 10:14:42 -0700192 const int row_scale = mi_size_high[BLOCK_16X16] == 2 ? 1 : 2;
193 const int col_scale = mi_size_wide[BLOCK_16X16] == 2 ? 1 : 2;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700194 cpi->active_map.update = 1;
195 if (new_map_16x16) {
196 int r, c;
197 for (r = 0; r < mi_rows; ++r) {
198 for (c = 0; c < mi_cols; ++c) {
199 active_map_8x8[r * mi_cols + c] =
Jingning Han9d533022017-04-07 10:14:42 -0700200 new_map_16x16[(r >> row_scale) * cols + (c >> col_scale)]
Yaowu Xuc27fc142016-08-22 16:08:15 -0700201 ? AM_SEGMENT_ID_ACTIVE
202 : AM_SEGMENT_ID_INACTIVE;
203 }
204 }
205 cpi->active_map.enabled = 1;
206 } else {
207 cpi->active_map.enabled = 0;
208 }
209 return 0;
210 } else {
211 return -1;
212 }
213}
214
Yaowu Xuf883b422016-08-30 14:01:10 -0700215int av1_get_active_map(AV1_COMP *cpi, unsigned char *new_map_16x16, int rows,
216 int cols) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700217 if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols &&
218 new_map_16x16) {
219 unsigned char *const seg_map_8x8 = cpi->segmentation_map;
220 const int mi_rows = cpi->common.mi_rows;
221 const int mi_cols = cpi->common.mi_cols;
Jingning Han9d533022017-04-07 10:14:42 -0700222 const int row_scale = mi_size_high[BLOCK_16X16] == 2 ? 1 : 2;
223 const int col_scale = mi_size_wide[BLOCK_16X16] == 2 ? 1 : 2;
224
Yaowu Xuc27fc142016-08-22 16:08:15 -0700225 memset(new_map_16x16, !cpi->active_map.enabled, rows * cols);
226 if (cpi->active_map.enabled) {
227 int r, c;
228 for (r = 0; r < mi_rows; ++r) {
229 for (c = 0; c < mi_cols; ++c) {
230 // Cyclic refresh segments are considered active despite not having
231 // AM_SEGMENT_ID_ACTIVE
Jingning Han9d533022017-04-07 10:14:42 -0700232 new_map_16x16[(r >> row_scale) * cols + (c >> col_scale)] |=
Yaowu Xuc27fc142016-08-22 16:08:15 -0700233 seg_map_8x8[r * mi_cols + c] != AM_SEGMENT_ID_INACTIVE;
234 }
235 }
236 }
237 return 0;
238 } else {
239 return -1;
240 }
241}
242
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -0800243// Compute the horizontal frequency components' energy in a frame
244// by calculuating the 16x4 Horizontal DCT. This is to be used to
245// decide the superresolution parameters.
Debargha Mukherjeef50fdce2018-11-13 11:13:00 -0800246void analyze_hor_freq(const AV1_COMP *cpi, double *energy) {
Debargha Mukherjee21eb0402018-12-03 12:10:59 -0800247 uint64_t freq_energy[16] = { 0 };
Debargha Mukherjeef50fdce2018-11-13 11:13:00 -0800248 const YV12_BUFFER_CONFIG *buf = cpi->source;
249 const int bd = cpi->td.mb.e_mbd.bd;
250 const int width = buf->y_crop_width;
251 const int height = buf->y_crop_height;
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -0800252 DECLARE_ALIGNED(16, int32_t, coeff[16 * 4]);
Debargha Mukherjeef50fdce2018-11-13 11:13:00 -0800253 int n = 0;
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -0800254 memset(freq_energy, 0, sizeof(freq_energy));
Debargha Mukherjeef50fdce2018-11-13 11:13:00 -0800255 if (buf->flags & YV12_FLAG_HIGHBITDEPTH) {
256 const int16_t *src16 = (const int16_t *)CONVERT_TO_SHORTPTR(buf->y_buffer);
257 for (int i = 0; i < height - 4; i += 4) {
258 for (int j = 0; j < width - 16; j += 16) {
259 av1_fwd_txfm2d_16x4(src16 + i * buf->y_stride + j, coeff, buf->y_stride,
260 H_DCT, bd);
Debargha Mukherjee21eb0402018-12-03 12:10:59 -0800261 for (int k = 1; k < 16; ++k) {
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -0800262 const uint64_t this_energy =
263 ((int64_t)coeff[k] * coeff[k]) +
264 ((int64_t)coeff[k + 16] * coeff[k + 16]) +
265 ((int64_t)coeff[k + 32] * coeff[k + 32]) +
266 ((int64_t)coeff[k + 48] * coeff[k + 48]);
Debargha Mukherjee21eb0402018-12-03 12:10:59 -0800267 freq_energy[k] += ROUND_POWER_OF_TWO(this_energy, 2 + 2 * (bd - 8));
Debargha Mukherjeef50fdce2018-11-13 11:13:00 -0800268 }
269 n++;
270 }
271 }
272 } else {
Debargha Mukherjeeac28c722018-11-14 22:09:46 -0800273 assert(bd == 8);
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -0800274 DECLARE_ALIGNED(16, int16_t, src16[16 * 4]);
Debargha Mukherjeef50fdce2018-11-13 11:13:00 -0800275 for (int i = 0; i < height - 4; i += 4) {
276 for (int j = 0; j < width - 16; j += 16) {
277 for (int ii = 0; ii < 4; ++ii)
278 for (int jj = 0; jj < 16; ++jj)
279 src16[ii * 16 + jj] =
280 buf->y_buffer[(i + ii) * buf->y_stride + (j + jj)];
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -0800281 av1_fwd_txfm2d_16x4(src16, coeff, 16, H_DCT, bd);
Debargha Mukherjee21eb0402018-12-03 12:10:59 -0800282 for (int k = 1; k < 16; ++k) {
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -0800283 const uint64_t this_energy =
284 ((int64_t)coeff[k] * coeff[k]) +
285 ((int64_t)coeff[k + 16] * coeff[k + 16]) +
286 ((int64_t)coeff[k + 32] * coeff[k + 32]) +
287 ((int64_t)coeff[k + 48] * coeff[k + 48]);
Debargha Mukherjee21eb0402018-12-03 12:10:59 -0800288 freq_energy[k] += ROUND_POWER_OF_TWO(this_energy, 2);
Debargha Mukherjeef50fdce2018-11-13 11:13:00 -0800289 }
290 n++;
291 }
292 }
293 }
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -0800294 if (n) {
Debargha Mukherjee21eb0402018-12-03 12:10:59 -0800295 for (int k = 1; k < 16; ++k) energy[k] = (double)freq_energy[k] / n;
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -0800296 // Convert to cumulative energy
Debargha Mukherjee21eb0402018-12-03 12:10:59 -0800297 for (int k = 14; k > 0; --k) energy[k] += energy[k + 1];
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -0800298 } else {
Debargha Mukherjee21eb0402018-12-03 12:10:59 -0800299 for (int k = 1; k < 16; ++k) energy[k] = 1e+20;
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -0800300 }
Debargha Mukherjeef50fdce2018-11-13 11:13:00 -0800301}
302
Yaowu Xu45295c32018-03-29 12:06:10 -0700303static void set_high_precision_mv(AV1_COMP *cpi, int allow_high_precision_mv,
304 int cur_frame_force_integer_mv) {
James Zern01a9d702017-08-25 19:09:33 +0000305 MACROBLOCK *const mb = &cpi->td.mb;
Hui Su50361152018-03-02 11:01:42 -0800306 cpi->common.allow_high_precision_mv =
307 allow_high_precision_mv && cur_frame_force_integer_mv == 0;
Rupert Swarbricka84faf22017-12-11 13:56:40 +0000308 const int copy_hp =
309 cpi->common.allow_high_precision_mv && cur_frame_force_integer_mv == 0;
Jingning Hanf050fc12018-03-09 14:53:33 -0800310 int *(*src)[2] = copy_hp ? &mb->nmvcost_hp : &mb->nmvcost;
311 mb->mv_cost_stack = *src;
James Zern01a9d702017-08-25 19:09:33 +0000312}
313
Yaowu Xuf883b422016-08-30 14:01:10 -0700314static BLOCK_SIZE select_sb_size(const AV1_COMP *const cpi) {
Urvang Joshie4530f82018-01-09 11:43:37 -0800315 const AV1_COMMON *const cm = &cpi->common;
316
Yaowu Xuf883b422016-08-30 14:01:10 -0700317 if (cpi->oxcf.superblock_size == AOM_SUPERBLOCK_SIZE_64X64)
Yaowu Xuc27fc142016-08-22 16:08:15 -0700318 return BLOCK_64X64;
Maxym Dmytrychenkocc6e0e12018-02-05 16:35:37 +0100319#if CONFIG_FILEOPTIONS
Urvang Joshie4530f82018-01-09 11:43:37 -0800320 if (cm->options && cm->options->ext_partition)
Maxym Dmytrychenkocc6e0e12018-02-05 16:35:37 +0100321#endif
322 if (cpi->oxcf.superblock_size == AOM_SUPERBLOCK_SIZE_128X128)
323 return BLOCK_128X128;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700324
Yaowu Xuf883b422016-08-30 14:01:10 -0700325 assert(cpi->oxcf.superblock_size == AOM_SUPERBLOCK_SIZE_DYNAMIC);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700326
Maxym Dmytrychenkocc6e0e12018-02-05 16:35:37 +0100327// TODO(any): Possibly could improve this with a heuristic.
328#if CONFIG_FILEOPTIONS
Urvang Joshie4530f82018-01-09 11:43:37 -0800329 if (cm->options && !cm->options->ext_partition) return BLOCK_64X64;
Maxym Dmytrychenkocc6e0e12018-02-05 16:35:37 +0100330#endif
Urvang Joshie4530f82018-01-09 11:43:37 -0800331
Urvang Joshiaab74432018-06-01 12:06:22 -0700332 // When superres / resize is on, 'cm->width / height' can change between
333 // calls, so we don't apply this heuristic there. Also, this heuristic gives
334 // compression gain for speed >= 2 only.
David Turner04b70d82019-01-24 15:39:19 +0000335 // Things break if superblock size changes per-frame which is why this
336 // heuristic is set based on configured speed rather than actual
337 // speed-features (which may change per-frame in future)
Urvang Joshiaab74432018-06-01 12:06:22 -0700338 if (cpi->oxcf.superres_mode == SUPERRES_NONE &&
339 cpi->oxcf.resize_mode == RESIZE_NONE && cpi->oxcf.speed >= 2) {
Urvang Joshie4530f82018-01-09 11:43:37 -0800340 return (cm->width >= 480 && cm->height >= 360) ? BLOCK_128X128
341 : BLOCK_64X64;
342 }
343
Yaowu Xuc27fc142016-08-22 16:08:15 -0700344 return BLOCK_128X128;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700345}
346
Yaowu Xuf883b422016-08-30 14:01:10 -0700347static void setup_frame(AV1_COMP *cpi) {
348 AV1_COMMON *const cm = &cpi->common;
Johannb0ef6ff2018-02-08 14:32:21 -0800349 // Set up entropy context depending on frame type. The decoder mandates
350 // the use of the default context, index 0, for keyframes and inter
351 // frames where the error_resilient_mode or intra_only flag is set. For
352 // other inter-frames the encoder currently uses only two contexts;
353 // context 1 for ALTREF frames and context 0 for the others.
Soo-Chul Han85e8c792018-01-21 01:58:15 -0500354
Sarah Parker50b6d6e2018-04-11 19:21:54 -0700355 if (frame_is_intra_only(cm) || cm->error_resilient_mode ||
David Turnera7f133c2019-01-22 14:47:16 +0000356 cpi->ext_use_primary_ref_none) {
Yaowu Xuf883b422016-08-30 14:01:10 -0700357 av1_setup_past_independence(cm);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700358 }
359
David Turnerd2a592e2018-11-16 14:59:31 +0000360 if (cm->current_frame.frame_type == KEY_FRAME && cm->show_frame) {
Imdad Sardharwalla4ec84ab2018-02-06 12:20:18 +0000361 set_sb_size(&cm->seq_params, select_sb_size(cpi));
Tarek AMARAc9813852018-03-05 18:40:18 -0500362 } else if (frame_is_sframe(cm)) {
Tarek AMARAc9813852018-03-05 18:40:18 -0500363 set_sb_size(&cm->seq_params, select_sb_size(cpi));
Yaowu Xuc27fc142016-08-22 16:08:15 -0700364 } else {
David Turnera21966b2018-12-05 14:48:49 +0000365 const RefCntBuffer *const primary_ref_buf = get_primary_ref_frame_buf(cm);
366 if (primary_ref_buf == NULL) {
David Barkercc615a82018-03-19 14:38:51 +0000367 av1_setup_past_independence(cm);
368 cm->seg.update_map = 1;
369 cm->seg.update_data = 1;
Thomas Daededa4d8b92017-06-05 15:44:14 -0700370 } else {
David Turnera21966b2018-12-05 14:48:49 +0000371 *cm->fc = primary_ref_buf->frame_context;
Thomas Daededa4d8b92017-06-05 15:44:14 -0700372 }
Yaowu Xuc27fc142016-08-22 16:08:15 -0700373 }
374
David Turnerbc0993e2019-02-15 14:42:23 +0000375 av1_zero(cm->cur_frame->interp_filter_selected);
David Turnera21966b2018-12-05 14:48:49 +0000376 cm->prev_frame = get_primary_ref_frame_buf(cm);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700377 cpi->vaq_refresh = 0;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700378}
379
Cheng Chen46f30c72017-09-07 11:13:33 -0700380static void enc_setup_mi(AV1_COMMON *cm) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700381 int i;
Ravi Chaudhary75c4c5f2018-07-17 16:32:08 +0530382 int mi_rows_sb_aligned = calc_mi_size(cm->mi_rows);
Yunqing Wang19b9f722018-02-20 16:22:01 -0800383 cm->mi = cm->mip;
Ravi Chaudhary75c4c5f2018-07-17 16:32:08 +0530384 memset(cm->mip, 0, cm->mi_stride * mi_rows_sb_aligned * sizeof(*cm->mip));
Yunqing Wang19b9f722018-02-20 16:22:01 -0800385 cm->prev_mi = cm->prev_mip;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700386 // Clear top border row
387 memset(cm->prev_mip, 0, sizeof(*cm->prev_mip) * cm->mi_stride);
388 // Clear left border column
Ravi Chaudhary75c4c5f2018-07-17 16:32:08 +0530389 for (i = 0; i < mi_rows_sb_aligned; ++i)
Yaowu Xuc27fc142016-08-22 16:08:15 -0700390 memset(&cm->prev_mip[i * cm->mi_stride], 0, sizeof(*cm->prev_mip));
Yunqing Wang19b9f722018-02-20 16:22:01 -0800391 cm->mi_grid_visible = cm->mi_grid_base;
392 cm->prev_mi_grid_visible = cm->prev_mi_grid_base;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700393
394 memset(cm->mi_grid_base, 0,
Ravi Chaudhary75c4c5f2018-07-17 16:32:08 +0530395 cm->mi_stride * mi_rows_sb_aligned * sizeof(*cm->mi_grid_base));
Yaowu Xuc27fc142016-08-22 16:08:15 -0700396}
397
Cheng Chen46f30c72017-09-07 11:13:33 -0700398static int enc_alloc_mi(AV1_COMMON *cm, int mi_size) {
Yaowu Xuf883b422016-08-30 14:01:10 -0700399 cm->mip = aom_calloc(mi_size, sizeof(*cm->mip));
Yaowu Xuc27fc142016-08-22 16:08:15 -0700400 if (!cm->mip) return 1;
Yaowu Xuf883b422016-08-30 14:01:10 -0700401 cm->prev_mip = aom_calloc(mi_size, sizeof(*cm->prev_mip));
Yaowu Xuc27fc142016-08-22 16:08:15 -0700402 if (!cm->prev_mip) return 1;
403 cm->mi_alloc_size = mi_size;
404
Yue Chen53b53f02018-03-29 14:31:23 -0700405 cm->mi_grid_base =
406 (MB_MODE_INFO **)aom_calloc(mi_size, sizeof(MB_MODE_INFO *));
Yaowu Xuc27fc142016-08-22 16:08:15 -0700407 if (!cm->mi_grid_base) return 1;
408 cm->prev_mi_grid_base =
Yue Chen53b53f02018-03-29 14:31:23 -0700409 (MB_MODE_INFO **)aom_calloc(mi_size, sizeof(MB_MODE_INFO *));
Yaowu Xuc27fc142016-08-22 16:08:15 -0700410 if (!cm->prev_mi_grid_base) return 1;
411
412 return 0;
413}
414
Cheng Chen46f30c72017-09-07 11:13:33 -0700415static void enc_free_mi(AV1_COMMON *cm) {
Yaowu Xuf883b422016-08-30 14:01:10 -0700416 aom_free(cm->mip);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700417 cm->mip = NULL;
Yaowu Xuf883b422016-08-30 14:01:10 -0700418 aom_free(cm->prev_mip);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700419 cm->prev_mip = NULL;
Yaowu Xuf883b422016-08-30 14:01:10 -0700420 aom_free(cm->mi_grid_base);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700421 cm->mi_grid_base = NULL;
Yaowu Xuf883b422016-08-30 14:01:10 -0700422 aom_free(cm->prev_mi_grid_base);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700423 cm->prev_mi_grid_base = NULL;
Debargha Mukherjeeccb27262017-09-25 14:19:46 -0700424 cm->mi_alloc_size = 0;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700425}
426
Cheng Chen46f30c72017-09-07 11:13:33 -0700427static void swap_mi_and_prev_mi(AV1_COMMON *cm) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700428 // Current mip will be the prev_mip for the next frame.
Yue Chen53b53f02018-03-29 14:31:23 -0700429 MB_MODE_INFO **temp_base = cm->prev_mi_grid_base;
430 MB_MODE_INFO *temp = cm->prev_mip;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700431 cm->prev_mip = cm->mip;
432 cm->mip = temp;
433
434 // Update the upper left visible macroblock ptrs.
Yunqing Wang19b9f722018-02-20 16:22:01 -0800435 cm->mi = cm->mip;
436 cm->prev_mi = cm->prev_mip;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700437
438 cm->prev_mi_grid_base = cm->mi_grid_base;
439 cm->mi_grid_base = temp_base;
Yunqing Wang19b9f722018-02-20 16:22:01 -0800440 cm->mi_grid_visible = cm->mi_grid_base;
441 cm->prev_mi_grid_visible = cm->prev_mi_grid_base;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700442}
443
Yaowu Xuf883b422016-08-30 14:01:10 -0700444void av1_initialize_enc(void) {
Wan-Teh Chang3cac4542018-06-29 10:21:39 -0700445 av1_rtcd();
446 aom_dsp_rtcd();
447 aom_scale_rtcd();
448 av1_init_intra_predictors();
449 av1_init_me_luts();
450 av1_rc_init_minq_luts();
451 av1_init_wedge_masks();
Yaowu Xuc27fc142016-08-22 16:08:15 -0700452}
453
Debargha Mukherjeeccb27262017-09-25 14:19:46 -0700454static void dealloc_context_buffers_ext(AV1_COMP *cpi) {
455 if (cpi->mbmi_ext_base) {
456 aom_free(cpi->mbmi_ext_base);
457 cpi->mbmi_ext_base = NULL;
458 }
459}
460
461static void alloc_context_buffers_ext(AV1_COMP *cpi) {
462 AV1_COMMON *cm = &cpi->common;
463 int mi_size = cm->mi_cols * cm->mi_rows;
464
465 dealloc_context_buffers_ext(cpi);
466 CHECK_MEM_ERROR(cm, cpi->mbmi_ext_base,
467 aom_calloc(mi_size, sizeof(*cpi->mbmi_ext_base)));
468}
469
Yaowu Xuc0ea2582019-01-15 10:17:16 -0800470static void reset_film_grain_chroma_params(aom_film_grain_t *pars) {
471 pars->num_cr_points = 0;
472 pars->cr_mult = 0;
473 pars->cr_luma_mult = 0;
474 memset(pars->scaling_points_cr, 0, sizeof(pars->scaling_points_cr));
475 memset(pars->ar_coeffs_cr, 0, sizeof(pars->ar_coeffs_cr));
476 pars->num_cb_points = 0;
477 pars->cb_mult = 0;
478 pars->cb_luma_mult = 0;
Yaowu Xufda7dcb2019-01-16 13:04:33 -0800479 pars->chroma_scaling_from_luma = 0;
Yaowu Xuc0ea2582019-01-15 10:17:16 -0800480 memset(pars->scaling_points_cb, 0, sizeof(pars->scaling_points_cb));
481 memset(pars->ar_coeffs_cb, 0, sizeof(pars->ar_coeffs_cb));
482}
483
Andrey Norkin6f1c2f72018-01-15 20:08:52 -0800484static void update_film_grain_parameters(struct AV1_COMP *cpi,
485 const AV1EncoderConfig *oxcf) {
486 AV1_COMMON *const cm = &cpi->common;
487 cpi->oxcf = *oxcf;
488
Neil Birkbecka2893ab2018-06-08 14:45:13 -0700489 if (cpi->film_grain_table) {
490 aom_film_grain_table_free(cpi->film_grain_table);
491 aom_free(cpi->film_grain_table);
492 cpi->film_grain_table = NULL;
Neil Birkbeckeb895ef2018-03-14 17:51:03 -0700493 }
Neil Birkbeckeb895ef2018-03-14 17:51:03 -0700494
Andrey Norkin6f1c2f72018-01-15 20:08:52 -0800495 if (oxcf->film_grain_test_vector) {
Urvang Joshi8d5a4ba2018-07-19 16:26:34 -0700496 cm->seq_params.film_grain_params_present = 1;
David Turnerd2a592e2018-11-16 14:59:31 +0000497 if (cm->current_frame.frame_type == KEY_FRAME) {
Andrey Norkin6f1c2f72018-01-15 20:08:52 -0800498 memcpy(&cm->film_grain_params,
499 film_grain_test_vectors + oxcf->film_grain_test_vector - 1,
500 sizeof(cm->film_grain_params));
Yaowu Xuc0ea2582019-01-15 10:17:16 -0800501 if (oxcf->monochrome)
502 reset_film_grain_chroma_params(&cm->film_grain_params);
Urvang Joshi20cf30e2018-07-19 02:33:58 -0700503 cm->film_grain_params.bit_depth = cm->seq_params.bit_depth;
504 if (cm->seq_params.color_range == AOM_CR_FULL_RANGE) {
Andrey Norkin6f1c2f72018-01-15 20:08:52 -0800505 cm->film_grain_params.clip_to_restricted_range = 0;
506 }
507 }
Neil Birkbeckeb895ef2018-03-14 17:51:03 -0700508 } else if (oxcf->film_grain_table_filename) {
Neil Birkbeckbd40ca72019-03-02 13:25:50 -0800509 cm->seq_params.film_grain_params_present = 1;
510
Neil Birkbecka2893ab2018-06-08 14:45:13 -0700511 cpi->film_grain_table = aom_malloc(sizeof(*cpi->film_grain_table));
512 memset(cpi->film_grain_table, 0, sizeof(aom_film_grain_table_t));
Neil Birkbeckeb895ef2018-03-14 17:51:03 -0700513
Neil Birkbecka2893ab2018-06-08 14:45:13 -0700514 aom_film_grain_table_read(cpi->film_grain_table,
Neil Birkbeckeb895ef2018-03-14 17:51:03 -0700515 oxcf->film_grain_table_filename, &cm->error);
Andrey Norkin6f1c2f72018-01-15 20:08:52 -0800516 } else {
Neil Birkbeckbd40ca72019-03-02 13:25:50 -0800517#if CONFIG_DENOISE
518 cm->seq_params.film_grain_params_present = (cpi->oxcf.noise_level > 0);
519#else
Urvang Joshi8d5a4ba2018-07-19 16:26:34 -0700520 cm->seq_params.film_grain_params_present = 0;
Neil Birkbeckbd40ca72019-03-02 13:25:50 -0800521#endif
Andrey Norkin6f1c2f72018-01-15 20:08:52 -0800522 memset(&cm->film_grain_params, 0, sizeof(cm->film_grain_params));
523 }
524}
Andrey Norkin6f1c2f72018-01-15 20:08:52 -0800525
Yaowu Xuf883b422016-08-30 14:01:10 -0700526static void dealloc_compressor_data(AV1_COMP *cpi) {
527 AV1_COMMON *const cm = &cpi->common;
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +0000528 const int num_planes = av1_num_planes(cm);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700529
Debargha Mukherjeeccb27262017-09-25 14:19:46 -0700530 dealloc_context_buffers_ext(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700531
Yaowu Xuf883b422016-08-30 14:01:10 -0700532 aom_free(cpi->tile_data);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700533 cpi->tile_data = NULL;
534
535 // Delete sementation map
Yaowu Xuf883b422016-08-30 14:01:10 -0700536 aom_free(cpi->segmentation_map);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700537 cpi->segmentation_map = NULL;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700538
Yaowu Xuf883b422016-08-30 14:01:10 -0700539 av1_cyclic_refresh_free(cpi->cyclic_refresh);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700540 cpi->cyclic_refresh = NULL;
541
Yaowu Xuf883b422016-08-30 14:01:10 -0700542 aom_free(cpi->active_map.map);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700543 cpi->active_map.map = NULL;
544
Jingning Hand064cf02017-06-01 10:00:39 -0700545 aom_free(cpi->td.mb.above_pred_buf);
546 cpi->td.mb.above_pred_buf = NULL;
547
548 aom_free(cpi->td.mb.left_pred_buf);
549 cpi->td.mb.left_pred_buf = NULL;
550
551 aom_free(cpi->td.mb.wsrc_buf);
552 cpi->td.mb.wsrc_buf = NULL;
553
Ravi Chaudhary5d970f42018-09-25 11:25:32 +0530554 aom_free(cpi->td.mb.inter_modes_info);
555 cpi->td.mb.inter_modes_info = NULL;
Ravi Chaudhary5d970f42018-09-25 11:25:32 +0530556
Ravi Chaudhary783d6a32018-08-28 18:21:02 +0530557 for (int i = 0; i < 2; i++)
558 for (int j = 0; j < 2; j++) {
559 aom_free(cpi->td.mb.hash_value_buffer[i][j]);
560 cpi->td.mb.hash_value_buffer[i][j] = NULL;
561 }
Jingning Hand064cf02017-06-01 10:00:39 -0700562 aom_free(cpi->td.mb.mask_buf);
563 cpi->td.mb.mask_buf = NULL;
Jingning Hand064cf02017-06-01 10:00:39 -0700564
Jingning Han6cc1fd32017-10-13 09:05:36 -0700565 aom_free(cm->tpl_mvs);
566 cm->tpl_mvs = NULL;
Jingning Han6cc1fd32017-10-13 09:05:36 -0700567
Yaowu Xuf883b422016-08-30 14:01:10 -0700568 av1_free_ref_frame_buffers(cm->buffer_pool);
Angie Chiangf0fbf9d2017-03-15 15:01:22 -0700569 av1_free_txb_buf(cpi);
Yaowu Xuf883b422016-08-30 14:01:10 -0700570 av1_free_context_buffers(cm);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700571
Yaowu Xuf883b422016-08-30 14:01:10 -0700572 aom_free_frame_buffer(&cpi->last_frame_uf);
Yaowu Xuf883b422016-08-30 14:01:10 -0700573 av1_free_restoration_buffers(cm);
Debargha Mukherjee999d2f62016-12-15 13:23:21 -0800574 aom_free_frame_buffer(&cpi->trial_frame_rst);
Yaowu Xuf883b422016-08-30 14:01:10 -0700575 aom_free_frame_buffer(&cpi->scaled_source);
576 aom_free_frame_buffer(&cpi->scaled_last_source);
577 aom_free_frame_buffer(&cpi->alt_ref_buffer);
578 av1_lookahead_destroy(cpi->lookahead);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700579
Yaowu Xuf883b422016-08-30 14:01:10 -0700580 aom_free(cpi->tile_tok[0][0]);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700581 cpi->tile_tok[0][0] = 0;
582
Ravi Chaudhary73cf15b2018-08-30 10:52:51 +0530583 aom_free(cpi->tplist[0][0]);
584 cpi->tplist[0][0] = NULL;
585
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +0000586 av1_free_pc_tree(&cpi->td, num_planes);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700587
hui sud9a812b2017-07-06 14:34:37 -0700588 aom_free(cpi->td.mb.palette_buffer);
Neil Birkbecka2893ab2018-06-08 14:45:13 -0700589
Urvang Joshi0a4cfad2018-09-07 11:10:39 -0700590 aom_free(cpi->td.mb.tmp_conv_dst);
591 for (int j = 0; j < 2; ++j) {
592 aom_free(cpi->td.mb.tmp_obmc_bufs[j]);
593 }
594
Neil Birkbecka2893ab2018-06-08 14:45:13 -0700595#if CONFIG_DENOISE
596 if (cpi->denoise_and_model) {
597 aom_denoise_and_model_free(cpi->denoise_and_model);
598 cpi->denoise_and_model = NULL;
599 }
600#endif
601 if (cpi->film_grain_table) {
602 aom_film_grain_table_free(cpi->film_grain_table);
603 cpi->film_grain_table = NULL;
604 }
Yaowu Xuc27fc142016-08-22 16:08:15 -0700605}
606
Yaowu Xuf883b422016-08-30 14:01:10 -0700607static void save_coding_context(AV1_COMP *cpi) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700608 CODING_CONTEXT *const cc = &cpi->coding_context;
Yaowu Xuf883b422016-08-30 14:01:10 -0700609 AV1_COMMON *cm = &cpi->common;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700610
Sebastien Alaiwane140c502017-04-27 09:52:34 +0200611 // Stores a snapshot of key state variables which can subsequently be
612 // restored with a call to av1_restore_coding_context. These functions are
613 // intended for use in a re-code loop in av1_compress_frame where the
614 // quantizer value is adjusted between loop iterations.
Jingning Hanf050fc12018-03-09 14:53:33 -0800615 av1_copy(cc->nmv_vec_cost, cpi->td.mb.nmv_vec_cost);
616 av1_copy(cc->nmv_costs, cpi->nmv_costs);
617 av1_copy(cc->nmv_costs_hp, cpi->nmv_costs_hp);
James Zern01a9d702017-08-25 19:09:33 +0000618
Yaowu Xuc27fc142016-08-22 16:08:15 -0700619 cc->fc = *cm->fc;
620}
621
Yaowu Xuf883b422016-08-30 14:01:10 -0700622static void restore_coding_context(AV1_COMP *cpi) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700623 CODING_CONTEXT *const cc = &cpi->coding_context;
Yaowu Xuf883b422016-08-30 14:01:10 -0700624 AV1_COMMON *cm = &cpi->common;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700625
Sebastien Alaiwane140c502017-04-27 09:52:34 +0200626 // Restore key state variables to the snapshot state stored in the
627 // previous call to av1_save_coding_context.
Jingning Hanf050fc12018-03-09 14:53:33 -0800628 av1_copy(cpi->td.mb.nmv_vec_cost, cc->nmv_vec_cost);
629 av1_copy(cpi->nmv_costs, cc->nmv_costs);
630 av1_copy(cpi->nmv_costs_hp, cc->nmv_costs_hp);
James Zern01a9d702017-08-25 19:09:33 +0000631
Yaowu Xuc27fc142016-08-22 16:08:15 -0700632 *cm->fc = cc->fc;
633}
634
Yaowu Xuf883b422016-08-30 14:01:10 -0700635static void configure_static_seg_features(AV1_COMP *cpi) {
636 AV1_COMMON *const cm = &cpi->common;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700637 const RATE_CONTROL *const rc = &cpi->rc;
638 struct segmentation *const seg = &cm->seg;
639
640 int high_q = (int)(rc->avg_q > 48.0);
641 int qi_delta;
642
643 // Disable and clear down for KF
David Turnerd2a592e2018-11-16 14:59:31 +0000644 if (cm->current_frame.frame_type == KEY_FRAME) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700645 // Clear down the global segmentation map
646 memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
647 seg->update_map = 0;
648 seg->update_data = 0;
649 cpi->static_mb_pct = 0;
650
651 // Disable segmentation
Yaowu Xuf883b422016-08-30 14:01:10 -0700652 av1_disable_segmentation(seg);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700653
654 // Clear down the segment features.
Yaowu Xuf883b422016-08-30 14:01:10 -0700655 av1_clearall_segfeatures(seg);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700656 } else if (cpi->refresh_alt_ref_frame) {
657 // If this is an alt ref frame
658 // Clear down the global segmentation map
659 memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
660 seg->update_map = 0;
661 seg->update_data = 0;
662 cpi->static_mb_pct = 0;
663
664 // Disable segmentation and individual segment features by default
Yaowu Xuf883b422016-08-30 14:01:10 -0700665 av1_disable_segmentation(seg);
666 av1_clearall_segfeatures(seg);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700667
668 // Scan frames from current to arf frame.
669 // This function re-enables segmentation if appropriate.
Yaowu Xuf883b422016-08-30 14:01:10 -0700670 av1_update_mbgraph_stats(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700671
672 // If segmentation was enabled set those features needed for the
673 // arf itself.
674 if (seg->enabled) {
675 seg->update_map = 1;
676 seg->update_data = 1;
677
Urvang Joshi20cf30e2018-07-19 02:33:58 -0700678 qi_delta = av1_compute_qdelta(rc, rc->avg_q, rc->avg_q * 0.875,
679 cm->seq_params.bit_depth);
Yaowu Xuf883b422016-08-30 14:01:10 -0700680 av1_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta - 2);
Cheng Chend8184da2017-09-26 18:15:22 -0700681 av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_Y_H, -2);
682 av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_Y_V, -2);
683 av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_U, -2);
684 av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_V, -2);
685
686 av1_enable_segfeature(seg, 1, SEG_LVL_ALT_LF_Y_H);
687 av1_enable_segfeature(seg, 1, SEG_LVL_ALT_LF_Y_V);
688 av1_enable_segfeature(seg, 1, SEG_LVL_ALT_LF_U);
689 av1_enable_segfeature(seg, 1, SEG_LVL_ALT_LF_V);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700690
Yaowu Xuf883b422016-08-30 14:01:10 -0700691 av1_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700692 }
693 } else if (seg->enabled) {
694 // All other frames if segmentation has been enabled
695
696 // First normal frame in a valid gf or alt ref group
697 if (rc->frames_since_golden == 0) {
698 // Set up segment features for normal frames in an arf group
699 if (rc->source_alt_ref_active) {
700 seg->update_map = 0;
701 seg->update_data = 1;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700702
Urvang Joshi20cf30e2018-07-19 02:33:58 -0700703 qi_delta = av1_compute_qdelta(rc, rc->avg_q, rc->avg_q * 1.125,
704 cm->seq_params.bit_depth);
Yaowu Xuf883b422016-08-30 14:01:10 -0700705 av1_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta + 2);
706 av1_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700707
Cheng Chend8184da2017-09-26 18:15:22 -0700708 av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_Y_H, -2);
709 av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_Y_V, -2);
710 av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_U, -2);
711 av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_V, -2);
712
713 av1_enable_segfeature(seg, 1, SEG_LVL_ALT_LF_Y_H);
714 av1_enable_segfeature(seg, 1, SEG_LVL_ALT_LF_Y_V);
715 av1_enable_segfeature(seg, 1, SEG_LVL_ALT_LF_U);
716 av1_enable_segfeature(seg, 1, SEG_LVL_ALT_LF_V);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700717
718 // Segment coding disabled for compred testing
719 if (high_q || (cpi->static_mb_pct == 100)) {
Yaowu Xuf883b422016-08-30 14:01:10 -0700720 av1_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME);
721 av1_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME);
722 av1_enable_segfeature(seg, 1, SEG_LVL_SKIP);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700723 }
724 } else {
725 // Disable segmentation and clear down features if alt ref
726 // is not active for this group
727
Yaowu Xuf883b422016-08-30 14:01:10 -0700728 av1_disable_segmentation(seg);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700729
730 memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
731
732 seg->update_map = 0;
733 seg->update_data = 0;
734
Yaowu Xuf883b422016-08-30 14:01:10 -0700735 av1_clearall_segfeatures(seg);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700736 }
737 } else if (rc->is_src_frame_alt_ref) {
738 // Special case where we are coding over the top of a previous
739 // alt ref frame.
740 // Segment coding disabled for compred testing
741
742 // Enable ref frame features for segment 0 as well
Yaowu Xuf883b422016-08-30 14:01:10 -0700743 av1_enable_segfeature(seg, 0, SEG_LVL_REF_FRAME);
744 av1_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700745
746 // All mbs should use ALTREF_FRAME
Yaowu Xuf883b422016-08-30 14:01:10 -0700747 av1_clear_segdata(seg, 0, SEG_LVL_REF_FRAME);
748 av1_set_segdata(seg, 0, SEG_LVL_REF_FRAME, ALTREF_FRAME);
749 av1_clear_segdata(seg, 1, SEG_LVL_REF_FRAME);
750 av1_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700751
752 // Skip all MBs if high Q (0,0 mv and skip coeffs)
753 if (high_q) {
Yaowu Xuf883b422016-08-30 14:01:10 -0700754 av1_enable_segfeature(seg, 0, SEG_LVL_SKIP);
755 av1_enable_segfeature(seg, 1, SEG_LVL_SKIP);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700756 }
757 // Enable data update
758 seg->update_data = 1;
759 } else {
760 // All other frames.
761
762 // No updates.. leave things as they are.
763 seg->update_map = 0;
764 seg->update_data = 0;
765 }
766 }
767}
768
Yaowu Xuf883b422016-08-30 14:01:10 -0700769static void update_reference_segmentation_map(AV1_COMP *cpi) {
770 AV1_COMMON *const cm = &cpi->common;
Yushin Choa7f65922018-04-04 16:06:11 -0700771 MB_MODE_INFO **mi_4x4_ptr = cm->mi_grid_visible;
David Turnerb757ce02018-11-12 15:01:28 +0000772 uint8_t *cache_ptr = cm->cur_frame->seg_map;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700773 int row, col;
774
775 for (row = 0; row < cm->mi_rows; row++) {
Yushin Choa7f65922018-04-04 16:06:11 -0700776 MB_MODE_INFO **mi_4x4 = mi_4x4_ptr;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700777 uint8_t *cache = cache_ptr;
Yushin Choa7f65922018-04-04 16:06:11 -0700778 for (col = 0; col < cm->mi_cols; col++, mi_4x4++, cache++)
779 cache[0] = mi_4x4[0]->segment_id;
780 mi_4x4_ptr += cm->mi_stride;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700781 cache_ptr += cm->mi_cols;
782 }
783}
784
Yaowu Xuf883b422016-08-30 14:01:10 -0700785static void alloc_raw_frame_buffers(AV1_COMP *cpi) {
786 AV1_COMMON *cm = &cpi->common;
Urvang Joshi20cf30e2018-07-19 02:33:58 -0700787 const SequenceHeader *const seq_params = &cm->seq_params;
Yaowu Xuf883b422016-08-30 14:01:10 -0700788 const AV1EncoderConfig *oxcf = &cpi->oxcf;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700789
Satish Kumar Suman7a7239b2019-03-13 14:48:14 +0530790 if (!cpi->lookahead) {
791 int is_scale = (oxcf->resize_mode || oxcf->superres_mode);
Satish Kumar Suman29909962019-01-09 10:31:21 +0530792 cpi->lookahead = av1_lookahead_init(
793 oxcf->width, oxcf->height, seq_params->subsampling_x,
794 seq_params->subsampling_y, seq_params->use_highbitdepth,
Satish Kumar Suman7a7239b2019-03-13 14:48:14 +0530795 oxcf->lag_in_frames, oxcf->border_in_pixels, is_scale);
796 }
Yaowu Xuc27fc142016-08-22 16:08:15 -0700797 if (!cpi->lookahead)
Yaowu Xuf883b422016-08-30 14:01:10 -0700798 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
Yaowu Xuc27fc142016-08-22 16:08:15 -0700799 "Failed to allocate lag buffers");
800
801 // TODO(agrange) Check if ARF is enabled and skip allocation if not.
Urvang Joshi20cf30e2018-07-19 02:33:58 -0700802 if (aom_realloc_frame_buffer(
803 &cpi->alt_ref_buffer, oxcf->width, oxcf->height,
804 seq_params->subsampling_x, seq_params->subsampling_y,
Satish Kumar Suman29909962019-01-09 10:31:21 +0530805 seq_params->use_highbitdepth, oxcf->border_in_pixels,
Urvang Joshi20cf30e2018-07-19 02:33:58 -0700806 cm->byte_alignment, NULL, NULL, NULL))
Yaowu Xuf883b422016-08-30 14:01:10 -0700807 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
Yaowu Xuc27fc142016-08-22 16:08:15 -0700808 "Failed to allocate altref buffer");
809}
810
Yaowu Xuf883b422016-08-30 14:01:10 -0700811static void alloc_util_frame_buffers(AV1_COMP *cpi) {
812 AV1_COMMON *const cm = &cpi->common;
Urvang Joshi20cf30e2018-07-19 02:33:58 -0700813 const SequenceHeader *const seq_params = &cm->seq_params;
814 if (aom_realloc_frame_buffer(
815 &cpi->last_frame_uf, cm->width, cm->height, seq_params->subsampling_x,
816 seq_params->subsampling_y, seq_params->use_highbitdepth,
Satish Kumar Suman29909962019-01-09 10:31:21 +0530817 cpi->oxcf.border_in_pixels, cm->byte_alignment, NULL, NULL, NULL))
Yaowu Xuf883b422016-08-30 14:01:10 -0700818 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
Yaowu Xuc27fc142016-08-22 16:08:15 -0700819 "Failed to allocate last frame buffer");
820
Fergus Simpson9cd57cf2017-06-12 17:02:03 -0700821 if (aom_realloc_frame_buffer(
Debargha Mukherjee3a4959f2018-02-26 15:34:03 -0800822 &cpi->trial_frame_rst, cm->superres_upscaled_width,
Urvang Joshi20cf30e2018-07-19 02:33:58 -0700823 cm->superres_upscaled_height, seq_params->subsampling_x,
824 seq_params->subsampling_y, seq_params->use_highbitdepth,
Satish Kumar Suman3b12c002018-12-19 15:27:20 +0530825 AOM_RESTORATION_FRAME_BORDER, cm->byte_alignment, NULL, NULL, NULL))
Debargha Mukherjee874d36d2016-12-14 16:53:17 -0800826 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
Debargha Mukherjee999d2f62016-12-15 13:23:21 -0800827 "Failed to allocate trial restored frame buffer");
Yaowu Xuc27fc142016-08-22 16:08:15 -0700828
Urvang Joshi20cf30e2018-07-19 02:33:58 -0700829 if (aom_realloc_frame_buffer(
830 &cpi->scaled_source, cm->width, cm->height, seq_params->subsampling_x,
831 seq_params->subsampling_y, seq_params->use_highbitdepth,
Satish Kumar Suman29909962019-01-09 10:31:21 +0530832 cpi->oxcf.border_in_pixels, cm->byte_alignment, NULL, NULL, NULL))
Yaowu Xuf883b422016-08-30 14:01:10 -0700833 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
Yaowu Xuc27fc142016-08-22 16:08:15 -0700834 "Failed to allocate scaled source buffer");
835
Urvang Joshi20cf30e2018-07-19 02:33:58 -0700836 if (aom_realloc_frame_buffer(
837 &cpi->scaled_last_source, cm->width, cm->height,
838 seq_params->subsampling_x, seq_params->subsampling_y,
Satish Kumar Suman29909962019-01-09 10:31:21 +0530839 seq_params->use_highbitdepth, cpi->oxcf.border_in_pixels,
Urvang Joshi20cf30e2018-07-19 02:33:58 -0700840 cm->byte_alignment, NULL, NULL, NULL))
Yaowu Xuf883b422016-08-30 14:01:10 -0700841 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
Yaowu Xuc27fc142016-08-22 16:08:15 -0700842 "Failed to allocate scaled last source buffer");
843}
844
Cheng Chen46f30c72017-09-07 11:13:33 -0700845static void alloc_compressor_data(AV1_COMP *cpi) {
Yaowu Xuf883b422016-08-30 14:01:10 -0700846 AV1_COMMON *cm = &cpi->common;
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +0000847 const int num_planes = av1_num_planes(cm);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700848
Yaowu Xuf883b422016-08-30 14:01:10 -0700849 av1_alloc_context_buffers(cm, cm->width, cm->height);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700850
Ravi Chaudhary73cf15b2018-08-30 10:52:51 +0530851 int mi_rows_aligned_to_sb =
852 ALIGN_POWER_OF_TWO(cm->mi_rows, cm->seq_params.mib_size_log2);
853 int sb_rows = mi_rows_aligned_to_sb >> cm->seq_params.mib_size_log2;
854
Angie Chiangf0fbf9d2017-03-15 15:01:22 -0700855 av1_alloc_txb_buf(cpi);
Angie Chiangf0fbf9d2017-03-15 15:01:22 -0700856
Yaowu Xuc27fc142016-08-22 16:08:15 -0700857 alloc_context_buffers_ext(cpi);
858
Yaowu Xuf883b422016-08-30 14:01:10 -0700859 aom_free(cpi->tile_tok[0][0]);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700860
861 {
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +0000862 unsigned int tokens =
863 get_token_alloc(cm->mb_rows, cm->mb_cols, MAX_SB_SIZE_LOG2, num_planes);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700864 CHECK_MEM_ERROR(cm, cpi->tile_tok[0][0],
Yaowu Xuf883b422016-08-30 14:01:10 -0700865 aom_calloc(tokens, sizeof(*cpi->tile_tok[0][0])));
Yaowu Xuc27fc142016-08-22 16:08:15 -0700866 }
Ravi Chaudhary73cf15b2018-08-30 10:52:51 +0530867 aom_free(cpi->tplist[0][0]);
868
869 CHECK_MEM_ERROR(cm, cpi->tplist[0][0],
870 aom_calloc(sb_rows * MAX_TILE_ROWS * MAX_TILE_COLS,
871 sizeof(*cpi->tplist[0][0])));
Yaowu Xuc27fc142016-08-22 16:08:15 -0700872
Yaowu Xuf883b422016-08-30 14:01:10 -0700873 av1_setup_pc_tree(&cpi->common, &cpi->td);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700874}
875
Yaowu Xuf883b422016-08-30 14:01:10 -0700876void av1_new_framerate(AV1_COMP *cpi, double framerate) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700877 cpi->framerate = framerate < 0.1 ? 30 : framerate;
Debargha Mukherjee7166f222017-09-05 21:32:42 -0700878 av1_rc_update_framerate(cpi, cpi->common.width, cpi->common.height);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700879}
880
Yunqing Wang75e20e82018-06-16 12:10:48 -0700881static void set_tile_info(AV1_COMP *cpi) {
Dominic Symesdb5d66f2017-08-18 18:11:34 +0200882 AV1_COMMON *const cm = &cpi->common;
Dominic Symesf58f1112017-09-25 12:47:40 +0200883 int i, start_sb;
Dominic Symesdb5d66f2017-08-18 18:11:34 +0200884
885 av1_get_tile_limits(cm);
Dominic Symesdb5d66f2017-08-18 18:11:34 +0200886
887 // configure tile columns
Dominic Symes26ad0b22017-10-01 16:35:13 +0200888 if (cpi->oxcf.tile_width_count == 0 || cpi->oxcf.tile_height_count == 0) {
Dominic Symesf58f1112017-09-25 12:47:40 +0200889 cm->uniform_tile_spacing_flag = 1;
Dominic Symesdb5d66f2017-08-18 18:11:34 +0200890 cm->log2_tile_cols = AOMMAX(cpi->oxcf.tile_columns, cm->min_log2_tile_cols);
891 cm->log2_tile_cols = AOMMIN(cm->log2_tile_cols, cm->max_log2_tile_cols);
Dominic Symesf58f1112017-09-25 12:47:40 +0200892 } else {
Imdad Sardharwalla4ec84ab2018-02-06 12:20:18 +0000893 int mi_cols = ALIGN_POWER_OF_TWO(cm->mi_cols, cm->seq_params.mib_size_log2);
894 int sb_cols = mi_cols >> cm->seq_params.mib_size_log2;
Dominic Symes26ad0b22017-10-01 16:35:13 +0200895 int size_sb, j = 0;
Dominic Symesf58f1112017-09-25 12:47:40 +0200896 cm->uniform_tile_spacing_flag = 0;
897 for (i = 0, start_sb = 0; start_sb < sb_cols && i < MAX_TILE_COLS; i++) {
898 cm->tile_col_start_sb[i] = start_sb;
Dominic Symes26ad0b22017-10-01 16:35:13 +0200899 size_sb = cpi->oxcf.tile_widths[j++];
900 if (j >= cpi->oxcf.tile_width_count) j = 0;
David Barker6cd5a822018-03-05 16:19:28 +0000901 start_sb += AOMMIN(size_sb, cm->max_tile_width_sb);
Dominic Symesf58f1112017-09-25 12:47:40 +0200902 }
903 cm->tile_cols = i;
904 cm->tile_col_start_sb[i] = sb_cols;
Dominic Symesdb5d66f2017-08-18 18:11:34 +0200905 }
906 av1_calculate_tile_cols(cm);
907
908 // configure tile rows
909 if (cm->uniform_tile_spacing_flag) {
910 cm->log2_tile_rows = AOMMAX(cpi->oxcf.tile_rows, cm->min_log2_tile_rows);
911 cm->log2_tile_rows = AOMMIN(cm->log2_tile_rows, cm->max_log2_tile_rows);
Dominic Symesf58f1112017-09-25 12:47:40 +0200912 } else {
Imdad Sardharwalla4ec84ab2018-02-06 12:20:18 +0000913 int mi_rows = ALIGN_POWER_OF_TWO(cm->mi_rows, cm->seq_params.mib_size_log2);
914 int sb_rows = mi_rows >> cm->seq_params.mib_size_log2;
Dominic Symes26ad0b22017-10-01 16:35:13 +0200915 int size_sb, j = 0;
Dominic Symesf58f1112017-09-25 12:47:40 +0200916 for (i = 0, start_sb = 0; start_sb < sb_rows && i < MAX_TILE_ROWS; i++) {
917 cm->tile_row_start_sb[i] = start_sb;
Dominic Symes26ad0b22017-10-01 16:35:13 +0200918 size_sb = cpi->oxcf.tile_heights[j++];
919 if (j >= cpi->oxcf.tile_height_count) j = 0;
920 start_sb += AOMMIN(size_sb, cm->max_tile_height_sb);
Dominic Symesf58f1112017-09-25 12:47:40 +0200921 }
922 cm->tile_rows = i;
923 cm->tile_row_start_sb[i] = sb_rows;
Dominic Symesdb5d66f2017-08-18 18:11:34 +0200924 }
925 av1_calculate_tile_rows(cm);
926}
927
Yaowu Xuf883b422016-08-30 14:01:10 -0700928static void update_frame_size(AV1_COMP *cpi) {
929 AV1_COMMON *const cm = &cpi->common;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700930 MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
931
Yaowu Xuf883b422016-08-30 14:01:10 -0700932 av1_set_mb_mi(cm, cm->width, cm->height);
933 av1_init_context_buffers(cm);
Luc Trudeau1e84af52017-11-25 15:00:28 -0500934 av1_init_macroblockd(cm, xd, NULL);
Yaowu Xuc27fc142016-08-22 16:08:15 -0700935 memset(cpi->mbmi_ext_base, 0,
936 cm->mi_rows * cm->mi_cols * sizeof(*cpi->mbmi_ext_base));
Yaowu Xuc27fc142016-08-22 16:08:15 -0700937 set_tile_info(cpi);
938}
939
Yaowu Xuf883b422016-08-30 14:01:10 -0700940static void init_buffer_indices(AV1_COMP *cpi) {
Yaowu Xuc27fc142016-08-22 16:08:15 -0700941 int fb_idx;
Zoe Liu5989a722018-03-29 13:37:36 -0700942 for (fb_idx = 0; fb_idx < REF_FRAMES; ++fb_idx)
David Turnera21966b2018-12-05 14:48:49 +0000943 cpi->common.remapped_ref_idx[fb_idx] = fb_idx;
RogerZhou3b635242017-09-19 10:06:46 -0700944 cpi->rate_index = 0;
945 cpi->rate_size = 0;
Yaowu Xuc27fc142016-08-22 16:08:15 -0700946}
947
Debargha Mukherjee57498692018-05-11 13:29:31 -0700948static INLINE int does_level_match(int width, int height, double fps,
949 int lvl_width, int lvl_height,
950 double lvl_fps, int lvl_dim_mult) {
951 const int64_t lvl_luma_pels = lvl_width * lvl_height;
952 const double lvl_display_sample_rate = lvl_luma_pels * lvl_fps;
953 const int64_t luma_pels = width * height;
954 const double display_sample_rate = luma_pels * fps;
955 return luma_pels <= lvl_luma_pels &&
956 display_sample_rate <= lvl_display_sample_rate &&
957 width <= lvl_width * lvl_dim_mult &&
958 height <= lvl_height * lvl_dim_mult;
959}
960
Andrey Norkin26495512018-06-20 17:13:11 -0700961static void set_bitstream_level_tier(SequenceHeader *seq, AV1_COMMON *cm,
Andrey Norkinf481d982018-05-15 12:05:31 -0700962 const AV1EncoderConfig *oxcf) {
Debargha Mukherjee57498692018-05-11 13:29:31 -0700963 // TODO(any): This is a placeholder function that only addresses dimensions
964 // and max display sample rates.
965 // Need to add checks for max bit rate, max decoded luma sample rate, header
966 // rate, etc. that are not covered by this function.
Hui Su8427ff22019-03-11 10:14:33 -0700967 AV1_LEVEL level = SEQ_LEVEL_MAX;
Debargha Mukherjee57498692018-05-11 13:29:31 -0700968 if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate, 512,
969 288, 30.0, 4)) {
Hui Su8427ff22019-03-11 10:14:33 -0700970 level = SEQ_LEVEL_2_0;
Debargha Mukherjee57498692018-05-11 13:29:31 -0700971 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
972 704, 396, 30.0, 4)) {
Hui Su8427ff22019-03-11 10:14:33 -0700973 level = SEQ_LEVEL_2_1;
Debargha Mukherjee57498692018-05-11 13:29:31 -0700974 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
975 1088, 612, 30.0, 4)) {
Hui Su8427ff22019-03-11 10:14:33 -0700976 level = SEQ_LEVEL_3_0;
Debargha Mukherjee57498692018-05-11 13:29:31 -0700977 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
978 1376, 774, 30.0, 4)) {
Hui Su8427ff22019-03-11 10:14:33 -0700979 level = SEQ_LEVEL_3_1;
Debargha Mukherjee57498692018-05-11 13:29:31 -0700980 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
981 2048, 1152, 30.0, 3)) {
Hui Su8427ff22019-03-11 10:14:33 -0700982 level = SEQ_LEVEL_4_0;
Debargha Mukherjee57498692018-05-11 13:29:31 -0700983 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
984 2048, 1152, 60.0, 3)) {
Hui Su8427ff22019-03-11 10:14:33 -0700985 level = SEQ_LEVEL_4_1;
Debargha Mukherjee57498692018-05-11 13:29:31 -0700986 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
987 4096, 2176, 30.0, 2)) {
Hui Su8427ff22019-03-11 10:14:33 -0700988 level = SEQ_LEVEL_5_0;
Debargha Mukherjee57498692018-05-11 13:29:31 -0700989 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
990 4096, 2176, 60.0, 2)) {
Hui Su8427ff22019-03-11 10:14:33 -0700991 level = SEQ_LEVEL_5_1;
Debargha Mukherjee57498692018-05-11 13:29:31 -0700992 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
993 4096, 2176, 120.0, 2)) {
Hui Su8427ff22019-03-11 10:14:33 -0700994 level = SEQ_LEVEL_5_2;
Debargha Mukherjee57498692018-05-11 13:29:31 -0700995 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
996 8192, 4352, 30.0, 2)) {
Hui Su8427ff22019-03-11 10:14:33 -0700997 level = SEQ_LEVEL_6_0;
Debargha Mukherjee57498692018-05-11 13:29:31 -0700998 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
999 8192, 4352, 60.0, 2)) {
Debargha Mukherjee57498692018-05-11 13:29:31 -07001000 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
1001 8192, 4352, 120.0, 2)) {
Hui Su8427ff22019-03-11 10:14:33 -07001002 level = SEQ_LEVEL_6_2;
Debargha Mukherjee57498692018-05-11 13:29:31 -07001003 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
1004 16384, 8704, 30.0, 2)) {
Hui Su8427ff22019-03-11 10:14:33 -07001005 level = SEQ_LEVEL_7_0;
Debargha Mukherjee57498692018-05-11 13:29:31 -07001006 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
1007 16384, 8704, 60.0, 2)) {
Hui Su8427ff22019-03-11 10:14:33 -07001008 level = SEQ_LEVEL_7_1;
Debargha Mukherjee57498692018-05-11 13:29:31 -07001009 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
1010 16384, 8704, 120.0, 2)) {
Hui Su8427ff22019-03-11 10:14:33 -07001011 level = SEQ_LEVEL_7_2;
Debargha Mukherjee57498692018-05-11 13:29:31 -07001012 }
Debargha Mukherjeeea675402018-05-10 16:10:41 -07001013 for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i) {
Hui Su8427ff22019-03-11 10:14:33 -07001014 seq->seq_level_idx[i] = level;
Andrey Norkin26495512018-06-20 17:13:11 -07001015 // Set the maximum parameters for bitrate and buffer size for this profile,
1016 // level, and tier
1017 cm->op_params[i].bitrate = max_level_bitrate(
Hui Su8427ff22019-03-11 10:14:33 -07001018 cm->seq_params.profile, seq->seq_level_idx[i], seq->tier[i]);
Andrey Norkinc7511de2018-06-22 12:31:06 -07001019 // Level with seq_level_idx = 31 returns a high "dummy" bitrate to pass the
1020 // check
Andrey Norkin26495512018-06-20 17:13:11 -07001021 if (cm->op_params[i].bitrate == 0)
1022 aom_internal_error(
1023 &cm->error, AOM_CODEC_UNSUP_BITSTREAM,
1024 "AV1 does not support this combination of profile, level, and tier.");
Andrey Norkinc7511de2018-06-22 12:31:06 -07001025 // Buffer size in bits/s is bitrate in bits/s * 1 s
Andrey Norkin26495512018-06-20 17:13:11 -07001026 cm->op_params[i].buffer_size = cm->op_params[i].bitrate;
Debargha Mukherjeeea675402018-05-10 16:10:41 -07001027 }
1028}
1029
Andrey Norkin26495512018-06-20 17:13:11 -07001030static void init_seq_coding_tools(SequenceHeader *seq, AV1_COMMON *cm,
1031 const AV1EncoderConfig *oxcf) {
Debargha Mukherjeec6f24c22018-04-07 08:43:08 -07001032 seq->still_picture = (oxcf->limit == 1);
1033 seq->reduced_still_picture_hdr = seq->still_picture;
Debargha Mukherjee9713ccb2018-04-08 19:09:17 -07001034 seq->reduced_still_picture_hdr &= !oxcf->full_still_picture_hdr;
Debargha Mukherjeeedd77252018-03-25 12:01:38 -07001035 seq->force_screen_content_tools = 2;
Debargha Mukherjeeedd77252018-03-25 12:01:38 -07001036 seq->force_integer_mv = 2;
David Turnerebf96f42018-11-14 16:57:57 +00001037 seq->order_hint_info.enable_order_hint = oxcf->enable_order_hint;
David Turner936235c2018-11-28 13:42:01 +00001038 seq->frame_id_numbers_present_flag =
1039 !(seq->still_picture && seq->reduced_still_picture_hdr) &&
1040 !oxcf->large_scale_tile && oxcf->error_resilient_mode;
Debargha Mukherjeec6f24c22018-04-07 08:43:08 -07001041 if (seq->still_picture && seq->reduced_still_picture_hdr) {
David Turnerebf96f42018-11-14 16:57:57 +00001042 seq->order_hint_info.enable_order_hint = 0;
Debargha Mukherjeec6f24c22018-04-07 08:43:08 -07001043 seq->force_screen_content_tools = 2;
1044 seq->force_integer_mv = 2;
1045 }
David Turnerebf96f42018-11-14 16:57:57 +00001046 seq->order_hint_info.order_hint_bits_minus_1 =
1047 seq->order_hint_info.enable_order_hint
1048 ? DEFAULT_EXPLICIT_ORDER_HINT_BITS - 1
1049 : -1;
Debargha Mukherjeec6f24c22018-04-07 08:43:08 -07001050
David Turner760a2f42018-12-07 15:25:36 +00001051 seq->max_frame_width =
1052 oxcf->forced_max_frame_width ? oxcf->forced_max_frame_width : oxcf->width;
1053 seq->max_frame_height = oxcf->forced_max_frame_height
1054 ? oxcf->forced_max_frame_height
1055 : oxcf->height;
1056 seq->num_bits_width =
1057 (seq->max_frame_width > 1) ? get_msb(seq->max_frame_width - 1) + 1 : 1;
1058 seq->num_bits_height =
1059 (seq->max_frame_height > 1) ? get_msb(seq->max_frame_height - 1) + 1 : 1;
1060 assert(seq->num_bits_width <= 16);
1061 assert(seq->num_bits_height <= 16);
1062
1063 seq->frame_id_length = FRAME_ID_LENGTH;
1064 seq->delta_frame_id_length = DELTA_FRAME_ID_LENGTH;
1065
Debargha Mukherjeec6f24c22018-04-07 08:43:08 -07001066 seq->enable_dual_filter = oxcf->enable_dual_filter;
Debargha Mukherjee7ac3eb12018-12-12 10:26:50 -08001067 seq->order_hint_info.enable_dist_wtd_comp = oxcf->enable_dist_wtd_comp;
1068 seq->order_hint_info.enable_dist_wtd_comp &=
David Turnerebf96f42018-11-14 16:57:57 +00001069 seq->order_hint_info.enable_order_hint;
1070 seq->order_hint_info.enable_ref_frame_mvs = oxcf->enable_ref_frame_mvs;
1071 seq->order_hint_info.enable_ref_frame_mvs &=
1072 seq->order_hint_info.enable_order_hint;
Debargha Mukherjeeedd77252018-03-25 12:01:38 -07001073 seq->enable_superres = oxcf->enable_superres;
1074 seq->enable_cdef = oxcf->enable_cdef;
1075 seq->enable_restoration = oxcf->enable_restoration;
Debargha Mukherjee37df9162018-03-25 12:48:24 -07001076 seq->enable_warped_motion = oxcf->enable_warped_motion;
Debargha Mukherjee16ea6ba2018-12-10 12:01:38 -08001077 seq->enable_interintra_compound = oxcf->enable_interintra_comp;
1078 seq->enable_masked_compound = oxcf->enable_masked_comp;
Debargha Mukherjee03c43ba2018-12-14 13:08:08 -08001079 seq->enable_intra_edge_filter = oxcf->enable_intra_edge_filter;
Yue Chen8f9ca582018-12-12 15:11:47 -08001080 seq->enable_filter_intra = oxcf->enable_filter_intra;
Debargha Mukherjee57498692018-05-11 13:29:31 -07001081
Andrey Norkin26495512018-06-20 17:13:11 -07001082 set_bitstream_level_tier(seq, cm, oxcf);
Adrian Grangec56f6ec2018-05-31 14:19:32 -07001083
1084 if (seq->operating_points_cnt_minus_1 == 0) {
1085 seq->operating_point_idc[0] = 0;
1086 } else {
1087 // Set operating_point_idc[] such that for the i-th operating point the
1088 // first (operating_points_cnt-i) spatial layers and the first temporal
1089 // layer are decoded Note that highest quality operating point should come
1090 // first
1091 for (int i = 0; i < seq->operating_points_cnt_minus_1 + 1; i++)
1092 seq->operating_point_idc[i] =
1093 (~(~0u << (seq->operating_points_cnt_minus_1 + 1 - i)) << 8) | 1;
1094 }
Debargha Mukherjeeedd77252018-03-25 12:01:38 -07001095}
1096
Yaowu Xuf883b422016-08-30 14:01:10 -07001097static void init_config(struct AV1_COMP *cpi, AV1EncoderConfig *oxcf) {
1098 AV1_COMMON *const cm = &cpi->common;
Yaowu Xuc27fc142016-08-22 16:08:15 -07001099
1100 cpi->oxcf = *oxcf;
1101 cpi->framerate = oxcf->init_framerate;
1102
Urvang Joshi20cf30e2018-07-19 02:33:58 -07001103 cm->seq_params.profile = oxcf->profile;
1104 cm->seq_params.bit_depth = oxcf->bit_depth;
1105 cm->seq_params.use_highbitdepth = oxcf->use_highbitdepth;
1106 cm->seq_params.color_primaries = oxcf->color_primaries;
1107 cm->seq_params.transfer_characteristics = oxcf->transfer_characteristics;
1108 cm->seq_params.matrix_coefficients = oxcf->matrix_coefficients;
Debargha Mukherjeef340fec2018-01-10 18:12:22 -08001109 cm->seq_params.monochrome = oxcf->monochrome;
Urvang Joshi20cf30e2018-07-19 02:33:58 -07001110 cm->seq_params.chroma_sample_position = oxcf->chroma_sample_position;
1111 cm->seq_params.color_range = oxcf->color_range;
Andrey Norkin28e9ce22018-01-08 10:11:21 -08001112 cm->timing_info_present = oxcf->timing_info_present;
Andrey Norkin795ba872018-03-06 13:24:14 -08001113 cm->timing_info.num_units_in_display_tick =
1114 oxcf->timing_info.num_units_in_display_tick;
1115 cm->timing_info.time_scale = oxcf->timing_info.time_scale;
1116 cm->timing_info.equal_picture_interval =
1117 oxcf->timing_info.equal_picture_interval;
1118 cm->timing_info.num_ticks_per_picture =
1119 oxcf->timing_info.num_ticks_per_picture;
1120
Andrey Norkin26495512018-06-20 17:13:11 -07001121 cm->seq_params.display_model_info_present_flag =
1122 oxcf->display_model_info_present_flag;
Adrian Grangec56f6ec2018-05-31 14:19:32 -07001123 cm->seq_params.decoder_model_info_present_flag =
1124 oxcf->decoder_model_info_present_flag;
Andrey Norkin795ba872018-03-06 13:24:14 -08001125 if (oxcf->decoder_model_info_present_flag) {
Andrey Norkin26495512018-06-20 17:13:11 -07001126 // set the decoder model parameters in schedule mode
Andrey Norkin795ba872018-03-06 13:24:14 -08001127 cm->buffer_model.num_units_in_decoding_tick =
1128 oxcf->buffer_model.num_units_in_decoding_tick;
Wan-Teh Changf64b3bc2018-07-02 09:42:39 -07001129 cm->buffer_removal_time_present = 1;
Andrey Norkin795ba872018-03-06 13:24:14 -08001130 set_aom_dec_model_info(&cm->buffer_model);
Andrey Norkin26495512018-06-20 17:13:11 -07001131 set_dec_model_op_parameters(&cm->op_params[0]);
1132 } else if (cm->timing_info_present &&
1133 cm->timing_info.equal_picture_interval &&
1134 !cm->seq_params.decoder_model_info_present_flag) {
1135 // set the decoder model parameters in resource availability mode
1136 set_resource_availability_parameters(&cm->op_params[0]);
Andrey Norkinc7511de2018-06-22 12:31:06 -07001137 } else {
1138 cm->op_params[0].initial_display_delay =
1139 10; // Default value (not signaled)
Andrey Norkin795ba872018-03-06 13:24:14 -08001140 }
Andrey Norkinc7511de2018-06-22 12:31:06 -07001141
Tom Fineganf8d6a162018-08-21 10:47:55 -07001142 if (cm->seq_params.monochrome) {
1143 cm->seq_params.subsampling_x = 1;
1144 cm->seq_params.subsampling_y = 1;
1145 } else if (cm->seq_params.color_primaries == AOM_CICP_CP_BT_709 &&
1146 cm->seq_params.transfer_characteristics == AOM_CICP_TC_SRGB &&
1147 cm->seq_params.matrix_coefficients == AOM_CICP_MC_IDENTITY) {
1148 cm->seq_params.subsampling_x = 0;
1149 cm->seq_params.subsampling_y = 0;
1150 } else {
1151 if (cm->seq_params.profile == 0) {
1152 cm->seq_params.subsampling_x = 1;
1153 cm->seq_params.subsampling_y = 1;
1154 } else if (cm->seq_params.profile == 1) {
1155 cm->seq_params.subsampling_x = 0;
1156 cm->seq_params.subsampling_y = 0;
1157 } else {
1158 if (cm->seq_params.bit_depth == AOM_BITS_12) {
1159 cm->seq_params.subsampling_x = oxcf->chroma_subsampling_x;
1160 cm->seq_params.subsampling_y = oxcf->chroma_subsampling_y;
1161 } else {
1162 cm->seq_params.subsampling_x = 1;
1163 cm->seq_params.subsampling_y = 0;
1164 }
1165 }
Tom Finegan02b2a842018-08-24 13:50:00 -07001166 }
1167
Yaowu Xuc27fc142016-08-22 16:08:15 -07001168 cm->width = oxcf->width;
1169 cm->height = oxcf->height;
Imdad Sardharwalla4ec84ab2018-02-06 12:20:18 +00001170 set_sb_size(&cm->seq_params,
1171 select_sb_size(cpi)); // set sb size before allocations
Cheng Chen46f30c72017-09-07 11:13:33 -07001172 alloc_compressor_data(cpi);
Yaowu Xuc7119a72018-03-29 09:59:37 -07001173
Andrey Norkin6f1c2f72018-01-15 20:08:52 -08001174 update_film_grain_parameters(cpi, oxcf);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001175
1176 // Single thread case: use counts in common.
Yue Chencc6a6ef2018-05-21 16:21:05 -07001177 cpi->td.counts = &cpi->counts;
Yaowu Xuc27fc142016-08-22 16:08:15 -07001178
1179 // change includes all joint functionality
Yaowu Xuf883b422016-08-30 14:01:10 -07001180 av1_change_config(cpi, oxcf);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001181
1182 cpi->static_mb_pct = 0;
1183 cpi->ref_frame_flags = 0;
1184
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07001185 // Reset resize pending flags
1186 cpi->resize_pending_width = 0;
1187 cpi->resize_pending_height = 0;
1188
Yaowu Xuc27fc142016-08-22 16:08:15 -07001189 init_buffer_indices(cpi);
1190}
1191
1192static void set_rc_buffer_sizes(RATE_CONTROL *rc,
Yaowu Xuf883b422016-08-30 14:01:10 -07001193 const AV1EncoderConfig *oxcf) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07001194 const int64_t bandwidth = oxcf->target_bandwidth;
1195 const int64_t starting = oxcf->starting_buffer_level_ms;
1196 const int64_t optimal = oxcf->optimal_buffer_level_ms;
1197 const int64_t maximum = oxcf->maximum_buffer_size_ms;
1198
1199 rc->starting_buffer_level = starting * bandwidth / 1000;
1200 rc->optimal_buffer_level =
1201 (optimal == 0) ? bandwidth / 8 : optimal * bandwidth / 1000;
1202 rc->maximum_buffer_size =
1203 (maximum == 0) ? bandwidth / 8 : maximum * bandwidth / 1000;
1204}
1205
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001206#define HIGHBD_BFP(BT, SDF, SDAF, VF, SVF, SVAF, SDX4DF, JSDAF, JSVAF) \
1207 cpi->fn_ptr[BT].sdf = SDF; \
1208 cpi->fn_ptr[BT].sdaf = SDAF; \
1209 cpi->fn_ptr[BT].vf = VF; \
1210 cpi->fn_ptr[BT].svf = SVF; \
1211 cpi->fn_ptr[BT].svaf = SVAF; \
1212 cpi->fn_ptr[BT].sdx4df = SDX4DF; \
1213 cpi->fn_ptr[BT].jsdaf = JSDAF; \
Cheng Chenbf3d4962017-11-01 14:48:52 -07001214 cpi->fn_ptr[BT].jsvaf = JSVAF;
Yaowu Xuc27fc142016-08-22 16:08:15 -07001215
1216#define MAKE_BFP_SAD_WRAPPER(fnname) \
1217 static unsigned int fnname##_bits8(const uint8_t *src_ptr, \
1218 int source_stride, \
1219 const uint8_t *ref_ptr, int ref_stride) { \
1220 return fnname(src_ptr, source_stride, ref_ptr, ref_stride); \
1221 } \
1222 static unsigned int fnname##_bits10( \
1223 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1224 int ref_stride) { \
1225 return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 2; \
1226 } \
1227 static unsigned int fnname##_bits12( \
1228 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1229 int ref_stride) { \
1230 return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 4; \
1231 }
1232
1233#define MAKE_BFP_SADAVG_WRAPPER(fnname) \
1234 static unsigned int fnname##_bits8( \
1235 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1236 int ref_stride, const uint8_t *second_pred) { \
1237 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred); \
1238 } \
1239 static unsigned int fnname##_bits10( \
1240 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1241 int ref_stride, const uint8_t *second_pred) { \
1242 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred) >> \
1243 2; \
1244 } \
1245 static unsigned int fnname##_bits12( \
1246 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1247 int ref_stride, const uint8_t *second_pred) { \
1248 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred) >> \
1249 4; \
1250 }
1251
Yaowu Xuc27fc142016-08-22 16:08:15 -07001252#define MAKE_BFP_SAD4D_WRAPPER(fnname) \
1253 static void fnname##_bits8(const uint8_t *src_ptr, int source_stride, \
1254 const uint8_t *const ref_ptr[], int ref_stride, \
1255 unsigned int *sad_array) { \
1256 fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array); \
1257 } \
1258 static void fnname##_bits10(const uint8_t *src_ptr, int source_stride, \
1259 const uint8_t *const ref_ptr[], int ref_stride, \
1260 unsigned int *sad_array) { \
1261 int i; \
1262 fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array); \
1263 for (i = 0; i < 4; i++) sad_array[i] >>= 2; \
1264 } \
1265 static void fnname##_bits12(const uint8_t *src_ptr, int source_stride, \
1266 const uint8_t *const ref_ptr[], int ref_stride, \
1267 unsigned int *sad_array) { \
1268 int i; \
1269 fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array); \
1270 for (i = 0; i < 4; i++) sad_array[i] >>= 4; \
1271 }
1272
Cheng Chenbf3d4962017-11-01 14:48:52 -07001273#define MAKE_BFP_JSADAVG_WRAPPER(fnname) \
1274 static unsigned int fnname##_bits8( \
1275 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1276 int ref_stride, const uint8_t *second_pred, \
Debargha Mukherjeef90004a2018-12-20 13:35:06 -08001277 const DIST_WTD_COMP_PARAMS *jcp_param) { \
Cheng Chenbf3d4962017-11-01 14:48:52 -07001278 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred, \
1279 jcp_param); \
1280 } \
1281 static unsigned int fnname##_bits10( \
1282 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1283 int ref_stride, const uint8_t *second_pred, \
Debargha Mukherjeef90004a2018-12-20 13:35:06 -08001284 const DIST_WTD_COMP_PARAMS *jcp_param) { \
Cheng Chenbf3d4962017-11-01 14:48:52 -07001285 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred, \
1286 jcp_param) >> \
1287 2; \
1288 } \
1289 static unsigned int fnname##_bits12( \
1290 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1291 int ref_stride, const uint8_t *second_pred, \
Debargha Mukherjeef90004a2018-12-20 13:35:06 -08001292 const DIST_WTD_COMP_PARAMS *jcp_param) { \
Cheng Chenbf3d4962017-11-01 14:48:52 -07001293 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred, \
1294 jcp_param) >> \
1295 4; \
1296 }
Cheng Chenbf3d4962017-11-01 14:48:52 -07001297
Yaowu Xuf883b422016-08-30 14:01:10 -07001298MAKE_BFP_SAD_WRAPPER(aom_highbd_sad128x128)
1299MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad128x128_avg)
Yaowu Xuf883b422016-08-30 14:01:10 -07001300MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad128x128x4d)
1301MAKE_BFP_SAD_WRAPPER(aom_highbd_sad128x64)
1302MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad128x64_avg)
1303MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad128x64x4d)
1304MAKE_BFP_SAD_WRAPPER(aom_highbd_sad64x128)
1305MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad64x128_avg)
1306MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad64x128x4d)
Yaowu Xuf883b422016-08-30 14:01:10 -07001307MAKE_BFP_SAD_WRAPPER(aom_highbd_sad32x16)
1308MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad32x16_avg)
1309MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad32x16x4d)
1310MAKE_BFP_SAD_WRAPPER(aom_highbd_sad16x32)
1311MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad16x32_avg)
1312MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad16x32x4d)
1313MAKE_BFP_SAD_WRAPPER(aom_highbd_sad64x32)
1314MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad64x32_avg)
1315MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad64x32x4d)
1316MAKE_BFP_SAD_WRAPPER(aom_highbd_sad32x64)
1317MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad32x64_avg)
1318MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad32x64x4d)
1319MAKE_BFP_SAD_WRAPPER(aom_highbd_sad32x32)
1320MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad32x32_avg)
Yaowu Xuf883b422016-08-30 14:01:10 -07001321MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad32x32x4d)
1322MAKE_BFP_SAD_WRAPPER(aom_highbd_sad64x64)
1323MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad64x64_avg)
Yaowu Xuf883b422016-08-30 14:01:10 -07001324MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad64x64x4d)
1325MAKE_BFP_SAD_WRAPPER(aom_highbd_sad16x16)
1326MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad16x16_avg)
Yaowu Xuf883b422016-08-30 14:01:10 -07001327MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad16x16x4d)
1328MAKE_BFP_SAD_WRAPPER(aom_highbd_sad16x8)
1329MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad16x8_avg)
Yaowu Xuf883b422016-08-30 14:01:10 -07001330MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad16x8x4d)
1331MAKE_BFP_SAD_WRAPPER(aom_highbd_sad8x16)
1332MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad8x16_avg)
Yaowu Xuf883b422016-08-30 14:01:10 -07001333MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad8x16x4d)
1334MAKE_BFP_SAD_WRAPPER(aom_highbd_sad8x8)
1335MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad8x8_avg)
Yaowu Xuf883b422016-08-30 14:01:10 -07001336MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad8x8x4d)
1337MAKE_BFP_SAD_WRAPPER(aom_highbd_sad8x4)
1338MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad8x4_avg)
Yaowu Xuf883b422016-08-30 14:01:10 -07001339MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad8x4x4d)
1340MAKE_BFP_SAD_WRAPPER(aom_highbd_sad4x8)
1341MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad4x8_avg)
Yaowu Xuf883b422016-08-30 14:01:10 -07001342MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad4x8x4d)
1343MAKE_BFP_SAD_WRAPPER(aom_highbd_sad4x4)
1344MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad4x4_avg)
Yaowu Xuf883b422016-08-30 14:01:10 -07001345MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad4x4x4d)
Yaowu Xuc27fc142016-08-22 16:08:15 -07001346
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01001347MAKE_BFP_SAD_WRAPPER(aom_highbd_sad4x16)
1348MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad4x16_avg)
1349MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad4x16x4d)
1350MAKE_BFP_SAD_WRAPPER(aom_highbd_sad16x4)
1351MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad16x4_avg)
1352MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad16x4x4d)
1353MAKE_BFP_SAD_WRAPPER(aom_highbd_sad8x32)
1354MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad8x32_avg)
1355MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad8x32x4d)
1356MAKE_BFP_SAD_WRAPPER(aom_highbd_sad32x8)
1357MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad32x8_avg)
1358MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad32x8x4d)
Rupert Swarbrick72678572017-08-02 12:05:26 +01001359MAKE_BFP_SAD_WRAPPER(aom_highbd_sad16x64)
1360MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad16x64_avg)
1361MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad16x64x4d)
1362MAKE_BFP_SAD_WRAPPER(aom_highbd_sad64x16)
1363MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad64x16_avg)
1364MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad64x16x4d)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01001365
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001366MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad128x128_avg)
1367MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad128x64_avg)
1368MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad64x128_avg)
1369MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad32x16_avg)
1370MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad16x32_avg)
1371MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad64x32_avg)
1372MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad32x64_avg)
1373MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad32x32_avg)
1374MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad64x64_avg)
1375MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad16x16_avg)
1376MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad16x8_avg)
1377MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad8x16_avg)
1378MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad8x8_avg)
1379MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad8x4_avg)
1380MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad4x8_avg)
1381MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad4x4_avg)
1382MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad4x16_avg)
1383MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad16x4_avg)
1384MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad8x32_avg)
1385MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad32x8_avg)
1386MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad16x64_avg)
1387MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad64x16_avg)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001388
David Barker0f3c94e2017-05-16 15:21:50 +01001389#define HIGHBD_MBFP(BT, MCSDF, MCSVF) \
David Barkerf19f35f2017-05-22 16:33:22 +01001390 cpi->fn_ptr[BT].msdf = MCSDF; \
1391 cpi->fn_ptr[BT].msvf = MCSVF;
Yaowu Xuc27fc142016-08-22 16:08:15 -07001392
David Barkerc155e012017-05-11 13:54:54 +01001393#define MAKE_MBFP_COMPOUND_SAD_WRAPPER(fnname) \
1394 static unsigned int fnname##_bits8( \
1395 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1396 int ref_stride, const uint8_t *second_pred_ptr, const uint8_t *m, \
1397 int m_stride, int invert_mask) { \
1398 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, \
1399 second_pred_ptr, m, m_stride, invert_mask); \
1400 } \
1401 static unsigned int fnname##_bits10( \
1402 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1403 int ref_stride, const uint8_t *second_pred_ptr, const uint8_t *m, \
1404 int m_stride, int invert_mask) { \
1405 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, \
1406 second_pred_ptr, m, m_stride, invert_mask) >> \
1407 2; \
1408 } \
1409 static unsigned int fnname##_bits12( \
1410 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1411 int ref_stride, const uint8_t *second_pred_ptr, const uint8_t *m, \
1412 int m_stride, int invert_mask) { \
1413 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, \
1414 second_pred_ptr, m, m_stride, invert_mask) >> \
1415 4; \
1416 }
1417
David Barkerf19f35f2017-05-22 16:33:22 +01001418MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad128x128)
1419MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad128x64)
1420MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad64x128)
David Barkerf19f35f2017-05-22 16:33:22 +01001421MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad64x64)
1422MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad64x32)
1423MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad32x64)
1424MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad32x32)
1425MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad32x16)
1426MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad16x32)
1427MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad16x16)
1428MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad16x8)
1429MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad8x16)
1430MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad8x8)
1431MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad8x4)
1432MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad4x8)
1433MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad4x4)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01001434MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad4x16)
1435MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad16x4)
1436MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad8x32)
1437MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad32x8)
Rupert Swarbrick72678572017-08-02 12:05:26 +01001438MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad16x64)
1439MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad64x16)
Yaowu Xuc27fc142016-08-22 16:08:15 -07001440
Yaowu Xuc27fc142016-08-22 16:08:15 -07001441#define HIGHBD_OBFP(BT, OSDF, OVF, OSVF) \
1442 cpi->fn_ptr[BT].osdf = OSDF; \
1443 cpi->fn_ptr[BT].ovf = OVF; \
1444 cpi->fn_ptr[BT].osvf = OSVF;
1445
1446#define MAKE_OBFP_SAD_WRAPPER(fnname) \
1447 static unsigned int fnname##_bits8(const uint8_t *ref, int ref_stride, \
1448 const int32_t *wsrc, \
1449 const int32_t *msk) { \
1450 return fnname(ref, ref_stride, wsrc, msk); \
1451 } \
1452 static unsigned int fnname##_bits10(const uint8_t *ref, int ref_stride, \
1453 const int32_t *wsrc, \
1454 const int32_t *msk) { \
1455 return fnname(ref, ref_stride, wsrc, msk) >> 2; \
1456 } \
1457 static unsigned int fnname##_bits12(const uint8_t *ref, int ref_stride, \
1458 const int32_t *wsrc, \
1459 const int32_t *msk) { \
1460 return fnname(ref, ref_stride, wsrc, msk) >> 4; \
1461 }
1462
Yaowu Xuf883b422016-08-30 14:01:10 -07001463MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad128x128)
1464MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad128x64)
1465MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad64x128)
Yaowu Xuf883b422016-08-30 14:01:10 -07001466MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad64x64)
1467MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad64x32)
1468MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad32x64)
1469MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad32x32)
1470MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad32x16)
1471MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad16x32)
1472MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad16x16)
1473MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad16x8)
1474MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad8x16)
1475MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad8x8)
1476MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad8x4)
1477MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad4x8)
1478MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad4x4)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01001479MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad4x16)
1480MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad16x4)
1481MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad8x32)
1482MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad32x8)
Rupert Swarbrick72678572017-08-02 12:05:26 +01001483MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad16x64)
1484MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad64x16)
Yaowu Xuc27fc142016-08-22 16:08:15 -07001485
Yaowu Xuf883b422016-08-30 14:01:10 -07001486static void highbd_set_var_fns(AV1_COMP *const cpi) {
1487 AV1_COMMON *const cm = &cpi->common;
Urvang Joshi20cf30e2018-07-19 02:33:58 -07001488 if (cm->seq_params.use_highbitdepth) {
1489 switch (cm->seq_params.bit_depth) {
Yaowu Xuf883b422016-08-30 14:01:10 -07001490 case AOM_BITS_8:
Cheng Chenbf3d4962017-11-01 14:48:52 -07001491 HIGHBD_BFP(BLOCK_64X16, aom_highbd_sad64x16_bits8,
1492 aom_highbd_sad64x16_avg_bits8, aom_highbd_8_variance64x16,
1493 aom_highbd_8_sub_pixel_variance64x16,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001494 aom_highbd_8_sub_pixel_avg_variance64x16,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001495 aom_highbd_sad64x16x4d_bits8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001496 aom_highbd_dist_wtd_sad64x16_avg_bits8,
1497 aom_highbd_8_dist_wtd_sub_pixel_avg_variance64x16)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001498
1499 HIGHBD_BFP(BLOCK_16X64, aom_highbd_sad16x64_bits8,
1500 aom_highbd_sad16x64_avg_bits8, aom_highbd_8_variance16x64,
1501 aom_highbd_8_sub_pixel_variance16x64,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001502 aom_highbd_8_sub_pixel_avg_variance16x64,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001503 aom_highbd_sad16x64x4d_bits8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001504 aom_highbd_dist_wtd_sad16x64_avg_bits8,
1505 aom_highbd_8_dist_wtd_sub_pixel_avg_variance16x64)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001506
1507 HIGHBD_BFP(
1508 BLOCK_32X8, aom_highbd_sad32x8_bits8, aom_highbd_sad32x8_avg_bits8,
1509 aom_highbd_8_variance32x8, aom_highbd_8_sub_pixel_variance32x8,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001510 aom_highbd_8_sub_pixel_avg_variance32x8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001511 aom_highbd_sad32x8x4d_bits8, aom_highbd_dist_wtd_sad32x8_avg_bits8,
1512 aom_highbd_8_dist_wtd_sub_pixel_avg_variance32x8)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001513
1514 HIGHBD_BFP(
1515 BLOCK_8X32, aom_highbd_sad8x32_bits8, aom_highbd_sad8x32_avg_bits8,
1516 aom_highbd_8_variance8x32, aom_highbd_8_sub_pixel_variance8x32,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001517 aom_highbd_8_sub_pixel_avg_variance8x32,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001518 aom_highbd_sad8x32x4d_bits8, aom_highbd_dist_wtd_sad8x32_avg_bits8,
1519 aom_highbd_8_dist_wtd_sub_pixel_avg_variance8x32)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001520
1521 HIGHBD_BFP(
1522 BLOCK_16X4, aom_highbd_sad16x4_bits8, aom_highbd_sad16x4_avg_bits8,
1523 aom_highbd_8_variance16x4, aom_highbd_8_sub_pixel_variance16x4,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001524 aom_highbd_8_sub_pixel_avg_variance16x4,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001525 aom_highbd_sad16x4x4d_bits8, aom_highbd_dist_wtd_sad16x4_avg_bits8,
1526 aom_highbd_8_dist_wtd_sub_pixel_avg_variance16x4)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001527
1528 HIGHBD_BFP(
1529 BLOCK_4X16, aom_highbd_sad4x16_bits8, aom_highbd_sad4x16_avg_bits8,
1530 aom_highbd_8_variance4x16, aom_highbd_8_sub_pixel_variance4x16,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001531 aom_highbd_8_sub_pixel_avg_variance4x16,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001532 aom_highbd_sad4x16x4d_bits8, aom_highbd_dist_wtd_sad4x16_avg_bits8,
1533 aom_highbd_8_dist_wtd_sub_pixel_avg_variance4x16)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001534
1535 HIGHBD_BFP(BLOCK_32X16, aom_highbd_sad32x16_bits8,
1536 aom_highbd_sad32x16_avg_bits8, aom_highbd_8_variance32x16,
1537 aom_highbd_8_sub_pixel_variance32x16,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001538 aom_highbd_8_sub_pixel_avg_variance32x16,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001539 aom_highbd_sad32x16x4d_bits8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001540 aom_highbd_dist_wtd_sad32x16_avg_bits8,
1541 aom_highbd_8_dist_wtd_sub_pixel_avg_variance32x16)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001542
1543 HIGHBD_BFP(BLOCK_16X32, aom_highbd_sad16x32_bits8,
1544 aom_highbd_sad16x32_avg_bits8, aom_highbd_8_variance16x32,
1545 aom_highbd_8_sub_pixel_variance16x32,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001546 aom_highbd_8_sub_pixel_avg_variance16x32,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001547 aom_highbd_sad16x32x4d_bits8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001548 aom_highbd_dist_wtd_sad16x32_avg_bits8,
1549 aom_highbd_8_dist_wtd_sub_pixel_avg_variance16x32)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001550
1551 HIGHBD_BFP(BLOCK_64X32, aom_highbd_sad64x32_bits8,
1552 aom_highbd_sad64x32_avg_bits8, aom_highbd_8_variance64x32,
1553 aom_highbd_8_sub_pixel_variance64x32,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001554 aom_highbd_8_sub_pixel_avg_variance64x32,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001555 aom_highbd_sad64x32x4d_bits8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001556 aom_highbd_dist_wtd_sad64x32_avg_bits8,
1557 aom_highbd_8_dist_wtd_sub_pixel_avg_variance64x32)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001558
1559 HIGHBD_BFP(BLOCK_32X64, aom_highbd_sad32x64_bits8,
1560 aom_highbd_sad32x64_avg_bits8, aom_highbd_8_variance32x64,
1561 aom_highbd_8_sub_pixel_variance32x64,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001562 aom_highbd_8_sub_pixel_avg_variance32x64,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001563 aom_highbd_sad32x64x4d_bits8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001564 aom_highbd_dist_wtd_sad32x64_avg_bits8,
1565 aom_highbd_8_dist_wtd_sub_pixel_avg_variance32x64)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001566
1567 HIGHBD_BFP(BLOCK_32X32, aom_highbd_sad32x32_bits8,
1568 aom_highbd_sad32x32_avg_bits8, aom_highbd_8_variance32x32,
1569 aom_highbd_8_sub_pixel_variance32x32,
1570 aom_highbd_8_sub_pixel_avg_variance32x32,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001571 aom_highbd_sad32x32x4d_bits8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001572 aom_highbd_dist_wtd_sad32x32_avg_bits8,
1573 aom_highbd_8_dist_wtd_sub_pixel_avg_variance32x32)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001574
1575 HIGHBD_BFP(BLOCK_64X64, aom_highbd_sad64x64_bits8,
1576 aom_highbd_sad64x64_avg_bits8, aom_highbd_8_variance64x64,
1577 aom_highbd_8_sub_pixel_variance64x64,
1578 aom_highbd_8_sub_pixel_avg_variance64x64,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001579 aom_highbd_sad64x64x4d_bits8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001580 aom_highbd_dist_wtd_sad64x64_avg_bits8,
1581 aom_highbd_8_dist_wtd_sub_pixel_avg_variance64x64)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001582
1583 HIGHBD_BFP(BLOCK_16X16, aom_highbd_sad16x16_bits8,
1584 aom_highbd_sad16x16_avg_bits8, aom_highbd_8_variance16x16,
1585 aom_highbd_8_sub_pixel_variance16x16,
1586 aom_highbd_8_sub_pixel_avg_variance16x16,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001587 aom_highbd_sad16x16x4d_bits8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001588 aom_highbd_dist_wtd_sad16x16_avg_bits8,
1589 aom_highbd_8_dist_wtd_sub_pixel_avg_variance16x16)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001590
1591 HIGHBD_BFP(
1592 BLOCK_16X8, aom_highbd_sad16x8_bits8, aom_highbd_sad16x8_avg_bits8,
1593 aom_highbd_8_variance16x8, aom_highbd_8_sub_pixel_variance16x8,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001594 aom_highbd_8_sub_pixel_avg_variance16x8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001595 aom_highbd_sad16x8x4d_bits8, aom_highbd_dist_wtd_sad16x8_avg_bits8,
1596 aom_highbd_8_dist_wtd_sub_pixel_avg_variance16x8)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001597
1598 HIGHBD_BFP(
1599 BLOCK_8X16, aom_highbd_sad8x16_bits8, aom_highbd_sad8x16_avg_bits8,
1600 aom_highbd_8_variance8x16, aom_highbd_8_sub_pixel_variance8x16,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001601 aom_highbd_8_sub_pixel_avg_variance8x16,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001602 aom_highbd_sad8x16x4d_bits8, aom_highbd_dist_wtd_sad8x16_avg_bits8,
1603 aom_highbd_8_dist_wtd_sub_pixel_avg_variance8x16)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001604
Cheng Chenbf3d4962017-11-01 14:48:52 -07001605 HIGHBD_BFP(
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001606 BLOCK_8X8, aom_highbd_sad8x8_bits8, aom_highbd_sad8x8_avg_bits8,
1607 aom_highbd_8_variance8x8, aom_highbd_8_sub_pixel_variance8x8,
1608 aom_highbd_8_sub_pixel_avg_variance8x8, aom_highbd_sad8x8x4d_bits8,
1609 aom_highbd_dist_wtd_sad8x8_avg_bits8,
1610 aom_highbd_8_dist_wtd_sub_pixel_avg_variance8x8)
1611
1612 HIGHBD_BFP(
1613 BLOCK_8X4, aom_highbd_sad8x4_bits8, aom_highbd_sad8x4_avg_bits8,
1614 aom_highbd_8_variance8x4, aom_highbd_8_sub_pixel_variance8x4,
1615 aom_highbd_8_sub_pixel_avg_variance8x4, aom_highbd_sad8x4x4d_bits8,
1616 aom_highbd_dist_wtd_sad8x4_avg_bits8,
1617 aom_highbd_8_dist_wtd_sub_pixel_avg_variance8x4)
1618
1619 HIGHBD_BFP(
1620 BLOCK_4X8, aom_highbd_sad4x8_bits8, aom_highbd_sad4x8_avg_bits8,
1621 aom_highbd_8_variance4x8, aom_highbd_8_sub_pixel_variance4x8,
1622 aom_highbd_8_sub_pixel_avg_variance4x8, aom_highbd_sad4x8x4d_bits8,
1623 aom_highbd_dist_wtd_sad4x8_avg_bits8,
1624 aom_highbd_8_dist_wtd_sub_pixel_avg_variance4x8)
1625
1626 HIGHBD_BFP(
1627 BLOCK_4X4, aom_highbd_sad4x4_bits8, aom_highbd_sad4x4_avg_bits8,
1628 aom_highbd_8_variance4x4, aom_highbd_8_sub_pixel_variance4x4,
1629 aom_highbd_8_sub_pixel_avg_variance4x4, aom_highbd_sad4x4x4d_bits8,
1630 aom_highbd_dist_wtd_sad4x4_avg_bits8,
1631 aom_highbd_8_dist_wtd_sub_pixel_avg_variance4x4)
1632
1633 HIGHBD_BFP(BLOCK_128X128, aom_highbd_sad128x128_bits8,
1634 aom_highbd_sad128x128_avg_bits8,
1635 aom_highbd_8_variance128x128,
1636 aom_highbd_8_sub_pixel_variance128x128,
1637 aom_highbd_8_sub_pixel_avg_variance128x128,
1638 aom_highbd_sad128x128x4d_bits8,
1639 aom_highbd_dist_wtd_sad128x128_avg_bits8,
1640 aom_highbd_8_dist_wtd_sub_pixel_avg_variance128x128)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001641
1642 HIGHBD_BFP(BLOCK_128X64, aom_highbd_sad128x64_bits8,
1643 aom_highbd_sad128x64_avg_bits8, aom_highbd_8_variance128x64,
1644 aom_highbd_8_sub_pixel_variance128x64,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001645 aom_highbd_8_sub_pixel_avg_variance128x64,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001646 aom_highbd_sad128x64x4d_bits8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001647 aom_highbd_dist_wtd_sad128x64_avg_bits8,
1648 aom_highbd_8_dist_wtd_sub_pixel_avg_variance128x64)
Cheng Chenbf3d4962017-11-01 14:48:52 -07001649
1650 HIGHBD_BFP(BLOCK_64X128, aom_highbd_sad64x128_bits8,
1651 aom_highbd_sad64x128_avg_bits8, aom_highbd_8_variance64x128,
1652 aom_highbd_8_sub_pixel_variance64x128,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001653 aom_highbd_8_sub_pixel_avg_variance64x128,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001654 aom_highbd_sad64x128x4d_bits8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001655 aom_highbd_dist_wtd_sad64x128_avg_bits8,
1656 aom_highbd_8_dist_wtd_sub_pixel_avg_variance64x128)
Yaowu Xuc27fc142016-08-22 16:08:15 -07001657
David Barkerf19f35f2017-05-22 16:33:22 +01001658 HIGHBD_MBFP(BLOCK_128X128, aom_highbd_masked_sad128x128_bits8,
1659 aom_highbd_8_masked_sub_pixel_variance128x128)
1660 HIGHBD_MBFP(BLOCK_128X64, aom_highbd_masked_sad128x64_bits8,
1661 aom_highbd_8_masked_sub_pixel_variance128x64)
1662 HIGHBD_MBFP(BLOCK_64X128, aom_highbd_masked_sad64x128_bits8,
1663 aom_highbd_8_masked_sub_pixel_variance64x128)
David Barkerf19f35f2017-05-22 16:33:22 +01001664 HIGHBD_MBFP(BLOCK_64X64, aom_highbd_masked_sad64x64_bits8,
1665 aom_highbd_8_masked_sub_pixel_variance64x64)
1666 HIGHBD_MBFP(BLOCK_64X32, aom_highbd_masked_sad64x32_bits8,
1667 aom_highbd_8_masked_sub_pixel_variance64x32)
1668 HIGHBD_MBFP(BLOCK_32X64, aom_highbd_masked_sad32x64_bits8,
1669 aom_highbd_8_masked_sub_pixel_variance32x64)
1670 HIGHBD_MBFP(BLOCK_32X32, aom_highbd_masked_sad32x32_bits8,
1671 aom_highbd_8_masked_sub_pixel_variance32x32)
1672 HIGHBD_MBFP(BLOCK_32X16, aom_highbd_masked_sad32x16_bits8,
1673 aom_highbd_8_masked_sub_pixel_variance32x16)
1674 HIGHBD_MBFP(BLOCK_16X32, aom_highbd_masked_sad16x32_bits8,
1675 aom_highbd_8_masked_sub_pixel_variance16x32)
1676 HIGHBD_MBFP(BLOCK_16X16, aom_highbd_masked_sad16x16_bits8,
1677 aom_highbd_8_masked_sub_pixel_variance16x16)
1678 HIGHBD_MBFP(BLOCK_8X16, aom_highbd_masked_sad8x16_bits8,
1679 aom_highbd_8_masked_sub_pixel_variance8x16)
1680 HIGHBD_MBFP(BLOCK_16X8, aom_highbd_masked_sad16x8_bits8,
1681 aom_highbd_8_masked_sub_pixel_variance16x8)
1682 HIGHBD_MBFP(BLOCK_8X8, aom_highbd_masked_sad8x8_bits8,
1683 aom_highbd_8_masked_sub_pixel_variance8x8)
1684 HIGHBD_MBFP(BLOCK_4X8, aom_highbd_masked_sad4x8_bits8,
1685 aom_highbd_8_masked_sub_pixel_variance4x8)
1686 HIGHBD_MBFP(BLOCK_8X4, aom_highbd_masked_sad8x4_bits8,
1687 aom_highbd_8_masked_sub_pixel_variance8x4)
1688 HIGHBD_MBFP(BLOCK_4X4, aom_highbd_masked_sad4x4_bits8,
1689 aom_highbd_8_masked_sub_pixel_variance4x4)
Rupert Swarbrick72678572017-08-02 12:05:26 +01001690 HIGHBD_MBFP(BLOCK_64X16, aom_highbd_masked_sad64x16_bits8,
1691 aom_highbd_8_masked_sub_pixel_variance64x16)
Rupert Swarbrick72678572017-08-02 12:05:26 +01001692 HIGHBD_MBFP(BLOCK_16X64, aom_highbd_masked_sad16x64_bits8,
1693 aom_highbd_8_masked_sub_pixel_variance16x64)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01001694 HIGHBD_MBFP(BLOCK_32X8, aom_highbd_masked_sad32x8_bits8,
1695 aom_highbd_8_masked_sub_pixel_variance32x8)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01001696 HIGHBD_MBFP(BLOCK_8X32, aom_highbd_masked_sad8x32_bits8,
1697 aom_highbd_8_masked_sub_pixel_variance8x32)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01001698 HIGHBD_MBFP(BLOCK_16X4, aom_highbd_masked_sad16x4_bits8,
1699 aom_highbd_8_masked_sub_pixel_variance16x4)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01001700 HIGHBD_MBFP(BLOCK_4X16, aom_highbd_masked_sad4x16_bits8,
1701 aom_highbd_8_masked_sub_pixel_variance4x16)
Yaowu Xuf883b422016-08-30 14:01:10 -07001702 HIGHBD_OBFP(BLOCK_128X128, aom_highbd_obmc_sad128x128_bits8,
1703 aom_highbd_obmc_variance128x128,
1704 aom_highbd_obmc_sub_pixel_variance128x128)
1705 HIGHBD_OBFP(BLOCK_128X64, aom_highbd_obmc_sad128x64_bits8,
1706 aom_highbd_obmc_variance128x64,
1707 aom_highbd_obmc_sub_pixel_variance128x64)
1708 HIGHBD_OBFP(BLOCK_64X128, aom_highbd_obmc_sad64x128_bits8,
1709 aom_highbd_obmc_variance64x128,
1710 aom_highbd_obmc_sub_pixel_variance64x128)
Yaowu Xuf883b422016-08-30 14:01:10 -07001711 HIGHBD_OBFP(BLOCK_64X64, aom_highbd_obmc_sad64x64_bits8,
1712 aom_highbd_obmc_variance64x64,
1713 aom_highbd_obmc_sub_pixel_variance64x64)
1714 HIGHBD_OBFP(BLOCK_64X32, aom_highbd_obmc_sad64x32_bits8,
1715 aom_highbd_obmc_variance64x32,
1716 aom_highbd_obmc_sub_pixel_variance64x32)
1717 HIGHBD_OBFP(BLOCK_32X64, aom_highbd_obmc_sad32x64_bits8,
1718 aom_highbd_obmc_variance32x64,
1719 aom_highbd_obmc_sub_pixel_variance32x64)
1720 HIGHBD_OBFP(BLOCK_32X32, aom_highbd_obmc_sad32x32_bits8,
1721 aom_highbd_obmc_variance32x32,
1722 aom_highbd_obmc_sub_pixel_variance32x32)
1723 HIGHBD_OBFP(BLOCK_32X16, aom_highbd_obmc_sad32x16_bits8,
1724 aom_highbd_obmc_variance32x16,
1725 aom_highbd_obmc_sub_pixel_variance32x16)
1726 HIGHBD_OBFP(BLOCK_16X32, aom_highbd_obmc_sad16x32_bits8,
1727 aom_highbd_obmc_variance16x32,
1728 aom_highbd_obmc_sub_pixel_variance16x32)
1729 HIGHBD_OBFP(BLOCK_16X16, aom_highbd_obmc_sad16x16_bits8,
1730 aom_highbd_obmc_variance16x16,
1731 aom_highbd_obmc_sub_pixel_variance16x16)
1732 HIGHBD_OBFP(BLOCK_8X16, aom_highbd_obmc_sad8x16_bits8,
1733 aom_highbd_obmc_variance8x16,
1734 aom_highbd_obmc_sub_pixel_variance8x16)
1735 HIGHBD_OBFP(BLOCK_16X8, aom_highbd_obmc_sad16x8_bits8,
1736 aom_highbd_obmc_variance16x8,
1737 aom_highbd_obmc_sub_pixel_variance16x8)
1738 HIGHBD_OBFP(BLOCK_8X8, aom_highbd_obmc_sad8x8_bits8,
1739 aom_highbd_obmc_variance8x8,
1740 aom_highbd_obmc_sub_pixel_variance8x8)
1741 HIGHBD_OBFP(BLOCK_4X8, aom_highbd_obmc_sad4x8_bits8,
1742 aom_highbd_obmc_variance4x8,
1743 aom_highbd_obmc_sub_pixel_variance4x8)
1744 HIGHBD_OBFP(BLOCK_8X4, aom_highbd_obmc_sad8x4_bits8,
1745 aom_highbd_obmc_variance8x4,
1746 aom_highbd_obmc_sub_pixel_variance8x4)
1747 HIGHBD_OBFP(BLOCK_4X4, aom_highbd_obmc_sad4x4_bits8,
1748 aom_highbd_obmc_variance4x4,
1749 aom_highbd_obmc_sub_pixel_variance4x4)
Rupert Swarbrick72678572017-08-02 12:05:26 +01001750 HIGHBD_OBFP(BLOCK_64X16, aom_highbd_obmc_sad64x16_bits8,
1751 aom_highbd_obmc_variance64x16,
1752 aom_highbd_obmc_sub_pixel_variance64x16)
Rupert Swarbrick72678572017-08-02 12:05:26 +01001753 HIGHBD_OBFP(BLOCK_16X64, aom_highbd_obmc_sad16x64_bits8,
1754 aom_highbd_obmc_variance16x64,
1755 aom_highbd_obmc_sub_pixel_variance16x64)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01001756 HIGHBD_OBFP(BLOCK_32X8, aom_highbd_obmc_sad32x8_bits8,
1757 aom_highbd_obmc_variance32x8,
1758 aom_highbd_obmc_sub_pixel_variance32x8)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01001759 HIGHBD_OBFP(BLOCK_8X32, aom_highbd_obmc_sad8x32_bits8,
1760 aom_highbd_obmc_variance8x32,
1761 aom_highbd_obmc_sub_pixel_variance8x32)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01001762 HIGHBD_OBFP(BLOCK_16X4, aom_highbd_obmc_sad16x4_bits8,
1763 aom_highbd_obmc_variance16x4,
1764 aom_highbd_obmc_sub_pixel_variance16x4)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01001765 HIGHBD_OBFP(BLOCK_4X16, aom_highbd_obmc_sad4x16_bits8,
1766 aom_highbd_obmc_variance4x16,
1767 aom_highbd_obmc_sub_pixel_variance4x16)
Yaowu Xuc27fc142016-08-22 16:08:15 -07001768 break;
1769
Yaowu Xuf883b422016-08-30 14:01:10 -07001770 case AOM_BITS_10:
Cheng Chenbf3d4962017-11-01 14:48:52 -07001771 HIGHBD_BFP(BLOCK_64X16, aom_highbd_sad64x16_bits10,
1772 aom_highbd_sad64x16_avg_bits10, aom_highbd_10_variance64x16,
1773 aom_highbd_10_sub_pixel_variance64x16,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001774 aom_highbd_10_sub_pixel_avg_variance64x16,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001775 aom_highbd_sad64x16x4d_bits10,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001776 aom_highbd_dist_wtd_sad64x16_avg_bits10,
1777 aom_highbd_10_dist_wtd_sub_pixel_avg_variance64x16);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001778
1779 HIGHBD_BFP(BLOCK_16X64, aom_highbd_sad16x64_bits10,
1780 aom_highbd_sad16x64_avg_bits10, aom_highbd_10_variance16x64,
1781 aom_highbd_10_sub_pixel_variance16x64,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001782 aom_highbd_10_sub_pixel_avg_variance16x64,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001783 aom_highbd_sad16x64x4d_bits10,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001784 aom_highbd_dist_wtd_sad16x64_avg_bits10,
1785 aom_highbd_10_dist_wtd_sub_pixel_avg_variance16x64);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001786
1787 HIGHBD_BFP(BLOCK_32X8, aom_highbd_sad32x8_bits10,
1788 aom_highbd_sad32x8_avg_bits10, aom_highbd_10_variance32x8,
1789 aom_highbd_10_sub_pixel_variance32x8,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001790 aom_highbd_10_sub_pixel_avg_variance32x8,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001791 aom_highbd_sad32x8x4d_bits10,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001792 aom_highbd_dist_wtd_sad32x8_avg_bits10,
1793 aom_highbd_10_dist_wtd_sub_pixel_avg_variance32x8);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001794
1795 HIGHBD_BFP(BLOCK_8X32, aom_highbd_sad8x32_bits10,
1796 aom_highbd_sad8x32_avg_bits10, aom_highbd_10_variance8x32,
1797 aom_highbd_10_sub_pixel_variance8x32,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001798 aom_highbd_10_sub_pixel_avg_variance8x32,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001799 aom_highbd_sad8x32x4d_bits10,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001800 aom_highbd_dist_wtd_sad8x32_avg_bits10,
1801 aom_highbd_10_dist_wtd_sub_pixel_avg_variance8x32);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001802
1803 HIGHBD_BFP(BLOCK_16X4, aom_highbd_sad16x4_bits10,
1804 aom_highbd_sad16x4_avg_bits10, aom_highbd_10_variance16x4,
1805 aom_highbd_10_sub_pixel_variance16x4,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001806 aom_highbd_10_sub_pixel_avg_variance16x4,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001807 aom_highbd_sad16x4x4d_bits10,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001808 aom_highbd_dist_wtd_sad16x4_avg_bits10,
1809 aom_highbd_10_dist_wtd_sub_pixel_avg_variance16x4);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001810
1811 HIGHBD_BFP(BLOCK_4X16, aom_highbd_sad4x16_bits10,
1812 aom_highbd_sad4x16_avg_bits10, aom_highbd_10_variance4x16,
1813 aom_highbd_10_sub_pixel_variance4x16,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001814 aom_highbd_10_sub_pixel_avg_variance4x16,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001815 aom_highbd_sad4x16x4d_bits10,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001816 aom_highbd_dist_wtd_sad4x16_avg_bits10,
1817 aom_highbd_10_dist_wtd_sub_pixel_avg_variance4x16);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001818
1819 HIGHBD_BFP(BLOCK_32X16, aom_highbd_sad32x16_bits10,
1820 aom_highbd_sad32x16_avg_bits10, aom_highbd_10_variance32x16,
1821 aom_highbd_10_sub_pixel_variance32x16,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001822 aom_highbd_10_sub_pixel_avg_variance32x16,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001823 aom_highbd_sad32x16x4d_bits10,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001824 aom_highbd_dist_wtd_sad32x16_avg_bits10,
1825 aom_highbd_10_dist_wtd_sub_pixel_avg_variance32x16);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001826
1827 HIGHBD_BFP(BLOCK_16X32, aom_highbd_sad16x32_bits10,
1828 aom_highbd_sad16x32_avg_bits10, aom_highbd_10_variance16x32,
1829 aom_highbd_10_sub_pixel_variance16x32,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001830 aom_highbd_10_sub_pixel_avg_variance16x32,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001831 aom_highbd_sad16x32x4d_bits10,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001832 aom_highbd_dist_wtd_sad16x32_avg_bits10,
1833 aom_highbd_10_dist_wtd_sub_pixel_avg_variance16x32);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001834
1835 HIGHBD_BFP(BLOCK_64X32, aom_highbd_sad64x32_bits10,
1836 aom_highbd_sad64x32_avg_bits10, aom_highbd_10_variance64x32,
1837 aom_highbd_10_sub_pixel_variance64x32,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001838 aom_highbd_10_sub_pixel_avg_variance64x32,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001839 aom_highbd_sad64x32x4d_bits10,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001840 aom_highbd_dist_wtd_sad64x32_avg_bits10,
1841 aom_highbd_10_dist_wtd_sub_pixel_avg_variance64x32);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001842
1843 HIGHBD_BFP(BLOCK_32X64, aom_highbd_sad32x64_bits10,
1844 aom_highbd_sad32x64_avg_bits10, aom_highbd_10_variance32x64,
1845 aom_highbd_10_sub_pixel_variance32x64,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001846 aom_highbd_10_sub_pixel_avg_variance32x64,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001847 aom_highbd_sad32x64x4d_bits10,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001848 aom_highbd_dist_wtd_sad32x64_avg_bits10,
1849 aom_highbd_10_dist_wtd_sub_pixel_avg_variance32x64);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001850
1851 HIGHBD_BFP(BLOCK_32X32, aom_highbd_sad32x32_bits10,
1852 aom_highbd_sad32x32_avg_bits10, aom_highbd_10_variance32x32,
1853 aom_highbd_10_sub_pixel_variance32x32,
1854 aom_highbd_10_sub_pixel_avg_variance32x32,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001855 aom_highbd_sad32x32x4d_bits10,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001856 aom_highbd_dist_wtd_sad32x32_avg_bits10,
1857 aom_highbd_10_dist_wtd_sub_pixel_avg_variance32x32);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001858
1859 HIGHBD_BFP(BLOCK_64X64, aom_highbd_sad64x64_bits10,
1860 aom_highbd_sad64x64_avg_bits10, aom_highbd_10_variance64x64,
1861 aom_highbd_10_sub_pixel_variance64x64,
1862 aom_highbd_10_sub_pixel_avg_variance64x64,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001863 aom_highbd_sad64x64x4d_bits10,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001864 aom_highbd_dist_wtd_sad64x64_avg_bits10,
1865 aom_highbd_10_dist_wtd_sub_pixel_avg_variance64x64);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001866
1867 HIGHBD_BFP(BLOCK_16X16, aom_highbd_sad16x16_bits10,
1868 aom_highbd_sad16x16_avg_bits10, aom_highbd_10_variance16x16,
1869 aom_highbd_10_sub_pixel_variance16x16,
1870 aom_highbd_10_sub_pixel_avg_variance16x16,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001871 aom_highbd_sad16x16x4d_bits10,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001872 aom_highbd_dist_wtd_sad16x16_avg_bits10,
1873 aom_highbd_10_dist_wtd_sub_pixel_avg_variance16x16);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001874
1875 HIGHBD_BFP(BLOCK_16X8, aom_highbd_sad16x8_bits10,
1876 aom_highbd_sad16x8_avg_bits10, aom_highbd_10_variance16x8,
1877 aom_highbd_10_sub_pixel_variance16x8,
1878 aom_highbd_10_sub_pixel_avg_variance16x8,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001879 aom_highbd_sad16x8x4d_bits10,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001880 aom_highbd_dist_wtd_sad16x8_avg_bits10,
1881 aom_highbd_10_dist_wtd_sub_pixel_avg_variance16x8);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001882
1883 HIGHBD_BFP(BLOCK_8X16, aom_highbd_sad8x16_bits10,
1884 aom_highbd_sad8x16_avg_bits10, aom_highbd_10_variance8x16,
1885 aom_highbd_10_sub_pixel_variance8x16,
1886 aom_highbd_10_sub_pixel_avg_variance8x16,
Cheng Chenbf3d4962017-11-01 14:48:52 -07001887 aom_highbd_sad8x16x4d_bits10,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001888 aom_highbd_dist_wtd_sad8x16_avg_bits10,
1889 aom_highbd_10_dist_wtd_sub_pixel_avg_variance8x16);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001890
1891 HIGHBD_BFP(
1892 BLOCK_8X8, aom_highbd_sad8x8_bits10, aom_highbd_sad8x8_avg_bits10,
1893 aom_highbd_10_variance8x8, aom_highbd_10_sub_pixel_variance8x8,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001894 aom_highbd_10_sub_pixel_avg_variance8x8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001895 aom_highbd_sad8x8x4d_bits10, aom_highbd_dist_wtd_sad8x8_avg_bits10,
1896 aom_highbd_10_dist_wtd_sub_pixel_avg_variance8x8);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001897
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001898 HIGHBD_BFP(
1899 BLOCK_8X4, aom_highbd_sad8x4_bits10, aom_highbd_sad8x4_avg_bits10,
1900 aom_highbd_10_variance8x4, aom_highbd_10_sub_pixel_variance8x4,
1901 aom_highbd_10_sub_pixel_avg_variance8x4,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001902 aom_highbd_sad8x4x4d_bits10, aom_highbd_dist_wtd_sad8x4_avg_bits10,
1903 aom_highbd_10_dist_wtd_sub_pixel_avg_variance8x4);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001904
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001905 HIGHBD_BFP(
1906 BLOCK_4X8, aom_highbd_sad4x8_bits10, aom_highbd_sad4x8_avg_bits10,
1907 aom_highbd_10_variance4x8, aom_highbd_10_sub_pixel_variance4x8,
1908 aom_highbd_10_sub_pixel_avg_variance4x8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001909 aom_highbd_sad4x8x4d_bits10, aom_highbd_dist_wtd_sad4x8_avg_bits10,
1910 aom_highbd_10_dist_wtd_sub_pixel_avg_variance4x8);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001911
1912 HIGHBD_BFP(
1913 BLOCK_4X4, aom_highbd_sad4x4_bits10, aom_highbd_sad4x4_avg_bits10,
1914 aom_highbd_10_variance4x4, aom_highbd_10_sub_pixel_variance4x4,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001915 aom_highbd_10_sub_pixel_avg_variance4x4,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001916 aom_highbd_sad4x4x4d_bits10, aom_highbd_dist_wtd_sad4x4_avg_bits10,
1917 aom_highbd_10_dist_wtd_sub_pixel_avg_variance4x4);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001918
Kyle Siefringef6e2df2018-04-10 14:51:35 -04001919 HIGHBD_BFP(BLOCK_128X128, aom_highbd_sad128x128_bits10,
1920 aom_highbd_sad128x128_avg_bits10,
1921 aom_highbd_10_variance128x128,
1922 aom_highbd_10_sub_pixel_variance128x128,
1923 aom_highbd_10_sub_pixel_avg_variance128x128,
1924 aom_highbd_sad128x128x4d_bits10,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001925 aom_highbd_dist_wtd_sad128x128_avg_bits10,
1926 aom_highbd_10_dist_wtd_sub_pixel_avg_variance128x128);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001927
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001928 HIGHBD_BFP(BLOCK_128X64, aom_highbd_sad128x64_bits10,
1929 aom_highbd_sad128x64_avg_bits10,
1930 aom_highbd_10_variance128x64,
1931 aom_highbd_10_sub_pixel_variance128x64,
1932 aom_highbd_10_sub_pixel_avg_variance128x64,
1933 aom_highbd_sad128x64x4d_bits10,
1934 aom_highbd_dist_wtd_sad128x64_avg_bits10,
1935 aom_highbd_10_dist_wtd_sub_pixel_avg_variance128x64);
Cheng Chenbf3d4962017-11-01 14:48:52 -07001936
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08001937 HIGHBD_BFP(BLOCK_64X128, aom_highbd_sad64x128_bits10,
1938 aom_highbd_sad64x128_avg_bits10,
1939 aom_highbd_10_variance64x128,
1940 aom_highbd_10_sub_pixel_variance64x128,
1941 aom_highbd_10_sub_pixel_avg_variance64x128,
1942 aom_highbd_sad64x128x4d_bits10,
1943 aom_highbd_dist_wtd_sad64x128_avg_bits10,
1944 aom_highbd_10_dist_wtd_sub_pixel_avg_variance64x128);
Yaowu Xuc27fc142016-08-22 16:08:15 -07001945
David Barkerf19f35f2017-05-22 16:33:22 +01001946 HIGHBD_MBFP(BLOCK_128X128, aom_highbd_masked_sad128x128_bits10,
1947 aom_highbd_10_masked_sub_pixel_variance128x128)
1948 HIGHBD_MBFP(BLOCK_128X64, aom_highbd_masked_sad128x64_bits10,
1949 aom_highbd_10_masked_sub_pixel_variance128x64)
1950 HIGHBD_MBFP(BLOCK_64X128, aom_highbd_masked_sad64x128_bits10,
1951 aom_highbd_10_masked_sub_pixel_variance64x128)
David Barkerf19f35f2017-05-22 16:33:22 +01001952 HIGHBD_MBFP(BLOCK_64X64, aom_highbd_masked_sad64x64_bits10,
1953 aom_highbd_10_masked_sub_pixel_variance64x64)
1954 HIGHBD_MBFP(BLOCK_64X32, aom_highbd_masked_sad64x32_bits10,
1955 aom_highbd_10_masked_sub_pixel_variance64x32)
1956 HIGHBD_MBFP(BLOCK_32X64, aom_highbd_masked_sad32x64_bits10,
1957 aom_highbd_10_masked_sub_pixel_variance32x64)
1958 HIGHBD_MBFP(BLOCK_32X32, aom_highbd_masked_sad32x32_bits10,
1959 aom_highbd_10_masked_sub_pixel_variance32x32)
1960 HIGHBD_MBFP(BLOCK_32X16, aom_highbd_masked_sad32x16_bits10,
1961 aom_highbd_10_masked_sub_pixel_variance32x16)
1962 HIGHBD_MBFP(BLOCK_16X32, aom_highbd_masked_sad16x32_bits10,
1963 aom_highbd_10_masked_sub_pixel_variance16x32)
1964 HIGHBD_MBFP(BLOCK_16X16, aom_highbd_masked_sad16x16_bits10,
1965 aom_highbd_10_masked_sub_pixel_variance16x16)
1966 HIGHBD_MBFP(BLOCK_8X16, aom_highbd_masked_sad8x16_bits10,
1967 aom_highbd_10_masked_sub_pixel_variance8x16)
1968 HIGHBD_MBFP(BLOCK_16X8, aom_highbd_masked_sad16x8_bits10,
1969 aom_highbd_10_masked_sub_pixel_variance16x8)
1970 HIGHBD_MBFP(BLOCK_8X8, aom_highbd_masked_sad8x8_bits10,
1971 aom_highbd_10_masked_sub_pixel_variance8x8)
1972 HIGHBD_MBFP(BLOCK_4X8, aom_highbd_masked_sad4x8_bits10,
1973 aom_highbd_10_masked_sub_pixel_variance4x8)
1974 HIGHBD_MBFP(BLOCK_8X4, aom_highbd_masked_sad8x4_bits10,
1975 aom_highbd_10_masked_sub_pixel_variance8x4)
1976 HIGHBD_MBFP(BLOCK_4X4, aom_highbd_masked_sad4x4_bits10,
1977 aom_highbd_10_masked_sub_pixel_variance4x4)
Rupert Swarbrick72678572017-08-02 12:05:26 +01001978 HIGHBD_MBFP(BLOCK_64X16, aom_highbd_masked_sad64x16_bits10,
1979 aom_highbd_10_masked_sub_pixel_variance64x16)
Rupert Swarbrick72678572017-08-02 12:05:26 +01001980 HIGHBD_MBFP(BLOCK_16X64, aom_highbd_masked_sad16x64_bits10,
1981 aom_highbd_10_masked_sub_pixel_variance16x64)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01001982 HIGHBD_MBFP(BLOCK_32X8, aom_highbd_masked_sad32x8_bits10,
1983 aom_highbd_10_masked_sub_pixel_variance32x8)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01001984 HIGHBD_MBFP(BLOCK_8X32, aom_highbd_masked_sad8x32_bits10,
1985 aom_highbd_10_masked_sub_pixel_variance8x32)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01001986 HIGHBD_MBFP(BLOCK_16X4, aom_highbd_masked_sad16x4_bits10,
1987 aom_highbd_10_masked_sub_pixel_variance16x4)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01001988 HIGHBD_MBFP(BLOCK_4X16, aom_highbd_masked_sad4x16_bits10,
1989 aom_highbd_10_masked_sub_pixel_variance4x16)
Yaowu Xuf883b422016-08-30 14:01:10 -07001990 HIGHBD_OBFP(BLOCK_128X128, aom_highbd_obmc_sad128x128_bits10,
1991 aom_highbd_10_obmc_variance128x128,
1992 aom_highbd_10_obmc_sub_pixel_variance128x128)
1993 HIGHBD_OBFP(BLOCK_128X64, aom_highbd_obmc_sad128x64_bits10,
1994 aom_highbd_10_obmc_variance128x64,
1995 aom_highbd_10_obmc_sub_pixel_variance128x64)
1996 HIGHBD_OBFP(BLOCK_64X128, aom_highbd_obmc_sad64x128_bits10,
1997 aom_highbd_10_obmc_variance64x128,
1998 aom_highbd_10_obmc_sub_pixel_variance64x128)
Yaowu Xuf883b422016-08-30 14:01:10 -07001999 HIGHBD_OBFP(BLOCK_64X64, aom_highbd_obmc_sad64x64_bits10,
2000 aom_highbd_10_obmc_variance64x64,
2001 aom_highbd_10_obmc_sub_pixel_variance64x64)
2002 HIGHBD_OBFP(BLOCK_64X32, aom_highbd_obmc_sad64x32_bits10,
2003 aom_highbd_10_obmc_variance64x32,
2004 aom_highbd_10_obmc_sub_pixel_variance64x32)
2005 HIGHBD_OBFP(BLOCK_32X64, aom_highbd_obmc_sad32x64_bits10,
2006 aom_highbd_10_obmc_variance32x64,
2007 aom_highbd_10_obmc_sub_pixel_variance32x64)
2008 HIGHBD_OBFP(BLOCK_32X32, aom_highbd_obmc_sad32x32_bits10,
2009 aom_highbd_10_obmc_variance32x32,
2010 aom_highbd_10_obmc_sub_pixel_variance32x32)
2011 HIGHBD_OBFP(BLOCK_32X16, aom_highbd_obmc_sad32x16_bits10,
2012 aom_highbd_10_obmc_variance32x16,
2013 aom_highbd_10_obmc_sub_pixel_variance32x16)
2014 HIGHBD_OBFP(BLOCK_16X32, aom_highbd_obmc_sad16x32_bits10,
2015 aom_highbd_10_obmc_variance16x32,
2016 aom_highbd_10_obmc_sub_pixel_variance16x32)
2017 HIGHBD_OBFP(BLOCK_16X16, aom_highbd_obmc_sad16x16_bits10,
2018 aom_highbd_10_obmc_variance16x16,
2019 aom_highbd_10_obmc_sub_pixel_variance16x16)
2020 HIGHBD_OBFP(BLOCK_8X16, aom_highbd_obmc_sad8x16_bits10,
2021 aom_highbd_10_obmc_variance8x16,
2022 aom_highbd_10_obmc_sub_pixel_variance8x16)
2023 HIGHBD_OBFP(BLOCK_16X8, aom_highbd_obmc_sad16x8_bits10,
2024 aom_highbd_10_obmc_variance16x8,
2025 aom_highbd_10_obmc_sub_pixel_variance16x8)
2026 HIGHBD_OBFP(BLOCK_8X8, aom_highbd_obmc_sad8x8_bits10,
2027 aom_highbd_10_obmc_variance8x8,
2028 aom_highbd_10_obmc_sub_pixel_variance8x8)
2029 HIGHBD_OBFP(BLOCK_4X8, aom_highbd_obmc_sad4x8_bits10,
2030 aom_highbd_10_obmc_variance4x8,
2031 aom_highbd_10_obmc_sub_pixel_variance4x8)
2032 HIGHBD_OBFP(BLOCK_8X4, aom_highbd_obmc_sad8x4_bits10,
2033 aom_highbd_10_obmc_variance8x4,
2034 aom_highbd_10_obmc_sub_pixel_variance8x4)
2035 HIGHBD_OBFP(BLOCK_4X4, aom_highbd_obmc_sad4x4_bits10,
2036 aom_highbd_10_obmc_variance4x4,
2037 aom_highbd_10_obmc_sub_pixel_variance4x4)
Rupert Swarbrick2fa6e1c2017-09-11 12:38:10 +01002038
Rupert Swarbrick72678572017-08-02 12:05:26 +01002039 HIGHBD_OBFP(BLOCK_64X16, aom_highbd_obmc_sad64x16_bits10,
2040 aom_highbd_10_obmc_variance64x16,
2041 aom_highbd_10_obmc_sub_pixel_variance64x16)
2042
2043 HIGHBD_OBFP(BLOCK_16X64, aom_highbd_obmc_sad16x64_bits10,
2044 aom_highbd_10_obmc_variance16x64,
2045 aom_highbd_10_obmc_sub_pixel_variance16x64)
2046
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01002047 HIGHBD_OBFP(BLOCK_32X8, aom_highbd_obmc_sad32x8_bits10,
2048 aom_highbd_10_obmc_variance32x8,
2049 aom_highbd_10_obmc_sub_pixel_variance32x8)
2050
2051 HIGHBD_OBFP(BLOCK_8X32, aom_highbd_obmc_sad8x32_bits10,
2052 aom_highbd_10_obmc_variance8x32,
2053 aom_highbd_10_obmc_sub_pixel_variance8x32)
2054
2055 HIGHBD_OBFP(BLOCK_16X4, aom_highbd_obmc_sad16x4_bits10,
2056 aom_highbd_10_obmc_variance16x4,
2057 aom_highbd_10_obmc_sub_pixel_variance16x4)
2058
2059 HIGHBD_OBFP(BLOCK_4X16, aom_highbd_obmc_sad4x16_bits10,
2060 aom_highbd_10_obmc_variance4x16,
2061 aom_highbd_10_obmc_sub_pixel_variance4x16)
Yaowu Xuc27fc142016-08-22 16:08:15 -07002062 break;
2063
Yaowu Xuf883b422016-08-30 14:01:10 -07002064 case AOM_BITS_12:
Cheng Chenbf3d4962017-11-01 14:48:52 -07002065 HIGHBD_BFP(BLOCK_64X16, aom_highbd_sad64x16_bits12,
2066 aom_highbd_sad64x16_avg_bits12, aom_highbd_12_variance64x16,
2067 aom_highbd_12_sub_pixel_variance64x16,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002068 aom_highbd_12_sub_pixel_avg_variance64x16,
Cheng Chenbf3d4962017-11-01 14:48:52 -07002069 aom_highbd_sad64x16x4d_bits12,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002070 aom_highbd_dist_wtd_sad64x16_avg_bits12,
2071 aom_highbd_12_dist_wtd_sub_pixel_avg_variance64x16);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002072
2073 HIGHBD_BFP(BLOCK_16X64, aom_highbd_sad16x64_bits12,
2074 aom_highbd_sad16x64_avg_bits12, aom_highbd_12_variance16x64,
2075 aom_highbd_12_sub_pixel_variance16x64,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002076 aom_highbd_12_sub_pixel_avg_variance16x64,
Cheng Chenbf3d4962017-11-01 14:48:52 -07002077 aom_highbd_sad16x64x4d_bits12,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002078 aom_highbd_dist_wtd_sad16x64_avg_bits12,
2079 aom_highbd_12_dist_wtd_sub_pixel_avg_variance16x64);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002080
2081 HIGHBD_BFP(BLOCK_32X8, aom_highbd_sad32x8_bits12,
2082 aom_highbd_sad32x8_avg_bits12, aom_highbd_12_variance32x8,
2083 aom_highbd_12_sub_pixel_variance32x8,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002084 aom_highbd_12_sub_pixel_avg_variance32x8,
Cheng Chenbf3d4962017-11-01 14:48:52 -07002085 aom_highbd_sad32x8x4d_bits12,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002086 aom_highbd_dist_wtd_sad32x8_avg_bits12,
2087 aom_highbd_12_dist_wtd_sub_pixel_avg_variance32x8);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002088
2089 HIGHBD_BFP(BLOCK_8X32, aom_highbd_sad8x32_bits12,
2090 aom_highbd_sad8x32_avg_bits12, aom_highbd_12_variance8x32,
2091 aom_highbd_12_sub_pixel_variance8x32,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002092 aom_highbd_12_sub_pixel_avg_variance8x32,
Cheng Chenbf3d4962017-11-01 14:48:52 -07002093 aom_highbd_sad8x32x4d_bits12,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002094 aom_highbd_dist_wtd_sad8x32_avg_bits12,
2095 aom_highbd_12_dist_wtd_sub_pixel_avg_variance8x32);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002096
2097 HIGHBD_BFP(BLOCK_16X4, aom_highbd_sad16x4_bits12,
2098 aom_highbd_sad16x4_avg_bits12, aom_highbd_12_variance16x4,
2099 aom_highbd_12_sub_pixel_variance16x4,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002100 aom_highbd_12_sub_pixel_avg_variance16x4,
Cheng Chenbf3d4962017-11-01 14:48:52 -07002101 aom_highbd_sad16x4x4d_bits12,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002102 aom_highbd_dist_wtd_sad16x4_avg_bits12,
2103 aom_highbd_12_dist_wtd_sub_pixel_avg_variance16x4);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002104
2105 HIGHBD_BFP(BLOCK_4X16, aom_highbd_sad4x16_bits12,
2106 aom_highbd_sad4x16_avg_bits12, aom_highbd_12_variance4x16,
2107 aom_highbd_12_sub_pixel_variance4x16,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002108 aom_highbd_12_sub_pixel_avg_variance4x16,
Cheng Chenbf3d4962017-11-01 14:48:52 -07002109 aom_highbd_sad4x16x4d_bits12,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002110 aom_highbd_dist_wtd_sad4x16_avg_bits12,
2111 aom_highbd_12_dist_wtd_sub_pixel_avg_variance4x16);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002112
2113 HIGHBD_BFP(BLOCK_32X16, aom_highbd_sad32x16_bits12,
2114 aom_highbd_sad32x16_avg_bits12, aom_highbd_12_variance32x16,
2115 aom_highbd_12_sub_pixel_variance32x16,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002116 aom_highbd_12_sub_pixel_avg_variance32x16,
Cheng Chenbf3d4962017-11-01 14:48:52 -07002117 aom_highbd_sad32x16x4d_bits12,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002118 aom_highbd_dist_wtd_sad32x16_avg_bits12,
2119 aom_highbd_12_dist_wtd_sub_pixel_avg_variance32x16);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002120
2121 HIGHBD_BFP(BLOCK_16X32, aom_highbd_sad16x32_bits12,
2122 aom_highbd_sad16x32_avg_bits12, aom_highbd_12_variance16x32,
2123 aom_highbd_12_sub_pixel_variance16x32,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002124 aom_highbd_12_sub_pixel_avg_variance16x32,
Cheng Chenbf3d4962017-11-01 14:48:52 -07002125 aom_highbd_sad16x32x4d_bits12,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002126 aom_highbd_dist_wtd_sad16x32_avg_bits12,
2127 aom_highbd_12_dist_wtd_sub_pixel_avg_variance16x32);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002128
2129 HIGHBD_BFP(BLOCK_64X32, aom_highbd_sad64x32_bits12,
2130 aom_highbd_sad64x32_avg_bits12, aom_highbd_12_variance64x32,
2131 aom_highbd_12_sub_pixel_variance64x32,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002132 aom_highbd_12_sub_pixel_avg_variance64x32,
Cheng Chenbf3d4962017-11-01 14:48:52 -07002133 aom_highbd_sad64x32x4d_bits12,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002134 aom_highbd_dist_wtd_sad64x32_avg_bits12,
2135 aom_highbd_12_dist_wtd_sub_pixel_avg_variance64x32);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002136
2137 HIGHBD_BFP(BLOCK_32X64, aom_highbd_sad32x64_bits12,
2138 aom_highbd_sad32x64_avg_bits12, aom_highbd_12_variance32x64,
2139 aom_highbd_12_sub_pixel_variance32x64,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002140 aom_highbd_12_sub_pixel_avg_variance32x64,
Cheng Chenbf3d4962017-11-01 14:48:52 -07002141 aom_highbd_sad32x64x4d_bits12,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002142 aom_highbd_dist_wtd_sad32x64_avg_bits12,
2143 aom_highbd_12_dist_wtd_sub_pixel_avg_variance32x64);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002144
2145 HIGHBD_BFP(BLOCK_32X32, aom_highbd_sad32x32_bits12,
2146 aom_highbd_sad32x32_avg_bits12, aom_highbd_12_variance32x32,
2147 aom_highbd_12_sub_pixel_variance32x32,
2148 aom_highbd_12_sub_pixel_avg_variance32x32,
Cheng Chenbf3d4962017-11-01 14:48:52 -07002149 aom_highbd_sad32x32x4d_bits12,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002150 aom_highbd_dist_wtd_sad32x32_avg_bits12,
2151 aom_highbd_12_dist_wtd_sub_pixel_avg_variance32x32);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002152
2153 HIGHBD_BFP(BLOCK_64X64, aom_highbd_sad64x64_bits12,
2154 aom_highbd_sad64x64_avg_bits12, aom_highbd_12_variance64x64,
2155 aom_highbd_12_sub_pixel_variance64x64,
2156 aom_highbd_12_sub_pixel_avg_variance64x64,
Cheng Chenbf3d4962017-11-01 14:48:52 -07002157 aom_highbd_sad64x64x4d_bits12,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002158 aom_highbd_dist_wtd_sad64x64_avg_bits12,
2159 aom_highbd_12_dist_wtd_sub_pixel_avg_variance64x64);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002160
2161 HIGHBD_BFP(BLOCK_16X16, aom_highbd_sad16x16_bits12,
2162 aom_highbd_sad16x16_avg_bits12, aom_highbd_12_variance16x16,
2163 aom_highbd_12_sub_pixel_variance16x16,
2164 aom_highbd_12_sub_pixel_avg_variance16x16,
Cheng Chenbf3d4962017-11-01 14:48:52 -07002165 aom_highbd_sad16x16x4d_bits12,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002166 aom_highbd_dist_wtd_sad16x16_avg_bits12,
2167 aom_highbd_12_dist_wtd_sub_pixel_avg_variance16x16);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002168
2169 HIGHBD_BFP(BLOCK_16X8, aom_highbd_sad16x8_bits12,
2170 aom_highbd_sad16x8_avg_bits12, aom_highbd_12_variance16x8,
2171 aom_highbd_12_sub_pixel_variance16x8,
2172 aom_highbd_12_sub_pixel_avg_variance16x8,
Cheng Chenbf3d4962017-11-01 14:48:52 -07002173 aom_highbd_sad16x8x4d_bits12,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002174 aom_highbd_dist_wtd_sad16x8_avg_bits12,
2175 aom_highbd_12_dist_wtd_sub_pixel_avg_variance16x8);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002176
2177 HIGHBD_BFP(BLOCK_8X16, aom_highbd_sad8x16_bits12,
2178 aom_highbd_sad8x16_avg_bits12, aom_highbd_12_variance8x16,
2179 aom_highbd_12_sub_pixel_variance8x16,
2180 aom_highbd_12_sub_pixel_avg_variance8x16,
Cheng Chenbf3d4962017-11-01 14:48:52 -07002181 aom_highbd_sad8x16x4d_bits12,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002182 aom_highbd_dist_wtd_sad8x16_avg_bits12,
2183 aom_highbd_12_dist_wtd_sub_pixel_avg_variance8x16);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002184
2185 HIGHBD_BFP(
2186 BLOCK_8X8, aom_highbd_sad8x8_bits12, aom_highbd_sad8x8_avg_bits12,
2187 aom_highbd_12_variance8x8, aom_highbd_12_sub_pixel_variance8x8,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002188 aom_highbd_12_sub_pixel_avg_variance8x8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002189 aom_highbd_sad8x8x4d_bits12, aom_highbd_dist_wtd_sad8x8_avg_bits12,
2190 aom_highbd_12_dist_wtd_sub_pixel_avg_variance8x8);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002191
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002192 HIGHBD_BFP(
2193 BLOCK_8X4, aom_highbd_sad8x4_bits12, aom_highbd_sad8x4_avg_bits12,
2194 aom_highbd_12_variance8x4, aom_highbd_12_sub_pixel_variance8x4,
2195 aom_highbd_12_sub_pixel_avg_variance8x4,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002196 aom_highbd_sad8x4x4d_bits12, aom_highbd_dist_wtd_sad8x4_avg_bits12,
2197 aom_highbd_12_dist_wtd_sub_pixel_avg_variance8x4);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002198
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002199 HIGHBD_BFP(
2200 BLOCK_4X8, aom_highbd_sad4x8_bits12, aom_highbd_sad4x8_avg_bits12,
2201 aom_highbd_12_variance4x8, aom_highbd_12_sub_pixel_variance4x8,
2202 aom_highbd_12_sub_pixel_avg_variance4x8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002203 aom_highbd_sad4x8x4d_bits12, aom_highbd_dist_wtd_sad4x8_avg_bits12,
2204 aom_highbd_12_dist_wtd_sub_pixel_avg_variance4x8);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002205
2206 HIGHBD_BFP(
2207 BLOCK_4X4, aom_highbd_sad4x4_bits12, aom_highbd_sad4x4_avg_bits12,
2208 aom_highbd_12_variance4x4, aom_highbd_12_sub_pixel_variance4x4,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002209 aom_highbd_12_sub_pixel_avg_variance4x4,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002210 aom_highbd_sad4x4x4d_bits12, aom_highbd_dist_wtd_sad4x4_avg_bits12,
2211 aom_highbd_12_dist_wtd_sub_pixel_avg_variance4x4);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002212
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002213 HIGHBD_BFP(BLOCK_128X128, aom_highbd_sad128x128_bits12,
2214 aom_highbd_sad128x128_avg_bits12,
2215 aom_highbd_12_variance128x128,
2216 aom_highbd_12_sub_pixel_variance128x128,
2217 aom_highbd_12_sub_pixel_avg_variance128x128,
2218 aom_highbd_sad128x128x4d_bits12,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002219 aom_highbd_dist_wtd_sad128x128_avg_bits12,
2220 aom_highbd_12_dist_wtd_sub_pixel_avg_variance128x128);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002221
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002222 HIGHBD_BFP(BLOCK_128X64, aom_highbd_sad128x64_bits12,
2223 aom_highbd_sad128x64_avg_bits12,
2224 aom_highbd_12_variance128x64,
2225 aom_highbd_12_sub_pixel_variance128x64,
2226 aom_highbd_12_sub_pixel_avg_variance128x64,
2227 aom_highbd_sad128x64x4d_bits12,
2228 aom_highbd_dist_wtd_sad128x64_avg_bits12,
2229 aom_highbd_12_dist_wtd_sub_pixel_avg_variance128x64);
Cheng Chenbf3d4962017-11-01 14:48:52 -07002230
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002231 HIGHBD_BFP(BLOCK_64X128, aom_highbd_sad64x128_bits12,
2232 aom_highbd_sad64x128_avg_bits12,
2233 aom_highbd_12_variance64x128,
2234 aom_highbd_12_sub_pixel_variance64x128,
2235 aom_highbd_12_sub_pixel_avg_variance64x128,
2236 aom_highbd_sad64x128x4d_bits12,
2237 aom_highbd_dist_wtd_sad64x128_avg_bits12,
2238 aom_highbd_12_dist_wtd_sub_pixel_avg_variance64x128);
Yaowu Xuc27fc142016-08-22 16:08:15 -07002239
David Barkerf19f35f2017-05-22 16:33:22 +01002240 HIGHBD_MBFP(BLOCK_128X128, aom_highbd_masked_sad128x128_bits12,
2241 aom_highbd_12_masked_sub_pixel_variance128x128)
2242 HIGHBD_MBFP(BLOCK_128X64, aom_highbd_masked_sad128x64_bits12,
2243 aom_highbd_12_masked_sub_pixel_variance128x64)
2244 HIGHBD_MBFP(BLOCK_64X128, aom_highbd_masked_sad64x128_bits12,
2245 aom_highbd_12_masked_sub_pixel_variance64x128)
David Barkerf19f35f2017-05-22 16:33:22 +01002246 HIGHBD_MBFP(BLOCK_64X64, aom_highbd_masked_sad64x64_bits12,
2247 aom_highbd_12_masked_sub_pixel_variance64x64)
2248 HIGHBD_MBFP(BLOCK_64X32, aom_highbd_masked_sad64x32_bits12,
2249 aom_highbd_12_masked_sub_pixel_variance64x32)
2250 HIGHBD_MBFP(BLOCK_32X64, aom_highbd_masked_sad32x64_bits12,
2251 aom_highbd_12_masked_sub_pixel_variance32x64)
2252 HIGHBD_MBFP(BLOCK_32X32, aom_highbd_masked_sad32x32_bits12,
2253 aom_highbd_12_masked_sub_pixel_variance32x32)
2254 HIGHBD_MBFP(BLOCK_32X16, aom_highbd_masked_sad32x16_bits12,
2255 aom_highbd_12_masked_sub_pixel_variance32x16)
2256 HIGHBD_MBFP(BLOCK_16X32, aom_highbd_masked_sad16x32_bits12,
2257 aom_highbd_12_masked_sub_pixel_variance16x32)
2258 HIGHBD_MBFP(BLOCK_16X16, aom_highbd_masked_sad16x16_bits12,
2259 aom_highbd_12_masked_sub_pixel_variance16x16)
2260 HIGHBD_MBFP(BLOCK_8X16, aom_highbd_masked_sad8x16_bits12,
2261 aom_highbd_12_masked_sub_pixel_variance8x16)
2262 HIGHBD_MBFP(BLOCK_16X8, aom_highbd_masked_sad16x8_bits12,
2263 aom_highbd_12_masked_sub_pixel_variance16x8)
2264 HIGHBD_MBFP(BLOCK_8X8, aom_highbd_masked_sad8x8_bits12,
2265 aom_highbd_12_masked_sub_pixel_variance8x8)
2266 HIGHBD_MBFP(BLOCK_4X8, aom_highbd_masked_sad4x8_bits12,
2267 aom_highbd_12_masked_sub_pixel_variance4x8)
2268 HIGHBD_MBFP(BLOCK_8X4, aom_highbd_masked_sad8x4_bits12,
2269 aom_highbd_12_masked_sub_pixel_variance8x4)
2270 HIGHBD_MBFP(BLOCK_4X4, aom_highbd_masked_sad4x4_bits12,
2271 aom_highbd_12_masked_sub_pixel_variance4x4)
Rupert Swarbrick72678572017-08-02 12:05:26 +01002272 HIGHBD_MBFP(BLOCK_64X16, aom_highbd_masked_sad64x16_bits12,
2273 aom_highbd_12_masked_sub_pixel_variance64x16)
Rupert Swarbrick72678572017-08-02 12:05:26 +01002274 HIGHBD_MBFP(BLOCK_16X64, aom_highbd_masked_sad16x64_bits12,
2275 aom_highbd_12_masked_sub_pixel_variance16x64)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01002276 HIGHBD_MBFP(BLOCK_32X8, aom_highbd_masked_sad32x8_bits12,
2277 aom_highbd_12_masked_sub_pixel_variance32x8)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01002278 HIGHBD_MBFP(BLOCK_8X32, aom_highbd_masked_sad8x32_bits12,
2279 aom_highbd_12_masked_sub_pixel_variance8x32)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01002280 HIGHBD_MBFP(BLOCK_16X4, aom_highbd_masked_sad16x4_bits12,
2281 aom_highbd_12_masked_sub_pixel_variance16x4)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01002282 HIGHBD_MBFP(BLOCK_4X16, aom_highbd_masked_sad4x16_bits12,
2283 aom_highbd_12_masked_sub_pixel_variance4x16)
Yaowu Xuf883b422016-08-30 14:01:10 -07002284 HIGHBD_OBFP(BLOCK_128X128, aom_highbd_obmc_sad128x128_bits12,
2285 aom_highbd_12_obmc_variance128x128,
2286 aom_highbd_12_obmc_sub_pixel_variance128x128)
2287 HIGHBD_OBFP(BLOCK_128X64, aom_highbd_obmc_sad128x64_bits12,
2288 aom_highbd_12_obmc_variance128x64,
2289 aom_highbd_12_obmc_sub_pixel_variance128x64)
2290 HIGHBD_OBFP(BLOCK_64X128, aom_highbd_obmc_sad64x128_bits12,
2291 aom_highbd_12_obmc_variance64x128,
2292 aom_highbd_12_obmc_sub_pixel_variance64x128)
Yaowu Xuf883b422016-08-30 14:01:10 -07002293 HIGHBD_OBFP(BLOCK_64X64, aom_highbd_obmc_sad64x64_bits12,
2294 aom_highbd_12_obmc_variance64x64,
2295 aom_highbd_12_obmc_sub_pixel_variance64x64)
2296 HIGHBD_OBFP(BLOCK_64X32, aom_highbd_obmc_sad64x32_bits12,
2297 aom_highbd_12_obmc_variance64x32,
2298 aom_highbd_12_obmc_sub_pixel_variance64x32)
2299 HIGHBD_OBFP(BLOCK_32X64, aom_highbd_obmc_sad32x64_bits12,
2300 aom_highbd_12_obmc_variance32x64,
2301 aom_highbd_12_obmc_sub_pixel_variance32x64)
2302 HIGHBD_OBFP(BLOCK_32X32, aom_highbd_obmc_sad32x32_bits12,
2303 aom_highbd_12_obmc_variance32x32,
2304 aom_highbd_12_obmc_sub_pixel_variance32x32)
2305 HIGHBD_OBFP(BLOCK_32X16, aom_highbd_obmc_sad32x16_bits12,
2306 aom_highbd_12_obmc_variance32x16,
2307 aom_highbd_12_obmc_sub_pixel_variance32x16)
2308 HIGHBD_OBFP(BLOCK_16X32, aom_highbd_obmc_sad16x32_bits12,
2309 aom_highbd_12_obmc_variance16x32,
2310 aom_highbd_12_obmc_sub_pixel_variance16x32)
2311 HIGHBD_OBFP(BLOCK_16X16, aom_highbd_obmc_sad16x16_bits12,
2312 aom_highbd_12_obmc_variance16x16,
2313 aom_highbd_12_obmc_sub_pixel_variance16x16)
2314 HIGHBD_OBFP(BLOCK_8X16, aom_highbd_obmc_sad8x16_bits12,
2315 aom_highbd_12_obmc_variance8x16,
2316 aom_highbd_12_obmc_sub_pixel_variance8x16)
2317 HIGHBD_OBFP(BLOCK_16X8, aom_highbd_obmc_sad16x8_bits12,
2318 aom_highbd_12_obmc_variance16x8,
2319 aom_highbd_12_obmc_sub_pixel_variance16x8)
2320 HIGHBD_OBFP(BLOCK_8X8, aom_highbd_obmc_sad8x8_bits12,
2321 aom_highbd_12_obmc_variance8x8,
2322 aom_highbd_12_obmc_sub_pixel_variance8x8)
2323 HIGHBD_OBFP(BLOCK_4X8, aom_highbd_obmc_sad4x8_bits12,
2324 aom_highbd_12_obmc_variance4x8,
2325 aom_highbd_12_obmc_sub_pixel_variance4x8)
2326 HIGHBD_OBFP(BLOCK_8X4, aom_highbd_obmc_sad8x4_bits12,
2327 aom_highbd_12_obmc_variance8x4,
2328 aom_highbd_12_obmc_sub_pixel_variance8x4)
2329 HIGHBD_OBFP(BLOCK_4X4, aom_highbd_obmc_sad4x4_bits12,
2330 aom_highbd_12_obmc_variance4x4,
2331 aom_highbd_12_obmc_sub_pixel_variance4x4)
Rupert Swarbrick72678572017-08-02 12:05:26 +01002332 HIGHBD_OBFP(BLOCK_64X16, aom_highbd_obmc_sad64x16_bits12,
2333 aom_highbd_12_obmc_variance64x16,
2334 aom_highbd_12_obmc_sub_pixel_variance64x16)
Rupert Swarbrick72678572017-08-02 12:05:26 +01002335 HIGHBD_OBFP(BLOCK_16X64, aom_highbd_obmc_sad16x64_bits12,
2336 aom_highbd_12_obmc_variance16x64,
2337 aom_highbd_12_obmc_sub_pixel_variance16x64)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01002338 HIGHBD_OBFP(BLOCK_32X8, aom_highbd_obmc_sad32x8_bits12,
2339 aom_highbd_12_obmc_variance32x8,
2340 aom_highbd_12_obmc_sub_pixel_variance32x8)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01002341 HIGHBD_OBFP(BLOCK_8X32, aom_highbd_obmc_sad8x32_bits12,
2342 aom_highbd_12_obmc_variance8x32,
2343 aom_highbd_12_obmc_sub_pixel_variance8x32)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01002344 HIGHBD_OBFP(BLOCK_16X4, aom_highbd_obmc_sad16x4_bits12,
2345 aom_highbd_12_obmc_variance16x4,
2346 aom_highbd_12_obmc_sub_pixel_variance16x4)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01002347 HIGHBD_OBFP(BLOCK_4X16, aom_highbd_obmc_sad4x16_bits12,
2348 aom_highbd_12_obmc_variance4x16,
2349 aom_highbd_12_obmc_sub_pixel_variance4x16)
Yaowu Xuc27fc142016-08-22 16:08:15 -07002350 break;
2351
2352 default:
2353 assert(0 &&
Urvang Joshi20cf30e2018-07-19 02:33:58 -07002354 "cm->seq_params.bit_depth should be AOM_BITS_8, "
Yaowu Xuf883b422016-08-30 14:01:10 -07002355 "AOM_BITS_10 or AOM_BITS_12");
Yaowu Xuc27fc142016-08-22 16:08:15 -07002356 }
2357 }
2358}
Yaowu Xuc27fc142016-08-22 16:08:15 -07002359
Yaowu Xuf883b422016-08-30 14:01:10 -07002360static void realloc_segmentation_maps(AV1_COMP *cpi) {
2361 AV1_COMMON *const cm = &cpi->common;
Yaowu Xuc27fc142016-08-22 16:08:15 -07002362
2363 // Create the encoder segmentation map and set all entries to 0
Yaowu Xuf883b422016-08-30 14:01:10 -07002364 aom_free(cpi->segmentation_map);
Yaowu Xuc27fc142016-08-22 16:08:15 -07002365 CHECK_MEM_ERROR(cm, cpi->segmentation_map,
Yaowu Xuf883b422016-08-30 14:01:10 -07002366 aom_calloc(cm->mi_rows * cm->mi_cols, 1));
Yaowu Xuc27fc142016-08-22 16:08:15 -07002367
2368 // Create a map used for cyclic background refresh.
Yaowu Xuf883b422016-08-30 14:01:10 -07002369 if (cpi->cyclic_refresh) av1_cyclic_refresh_free(cpi->cyclic_refresh);
Yaowu Xuc27fc142016-08-22 16:08:15 -07002370 CHECK_MEM_ERROR(cm, cpi->cyclic_refresh,
Yaowu Xuf883b422016-08-30 14:01:10 -07002371 av1_cyclic_refresh_alloc(cm->mi_rows, cm->mi_cols));
Yaowu Xuc27fc142016-08-22 16:08:15 -07002372
2373 // Create a map used to mark inactive areas.
Yaowu Xuf883b422016-08-30 14:01:10 -07002374 aom_free(cpi->active_map.map);
Yaowu Xuc27fc142016-08-22 16:08:15 -07002375 CHECK_MEM_ERROR(cm, cpi->active_map.map,
Yaowu Xuf883b422016-08-30 14:01:10 -07002376 aom_calloc(cm->mi_rows * cm->mi_cols, 1));
Yaowu Xuc27fc142016-08-22 16:08:15 -07002377}
2378
Yaowu Xuf883b422016-08-30 14:01:10 -07002379void av1_change_config(struct AV1_COMP *cpi, const AV1EncoderConfig *oxcf) {
2380 AV1_COMMON *const cm = &cpi->common;
Urvang Joshi20cf30e2018-07-19 02:33:58 -07002381 SequenceHeader *const seq_params = &cm->seq_params;
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +00002382 const int num_planes = av1_num_planes(cm);
Yaowu Xuc27fc142016-08-22 16:08:15 -07002383 RATE_CONTROL *const rc = &cpi->rc;
hui sud9a812b2017-07-06 14:34:37 -07002384 MACROBLOCK *const x = &cpi->td.mb;
Yaowu Xuc27fc142016-08-22 16:08:15 -07002385
Urvang Joshi20cf30e2018-07-19 02:33:58 -07002386 if (seq_params->profile != oxcf->profile) seq_params->profile = oxcf->profile;
2387 seq_params->bit_depth = oxcf->bit_depth;
2388 seq_params->color_primaries = oxcf->color_primaries;
2389 seq_params->transfer_characteristics = oxcf->transfer_characteristics;
2390 seq_params->matrix_coefficients = oxcf->matrix_coefficients;
2391 seq_params->monochrome = oxcf->monochrome;
2392 seq_params->chroma_sample_position = oxcf->chroma_sample_position;
2393 seq_params->color_range = oxcf->color_range;
Yaowu Xuc27fc142016-08-22 16:08:15 -07002394
Urvang Joshi20cf30e2018-07-19 02:33:58 -07002395 assert(IMPLIES(seq_params->profile <= PROFILE_1,
2396 seq_params->bit_depth <= AOM_BITS_10));
Yaowu Xuc27fc142016-08-22 16:08:15 -07002397
Hui Su2aa492c2019-03-12 15:18:18 -07002398 memcpy(cpi->target_seq_level_idx, oxcf->target_seq_level_idx,
2399 sizeof(cpi->target_seq_level_idx));
2400 cpi->keep_level_stats = 0;
2401 for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i) {
2402 if (cpi->target_seq_level_idx[i] < SEQ_LEVELS) {
2403 cpi->keep_level_stats = 1;
2404 break;
2405 }
2406 }
kyslovabeeb7c2019-03-06 18:35:04 -08002407
Andrey Norkin28e9ce22018-01-08 10:11:21 -08002408 cm->timing_info_present = oxcf->timing_info_present;
Andrey Norkin795ba872018-03-06 13:24:14 -08002409 cm->timing_info.num_units_in_display_tick =
2410 oxcf->timing_info.num_units_in_display_tick;
2411 cm->timing_info.time_scale = oxcf->timing_info.time_scale;
2412 cm->timing_info.equal_picture_interval =
2413 oxcf->timing_info.equal_picture_interval;
2414 cm->timing_info.num_ticks_per_picture =
2415 oxcf->timing_info.num_ticks_per_picture;
2416
Urvang Joshi20cf30e2018-07-19 02:33:58 -07002417 seq_params->display_model_info_present_flag =
Andrey Norkin26495512018-06-20 17:13:11 -07002418 oxcf->display_model_info_present_flag;
Urvang Joshi20cf30e2018-07-19 02:33:58 -07002419 seq_params->decoder_model_info_present_flag =
Adrian Grangec56f6ec2018-05-31 14:19:32 -07002420 oxcf->decoder_model_info_present_flag;
Andrey Norkin795ba872018-03-06 13:24:14 -08002421 if (oxcf->decoder_model_info_present_flag) {
Andrey Norkin26495512018-06-20 17:13:11 -07002422 // set the decoder model parameters in schedule mode
Andrey Norkin795ba872018-03-06 13:24:14 -08002423 cm->buffer_model.num_units_in_decoding_tick =
2424 oxcf->buffer_model.num_units_in_decoding_tick;
Wan-Teh Changf64b3bc2018-07-02 09:42:39 -07002425 cm->buffer_removal_time_present = 1;
Andrey Norkin795ba872018-03-06 13:24:14 -08002426 set_aom_dec_model_info(&cm->buffer_model);
Andrey Norkin26495512018-06-20 17:13:11 -07002427 set_dec_model_op_parameters(&cm->op_params[0]);
2428 } else if (cm->timing_info_present &&
2429 cm->timing_info.equal_picture_interval &&
Urvang Joshi20cf30e2018-07-19 02:33:58 -07002430 !seq_params->decoder_model_info_present_flag) {
Andrey Norkin26495512018-06-20 17:13:11 -07002431 // set the decoder model parameters in resource availability mode
2432 set_resource_availability_parameters(&cm->op_params[0]);
Andrey Norkinc7511de2018-06-22 12:31:06 -07002433 } else {
2434 cm->op_params[0].initial_display_delay =
2435 10; // Default value (not signaled)
Andrey Norkin795ba872018-03-06 13:24:14 -08002436 }
Andrey Norkin28e9ce22018-01-08 10:11:21 -08002437
Andrey Norkin6f1c2f72018-01-15 20:08:52 -08002438 update_film_grain_parameters(cpi, oxcf);
Andrey Norkin6f1c2f72018-01-15 20:08:52 -08002439
Yaowu Xuc27fc142016-08-22 16:08:15 -07002440 cpi->oxcf = *oxcf;
Maxym Dmytrychenkocc6e0e12018-02-05 16:35:37 +01002441 cpi->common.options = oxcf->cfg;
Urvang Joshi20cf30e2018-07-19 02:33:58 -07002442 x->e_mbd.bd = (int)seq_params->bit_depth;
hui sud9a812b2017-07-06 14:34:37 -07002443 x->e_mbd.global_motion = cm->global_motion;
Yaowu Xuc27fc142016-08-22 16:08:15 -07002444
Yaowu Xuf883b422016-08-30 14:01:10 -07002445 if ((oxcf->pass == 0) && (oxcf->rc_mode == AOM_Q)) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07002446 rc->baseline_gf_interval = FIXED_GF_INTERVAL;
2447 } else {
2448 rc->baseline_gf_interval = (MIN_GF_INTERVAL + MAX_GF_INTERVAL) / 2;
2449 }
2450
2451 cpi->refresh_last_frame = 1;
2452 cpi->refresh_golden_frame = 0;
Yaowu Xuc27fc142016-08-22 16:08:15 -07002453 cpi->refresh_bwd_ref_frame = 0;
Zoe Liue9b15e22017-07-19 15:53:01 -07002454 cpi->refresh_alt2_ref_frame = 0;
Yaowu Xuc27fc142016-08-22 16:08:15 -07002455
Debargha Mukherjee229fdc82018-03-10 07:45:33 -08002456 cm->refresh_frame_context = (oxcf->frame_parallel_decoding_mode)
2457 ? REFRESH_FRAME_CONTEXT_DISABLED
2458 : REFRESH_FRAME_CONTEXT_BACKWARD;
Rupert Swarbrick84b05ac2017-10-27 18:10:53 +01002459 if (oxcf->large_scale_tile)
James Zernf34dfc82018-02-23 16:53:33 -08002460 cm->refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED;
Rupert Swarbrick84b05ac2017-10-27 18:10:53 +01002461
Alex Converse74ad0912017-07-18 10:22:58 -07002462 if (x->palette_buffer == NULL) {
hui sud9a812b2017-07-06 14:34:37 -07002463 CHECK_MEM_ERROR(cm, x->palette_buffer,
2464 aom_memalign(16, sizeof(*x->palette_buffer)));
2465 }
Urvang Joshi0a4cfad2018-09-07 11:10:39 -07002466
2467 if (x->tmp_conv_dst == NULL) {
2468 CHECK_MEM_ERROR(
2469 cm, x->tmp_conv_dst,
2470 aom_memalign(32, MAX_SB_SIZE * MAX_SB_SIZE * sizeof(*x->tmp_conv_dst)));
Urvang Joshie58f6ec2018-09-10 15:10:12 -07002471 x->e_mbd.tmp_conv_dst = x->tmp_conv_dst;
Urvang Joshi0a4cfad2018-09-07 11:10:39 -07002472 }
2473 for (int i = 0; i < 2; ++i) {
2474 if (x->tmp_obmc_bufs[i] == NULL) {
2475 CHECK_MEM_ERROR(cm, x->tmp_obmc_bufs[i],
wenyao.liu22d8ab32018-10-16 09:11:29 +08002476 aom_memalign(32, 2 * MAX_MB_PLANE * MAX_SB_SQUARE *
Urvang Joshi0a4cfad2018-09-07 11:10:39 -07002477 sizeof(*x->tmp_obmc_bufs[i])));
Urvang Joshie58f6ec2018-09-10 15:10:12 -07002478 x->e_mbd.tmp_obmc_bufs[i] = x->tmp_obmc_bufs[i];
Urvang Joshi0a4cfad2018-09-07 11:10:39 -07002479 }
2480 }
2481
Yaowu Xuf883b422016-08-30 14:01:10 -07002482 av1_reset_segment_features(cm);
Debargha Mukherjeeb2147752017-11-01 07:00:45 -07002483 set_high_precision_mv(cpi, 1, 0);
Yaowu Xuc27fc142016-08-22 16:08:15 -07002484
Yaowu Xuc27fc142016-08-22 16:08:15 -07002485 set_rc_buffer_sizes(rc, &cpi->oxcf);
2486
2487 // Under a configuration change, where maximum_buffer_size may change,
2488 // keep buffer level clipped to the maximum allowed buffer size.
Yaowu Xuf883b422016-08-30 14:01:10 -07002489 rc->bits_off_target = AOMMIN(rc->bits_off_target, rc->maximum_buffer_size);
2490 rc->buffer_level = AOMMIN(rc->buffer_level, rc->maximum_buffer_size);
Yaowu Xuc27fc142016-08-22 16:08:15 -07002491
2492 // Set up frame rate and related parameters rate control values.
Yaowu Xuf883b422016-08-30 14:01:10 -07002493 av1_new_framerate(cpi, cpi->framerate);
Yaowu Xuc27fc142016-08-22 16:08:15 -07002494
2495 // Set absolute upper and lower quality limits
2496 rc->worst_quality = cpi->oxcf.worst_allowed_q;
2497 rc->best_quality = cpi->oxcf.best_allowed_q;
2498
Urvang Joshib55cb5e2018-09-12 14:50:21 -07002499 cm->interp_filter = oxcf->large_scale_tile ? EIGHTTAP_REGULAR : SWITCHABLE;
Yue Chen5380cb52018-02-23 15:33:21 -08002500 cm->switchable_motion_mode = 1;
2501
Yaowu Xuc27fc142016-08-22 16:08:15 -07002502 if (cpi->oxcf.render_width > 0 && cpi->oxcf.render_height > 0) {
2503 cm->render_width = cpi->oxcf.render_width;
2504 cm->render_height = cpi->oxcf.render_height;
2505 } else {
2506 cm->render_width = cpi->oxcf.width;
2507 cm->render_height = cpi->oxcf.height;
2508 }
2509 cm->width = cpi->oxcf.width;
2510 cm->height = cpi->oxcf.height;
2511
Urvang Joshi20cf30e2018-07-19 02:33:58 -07002512 int sb_size = seq_params->sb_size;
Urvang Joshie4530f82018-01-09 11:43:37 -08002513 // Superblock size should not be updated after the first key frame.
2514 if (!cpi->seq_params_locked) {
2515 set_sb_size(&cm->seq_params, select_sb_size(cpi));
Hui Sud909c2c2019-03-08 11:51:14 -08002516 for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i)
2517 seq_params->tier[i] = (oxcf->tier_mask >> i) & 1;
Urvang Joshie4530f82018-01-09 11:43:37 -08002518 }
Dominic Symes917d6c02017-10-11 18:00:52 +02002519
Urvang Joshi20cf30e2018-07-19 02:33:58 -07002520 if (cpi->initial_width || sb_size != seq_params->sb_size) {
Dominic Symes917d6c02017-10-11 18:00:52 +02002521 if (cm->width > cpi->initial_width || cm->height > cpi->initial_height ||
Urvang Joshi20cf30e2018-07-19 02:33:58 -07002522 seq_params->sb_size != sb_size) {
Yaowu Xuf883b422016-08-30 14:01:10 -07002523 av1_free_context_buffers(cm);
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +00002524 av1_free_pc_tree(&cpi->td, num_planes);
Cheng Chen46f30c72017-09-07 11:13:33 -07002525 alloc_compressor_data(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07002526 realloc_segmentation_maps(cpi);
2527 cpi->initial_width = cpi->initial_height = 0;
2528 }
2529 }
2530 update_frame_size(cpi);
2531
2532 cpi->alt_ref_source = NULL;
2533 rc->is_src_frame_alt_ref = 0;
2534
Yaowu Xuc27fc142016-08-22 16:08:15 -07002535 set_tile_info(cpi);
2536
2537 cpi->ext_refresh_frame_flags_pending = 0;
2538 cpi->ext_refresh_frame_context_pending = 0;
2539
Yaowu Xuc27fc142016-08-22 16:08:15 -07002540 highbd_set_var_fns(cpi);
Imdad Sardharwallabf2cc012018-02-09 17:32:10 +00002541
Debargha Mukherjeeedd77252018-03-25 12:01:38 -07002542 // Init sequence level coding tools
Debargha Mukherjeef2e5bb32018-03-26 14:35:24 -07002543 // This should not be called after the first key frame.
2544 if (!cpi->seq_params_locked) {
Urvang Joshi20cf30e2018-07-19 02:33:58 -07002545 seq_params->operating_points_cnt_minus_1 =
Adrian Grangec56f6ec2018-05-31 14:19:32 -07002546 cm->number_spatial_layers > 1 ? cm->number_spatial_layers - 1 : 0;
Andrey Norkin26495512018-06-20 17:13:11 -07002547 init_seq_coding_tools(&cm->seq_params, cm, oxcf);
Debargha Mukherjeef2e5bb32018-03-26 14:35:24 -07002548 }
Yaowu Xuc27fc142016-08-22 16:08:15 -07002549}
2550
chiyotsaid16a2572019-03-05 17:48:10 -08002551static void init_level_info(AV1LevelInfo *level_info) {
Hui Sua1ff3f82019-03-12 11:59:01 -07002552 memset(level_info, 0, MAX_NUM_OPERATING_POINTS * sizeof(*level_info));
2553 for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i)
2554 level_info[i].level_spec.level = SEQ_LEVEL_MAX;
chiyotsaid16a2572019-03-05 17:48:10 -08002555}
2556
Yaowu Xuf883b422016-08-30 14:01:10 -07002557AV1_COMP *av1_create_compressor(AV1EncoderConfig *oxcf,
2558 BufferPool *const pool) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07002559 unsigned int i;
Yaowu Xuf883b422016-08-30 14:01:10 -07002560 AV1_COMP *volatile const cpi = aom_memalign(32, sizeof(AV1_COMP));
2561 AV1_COMMON *volatile const cm = cpi != NULL ? &cpi->common : NULL;
Yaowu Xuc27fc142016-08-22 16:08:15 -07002562
2563 if (!cm) return NULL;
2564
Yaowu Xuf883b422016-08-30 14:01:10 -07002565 av1_zero(*cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07002566
Wan-Teh Changa2fad3e2018-07-19 16:55:19 -07002567 // The jmp_buf is valid only for the duration of the function that calls
2568 // setjmp(). Therefore, this function must reset the 'setjmp' field to 0
2569 // before it returns.
Yaowu Xuc27fc142016-08-22 16:08:15 -07002570 if (setjmp(cm->error.jmp)) {
2571 cm->error.setjmp = 0;
Yaowu Xuf883b422016-08-30 14:01:10 -07002572 av1_remove_compressor(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07002573 return 0;
2574 }
2575
2576 cm->error.setjmp = 1;
Cheng Chen46f30c72017-09-07 11:13:33 -07002577 cm->alloc_mi = enc_alloc_mi;
2578 cm->free_mi = enc_free_mi;
2579 cm->setup_mi = enc_setup_mi;
Yaowu Xuc27fc142016-08-22 16:08:15 -07002580
Angie Chianga5d96c42016-10-21 16:16:56 -07002581 CHECK_MEM_ERROR(cm, cm->fc,
2582 (FRAME_CONTEXT *)aom_memalign(32, sizeof(*cm->fc)));
David Turner1bcefb32018-11-19 17:54:00 +00002583 CHECK_MEM_ERROR(
2584 cm, cm->default_frame_context,
2585 (FRAME_CONTEXT *)aom_memalign(32, sizeof(*cm->default_frame_context)));
Angie Chianga5d96c42016-10-21 16:16:56 -07002586 memset(cm->fc, 0, sizeof(*cm->fc));
David Turner1bcefb32018-11-19 17:54:00 +00002587 memset(cm->default_frame_context, 0, sizeof(*cm->default_frame_context));
Yaowu Xuc27fc142016-08-22 16:08:15 -07002588
2589 cpi->resize_state = 0;
2590 cpi->resize_avg_qp = 0;
2591 cpi->resize_buffer_underflow = 0;
Fergus Simpsonddc846e2017-04-24 18:09:13 -07002592
Yaowu Xuc27fc142016-08-22 16:08:15 -07002593 cpi->common.buffer_pool = pool;
2594
2595 init_config(cpi, oxcf);
Yaowu Xuf883b422016-08-30 14:01:10 -07002596 av1_rc_init(&cpi->oxcf, oxcf->pass, &cpi->rc);
Yaowu Xuc27fc142016-08-22 16:08:15 -07002597
David Turnerd2a592e2018-11-16 14:59:31 +00002598 cm->current_frame.frame_number = 0;
David Turnera4c96252019-01-11 16:36:39 +00002599 cm->current_frame_id = -1;
Debargha Mukherjeef2e5bb32018-03-26 14:35:24 -07002600 cpi->seq_params_locked = 0;
Yaowu Xuc27fc142016-08-22 16:08:15 -07002601 cpi->partition_search_skippable_frame = 0;
2602 cpi->tile_data = NULL;
David Turnere7ebf902018-12-04 14:04:55 +00002603 cpi->last_show_frame_buf = NULL;
Yaowu Xuc27fc142016-08-22 16:08:15 -07002604 realloc_segmentation_maps(cpi);
2605
Jingning Hanf050fc12018-03-09 14:53:33 -08002606 memset(cpi->nmv_costs, 0, sizeof(cpi->nmv_costs));
2607 memset(cpi->nmv_costs_hp, 0, sizeof(cpi->nmv_costs_hp));
James Zern01a9d702017-08-25 19:09:33 +00002608
Yaowu Xuc27fc142016-08-22 16:08:15 -07002609 for (i = 0; i < (sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]));
2610 i++) {
2611 CHECK_MEM_ERROR(
2612 cm, cpi->mbgraph_stats[i].mb_stats,
Yaowu Xuf883b422016-08-30 14:01:10 -07002613 aom_calloc(cm->MBs * sizeof(*cpi->mbgraph_stats[i].mb_stats), 1));
Yaowu Xuc27fc142016-08-22 16:08:15 -07002614 }
2615
Yaowu Xuc27fc142016-08-22 16:08:15 -07002616 cpi->refresh_alt_ref_frame = 0;
Yaowu Xuc27fc142016-08-22 16:08:15 -07002617
Hui Sua1ff3f82019-03-12 11:59:01 -07002618 init_level_info(cpi->level_info);
chiyotsaid16a2572019-03-05 17:48:10 -08002619
Yaowu Xuc27fc142016-08-22 16:08:15 -07002620 cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS;
2621#if CONFIG_INTERNAL_STATS
2622 cpi->b_calculate_blockiness = 1;
2623 cpi->b_calculate_consistency = 1;
2624 cpi->total_inconsistency = 0;
2625 cpi->psnr.worst = 100.0;
2626 cpi->worst_ssim = 100.0;
2627
2628 cpi->count = 0;
2629 cpi->bytes = 0;
Debargha Mukherjee0857e662019-01-04 16:22:09 -08002630#if CONFIG_SPEED_STATS
2631 cpi->tx_search_count = 0;
2632#endif // CONFIG_SPEED_STATS
Yaowu Xuc27fc142016-08-22 16:08:15 -07002633
2634 if (cpi->b_calculate_psnr) {
2635 cpi->total_sq_error = 0;
2636 cpi->total_samples = 0;
2637 cpi->tot_recode_hits = 0;
2638 cpi->summed_quality = 0;
2639 cpi->summed_weights = 0;
2640 }
2641
2642 cpi->fastssim.worst = 100.0;
2643 cpi->psnrhvs.worst = 100.0;
2644
2645 if (cpi->b_calculate_blockiness) {
2646 cpi->total_blockiness = 0;
2647 cpi->worst_blockiness = 0.0;
2648 }
2649
2650 if (cpi->b_calculate_consistency) {
2651 CHECK_MEM_ERROR(cm, cpi->ssim_vars,
Yaowu Xuf883b422016-08-30 14:01:10 -07002652 aom_malloc(sizeof(*cpi->ssim_vars) * 4 *
Yaowu Xuc27fc142016-08-22 16:08:15 -07002653 cpi->common.mi_rows * cpi->common.mi_cols));
2654 cpi->worst_consistency = 100.0;
2655 }
2656#endif
Debargha Mukherjee5802ebe2016-12-21 04:17:24 -08002657#if CONFIG_ENTROPY_STATS
2658 av1_zero(aggregate_fc);
2659#endif // CONFIG_ENTROPY_STATS
Yaowu Xuc27fc142016-08-22 16:08:15 -07002660
2661 cpi->first_time_stamp_ever = INT64_MAX;
2662
Jingning Hanf050fc12018-03-09 14:53:33 -08002663 cpi->td.mb.nmvcost[0] = &cpi->nmv_costs[0][MV_MAX];
2664 cpi->td.mb.nmvcost[1] = &cpi->nmv_costs[1][MV_MAX];
2665 cpi->td.mb.nmvcost_hp[0] = &cpi->nmv_costs_hp[0][MV_MAX];
2666 cpi->td.mb.nmvcost_hp[1] = &cpi->nmv_costs_hp[1][MV_MAX];
James Zern01a9d702017-08-25 19:09:33 +00002667
Yaowu Xuc27fc142016-08-22 16:08:15 -07002668#ifdef OUTPUT_YUV_SKINMAP
2669 yuv_skinmap_file = fopen("skinmap.yuv", "ab");
2670#endif
2671#ifdef OUTPUT_YUV_REC
2672 yuv_rec_file = fopen("rec.yuv", "wb");
2673#endif
2674
Yaowu Xuc27fc142016-08-22 16:08:15 -07002675 if (oxcf->pass == 1) {
Yaowu Xuf883b422016-08-30 14:01:10 -07002676 av1_init_first_pass(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07002677 } else if (oxcf->pass == 2) {
2678 const size_t packet_sz = sizeof(FIRSTPASS_STATS);
2679 const int packets = (int)(oxcf->two_pass_stats_in.sz / packet_sz);
2680
Yaowu Xuc27fc142016-08-22 16:08:15 -07002681 cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf;
2682 cpi->twopass.stats_in = cpi->twopass.stats_in_start;
2683 cpi->twopass.stats_in_end = &cpi->twopass.stats_in[packets - 1];
2684
Yaowu Xuf883b422016-08-30 14:01:10 -07002685 av1_init_second_pass(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07002686 }
2687
Jingning Hand064cf02017-06-01 10:00:39 -07002688 CHECK_MEM_ERROR(
2689 cm, cpi->td.mb.above_pred_buf,
Yue Chen1a799252018-03-01 16:47:41 -08002690 (uint8_t *)aom_memalign(16, MAX_MB_PLANE * MAX_SB_SQUARE *
Johannb0ef6ff2018-02-08 14:32:21 -08002691 sizeof(*cpi->td.mb.above_pred_buf)));
Jingning Hand064cf02017-06-01 10:00:39 -07002692 CHECK_MEM_ERROR(
2693 cm, cpi->td.mb.left_pred_buf,
Yue Chen1a799252018-03-01 16:47:41 -08002694 (uint8_t *)aom_memalign(16, MAX_MB_PLANE * MAX_SB_SQUARE *
Johannb0ef6ff2018-02-08 14:32:21 -08002695 sizeof(*cpi->td.mb.left_pred_buf)));
Jingning Hand064cf02017-06-01 10:00:39 -07002696
2697 CHECK_MEM_ERROR(cm, cpi->td.mb.wsrc_buf,
2698 (int32_t *)aom_memalign(
2699 16, MAX_SB_SQUARE * sizeof(*cpi->td.mb.wsrc_buf)));
2700
Ravi Chaudhary5d970f42018-09-25 11:25:32 +05302701 CHECK_MEM_ERROR(
2702 cm, cpi->td.mb.inter_modes_info,
2703 (InterModesInfo *)aom_malloc(sizeof(*cpi->td.mb.inter_modes_info)));
Ravi Chaudhary5d970f42018-09-25 11:25:32 +05302704
Ravi Chaudhary783d6a32018-08-28 18:21:02 +05302705 for (int x = 0; x < 2; x++)
2706 for (int y = 0; y < 2; y++)
2707 CHECK_MEM_ERROR(
2708 cm, cpi->td.mb.hash_value_buffer[x][y],
2709 (uint32_t *)aom_malloc(AOM_BUFFER_SIZE_FOR_BLOCK_HASH *
2710 sizeof(*cpi->td.mb.hash_value_buffer[0][0])));
2711
2712 cpi->td.mb.g_crc_initialized = 0;
2713
Jingning Hand064cf02017-06-01 10:00:39 -07002714 CHECK_MEM_ERROR(cm, cpi->td.mb.mask_buf,
2715 (int32_t *)aom_memalign(
2716 16, MAX_SB_SQUARE * sizeof(*cpi->td.mb.mask_buf)));
2717
David Turner04b70d82019-01-24 15:39:19 +00002718 av1_set_speed_features_framesize_independent(cpi, oxcf->speed);
2719 av1_set_speed_features_framesize_dependent(cpi, oxcf->speed);
Yaowu Xuc27fc142016-08-22 16:08:15 -07002720
Yue Chen7cae98f2018-08-24 10:43:16 -07002721 for (int frame = 0; frame < MAX_LAG_BUFFERS; ++frame) {
2722 int mi_cols = ALIGN_POWER_OF_TWO(cm->mi_cols, MAX_MIB_SIZE_LOG2);
2723 int mi_rows = ALIGN_POWER_OF_TWO(cm->mi_rows, MAX_MIB_SIZE_LOG2);
2724
2725 CHECK_MEM_ERROR(cm, cpi->tpl_stats[frame].tpl_stats_ptr,
2726 aom_calloc(mi_rows * mi_cols,
2727 sizeof(*cpi->tpl_stats[frame].tpl_stats_ptr)));
2728 cpi->tpl_stats[frame].is_valid = 0;
2729 cpi->tpl_stats[frame].width = mi_cols;
2730 cpi->tpl_stats[frame].height = mi_rows;
2731 cpi->tpl_stats[frame].stride = mi_cols;
2732 cpi->tpl_stats[frame].mi_rows = cm->mi_rows;
2733 cpi->tpl_stats[frame].mi_cols = cm->mi_cols;
2734 }
2735
chiyotsai9c484b32019-03-07 16:01:50 -08002736#if CONFIG_COLLECT_PARTITION_STATS == 2
chiyotsai92ed0dd2019-01-25 14:50:14 -08002737 av1_zero(cpi->partition_stats);
2738#endif
2739
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002740#define BFP(BT, SDF, SDAF, VF, SVF, SVAF, SDX4DF, JSDAF, JSVAF) \
2741 cpi->fn_ptr[BT].sdf = SDF; \
2742 cpi->fn_ptr[BT].sdaf = SDAF; \
2743 cpi->fn_ptr[BT].vf = VF; \
2744 cpi->fn_ptr[BT].svf = SVF; \
2745 cpi->fn_ptr[BT].svaf = SVAF; \
2746 cpi->fn_ptr[BT].sdx4df = SDX4DF; \
2747 cpi->fn_ptr[BT].jsdaf = JSDAF; \
Cheng Chenf78632e2017-10-20 15:30:51 -07002748 cpi->fn_ptr[BT].jsvaf = JSVAF;
Yaowu Xuc27fc142016-08-22 16:08:15 -07002749
Cheng Chenf78632e2017-10-20 15:30:51 -07002750 BFP(BLOCK_4X16, aom_sad4x16, aom_sad4x16_avg, aom_variance4x16,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002751 aom_sub_pixel_variance4x16, aom_sub_pixel_avg_variance4x16,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002752 aom_sad4x16x4d, aom_dist_wtd_sad4x16_avg,
2753 aom_dist_wtd_sub_pixel_avg_variance4x16)
Cheng Chenf78632e2017-10-20 15:30:51 -07002754
2755 BFP(BLOCK_16X4, aom_sad16x4, aom_sad16x4_avg, aom_variance16x4,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002756 aom_sub_pixel_variance16x4, aom_sub_pixel_avg_variance16x4,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002757 aom_sad16x4x4d, aom_dist_wtd_sad16x4_avg,
2758 aom_dist_wtd_sub_pixel_avg_variance16x4)
Cheng Chenf78632e2017-10-20 15:30:51 -07002759
2760 BFP(BLOCK_8X32, aom_sad8x32, aom_sad8x32_avg, aom_variance8x32,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002761 aom_sub_pixel_variance8x32, aom_sub_pixel_avg_variance8x32,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002762 aom_sad8x32x4d, aom_dist_wtd_sad8x32_avg,
2763 aom_dist_wtd_sub_pixel_avg_variance8x32)
Cheng Chenf78632e2017-10-20 15:30:51 -07002764
2765 BFP(BLOCK_32X8, aom_sad32x8, aom_sad32x8_avg, aom_variance32x8,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002766 aom_sub_pixel_variance32x8, aom_sub_pixel_avg_variance32x8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002767 aom_sad32x8x4d, aom_dist_wtd_sad32x8_avg,
2768 aom_dist_wtd_sub_pixel_avg_variance32x8)
Cheng Chenf78632e2017-10-20 15:30:51 -07002769
2770 BFP(BLOCK_16X64, aom_sad16x64, aom_sad16x64_avg, aom_variance16x64,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002771 aom_sub_pixel_variance16x64, aom_sub_pixel_avg_variance16x64,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002772 aom_sad16x64x4d, aom_dist_wtd_sad16x64_avg,
2773 aom_dist_wtd_sub_pixel_avg_variance16x64)
Cheng Chenf78632e2017-10-20 15:30:51 -07002774
2775 BFP(BLOCK_64X16, aom_sad64x16, aom_sad64x16_avg, aom_variance64x16,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002776 aom_sub_pixel_variance64x16, aom_sub_pixel_avg_variance64x16,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002777 aom_sad64x16x4d, aom_dist_wtd_sad64x16_avg,
2778 aom_dist_wtd_sub_pixel_avg_variance64x16)
Cheng Chenf78632e2017-10-20 15:30:51 -07002779
Cheng Chenf78632e2017-10-20 15:30:51 -07002780 BFP(BLOCK_128X128, aom_sad128x128, aom_sad128x128_avg, aom_variance128x128,
2781 aom_sub_pixel_variance128x128, aom_sub_pixel_avg_variance128x128,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002782 aom_sad128x128x4d, aom_dist_wtd_sad128x128_avg,
2783 aom_dist_wtd_sub_pixel_avg_variance128x128)
Cheng Chenf78632e2017-10-20 15:30:51 -07002784
2785 BFP(BLOCK_128X64, aom_sad128x64, aom_sad128x64_avg, aom_variance128x64,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002786 aom_sub_pixel_variance128x64, aom_sub_pixel_avg_variance128x64,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002787 aom_sad128x64x4d, aom_dist_wtd_sad128x64_avg,
2788 aom_dist_wtd_sub_pixel_avg_variance128x64)
Cheng Chenf78632e2017-10-20 15:30:51 -07002789
2790 BFP(BLOCK_64X128, aom_sad64x128, aom_sad64x128_avg, aom_variance64x128,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002791 aom_sub_pixel_variance64x128, aom_sub_pixel_avg_variance64x128,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002792 aom_sad64x128x4d, aom_dist_wtd_sad64x128_avg,
2793 aom_dist_wtd_sub_pixel_avg_variance64x128)
Cheng Chenf78632e2017-10-20 15:30:51 -07002794
2795 BFP(BLOCK_32X16, aom_sad32x16, aom_sad32x16_avg, aom_variance32x16,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002796 aom_sub_pixel_variance32x16, aom_sub_pixel_avg_variance32x16,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002797 aom_sad32x16x4d, aom_dist_wtd_sad32x16_avg,
2798 aom_dist_wtd_sub_pixel_avg_variance32x16)
Cheng Chenf78632e2017-10-20 15:30:51 -07002799
2800 BFP(BLOCK_16X32, aom_sad16x32, aom_sad16x32_avg, aom_variance16x32,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002801 aom_sub_pixel_variance16x32, aom_sub_pixel_avg_variance16x32,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002802 aom_sad16x32x4d, aom_dist_wtd_sad16x32_avg,
2803 aom_dist_wtd_sub_pixel_avg_variance16x32)
Cheng Chenf78632e2017-10-20 15:30:51 -07002804
2805 BFP(BLOCK_64X32, aom_sad64x32, aom_sad64x32_avg, aom_variance64x32,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002806 aom_sub_pixel_variance64x32, aom_sub_pixel_avg_variance64x32,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002807 aom_sad64x32x4d, aom_dist_wtd_sad64x32_avg,
2808 aom_dist_wtd_sub_pixel_avg_variance64x32)
Cheng Chenf78632e2017-10-20 15:30:51 -07002809
2810 BFP(BLOCK_32X64, aom_sad32x64, aom_sad32x64_avg, aom_variance32x64,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002811 aom_sub_pixel_variance32x64, aom_sub_pixel_avg_variance32x64,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002812 aom_sad32x64x4d, aom_dist_wtd_sad32x64_avg,
2813 aom_dist_wtd_sub_pixel_avg_variance32x64)
Cheng Chenf78632e2017-10-20 15:30:51 -07002814
2815 BFP(BLOCK_32X32, aom_sad32x32, aom_sad32x32_avg, aom_variance32x32,
2816 aom_sub_pixel_variance32x32, aom_sub_pixel_avg_variance32x32,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002817 aom_sad32x32x4d, aom_dist_wtd_sad32x32_avg,
2818 aom_dist_wtd_sub_pixel_avg_variance32x32)
Cheng Chenf78632e2017-10-20 15:30:51 -07002819
2820 BFP(BLOCK_64X64, aom_sad64x64, aom_sad64x64_avg, aom_variance64x64,
2821 aom_sub_pixel_variance64x64, aom_sub_pixel_avg_variance64x64,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002822 aom_sad64x64x4d, aom_dist_wtd_sad64x64_avg,
2823 aom_dist_wtd_sub_pixel_avg_variance64x64)
Cheng Chenf78632e2017-10-20 15:30:51 -07002824
2825 BFP(BLOCK_16X16, aom_sad16x16, aom_sad16x16_avg, aom_variance16x16,
2826 aom_sub_pixel_variance16x16, aom_sub_pixel_avg_variance16x16,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002827 aom_sad16x16x4d, aom_dist_wtd_sad16x16_avg,
2828 aom_dist_wtd_sub_pixel_avg_variance16x16)
Cheng Chenf78632e2017-10-20 15:30:51 -07002829
2830 BFP(BLOCK_16X8, aom_sad16x8, aom_sad16x8_avg, aom_variance16x8,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002831 aom_sub_pixel_variance16x8, aom_sub_pixel_avg_variance16x8,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002832 aom_sad16x8x4d, aom_dist_wtd_sad16x8_avg,
2833 aom_dist_wtd_sub_pixel_avg_variance16x8)
Cheng Chenf78632e2017-10-20 15:30:51 -07002834
2835 BFP(BLOCK_8X16, aom_sad8x16, aom_sad8x16_avg, aom_variance8x16,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002836 aom_sub_pixel_variance8x16, aom_sub_pixel_avg_variance8x16,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002837 aom_sad8x16x4d, aom_dist_wtd_sad8x16_avg,
2838 aom_dist_wtd_sub_pixel_avg_variance8x16)
Cheng Chenf78632e2017-10-20 15:30:51 -07002839
2840 BFP(BLOCK_8X8, aom_sad8x8, aom_sad8x8_avg, aom_variance8x8,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002841 aom_sub_pixel_variance8x8, aom_sub_pixel_avg_variance8x8, aom_sad8x8x4d,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002842 aom_dist_wtd_sad8x8_avg, aom_dist_wtd_sub_pixel_avg_variance8x8)
Cheng Chenf78632e2017-10-20 15:30:51 -07002843
2844 BFP(BLOCK_8X4, aom_sad8x4, aom_sad8x4_avg, aom_variance8x4,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002845 aom_sub_pixel_variance8x4, aom_sub_pixel_avg_variance8x4, aom_sad8x4x4d,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002846 aom_dist_wtd_sad8x4_avg, aom_dist_wtd_sub_pixel_avg_variance8x4)
Cheng Chenf78632e2017-10-20 15:30:51 -07002847
2848 BFP(BLOCK_4X8, aom_sad4x8, aom_sad4x8_avg, aom_variance4x8,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002849 aom_sub_pixel_variance4x8, aom_sub_pixel_avg_variance4x8, aom_sad4x8x4d,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002850 aom_dist_wtd_sad4x8_avg, aom_dist_wtd_sub_pixel_avg_variance4x8)
Cheng Chenf78632e2017-10-20 15:30:51 -07002851
2852 BFP(BLOCK_4X4, aom_sad4x4, aom_sad4x4_avg, aom_variance4x4,
Kyle Siefringef6e2df2018-04-10 14:51:35 -04002853 aom_sub_pixel_variance4x4, aom_sub_pixel_avg_variance4x4, aom_sad4x4x4d,
Debargha Mukherjee0c96c112018-12-20 16:04:18 -08002854 aom_dist_wtd_sad4x4_avg, aom_dist_wtd_sub_pixel_avg_variance4x4)
Cheng Chenf78632e2017-10-20 15:30:51 -07002855
Yaowu Xuc27fc142016-08-22 16:08:15 -07002856#define OBFP(BT, OSDF, OVF, OSVF) \
2857 cpi->fn_ptr[BT].osdf = OSDF; \
2858 cpi->fn_ptr[BT].ovf = OVF; \
2859 cpi->fn_ptr[BT].osvf = OSVF;
2860
Yaowu Xuf883b422016-08-30 14:01:10 -07002861 OBFP(BLOCK_128X128, aom_obmc_sad128x128, aom_obmc_variance128x128,
2862 aom_obmc_sub_pixel_variance128x128)
2863 OBFP(BLOCK_128X64, aom_obmc_sad128x64, aom_obmc_variance128x64,
2864 aom_obmc_sub_pixel_variance128x64)
2865 OBFP(BLOCK_64X128, aom_obmc_sad64x128, aom_obmc_variance64x128,
2866 aom_obmc_sub_pixel_variance64x128)
Yaowu Xuf883b422016-08-30 14:01:10 -07002867 OBFP(BLOCK_64X64, aom_obmc_sad64x64, aom_obmc_variance64x64,
2868 aom_obmc_sub_pixel_variance64x64)
2869 OBFP(BLOCK_64X32, aom_obmc_sad64x32, aom_obmc_variance64x32,
2870 aom_obmc_sub_pixel_variance64x32)
2871 OBFP(BLOCK_32X64, aom_obmc_sad32x64, aom_obmc_variance32x64,
2872 aom_obmc_sub_pixel_variance32x64)
2873 OBFP(BLOCK_32X32, aom_obmc_sad32x32, aom_obmc_variance32x32,
2874 aom_obmc_sub_pixel_variance32x32)
2875 OBFP(BLOCK_32X16, aom_obmc_sad32x16, aom_obmc_variance32x16,
2876 aom_obmc_sub_pixel_variance32x16)
2877 OBFP(BLOCK_16X32, aom_obmc_sad16x32, aom_obmc_variance16x32,
2878 aom_obmc_sub_pixel_variance16x32)
2879 OBFP(BLOCK_16X16, aom_obmc_sad16x16, aom_obmc_variance16x16,
2880 aom_obmc_sub_pixel_variance16x16)
2881 OBFP(BLOCK_16X8, aom_obmc_sad16x8, aom_obmc_variance16x8,
2882 aom_obmc_sub_pixel_variance16x8)
2883 OBFP(BLOCK_8X16, aom_obmc_sad8x16, aom_obmc_variance8x16,
2884 aom_obmc_sub_pixel_variance8x16)
2885 OBFP(BLOCK_8X8, aom_obmc_sad8x8, aom_obmc_variance8x8,
2886 aom_obmc_sub_pixel_variance8x8)
2887 OBFP(BLOCK_4X8, aom_obmc_sad4x8, aom_obmc_variance4x8,
2888 aom_obmc_sub_pixel_variance4x8)
2889 OBFP(BLOCK_8X4, aom_obmc_sad8x4, aom_obmc_variance8x4,
2890 aom_obmc_sub_pixel_variance8x4)
2891 OBFP(BLOCK_4X4, aom_obmc_sad4x4, aom_obmc_variance4x4,
2892 aom_obmc_sub_pixel_variance4x4)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01002893 OBFP(BLOCK_4X16, aom_obmc_sad4x16, aom_obmc_variance4x16,
2894 aom_obmc_sub_pixel_variance4x16)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01002895 OBFP(BLOCK_16X4, aom_obmc_sad16x4, aom_obmc_variance16x4,
2896 aom_obmc_sub_pixel_variance16x4)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01002897 OBFP(BLOCK_8X32, aom_obmc_sad8x32, aom_obmc_variance8x32,
2898 aom_obmc_sub_pixel_variance8x32)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01002899 OBFP(BLOCK_32X8, aom_obmc_sad32x8, aom_obmc_variance32x8,
2900 aom_obmc_sub_pixel_variance32x8)
Rupert Swarbrick72678572017-08-02 12:05:26 +01002901 OBFP(BLOCK_16X64, aom_obmc_sad16x64, aom_obmc_variance16x64,
2902 aom_obmc_sub_pixel_variance16x64)
Rupert Swarbrick72678572017-08-02 12:05:26 +01002903 OBFP(BLOCK_64X16, aom_obmc_sad64x16, aom_obmc_variance64x16,
2904 aom_obmc_sub_pixel_variance64x16)
Yaowu Xuc27fc142016-08-22 16:08:15 -07002905
David Barkerf19f35f2017-05-22 16:33:22 +01002906#define MBFP(BT, MCSDF, MCSVF) \
2907 cpi->fn_ptr[BT].msdf = MCSDF; \
2908 cpi->fn_ptr[BT].msvf = MCSVF;
Yaowu Xuc27fc142016-08-22 16:08:15 -07002909
David Barkerf19f35f2017-05-22 16:33:22 +01002910 MBFP(BLOCK_128X128, aom_masked_sad128x128,
2911 aom_masked_sub_pixel_variance128x128)
2912 MBFP(BLOCK_128X64, aom_masked_sad128x64, aom_masked_sub_pixel_variance128x64)
2913 MBFP(BLOCK_64X128, aom_masked_sad64x128, aom_masked_sub_pixel_variance64x128)
David Barkerf19f35f2017-05-22 16:33:22 +01002914 MBFP(BLOCK_64X64, aom_masked_sad64x64, aom_masked_sub_pixel_variance64x64)
2915 MBFP(BLOCK_64X32, aom_masked_sad64x32, aom_masked_sub_pixel_variance64x32)
2916 MBFP(BLOCK_32X64, aom_masked_sad32x64, aom_masked_sub_pixel_variance32x64)
2917 MBFP(BLOCK_32X32, aom_masked_sad32x32, aom_masked_sub_pixel_variance32x32)
2918 MBFP(BLOCK_32X16, aom_masked_sad32x16, aom_masked_sub_pixel_variance32x16)
2919 MBFP(BLOCK_16X32, aom_masked_sad16x32, aom_masked_sub_pixel_variance16x32)
2920 MBFP(BLOCK_16X16, aom_masked_sad16x16, aom_masked_sub_pixel_variance16x16)
2921 MBFP(BLOCK_16X8, aom_masked_sad16x8, aom_masked_sub_pixel_variance16x8)
2922 MBFP(BLOCK_8X16, aom_masked_sad8x16, aom_masked_sub_pixel_variance8x16)
2923 MBFP(BLOCK_8X8, aom_masked_sad8x8, aom_masked_sub_pixel_variance8x8)
2924 MBFP(BLOCK_4X8, aom_masked_sad4x8, aom_masked_sub_pixel_variance4x8)
2925 MBFP(BLOCK_8X4, aom_masked_sad8x4, aom_masked_sub_pixel_variance8x4)
2926 MBFP(BLOCK_4X4, aom_masked_sad4x4, aom_masked_sub_pixel_variance4x4)
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01002927
Rupert Swarbrick93c39e92017-07-12 11:11:02 +01002928 MBFP(BLOCK_4X16, aom_masked_sad4x16, aom_masked_sub_pixel_variance4x16)
2929
2930 MBFP(BLOCK_16X4, aom_masked_sad16x4, aom_masked_sub_pixel_variance16x4)
2931
2932 MBFP(BLOCK_8X32, aom_masked_sad8x32, aom_masked_sub_pixel_variance8x32)
2933
2934 MBFP(BLOCK_32X8, aom_masked_sad32x8, aom_masked_sub_pixel_variance32x8)
Rupert Swarbrick72678572017-08-02 12:05:26 +01002935
2936 MBFP(BLOCK_16X64, aom_masked_sad16x64, aom_masked_sub_pixel_variance16x64)
2937
2938 MBFP(BLOCK_64X16, aom_masked_sad64x16, aom_masked_sub_pixel_variance64x16)
Rupert Swarbrick2fa6e1c2017-09-11 12:38:10 +01002939
Yaowu Xuc27fc142016-08-22 16:08:15 -07002940 highbd_set_var_fns(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07002941
Yaowu Xuf883b422016-08-30 14:01:10 -07002942 /* av1_init_quantizer() is first called here. Add check in
2943 * av1_frame_init_quantizer() so that av1_init_quantizer is only
Yaowu Xuc27fc142016-08-22 16:08:15 -07002944 * called later when needed. This will avoid unnecessary calls of
Yaowu Xuf883b422016-08-30 14:01:10 -07002945 * av1_init_quantizer() for every frame.
Yaowu Xuc27fc142016-08-22 16:08:15 -07002946 */
Yaowu Xuf883b422016-08-30 14:01:10 -07002947 av1_init_quantizer(cpi);
Zoe Liud902b742018-02-19 17:02:41 -08002948 av1_qm_init(cm);
Yaowu Xuc27fc142016-08-22 16:08:15 -07002949
Yaowu Xuf883b422016-08-30 14:01:10 -07002950 av1_loop_filter_init(cm);
Urvang Joshide71d142017-10-05 12:12:15 -07002951 cm->superres_scale_denominator = SCALE_NUMERATOR;
Debargha Mukherjee29e40a62017-06-14 09:37:12 -07002952 cm->superres_upscaled_width = oxcf->width;
2953 cm->superres_upscaled_height = oxcf->height;
Yaowu Xuf883b422016-08-30 14:01:10 -07002954 av1_loop_restoration_precal();
Yaowu Xuc27fc142016-08-22 16:08:15 -07002955
2956 cm->error.setjmp = 0;
2957
2958 return cpi;
2959}
2960
Urvang Joshiee2c8112018-05-04 14:53:15 -07002961#if CONFIG_INTERNAL_STATS
Yaowu Xuc27fc142016-08-22 16:08:15 -07002962#define SNPRINT(H, T) snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T))
2963
2964#define SNPRINT2(H, T, V) \
2965 snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T), (V))
Urvang Joshiee2c8112018-05-04 14:53:15 -07002966#endif // CONFIG_INTERNAL_STATS
Yaowu Xuc27fc142016-08-22 16:08:15 -07002967
Yaowu Xuf883b422016-08-30 14:01:10 -07002968void av1_remove_compressor(AV1_COMP *cpi) {
2969 AV1_COMMON *cm;
Yaowu Xuc27fc142016-08-22 16:08:15 -07002970 unsigned int i;
2971 int t;
2972
2973 if (!cpi) return;
2974
2975 cm = &cpi->common;
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +00002976 const int num_planes = av1_num_planes(cm);
2977
David Turnerd2a592e2018-11-16 14:59:31 +00002978 if (cm->current_frame.frame_number > 0) {
Debargha Mukherjee5802ebe2016-12-21 04:17:24 -08002979#if CONFIG_ENTROPY_STATS
2980 if (cpi->oxcf.pass != 1) {
2981 fprintf(stderr, "Writing counts.stt\n");
2982 FILE *f = fopen("counts.stt", "wb");
2983 fwrite(&aggregate_fc, sizeof(aggregate_fc), 1, f);
2984 fclose(f);
2985 }
2986#endif // CONFIG_ENTROPY_STATS
Yaowu Xuc27fc142016-08-22 16:08:15 -07002987#if CONFIG_INTERNAL_STATS
Yaowu Xuf883b422016-08-30 14:01:10 -07002988 aom_clear_system_state();
Yaowu Xuc27fc142016-08-22 16:08:15 -07002989
2990 if (cpi->oxcf.pass != 1) {
2991 char headings[512] = { 0 };
2992 char results[512] = { 0 };
2993 FILE *f = fopen("opsnr.stt", "a");
2994 double time_encoded =
2995 (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) /
2996 10000000.000;
2997 double total_encode_time =
2998 (cpi->time_receive_data + cpi->time_compress_data) / 1000.000;
2999 const double dr =
3000 (double)cpi->bytes * (double)8 / (double)1000 / time_encoded;
3001 const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1);
3002 const double target_rate = (double)cpi->oxcf.target_bandwidth / 1000;
3003 const double rate_err = ((100.0 * (dr - target_rate)) / target_rate);
3004
3005 if (cpi->b_calculate_psnr) {
Yaowu Xuf883b422016-08-30 14:01:10 -07003006 const double total_psnr = aom_sse_to_psnr(
Yaowu Xuc27fc142016-08-22 16:08:15 -07003007 (double)cpi->total_samples, peak, (double)cpi->total_sq_error);
3008 const double total_ssim =
3009 100 * pow(cpi->summed_quality / cpi->summed_weights, 8.0);
3010 snprintf(headings, sizeof(headings),
Jingning Han87651b22017-11-28 20:02:26 -08003011 "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\t"
Yaowu Xuf883b422016-08-30 14:01:10 -07003012 "AOMSSIM\tVPSSIMP\tFASTSIM\tPSNRHVS\t"
Jingning Hanbe1ae3f2017-11-27 10:27:56 -08003013 "WstPsnr\tWstSsim\tWstFast\tWstHVS\t"
Jingning Han87651b22017-11-28 20:02:26 -08003014 "AVPsrnY\tAPsnrCb\tAPsnrCr");
Yaowu Xuc27fc142016-08-22 16:08:15 -07003015 snprintf(results, sizeof(results),
3016 "%7.2f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
3017 "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
Jingning Hanbe1ae3f2017-11-27 10:27:56 -08003018 "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
Jingning Han87651b22017-11-28 20:02:26 -08003019 "%7.3f\t%7.3f\t%7.3f",
Wan-Teh Changc25c92a2018-04-23 15:04:14 -07003020 dr, cpi->psnr.stat[STAT_ALL] / cpi->count, total_psnr,
3021 cpi->psnr.stat[STAT_ALL] / cpi->count, total_psnr, total_ssim,
3022 total_ssim, cpi->fastssim.stat[STAT_ALL] / cpi->count,
3023 cpi->psnrhvs.stat[STAT_ALL] / cpi->count, cpi->psnr.worst,
Jingning Hanbe1ae3f2017-11-27 10:27:56 -08003024 cpi->worst_ssim, cpi->fastssim.worst, cpi->psnrhvs.worst,
Wan-Teh Changc25c92a2018-04-23 15:04:14 -07003025 cpi->psnr.stat[STAT_Y] / cpi->count,
3026 cpi->psnr.stat[STAT_U] / cpi->count,
3027 cpi->psnr.stat[STAT_V] / cpi->count);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003028
3029 if (cpi->b_calculate_blockiness) {
3030 SNPRINT(headings, "\t Block\tWstBlck");
3031 SNPRINT2(results, "\t%7.3f", cpi->total_blockiness / cpi->count);
3032 SNPRINT2(results, "\t%7.3f", cpi->worst_blockiness);
3033 }
3034
3035 if (cpi->b_calculate_consistency) {
3036 double consistency =
Yaowu Xuf883b422016-08-30 14:01:10 -07003037 aom_sse_to_psnr((double)cpi->total_samples, peak,
Yaowu Xuc27fc142016-08-22 16:08:15 -07003038 (double)cpi->total_inconsistency);
3039
3040 SNPRINT(headings, "\tConsist\tWstCons");
3041 SNPRINT2(results, "\t%7.3f", consistency);
3042 SNPRINT2(results, "\t%7.3f", cpi->worst_consistency);
3043 }
Sarah Parkerf97b7862016-08-25 17:42:57 -07003044 fprintf(f, "%s\t Time\tRcErr\tAbsErr\n", headings);
3045 fprintf(f, "%s\t%8.0f\t%7.2f\t%7.2f\n", results, total_encode_time,
Yaowu Xuc27fc142016-08-22 16:08:15 -07003046 rate_err, fabs(rate_err));
3047 }
3048
3049 fclose(f);
3050 }
Urvang Joshiee2c8112018-05-04 14:53:15 -07003051#endif // CONFIG_INTERNAL_STATS
Debargha Mukherjee0857e662019-01-04 16:22:09 -08003052#if CONFIG_SPEED_STATS
3053 if (cpi->oxcf.pass != 1) {
3054 fprintf(stdout, "tx_search_count = %d\n", cpi->tx_search_count);
3055 }
3056#endif // CONFIG_SPEED_STATS
chiyotsai92ed0dd2019-01-25 14:50:14 -08003057
chiyotsai9c484b32019-03-07 16:01:50 -08003058#if CONFIG_COLLECT_PARTITION_STATS == 2
chiyotsai92ed0dd2019-01-25 14:50:14 -08003059 if (cpi->oxcf.pass != 1) {
3060 av1_print_partition_stats(&cpi->partition_stats);
3061 }
3062#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -07003063 }
3064
Yue Chen7cae98f2018-08-24 10:43:16 -07003065 for (int frame = 0; frame < MAX_LAG_BUFFERS; ++frame) {
3066 aom_free(cpi->tpl_stats[frame].tpl_stats_ptr);
3067 cpi->tpl_stats[frame].is_valid = 0;
3068 }
3069
Ravi Chaudhary1f58dd82018-12-07 17:24:15 +05303070 for (t = cpi->num_workers - 1; t >= 0; --t) {
Yaowu Xuf883b422016-08-30 14:01:10 -07003071 AVxWorker *const worker = &cpi->workers[t];
Yaowu Xuc27fc142016-08-22 16:08:15 -07003072 EncWorkerData *const thread_data = &cpi->tile_thr_data[t];
3073
3074 // Deallocate allocated threads.
Yaowu Xuf883b422016-08-30 14:01:10 -07003075 aom_get_worker_interface()->end(worker);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003076
3077 // Deallocate allocated thread data.
Ravi Chaudhary1cf7d162018-10-09 17:00:43 +05303078 if (cpi->row_mt == 1) aom_free(thread_data->td->tctx);
Ravi Chaudhary1f58dd82018-12-07 17:24:15 +05303079 if (t > 0) {
hui sud9a812b2017-07-06 14:34:37 -07003080 aom_free(thread_data->td->palette_buffer);
Urvang Joshi0a4cfad2018-09-07 11:10:39 -07003081 aom_free(thread_data->td->tmp_conv_dst);
3082 for (int j = 0; j < 2; ++j) {
3083 aom_free(thread_data->td->tmp_obmc_bufs[j]);
3084 }
Jingning Hand064cf02017-06-01 10:00:39 -07003085 aom_free(thread_data->td->above_pred_buf);
3086 aom_free(thread_data->td->left_pred_buf);
3087 aom_free(thread_data->td->wsrc_buf);
wenyao.liu22d8ab32018-10-16 09:11:29 +08003088
Ravi Chaudhary5d970f42018-09-25 11:25:32 +05303089 aom_free(thread_data->td->inter_modes_info);
Urvang Joshi0a4cfad2018-09-07 11:10:39 -07003090 for (int x = 0; x < 2; x++) {
Ravi Chaudhary783d6a32018-08-28 18:21:02 +05303091 for (int y = 0; y < 2; y++) {
3092 aom_free(thread_data->td->hash_value_buffer[x][y]);
3093 thread_data->td->hash_value_buffer[x][y] = NULL;
3094 }
Urvang Joshi0a4cfad2018-09-07 11:10:39 -07003095 }
Jingning Hand064cf02017-06-01 10:00:39 -07003096 aom_free(thread_data->td->mask_buf);
Yaowu Xuf883b422016-08-30 14:01:10 -07003097 aom_free(thread_data->td->counts);
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +00003098 av1_free_pc_tree(thread_data->td, num_planes);
Yaowu Xuf883b422016-08-30 14:01:10 -07003099 aom_free(thread_data->td);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003100 }
3101 }
Ravi Chaudhary90a15f42018-10-11 18:56:35 +05303102#if CONFIG_MULTITHREAD
3103 if (cpi->row_mt == 1) {
3104 if (cpi->row_mt_mutex_ != NULL) {
3105 pthread_mutex_destroy(cpi->row_mt_mutex_);
3106 aom_free(cpi->row_mt_mutex_);
3107 }
3108 }
3109#endif
Ravi Chaudharyc5e74692018-10-08 16:05:38 +05303110 av1_row_mt_mem_dealloc(cpi);
Yaowu Xuf883b422016-08-30 14:01:10 -07003111 aom_free(cpi->tile_thr_data);
3112 aom_free(cpi->workers);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003113
Deepa K G964e72e2018-05-16 16:56:01 +05303114 if (cpi->num_workers > 1) {
3115 av1_loop_filter_dealloc(&cpi->lf_row_sync);
Ravi Chaudharye2aa4012018-06-04 14:20:00 +05303116 av1_loop_restoration_dealloc(&cpi->lr_row_sync, cpi->num_workers);
Deepa K G964e72e2018-05-16 16:56:01 +05303117 }
3118
Yaowu Xuc27fc142016-08-22 16:08:15 -07003119 dealloc_compressor_data(cpi);
3120
3121 for (i = 0; i < sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]);
3122 ++i) {
Yaowu Xuf883b422016-08-30 14:01:10 -07003123 aom_free(cpi->mbgraph_stats[i].mb_stats);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003124 }
3125
Debargha Mukherjee5d157212017-01-10 14:44:47 -08003126#if CONFIG_INTERNAL_STATS
3127 aom_free(cpi->ssim_vars);
3128 cpi->ssim_vars = NULL;
3129#endif // CONFIG_INTERNAL_STATS
Yaowu Xuc27fc142016-08-22 16:08:15 -07003130
Yaowu Xuf883b422016-08-30 14:01:10 -07003131 av1_remove_common(cm);
RogerZhou80d52342017-11-20 10:56:26 -08003132 for (i = 0; i < FRAME_BUFFERS; ++i) {
3133 av1_hash_table_destroy(&cm->buffer_pool->frame_bufs[i].hash_table);
3134 }
Michelle Findlay-Olynykdea531d2017-12-13 14:10:56 -08003135 if (cpi->sf.use_hash_based_trellis) hbt_destroy();
Yaowu Xuf883b422016-08-30 14:01:10 -07003136 av1_free_ref_frame_buffers(cm->buffer_pool);
3137 aom_free(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003138
3139#ifdef OUTPUT_YUV_SKINMAP
3140 fclose(yuv_skinmap_file);
3141#endif
3142#ifdef OUTPUT_YUV_REC
3143 fclose(yuv_rec_file);
3144#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -07003145}
3146
Yaowu Xuf883b422016-08-30 14:01:10 -07003147static void generate_psnr_packet(AV1_COMP *cpi) {
3148 struct aom_codec_cx_pkt pkt;
Yaowu Xuc27fc142016-08-22 16:08:15 -07003149 int i;
3150 PSNR_STATS psnr;
David Turnerc29e1a92018-12-06 14:10:14 +00003151 aom_calc_highbd_psnr(cpi->source, &cpi->common.cur_frame->buf, &psnr,
Yaowu Xuc27fc142016-08-22 16:08:15 -07003152 cpi->td.mb.e_mbd.bd, cpi->oxcf.input_bit_depth);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003153
3154 for (i = 0; i < 4; ++i) {
3155 pkt.data.psnr.samples[i] = psnr.samples[i];
3156 pkt.data.psnr.sse[i] = psnr.sse[i];
3157 pkt.data.psnr.psnr[i] = psnr.psnr[i];
3158 }
Yaowu Xuf883b422016-08-30 14:01:10 -07003159 pkt.kind = AOM_CODEC_PSNR_PKT;
3160 aom_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003161}
3162
Yaowu Xuf883b422016-08-30 14:01:10 -07003163int av1_use_as_reference(AV1_COMP *cpi, int ref_frame_flags) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07003164 if (ref_frame_flags > ((1 << INTER_REFS_PER_FRAME) - 1)) return -1;
3165
Yunqing Wangf2e7a392017-11-08 00:27:21 -08003166 cpi->ext_ref_frame_flags = ref_frame_flags;
Yaowu Xuc27fc142016-08-22 16:08:15 -07003167 return 0;
3168}
3169
Thomas Daede497d1952017-08-08 17:33:06 -07003170int av1_copy_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd) {
3171 AV1_COMMON *const cm = &cpi->common;
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +00003172 const int num_planes = av1_num_planes(cm);
Thomas Daede497d1952017-08-08 17:33:06 -07003173 YV12_BUFFER_CONFIG *cfg = get_ref_frame(cm, idx);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003174 if (cfg) {
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +00003175 aom_yv12_copy_frame(cfg, sd, num_planes);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003176 return 0;
3177 } else {
3178 return -1;
3179 }
3180}
3181
Thomas Daede497d1952017-08-08 17:33:06 -07003182int av1_set_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd) {
3183 AV1_COMMON *const cm = &cpi->common;
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +00003184 const int num_planes = av1_num_planes(cm);
Thomas Daede497d1952017-08-08 17:33:06 -07003185 YV12_BUFFER_CONFIG *cfg = get_ref_frame(cm, idx);
Yaowu Xuf883b422016-08-30 14:01:10 -07003186 if (cfg) {
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +00003187 aom_yv12_copy_frame(sd, cfg, num_planes);
Yaowu Xuf883b422016-08-30 14:01:10 -07003188 return 0;
3189 } else {
3190 return -1;
3191 }
3192}
3193
3194int av1_update_entropy(AV1_COMP *cpi, int update) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07003195 cpi->ext_refresh_frame_context = update;
3196 cpi->ext_refresh_frame_context_pending = 1;
3197 return 0;
3198}
3199
3200#if defined(OUTPUT_YUV_DENOISED) || defined(OUTPUT_YUV_SKINMAP)
3201// The denoiser buffer is allocated as a YUV 440 buffer. This function writes it
3202// as YUV 420. We simply use the top-left pixels of the UV buffers, since we do
3203// not denoise the UV channels at this time. If ever we implement UV channel
3204// denoising we will have to modify this.
Yaowu Xuf883b422016-08-30 14:01:10 -07003205void aom_write_yuv_frame_420(YV12_BUFFER_CONFIG *s, FILE *f) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07003206 uint8_t *src = s->y_buffer;
3207 int h = s->y_height;
3208
3209 do {
3210 fwrite(src, s->y_width, 1, f);
3211 src += s->y_stride;
3212 } while (--h);
3213
3214 src = s->u_buffer;
3215 h = s->uv_height;
3216
3217 do {
3218 fwrite(src, s->uv_width, 1, f);
3219 src += s->uv_stride;
3220 } while (--h);
3221
3222 src = s->v_buffer;
3223 h = s->uv_height;
3224
3225 do {
3226 fwrite(src, s->uv_width, 1, f);
3227 src += s->uv_stride;
3228 } while (--h);
3229}
3230#endif
3231
Yaowu Xuc27fc142016-08-22 16:08:15 -07003232#ifdef OUTPUT_YUV_REC
Yaowu Xuf883b422016-08-30 14:01:10 -07003233void aom_write_one_yuv_frame(AV1_COMMON *cm, YV12_BUFFER_CONFIG *s) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07003234 uint8_t *src = s->y_buffer;
3235 int h = cm->height;
Wei-Ting Lin01d4d8f2017-08-03 17:04:12 -07003236 if (yuv_rec_file == NULL) return;
Yaowu Xuc27fc142016-08-22 16:08:15 -07003237 if (s->flags & YV12_FLAG_HIGHBITDEPTH) {
3238 uint16_t *src16 = CONVERT_TO_SHORTPTR(s->y_buffer);
3239
3240 do {
3241 fwrite(src16, s->y_width, 2, yuv_rec_file);
3242 src16 += s->y_stride;
3243 } while (--h);
3244
3245 src16 = CONVERT_TO_SHORTPTR(s->u_buffer);
3246 h = s->uv_height;
3247
3248 do {
3249 fwrite(src16, s->uv_width, 2, yuv_rec_file);
3250 src16 += s->uv_stride;
3251 } while (--h);
3252
3253 src16 = CONVERT_TO_SHORTPTR(s->v_buffer);
3254 h = s->uv_height;
3255
3256 do {
3257 fwrite(src16, s->uv_width, 2, yuv_rec_file);
3258 src16 += s->uv_stride;
3259 } while (--h);
3260
3261 fflush(yuv_rec_file);
3262 return;
3263 }
Yaowu Xuc27fc142016-08-22 16:08:15 -07003264
3265 do {
3266 fwrite(src, s->y_width, 1, yuv_rec_file);
3267 src += s->y_stride;
3268 } while (--h);
3269
3270 src = s->u_buffer;
3271 h = s->uv_height;
3272
3273 do {
3274 fwrite(src, s->uv_width, 1, yuv_rec_file);
3275 src += s->uv_stride;
3276 } while (--h);
3277
3278 src = s->v_buffer;
3279 h = s->uv_height;
3280
3281 do {
3282 fwrite(src, s->uv_width, 1, yuv_rec_file);
3283 src += s->uv_stride;
3284 } while (--h);
3285
3286 fflush(yuv_rec_file);
3287}
3288#endif // OUTPUT_YUV_REC
3289
Debargha Mukherjee11f0e402017-03-29 07:42:40 -07003290#define GM_RECODE_LOOP_NUM4X4_FACTOR 192
Debargha Mukherjeeb98a7022016-11-15 16:07:12 -08003291static int recode_loop_test_global_motion(AV1_COMP *cpi) {
3292 int i;
3293 int recode = 0;
Debargha Mukherjeea575d232017-04-28 17:46:47 -07003294 RD_COUNTS *const rdc = &cpi->td.rd_counts;
Debargha Mukherjeeb98a7022016-11-15 16:07:12 -08003295 AV1_COMMON *const cm = &cpi->common;
3296 for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
3297 if (cm->global_motion[i].wmtype != IDENTITY &&
Debargha Mukherjeea575d232017-04-28 17:46:47 -07003298 rdc->global_motion_used[i] * GM_RECODE_LOOP_NUM4X4_FACTOR <
Debargha Mukherjee265db6d2017-03-28 11:15:27 -07003299 cpi->gmparams_cost[i]) {
David Barkerd7c8bd52017-09-25 14:47:29 +01003300 cm->global_motion[i] = default_warp_params;
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07003301 assert(cm->global_motion[i].wmtype == IDENTITY);
Debargha Mukherjee265db6d2017-03-28 11:15:27 -07003302 cpi->gmparams_cost[i] = 0;
David Barker43479c62016-11-30 10:34:20 +00003303 recode = 1;
Urvang Joshi02aade82017-12-18 17:18:16 -08003304 // TODO(sarahparker): The earlier condition for recoding here was:
3305 // "recode |= (rdc->global_motion_used[i] > 0);". Can we bring something
3306 // similar to that back to speed up global motion?
Debargha Mukherjeeb98a7022016-11-15 16:07:12 -08003307 }
3308 }
3309 return recode;
3310}
Debargha Mukherjeeb98a7022016-11-15 16:07:12 -08003311
Yaowu Xuc27fc142016-08-22 16:08:15 -07003312// Function to test for conditions that indicate we should loop
3313// back and recode a frame.
Yaowu Xuf883b422016-08-30 14:01:10 -07003314static int recode_loop_test(AV1_COMP *cpi, int high_limit, int low_limit, int q,
3315 int maxq, int minq) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07003316 const RATE_CONTROL *const rc = &cpi->rc;
Yaowu Xuf883b422016-08-30 14:01:10 -07003317 const AV1EncoderConfig *const oxcf = &cpi->oxcf;
Yaowu Xuc27fc142016-08-22 16:08:15 -07003318 const int frame_is_kfgfarf = frame_is_kf_gf_arf(cpi);
3319 int force_recode = 0;
3320
3321 if ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
3322 (cpi->sf.recode_loop == ALLOW_RECODE) ||
3323 (frame_is_kfgfarf && (cpi->sf.recode_loop == ALLOW_RECODE_KFARFGF))) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07003324 // TODO(agrange) high_limit could be greater than the scale-down threshold.
3325 if ((rc->projected_frame_size > high_limit && q < maxq) ||
3326 (rc->projected_frame_size < low_limit && q > minq)) {
3327 force_recode = 1;
Yaowu Xuf883b422016-08-30 14:01:10 -07003328 } else if (cpi->oxcf.rc_mode == AOM_CQ) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07003329 // Deal with frame undershoot and whether or not we are
3330 // below the automatically set cq level.
3331 if (q > oxcf->cq_level &&
3332 rc->projected_frame_size < ((rc->this_frame_target * 7) >> 3)) {
3333 force_recode = 1;
3334 }
3335 }
3336 }
3337 return force_recode;
3338}
3339
Cheng Chen46f30c72017-09-07 11:13:33 -07003340static void scale_references(AV1_COMP *cpi) {
Yaowu Xuf883b422016-08-30 14:01:10 -07003341 AV1_COMMON *cm = &cpi->common;
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +00003342 const int num_planes = av1_num_planes(cm);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003343 MV_REFERENCE_FRAME ref_frame;
Yaowu Xuf883b422016-08-30 14:01:10 -07003344 const AOM_REFFRAME ref_mask[INTER_REFS_PER_FRAME] = {
Sebastien Alaiwan365e6442017-10-16 11:35:00 +02003345 AOM_LAST_FLAG, AOM_LAST2_FLAG, AOM_LAST3_FLAG, AOM_GOLD_FLAG,
3346 AOM_BWD_FLAG, AOM_ALT2_FLAG, AOM_ALT_FLAG
Yaowu Xuc27fc142016-08-22 16:08:15 -07003347 };
3348
3349 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
Yaowu Xuf883b422016-08-30 14:01:10 -07003350 // Need to convert from AOM_REFFRAME to index into ref_mask (subtract 1).
Yaowu Xuc27fc142016-08-22 16:08:15 -07003351 if (cpi->ref_frame_flags & ref_mask[ref_frame - 1]) {
3352 BufferPool *const pool = cm->buffer_pool;
3353 const YV12_BUFFER_CONFIG *const ref =
David Turnera21966b2018-12-05 14:48:49 +00003354 get_ref_frame_yv12_buf(cm, ref_frame);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003355
3356 if (ref == NULL) {
David Turnere7ebf902018-12-04 14:04:55 +00003357 cpi->scaled_ref_buf[ref_frame - 1] = NULL;
Yaowu Xuc27fc142016-08-22 16:08:15 -07003358 continue;
3359 }
3360
Yaowu Xuc27fc142016-08-22 16:08:15 -07003361 if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07003362 int force_scaling = 0;
David Turnere7ebf902018-12-04 14:04:55 +00003363 RefCntBuffer *new_fb = cpi->scaled_ref_buf[ref_frame - 1];
3364 if (new_fb == NULL) {
3365 const int new_fb_idx = get_free_fb(cm);
3366 if (new_fb_idx == INVALID_IDX) {
Wan-Teh Chang4a8c0042018-10-05 09:41:52 -07003367 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
3368 "Unable to find free frame buffer");
David Turnere7ebf902018-12-04 14:04:55 +00003369 }
Yaowu Xuc27fc142016-08-22 16:08:15 -07003370 force_scaling = 1;
David Turnere7ebf902018-12-04 14:04:55 +00003371 new_fb = &pool->frame_bufs[new_fb_idx];
Yaowu Xuc27fc142016-08-22 16:08:15 -07003372 }
David Turnere7ebf902018-12-04 14:04:55 +00003373
3374 if (force_scaling || new_fb->buf.y_crop_width != cm->width ||
3375 new_fb->buf.y_crop_height != cm->height) {
Yaowu Xu671f2bd2016-09-30 15:07:57 -07003376 if (aom_realloc_frame_buffer(
David Turnere7ebf902018-12-04 14:04:55 +00003377 &new_fb->buf, cm->width, cm->height,
Urvang Joshi20cf30e2018-07-19 02:33:58 -07003378 cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,
Satish Kumar Suman29909962019-01-09 10:31:21 +05303379 cm->seq_params.use_highbitdepth, cpi->oxcf.border_in_pixels,
Wan-Teh Chang41d286f2018-10-03 11:43:03 -07003380 cm->byte_alignment, NULL, NULL, NULL)) {
3381 if (force_scaling) {
3382 // Release the reference acquired in the get_free_fb() call above.
David Turnere7ebf902018-12-04 14:04:55 +00003383 --new_fb->ref_count;
Wan-Teh Chang41d286f2018-10-03 11:43:03 -07003384 }
Yaowu Xuf883b422016-08-30 14:01:10 -07003385 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
Yaowu Xuc27fc142016-08-22 16:08:15 -07003386 "Failed to allocate frame buffer");
Wan-Teh Chang41d286f2018-10-03 11:43:03 -07003387 }
Urvang Joshi20cf30e2018-07-19 02:33:58 -07003388 av1_resize_and_extend_frame(
David Turnere7ebf902018-12-04 14:04:55 +00003389 ref, &new_fb->buf, (int)cm->seq_params.bit_depth, num_planes);
3390 cpi->scaled_ref_buf[ref_frame - 1] = new_fb;
Yaowu Xuc27fc142016-08-22 16:08:15 -07003391 alloc_frame_mvs(cm, new_fb);
3392 }
Yaowu Xuc27fc142016-08-22 16:08:15 -07003393 } else {
David Turnera21966b2018-12-05 14:48:49 +00003394 RefCntBuffer *buf = get_ref_frame_buf(cm, ref_frame);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003395 buf->buf.y_crop_width = ref->y_crop_width;
3396 buf->buf.y_crop_height = ref->y_crop_height;
David Turnere7ebf902018-12-04 14:04:55 +00003397 cpi->scaled_ref_buf[ref_frame - 1] = buf;
Yaowu Xuc27fc142016-08-22 16:08:15 -07003398 ++buf->ref_count;
3399 }
3400 } else {
David Turnere7ebf902018-12-04 14:04:55 +00003401 if (cpi->oxcf.pass != 0) cpi->scaled_ref_buf[ref_frame - 1] = NULL;
Yaowu Xuc27fc142016-08-22 16:08:15 -07003402 }
3403 }
3404}
3405
Yaowu Xuf883b422016-08-30 14:01:10 -07003406static void release_scaled_references(AV1_COMP *cpi) {
Imdad Sardharwalladadaba62018-02-23 12:06:56 +00003407 // TODO(isbs): only refresh the necessary frames, rather than all of them
David Turnere7ebf902018-12-04 14:04:55 +00003408 for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
3409 RefCntBuffer *const buf = cpi->scaled_ref_buf[i];
3410 if (buf != NULL) {
Imdad Sardharwalladadaba62018-02-23 12:06:56 +00003411 --buf->ref_count;
David Turnere7ebf902018-12-04 14:04:55 +00003412 cpi->scaled_ref_buf[i] = NULL;
Yaowu Xuc27fc142016-08-22 16:08:15 -07003413 }
3414 }
3415}
3416
Yaowu Xuf883b422016-08-30 14:01:10 -07003417static void set_mv_search_params(AV1_COMP *cpi) {
3418 const AV1_COMMON *const cm = &cpi->common;
3419 const unsigned int max_mv_def = AOMMIN(cm->width, cm->height);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003420
3421 // Default based on max resolution.
Yaowu Xuf883b422016-08-30 14:01:10 -07003422 cpi->mv_step_param = av1_init_search_range(max_mv_def);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003423
3424 if (cpi->sf.mv.auto_mv_step_size) {
3425 if (frame_is_intra_only(cm)) {
3426 // Initialize max_mv_magnitude for use in the first INTER frame
3427 // after a key/intra-only frame.
3428 cpi->max_mv_magnitude = max_mv_def;
3429 } else {
3430 if (cm->show_frame) {
3431 // Allow mv_steps to correspond to twice the max mv magnitude found
3432 // in the previous frame, capped by the default max_mv_magnitude based
3433 // on resolution.
Yaowu Xuf883b422016-08-30 14:01:10 -07003434 cpi->mv_step_param = av1_init_search_range(
3435 AOMMIN(max_mv_def, 2 * cpi->max_mv_magnitude));
Yaowu Xuc27fc142016-08-22 16:08:15 -07003436 }
3437 cpi->max_mv_magnitude = 0;
3438 }
3439 }
3440}
3441
Hui Subdf0c992019-02-14 14:52:41 -08003442static void set_screen_content_options(AV1_COMP *cpi) {
3443 AV1_COMMON *cm = &cpi->common;
3444
3445 if (cm->seq_params.force_screen_content_tools != 2) {
3446 cm->allow_screen_content_tools = cm->allow_intrabc =
3447 cm->seq_params.force_screen_content_tools;
3448 return;
3449 }
3450
3451 if (cpi->oxcf.content == AOM_CONTENT_SCREEN) {
3452 cm->allow_screen_content_tools = cm->allow_intrabc = 1;
3453 return;
3454 }
3455
3456 // Estimate if the source frame is screen content, based on the portion of
3457 // blocks that have few luma colors.
3458 const uint8_t *src = cpi->source->y_buffer;
3459 assert(src != NULL);
3460 const int use_hbd = cpi->source->flags & YV12_FLAG_HIGHBITDEPTH;
3461 const int stride = cpi->source->y_stride;
3462 const int width = cpi->source->y_width;
3463 const int height = cpi->source->y_height;
3464 const int bd = cm->seq_params.bit_depth;
3465 const int blk_w = 16;
3466 const int blk_h = 16;
3467 // These threshold values are selected experimentally.
3468 const int color_thresh = 4;
3469 const unsigned int var_thresh = 0;
3470 // Counts of blocks with no more than color_thresh colors.
3471 int counts_1 = 0;
3472 // Counts of blocks with no more than color_thresh colors and variance larger
3473 // than var_thresh.
3474 int counts_2 = 0;
3475
3476 for (int r = 0; r + blk_h <= height; r += blk_h) {
3477 for (int c = 0; c + blk_w <= width; c += blk_w) {
3478 int count_buf[1 << 12]; // Maximum (1 << 12) color levels.
3479 const uint8_t *const this_src = src + r * stride + c;
3480 const int n_colors =
3481 use_hbd ? av1_count_colors_highbd(this_src, stride, blk_w, blk_h, bd,
3482 count_buf)
3483 : av1_count_colors(this_src, stride, blk_w, blk_h, count_buf);
3484 if (n_colors > 1 && n_colors <= color_thresh) {
3485 ++counts_1;
3486 struct buf_2d buf;
3487 buf.stride = stride;
3488 buf.buf = (uint8_t *)this_src;
3489 const unsigned int var =
3490 use_hbd
3491 ? av1_high_get_sby_perpixel_variance(cpi, &buf, BLOCK_16X16, bd)
3492 : av1_get_sby_perpixel_variance(cpi, &buf, BLOCK_16X16);
3493 if (var > var_thresh) ++counts_2;
3494 }
3495 }
3496 }
3497
3498 // The threshold values are selected experimentally.
3499 cm->allow_screen_content_tools =
3500 counts_1 * blk_h * blk_w * 10 > width * height;
3501 // IntraBC would force loop filters off, so we use more strict rules that also
3502 // requires that the block has high variance.
3503 cm->allow_intrabc = cm->allow_screen_content_tools &&
3504 counts_2 * blk_h * blk_w * 15 > width * height;
3505}
3506
Yaowu Xuf883b422016-08-30 14:01:10 -07003507static void set_size_independent_vars(AV1_COMP *cpi) {
Debargha Mukherjeeb98a7022016-11-15 16:07:12 -08003508 int i;
Debargha Mukherjeedf713102018-10-02 12:33:32 -07003509 AV1_COMMON *cm = &cpi->common;
Debargha Mukherjeeb98a7022016-11-15 16:07:12 -08003510 for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
Debargha Mukherjeedf713102018-10-02 12:33:32 -07003511 cm->global_motion[i] = default_warp_params;
Debargha Mukherjeeb98a7022016-11-15 16:07:12 -08003512 }
3513 cpi->global_motion_search_done = 0;
Yunqing Wang9411e432019-03-14 15:53:23 -07003514
3515 if (frame_is_intra_only(cm)) set_screen_content_options(cpi);
3516 cpi->is_screen_content_type = (cm->allow_screen_content_tools != 0);
3517
David Turner04b70d82019-01-24 15:39:19 +00003518 av1_set_speed_features_framesize_independent(cpi, cpi->speed);
Yaowu Xuf883b422016-08-30 14:01:10 -07003519 av1_set_rd_speed_thresholds(cpi);
Debargha Mukherjeedf713102018-10-02 12:33:32 -07003520 cm->interp_filter = SWITCHABLE;
3521 cm->switchable_motion_mode = 1;
Yaowu Xuc27fc142016-08-22 16:08:15 -07003522}
3523
Yaowu Xuf883b422016-08-30 14:01:10 -07003524static void set_size_dependent_vars(AV1_COMP *cpi, int *q, int *bottom_index,
Yaowu Xuc27fc142016-08-22 16:08:15 -07003525 int *top_index) {
Yaowu Xuf883b422016-08-30 14:01:10 -07003526 AV1_COMMON *const cm = &cpi->common;
3527 const AV1EncoderConfig *const oxcf = &cpi->oxcf;
Yaowu Xuc27fc142016-08-22 16:08:15 -07003528
3529 // Setup variables that depend on the dimensions of the frame.
David Turner04b70d82019-01-24 15:39:19 +00003530 av1_set_speed_features_framesize_dependent(cpi, cpi->speed);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003531
Sebastien Alaiwan41cae6a2018-01-12 12:22:29 +01003532 // Decide q and q bounds.
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003533 *q = av1_rc_pick_q_and_bounds(cpi, cm->width, cm->height, bottom_index,
3534 top_index);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003535
James Zern01a9d702017-08-25 19:09:33 +00003536 if (!frame_is_intra_only(cm)) {
RogerZhou3b635242017-09-19 10:06:46 -07003537 set_high_precision_mv(cpi, (*q) < HIGH_PRECISION_MV_QTHRESH,
RogerZhou10a03802017-10-26 11:49:48 -07003538 cpi->common.cur_frame_force_integer_mv);
James Zern01a9d702017-08-25 19:09:33 +00003539 }
Yaowu Xuc27fc142016-08-22 16:08:15 -07003540
3541 // Configure experimental use of segmentation for enhanced coding of
3542 // static regions if indicated.
3543 // Only allowed in the second pass of a two pass encode, as it requires
3544 // lagged coding, and if the relevant speed feature flag is set.
3545 if (oxcf->pass == 2 && cpi->sf.static_segmentation)
3546 configure_static_seg_features(cpi);
3547}
3548
Yaowu Xuf883b422016-08-30 14:01:10 -07003549static void init_motion_estimation(AV1_COMP *cpi) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07003550 int y_stride = cpi->scaled_source.y_stride;
Satish Kumar Sumane6d0be52019-02-14 14:33:28 +05303551 int y_stride_src = (cpi->oxcf.resize_mode || cpi->oxcf.superres_mode)
3552 ? y_stride
3553 : cpi->lookahead->buf->img.y_stride;
Yaowu Xuc27fc142016-08-22 16:08:15 -07003554
3555 if (cpi->sf.mv.search_method == NSTEP) {
Satish Kumar Sumane6d0be52019-02-14 14:33:28 +05303556 av1_init3smotion_compensation(&cpi->ss_cfg[SS_CFG_SRC], y_stride);
3557 av1_init3smotion_compensation(&cpi->ss_cfg[SS_CFG_LOOKAHEAD], y_stride_src);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003558 } else if (cpi->sf.mv.search_method == DIAMOND) {
Satish Kumar Sumane6d0be52019-02-14 14:33:28 +05303559 av1_init_dsmotion_compensation(&cpi->ss_cfg[SS_CFG_SRC], y_stride);
3560 av1_init_dsmotion_compensation(&cpi->ss_cfg[SS_CFG_LOOKAHEAD],
3561 y_stride_src);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003562 }
3563}
3564
Debargha Mukherjee84f567c2017-06-21 10:53:59 -07003565#define COUPLED_CHROMA_FROM_LUMA_RESTORATION 0
Rupert Swarbrickbcb65fe2017-10-25 17:15:28 +01003566static void set_restoration_unit_size(int width, int height, int sx, int sy,
3567 RestorationInfo *rst) {
Debargha Mukherjee1008c1e2017-03-06 19:18:43 -08003568 (void)width;
3569 (void)height;
Debargha Mukherjee84f567c2017-06-21 10:53:59 -07003570 (void)sx;
3571 (void)sy;
3572#if COUPLED_CHROMA_FROM_LUMA_RESTORATION
3573 int s = AOMMIN(sx, sy);
3574#else
3575 int s = 0;
3576#endif // !COUPLED_CHROMA_FROM_LUMA_RESTORATION
3577
Debargha Mukherjee5f7f3672017-08-12 10:22:49 -07003578 if (width * height > 352 * 288)
Urvang Joshi813186b2018-03-08 15:38:46 -08003579 rst[0].restoration_unit_size = RESTORATION_UNITSIZE_MAX;
Debargha Mukherjee5f7f3672017-08-12 10:22:49 -07003580 else
Urvang Joshi813186b2018-03-08 15:38:46 -08003581 rst[0].restoration_unit_size = (RESTORATION_UNITSIZE_MAX >> 1);
Rupert Swarbrickbcb65fe2017-10-25 17:15:28 +01003582 rst[1].restoration_unit_size = rst[0].restoration_unit_size >> s;
3583 rst[2].restoration_unit_size = rst[1].restoration_unit_size;
Debargha Mukherjee1008c1e2017-03-06 19:18:43 -08003584}
Debargha Mukherjee1008c1e2017-03-06 19:18:43 -08003585
Ravi Chaudhary783d6a32018-08-28 18:21:02 +05303586static void init_ref_frame_bufs(AV1_COMP *cpi) {
3587 AV1_COMMON *const cm = &cpi->common;
Cheng Chen46f30c72017-09-07 11:13:33 -07003588 int i;
3589 BufferPool *const pool = cm->buffer_pool;
Jack Haughtonddb80602018-11-21 16:41:49 +00003590 cm->cur_frame = NULL;
Cheng Chen46f30c72017-09-07 11:13:33 -07003591 for (i = 0; i < REF_FRAMES; ++i) {
David Turnere7ebf902018-12-04 14:04:55 +00003592 cm->ref_frame_map[i] = NULL;
Wan-Teh Changd05e0332018-10-03 12:00:43 -07003593 }
3594 for (i = 0; i < FRAME_BUFFERS; ++i) {
Cheng Chen46f30c72017-09-07 11:13:33 -07003595 pool->frame_bufs[i].ref_count = 0;
3596 }
RogerZhou86902d02018-02-28 15:29:16 -08003597 if (cm->seq_params.force_screen_content_tools) {
Hui Su2d5fd742018-02-21 18:10:37 -08003598 for (i = 0; i < FRAME_BUFFERS; ++i) {
Ravi Chaudhary783d6a32018-08-28 18:21:02 +05303599 av1_hash_table_init(&pool->frame_bufs[i].hash_table, &cpi->td.mb);
Hui Su2d5fd742018-02-21 18:10:37 -08003600 }
Cheng Chen46f30c72017-09-07 11:13:33 -07003601 }
Cheng Chen46f30c72017-09-07 11:13:33 -07003602}
3603
Yaowu Xud3e7c682017-12-21 14:08:25 -08003604static void check_initial_width(AV1_COMP *cpi, int use_highbitdepth,
Cheng Chen46f30c72017-09-07 11:13:33 -07003605 int subsampling_x, int subsampling_y) {
3606 AV1_COMMON *const cm = &cpi->common;
Urvang Joshi20cf30e2018-07-19 02:33:58 -07003607 SequenceHeader *const seq_params = &cm->seq_params;
Cheng Chen46f30c72017-09-07 11:13:33 -07003608
Urvang Joshi20cf30e2018-07-19 02:33:58 -07003609 if (!cpi->initial_width || seq_params->use_highbitdepth != use_highbitdepth ||
3610 seq_params->subsampling_x != subsampling_x ||
3611 seq_params->subsampling_y != subsampling_y) {
3612 seq_params->subsampling_x = subsampling_x;
3613 seq_params->subsampling_y = subsampling_y;
3614 seq_params->use_highbitdepth = use_highbitdepth;
Cheng Chen46f30c72017-09-07 11:13:33 -07003615
3616 alloc_raw_frame_buffers(cpi);
Ravi Chaudhary783d6a32018-08-28 18:21:02 +05303617 init_ref_frame_bufs(cpi);
Cheng Chen46f30c72017-09-07 11:13:33 -07003618 alloc_util_frame_buffers(cpi);
3619
3620 init_motion_estimation(cpi); // TODO(agrange) This can be removed.
3621
3622 cpi->initial_width = cm->width;
3623 cpi->initial_height = cm->height;
3624 cpi->initial_mbs = cm->MBs;
3625 }
3626}
3627
3628// Returns 1 if the assigned width or height was <= 0.
3629static int set_size_literal(AV1_COMP *cpi, int width, int height) {
3630 AV1_COMMON *cm = &cpi->common;
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +00003631 const int num_planes = av1_num_planes(cm);
Urvang Joshi20cf30e2018-07-19 02:33:58 -07003632 check_initial_width(cpi, cm->seq_params.use_highbitdepth,
3633 cm->seq_params.subsampling_x,
3634 cm->seq_params.subsampling_y);
Cheng Chen46f30c72017-09-07 11:13:33 -07003635
3636 if (width <= 0 || height <= 0) return 1;
3637
3638 cm->width = width;
Cheng Chen46f30c72017-09-07 11:13:33 -07003639 cm->height = height;
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07003640
3641 if (cpi->initial_width && cpi->initial_height &&
3642 (cm->width > cpi->initial_width || cm->height > cpi->initial_height)) {
3643 av1_free_context_buffers(cm);
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +00003644 av1_free_pc_tree(&cpi->td, num_planes);
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07003645 alloc_compressor_data(cpi);
3646 realloc_segmentation_maps(cpi);
3647 cpi->initial_width = cpi->initial_height = 0;
Cheng Chen46f30c72017-09-07 11:13:33 -07003648 }
Cheng Chen46f30c72017-09-07 11:13:33 -07003649 update_frame_size(cpi);
3650
3651 return 0;
3652}
3653
David Turner475a3132019-01-18 15:17:17 +00003654void av1_set_frame_size(AV1_COMP *cpi, int width, int height) {
Fergus Simpsonbc189932017-05-16 17:02:39 -07003655 AV1_COMMON *const cm = &cpi->common;
Urvang Joshi20cf30e2018-07-19 02:33:58 -07003656 const SequenceHeader *const seq_params = &cm->seq_params;
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +00003657 const int num_planes = av1_num_planes(cm);
Fergus Simpsonbc189932017-05-16 17:02:39 -07003658 MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07003659 int ref_frame;
Yaowu Xuc27fc142016-08-22 16:08:15 -07003660
Fergus Simpsonbc189932017-05-16 17:02:39 -07003661 if (width != cm->width || height != cm->height) {
Fergus Simpson3502d082017-04-10 12:25:07 -07003662 // There has been a change in the encoded frame size
Cheng Chen46f30c72017-09-07 11:13:33 -07003663 set_size_literal(cpi, width, height);
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07003664 set_mv_search_params(cpi);
Urvang Joshic8b52d52018-03-23 13:16:51 -07003665 // Recalculate 'all_lossless' in case super-resolution was (un)selected.
Cheng Chen09c83a52018-06-05 12:27:36 -07003666 cm->all_lossless = cm->coded_lossless && !av1_superres_scaled(cm);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003667 }
3668
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07003669 if (cpi->oxcf.pass == 2) {
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003670 av1_set_target_rate(cpi, cm->width, cm->height);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003671 }
3672
David Turnere7ebf902018-12-04 14:04:55 +00003673 alloc_frame_mvs(cm, cm->cur_frame);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003674
Cherma Rajan A71d20db2018-04-27 11:15:32 +05303675 // Allocate above context buffers
Cherma Rajan Af1479082018-05-09 14:26:34 +05303676 if (cm->num_allocated_above_context_planes < av1_num_planes(cm) ||
3677 cm->num_allocated_above_context_mi_col < cm->mi_cols ||
Cherma Rajan A71d20db2018-04-27 11:15:32 +05303678 cm->num_allocated_above_contexts < cm->tile_rows) {
3679 av1_free_above_context_buffers(cm, cm->num_allocated_above_contexts);
3680 if (av1_alloc_above_context_buffers(cm, cm->tile_rows))
3681 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
3682 "Failed to allocate context buffers");
3683 }
3684
Yaowu Xuc27fc142016-08-22 16:08:15 -07003685 // Reset the frame pointers to the current frame size.
Urvang Joshi20cf30e2018-07-19 02:33:58 -07003686 if (aom_realloc_frame_buffer(
Jack Haughtonddb80602018-11-21 16:41:49 +00003687 &cm->cur_frame->buf, cm->width, cm->height, seq_params->subsampling_x,
3688 seq_params->subsampling_y, seq_params->use_highbitdepth,
Satish Kumar Suman29909962019-01-09 10:31:21 +05303689 cpi->oxcf.border_in_pixels, cm->byte_alignment, NULL, NULL, NULL))
Yaowu Xuf883b422016-08-30 14:01:10 -07003690 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
Yaowu Xuc27fc142016-08-22 16:08:15 -07003691 "Failed to allocate frame buffer");
3692
Rupert Swarbrickf88bc042017-10-18 10:45:51 +01003693 const int frame_width = cm->superres_upscaled_width;
3694 const int frame_height = cm->superres_upscaled_height;
Urvang Joshi20cf30e2018-07-19 02:33:58 -07003695 set_restoration_unit_size(frame_width, frame_height,
3696 seq_params->subsampling_x,
3697 seq_params->subsampling_y, cm->rst_info);
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +00003698 for (int i = 0; i < num_planes; ++i)
Rupert Swarbrick1a96c3f2017-10-24 11:55:00 +01003699 cm->rst_info[i].frame_restoration_type = RESTORE_NONE;
Rupert Swarbrickf88bc042017-10-18 10:45:51 +01003700
3701 av1_alloc_restoration_buffers(cm);
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -08003702 alloc_util_frame_buffers(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003703 init_motion_estimation(cpi);
3704
3705 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
David Turnera21966b2018-12-05 14:48:49 +00003706 RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
David Turnere7ebf902018-12-04 14:04:55 +00003707 if (buf != NULL) {
David Turnera21966b2018-12-05 14:48:49 +00003708 struct scale_factors *sf = get_ref_scale_factors(cm, ref_frame);
3709 av1_setup_scale_factors_for_frame(sf, buf->buf.y_crop_width,
David Turner1bcefb32018-11-19 17:54:00 +00003710 buf->buf.y_crop_height, cm->width,
Debargha Mukherjeee242a812018-03-07 21:43:09 -08003711 cm->height);
David Turnera21966b2018-12-05 14:48:49 +00003712 if (av1_is_scaled(sf)) aom_extend_frame_borders(&buf->buf, num_planes);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003713 }
3714 }
Zoe Liu7b1ec7a2017-05-24 22:28:24 -07003715
Hui Su5ebd8702018-01-08 18:09:20 -08003716 av1_setup_scale_factors_for_frame(&cm->sf_identity, cm->width, cm->height,
Debargha Mukherjeee242a812018-03-07 21:43:09 -08003717 cm->width, cm->height);
Yaowu Xuc27fc142016-08-22 16:08:15 -07003718
3719 set_ref_ptrs(cm, xd, LAST_FRAME, LAST_FRAME);
3720}
3721
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003722static uint8_t calculate_next_resize_scale(const AV1_COMP *cpi) {
3723 // Choose an arbitrary random number
3724 static unsigned int seed = 56789;
3725 const AV1EncoderConfig *oxcf = &cpi->oxcf;
Urvang Joshide71d142017-10-05 12:12:15 -07003726 if (oxcf->pass == 1) return SCALE_NUMERATOR;
3727 uint8_t new_denom = SCALE_NUMERATOR;
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003728
Debargha Mukherjee2b7c2b32018-04-10 07:35:28 -07003729 if (cpi->common.seq_params.reduced_still_picture_hdr) return SCALE_NUMERATOR;
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003730 switch (oxcf->resize_mode) {
Urvang Joshide71d142017-10-05 12:12:15 -07003731 case RESIZE_NONE: new_denom = SCALE_NUMERATOR; break;
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003732 case RESIZE_FIXED:
David Turnerd2a592e2018-11-16 14:59:31 +00003733 if (cpi->common.current_frame.frame_type == KEY_FRAME)
Urvang Joshide71d142017-10-05 12:12:15 -07003734 new_denom = oxcf->resize_kf_scale_denominator;
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003735 else
Urvang Joshide71d142017-10-05 12:12:15 -07003736 new_denom = oxcf->resize_scale_denominator;
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003737 break;
Urvang Joshide71d142017-10-05 12:12:15 -07003738 case RESIZE_RANDOM: new_denom = lcg_rand16(&seed) % 9 + 8; break;
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003739 default: assert(0);
3740 }
Urvang Joshide71d142017-10-05 12:12:15 -07003741 return new_denom;
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003742}
3743
Debargha Mukherjeee3cd5a52018-11-29 11:05:22 -08003744#define ENERGY_BY_Q2_THRESH 0.01
Debargha Mukherjee21eb0402018-12-03 12:10:59 -08003745#define ENERGY_BY_AC_THRESH 0.2
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -08003746
3747static uint8_t get_superres_denom_from_qindex_energy(int qindex, double *energy,
Debargha Mukherjee21eb0402018-12-03 12:10:59 -08003748 double threshq,
3749 double threshp) {
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -08003750 const double q = av1_convert_qindex_to_q(qindex, AOM_BITS_8);
Debargha Mukherjee21eb0402018-12-03 12:10:59 -08003751 const double tq = threshq * q * q;
3752 const double tp = threshp * energy[1];
3753 const double thresh = AOMMIN(tq, tp);
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -08003754 int k;
Debargha Mukherjee21eb0402018-12-03 12:10:59 -08003755 for (k = 16; k > 8; --k) {
3756 if (energy[k - 1] > thresh) break;
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -08003757 }
Debargha Mukherjee21eb0402018-12-03 12:10:59 -08003758 return 3 * SCALE_NUMERATOR - k;
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -08003759}
3760
3761static uint8_t get_superres_denom_for_qindex(const AV1_COMP *cpi, int qindex) {
Debargha Mukherjee21eb0402018-12-03 12:10:59 -08003762 double energy[16];
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -08003763 analyze_hor_freq(cpi, energy);
Debargha Mukherjee21eb0402018-12-03 12:10:59 -08003764 /*
3765 printf("\nenergy = [");
3766 for (int k = 1; k < 16; ++k) printf("%f, ", energy[k]);
3767 printf("]\n");
3768 */
3769 return get_superres_denom_from_qindex_energy(
3770 qindex, energy, ENERGY_BY_Q2_THRESH, ENERGY_BY_AC_THRESH);
Debargha Mukherjeef48b0d22018-11-20 12:23:43 -08003771}
3772
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003773static uint8_t calculate_next_superres_scale(AV1_COMP *cpi) {
3774 // Choose an arbitrary random number
3775 static unsigned int seed = 34567;
3776 const AV1EncoderConfig *oxcf = &cpi->oxcf;
Urvang Joshide71d142017-10-05 12:12:15 -07003777 if (oxcf->pass == 1) return SCALE_NUMERATOR;
3778 uint8_t new_denom = SCALE_NUMERATOR;
Urvang Joshi2c92b072018-03-19 17:23:31 -07003779
3780 // Make sure that superres mode of the frame is consistent with the
3781 // sequence-level flag.
3782 assert(IMPLIES(oxcf->superres_mode != SUPERRES_NONE,
3783 cpi->common.seq_params.enable_superres));
3784 assert(IMPLIES(!cpi->common.seq_params.enable_superres,
3785 oxcf->superres_mode == SUPERRES_NONE));
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003786
3787 switch (oxcf->superres_mode) {
Urvang Joshide71d142017-10-05 12:12:15 -07003788 case SUPERRES_NONE: new_denom = SCALE_NUMERATOR; break;
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003789 case SUPERRES_FIXED:
David Turnerd2a592e2018-11-16 14:59:31 +00003790 if (cpi->common.current_frame.frame_type == KEY_FRAME)
Urvang Joshide71d142017-10-05 12:12:15 -07003791 new_denom = oxcf->superres_kf_scale_denominator;
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003792 else
Urvang Joshide71d142017-10-05 12:12:15 -07003793 new_denom = oxcf->superres_scale_denominator;
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003794 break;
Urvang Joshide71d142017-10-05 12:12:15 -07003795 case SUPERRES_RANDOM: new_denom = lcg_rand16(&seed) % 9 + 8; break;
Urvang Joshif1fa6862018-01-08 16:39:33 -08003796 case SUPERRES_QTHRESH: {
Debargha Mukherjeedf713102018-10-02 12:33:32 -07003797 // Do not use superres when screen content tools are used.
3798 if (cpi->common.allow_screen_content_tools) break;
Debargha Mukherjee2b2c5fd2018-11-14 13:21:24 -08003799 if (oxcf->rc_mode == AOM_VBR || oxcf->rc_mode == AOM_CQ)
3800 av1_set_target_rate(cpi, cpi->oxcf.width, cpi->oxcf.height);
Urvang Joshi2c92b072018-03-19 17:23:31 -07003801 int bottom_index, top_index;
3802 const int q = av1_rc_pick_q_and_bounds(
3803 cpi, cpi->oxcf.width, cpi->oxcf.height, &bottom_index, &top_index);
Debargha Mukherjeef48b0d22018-11-20 12:23:43 -08003804
Debargha Mukherjeeacd9b7d2018-11-26 15:15:05 -08003805 const int qthresh = (frame_is_intra_only(&cpi->common))
3806 ? oxcf->superres_kf_qthresh
3807 : oxcf->superres_qthresh;
Urvang Joshib17e0a62019-01-11 16:11:54 -08003808 if (q <= qthresh) {
Urvang Joshide71d142017-10-05 12:12:15 -07003809 new_denom = SCALE_NUMERATOR;
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003810 } else {
Debargha Mukherjeee3cd5a52018-11-29 11:05:22 -08003811 new_denom = get_superres_denom_for_qindex(cpi, q);
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003812 }
3813 break;
Urvang Joshif1fa6862018-01-08 16:39:33 -08003814 }
Urvang Joshi36a83732019-01-31 15:31:57 -08003815 case SUPERRES_AUTO: {
3816 // Don't use when screen content tools are used.
3817 if (cpi->common.allow_screen_content_tools) break;
3818 // Don't use for inter frames.
3819 if (!frame_is_intra_only(&cpi->common)) break;
3820 // Don't use for keyframes that can be used as references.
3821 if (cpi->rc.frames_to_key != 1) break;
Urvang Joshi36a83732019-01-31 15:31:57 -08003822
3823 // Now decide the use of superres based on 'q'.
3824 int bottom_index, top_index;
3825 const int q = av1_rc_pick_q_and_bounds(
3826 cpi, cpi->oxcf.width, cpi->oxcf.height, &bottom_index, &top_index);
3827
3828 const int qthresh = 128;
3829 if (q <= qthresh) {
3830 new_denom = SCALE_NUMERATOR;
3831 } else {
3832 new_denom = get_superres_denom_for_qindex(cpi, q);
3833 }
3834 break;
3835 }
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003836 default: assert(0);
3837 }
Urvang Joshide71d142017-10-05 12:12:15 -07003838 return new_denom;
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003839}
3840
Urvang Joshide71d142017-10-05 12:12:15 -07003841static int dimension_is_ok(int orig_dim, int resized_dim, int denom) {
3842 return (resized_dim * SCALE_NUMERATOR >= orig_dim * denom / 2);
3843}
3844
3845static int dimensions_are_ok(int owidth, int oheight, size_params_type *rsz) {
Urvang Joshi94ad3702017-12-06 11:38:08 -08003846 // Only need to check the width, as scaling is horizontal only.
3847 (void)oheight;
3848 return dimension_is_ok(owidth, rsz->resize_width, rsz->superres_denom);
Urvang Joshide71d142017-10-05 12:12:15 -07003849}
3850
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003851static int validate_size_scales(RESIZE_MODE resize_mode,
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07003852 SUPERRES_MODE superres_mode, int owidth,
3853 int oheight, size_params_type *rsz) {
Urvang Joshide71d142017-10-05 12:12:15 -07003854 if (dimensions_are_ok(owidth, oheight, rsz)) { // Nothing to do.
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003855 return 1;
Urvang Joshide71d142017-10-05 12:12:15 -07003856 }
3857
Urvang Joshi69fde2e2017-10-09 15:34:18 -07003858 // Calculate current resize scale.
Urvang Joshide71d142017-10-05 12:12:15 -07003859 int resize_denom =
3860 AOMMAX(DIVIDE_AND_ROUND(owidth * SCALE_NUMERATOR, rsz->resize_width),
3861 DIVIDE_AND_ROUND(oheight * SCALE_NUMERATOR, rsz->resize_height));
3862
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003863 if (resize_mode != RESIZE_RANDOM && superres_mode == SUPERRES_RANDOM) {
Urvang Joshide71d142017-10-05 12:12:15 -07003864 // Alter superres scale as needed to enforce conformity.
3865 rsz->superres_denom =
3866 (2 * SCALE_NUMERATOR * SCALE_NUMERATOR) / resize_denom;
3867 if (!dimensions_are_ok(owidth, oheight, rsz)) {
3868 if (rsz->superres_denom > SCALE_NUMERATOR) --rsz->superres_denom;
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07003869 }
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003870 } else if (resize_mode == RESIZE_RANDOM && superres_mode != SUPERRES_RANDOM) {
Urvang Joshide71d142017-10-05 12:12:15 -07003871 // Alter resize scale as needed to enforce conformity.
3872 resize_denom =
3873 (2 * SCALE_NUMERATOR * SCALE_NUMERATOR) / rsz->superres_denom;
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07003874 rsz->resize_width = owidth;
3875 rsz->resize_height = oheight;
3876 av1_calculate_scaled_size(&rsz->resize_width, &rsz->resize_height,
Urvang Joshide71d142017-10-05 12:12:15 -07003877 resize_denom);
3878 if (!dimensions_are_ok(owidth, oheight, rsz)) {
3879 if (resize_denom > SCALE_NUMERATOR) {
3880 --resize_denom;
3881 rsz->resize_width = owidth;
3882 rsz->resize_height = oheight;
3883 av1_calculate_scaled_size(&rsz->resize_width, &rsz->resize_height,
3884 resize_denom);
3885 }
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07003886 }
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003887 } else if (resize_mode == RESIZE_RANDOM && superres_mode == SUPERRES_RANDOM) {
Urvang Joshide71d142017-10-05 12:12:15 -07003888 // Alter both resize and superres scales as needed to enforce conformity.
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003889 do {
Urvang Joshide71d142017-10-05 12:12:15 -07003890 if (resize_denom > rsz->superres_denom)
3891 --resize_denom;
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003892 else
Urvang Joshide71d142017-10-05 12:12:15 -07003893 --rsz->superres_denom;
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07003894 rsz->resize_width = owidth;
3895 rsz->resize_height = oheight;
3896 av1_calculate_scaled_size(&rsz->resize_width, &rsz->resize_height,
Urvang Joshide71d142017-10-05 12:12:15 -07003897 resize_denom);
3898 } while (!dimensions_are_ok(owidth, oheight, rsz) &&
3899 (resize_denom > SCALE_NUMERATOR ||
3900 rsz->superres_denom > SCALE_NUMERATOR));
Urvang Joshif1fa6862018-01-08 16:39:33 -08003901 } else { // We are allowed to alter neither resize scale nor superres
3902 // scale.
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003903 return 0;
3904 }
Urvang Joshide71d142017-10-05 12:12:15 -07003905 return dimensions_are_ok(owidth, oheight, rsz);
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003906}
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003907
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07003908// Calculates resize and superres params for next frame
David Turner475a3132019-01-18 15:17:17 +00003909static size_params_type calculate_next_size_params(AV1_COMP *cpi) {
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003910 const AV1EncoderConfig *oxcf = &cpi->oxcf;
Debargha Mukherjee3a4959f2018-02-26 15:34:03 -08003911 size_params_type rsz = { oxcf->width, oxcf->height, SCALE_NUMERATOR };
Urvang Joshide71d142017-10-05 12:12:15 -07003912 int resize_denom;
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003913 if (oxcf->pass == 1) return rsz;
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07003914 if (cpi->resize_pending_width && cpi->resize_pending_height) {
3915 rsz.resize_width = cpi->resize_pending_width;
3916 rsz.resize_height = cpi->resize_pending_height;
3917 cpi->resize_pending_width = cpi->resize_pending_height = 0;
3918 } else {
Urvang Joshide71d142017-10-05 12:12:15 -07003919 resize_denom = calculate_next_resize_scale(cpi);
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07003920 rsz.resize_width = cpi->oxcf.width;
3921 rsz.resize_height = cpi->oxcf.height;
3922 av1_calculate_scaled_size(&rsz.resize_width, &rsz.resize_height,
Urvang Joshide71d142017-10-05 12:12:15 -07003923 resize_denom);
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07003924 }
Urvang Joshide71d142017-10-05 12:12:15 -07003925 rsz.superres_denom = calculate_next_superres_scale(cpi);
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07003926 if (!validate_size_scales(oxcf->resize_mode, oxcf->superres_mode, oxcf->width,
3927 oxcf->height, &rsz))
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003928 assert(0 && "Invalid scale parameters");
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003929 return rsz;
3930}
3931
Urvang Joshi22b150b2019-01-10 14:32:32 -08003932static void setup_frame_size_from_params(AV1_COMP *cpi,
3933 const size_params_type *rsz) {
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07003934 int encode_width = rsz->resize_width;
3935 int encode_height = rsz->resize_height;
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07003936
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07003937 AV1_COMMON *cm = &cpi->common;
3938 cm->superres_upscaled_width = encode_width;
3939 cm->superres_upscaled_height = encode_height;
Urvang Joshide71d142017-10-05 12:12:15 -07003940 cm->superres_scale_denominator = rsz->superres_denom;
Urvang Joshi69fde2e2017-10-09 15:34:18 -07003941 av1_calculate_scaled_superres_size(&encode_width, &encode_height,
3942 rsz->superres_denom);
David Turner475a3132019-01-18 15:17:17 +00003943 av1_set_frame_size(cpi, encode_width, encode_height);
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07003944}
3945
David Turnerdedd8ff2019-01-23 13:59:46 +00003946void av1_setup_frame_size(AV1_COMP *cpi) {
Debargha Mukherjeea082f762019-03-04 15:05:18 -08003947 AV1_COMMON *cm = &cpi->common;
Urvang Joshi22b150b2019-01-10 14:32:32 -08003948 // Reset superres params from previous frame.
Debargha Mukherjeea082f762019-03-04 15:05:18 -08003949 cm->superres_scale_denominator = SCALE_NUMERATOR;
David Turner475a3132019-01-18 15:17:17 +00003950 const size_params_type rsz = calculate_next_size_params(cpi);
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003951 setup_frame_size_from_params(cpi, &rsz);
Debargha Mukherjeea082f762019-03-04 15:05:18 -08003952
3953 assert(is_min_tile_width_satisfied(cm));
Debargha Mukherjee7166f222017-09-05 21:32:42 -07003954}
3955
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07003956static void superres_post_encode(AV1_COMP *cpi) {
3957 AV1_COMMON *cm = &cpi->common;
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +00003958 const int num_planes = av1_num_planes(cm);
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07003959
Cheng Chen09c83a52018-06-05 12:27:36 -07003960 if (!av1_superres_scaled(cm)) return;
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07003961
Urvang Joshid6b5d512018-03-20 13:34:38 -07003962 assert(cpi->oxcf.enable_superres);
3963 assert(!is_lossless_requested(&cpi->oxcf));
Urvang Joshic8b52d52018-03-23 13:16:51 -07003964 assert(!cm->all_lossless);
Urvang Joshid6b5d512018-03-20 13:34:38 -07003965
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07003966 av1_superres_upscale(cm, NULL);
3967
3968 // If regular resizing is occurring the source will need to be downscaled to
3969 // match the upscaled superres resolution. Otherwise the original source is
3970 // used.
Cheng Chen09c83a52018-06-05 12:27:36 -07003971 if (!av1_resize_scaled(cm)) {
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07003972 cpi->source = cpi->unscaled_source;
3973 if (cpi->last_source != NULL) cpi->last_source = cpi->unscaled_last_source;
3974 } else {
Fergus Simpsonabd43432017-06-12 15:54:43 -07003975 assert(cpi->unscaled_source->y_crop_width != cm->superres_upscaled_width);
3976 assert(cpi->unscaled_source->y_crop_height != cm->superres_upscaled_height);
Urvang Joshif1fa6862018-01-08 16:39:33 -08003977 // Do downscale. cm->(width|height) has been updated by
3978 // av1_superres_upscale
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07003979 if (aom_realloc_frame_buffer(
3980 &cpi->scaled_source, cm->superres_upscaled_width,
Urvang Joshi20cf30e2018-07-19 02:33:58 -07003981 cm->superres_upscaled_height, cm->seq_params.subsampling_x,
3982 cm->seq_params.subsampling_y, cm->seq_params.use_highbitdepth,
3983 AOM_BORDER_IN_PIXELS, cm->byte_alignment, NULL, NULL, NULL))
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07003984 aom_internal_error(
3985 &cm->error, AOM_CODEC_MEM_ERROR,
3986 "Failed to reallocate scaled source buffer for superres");
3987 assert(cpi->scaled_source.y_crop_width == cm->superres_upscaled_width);
3988 assert(cpi->scaled_source.y_crop_height == cm->superres_upscaled_height);
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07003989 av1_resize_and_extend_frame(cpi->unscaled_source, &cpi->scaled_source,
Urvang Joshi20cf30e2018-07-19 02:33:58 -07003990 (int)cm->seq_params.bit_depth, num_planes);
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07003991 cpi->source = &cpi->scaled_source;
3992 }
3993}
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07003994
3995static void loopfilter_frame(AV1_COMP *cpi, AV1_COMMON *cm) {
Imdad Sardharwallaaf8e2642018-01-19 11:46:34 +00003996 const int num_planes = av1_num_planes(cm);
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07003997 MACROBLOCKD *xd = &cpi->td.mb.e_mbd;
Urvang Joshi14072aa2018-03-21 17:43:36 -07003998
Urvang Joshic8b52d52018-03-23 13:16:51 -07003999 assert(IMPLIES(is_lossless_requested(&cpi->oxcf),
4000 cm->coded_lossless && cm->all_lossless));
4001
logangwf95c9162019-02-20 12:02:32 -08004002 const int use_loopfilter = !cm->coded_lossless && !cm->large_scale_tile;
4003 const int use_cdef = cm->seq_params.enable_cdef && !cm->coded_lossless &&
4004 !cm->large_scale_tile;
4005 const int use_restoration = cm->seq_params.enable_restoration &&
4006 !cm->all_lossless && !cm->large_scale_tile;
Urvang Joshi14072aa2018-03-21 17:43:36 -07004007
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07004008 struct loopfilter *lf = &cm->lf;
Yunqing Wangeeb08a92017-07-07 21:25:18 -07004009
Yunqing Wangd1f32e62019-02-20 10:37:51 -08004010#if CONFIG_COLLECT_COMPONENT_TIMING
4011 start_timing(cpi, loop_filter_time);
4012#endif
logangwf95c9162019-02-20 12:02:32 -08004013 if (use_loopfilter) {
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07004014 aom_clear_system_state();
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07004015 av1_pick_filter_level(cpi->source, cpi, cpi->sf.lpf_pick);
logangwf95c9162019-02-20 12:02:32 -08004016 } else {
4017 lf->filter_level[0] = 0;
4018 lf->filter_level[1] = 0;
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07004019 }
4020
Debargha Mukherjee2382b142018-02-26 14:31:32 -08004021 if (lf->filter_level[0] || lf->filter_level[1]) {
Deepa K G964e72e2018-05-16 16:56:01 +05304022 if (cpi->num_workers > 1)
David Turnerc29e1a92018-12-06 14:10:14 +00004023 av1_loop_filter_frame_mt(&cm->cur_frame->buf, cm, xd, 0, num_planes, 0,
Cheng Chene3600cd2018-09-21 18:45:42 -07004024#if LOOP_FILTER_BITMASK
4025 0,
4026#endif
Deepa K G964e72e2018-05-16 16:56:01 +05304027 cpi->workers, cpi->num_workers,
4028 &cpi->lf_row_sync);
4029 else
David Turnerc29e1a92018-12-06 14:10:14 +00004030 av1_loop_filter_frame(&cm->cur_frame->buf, cm, xd,
Cheng Chen84b09932018-08-12 17:35:13 -07004031#if LOOP_FILTER_BITMASK
4032 0,
Cheng Chen8ab1f442018-04-27 18:01:52 -07004033#endif
Cheng Chen84b09932018-08-12 17:35:13 -07004034 0, num_planes, 0);
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07004035 }
Yunqing Wangd1f32e62019-02-20 10:37:51 -08004036#if CONFIG_COLLECT_COMPONENT_TIMING
4037 end_timing(cpi, loop_filter_time);
4038#endif
Debargha Mukherjeee168a782017-08-31 12:30:10 -07004039
logangwf95c9162019-02-20 12:02:32 -08004040 if (use_restoration)
David Turnerc29e1a92018-12-06 14:10:14 +00004041 av1_loop_restoration_save_boundary_lines(&cm->cur_frame->buf, cm, 0);
Ola Hugosson1e7f2d02017-09-22 21:36:26 +02004042
logangwf95c9162019-02-20 12:02:32 -08004043 if (use_cdef) {
Yunqing Wangd1f32e62019-02-20 10:37:51 -08004044#if CONFIG_COLLECT_COMPONENT_TIMING
4045 start_timing(cpi, cdef_time);
4046#endif
Steinar Midtskogen59782122017-07-20 08:49:43 +02004047 // Find CDEF parameters
David Turnerc29e1a92018-12-06 14:10:14 +00004048 av1_cdef_search(&cm->cur_frame->buf, cpi->source, cm, xd,
Debargha Mukherjeed7338aa2017-11-04 07:34:50 -07004049 cpi->sf.fast_cdef_search);
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07004050
4051 // Apply the filter
David Turnerc29e1a92018-12-06 14:10:14 +00004052 av1_cdef_frame(&cm->cur_frame->buf, cm, xd);
Yunqing Wangd1f32e62019-02-20 10:37:51 -08004053#if CONFIG_COLLECT_COMPONENT_TIMING
4054 end_timing(cpi, cdef_time);
4055#endif
logangwf95c9162019-02-20 12:02:32 -08004056 } else {
4057 cm->cdef_info.cdef_bits = 0;
4058 cm->cdef_info.cdef_strengths[0] = 0;
4059 cm->cdef_info.nb_cdef_strengths = 1;
4060 cm->cdef_info.cdef_uv_strengths[0] = 0;
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07004061 }
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07004062
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07004063 superres_post_encode(cpi);
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07004064
Yunqing Wangd1f32e62019-02-20 10:37:51 -08004065#if CONFIG_COLLECT_COMPONENT_TIMING
4066 start_timing(cpi, loop_restoration_time);
4067#endif
logangwf95c9162019-02-20 12:02:32 -08004068 if (use_restoration) {
David Turnerc29e1a92018-12-06 14:10:14 +00004069 av1_loop_restoration_save_boundary_lines(&cm->cur_frame->buf, cm, 1);
Yaowu Xu35ee2342017-11-08 11:50:46 -08004070 av1_pick_filter_restoration(cpi->source, cpi);
4071 if (cm->rst_info[0].frame_restoration_type != RESTORE_NONE ||
4072 cm->rst_info[1].frame_restoration_type != RESTORE_NONE ||
4073 cm->rst_info[2].frame_restoration_type != RESTORE_NONE) {
Ravi Chaudharye2aa4012018-06-04 14:20:00 +05304074 if (cpi->num_workers > 1)
David Turnerc29e1a92018-12-06 14:10:14 +00004075 av1_loop_restoration_filter_frame_mt(&cm->cur_frame->buf, cm, 0,
Ravi Chaudharye2aa4012018-06-04 14:20:00 +05304076 cpi->workers, cpi->num_workers,
4077 &cpi->lr_row_sync, &cpi->lr_ctxt);
4078 else
David Turnerc29e1a92018-12-06 14:10:14 +00004079 av1_loop_restoration_filter_frame(&cm->cur_frame->buf, cm, 0,
Ravi Chaudharye2aa4012018-06-04 14:20:00 +05304080 &cpi->lr_ctxt);
Yaowu Xu35ee2342017-11-08 11:50:46 -08004081 }
logangwf95c9162019-02-20 12:02:32 -08004082 } else {
4083 cm->rst_info[0].frame_restoration_type = RESTORE_NONE;
4084 cm->rst_info[1].frame_restoration_type = RESTORE_NONE;
4085 cm->rst_info[2].frame_restoration_type = RESTORE_NONE;
Fergus Simpsond2bcbb52017-05-22 23:15:05 -07004086 }
Yunqing Wangd1f32e62019-02-20 10:37:51 -08004087#if CONFIG_COLLECT_COMPONENT_TIMING
4088 end_timing(cpi, loop_restoration_time);
4089#endif
Fergus Simpsonbc189932017-05-16 17:02:39 -07004090}
4091
David Turnerf2b334c2018-12-13 13:00:55 +00004092static void fix_interp_filter(InterpFilter *const interp_filter,
4093 const FRAME_COUNTS *const counts) {
4094 if (*interp_filter == SWITCHABLE) {
4095 // Check to see if only one of the filters is actually used
4096 int count[SWITCHABLE_FILTERS] = { 0 };
4097 int num_filters_used = 0;
4098 for (int i = 0; i < SWITCHABLE_FILTERS; ++i) {
4099 for (int j = 0; j < SWITCHABLE_FILTER_CONTEXTS; ++j)
4100 count[i] += counts->switchable_interp[j][i];
4101 num_filters_used += (count[i] > 0);
4102 }
4103 if (num_filters_used == 1) {
4104 // Only one filter is used. So set the filter at frame level
4105 for (int i = 0; i < SWITCHABLE_FILTERS; ++i) {
4106 if (count[i]) {
4107 if (i == EIGHTTAP_REGULAR) *interp_filter = i;
4108 break;
4109 }
4110 }
4111 }
4112 }
4113}
4114
David Turner996b2c12018-12-07 15:52:30 +00004115static void finalize_encoded_frame(AV1_COMP *const cpi) {
4116 AV1_COMMON *const cm = &cpi->common;
David Turner99e990e2018-12-10 12:54:26 +00004117 CurrentFrame *const current_frame = &cm->current_frame;
David Turner996b2c12018-12-07 15:52:30 +00004118
David Turner99e990e2018-12-10 12:54:26 +00004119 if (!cm->seq_params.reduced_still_picture_hdr &&
4120 encode_show_existing_frame(cm)) {
4121 RefCntBuffer *const frame_to_show =
4122 cm->ref_frame_map[cpi->existing_fb_idx_to_show];
4123
Wan-Teh Chang88cd1662019-01-14 12:38:41 -08004124 if (frame_to_show == NULL) {
David Turner99e990e2018-12-10 12:54:26 +00004125 aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
4126 "Buffer does not contain a reconstructed frame");
4127 }
Wan-Teh Chang88cd1662019-01-14 12:38:41 -08004128 assert(frame_to_show->ref_count > 0);
David Turner99e990e2018-12-10 12:54:26 +00004129 assign_frame_buffer_p(&cm->cur_frame, frame_to_show);
David Turner99e990e2018-12-10 12:54:26 +00004130 }
David Turner08f909c2018-12-18 13:29:14 +00004131
4132 if (!encode_show_existing_frame(cm) &&
4133 cm->seq_params.film_grain_params_present &&
4134 (cm->show_frame || cm->showable_frame)) {
4135 // Copy the current frame's film grain params to the its corresponding
4136 // RefCntBuffer slot.
4137 cm->cur_frame->film_grain_params = cm->film_grain_params;
4138
4139 // We must update the parameters if this is not an INTER_FRAME
4140 if (current_frame->frame_type != INTER_FRAME)
4141 cm->cur_frame->film_grain_params.update_parameters = 1;
4142
4143 // Iterate the random seed for the next frame.
4144 cm->film_grain_params.random_seed += 3381;
4145 if (cm->film_grain_params.random_seed == 0)
4146 cm->film_grain_params.random_seed = 7391;
4147 }
David Turnerf2b334c2018-12-13 13:00:55 +00004148
4149 // Initialise all tiles' contexts from the global frame context
4150 for (int tile_col = 0; tile_col < cm->tile_cols; tile_col++) {
4151 for (int tile_row = 0; tile_row < cm->tile_rows; tile_row++) {
4152 const int tile_idx = tile_row * cm->tile_cols + tile_col;
4153 cpi->tile_data[tile_idx].tctx = *cm->fc;
4154 }
4155 }
4156
4157 fix_interp_filter(&cm->interp_filter, cpi->td.counts);
David Turner996b2c12018-12-07 15:52:30 +00004158}
4159
Urvang Joshi57643372019-02-21 11:10:57 -08004160static int get_regulated_q_overshoot(AV1_COMP *const cpi, int q_low, int q_high,
4161 int top_index, int bottom_index) {
4162 const AV1_COMMON *const cm = &cpi->common;
4163 const RATE_CONTROL *const rc = &cpi->rc;
4164
4165 av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height);
4166
4167 int q_regulated =
4168 av1_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4169 AOMMAX(q_high, top_index), cm->width, cm->height);
4170
4171 int retries = 0;
4172 while (q_regulated < q_low && retries < 10) {
4173 av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height);
4174 q_regulated =
4175 av1_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4176 AOMMAX(q_high, top_index), cm->width, cm->height);
4177 retries++;
4178 }
4179 return q_regulated;
4180}
4181
4182static int get_regulated_q_undershoot(AV1_COMP *const cpi, int q_high,
4183 int top_index, int bottom_index) {
4184 const AV1_COMMON *const cm = &cpi->common;
4185 const RATE_CONTROL *const rc = &cpi->rc;
4186
4187 av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height);
4188 int q_regulated = av1_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4189 top_index, cm->width, cm->height);
4190
4191 int retries = 0;
4192 while (q_regulated > q_high && retries < 10) {
4193 av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height);
4194 q_regulated = av1_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4195 top_index, cm->width, cm->height);
4196 retries++;
4197 }
4198 return q_regulated;
4199}
4200
David Turner2f3b5df2019-01-02 14:30:50 +00004201// Called after encode_with_recode_loop() has just encoded a frame and packed
4202// its bitstream. This function works out whether we under- or over-shot
4203// our bitrate target and adjusts q as appropriate. Also decides whether
4204// or not we should do another recode loop, indicated by *loop
4205static void recode_loop_update_q(AV1_COMP *const cpi, int *const loop,
4206 int *const q, int *const q_low,
4207 int *const q_high, const int top_index,
4208 const int bottom_index,
4209 int *const undershoot_seen,
4210 int *const overshoot_seen,
4211 const int loop_at_this_size) {
4212 AV1_COMMON *const cm = &cpi->common;
4213 RATE_CONTROL *const rc = &cpi->rc;
4214
4215 int frame_over_shoot_limit = 0, frame_under_shoot_limit = 0;
4216 av1_rc_compute_frame_size_bounds(cpi, rc->this_frame_target,
4217 &frame_under_shoot_limit,
4218 &frame_over_shoot_limit);
4219 if (frame_over_shoot_limit == 0) frame_over_shoot_limit = 1;
4220
4221 if ((cm->current_frame.frame_type == KEY_FRAME) &&
4222 rc->this_key_frame_forced &&
4223 (rc->projected_frame_size < rc->max_frame_bandwidth)) {
4224 int last_q = *q;
4225 int64_t kf_err;
4226
4227 int64_t high_err_target = cpi->ambient_err;
4228 int64_t low_err_target = cpi->ambient_err >> 1;
4229
4230 if (cm->seq_params.use_highbitdepth) {
4231 kf_err = aom_highbd_get_y_sse(cpi->source, &cm->cur_frame->buf);
4232 } else {
4233 kf_err = aom_get_y_sse(cpi->source, &cm->cur_frame->buf);
4234 }
4235 // Prevent possible divide by zero error below for perfect KF
4236 kf_err += !kf_err;
4237
4238 // The key frame is not good enough or we can afford
4239 // to make it better without undue risk of popping.
4240 if ((kf_err > high_err_target &&
4241 rc->projected_frame_size <= frame_over_shoot_limit) ||
4242 (kf_err > low_err_target &&
4243 rc->projected_frame_size <= frame_under_shoot_limit)) {
4244 // Lower q_high
4245 *q_high = *q > *q_low ? *q - 1 : *q_low;
4246
4247 // Adjust Q
4248 *q = (int)((*q * high_err_target) / kf_err);
4249 *q = AOMMIN(*q, (*q_high + *q_low) >> 1);
4250 } else if (kf_err < low_err_target &&
4251 rc->projected_frame_size >= frame_under_shoot_limit) {
4252 // The key frame is much better than the previous frame
4253 // Raise q_low
4254 *q_low = *q < *q_high ? *q + 1 : *q_high;
4255
4256 // Adjust Q
4257 *q = (int)((*q * low_err_target) / kf_err);
4258 *q = AOMMIN(*q, (*q_high + *q_low + 1) >> 1);
4259 }
4260
4261 // Clamp Q to upper and lower limits:
4262 *q = clamp(*q, *q_low, *q_high);
4263
4264 *loop = *q != last_q;
4265 } else if (recode_loop_test(cpi, frame_over_shoot_limit,
4266 frame_under_shoot_limit, *q,
4267 AOMMAX(*q_high, top_index), bottom_index)) {
4268 // Is the projected frame size out of range and are we allowed
4269 // to attempt to recode.
4270 int last_q = *q;
David Turner2f3b5df2019-01-02 14:30:50 +00004271
4272 // Frame size out of permitted range:
4273 // Update correction factor & compute new Q to try...
4274 // Frame is too large
4275 if (rc->projected_frame_size > rc->this_frame_target) {
4276 // Special case if the projected size is > the max allowed.
4277 if (rc->projected_frame_size >= rc->max_frame_bandwidth)
4278 *q_high = rc->worst_quality;
4279
4280 // Raise Qlow as to at least the current value
4281 *q_low = *q < *q_high ? *q + 1 : *q_high;
4282
Urvang Joshi57643372019-02-21 11:10:57 -08004283 if (*undershoot_seen || loop_at_this_size > 2 ||
4284 (loop_at_this_size == 2 && !frame_is_intra_only(cm))) {
David Turner2f3b5df2019-01-02 14:30:50 +00004285 av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height);
4286
4287 *q = (*q_high + *q_low + 1) / 2;
Urvang Joshi57643372019-02-21 11:10:57 -08004288 } else if (loop_at_this_size == 2 && frame_is_intra_only(cm)) {
4289 const int q_mid = (*q_high + *q_low + 1) / 2;
4290 const int q_regulated = get_regulated_q_overshoot(
4291 cpi, *q_low, *q_high, top_index, bottom_index);
4292 // Get 'q' in-between 'q_mid' and 'q_regulated' for a smooth
4293 // transition between loop_at_this_size < 2 and loop_at_this_size > 2.
4294 *q = (q_mid + q_regulated + 1) / 2;
David Turner2f3b5df2019-01-02 14:30:50 +00004295 } else {
Urvang Joshi57643372019-02-21 11:10:57 -08004296 *q = get_regulated_q_overshoot(cpi, *q_low, *q_high, top_index,
4297 bottom_index);
David Turner2f3b5df2019-01-02 14:30:50 +00004298 }
4299
4300 *overshoot_seen = 1;
4301 } else {
4302 // Frame is too small
4303 *q_high = *q > *q_low ? *q - 1 : *q_low;
4304
Urvang Joshi57643372019-02-21 11:10:57 -08004305 if (*overshoot_seen || loop_at_this_size > 2 ||
4306 (loop_at_this_size == 2 && !frame_is_intra_only(cm))) {
David Turner2f3b5df2019-01-02 14:30:50 +00004307 av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height);
4308 *q = (*q_high + *q_low) / 2;
Urvang Joshi57643372019-02-21 11:10:57 -08004309 } else if (loop_at_this_size == 2 && frame_is_intra_only(cm)) {
4310 const int q_mid = (*q_high + *q_low) / 2;
4311 const int q_regulated =
4312 get_regulated_q_undershoot(cpi, *q_high, top_index, bottom_index);
4313 // Get 'q' in-between 'q_mid' and 'q_regulated' for a smooth
4314 // transition between loop_at_this_size < 2 and loop_at_this_size > 2.
4315 *q = (q_mid + q_regulated) / 2;
4316
4317 // Special case reset for qlow for constrained quality.
4318 // This should only trigger where there is very substantial
4319 // undershoot on a frame and the auto cq level is above
4320 // the user passsed in value.
4321 if (cpi->oxcf.rc_mode == AOM_CQ && q_regulated < *q_low) {
4322 *q_low = *q;
4323 }
David Turner2f3b5df2019-01-02 14:30:50 +00004324 } else {
Urvang Joshi57643372019-02-21 11:10:57 -08004325 *q = get_regulated_q_undershoot(cpi, *q_high, top_index, bottom_index);
4326
David Turner2f3b5df2019-01-02 14:30:50 +00004327 // Special case reset for qlow for constrained quality.
4328 // This should only trigger where there is very substantial
4329 // undershoot on a frame and the auto cq level is above
4330 // the user passsed in value.
4331 if (cpi->oxcf.rc_mode == AOM_CQ && *q < *q_low) {
4332 *q_low = *q;
4333 }
David Turner2f3b5df2019-01-02 14:30:50 +00004334 }
4335
4336 *undershoot_seen = 1;
4337 }
4338
4339 // Clamp Q to upper and lower limits:
4340 *q = clamp(*q, *q_low, *q_high);
4341
4342 *loop = (*q != last_q);
4343 } else {
4344 *loop = 0;
4345 }
4346}
4347
Tom Finegane4099e32018-01-23 12:01:51 -08004348static int encode_with_recode_loop(AV1_COMP *cpi, size_t *size, uint8_t *dest) {
Yaowu Xuf883b422016-08-30 14:01:10 -07004349 AV1_COMMON *const cm = &cpi->common;
Yaowu Xuc27fc142016-08-22 16:08:15 -07004350 RATE_CONTROL *const rc = &cpi->rc;
David Turner2f3b5df2019-01-02 14:30:50 +00004351 const int allow_recode = cpi->sf.recode_loop != DISALLOW_RECODE;
Yaowu Xuc27fc142016-08-22 16:08:15 -07004352
4353 set_size_independent_vars(cpi);
4354
Yaowu Xu9b0f7032017-07-31 11:01:19 -07004355 cpi->source->buf_8bit_valid = 0;
Yaowu Xu9b0f7032017-07-31 11:01:19 -07004356
David Turnerdedd8ff2019-01-23 13:59:46 +00004357 av1_setup_frame_size(cpi);
Debargha Mukherjee7166f222017-09-05 21:32:42 -07004358
David Turner2f3b5df2019-01-02 14:30:50 +00004359 int top_index = 0, bottom_index = 0;
4360 int q = 0, q_low = 0, q_high = 0;
4361 set_size_dependent_vars(cpi, &q, &bottom_index, &top_index);
4362 q_low = bottom_index;
4363 q_high = top_index;
4364
4365 // Loop variables
4366 int loop_count = 0;
4367 int loop_at_this_size = 0;
4368 int loop = 0;
4369 int overshoot_seen = 0;
4370 int undershoot_seen = 0;
Yunqing Wangd1f32e62019-02-20 10:37:51 -08004371
4372#if CONFIG_COLLECT_COMPONENT_TIMING
4373 printf("\n Encoding a frame:");
4374#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -07004375 do {
Yaowu Xuf883b422016-08-30 14:01:10 -07004376 aom_clear_system_state();
Yaowu Xuc27fc142016-08-22 16:08:15 -07004377
Urvang Joshif1fa6862018-01-08 16:39:33 -08004378 // if frame was scaled calculate global_motion_search again if already
4379 // done
David Turner2f3b5df2019-01-02 14:30:50 +00004380 if (loop_count > 0 && cpi->source && cpi->global_motion_search_done) {
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07004381 if (cpi->source->y_crop_width != cm->width ||
David Turner2f3b5df2019-01-02 14:30:50 +00004382 cpi->source->y_crop_height != cm->height) {
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07004383 cpi->global_motion_search_done = 0;
David Turner2f3b5df2019-01-02 14:30:50 +00004384 }
4385 }
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07004386 cpi->source =
4387 av1_scale_if_required(cm, cpi->unscaled_source, &cpi->scaled_source);
David Turner2f3b5df2019-01-02 14:30:50 +00004388 if (cpi->unscaled_last_source != NULL) {
Debargha Mukherjee17e7b082017-08-13 09:33:03 -07004389 cpi->last_source = av1_scale_if_required(cm, cpi->unscaled_last_source,
4390 &cpi->scaled_last_source);
David Turner2f3b5df2019-01-02 14:30:50 +00004391 }
Debargha Mukherjee17e7b082017-08-13 09:33:03 -07004392
David Turner2f3b5df2019-01-02 14:30:50 +00004393 if (!frame_is_intra_only(cm)) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07004394 if (loop_count > 0) {
4395 release_scaled_references(cpi);
4396 }
Cheng Chen46f30c72017-09-07 11:13:33 -07004397 scale_references(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07004398 }
Yaowu Xuf883b422016-08-30 14:01:10 -07004399 av1_set_quantizer(cm, q);
Yue Chena7d80482019-01-31 09:48:09 -08004400 av1_init_quantizer(cpi);
kyslov7b9d0d62018-12-21 11:12:26 -08004401
4402 av1_set_variance_partition_thresholds(cpi, q, 0);
4403
Debargha Mukherjeef48b0d22018-11-20 12:23:43 -08004404 // printf("Frame %d/%d: q = %d, frame_type = %d superres_denom = %d\n",
4405 // cm->current_frame.frame_number, cm->show_frame, q,
4406 // cm->current_frame.frame_type, cm->superres_scale_denominator);
Yaowu Xuc27fc142016-08-22 16:08:15 -07004407
David Turner2f3b5df2019-01-02 14:30:50 +00004408 if (loop_count == 0) {
4409 setup_frame(cpi);
4410 } else if (get_primary_ref_frame_buf(cm) == NULL) {
4411 // Base q-index may have changed, so we need to assign proper default coef
4412 // probs before every iteration.
Yaowu Xuf883b422016-08-30 14:01:10 -07004413 av1_default_coef_probs(cm);
Hui Su3694c832017-11-10 14:15:58 -08004414 av1_setup_frame_contexts(cm);
David Barkerfc91b392018-03-09 15:32:03 +00004415 }
Yaowu Xuc27fc142016-08-22 16:08:15 -07004416
Yaowu Xuc27fc142016-08-22 16:08:15 -07004417 if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
Yaowu Xuf883b422016-08-30 14:01:10 -07004418 av1_vaq_frame_setup(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07004419 } else if (cpi->oxcf.aq_mode == COMPLEXITY_AQ) {
Yaowu Xuf883b422016-08-30 14:01:10 -07004420 av1_setup_in_frame_q_adj(cpi);
David Turner2f3b5df2019-01-02 14:30:50 +00004421 } else if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && !allow_recode) {
4422 suppress_active_map(cpi);
4423 av1_cyclic_refresh_setup(cpi);
4424 apply_active_map(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07004425 }
David Turner2f3b5df2019-01-02 14:30:50 +00004426
Rostislav Pehlivanov3a964622018-03-14 18:00:32 +00004427 if (cm->seg.enabled) {
David Barkercab37552018-03-21 11:56:24 +00004428 if (!cm->seg.update_data && cm->prev_frame) {
Rostislav Pehlivanov3a964622018-03-14 18:00:32 +00004429 segfeatures_copy(&cm->seg, &cm->prev_frame->seg);
David Barker11c93562018-06-05 12:00:07 +01004430 } else {
4431 calculate_segdata(&cm->seg);
Yue Chend90d3432018-03-16 11:28:42 -07004432 }
David Barkercab37552018-03-21 11:56:24 +00004433 } else {
4434 memset(&cm->seg, 0, sizeof(cm->seg));
Rostislav Pehlivanov3a964622018-03-14 18:00:32 +00004435 }
David Barkercab37552018-03-21 11:56:24 +00004436 segfeatures_copy(&cm->cur_frame->seg, &cm->seg);
Yaowu Xuc27fc142016-08-22 16:08:15 -07004437
David Turner2f3b5df2019-01-02 14:30:50 +00004438 if (allow_recode) save_coding_context(cpi);
Yunqing Wangd1f32e62019-02-20 10:37:51 -08004439#if CONFIG_COLLECT_COMPONENT_TIMING
4440 start_timing(cpi, av1_encode_frame_time);
4441#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -07004442 // transform / motion compensation build reconstruction frame
Yaowu Xuf883b422016-08-30 14:01:10 -07004443 av1_encode_frame(cpi);
Yunqing Wangd1f32e62019-02-20 10:37:51 -08004444#if CONFIG_COLLECT_COMPONENT_TIMING
4445 end_timing(cpi, av1_encode_frame_time);
4446#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -07004447
Yaowu Xuf883b422016-08-30 14:01:10 -07004448 aom_clear_system_state();
Yaowu Xuc27fc142016-08-22 16:08:15 -07004449
4450 // Dummy pack of the bitstream using up to date stats to get an
4451 // accurate estimate of output frame size to determine if we need
4452 // to recode.
4453 if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF) {
Jingning Han8f661602017-08-19 08:16:50 -07004454 restore_coding_context(cpi);
Tom Finegane4099e32018-01-23 12:01:51 -08004455
David Turner996b2c12018-12-07 15:52:30 +00004456 finalize_encoded_frame(cpi);
David Turner35cba132018-12-10 15:48:15 +00004457 int largest_tile_id = 0; // Output from bitstream: unused here
4458 if (av1_pack_bitstream(cpi, dest, size, &largest_tile_id) != AOM_CODEC_OK)
Tom Finegane4099e32018-01-23 12:01:51 -08004459 return AOM_CODEC_ERROR;
Yaowu Xuc27fc142016-08-22 16:08:15 -07004460
4461 rc->projected_frame_size = (int)(*size) << 3;
4462 restore_coding_context(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07004463 }
4464
David Turner2f3b5df2019-01-02 14:30:50 +00004465 if (allow_recode && cpi->oxcf.rc_mode != AOM_Q) {
4466 // Update q and decide whether to do a recode loop
4467 recode_loop_update_q(cpi, &loop, &q, &q_low, &q_high, top_index,
4468 bottom_index, &undershoot_seen, &overshoot_seen,
4469 loop_at_this_size);
Yaowu Xuc27fc142016-08-22 16:08:15 -07004470 }
4471
4472 // Special case for overlay frame.
4473 if (rc->is_src_frame_alt_ref &&
4474 rc->projected_frame_size < rc->max_frame_bandwidth)
4475 loop = 0;
4476
David Turner2f3b5df2019-01-02 14:30:50 +00004477 if (allow_recode && !cpi->sf.gm_disable_recode &&
4478 recode_loop_test_global_motion(cpi)) {
4479 loop = 1;
Debargha Mukherjeeb98a7022016-11-15 16:07:12 -08004480 }
Debargha Mukherjeeb98a7022016-11-15 16:07:12 -08004481
Yaowu Xuc27fc142016-08-22 16:08:15 -07004482 if (loop) {
4483 ++loop_count;
4484 ++loop_at_this_size;
4485
4486#if CONFIG_INTERNAL_STATS
4487 ++cpi->tot_recode_hits;
4488#endif
4489 }
Yunqing Wangd1f32e62019-02-20 10:37:51 -08004490#if CONFIG_COLLECT_COMPONENT_TIMING
4491 if (loop) printf("\n Recoding:");
4492#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -07004493 } while (loop);
Tom Finegane4099e32018-01-23 12:01:51 -08004494
4495 return AOM_CODEC_OK;
Yaowu Xuc27fc142016-08-22 16:08:15 -07004496}
4497
Yaowu Xuc27fc142016-08-22 16:08:15 -07004498#define DUMP_RECON_FRAMES 0
4499
4500#if DUMP_RECON_FRAMES == 1
4501// NOTE(zoeliu): For debug - Output the filtered reconstructed video.
Yaowu Xuf883b422016-08-30 14:01:10 -07004502static void dump_filtered_recon_frames(AV1_COMP *cpi) {
4503 AV1_COMMON *const cm = &cpi->common;
David Turnerd2a592e2018-11-16 14:59:31 +00004504 const CurrentFrame *const current_frame = &cm->current_frame;
David Turnerc29e1a92018-12-06 14:10:14 +00004505 const YV12_BUFFER_CONFIG *recon_buf = &cm->cur_frame->buf;
Yaowu Xuc27fc142016-08-22 16:08:15 -07004506
Zoe Liub4f31032017-11-03 23:48:35 -07004507 if (recon_buf == NULL) {
David Turnerd2a592e2018-11-16 14:59:31 +00004508 printf("Frame %d is not ready.\n", current_frame->frame_number);
Zoe Liub4f31032017-11-03 23:48:35 -07004509 return;
4510 }
4511
Zoe Liu27deb382018-03-27 15:13:56 -07004512 static const int flag_list[REF_FRAMES] = { 0,
4513 AOM_LAST_FLAG,
4514 AOM_LAST2_FLAG,
4515 AOM_LAST3_FLAG,
4516 AOM_GOLD_FLAG,
4517 AOM_BWD_FLAG,
4518 AOM_ALT2_FLAG,
4519 AOM_ALT_FLAG };
Zoe Liub4f31032017-11-03 23:48:35 -07004520 printf(
4521 "\n***Frame=%d (frame_offset=%d, show_frame=%d, "
4522 "show_existing_frame=%d) "
4523 "[LAST LAST2 LAST3 GOLDEN BWD ALT2 ALT]=[",
David Turnerd2a592e2018-11-16 14:59:31 +00004524 current_frame->frame_number, current_frame->order_hint, cm->show_frame,
Zoe Liub4f31032017-11-03 23:48:35 -07004525 cm->show_existing_frame);
4526 for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
David Turnera21966b2018-12-05 14:48:49 +00004527 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
4528 const int ref_offset = buf != NULL ? (int)buf->order_hint : -1;
Urvang Joshib6f17672019-03-05 11:51:02 -08004529 printf(" %d(%c)", ref_offset,
4530 (cpi->ref_frame_flags & flag_list[ref_frame]) ? 'Y' : 'N');
Zoe Liub4f31032017-11-03 23:48:35 -07004531 }
4532 printf(" ]\n");
Zoe Liub4f31032017-11-03 23:48:35 -07004533
4534 if (!cm->show_frame) {
4535 printf("Frame %d is a no show frame, so no image dump.\n",
David Turnerd2a592e2018-11-16 14:59:31 +00004536 current_frame->frame_number);
Yaowu Xuc27fc142016-08-22 16:08:15 -07004537 return;
4538 }
4539
Zoe Liub4f31032017-11-03 23:48:35 -07004540 int h;
4541 char file_name[256] = "/tmp/enc_filtered_recon.yuv";
4542 FILE *f_recon = NULL;
4543
David Turnerd2a592e2018-11-16 14:59:31 +00004544 if (current_frame->frame_number == 0) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07004545 if ((f_recon = fopen(file_name, "wb")) == NULL) {
4546 printf("Unable to open file %s to write.\n", file_name);
4547 return;
4548 }
4549 } else {
4550 if ((f_recon = fopen(file_name, "ab")) == NULL) {
4551 printf("Unable to open file %s to append.\n", file_name);
4552 return;
4553 }
4554 }
4555 printf(
Zoe Liuf40a9572017-10-13 12:37:19 -07004556 "\nFrame=%5d, encode_update_type[%5d]=%1d, frame_offset=%d, "
4557 "show_frame=%d, show_existing_frame=%d, source_alt_ref_active=%d, "
Urvang Joshi7a890232019-03-22 17:00:31 -07004558 "refresh_alt_ref_frame=%d, "
Zoe Liuf40a9572017-10-13 12:37:19 -07004559 "y_stride=%4d, uv_stride=%4d, cm->width=%4d, cm->height=%4d\n\n",
David Turnerd2a592e2018-11-16 14:59:31 +00004560 current_frame->frame_number, cpi->twopass.gf_group.index,
Yaowu Xuc27fc142016-08-22 16:08:15 -07004561 cpi->twopass.gf_group.update_type[cpi->twopass.gf_group.index],
David Turnerd2a592e2018-11-16 14:59:31 +00004562 current_frame->order_hint, cm->show_frame, cm->show_existing_frame,
Zoe Liuf40a9572017-10-13 12:37:19 -07004563 cpi->rc.source_alt_ref_active, cpi->refresh_alt_ref_frame,
Zoe Liuf40a9572017-10-13 12:37:19 -07004564 recon_buf->y_stride, recon_buf->uv_stride, cm->width, cm->height);
Zoe Liue9b15e22017-07-19 15:53:01 -07004565#if 0
4566 int ref_frame;
4567 printf("get_ref_frame_map_idx: [");
4568 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame)
David Turnera21966b2018-12-05 14:48:49 +00004569 printf(" %d", get_ref_frame_map_idx(cm, ref_frame));
Zoe Liue9b15e22017-07-19 15:53:01 -07004570 printf(" ]\n");
Zoe Liue9b15e22017-07-19 15:53:01 -07004571#endif // 0
Yaowu Xuc27fc142016-08-22 16:08:15 -07004572
4573 // --- Y ---
4574 for (h = 0; h < cm->height; ++h) {
4575 fwrite(&recon_buf->y_buffer[h * recon_buf->y_stride], 1, cm->width,
4576 f_recon);
4577 }
4578 // --- U ---
4579 for (h = 0; h < (cm->height >> 1); ++h) {
4580 fwrite(&recon_buf->u_buffer[h * recon_buf->uv_stride], 1, (cm->width >> 1),
4581 f_recon);
4582 }
4583 // --- V ---
4584 for (h = 0; h < (cm->height >> 1); ++h) {
4585 fwrite(&recon_buf->v_buffer[h * recon_buf->uv_stride], 1, (cm->width >> 1),
4586 f_recon);
4587 }
4588
4589 fclose(f_recon);
4590}
4591#endif // DUMP_RECON_FRAMES
4592
David Turnerbc0993e2019-02-15 14:42:23 +00004593static int get_interp_filter_selected(const AV1_COMMON *const cm,
4594 MV_REFERENCE_FRAME ref,
4595 InterpFilters ifilter) {
4596 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref);
4597 if (buf == NULL) return 0;
4598 return buf->interp_filter_selected[ifilter];
4599}
Sachin Kumar Gargfd39b232019-01-03 17:41:09 +05304600
David Turnerbc0993e2019-02-15 14:42:23 +00004601static int setup_interp_filter_search_mask(AV1_COMP *cpi) {
4602 const AV1_COMMON *const cm = &cpi->common;
4603 int ref_total[REF_FRAMES] = { 0 };
4604
4605 if (cpi->common.last_frame_type == KEY_FRAME || cpi->refresh_alt_ref_frame)
4606 return 0;
4607
4608 for (MV_REFERENCE_FRAME ref = LAST_FRAME; ref <= ALTREF_FRAME; ++ref) {
4609 for (InterpFilters ifilter = EIGHTTAP_REGULAR; ifilter <= MULTITAP_SHARP;
4610 ++ifilter) {
4611 ref_total[ref] += get_interp_filter_selected(cm, ref, ifilter);
4612 }
4613 }
4614 int ref_total_total = (ref_total[LAST2_FRAME] + ref_total[LAST3_FRAME] +
4615 ref_total[GOLDEN_FRAME] + ref_total[BWDREF_FRAME] +
4616 ref_total[ALTREF2_FRAME] + ref_total[ALTREF_FRAME]);
4617
4618 int mask = 0;
4619 for (InterpFilters ifilter = EIGHTTAP_REGULAR; ifilter <= MULTITAP_SHARP;
4620 ++ifilter) {
4621 int last_score = get_interp_filter_selected(cm, LAST_FRAME, ifilter) * 30;
4622 if (ref_total[LAST_FRAME] && last_score <= ref_total[LAST_FRAME]) {
4623 int filter_score =
4624 get_interp_filter_selected(cm, LAST2_FRAME, ifilter) * 20 +
4625 get_interp_filter_selected(cm, LAST3_FRAME, ifilter) * 20 +
4626 get_interp_filter_selected(cm, GOLDEN_FRAME, ifilter) * 20 +
4627 get_interp_filter_selected(cm, BWDREF_FRAME, ifilter) * 10 +
4628 get_interp_filter_selected(cm, ALTREF2_FRAME, ifilter) * 10 +
4629 get_interp_filter_selected(cm, ALTREF_FRAME, ifilter) * 10;
4630 if (filter_score < ref_total_total) mask |= 1 << ifilter;
4631 }
Sachin Kumar Gargfd39b232019-01-03 17:41:09 +05304632 }
4633 return mask;
4634}
4635
David Turnerefed6372019-01-11 15:14:11 +00004636static int is_integer_mv(AV1_COMP *cpi, const YV12_BUFFER_CONFIG *cur_picture,
4637 const YV12_BUFFER_CONFIG *last_picture,
4638 hash_table *last_hash_table) {
4639 aom_clear_system_state();
4640 // check use hash ME
4641 int k;
4642 uint32_t hash_value_1;
4643 uint32_t hash_value_2;
4644
4645 const int block_size = 8;
4646 const double threshold_current = 0.8;
4647 const double threshold_average = 0.95;
4648 const int max_history_size = 32;
4649 int T = 0; // total block
4650 int C = 0; // match with collocated block
4651 int S = 0; // smooth region but not match with collocated block
4652 int M = 0; // match with other block
4653
4654 const int pic_width = cur_picture->y_width;
4655 const int pic_height = cur_picture->y_height;
4656 for (int i = 0; i + block_size <= pic_height; i += block_size) {
4657 for (int j = 0; j + block_size <= pic_width; j += block_size) {
4658 const int x_pos = j;
4659 const int y_pos = i;
4660 int match = 1;
4661 T++;
4662
4663 // check whether collocated block match with current
4664 uint8_t *p_cur = cur_picture->y_buffer;
4665 uint8_t *p_ref = last_picture->y_buffer;
4666 int stride_cur = cur_picture->y_stride;
4667 int stride_ref = last_picture->y_stride;
4668 p_cur += (y_pos * stride_cur + x_pos);
4669 p_ref += (y_pos * stride_ref + x_pos);
4670
4671 if (cur_picture->flags & YV12_FLAG_HIGHBITDEPTH) {
4672 uint16_t *p16_cur = CONVERT_TO_SHORTPTR(p_cur);
4673 uint16_t *p16_ref = CONVERT_TO_SHORTPTR(p_ref);
4674 for (int tmpY = 0; tmpY < block_size && match; tmpY++) {
4675 for (int tmpX = 0; tmpX < block_size && match; tmpX++) {
4676 if (p16_cur[tmpX] != p16_ref[tmpX]) {
4677 match = 0;
4678 }
4679 }
4680 p16_cur += stride_cur;
4681 p16_ref += stride_ref;
4682 }
4683 } else {
4684 for (int tmpY = 0; tmpY < block_size && match; tmpY++) {
4685 for (int tmpX = 0; tmpX < block_size && match; tmpX++) {
4686 if (p_cur[tmpX] != p_ref[tmpX]) {
4687 match = 0;
4688 }
4689 }
4690 p_cur += stride_cur;
4691 p_ref += stride_ref;
4692 }
4693 }
4694
4695 if (match) {
4696 C++;
4697 continue;
4698 }
4699
4700 if (av1_hash_is_horizontal_perfect(cur_picture, block_size, x_pos,
4701 y_pos) ||
4702 av1_hash_is_vertical_perfect(cur_picture, block_size, x_pos, y_pos)) {
4703 S++;
4704 continue;
4705 }
4706
4707 av1_get_block_hash_value(
4708 cur_picture->y_buffer + y_pos * stride_cur + x_pos, stride_cur,
4709 block_size, &hash_value_1, &hash_value_2,
4710 (cur_picture->flags & YV12_FLAG_HIGHBITDEPTH), &cpi->td.mb);
4711 // Hashing does not work for highbitdepth currently.
4712 // TODO(Roger): Make it work for highbitdepth.
4713 if (av1_use_hash_me(&cpi->common)) {
4714 if (av1_has_exact_match(last_hash_table, hash_value_1, hash_value_2)) {
4715 M++;
4716 }
4717 }
4718 }
4719 }
4720
4721 assert(T > 0);
4722 double csm_rate = ((double)(C + S + M)) / ((double)(T));
4723 double m_rate = ((double)(M)) / ((double)(T));
4724
4725 cpi->csm_rate_array[cpi->rate_index] = csm_rate;
4726 cpi->m_rate_array[cpi->rate_index] = m_rate;
4727
4728 cpi->rate_index = (cpi->rate_index + 1) % max_history_size;
4729 cpi->rate_size++;
4730 cpi->rate_size = AOMMIN(cpi->rate_size, max_history_size);
4731
4732 if (csm_rate < threshold_current) {
4733 return 0;
4734 }
4735
4736 if (C == T) {
4737 return 1;
4738 }
4739
4740 double csm_average = 0.0;
4741 double m_average = 0.0;
4742
4743 for (k = 0; k < cpi->rate_size; k++) {
4744 csm_average += cpi->csm_rate_array[k];
4745 m_average += cpi->m_rate_array[k];
4746 }
4747 csm_average /= cpi->rate_size;
4748 m_average /= cpi->rate_size;
4749
4750 if (csm_average < threshold_average) {
4751 return 0;
4752 }
4753
4754 if (M > (T - C - S) / 3) {
4755 return 1;
4756 }
4757
4758 if (csm_rate > 0.99 && m_rate > 0.01) {
4759 return 1;
4760 }
4761
4762 if (csm_average + m_average > 1.01) {
4763 return 1;
4764 }
4765
4766 return 0;
4767}
4768
David Turner73245762019-02-11 16:42:34 +00004769// Refresh reference frame buffers according to refresh_frame_flags.
4770static void refresh_reference_frames(AV1_COMP *cpi) {
4771 AV1_COMMON *const cm = &cpi->common;
4772 // All buffers are refreshed for shown keyframes and S-frames.
4773
4774 for (int ref_frame = 0; ref_frame < REF_FRAMES; ref_frame++) {
4775 if (((cm->current_frame.refresh_frame_flags >> ref_frame) & 1) == 1) {
4776 assign_frame_buffer_p(&cm->ref_frame_map[ref_frame], cm->cur_frame);
4777 }
4778 }
4779}
4780
4781static int encode_frame_to_data_rate(AV1_COMP *cpi, size_t *size,
4782 uint8_t *dest) {
Yaowu Xuf883b422016-08-30 14:01:10 -07004783 AV1_COMMON *const cm = &cpi->common;
Urvang Joshi20cf30e2018-07-19 02:33:58 -07004784 SequenceHeader *const seq_params = &cm->seq_params;
David Turnerd2a592e2018-11-16 14:59:31 +00004785 CurrentFrame *const current_frame = &cm->current_frame;
Yaowu Xuf883b422016-08-30 14:01:10 -07004786 const AV1EncoderConfig *const oxcf = &cpi->oxcf;
Yaowu Xuc27fc142016-08-22 16:08:15 -07004787 struct segmentation *const seg = &cm->seg;
Thomas Davies4822e142017-10-10 11:30:36 +01004788
Yunqing Wangd1f32e62019-02-20 10:37:51 -08004789#if CONFIG_COLLECT_COMPONENT_TIMING
4790 start_timing(cpi, encode_frame_to_data_rate_time);
4791#endif
4792
Fangwen Fu8d164de2016-12-14 13:40:54 -08004793 // frame type has been decided outside of this function call
David Turnerd2a592e2018-11-16 14:59:31 +00004794 cm->cur_frame->frame_type = current_frame->frame_type;
Debargha Mukherjee07a7c1f2018-03-21 17:39:13 -07004795
Yunqing Wang9612d552018-05-15 14:58:30 -07004796 cm->large_scale_tile = cpi->oxcf.large_scale_tile;
4797 cm->single_tile_decoding = cpi->oxcf.single_tile_decoding;
Yunqing Wang9612d552018-05-15 14:58:30 -07004798
sarahparker21dbca42018-03-30 17:43:44 -07004799 cm->allow_ref_frame_mvs &= frame_might_allow_ref_frame_mvs(cm);
Yunqing Wangd48fb162018-06-15 10:55:28 -07004800 // cm->allow_ref_frame_mvs needs to be written into the frame header while
4801 // cm->large_scale_tile is 1, therefore, "cm->large_scale_tile=1" case is
4802 // separated from frame_might_allow_ref_frame_mvs().
4803 cm->allow_ref_frame_mvs &= !cm->large_scale_tile;
4804
Debargha Mukherjee1d7217e2018-03-26 13:32:13 -07004805 cm->allow_warped_motion =
Debargha Mukherjeea5b810a2018-03-26 19:19:55 -07004806 cpi->oxcf.allow_warped_motion && frame_might_allow_warped_motion(cm);
Yaowu Xuc27fc142016-08-22 16:08:15 -07004807
Sachin Kumar Gargfd39b232019-01-03 17:41:09 +05304808 cm->last_frame_type = current_frame->frame_type;
4809 if (cpi->oxcf.pass == 2 && cpi->sf.adaptive_interp_filter_search)
4810 cpi->sf.interp_filter_search_mask = setup_interp_filter_search_mask(cpi);
4811
Yunqing Wangc3e21ec2019-02-28 16:29:27 -08004812 cpi->two_pass_partition_search = cpi->sf.two_pass_partition_search &&
4813 !cpi->partition_search_skippable_frame;
Yunqing Wangc3e21ec2019-02-28 16:29:27 -08004814
Sarah Parker33005522018-07-27 14:46:25 -07004815 if (encode_show_existing_frame(cm)) {
Jingning Han8f661602017-08-19 08:16:50 -07004816 restore_coding_context(cpi);
Zoe Liub4f31032017-11-03 23:48:35 -07004817
David Turner996b2c12018-12-07 15:52:30 +00004818 finalize_encoded_frame(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07004819 // Build the bitstream
David Turner35cba132018-12-10 15:48:15 +00004820 int largest_tile_id = 0; // Output from bitstream: unused here
4821 if (av1_pack_bitstream(cpi, dest, size, &largest_tile_id) != AOM_CODEC_OK)
Tom Finegane4099e32018-01-23 12:01:51 -08004822 return AOM_CODEC_ERROR;
Yaowu Xuc27fc142016-08-22 16:08:15 -07004823
David Turner90311862018-11-29 13:34:36 +00004824 if (seq_params->frame_id_numbers_present_flag &&
4825 current_frame->frame_type == KEY_FRAME) {
4826 // Displaying a forward key-frame, so reset the ref buffer IDs
4827 int display_frame_id = cm->ref_frame_id[cpi->existing_fb_idx_to_show];
4828 for (int i = 0; i < REF_FRAMES; i++)
4829 cm->ref_frame_id[i] = display_frame_id;
4830 }
4831
Debargha Mukherjeef2e5bb32018-03-26 14:35:24 -07004832 cpi->seq_params_locked = 1;
4833
Yaowu Xuc27fc142016-08-22 16:08:15 -07004834#if DUMP_RECON_FRAMES == 1
4835 // NOTE(zoeliu): For debug - Output the filtered reconstructed video.
4836 dump_filtered_recon_frames(cpi);
4837#endif // DUMP_RECON_FRAMES
4838
David Turner73245762019-02-11 16:42:34 +00004839 // NOTE: Save the new show frame buffer index for --test-code=warn, i.e.,
4840 // for the purpose to verify no mismatch between encoder and decoder.
4841 if (cm->show_frame) cpi->last_show_frame_buf = cm->cur_frame;
Yaowu Xuc27fc142016-08-22 16:08:15 -07004842
David Turner73245762019-02-11 16:42:34 +00004843 refresh_reference_frames(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07004844
Yaowu Xuc27fc142016-08-22 16:08:15 -07004845 // Since we allocate a spot for the OVERLAY frame in the gf group, we need
4846 // to do post-encoding update accordingly.
4847 if (cpi->rc.is_src_frame_alt_ref) {
Debargha Mukherjee7166f222017-09-05 21:32:42 -07004848 av1_set_target_rate(cpi, cm->width, cm->height);
Yaowu Xuf883b422016-08-30 14:01:10 -07004849 av1_rc_postencode_update(cpi, *size);
Yaowu Xuc27fc142016-08-22 16:08:15 -07004850 }
Yaowu Xuc27fc142016-08-22 16:08:15 -07004851
David Turnerd2a592e2018-11-16 14:59:31 +00004852 ++current_frame->frame_number;
Yaowu Xuc27fc142016-08-22 16:08:15 -07004853
Tom Finegane4099e32018-01-23 12:01:51 -08004854 return AOM_CODEC_OK;
Yaowu Xuc27fc142016-08-22 16:08:15 -07004855 }
Yaowu Xuc27fc142016-08-22 16:08:15 -07004856
David Turnerefed6372019-01-11 15:14:11 +00004857 // Work out whether to force_integer_mv this frame
4858 if (oxcf->pass != 1 && cpi->common.allow_screen_content_tools &&
4859 !frame_is_intra_only(cm)) {
4860 if (cpi->common.seq_params.force_integer_mv == 2) {
4861 // Adaptive mode: see what previous frame encoded did
4862 if (cpi->unscaled_last_source != NULL) {
4863 cm->cur_frame_force_integer_mv =
4864 is_integer_mv(cpi, cpi->source, cpi->unscaled_last_source,
4865 cpi->previous_hash_table);
4866 } else {
4867 cpi->common.cur_frame_force_integer_mv = 0;
4868 }
4869 } else {
4870 cpi->common.cur_frame_force_integer_mv =
4871 cpi->common.seq_params.force_integer_mv;
4872 }
4873 } else {
4874 cpi->common.cur_frame_force_integer_mv = 0;
4875 }
4876
Yaowu Xuc27fc142016-08-22 16:08:15 -07004877 // Set default state for segment based loop filter update flags.
4878 cm->lf.mode_ref_delta_update = 0;
4879
Yaowu Xuc27fc142016-08-22 16:08:15 -07004880 // Set various flags etc to special state if it is a key frame.
Tarek AMARAc9813852018-03-05 18:40:18 -05004881 if (frame_is_intra_only(cm) || frame_is_sframe(cm)) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07004882 // Reset the loop filter deltas and segmentation map.
Yaowu Xuf883b422016-08-30 14:01:10 -07004883 av1_reset_segment_features(cm);
Yaowu Xuc27fc142016-08-22 16:08:15 -07004884
4885 // If segmentation is enabled force a map update for key frames.
4886 if (seg->enabled) {
4887 seg->update_map = 1;
4888 seg->update_data = 1;
4889 }
4890
4891 // The alternate reference frame cannot be active for a key frame.
4892 cpi->rc.source_alt_ref_active = 0;
Yaowu Xuc27fc142016-08-22 16:08:15 -07004893 }
Thomas Daviesaf6df172016-11-09 14:04:18 +00004894 if (cpi->oxcf.mtu == 0) {
4895 cm->num_tg = cpi->oxcf.num_tile_groups;
4896 } else {
Yaowu Xu859a5272016-11-10 15:32:21 -08004897 // Use a default value for the purposes of weighting costs in probability
4898 // updates
Thomas Daviesaf6df172016-11-09 14:04:18 +00004899 cm->num_tg = DEFAULT_MAX_NUM_TG;
4900 }
Yaowu Xuc27fc142016-08-22 16:08:15 -07004901
4902 // For 1 pass CBR, check if we are dropping this frame.
4903 // Never drop on key frame.
Yaowu Xuf883b422016-08-30 14:01:10 -07004904 if (oxcf->pass == 0 && oxcf->rc_mode == AOM_CBR &&
David Turnerd2a592e2018-11-16 14:59:31 +00004905 current_frame->frame_type != KEY_FRAME) {
Yaowu Xuf883b422016-08-30 14:01:10 -07004906 if (av1_rc_drop_frame(cpi)) {
4907 av1_rc_postencode_update_drop_frame(cpi);
David Turnera4c96252019-01-11 16:36:39 +00004908 release_scaled_references(cpi);
Tom Finegane4099e32018-01-23 12:01:51 -08004909 return AOM_CODEC_OK;
Yaowu Xuc27fc142016-08-22 16:08:15 -07004910 }
4911 }
4912
Yaowu Xuf883b422016-08-30 14:01:10 -07004913 aom_clear_system_state();
Yaowu Xuc27fc142016-08-22 16:08:15 -07004914
4915#if CONFIG_INTERNAL_STATS
4916 memset(cpi->mode_chosen_counts, 0,
4917 MAX_MODES * sizeof(*cpi->mode_chosen_counts));
4918#endif
4919
Urvang Joshi20cf30e2018-07-19 02:33:58 -07004920 if (seq_params->frame_id_numbers_present_flag) {
Arild Fuldseth (arilfuld)5114b7b2016-11-09 13:32:54 +01004921 /* Non-normative definition of current_frame_id ("frame counter" with
Johann123e8a62017-12-28 14:40:49 -08004922 * wraparound) */
Arild Fuldseth (arilfuld)5114b7b2016-11-09 13:32:54 +01004923 if (cm->current_frame_id == -1) {
David Barker49a76562016-12-07 14:50:21 +00004924 int lsb, msb;
Yaowu Xud3e7c682017-12-21 14:08:25 -08004925 /* quasi-random initialization of current_frame_id for a key frame */
Alex Conversef77fd0b2017-04-20 11:00:24 -07004926 if (cpi->source->flags & YV12_FLAG_HIGHBITDEPTH) {
4927 lsb = CONVERT_TO_SHORTPTR(cpi->source->y_buffer)[0] & 0xff;
4928 msb = CONVERT_TO_SHORTPTR(cpi->source->y_buffer)[1] & 0xff;
David Barker49a76562016-12-07 14:50:21 +00004929 } else {
Alex Conversef77fd0b2017-04-20 11:00:24 -07004930 lsb = cpi->source->y_buffer[0] & 0xff;
4931 msb = cpi->source->y_buffer[1] & 0xff;
David Barker49a76562016-12-07 14:50:21 +00004932 }
David Turner760a2f42018-12-07 15:25:36 +00004933 cm->current_frame_id =
4934 ((msb << 8) + lsb) % (1 << seq_params->frame_id_length);
Tarek AMARAc9813852018-03-05 18:40:18 -05004935
4936 // S_frame is meant for stitching different streams of different
4937 // resolutions together, so current_frame_id must be the
4938 // same across different streams of the same content current_frame_id
4939 // should be the same and not random. 0x37 is a chosen number as start
4940 // point
4941 if (cpi->oxcf.sframe_enabled) cm->current_frame_id = 0x37;
Arild Fuldseth (arilfuld)5114b7b2016-11-09 13:32:54 +01004942 } else {
4943 cm->current_frame_id =
David Turner760a2f42018-12-07 15:25:36 +00004944 (cm->current_frame_id + 1 + (1 << seq_params->frame_id_length)) %
4945 (1 << seq_params->frame_id_length);
Arild Fuldseth (arilfuld)5114b7b2016-11-09 13:32:54 +01004946 }
4947 }
Arild Fuldseth (arilfuld)5114b7b2016-11-09 13:32:54 +01004948
Hui Su483a8452018-02-26 12:28:48 -08004949 switch (cpi->oxcf.cdf_update_mode) {
4950 case 0: // No CDF update for any frames(4~6% compression loss).
4951 cm->disable_cdf_update = 1;
4952 break;
4953 case 1: // Enable CDF update for all frames.
4954 cm->disable_cdf_update = 0;
4955 break;
4956 case 2:
4957 // Strategically determine at which frames to do CDF update.
4958 // Currently only enable CDF update for all-intra and no-show frames(1.5%
4959 // compression loss).
4960 // TODO(huisu@google.com): design schemes for various trade-offs between
4961 // compression quality and decoding speed.
Hui Sub1b76b32018-02-27 15:24:48 -08004962 cm->disable_cdf_update =
4963 (frame_is_intra_only(cm) || !cm->show_frame) ? 0 : 1;
Hui Su483a8452018-02-26 12:28:48 -08004964 break;
4965 }
Urvang Joshi20cf30e2018-07-19 02:33:58 -07004966 cm->timing_info_present &= !seq_params->reduced_still_picture_hdr;
Hui Su483a8452018-02-26 12:28:48 -08004967
Yunqing Wangd1f32e62019-02-20 10:37:51 -08004968#if CONFIG_COLLECT_COMPONENT_TIMING
4969 start_timing(cpi, encode_with_recode_loop_time);
4970#endif
David Turner2f3b5df2019-01-02 14:30:50 +00004971 if (encode_with_recode_loop(cpi, size, dest) != AOM_CODEC_OK)
4972 return AOM_CODEC_ERROR;
Yunqing Wangd1f32e62019-02-20 10:37:51 -08004973#if CONFIG_COLLECT_COMPONENT_TIMING
4974 end_timing(cpi, encode_with_recode_loop_time);
4975#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -07004976
4977#ifdef OUTPUT_YUV_SKINMAP
David Turnerd2a592e2018-11-16 14:59:31 +00004978 if (cpi->common.current_frame.frame_number > 1) {
Yaowu Xuf883b422016-08-30 14:01:10 -07004979 av1_compute_skin_map(cpi, yuv_skinmap_file);
Yaowu Xuc27fc142016-08-22 16:08:15 -07004980 }
4981#endif // OUTPUT_YUV_SKINMAP
4982
4983 // Special case code to reduce pulsing when key frames are forced at a
4984 // fixed interval. Note the reconstruction error if it is the frame before
4985 // the force key frame
4986 if (cpi->rc.next_key_frame_forced && cpi->rc.frames_to_key == 1) {
Urvang Joshi20cf30e2018-07-19 02:33:58 -07004987 if (seq_params->use_highbitdepth) {
Jack Haughtonddb80602018-11-21 16:41:49 +00004988 cpi->ambient_err = aom_highbd_get_y_sse(cpi->source, &cm->cur_frame->buf);
Yaowu Xuc27fc142016-08-22 16:08:15 -07004989 } else {
Jack Haughtonddb80602018-11-21 16:41:49 +00004990 cpi->ambient_err = aom_get_y_sse(cpi->source, &cm->cur_frame->buf);
Yaowu Xuc27fc142016-08-22 16:08:15 -07004991 }
Yaowu Xuc27fc142016-08-22 16:08:15 -07004992 }
4993
David Turnerc29e1a92018-12-06 14:10:14 +00004994 cm->cur_frame->buf.color_primaries = seq_params->color_primaries;
4995 cm->cur_frame->buf.transfer_characteristics =
Urvang Joshi20cf30e2018-07-19 02:33:58 -07004996 seq_params->transfer_characteristics;
David Turnerc29e1a92018-12-06 14:10:14 +00004997 cm->cur_frame->buf.matrix_coefficients = seq_params->matrix_coefficients;
4998 cm->cur_frame->buf.monochrome = seq_params->monochrome;
4999 cm->cur_frame->buf.chroma_sample_position =
Urvang Joshi20cf30e2018-07-19 02:33:58 -07005000 seq_params->chroma_sample_position;
David Turnerc29e1a92018-12-06 14:10:14 +00005001 cm->cur_frame->buf.color_range = seq_params->color_range;
5002 cm->cur_frame->buf.render_width = cm->render_width;
5003 cm->cur_frame->buf.render_height = cm->render_height;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005004
Sebastien Alaiwan365e6442017-10-16 11:35:00 +02005005 // TODO(zoeliu): For non-ref frames, loop filtering may need to be turned
5006 // off.
Yaowu Xuc27fc142016-08-22 16:08:15 -07005007
5008 // Pick the loop filter level for the frame.
Cheng Chen68dc9142018-05-02 17:46:28 -07005009 if (!cm->allow_intrabc) {
David Barker218556e2018-02-14 14:23:12 +00005010 loopfilter_frame(cpi, cm);
Hui Su06463e42018-02-23 22:17:36 -08005011 } else {
Hui Su06463e42018-02-23 22:17:36 -08005012 cm->lf.filter_level[0] = 0;
5013 cm->lf.filter_level[1] = 0;
David Turnerebf96f42018-11-14 16:57:57 +00005014 cm->cdef_info.cdef_bits = 0;
5015 cm->cdef_info.cdef_strengths[0] = 0;
5016 cm->cdef_info.nb_cdef_strengths = 1;
5017 cm->cdef_info.cdef_uv_strengths[0] = 0;
Hui Su06463e42018-02-23 22:17:36 -08005018 cm->rst_info[0].frame_restoration_type = RESTORE_NONE;
5019 cm->rst_info[1].frame_restoration_type = RESTORE_NONE;
5020 cm->rst_info[2].frame_restoration_type = RESTORE_NONE;
Hui Su06463e42018-02-23 22:17:36 -08005021 }
David Barker218556e2018-02-14 14:23:12 +00005022
5023 // TODO(debargha): Fix mv search range on encoder side
David Turnerc29e1a92018-12-06 14:10:14 +00005024 // aom_extend_frame_inner_borders(&cm->cur_frame->buf, av1_num_planes(cm));
5025 aom_extend_frame_borders(&cm->cur_frame->buf, av1_num_planes(cm));
Yaowu Xuc27fc142016-08-22 16:08:15 -07005026
Wei-Ting Lin01d4d8f2017-08-03 17:04:12 -07005027#ifdef OUTPUT_YUV_REC
David Turnerc29e1a92018-12-06 14:10:14 +00005028 aom_write_one_yuv_frame(cm, &cm->cur_frame->buf);
Wei-Ting Lin01d4d8f2017-08-03 17:04:12 -07005029#endif
5030
David Turner996b2c12018-12-07 15:52:30 +00005031 finalize_encoded_frame(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005032 // Build the bitstream
David Turner35cba132018-12-10 15:48:15 +00005033 int largest_tile_id = 0; // Output from pack_bitstream
Yunqing Wangd1f32e62019-02-20 10:37:51 -08005034#if CONFIG_COLLECT_COMPONENT_TIMING
5035 start_timing(cpi, av1_pack_bitstream_final_time);
5036#endif
David Turner35cba132018-12-10 15:48:15 +00005037 if (av1_pack_bitstream(cpi, dest, size, &largest_tile_id) != AOM_CODEC_OK)
Tom Finegane4099e32018-01-23 12:01:51 -08005038 return AOM_CODEC_ERROR;
Yunqing Wangd1f32e62019-02-20 10:37:51 -08005039#if CONFIG_COLLECT_COMPONENT_TIMING
5040 end_timing(cpi, av1_pack_bitstream_final_time);
5041#endif
Yaowu Xuc27fc142016-08-22 16:08:15 -07005042
Debargha Mukherjeef2e5bb32018-03-26 14:35:24 -07005043 cpi->seq_params_locked = 1;
5044
David Turner996b2c12018-12-07 15:52:30 +00005045 // Update reference frame ids for reference frames this frame will overwrite
Urvang Joshi20cf30e2018-07-19 02:33:58 -07005046 if (seq_params->frame_id_numbers_present_flag) {
David Turner996b2c12018-12-07 15:52:30 +00005047 for (int i = 0; i < REF_FRAMES; i++) {
5048 if ((current_frame->refresh_frame_flags >> i) & 1) {
Arild Fuldseth (arilfuld)5114b7b2016-11-09 13:32:54 +01005049 cm->ref_frame_id[i] = cm->current_frame_id;
5050 }
5051 }
5052 }
Arild Fuldseth (arilfuld)5114b7b2016-11-09 13:32:54 +01005053
Yaowu Xuc27fc142016-08-22 16:08:15 -07005054#if DUMP_RECON_FRAMES == 1
5055 // NOTE(zoeliu): For debug - Output the filtered reconstructed video.
Zoe Liub4f31032017-11-03 23:48:35 -07005056 dump_filtered_recon_frames(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005057#endif // DUMP_RECON_FRAMES
5058
Soo-Chul Han934af352017-10-15 15:21:51 -04005059 if (cm->seg.enabled) {
5060 if (cm->seg.update_map) {
5061 update_reference_segmentation_map(cpi);
Yue Chend90d3432018-03-16 11:28:42 -07005062 } else if (cm->last_frame_seg_map) {
David Turnerb757ce02018-11-12 15:01:28 +00005063 memcpy(cm->cur_frame->seg_map, cm->last_frame_seg_map,
Soo-Chul Han934af352017-10-15 15:21:51 -04005064 cm->mi_cols * cm->mi_rows * sizeof(uint8_t));
5065 }
5066 }
Yaowu Xuc27fc142016-08-22 16:08:15 -07005067
5068 if (frame_is_intra_only(cm) == 0) {
5069 release_scaled_references(cpi);
5070 }
5071
David Turner73245762019-02-11 16:42:34 +00005072 // NOTE: Save the new show frame buffer index for --test-code=warn, i.e.,
5073 // for the purpose to verify no mismatch between encoder and decoder.
5074 if (cm->show_frame) cpi->last_show_frame_buf = cm->cur_frame;
5075
5076 refresh_reference_frames(cpi);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005077
Debargha Mukherjee5802ebe2016-12-21 04:17:24 -08005078#if CONFIG_ENTROPY_STATS
Yue Chencc6a6ef2018-05-21 16:21:05 -07005079 av1_accumulate_frame_counts(&aggregate_fc, &cpi->counts);
Debargha Mukherjee5802ebe2016-12-21 04:17:24 -08005080#endif // CONFIG_ENTROPY_STATS
Yaowu Xuc27fc142016-08-22 16:08:15 -07005081
Hui Sudc54be62018-03-14 19:14:28 -07005082 if (cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD) {
David Turner35cba132018-12-10 15:48:15 +00005083 *cm->fc = cpi->tile_data[largest_tile_id].tctx;
Hui Sudc54be62018-03-14 19:14:28 -07005084 av1_reset_cdf_symbol_counters(cm->fc);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005085 }
David Turnera4c96252019-01-11 16:36:39 +00005086 if (!cm->large_scale_tile) {
5087 cm->cur_frame->frame_context = *cm->fc;
5088 }
5089#define EXT_TILE_DEBUG 0
5090#if EXT_TILE_DEBUG
5091 if (cm->large_scale_tile && oxcf->pass == 2) {
5092 char fn[20] = "./fc";
5093 fn[4] = current_frame->frame_number / 100 + '0';
5094 fn[5] = (current_frame->frame_number % 100) / 10 + '0';
5095 fn[6] = (current_frame->frame_number % 10) + '0';
5096 fn[7] = '\0';
5097 av1_print_frame_contexts(cm->fc, fn);
5098 }
5099#endif // EXT_TILE_DEBUG
5100#undef EXT_TILE_DEBUG
Yaowu Xuc27fc142016-08-22 16:08:15 -07005101
Yunqing Wangd1f32e62019-02-20 10:37:51 -08005102#if CONFIG_COLLECT_COMPONENT_TIMING
5103 end_timing(cpi, encode_frame_to_data_rate_time);
5104
5105 // Print out timing information.
5106 int i;
chiyotsai9c484b32019-03-07 16:01:50 -08005107 fprintf(stderr, "\n Frame number: %d, Frame type: %s, Show Frame: %d\n",
Yunqing Wangd1f32e62019-02-20 10:37:51 -08005108 cm->current_frame.frame_number,
chiyotsai9c484b32019-03-07 16:01:50 -08005109 get_frame_type_enum(cm->current_frame.frame_type), cm->show_frame);
Yunqing Wangd1f32e62019-02-20 10:37:51 -08005110 for (i = 0; i < kTimingComponents; i++) {
5111 cpi->component_time[i] += cpi->frame_component_time[i];
5112 fprintf(stderr, " %s: %" PRId64 " us (total: %" PRId64 " us)\n",
5113 get_component_name(i), cpi->frame_component_time[i],
5114 cpi->component_time[i]);
5115 cpi->frame_component_time[i] = 0;
5116 }
5117#endif
5118
Sachin Kumar Gargfd39b232019-01-03 17:41:09 +05305119 cm->last_frame_type = current_frame->frame_type;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005120
Yaowu Xuf883b422016-08-30 14:01:10 -07005121 av1_rc_postencode_update(cpi, *size);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005122
David Turnerefed6372019-01-11 15:14:11 +00005123 // Store encoded frame's hash table for is_integer_mv() next time
5124 if (oxcf->pass != 1 && cpi->common.allow_screen_content_tools) {
5125 cpi->previous_hash_table = &cm->cur_frame->hash_table;
5126 }
5127
Yaowu Xuc27fc142016-08-22 16:08:15 -07005128 // Clear the one shot update flags for segmentation map and mode/ref loop
5129 // filter deltas.
5130 cm->seg.update_map = 0;
5131 cm->seg.update_data = 0;
5132 cm->lf.mode_ref_delta_update = 0;
5133
Wei-Ting Linfb7dc062018-06-28 18:26:13 -07005134 // A droppable frame might not be shown but it always
5135 // takes a space in the gf group. Therefore, even when
5136 // it is not shown, we still need update the count down.
5137
Yaowu Xuc27fc142016-08-22 16:08:15 -07005138 if (cm->show_frame) {
Urvang Joshif1fa6862018-01-08 16:39:33 -08005139 // TODO(zoeliu): We may only swamp mi and prev_mi for those frames that
5140 // are
Sebastien Alaiwan365e6442017-10-16 11:35:00 +02005141 // being used as reference.
Cheng Chen46f30c72017-09-07 11:13:33 -07005142 swap_mi_and_prev_mi(cm);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005143 // Don't increment frame counters if this was an altref buffer
5144 // update not a real frame
Wei-Ting Lin96ee0eb2018-06-22 15:27:22 -07005145
David Turnerd2a592e2018-11-16 14:59:31 +00005146 ++current_frame->frame_number;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005147 }
5148
Tom Finegane4099e32018-01-23 12:01:51 -08005149 return AOM_CODEC_OK;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005150}
5151
David Turner056f7cd2019-01-07 17:48:13 +00005152int av1_encode(AV1_COMP *const cpi, uint8_t *const dest,
David Turnercb5e36f2019-01-17 17:15:25 +00005153 const EncodeFrameInput *const frame_input,
David Turner056f7cd2019-01-07 17:48:13 +00005154 const EncodeFrameParams *const frame_params,
5155 EncodeFrameResults *const frame_results) {
David Turner07dbd8e2019-01-08 17:16:25 +00005156 AV1_COMMON *const cm = &cpi->common;
David Turnera7f133c2019-01-22 14:47:16 +00005157 CurrentFrame *const current_frame = &cm->current_frame;
David Turner07dbd8e2019-01-08 17:16:25 +00005158
David Turnercb5e36f2019-01-17 17:15:25 +00005159 cpi->unscaled_source = frame_input->source;
5160 cpi->source = frame_input->source;
5161 cpi->unscaled_last_source = frame_input->last_source;
David Turner056f7cd2019-01-07 17:48:13 +00005162
David Turner6e8b4d92019-02-18 15:01:33 +00005163 current_frame->refresh_frame_flags = frame_params->refresh_frame_flags;
David Turner07dbd8e2019-01-08 17:16:25 +00005164 cm->error_resilient_mode = frame_params->error_resilient_mode;
David Turnera7f133c2019-01-22 14:47:16 +00005165 cm->primary_ref_frame = frame_params->primary_ref_frame;
David Turner475a3132019-01-18 15:17:17 +00005166 cm->current_frame.frame_type = frame_params->frame_type;
David Turnerdedd8ff2019-01-23 13:59:46 +00005167 cm->show_frame = frame_params->show_frame;
David Turner07dbd8e2019-01-08 17:16:25 +00005168 cpi->ref_frame_flags = frame_params->ref_frame_flags;
David Turner04b70d82019-01-24 15:39:19 +00005169 cpi->speed = frame_params->speed;
David Turnere86ee0d2019-02-18 17:16:28 +00005170 cm->show_existing_frame = frame_params->show_existing_frame;
5171 cpi->existing_fb_idx_to_show = frame_params->existing_fb_idx_to_show;
David Turner07dbd8e2019-01-08 17:16:25 +00005172
David Turner73245762019-02-11 16:42:34 +00005173 memcpy(cm->remapped_ref_idx, frame_params->remapped_ref_idx,
5174 REF_FRAMES * sizeof(*cm->remapped_ref_idx));
5175
David Turnerfe3aecb2019-02-06 14:42:42 +00005176 cpi->refresh_last_frame = frame_params->refresh_last_frame;
5177 cpi->refresh_golden_frame = frame_params->refresh_golden_frame;
5178 cpi->refresh_bwd_ref_frame = frame_params->refresh_bwd_ref_frame;
5179 cpi->refresh_alt2_ref_frame = frame_params->refresh_alt2_ref_frame;
5180 cpi->refresh_alt_ref_frame = frame_params->refresh_alt_ref_frame;
5181
David Turnera7f133c2019-01-22 14:47:16 +00005182 if (current_frame->frame_type == KEY_FRAME && cm->show_frame)
5183 current_frame->frame_number = 0;
5184
5185 if (cm->show_existing_frame) {
5186 current_frame->order_hint = cm->cur_frame->order_hint;
5187 } else {
5188 current_frame->order_hint =
5189 current_frame->frame_number + frame_params->order_offset;
5190 current_frame->order_hint %=
5191 (1 << (cm->seq_params.order_hint_info.order_hint_bits_minus_1 + 1));
5192 }
5193
David Turnercb5e36f2019-01-17 17:15:25 +00005194 if (cpi->oxcf.pass == 1) {
5195 av1_first_pass(cpi, frame_input->ts_duration);
5196 } else if (cpi->oxcf.pass == 0 || cpi->oxcf.pass == 2) {
David Turner73245762019-02-11 16:42:34 +00005197 if (encode_frame_to_data_rate(cpi, &frame_results->size, dest) !=
5198 AOM_CODEC_OK) {
David Turnercb5e36f2019-01-17 17:15:25 +00005199 return AOM_CODEC_ERROR;
5200 }
5201 } else {
David Turner056f7cd2019-01-07 17:48:13 +00005202 return AOM_CODEC_ERROR;
5203 }
5204
5205 return AOM_CODEC_OK;
5206}
5207
Neil Birkbecka2893ab2018-06-08 14:45:13 -07005208#if CONFIG_DENOISE
5209static int apply_denoise_2d(AV1_COMP *cpi, YV12_BUFFER_CONFIG *sd,
5210 int block_size, float noise_level,
5211 int64_t time_stamp, int64_t end_time) {
5212 AV1_COMMON *const cm = &cpi->common;
5213 if (!cpi->denoise_and_model) {
Urvang Joshi20cf30e2018-07-19 02:33:58 -07005214 cpi->denoise_and_model = aom_denoise_and_model_alloc(
5215 cm->seq_params.bit_depth, block_size, noise_level);
Neil Birkbecka2893ab2018-06-08 14:45:13 -07005216 if (!cpi->denoise_and_model) {
5217 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
5218 "Error allocating denoise and model");
5219 return -1;
5220 }
5221 }
5222 if (!cpi->film_grain_table) {
5223 cpi->film_grain_table = aom_malloc(sizeof(*cpi->film_grain_table));
5224 if (!cpi->film_grain_table) {
5225 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
5226 "Error allocating grain table");
5227 return -1;
5228 }
5229 memset(cpi->film_grain_table, 0, sizeof(*cpi->film_grain_table));
5230 }
5231 if (aom_denoise_and_model_run(cpi->denoise_and_model, sd,
5232 &cm->film_grain_params)) {
5233 if (cm->film_grain_params.apply_grain) {
5234 aom_film_grain_table_append(cpi->film_grain_table, time_stamp, end_time,
5235 &cm->film_grain_params);
5236 }
5237 }
5238 return 0;
5239}
5240#endif
5241
James Zern3e2613b2017-03-30 23:14:40 -07005242int av1_receive_raw_frame(AV1_COMP *cpi, aom_enc_frame_flags_t frame_flags,
Yaowu Xuf883b422016-08-30 14:01:10 -07005243 YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
5244 int64_t end_time) {
5245 AV1_COMMON *const cm = &cpi->common;
Urvang Joshi20cf30e2018-07-19 02:33:58 -07005246 const SequenceHeader *const seq_params = &cm->seq_params;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005247 int res = 0;
5248 const int subsampling_x = sd->subsampling_x;
5249 const int subsampling_y = sd->subsampling_y;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005250 const int use_highbitdepth = (sd->flags & YV12_FLAG_HIGHBITDEPTH) != 0;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005251
Yaowu Xuc27fc142016-08-22 16:08:15 -07005252 check_initial_width(cpi, use_highbitdepth, subsampling_x, subsampling_y);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005253
Yunqing Wangd1f32e62019-02-20 10:37:51 -08005254#if CONFIG_INTERNAL_STATS
5255 struct aom_usec_timer timer;
Yaowu Xuf883b422016-08-30 14:01:10 -07005256 aom_usec_timer_start(&timer);
Yunqing Wangd1f32e62019-02-20 10:37:51 -08005257#endif
Neil Birkbecka2893ab2018-06-08 14:45:13 -07005258#if CONFIG_DENOISE
5259 if (cpi->oxcf.noise_level > 0)
5260 if (apply_denoise_2d(cpi, sd, cpi->oxcf.noise_block_size,
5261 cpi->oxcf.noise_level, time_stamp, end_time) < 0)
5262 res = -1;
5263#endif // CONFIG_DENOISE
5264
Yaowu Xuf883b422016-08-30 14:01:10 -07005265 if (av1_lookahead_push(cpi->lookahead, sd, time_stamp, end_time,
Yaowu Xud3e7c682017-12-21 14:08:25 -08005266 use_highbitdepth, frame_flags))
Yaowu Xuc27fc142016-08-22 16:08:15 -07005267 res = -1;
Yunqing Wangd1f32e62019-02-20 10:37:51 -08005268#if CONFIG_INTERNAL_STATS
Yaowu Xuf883b422016-08-30 14:01:10 -07005269 aom_usec_timer_mark(&timer);
5270 cpi->time_receive_data += aom_usec_timer_elapsed(&timer);
Yunqing Wangd1f32e62019-02-20 10:37:51 -08005271#endif
Urvang Joshi20cf30e2018-07-19 02:33:58 -07005272 if ((seq_params->profile == PROFILE_0) && !seq_params->monochrome &&
Yaowu Xuc27fc142016-08-22 16:08:15 -07005273 (subsampling_x != 1 || subsampling_y != 1)) {
Yaowu Xuf883b422016-08-30 14:01:10 -07005274 aom_internal_error(&cm->error, AOM_CODEC_INVALID_PARAM,
Debargha Mukherjeef9a50ea2018-01-09 22:28:20 -08005275 "Non-4:2:0 color format requires profile 1 or 2");
Yaowu Xuc27fc142016-08-22 16:08:15 -07005276 res = -1;
5277 }
Urvang Joshi20cf30e2018-07-19 02:33:58 -07005278 if ((seq_params->profile == PROFILE_1) &&
Debargha Mukherjeef9a50ea2018-01-09 22:28:20 -08005279 !(subsampling_x == 0 && subsampling_y == 0)) {
Yaowu Xuf883b422016-08-30 14:01:10 -07005280 aom_internal_error(&cm->error, AOM_CODEC_INVALID_PARAM,
Debargha Mukherjeef9a50ea2018-01-09 22:28:20 -08005281 "Profile 1 requires 4:4:4 color format");
5282 res = -1;
5283 }
Urvang Joshi20cf30e2018-07-19 02:33:58 -07005284 if ((seq_params->profile == PROFILE_2) &&
5285 (seq_params->bit_depth <= AOM_BITS_10) &&
Debargha Mukherjeef9a50ea2018-01-09 22:28:20 -08005286 !(subsampling_x == 1 && subsampling_y == 0)) {
5287 aom_internal_error(&cm->error, AOM_CODEC_INVALID_PARAM,
5288 "Profile 2 bit-depth < 10 requires 4:2:2 color format");
Yaowu Xuc27fc142016-08-22 16:08:15 -07005289 res = -1;
5290 }
5291
5292 return res;
5293}
5294
Yaowu Xuc27fc142016-08-22 16:08:15 -07005295#if CONFIG_INTERNAL_STATS
Yaowu Xuf883b422016-08-30 14:01:10 -07005296extern double av1_get_blockiness(const unsigned char *img1, int img1_pitch,
5297 const unsigned char *img2, int img2_pitch,
5298 int width, int height);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005299
5300static void adjust_image_stat(double y, double u, double v, double all,
5301 ImageStat *s) {
Wan-Teh Changc25c92a2018-04-23 15:04:14 -07005302 s->stat[STAT_Y] += y;
5303 s->stat[STAT_U] += u;
5304 s->stat[STAT_V] += v;
5305 s->stat[STAT_ALL] += all;
Yaowu Xuf883b422016-08-30 14:01:10 -07005306 s->worst = AOMMIN(s->worst, all);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005307}
5308
Angie Chiang08a22a62017-07-17 17:29:17 -07005309static void compute_internal_stats(AV1_COMP *cpi, int frame_bytes) {
Yaowu Xuf883b422016-08-30 14:01:10 -07005310 AV1_COMMON *const cm = &cpi->common;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005311 double samples = 0.0;
5312 uint32_t in_bit_depth = 8;
5313 uint32_t bit_depth = 8;
5314
Angie Chiang08a22a62017-07-17 17:29:17 -07005315#if CONFIG_INTER_STATS_ONLY
David Turnerd2a592e2018-11-16 14:59:31 +00005316 if (cm->current_frame.frame_type == KEY_FRAME) return; // skip key frame
Angie Chiang08a22a62017-07-17 17:29:17 -07005317#endif
5318 cpi->bytes += frame_bytes;
5319
Urvang Joshi20cf30e2018-07-19 02:33:58 -07005320 if (cm->seq_params.use_highbitdepth) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07005321 in_bit_depth = cpi->oxcf.input_bit_depth;
Urvang Joshi20cf30e2018-07-19 02:33:58 -07005322 bit_depth = cm->seq_params.bit_depth;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005323 }
Yaowu Xuc27fc142016-08-22 16:08:15 -07005324 if (cm->show_frame) {
Alex Conversef77fd0b2017-04-20 11:00:24 -07005325 const YV12_BUFFER_CONFIG *orig = cpi->source;
David Turnerc29e1a92018-12-06 14:10:14 +00005326 const YV12_BUFFER_CONFIG *recon = &cpi->common.cur_frame->buf;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005327 double y, u, v, frame_all;
5328
5329 cpi->count++;
5330 if (cpi->b_calculate_psnr) {
5331 PSNR_STATS psnr;
5332 double frame_ssim2 = 0.0, weight = 0.0;
Yaowu Xuf883b422016-08-30 14:01:10 -07005333 aom_clear_system_state();
Yaowu Xud3e7c682017-12-21 14:08:25 -08005334 // TODO(yaowu): unify these two versions into one.
Yaowu Xuf883b422016-08-30 14:01:10 -07005335 aom_calc_highbd_psnr(orig, recon, &psnr, bit_depth, in_bit_depth);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005336
5337 adjust_image_stat(psnr.psnr[1], psnr.psnr[2], psnr.psnr[3], psnr.psnr[0],
5338 &cpi->psnr);
5339 cpi->total_sq_error += psnr.sse[0];
5340 cpi->total_samples += psnr.samples[0];
5341 samples = psnr.samples[0];
Yaowu Xud3e7c682017-12-21 14:08:25 -08005342 // TODO(yaowu): unify these two versions into one.
Urvang Joshi20cf30e2018-07-19 02:33:58 -07005343 if (cm->seq_params.use_highbitdepth)
Yaowu Xuc27fc142016-08-22 16:08:15 -07005344 frame_ssim2 =
Yaowu Xuf883b422016-08-30 14:01:10 -07005345 aom_highbd_calc_ssim(orig, recon, &weight, bit_depth, in_bit_depth);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005346 else
Yaowu Xuf883b422016-08-30 14:01:10 -07005347 frame_ssim2 = aom_calc_ssim(orig, recon, &weight);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005348
Yaowu Xuf883b422016-08-30 14:01:10 -07005349 cpi->worst_ssim = AOMMIN(cpi->worst_ssim, frame_ssim2);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005350 cpi->summed_quality += frame_ssim2 * weight;
5351 cpi->summed_weights += weight;
5352
5353#if 0
5354 {
5355 FILE *f = fopen("q_used.stt", "a");
Zoe Liuee202be2017-11-17 12:14:33 -08005356 double y2 = psnr.psnr[1];
5357 double u2 = psnr.psnr[2];
5358 double v2 = psnr.psnr[3];
5359 double frame_psnr2 = psnr.psnr[0];
Yaowu Xuc27fc142016-08-22 16:08:15 -07005360 fprintf(f, "%5d : Y%f7.3:U%f7.3:V%f7.3:F%f7.3:S%7.3f\n",
David Turnerd2a592e2018-11-16 14:59:31 +00005361 cm->current_frame.frame_number, y2, u2, v2,
Yaowu Xuc27fc142016-08-22 16:08:15 -07005362 frame_psnr2, frame_ssim2);
5363 fclose(f);
5364 }
5365#endif
5366 }
5367 if (cpi->b_calculate_blockiness) {
Urvang Joshi20cf30e2018-07-19 02:33:58 -07005368 if (!cm->seq_params.use_highbitdepth) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07005369 const double frame_blockiness =
Yaowu Xuf883b422016-08-30 14:01:10 -07005370 av1_get_blockiness(orig->y_buffer, orig->y_stride, recon->y_buffer,
5371 recon->y_stride, orig->y_width, orig->y_height);
5372 cpi->worst_blockiness = AOMMAX(cpi->worst_blockiness, frame_blockiness);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005373 cpi->total_blockiness += frame_blockiness;
5374 }
5375
5376 if (cpi->b_calculate_consistency) {
Urvang Joshi20cf30e2018-07-19 02:33:58 -07005377 if (!cm->seq_params.use_highbitdepth) {
Yaowu Xuf883b422016-08-30 14:01:10 -07005378 const double this_inconsistency = aom_get_ssim_metrics(
Yaowu Xuc27fc142016-08-22 16:08:15 -07005379 orig->y_buffer, orig->y_stride, recon->y_buffer, recon->y_stride,
5380 orig->y_width, orig->y_height, cpi->ssim_vars, &cpi->metrics, 1);
5381
5382 const double peak = (double)((1 << in_bit_depth) - 1);
5383 const double consistency =
Yaowu Xuf883b422016-08-30 14:01:10 -07005384 aom_sse_to_psnr(samples, peak, cpi->total_inconsistency);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005385 if (consistency > 0.0)
5386 cpi->worst_consistency =
Yaowu Xuf883b422016-08-30 14:01:10 -07005387 AOMMIN(cpi->worst_consistency, consistency);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005388 cpi->total_inconsistency += this_inconsistency;
5389 }
5390 }
5391 }
5392
5393 frame_all =
Yaowu Xuf883b422016-08-30 14:01:10 -07005394 aom_calc_fastssim(orig, recon, &y, &u, &v, bit_depth, in_bit_depth);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005395 adjust_image_stat(y, u, v, frame_all, &cpi->fastssim);
Yaowu Xuf883b422016-08-30 14:01:10 -07005396 frame_all = aom_psnrhvs(orig, recon, &y, &u, &v, bit_depth, in_bit_depth);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005397 adjust_image_stat(y, u, v, frame_all, &cpi->psnrhvs);
5398 }
5399}
5400#endif // CONFIG_INTERNAL_STATS
Andrey Norkin795ba872018-03-06 13:24:14 -08005401int av1_get_compressed_data(AV1_COMP *cpi, unsigned int *frame_flags,
5402 size_t *size, uint8_t *dest, int64_t *time_stamp,
5403 int64_t *time_end, int flush,
5404 const aom_rational_t *timebase) {
Yaowu Xuf883b422016-08-30 14:01:10 -07005405 const AV1EncoderConfig *const oxcf = &cpi->oxcf;
5406 AV1_COMMON *const cm = &cpi->common;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005407
5408#if CONFIG_BITSTREAM_DEBUG
5409 assert(cpi->oxcf.max_threads == 0 &&
5410 "bitstream debug tool does not support multithreading");
5411 bitstream_queue_record_write();
logangwde8b1982019-02-25 09:47:30 -08005412 bitstream_queue_set_frame_write(cm->current_frame.frame_number * 2 +
David Turnerd2a592e2018-11-16 14:59:31 +00005413 cm->show_frame);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005414#endif
5415
Sarah Parker740e8392019-01-23 15:47:53 -08005416 // Indicates whether or not to use an adaptive quantize b rather than
5417 // the traditional version
5418 cm->use_quant_b_adapt = cpi->oxcf.quant_b_adapt;
5419
Dominic Symesd4929012018-01-31 17:32:01 +01005420 cm->showable_frame = 0;
David Turnere43f7fe2019-01-15 14:58:00 +00005421 *size = 0;
Yunqing Wangd1f32e62019-02-20 10:37:51 -08005422#if CONFIG_INTERNAL_STATS
5423 struct aom_usec_timer cmptimer;
Yaowu Xuf883b422016-08-30 14:01:10 -07005424 aom_usec_timer_start(&cmptimer);
Yunqing Wangd1f32e62019-02-20 10:37:51 -08005425#endif
RogerZhou3b635242017-09-19 10:06:46 -07005426 set_high_precision_mv(cpi, ALTREF_HIGH_PRECISION_MV, 0);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005427
Debargha Mukherjeeba7b8fe2018-03-15 23:10:07 -07005428 // Normal defaults
sarahparker27d686a2018-03-30 17:43:44 -07005429 cm->refresh_frame_context = oxcf->frame_parallel_decoding_mode
5430 ? REFRESH_FRAME_CONTEXT_DISABLED
5431 : REFRESH_FRAME_CONTEXT_BACKWARD;
Rupert Swarbrick84b05ac2017-10-27 18:10:53 +01005432 if (oxcf->large_scale_tile)
James Zernf34dfc82018-02-23 16:53:33 -08005433 cm->refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005434
Sarah Parkerb9041612018-05-22 19:06:47 -07005435 // Initialize fields related to forward keyframes
Sarah Parkeraf32a7b2018-06-29 14:59:05 -07005436 cpi->no_show_kf = 0;
Zoe Liub4991202017-12-21 15:31:06 -08005437
David Turnerdedd8ff2019-01-23 13:59:46 +00005438 if (assign_cur_frame_new_fb(cm) == NULL) return AOM_CODEC_ERROR;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005439
David Turnerdedd8ff2019-01-23 13:59:46 +00005440 const int result = av1_encode_strategy(cpi, size, dest, frame_flags,
5441 time_stamp, time_end, timebase, flush);
5442 if (result != AOM_CODEC_OK && result != -1) {
David Turner1539bb02019-01-24 15:28:13 +00005443 return AOM_CODEC_ERROR;
David Turnerdedd8ff2019-01-23 13:59:46 +00005444 } else if (result == -1) {
5445 // Returning -1 indicates no frame encoded; more input is required
5446 return -1;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005447 }
Yunqing Wangd1f32e62019-02-20 10:37:51 -08005448#if CONFIG_INTERNAL_STATS
Yaowu Xuf883b422016-08-30 14:01:10 -07005449 aom_usec_timer_mark(&cmptimer);
5450 cpi->time_compress_data += aom_usec_timer_elapsed(&cmptimer);
Yunqing Wangd1f32e62019-02-20 10:37:51 -08005451#endif
David Turnerc4bf8c72019-01-15 13:14:37 +00005452 if (cpi->b_calculate_psnr) {
5453 if (cm->show_existing_frame || (oxcf->pass != 1 && cm->show_frame)) {
5454 generate_psnr_packet(cpi);
5455 }
5456 }
kyslovabeeb7c2019-03-06 18:35:04 -08005457 if (cpi->keep_level_stats && oxcf->pass != 1 && !cm->show_existing_frame)
5458 av1_update_level_info(cpi, *size, *time_stamp, *time_end);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005459
5460#if CONFIG_INTERNAL_STATS
5461 if (oxcf->pass != 1) {
Angie Chiang08a22a62017-07-17 17:29:17 -07005462 compute_internal_stats(cpi, (int)(*size));
Yaowu Xuc27fc142016-08-22 16:08:15 -07005463 }
5464#endif // CONFIG_INTERNAL_STATS
Debargha Mukherjee0857e662019-01-04 16:22:09 -08005465#if CONFIG_SPEED_STATS
David Turnerc4bf8c72019-01-15 13:14:37 +00005466 if (cpi->oxcf.pass != 1 && !cm->show_existing_frame) {
Debargha Mukherjee0857e662019-01-04 16:22:09 -08005467 cpi->tx_search_count += cpi->td.mb.tx_search_count;
5468 cpi->td.mb.tx_search_count = 0;
5469 }
5470#endif // CONFIG_SPEED_STATS
Yaowu Xuc27fc142016-08-22 16:08:15 -07005471
Yaowu Xuf883b422016-08-30 14:01:10 -07005472 aom_clear_system_state();
Yaowu Xuc27fc142016-08-22 16:08:15 -07005473
5474 return 0;
5475}
5476
Yaowu Xuf883b422016-08-30 14:01:10 -07005477int av1_get_preview_raw_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *dest) {
5478 AV1_COMMON *cm = &cpi->common;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005479 if (!cm->show_frame) {
5480 return -1;
5481 } else {
5482 int ret;
David Turnerc29e1a92018-12-06 14:10:14 +00005483 if (cm->cur_frame != NULL) {
5484 *dest = cm->cur_frame->buf;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005485 dest->y_width = cm->width;
5486 dest->y_height = cm->height;
Urvang Joshi20cf30e2018-07-19 02:33:58 -07005487 dest->uv_width = cm->width >> cm->seq_params.subsampling_x;
5488 dest->uv_height = cm->height >> cm->seq_params.subsampling_y;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005489 ret = 0;
5490 } else {
5491 ret = -1;
5492 }
Yaowu Xuf883b422016-08-30 14:01:10 -07005493 aom_clear_system_state();
Yaowu Xuc27fc142016-08-22 16:08:15 -07005494 return ret;
5495 }
5496}
5497
Yaowu Xuf883b422016-08-30 14:01:10 -07005498int av1_get_last_show_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *frame) {
David Turnere7ebf902018-12-04 14:04:55 +00005499 if (cpi->last_show_frame_buf == NULL) return -1;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005500
David Turnere7ebf902018-12-04 14:04:55 +00005501 *frame = cpi->last_show_frame_buf->buf;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005502 return 0;
5503}
5504
Yunqing Wangff9bfca2018-06-06 11:46:08 -07005505static int equal_dimensions_and_border(const YV12_BUFFER_CONFIG *a,
5506 const YV12_BUFFER_CONFIG *b) {
5507 return a->y_height == b->y_height && a->y_width == b->y_width &&
5508 a->uv_height == b->uv_height && a->uv_width == b->uv_width &&
5509 a->y_stride == b->y_stride && a->uv_stride == b->uv_stride &&
5510 a->border == b->border &&
5511 (a->flags & YV12_FLAG_HIGHBITDEPTH) ==
5512 (b->flags & YV12_FLAG_HIGHBITDEPTH);
5513}
5514
Yunqing Wang93b18f32018-06-08 21:08:29 -07005515aom_codec_err_t av1_copy_new_frame_enc(AV1_COMMON *cm,
5516 YV12_BUFFER_CONFIG *new_frame,
5517 YV12_BUFFER_CONFIG *sd) {
Yunqing Wangff9bfca2018-06-06 11:46:08 -07005518 const int num_planes = av1_num_planes(cm);
5519 if (!equal_dimensions_and_border(new_frame, sd))
5520 aom_internal_error(&cm->error, AOM_CODEC_ERROR,
5521 "Incorrect buffer dimensions");
5522 else
5523 aom_yv12_copy_frame(new_frame, sd, num_planes);
5524
5525 return cm->error.error_code;
5526}
5527
Yaowu Xuf883b422016-08-30 14:01:10 -07005528int av1_set_internal_size(AV1_COMP *cpi, AOM_SCALING horiz_mode,
5529 AOM_SCALING vert_mode) {
Yaowu Xuc27fc142016-08-22 16:08:15 -07005530 int hr = 0, hs = 0, vr = 0, vs = 0;
5531
5532 if (horiz_mode > ONETWO || vert_mode > ONETWO) return -1;
5533
5534 Scale2Ratio(horiz_mode, &hr, &hs);
5535 Scale2Ratio(vert_mode, &vr, &vs);
5536
5537 // always go to the next whole number
Debargha Mukherjeeccb27262017-09-25 14:19:46 -07005538 cpi->resize_pending_width = (hs - 1 + cpi->oxcf.width * hr) / hs;
5539 cpi->resize_pending_height = (vs - 1 + cpi->oxcf.height * vr) / vs;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005540
5541 return 0;
5542}
5543
Yaowu Xuf883b422016-08-30 14:01:10 -07005544int av1_get_quantizer(AV1_COMP *cpi) { return cpi->common.base_qindex; }
Yaowu Xuc27fc142016-08-22 16:08:15 -07005545
Soo-Chul Han29c46fb2018-03-23 16:02:00 -04005546int av1_convert_sect5obus_to_annexb(uint8_t *buffer, size_t *frame_size) {
5547 size_t output_size = 0;
5548 size_t total_bytes_read = 0;
5549 size_t remaining_size = *frame_size;
5550 uint8_t *buff_ptr = buffer;
5551
5552 // go through each OBUs
5553 while (total_bytes_read < *frame_size) {
5554 uint8_t saved_obu_header[2];
5555 uint64_t obu_payload_size;
5556 size_t length_of_payload_size;
5557 size_t length_of_obu_size;
5558 uint32_t obu_header_size = (buff_ptr[0] >> 2) & 0x1 ? 2 : 1;
5559 size_t obu_bytes_read = obu_header_size; // bytes read for current obu
5560
5561 // save the obu header (1 or 2 bytes)
5562 memmove(saved_obu_header, buff_ptr, obu_header_size);
5563 // clear the obu_has_size_field
5564 saved_obu_header[0] = saved_obu_header[0] & (~0x2);
5565
5566 // get the payload_size and length of payload_size
5567 if (aom_uleb_decode(buff_ptr + obu_header_size, remaining_size,
5568 &obu_payload_size, &length_of_payload_size) != 0) {
5569 return AOM_CODEC_ERROR;
5570 }
5571 obu_bytes_read += length_of_payload_size;
5572
5573 // calculate the length of size of the obu header plus payload
5574 length_of_obu_size =
5575 aom_uleb_size_in_bytes((uint64_t)(obu_header_size + obu_payload_size));
5576
5577 // move the rest of data to new location
5578 memmove(buff_ptr + length_of_obu_size + obu_header_size,
5579 buff_ptr + obu_bytes_read, remaining_size - obu_bytes_read);
Yaowu Xu9e494202018-04-03 11:19:49 -07005580 obu_bytes_read += (size_t)obu_payload_size;
Soo-Chul Han29c46fb2018-03-23 16:02:00 -04005581
5582 // write the new obu size
5583 const uint64_t obu_size = obu_header_size + obu_payload_size;
5584 size_t coded_obu_size;
5585 if (aom_uleb_encode(obu_size, sizeof(obu_size), buff_ptr,
5586 &coded_obu_size) != 0) {
5587 return AOM_CODEC_ERROR;
5588 }
5589
5590 // write the saved (modified) obu_header following obu size
5591 memmove(buff_ptr + length_of_obu_size, saved_obu_header, obu_header_size);
5592
5593 total_bytes_read += obu_bytes_read;
5594 remaining_size -= obu_bytes_read;
5595 buff_ptr += length_of_obu_size + obu_size;
Yaowu Xu9e494202018-04-03 11:19:49 -07005596 output_size += length_of_obu_size + (size_t)obu_size;
Soo-Chul Han29c46fb2018-03-23 16:02:00 -04005597 }
5598
5599 *frame_size = output_size;
5600 return AOM_CODEC_OK;
5601}
5602
Yaowu Xuf883b422016-08-30 14:01:10 -07005603void av1_apply_encoding_flags(AV1_COMP *cpi, aom_enc_frame_flags_t flags) {
Yunqing Wang9a50fec2017-11-02 17:02:00 -07005604 // TODO(yunqingwang): For what references to use, external encoding flags
5605 // should be consistent with internal reference frame selection. Need to
5606 // ensure that there is not conflict between the two. In AV1 encoder, the
5607 // priority rank for 7 reference frames are: LAST, ALTREF, LAST2, LAST3,
5608 // GOLDEN, BWDREF, ALTREF2. If only one reference frame is used, it must be
5609 // LAST.
Yunqing Wangf2e7a392017-11-08 00:27:21 -08005610 cpi->ext_ref_frame_flags = AOM_REFFRAME_ALL;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005611 if (flags &
Yunqing Wang9a50fec2017-11-02 17:02:00 -07005612 (AOM_EFLAG_NO_REF_LAST | AOM_EFLAG_NO_REF_LAST2 | AOM_EFLAG_NO_REF_LAST3 |
5613 AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_REF_BWD |
5614 AOM_EFLAG_NO_REF_ARF2)) {
Yaowu Xuf883b422016-08-30 14:01:10 -07005615 if (flags & AOM_EFLAG_NO_REF_LAST) {
Yunqing Wangf2e7a392017-11-08 00:27:21 -08005616 cpi->ext_ref_frame_flags = 0;
Yunqing Wang9a50fec2017-11-02 17:02:00 -07005617 } else {
5618 int ref = AOM_REFFRAME_ALL;
5619
5620 if (flags & AOM_EFLAG_NO_REF_LAST2) ref ^= AOM_LAST2_FLAG;
5621 if (flags & AOM_EFLAG_NO_REF_LAST3) ref ^= AOM_LAST3_FLAG;
5622
5623 if (flags & AOM_EFLAG_NO_REF_GF) ref ^= AOM_GOLD_FLAG;
5624
5625 if (flags & AOM_EFLAG_NO_REF_ARF) {
5626 ref ^= AOM_ALT_FLAG;
5627 ref ^= AOM_BWD_FLAG;
5628 ref ^= AOM_ALT2_FLAG;
5629 } else {
5630 if (flags & AOM_EFLAG_NO_REF_BWD) ref ^= AOM_BWD_FLAG;
5631 if (flags & AOM_EFLAG_NO_REF_ARF2) ref ^= AOM_ALT2_FLAG;
5632 }
5633
5634 av1_use_as_reference(cpi, ref);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005635 }
Yaowu Xuc27fc142016-08-22 16:08:15 -07005636 }
5637
5638 if (flags &
Yunqing Wang9a50fec2017-11-02 17:02:00 -07005639 (AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF)) {
Yaowu Xuf883b422016-08-30 14:01:10 -07005640 int upd = AOM_REFFRAME_ALL;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005641
Yunqing Wang9a50fec2017-11-02 17:02:00 -07005642 // Refreshing LAST/LAST2/LAST3 is handled by 1 common flag.
5643 if (flags & AOM_EFLAG_NO_UPD_LAST) upd ^= AOM_LAST_FLAG;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005644
Yaowu Xuf883b422016-08-30 14:01:10 -07005645 if (flags & AOM_EFLAG_NO_UPD_GF) upd ^= AOM_GOLD_FLAG;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005646
Yunqing Wang9a50fec2017-11-02 17:02:00 -07005647 if (flags & AOM_EFLAG_NO_UPD_ARF) {
5648 upd ^= AOM_ALT_FLAG;
5649 upd ^= AOM_BWD_FLAG;
5650 upd ^= AOM_ALT2_FLAG;
5651 }
Yaowu Xuc27fc142016-08-22 16:08:15 -07005652
David Turnerce9b5902019-01-23 17:25:47 +00005653 cpi->ext_refresh_last_frame = (upd & AOM_LAST_FLAG) != 0;
5654 cpi->ext_refresh_golden_frame = (upd & AOM_GOLD_FLAG) != 0;
5655 cpi->ext_refresh_alt_ref_frame = (upd & AOM_ALT_FLAG) != 0;
5656 cpi->ext_refresh_bwd_ref_frame = (upd & AOM_BWD_FLAG) != 0;
5657 cpi->ext_refresh_alt2_ref_frame = (upd & AOM_ALT2_FLAG) != 0;
5658 cpi->ext_refresh_frame_flags_pending = 1;
David Turner4f1f1812019-01-24 17:00:24 +00005659 } else {
5660 cpi->ext_refresh_frame_flags_pending = 0;
Yaowu Xuc27fc142016-08-22 16:08:15 -07005661 }
5662
sarahparker21dbca42018-03-30 17:43:44 -07005663 cpi->ext_use_ref_frame_mvs = cpi->oxcf.allow_ref_frame_mvs &
5664 ((flags & AOM_EFLAG_NO_REF_FRAME_MVS) == 0);
sarahparker27d686a2018-03-30 17:43:44 -07005665 cpi->ext_use_error_resilient = cpi->oxcf.error_resilient_mode |
5666 ((flags & AOM_EFLAG_ERROR_RESILIENT) != 0);
sarahparker9806fed2018-03-30 17:43:44 -07005667 cpi->ext_use_s_frame =
5668 cpi->oxcf.s_frame_mode | ((flags & AOM_EFLAG_SET_S_FRAME) != 0);
Sarah Parker50b6d6e2018-04-11 19:21:54 -07005669 cpi->ext_use_primary_ref_none = (flags & AOM_EFLAG_SET_PRIMARY_REF_NONE) != 0;
sarahparker21dbca42018-03-30 17:43:44 -07005670
Yaowu Xuf883b422016-08-30 14:01:10 -07005671 if (flags & AOM_EFLAG_NO_UPD_ENTROPY) {
5672 av1_update_entropy(cpi, 0);
Yaowu Xuc27fc142016-08-22 16:08:15 -07005673 }
5674}
Andrey Norkin795ba872018-03-06 13:24:14 -08005675
Tom Fineganf8d6a162018-08-21 10:47:55 -07005676aom_fixed_buf_t *av1_get_global_headers(AV1_COMP *cpi) {
5677 if (!cpi) return NULL;
5678
5679 uint8_t header_buf[512] = { 0 };
5680 const uint32_t sequence_header_size =
5681 write_sequence_header_obu(cpi, &header_buf[0]);
5682 assert(sequence_header_size <= sizeof(header_buf));
5683 if (sequence_header_size == 0) return NULL;
5684
5685 const size_t obu_header_size = 1;
5686 const size_t size_field_size = aom_uleb_size_in_bytes(sequence_header_size);
5687 const size_t payload_offset = obu_header_size + size_field_size;
5688
5689 if (payload_offset + sequence_header_size > sizeof(header_buf)) return NULL;
5690 memmove(&header_buf[payload_offset], &header_buf[0], sequence_header_size);
5691
5692 if (write_obu_header(OBU_SEQUENCE_HEADER, 0, &header_buf[0]) !=
5693 obu_header_size) {
5694 return NULL;
5695 }
5696
5697 size_t coded_size_field_size = 0;
5698 if (aom_uleb_encode(sequence_header_size, size_field_size,
5699 &header_buf[obu_header_size],
5700 &coded_size_field_size) != 0) {
5701 return NULL;
5702 }
5703 assert(coded_size_field_size == size_field_size);
5704
5705 aom_fixed_buf_t *global_headers =
5706 (aom_fixed_buf_t *)malloc(sizeof(*global_headers));
5707 if (!global_headers) return NULL;
5708
5709 const size_t global_header_buf_size =
5710 obu_header_size + size_field_size + sequence_header_size;
5711
5712 global_headers->buf = malloc(global_header_buf_size);
5713 if (!global_headers->buf) {
5714 free(global_headers);
5715 return NULL;
5716 }
5717
5718 memcpy(global_headers->buf, &header_buf[0], global_header_buf_size);
5719 global_headers->sz = global_header_buf_size;
5720 return global_headers;
5721}