1 /*
2 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
3 *
4 * This source code is subject to the terms of the BSD 2 Clause License and
5 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6 * was not distributed with this source code in the LICENSE file, you can
7 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8 * Media Patent License 1.0 was not distributed with this source code in the
9 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10 */
11
12 #include <limits.h>
13 #include <math.h>
14 #include <stdio.h>
15
16 #include "config/aom_config.h"
17 #include "config/aom_dsp_rtcd.h"
18 #include "config/aom_scale_rtcd.h"
19 #include "config/av1_rtcd.h"
20
21 #include "aom_dsp/aom_dsp_common.h"
22 #include "aom_dsp/aom_filter.h"
23 #if CONFIG_DENOISE
24 #include "aom_dsp/grain_table.h"
25 #include "aom_dsp/noise_util.h"
26 #include "aom_dsp/noise_model.h"
27 #endif
28 #include "aom_dsp/psnr.h"
29 #if CONFIG_INTERNAL_STATS
30 #include "aom_dsp/ssim.h"
31 #endif
32 #include "aom_ports/aom_timer.h"
33 #include "aom_ports/mem.h"
34 #include "aom_ports/system_state.h"
35 #include "aom_scale/aom_scale.h"
36 #if CONFIG_BITSTREAM_DEBUG
37 #include "aom_util/debug_util.h"
38 #endif // CONFIG_BITSTREAM_DEBUG
39
40 #include "av1/common/alloccommon.h"
41 #include "av1/common/cdef.h"
42 #include "av1/common/filter.h"
43 #include "av1/common/idct.h"
44 #include "av1/common/reconinter.h"
45 #include "av1/common/reconintra.h"
46 #include "av1/common/resize.h"
47 #include "av1/common/tile_common.h"
48
49 #include "av1/encoder/av1_multi_thread.h"
50 #include "av1/encoder/aq_complexity.h"
51 #include "av1/encoder/aq_cyclicrefresh.h"
52 #include "av1/encoder/aq_variance.h"
53 #include "av1/encoder/bitstream.h"
54 #include "av1/encoder/context_tree.h"
55 #include "av1/encoder/encodeframe.h"
56 #include "av1/encoder/encodemv.h"
57 #include "av1/encoder/encode_strategy.h"
58 #include "av1/encoder/encoder.h"
59 #include "av1/encoder/encodetxb.h"
60 #include "av1/encoder/ethread.h"
61 #include "av1/encoder/firstpass.h"
62 #include "av1/encoder/grain_test_vectors.h"
63 #include "av1/encoder/hash_motion.h"
64 #include "av1/encoder/mbgraph.h"
65 #include "av1/encoder/pass2_strategy.h"
66 #include "av1/encoder/picklpf.h"
67 #include "av1/encoder/pickrst.h"
68 #include "av1/encoder/random.h"
69 #include "av1/encoder/ratectrl.h"
70 #include "av1/encoder/rd.h"
71 #include "av1/encoder/rdopt.h"
72 #include "av1/encoder/segmentation.h"
73 #include "av1/encoder/speed_features.h"
74 #include "av1/encoder/reconinter_enc.h"
75 #include "av1/encoder/var_based_part.h"
76
77 #define DEFAULT_EXPLICIT_ORDER_HINT_BITS 7
78
79 #if CONFIG_ENTROPY_STATS
80 FRAME_COUNTS aggregate_fc;
81 #endif // CONFIG_ENTROPY_STATS
82
83 #define AM_SEGMENT_ID_INACTIVE 7
84 #define AM_SEGMENT_ID_ACTIVE 0
85
86 // 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
92
93 // #define OUTPUT_YUV_REC
94 #ifdef OUTPUT_YUV_SKINMAP
95 FILE *yuv_skinmap_file = NULL;
96 #endif
97 #ifdef OUTPUT_YUV_REC
98 FILE *yuv_rec_file;
99 #define FILE_NAME_LEN 100
100 #endif
101
Scale2Ratio(AOM_SCALING mode,int * hr,int * hs)102 static INLINE void Scale2Ratio(AOM_SCALING mode, int *hr, int *hs) {
103 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.
suppress_active_map(AV1_COMP * cpi)130 static void suppress_active_map(AV1_COMP *cpi) {
131 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
apply_active_map(AV1_COMP * cpi)139 static void apply_active_map(AV1_COMP *cpi) {
140 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];
156 av1_enable_segmentation(seg);
157 av1_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_SKIP);
158 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);
171 } else {
172 av1_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_SKIP);
173 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);
177 if (seg->enabled) {
178 seg->update_data = 1;
179 seg->update_map = 1;
180 }
181 }
182 cpi->active_map.update = 0;
183 }
184 }
185
av1_set_active_map(AV1_COMP * cpi,unsigned char * new_map_16x16,int rows,int cols)186 int av1_set_active_map(AV1_COMP *cpi, unsigned char *new_map_16x16, int rows,
187 int cols) {
188 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;
192 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;
194 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] =
200 new_map_16x16[(r >> row_scale) * cols + (c >> col_scale)]
201 ? 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
av1_get_active_map(AV1_COMP * cpi,unsigned char * new_map_16x16,int rows,int cols)215 int av1_get_active_map(AV1_COMP *cpi, unsigned char *new_map_16x16, int rows,
216 int cols) {
217 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;
222 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
225 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
232 new_map_16x16[(r >> row_scale) * cols + (c >> col_scale)] |=
233 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
243 // 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.
analyze_hor_freq(const AV1_COMP * cpi,double * energy)246 void analyze_hor_freq(const AV1_COMP *cpi, double *energy) {
247 uint64_t freq_energy[16] = { 0 };
248 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;
252 DECLARE_ALIGNED(16, int32_t, coeff[16 * 4]);
253 int n = 0;
254 memset(freq_energy, 0, sizeof(freq_energy));
255 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);
261 for (int k = 1; k < 16; ++k) {
262 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]);
267 freq_energy[k] += ROUND_POWER_OF_TWO(this_energy, 2 + 2 * (bd - 8));
268 }
269 n++;
270 }
271 }
272 } else {
273 assert(bd == 8);
274 DECLARE_ALIGNED(16, int16_t, src16[16 * 4]);
275 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)];
281 av1_fwd_txfm2d_16x4(src16, coeff, 16, H_DCT, bd);
282 for (int k = 1; k < 16; ++k) {
283 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]);
288 freq_energy[k] += ROUND_POWER_OF_TWO(this_energy, 2);
289 }
290 n++;
291 }
292 }
293 }
294 if (n) {
295 for (int k = 1; k < 16; ++k) energy[k] = (double)freq_energy[k] / n;
296 // Convert to cumulative energy
297 for (int k = 14; k > 0; --k) energy[k] += energy[k + 1];
298 } else {
299 for (int k = 1; k < 16; ++k) energy[k] = 1e+20;
300 }
301 }
302
set_high_precision_mv(AV1_COMP * cpi,int allow_high_precision_mv,int cur_frame_force_integer_mv)303 static void set_high_precision_mv(AV1_COMP *cpi, int allow_high_precision_mv,
304 int cur_frame_force_integer_mv) {
305 MACROBLOCK *const mb = &cpi->td.mb;
306 cpi->common.allow_high_precision_mv =
307 allow_high_precision_mv && cur_frame_force_integer_mv == 0;
308 const int copy_hp =
309 cpi->common.allow_high_precision_mv && cur_frame_force_integer_mv == 0;
310 int *(*src)[2] = copy_hp ? &mb->nmvcost_hp : &mb->nmvcost;
311 mb->mv_cost_stack = *src;
312 }
313
select_sb_size(const AV1_COMP * const cpi)314 static BLOCK_SIZE select_sb_size(const AV1_COMP *const cpi) {
315 const AV1_COMMON *const cm = &cpi->common;
316
317 if (cpi->oxcf.superblock_size == AOM_SUPERBLOCK_SIZE_64X64)
318 return BLOCK_64X64;
319 #if CONFIG_FILEOPTIONS
320 if (cm->options && cm->options->ext_partition)
321 #endif
322 if (cpi->oxcf.superblock_size == AOM_SUPERBLOCK_SIZE_128X128)
323 return BLOCK_128X128;
324
325 assert(cpi->oxcf.superblock_size == AOM_SUPERBLOCK_SIZE_DYNAMIC);
326
327 // TODO(any): Possibly could improve this with a heuristic.
328 #if CONFIG_FILEOPTIONS
329 if (cm->options && !cm->options->ext_partition) return BLOCK_64X64;
330 #endif
331
332 // 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.
335 // 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)
338 if (cpi->oxcf.superres_mode == SUPERRES_NONE &&
339 cpi->oxcf.resize_mode == RESIZE_NONE && cpi->oxcf.speed >= 2) {
340 return (cm->width >= 480 && cm->height >= 360) ? BLOCK_128X128
341 : BLOCK_64X64;
342 }
343
344 return BLOCK_128X128;
345 }
346
setup_frame(AV1_COMP * cpi)347 static void setup_frame(AV1_COMP *cpi) {
348 AV1_COMMON *const cm = &cpi->common;
349 // 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.
354
355 if (frame_is_intra_only(cm) || cm->error_resilient_mode ||
356 cpi->ext_use_primary_ref_none) {
357 av1_setup_past_independence(cm);
358 }
359
360 if (cm->current_frame.frame_type == KEY_FRAME && cm->show_frame) {
361 set_sb_size(&cm->seq_params, select_sb_size(cpi));
362 } else if (frame_is_sframe(cm)) {
363 set_sb_size(&cm->seq_params, select_sb_size(cpi));
364 } else {
365 const RefCntBuffer *const primary_ref_buf = get_primary_ref_frame_buf(cm);
366 if (primary_ref_buf == NULL) {
367 av1_setup_past_independence(cm);
368 cm->seg.update_map = 1;
369 cm->seg.update_data = 1;
370 } else {
371 *cm->fc = primary_ref_buf->frame_context;
372 }
373 }
374
375 av1_zero(cm->cur_frame->interp_filter_selected);
376 cm->prev_frame = get_primary_ref_frame_buf(cm);
377 cpi->vaq_refresh = 0;
378 }
379
enc_setup_mi(AV1_COMMON * cm)380 static void enc_setup_mi(AV1_COMMON *cm) {
381 int i;
382 int mi_rows_sb_aligned = calc_mi_size(cm->mi_rows);
383 cm->mi = cm->mip;
384 memset(cm->mip, 0, cm->mi_stride * mi_rows_sb_aligned * sizeof(*cm->mip));
385 cm->prev_mi = cm->prev_mip;
386 // Clear top border row
387 memset(cm->prev_mip, 0, sizeof(*cm->prev_mip) * cm->mi_stride);
388 // Clear left border column
389 for (i = 0; i < mi_rows_sb_aligned; ++i)
390 memset(&cm->prev_mip[i * cm->mi_stride], 0, sizeof(*cm->prev_mip));
391 cm->mi_grid_visible = cm->mi_grid_base;
392 cm->prev_mi_grid_visible = cm->prev_mi_grid_base;
393
394 memset(cm->mi_grid_base, 0,
395 cm->mi_stride * mi_rows_sb_aligned * sizeof(*cm->mi_grid_base));
396 }
397
enc_alloc_mi(AV1_COMMON * cm,int mi_size)398 static int enc_alloc_mi(AV1_COMMON *cm, int mi_size) {
399 cm->mip = aom_calloc(mi_size, sizeof(*cm->mip));
400 if (!cm->mip) return 1;
401 cm->prev_mip = aom_calloc(mi_size, sizeof(*cm->prev_mip));
402 if (!cm->prev_mip) return 1;
403 cm->mi_alloc_size = mi_size;
404
405 cm->mi_grid_base =
406 (MB_MODE_INFO **)aom_calloc(mi_size, sizeof(MB_MODE_INFO *));
407 if (!cm->mi_grid_base) return 1;
408 cm->prev_mi_grid_base =
409 (MB_MODE_INFO **)aom_calloc(mi_size, sizeof(MB_MODE_INFO *));
410 if (!cm->prev_mi_grid_base) return 1;
411
412 return 0;
413 }
414
enc_free_mi(AV1_COMMON * cm)415 static void enc_free_mi(AV1_COMMON *cm) {
416 aom_free(cm->mip);
417 cm->mip = NULL;
418 aom_free(cm->prev_mip);
419 cm->prev_mip = NULL;
420 aom_free(cm->mi_grid_base);
421 cm->mi_grid_base = NULL;
422 aom_free(cm->prev_mi_grid_base);
423 cm->prev_mi_grid_base = NULL;
424 cm->mi_alloc_size = 0;
425 }
426
swap_mi_and_prev_mi(AV1_COMMON * cm)427 static void swap_mi_and_prev_mi(AV1_COMMON *cm) {
428 // Current mip will be the prev_mip for the next frame.
429 MB_MODE_INFO **temp_base = cm->prev_mi_grid_base;
430 MB_MODE_INFO *temp = cm->prev_mip;
431 cm->prev_mip = cm->mip;
432 cm->mip = temp;
433
434 // Update the upper left visible macroblock ptrs.
435 cm->mi = cm->mip;
436 cm->prev_mi = cm->prev_mip;
437
438 cm->prev_mi_grid_base = cm->mi_grid_base;
439 cm->mi_grid_base = temp_base;
440 cm->mi_grid_visible = cm->mi_grid_base;
441 cm->prev_mi_grid_visible = cm->prev_mi_grid_base;
442 }
443
av1_initialize_enc(void)444 void av1_initialize_enc(void) {
445 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();
452 }
453
dealloc_context_buffers_ext(AV1_COMP * cpi)454 static 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
alloc_context_buffers_ext(AV1_COMP * cpi)461 static 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
reset_film_grain_chroma_params(aom_film_grain_t * pars)470 static 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;
479 pars->chroma_scaling_from_luma = 0;
480 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
update_film_grain_parameters(struct AV1_COMP * cpi,const AV1EncoderConfig * oxcf)484 static 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
489 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;
493 }
494
495 if (oxcf->film_grain_test_vector) {
496 cm->seq_params.film_grain_params_present = 1;
497 if (cm->current_frame.frame_type == KEY_FRAME) {
498 memcpy(&cm->film_grain_params,
499 film_grain_test_vectors + oxcf->film_grain_test_vector - 1,
500 sizeof(cm->film_grain_params));
501 if (oxcf->monochrome)
502 reset_film_grain_chroma_params(&cm->film_grain_params);
503 cm->film_grain_params.bit_depth = cm->seq_params.bit_depth;
504 if (cm->seq_params.color_range == AOM_CR_FULL_RANGE) {
505 cm->film_grain_params.clip_to_restricted_range = 0;
506 }
507 }
508 } else if (oxcf->film_grain_table_filename) {
509 cm->seq_params.film_grain_params_present = 1;
510
511 cpi->film_grain_table = aom_malloc(sizeof(*cpi->film_grain_table));
512 memset(cpi->film_grain_table, 0, sizeof(aom_film_grain_table_t));
513
514 aom_film_grain_table_read(cpi->film_grain_table,
515 oxcf->film_grain_table_filename, &cm->error);
516 } else {
517 #if CONFIG_DENOISE
518 cm->seq_params.film_grain_params_present = (cpi->oxcf.noise_level > 0);
519 #else
520 cm->seq_params.film_grain_params_present = 0;
521 #endif
522 memset(&cm->film_grain_params, 0, sizeof(cm->film_grain_params));
523 }
524 }
525
dealloc_compressor_data(AV1_COMP * cpi)526 static void dealloc_compressor_data(AV1_COMP *cpi) {
527 AV1_COMMON *const cm = &cpi->common;
528 const int num_planes = av1_num_planes(cm);
529
530 dealloc_context_buffers_ext(cpi);
531
532 aom_free(cpi->tile_data);
533 cpi->tile_data = NULL;
534
535 // Delete sementation map
536 aom_free(cpi->segmentation_map);
537 cpi->segmentation_map = NULL;
538
539 av1_cyclic_refresh_free(cpi->cyclic_refresh);
540 cpi->cyclic_refresh = NULL;
541
542 aom_free(cpi->active_map.map);
543 cpi->active_map.map = NULL;
544
545 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
554 aom_free(cpi->td.mb.inter_modes_info);
555 cpi->td.mb.inter_modes_info = NULL;
556
557 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 }
562 aom_free(cpi->td.mb.mask_buf);
563 cpi->td.mb.mask_buf = NULL;
564
565 aom_free(cm->tpl_mvs);
566 cm->tpl_mvs = NULL;
567
568 av1_free_ref_frame_buffers(cm->buffer_pool);
569 av1_free_txb_buf(cpi);
570 av1_free_context_buffers(cm);
571
572 aom_free_frame_buffer(&cpi->last_frame_uf);
573 av1_free_restoration_buffers(cm);
574 aom_free_frame_buffer(&cpi->trial_frame_rst);
575 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);
579
580 aom_free(cpi->tile_tok[0][0]);
581 cpi->tile_tok[0][0] = 0;
582
583 aom_free(cpi->tplist[0][0]);
584 cpi->tplist[0][0] = NULL;
585
586 av1_free_pc_tree(&cpi->td, num_planes);
587
588 aom_free(cpi->td.mb.palette_buffer);
589
590 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
595 #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 }
605 }
606
save_coding_context(AV1_COMP * cpi)607 static void save_coding_context(AV1_COMP *cpi) {
608 CODING_CONTEXT *const cc = &cpi->coding_context;
609 AV1_COMMON *cm = &cpi->common;
610
611 // 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.
615 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);
618
619 cc->fc = *cm->fc;
620 }
621
restore_coding_context(AV1_COMP * cpi)622 static void restore_coding_context(AV1_COMP *cpi) {
623 CODING_CONTEXT *const cc = &cpi->coding_context;
624 AV1_COMMON *cm = &cpi->common;
625
626 // Restore key state variables to the snapshot state stored in the
627 // previous call to av1_save_coding_context.
628 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);
631
632 *cm->fc = cc->fc;
633 }
634
configure_static_seg_features(AV1_COMP * cpi)635 static void configure_static_seg_features(AV1_COMP *cpi) {
636 AV1_COMMON *const cm = &cpi->common;
637 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
644 if (cm->current_frame.frame_type == KEY_FRAME) {
645 // 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
652 av1_disable_segmentation(seg);
653
654 // Clear down the segment features.
655 av1_clearall_segfeatures(seg);
656 } 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
665 av1_disable_segmentation(seg);
666 av1_clearall_segfeatures(seg);
667
668 // Scan frames from current to arf frame.
669 // This function re-enables segmentation if appropriate.
670 av1_update_mbgraph_stats(cpi);
671
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
678 qi_delta = av1_compute_qdelta(rc, rc->avg_q, rc->avg_q * 0.875,
679 cm->seq_params.bit_depth);
680 av1_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta - 2);
681 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);
690
691 av1_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
692 }
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;
702
703 qi_delta = av1_compute_qdelta(rc, rc->avg_q, rc->avg_q * 1.125,
704 cm->seq_params.bit_depth);
705 av1_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta + 2);
706 av1_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
707
708 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);
717
718 // Segment coding disabled for compred testing
719 if (high_q || (cpi->static_mb_pct == 100)) {
720 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);
723 }
724 } else {
725 // Disable segmentation and clear down features if alt ref
726 // is not active for this group
727
728 av1_disable_segmentation(seg);
729
730 memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
731
732 seg->update_map = 0;
733 seg->update_data = 0;
734
735 av1_clearall_segfeatures(seg);
736 }
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
743 av1_enable_segfeature(seg, 0, SEG_LVL_REF_FRAME);
744 av1_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME);
745
746 // All mbs should use ALTREF_FRAME
747 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);
751
752 // Skip all MBs if high Q (0,0 mv and skip coeffs)
753 if (high_q) {
754 av1_enable_segfeature(seg, 0, SEG_LVL_SKIP);
755 av1_enable_segfeature(seg, 1, SEG_LVL_SKIP);
756 }
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
update_reference_segmentation_map(AV1_COMP * cpi)769 static void update_reference_segmentation_map(AV1_COMP *cpi) {
770 AV1_COMMON *const cm = &cpi->common;
771 MB_MODE_INFO **mi_4x4_ptr = cm->mi_grid_visible;
772 uint8_t *cache_ptr = cm->cur_frame->seg_map;
773 int row, col;
774
775 for (row = 0; row < cm->mi_rows; row++) {
776 MB_MODE_INFO **mi_4x4 = mi_4x4_ptr;
777 uint8_t *cache = cache_ptr;
778 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;
781 cache_ptr += cm->mi_cols;
782 }
783 }
784
alloc_raw_frame_buffers(AV1_COMP * cpi)785 static void alloc_raw_frame_buffers(AV1_COMP *cpi) {
786 AV1_COMMON *cm = &cpi->common;
787 const SequenceHeader *const seq_params = &cm->seq_params;
788 const AV1EncoderConfig *oxcf = &cpi->oxcf;
789
790 if (!cpi->lookahead) {
791 int is_scale = (oxcf->resize_mode || oxcf->superres_mode);
792 cpi->lookahead = av1_lookahead_init(
793 oxcf->width, oxcf->height, seq_params->subsampling_x,
794 seq_params->subsampling_y, seq_params->use_highbitdepth,
795 oxcf->lag_in_frames, oxcf->border_in_pixels, is_scale);
796 }
797 if (!cpi->lookahead)
798 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
799 "Failed to allocate lag buffers");
800
801 // TODO(agrange) Check if ARF is enabled and skip allocation if not.
802 if (aom_realloc_frame_buffer(
803 &cpi->alt_ref_buffer, oxcf->width, oxcf->height,
804 seq_params->subsampling_x, seq_params->subsampling_y,
805 seq_params->use_highbitdepth, oxcf->border_in_pixels,
806 cm->byte_alignment, NULL, NULL, NULL))
807 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
808 "Failed to allocate altref buffer");
809 }
810
alloc_util_frame_buffers(AV1_COMP * cpi)811 static void alloc_util_frame_buffers(AV1_COMP *cpi) {
812 AV1_COMMON *const cm = &cpi->common;
813 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,
817 cpi->oxcf.border_in_pixels, cm->byte_alignment, NULL, NULL, NULL))
818 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
819 "Failed to allocate last frame buffer");
820
821 if (aom_realloc_frame_buffer(
822 &cpi->trial_frame_rst, cm->superres_upscaled_width,
823 cm->superres_upscaled_height, seq_params->subsampling_x,
824 seq_params->subsampling_y, seq_params->use_highbitdepth,
825 AOM_RESTORATION_FRAME_BORDER, cm->byte_alignment, NULL, NULL, NULL))
826 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
827 "Failed to allocate trial restored frame buffer");
828
829 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,
832 cpi->oxcf.border_in_pixels, cm->byte_alignment, NULL, NULL, NULL))
833 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
834 "Failed to allocate scaled source buffer");
835
836 if (aom_realloc_frame_buffer(
837 &cpi->scaled_last_source, cm->width, cm->height,
838 seq_params->subsampling_x, seq_params->subsampling_y,
839 seq_params->use_highbitdepth, cpi->oxcf.border_in_pixels,
840 cm->byte_alignment, NULL, NULL, NULL))
841 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
842 "Failed to allocate scaled last source buffer");
843 }
844
alloc_compressor_data(AV1_COMP * cpi)845 static void alloc_compressor_data(AV1_COMP *cpi) {
846 AV1_COMMON *cm = &cpi->common;
847 const int num_planes = av1_num_planes(cm);
848
849 av1_alloc_context_buffers(cm, cm->width, cm->height);
850
851 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
855 av1_alloc_txb_buf(cpi);
856
857 alloc_context_buffers_ext(cpi);
858
859 aom_free(cpi->tile_tok[0][0]);
860
861 {
862 unsigned int tokens =
863 get_token_alloc(cm->mb_rows, cm->mb_cols, MAX_SB_SIZE_LOG2, num_planes);
864 CHECK_MEM_ERROR(cm, cpi->tile_tok[0][0],
865 aom_calloc(tokens, sizeof(*cpi->tile_tok[0][0])));
866 }
867 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])));
872
873 av1_setup_pc_tree(&cpi->common, &cpi->td);
874 }
875
av1_new_framerate(AV1_COMP * cpi,double framerate)876 void av1_new_framerate(AV1_COMP *cpi, double framerate) {
877 cpi->framerate = framerate < 0.1 ? 30 : framerate;
878 av1_rc_update_framerate(cpi, cpi->common.width, cpi->common.height);
879 }
880
set_tile_info(AV1_COMP * cpi)881 static void set_tile_info(AV1_COMP *cpi) {
882 AV1_COMMON *const cm = &cpi->common;
883 int i, start_sb;
884
885 av1_get_tile_limits(cm);
886
887 // configure tile columns
888 if (cpi->oxcf.tile_width_count == 0 || cpi->oxcf.tile_height_count == 0) {
889 cm->uniform_tile_spacing_flag = 1;
890 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);
892 } else {
893 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;
895 int size_sb, j = 0;
896 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;
899 size_sb = cpi->oxcf.tile_widths[j++];
900 if (j >= cpi->oxcf.tile_width_count) j = 0;
901 start_sb += AOMMIN(size_sb, cm->max_tile_width_sb);
902 }
903 cm->tile_cols = i;
904 cm->tile_col_start_sb[i] = sb_cols;
905 }
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);
912 } else {
913 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;
915 int size_sb, j = 0;
916 for (i = 0, start_sb = 0; start_sb < sb_rows && i < MAX_TILE_ROWS; i++) {
917 cm->tile_row_start_sb[i] = start_sb;
918 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);
921 }
922 cm->tile_rows = i;
923 cm->tile_row_start_sb[i] = sb_rows;
924 }
925 av1_calculate_tile_rows(cm);
926 }
927
update_frame_size(AV1_COMP * cpi)928 static void update_frame_size(AV1_COMP *cpi) {
929 AV1_COMMON *const cm = &cpi->common;
930 MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
931
932 av1_set_mb_mi(cm, cm->width, cm->height);
933 av1_init_context_buffers(cm);
934 av1_init_macroblockd(cm, xd, NULL);
935 memset(cpi->mbmi_ext_base, 0,
936 cm->mi_rows * cm->mi_cols * sizeof(*cpi->mbmi_ext_base));
937 set_tile_info(cpi);
938 }
939
init_buffer_indices(AV1_COMP * cpi)940 static void init_buffer_indices(AV1_COMP *cpi) {
941 int fb_idx;
942 for (fb_idx = 0; fb_idx < REF_FRAMES; ++fb_idx)
943 cpi->common.remapped_ref_idx[fb_idx] = fb_idx;
944 cpi->rate_index = 0;
945 cpi->rate_size = 0;
946 }
947
does_level_match(int width,int height,double fps,int lvl_width,int lvl_height,double lvl_fps,int lvl_dim_mult)948 static 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
set_bitstream_level_tier(SequenceHeader * seq,AV1_COMMON * cm,const AV1EncoderConfig * oxcf)961 static void set_bitstream_level_tier(SequenceHeader *seq, AV1_COMMON *cm,
962 const AV1EncoderConfig *oxcf) {
963 // 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.
967 AV1_LEVEL level = SEQ_LEVEL_MAX;
968 if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate, 512,
969 288, 30.0, 4)) {
970 level = SEQ_LEVEL_2_0;
971 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
972 704, 396, 30.0, 4)) {
973 level = SEQ_LEVEL_2_1;
974 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
975 1088, 612, 30.0, 4)) {
976 level = SEQ_LEVEL_3_0;
977 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
978 1376, 774, 30.0, 4)) {
979 level = SEQ_LEVEL_3_1;
980 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
981 2048, 1152, 30.0, 3)) {
982 level = SEQ_LEVEL_4_0;
983 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
984 2048, 1152, 60.0, 3)) {
985 level = SEQ_LEVEL_4_1;
986 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
987 4096, 2176, 30.0, 2)) {
988 level = SEQ_LEVEL_5_0;
989 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
990 4096, 2176, 60.0, 2)) {
991 level = SEQ_LEVEL_5_1;
992 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
993 4096, 2176, 120.0, 2)) {
994 level = SEQ_LEVEL_5_2;
995 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
996 8192, 4352, 30.0, 2)) {
997 level = SEQ_LEVEL_6_0;
998 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
999 8192, 4352, 60.0, 2)) {
1000 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
1001 8192, 4352, 120.0, 2)) {
1002 level = SEQ_LEVEL_6_2;
1003 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
1004 16384, 8704, 30.0, 2)) {
1005 level = SEQ_LEVEL_7_0;
1006 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
1007 16384, 8704, 60.0, 2)) {
1008 level = SEQ_LEVEL_7_1;
1009 } else if (does_level_match(oxcf->width, oxcf->height, oxcf->init_framerate,
1010 16384, 8704, 120.0, 2)) {
1011 level = SEQ_LEVEL_7_2;
1012 }
1013 for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i) {
1014 seq->seq_level_idx[i] = level;
1015 // 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(
1018 cm->seq_params.profile, seq->seq_level_idx[i], seq->tier[i]);
1019 // Level with seq_level_idx = 31 returns a high "dummy" bitrate to pass the
1020 // check
1021 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.");
1025 // Buffer size in bits/s is bitrate in bits/s * 1 s
1026 cm->op_params[i].buffer_size = cm->op_params[i].bitrate;
1027 }
1028 }
1029
init_seq_coding_tools(SequenceHeader * seq,AV1_COMMON * cm,const AV1EncoderConfig * oxcf)1030 static void init_seq_coding_tools(SequenceHeader *seq, AV1_COMMON *cm,
1031 const AV1EncoderConfig *oxcf) {
1032 seq->still_picture = (oxcf->limit == 1);
1033 seq->reduced_still_picture_hdr = seq->still_picture;
1034 seq->reduced_still_picture_hdr &= !oxcf->full_still_picture_hdr;
1035 seq->force_screen_content_tools = 2;
1036 seq->force_integer_mv = 2;
1037 seq->order_hint_info.enable_order_hint = oxcf->enable_order_hint;
1038 seq->frame_id_numbers_present_flag =
1039 !(seq->still_picture && seq->reduced_still_picture_hdr) &&
1040 !oxcf->large_scale_tile && oxcf->error_resilient_mode;
1041 if (seq->still_picture && seq->reduced_still_picture_hdr) {
1042 seq->order_hint_info.enable_order_hint = 0;
1043 seq->force_screen_content_tools = 2;
1044 seq->force_integer_mv = 2;
1045 }
1046 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;
1050
1051 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
1066 seq->enable_dual_filter = oxcf->enable_dual_filter;
1067 seq->order_hint_info.enable_dist_wtd_comp = oxcf->enable_dist_wtd_comp;
1068 seq->order_hint_info.enable_dist_wtd_comp &=
1069 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;
1073 seq->enable_superres = oxcf->enable_superres;
1074 seq->enable_cdef = oxcf->enable_cdef;
1075 seq->enable_restoration = oxcf->enable_restoration;
1076 seq->enable_warped_motion = oxcf->enable_warped_motion;
1077 seq->enable_interintra_compound = oxcf->enable_interintra_comp;
1078 seq->enable_masked_compound = oxcf->enable_masked_comp;
1079 seq->enable_intra_edge_filter = oxcf->enable_intra_edge_filter;
1080 seq->enable_filter_intra = oxcf->enable_filter_intra;
1081
1082 set_bitstream_level_tier(seq, cm, oxcf);
1083
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 }
1095 }
1096
init_config(struct AV1_COMP * cpi,AV1EncoderConfig * oxcf)1097 static void init_config(struct AV1_COMP *cpi, AV1EncoderConfig *oxcf) {
1098 AV1_COMMON *const cm = &cpi->common;
1099
1100 cpi->oxcf = *oxcf;
1101 cpi->framerate = oxcf->init_framerate;
1102
1103 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;
1109 cm->seq_params.monochrome = oxcf->monochrome;
1110 cm->seq_params.chroma_sample_position = oxcf->chroma_sample_position;
1111 cm->seq_params.color_range = oxcf->color_range;
1112 cm->timing_info_present = oxcf->timing_info_present;
1113 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
1121 cm->seq_params.display_model_info_present_flag =
1122 oxcf->display_model_info_present_flag;
1123 cm->seq_params.decoder_model_info_present_flag =
1124 oxcf->decoder_model_info_present_flag;
1125 if (oxcf->decoder_model_info_present_flag) {
1126 // set the decoder model parameters in schedule mode
1127 cm->buffer_model.num_units_in_decoding_tick =
1128 oxcf->buffer_model.num_units_in_decoding_tick;
1129 cm->buffer_removal_time_present = 1;
1130 set_aom_dec_model_info(&cm->buffer_model);
1131 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]);
1137 } else {
1138 cm->op_params[0].initial_display_delay =
1139 10; // Default value (not signaled)
1140 }
1141
1142 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 }
1166 }
1167
1168 cm->width = oxcf->width;
1169 cm->height = oxcf->height;
1170 set_sb_size(&cm->seq_params,
1171 select_sb_size(cpi)); // set sb size before allocations
1172 alloc_compressor_data(cpi);
1173
1174 update_film_grain_parameters(cpi, oxcf);
1175
1176 // Single thread case: use counts in common.
1177 cpi->td.counts = &cpi->counts;
1178
1179 // change includes all joint functionality
1180 av1_change_config(cpi, oxcf);
1181
1182 cpi->static_mb_pct = 0;
1183 cpi->ref_frame_flags = 0;
1184
1185 // Reset resize pending flags
1186 cpi->resize_pending_width = 0;
1187 cpi->resize_pending_height = 0;
1188
1189 init_buffer_indices(cpi);
1190 }
1191
set_rc_buffer_sizes(RATE_CONTROL * rc,const AV1EncoderConfig * oxcf)1192 static void set_rc_buffer_sizes(RATE_CONTROL *rc,
1193 const AV1EncoderConfig *oxcf) {
1194 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
1206 #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; \
1214 cpi->fn_ptr[BT].jsvaf = JSVAF;
1215
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
1252 #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
1273 #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, \
1277 const DIST_WTD_COMP_PARAMS *jcp_param) { \
1278 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, \
1284 const DIST_WTD_COMP_PARAMS *jcp_param) { \
1285 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, \
1292 const DIST_WTD_COMP_PARAMS *jcp_param) { \
1293 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred, \
1294 jcp_param) >> \
1295 4; \
1296 }
1297
1298 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad128x128)
MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad128x128_avg)1299 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad128x128_avg)
1300 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad128x128x4d)
1301 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad128x64)
1302 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad128x64_avg)
1303 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad128x64x4d)
1304 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad64x128)
1305 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad64x128_avg)
1306 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad64x128x4d)
1307 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad32x16)
1308 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad32x16_avg)
1309 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad32x16x4d)
1310 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad16x32)
1311 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad16x32_avg)
1312 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad16x32x4d)
1313 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad64x32)
1314 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad64x32_avg)
1315 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad64x32x4d)
1316 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad32x64)
1317 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad32x64_avg)
1318 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad32x64x4d)
1319 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad32x32)
1320 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad32x32_avg)
1321 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad32x32x4d)
1322 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad64x64)
1323 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad64x64_avg)
1324 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad64x64x4d)
1325 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad16x16)
1326 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad16x16_avg)
1327 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad16x16x4d)
1328 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad16x8)
1329 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad16x8_avg)
1330 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad16x8x4d)
1331 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad8x16)
1332 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad8x16_avg)
1333 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad8x16x4d)
1334 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad8x8)
1335 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad8x8_avg)
1336 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad8x8x4d)
1337 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad8x4)
1338 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad8x4_avg)
1339 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad8x4x4d)
1340 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad4x8)
1341 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad4x8_avg)
1342 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad4x8x4d)
1343 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad4x4)
1344 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad4x4_avg)
1345 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad4x4x4d)
1346
1347 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad4x16)
1348 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad4x16_avg)
1349 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad4x16x4d)
1350 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad16x4)
1351 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad16x4_avg)
1352 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad16x4x4d)
1353 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad8x32)
1354 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad8x32_avg)
1355 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad8x32x4d)
1356 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad32x8)
1357 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad32x8_avg)
1358 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad32x8x4d)
1359 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad16x64)
1360 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad16x64_avg)
1361 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad16x64x4d)
1362 MAKE_BFP_SAD_WRAPPER(aom_highbd_sad64x16)
1363 MAKE_BFP_SADAVG_WRAPPER(aom_highbd_sad64x16_avg)
1364 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad64x16x4d)
1365
1366 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad128x128_avg)
1367 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad128x64_avg)
1368 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad64x128_avg)
1369 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad32x16_avg)
1370 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad16x32_avg)
1371 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad64x32_avg)
1372 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad32x64_avg)
1373 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad32x32_avg)
1374 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad64x64_avg)
1375 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad16x16_avg)
1376 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad16x8_avg)
1377 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad8x16_avg)
1378 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad8x8_avg)
1379 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad8x4_avg)
1380 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad4x8_avg)
1381 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad4x4_avg)
1382 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad4x16_avg)
1383 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad16x4_avg)
1384 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad8x32_avg)
1385 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad32x8_avg)
1386 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad16x64_avg)
1387 MAKE_BFP_JSADAVG_WRAPPER(aom_highbd_dist_wtd_sad64x16_avg)
1388
1389 #define HIGHBD_MBFP(BT, MCSDF, MCSVF) \
1390 cpi->fn_ptr[BT].msdf = MCSDF; \
1391 cpi->fn_ptr[BT].msvf = MCSVF;
1392
1393 #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
1418 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad128x128)
1419 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad128x64)
1420 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad64x128)
1421 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad64x64)
1422 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad64x32)
1423 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad32x64)
1424 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad32x32)
1425 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad32x16)
1426 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad16x32)
1427 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad16x16)
1428 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad16x8)
1429 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad8x16)
1430 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad8x8)
1431 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad8x4)
1432 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad4x8)
1433 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad4x4)
1434 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad4x16)
1435 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad16x4)
1436 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad8x32)
1437 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad32x8)
1438 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad16x64)
1439 MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_sad64x16)
1440
1441 #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
1463 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad128x128)
1464 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad128x64)
1465 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad64x128)
1466 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad64x64)
1467 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad64x32)
1468 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad32x64)
1469 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad32x32)
1470 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad32x16)
1471 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad16x32)
1472 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad16x16)
1473 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad16x8)
1474 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad8x16)
1475 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad8x8)
1476 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad8x4)
1477 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad4x8)
1478 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad4x4)
1479 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad4x16)
1480 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad16x4)
1481 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad8x32)
1482 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad32x8)
1483 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad16x64)
1484 MAKE_OBFP_SAD_WRAPPER(aom_highbd_obmc_sad64x16)
1485
1486 static void highbd_set_var_fns(AV1_COMP *const cpi) {
1487 AV1_COMMON *const cm = &cpi->common;
1488 if (cm->seq_params.use_highbitdepth) {
1489 switch (cm->seq_params.bit_depth) {
1490 case AOM_BITS_8:
1491 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,
1494 aom_highbd_8_sub_pixel_avg_variance64x16,
1495 aom_highbd_sad64x16x4d_bits8,
1496 aom_highbd_dist_wtd_sad64x16_avg_bits8,
1497 aom_highbd_8_dist_wtd_sub_pixel_avg_variance64x16)
1498
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,
1502 aom_highbd_8_sub_pixel_avg_variance16x64,
1503 aom_highbd_sad16x64x4d_bits8,
1504 aom_highbd_dist_wtd_sad16x64_avg_bits8,
1505 aom_highbd_8_dist_wtd_sub_pixel_avg_variance16x64)
1506
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,
1510 aom_highbd_8_sub_pixel_avg_variance32x8,
1511 aom_highbd_sad32x8x4d_bits8, aom_highbd_dist_wtd_sad32x8_avg_bits8,
1512 aom_highbd_8_dist_wtd_sub_pixel_avg_variance32x8)
1513
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,
1517 aom_highbd_8_sub_pixel_avg_variance8x32,
1518 aom_highbd_sad8x32x4d_bits8, aom_highbd_dist_wtd_sad8x32_avg_bits8,
1519 aom_highbd_8_dist_wtd_sub_pixel_avg_variance8x32)
1520
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,
1524 aom_highbd_8_sub_pixel_avg_variance16x4,
1525 aom_highbd_sad16x4x4d_bits8, aom_highbd_dist_wtd_sad16x4_avg_bits8,
1526 aom_highbd_8_dist_wtd_sub_pixel_avg_variance16x4)
1527
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,
1531 aom_highbd_8_sub_pixel_avg_variance4x16,
1532 aom_highbd_sad4x16x4d_bits8, aom_highbd_dist_wtd_sad4x16_avg_bits8,
1533 aom_highbd_8_dist_wtd_sub_pixel_avg_variance4x16)
1534
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,
1538 aom_highbd_8_sub_pixel_avg_variance32x16,
1539 aom_highbd_sad32x16x4d_bits8,
1540 aom_highbd_dist_wtd_sad32x16_avg_bits8,
1541 aom_highbd_8_dist_wtd_sub_pixel_avg_variance32x16)
1542
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,
1546 aom_highbd_8_sub_pixel_avg_variance16x32,
1547 aom_highbd_sad16x32x4d_bits8,
1548 aom_highbd_dist_wtd_sad16x32_avg_bits8,
1549 aom_highbd_8_dist_wtd_sub_pixel_avg_variance16x32)
1550
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,
1554 aom_highbd_8_sub_pixel_avg_variance64x32,
1555 aom_highbd_sad64x32x4d_bits8,
1556 aom_highbd_dist_wtd_sad64x32_avg_bits8,
1557 aom_highbd_8_dist_wtd_sub_pixel_avg_variance64x32)
1558
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,
1562 aom_highbd_8_sub_pixel_avg_variance32x64,
1563 aom_highbd_sad32x64x4d_bits8,
1564 aom_highbd_dist_wtd_sad32x64_avg_bits8,
1565 aom_highbd_8_dist_wtd_sub_pixel_avg_variance32x64)
1566
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,
1571 aom_highbd_sad32x32x4d_bits8,
1572 aom_highbd_dist_wtd_sad32x32_avg_bits8,
1573 aom_highbd_8_dist_wtd_sub_pixel_avg_variance32x32)
1574
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,
1579 aom_highbd_sad64x64x4d_bits8,
1580 aom_highbd_dist_wtd_sad64x64_avg_bits8,
1581 aom_highbd_8_dist_wtd_sub_pixel_avg_variance64x64)
1582
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,
1587 aom_highbd_sad16x16x4d_bits8,
1588 aom_highbd_dist_wtd_sad16x16_avg_bits8,
1589 aom_highbd_8_dist_wtd_sub_pixel_avg_variance16x16)
1590
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,
1594 aom_highbd_8_sub_pixel_avg_variance16x8,
1595 aom_highbd_sad16x8x4d_bits8, aom_highbd_dist_wtd_sad16x8_avg_bits8,
1596 aom_highbd_8_dist_wtd_sub_pixel_avg_variance16x8)
1597
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,
1601 aom_highbd_8_sub_pixel_avg_variance8x16,
1602 aom_highbd_sad8x16x4d_bits8, aom_highbd_dist_wtd_sad8x16_avg_bits8,
1603 aom_highbd_8_dist_wtd_sub_pixel_avg_variance8x16)
1604
1605 HIGHBD_BFP(
1606 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)
1641
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,
1645 aom_highbd_8_sub_pixel_avg_variance128x64,
1646 aom_highbd_sad128x64x4d_bits8,
1647 aom_highbd_dist_wtd_sad128x64_avg_bits8,
1648 aom_highbd_8_dist_wtd_sub_pixel_avg_variance128x64)
1649
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,
1653 aom_highbd_8_sub_pixel_avg_variance64x128,
1654 aom_highbd_sad64x128x4d_bits8,
1655 aom_highbd_dist_wtd_sad64x128_avg_bits8,
1656 aom_highbd_8_dist_wtd_sub_pixel_avg_variance64x128)
1657
1658 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)
1664 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)
1690 HIGHBD_MBFP(BLOCK_64X16, aom_highbd_masked_sad64x16_bits8,
1691 aom_highbd_8_masked_sub_pixel_variance64x16)
1692 HIGHBD_MBFP(BLOCK_16X64, aom_highbd_masked_sad16x64_bits8,
1693 aom_highbd_8_masked_sub_pixel_variance16x64)
1694 HIGHBD_MBFP(BLOCK_32X8, aom_highbd_masked_sad32x8_bits8,
1695 aom_highbd_8_masked_sub_pixel_variance32x8)
1696 HIGHBD_MBFP(BLOCK_8X32, aom_highbd_masked_sad8x32_bits8,
1697 aom_highbd_8_masked_sub_pixel_variance8x32)
1698 HIGHBD_MBFP(BLOCK_16X4, aom_highbd_masked_sad16x4_bits8,
1699 aom_highbd_8_masked_sub_pixel_variance16x4)
1700 HIGHBD_MBFP(BLOCK_4X16, aom_highbd_masked_sad4x16_bits8,
1701 aom_highbd_8_masked_sub_pixel_variance4x16)
1702 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)
1711 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)
1750 HIGHBD_OBFP(BLOCK_64X16, aom_highbd_obmc_sad64x16_bits8,
1751 aom_highbd_obmc_variance64x16,
1752 aom_highbd_obmc_sub_pixel_variance64x16)
1753 HIGHBD_OBFP(BLOCK_16X64, aom_highbd_obmc_sad16x64_bits8,
1754 aom_highbd_obmc_variance16x64,
1755 aom_highbd_obmc_sub_pixel_variance16x64)
1756 HIGHBD_OBFP(BLOCK_32X8, aom_highbd_obmc_sad32x8_bits8,
1757 aom_highbd_obmc_variance32x8,
1758 aom_highbd_obmc_sub_pixel_variance32x8)
1759 HIGHBD_OBFP(BLOCK_8X32, aom_highbd_obmc_sad8x32_bits8,
1760 aom_highbd_obmc_variance8x32,
1761 aom_highbd_obmc_sub_pixel_variance8x32)
1762 HIGHBD_OBFP(BLOCK_16X4, aom_highbd_obmc_sad16x4_bits8,
1763 aom_highbd_obmc_variance16x4,
1764 aom_highbd_obmc_sub_pixel_variance16x4)
1765 HIGHBD_OBFP(BLOCK_4X16, aom_highbd_obmc_sad4x16_bits8,
1766 aom_highbd_obmc_variance4x16,
1767 aom_highbd_obmc_sub_pixel_variance4x16)
1768 break;
1769
1770 case AOM_BITS_10:
1771 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,
1774 aom_highbd_10_sub_pixel_avg_variance64x16,
1775 aom_highbd_sad64x16x4d_bits10,
1776 aom_highbd_dist_wtd_sad64x16_avg_bits10,
1777 aom_highbd_10_dist_wtd_sub_pixel_avg_variance64x16);
1778
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,
1782 aom_highbd_10_sub_pixel_avg_variance16x64,
1783 aom_highbd_sad16x64x4d_bits10,
1784 aom_highbd_dist_wtd_sad16x64_avg_bits10,
1785 aom_highbd_10_dist_wtd_sub_pixel_avg_variance16x64);
1786
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,
1790 aom_highbd_10_sub_pixel_avg_variance32x8,
1791 aom_highbd_sad32x8x4d_bits10,
1792 aom_highbd_dist_wtd_sad32x8_avg_bits10,
1793 aom_highbd_10_dist_wtd_sub_pixel_avg_variance32x8);
1794
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,
1798 aom_highbd_10_sub_pixel_avg_variance8x32,
1799 aom_highbd_sad8x32x4d_bits10,
1800 aom_highbd_dist_wtd_sad8x32_avg_bits10,
1801 aom_highbd_10_dist_wtd_sub_pixel_avg_variance8x32);
1802
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,
1806 aom_highbd_10_sub_pixel_avg_variance16x4,
1807 aom_highbd_sad16x4x4d_bits10,
1808 aom_highbd_dist_wtd_sad16x4_avg_bits10,
1809 aom_highbd_10_dist_wtd_sub_pixel_avg_variance16x4);
1810
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,
1814 aom_highbd_10_sub_pixel_avg_variance4x16,
1815 aom_highbd_sad4x16x4d_bits10,
1816 aom_highbd_dist_wtd_sad4x16_avg_bits10,
1817 aom_highbd_10_dist_wtd_sub_pixel_avg_variance4x16);
1818
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,
1822 aom_highbd_10_sub_pixel_avg_variance32x16,
1823 aom_highbd_sad32x16x4d_bits10,
1824 aom_highbd_dist_wtd_sad32x16_avg_bits10,
1825 aom_highbd_10_dist_wtd_sub_pixel_avg_variance32x16);
1826
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,
1830 aom_highbd_10_sub_pixel_avg_variance16x32,
1831 aom_highbd_sad16x32x4d_bits10,
1832 aom_highbd_dist_wtd_sad16x32_avg_bits10,
1833 aom_highbd_10_dist_wtd_sub_pixel_avg_variance16x32);
1834
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,
1838 aom_highbd_10_sub_pixel_avg_variance64x32,
1839 aom_highbd_sad64x32x4d_bits10,
1840 aom_highbd_dist_wtd_sad64x32_avg_bits10,
1841 aom_highbd_10_dist_wtd_sub_pixel_avg_variance64x32);
1842
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,
1846 aom_highbd_10_sub_pixel_avg_variance32x64,
1847 aom_highbd_sad32x64x4d_bits10,
1848 aom_highbd_dist_wtd_sad32x64_avg_bits10,
1849 aom_highbd_10_dist_wtd_sub_pixel_avg_variance32x64);
1850
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,
1855 aom_highbd_sad32x32x4d_bits10,
1856 aom_highbd_dist_wtd_sad32x32_avg_bits10,
1857 aom_highbd_10_dist_wtd_sub_pixel_avg_variance32x32);
1858
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,
1863 aom_highbd_sad64x64x4d_bits10,
1864 aom_highbd_dist_wtd_sad64x64_avg_bits10,
1865 aom_highbd_10_dist_wtd_sub_pixel_avg_variance64x64);
1866
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,
1871 aom_highbd_sad16x16x4d_bits10,
1872 aom_highbd_dist_wtd_sad16x16_avg_bits10,
1873 aom_highbd_10_dist_wtd_sub_pixel_avg_variance16x16);
1874
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,
1879 aom_highbd_sad16x8x4d_bits10,
1880 aom_highbd_dist_wtd_sad16x8_avg_bits10,
1881 aom_highbd_10_dist_wtd_sub_pixel_avg_variance16x8);
1882
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,
1887 aom_highbd_sad8x16x4d_bits10,
1888 aom_highbd_dist_wtd_sad8x16_avg_bits10,
1889 aom_highbd_10_dist_wtd_sub_pixel_avg_variance8x16);
1890
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,
1894 aom_highbd_10_sub_pixel_avg_variance8x8,
1895 aom_highbd_sad8x8x4d_bits10, aom_highbd_dist_wtd_sad8x8_avg_bits10,
1896 aom_highbd_10_dist_wtd_sub_pixel_avg_variance8x8);
1897
1898 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,
1902 aom_highbd_sad8x4x4d_bits10, aom_highbd_dist_wtd_sad8x4_avg_bits10,
1903 aom_highbd_10_dist_wtd_sub_pixel_avg_variance8x4);
1904
1905 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,
1909 aom_highbd_sad4x8x4d_bits10, aom_highbd_dist_wtd_sad4x8_avg_bits10,
1910 aom_highbd_10_dist_wtd_sub_pixel_avg_variance4x8);
1911
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,
1915 aom_highbd_10_sub_pixel_avg_variance4x4,
1916 aom_highbd_sad4x4x4d_bits10, aom_highbd_dist_wtd_sad4x4_avg_bits10,
1917 aom_highbd_10_dist_wtd_sub_pixel_avg_variance4x4);
1918
1919 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,
1925 aom_highbd_dist_wtd_sad128x128_avg_bits10,
1926 aom_highbd_10_dist_wtd_sub_pixel_avg_variance128x128);
1927
1928 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);
1936
1937 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);
1945
1946 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)
1952 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)
1978 HIGHBD_MBFP(BLOCK_64X16, aom_highbd_masked_sad64x16_bits10,
1979 aom_highbd_10_masked_sub_pixel_variance64x16)
1980 HIGHBD_MBFP(BLOCK_16X64, aom_highbd_masked_sad16x64_bits10,
1981 aom_highbd_10_masked_sub_pixel_variance16x64)
1982 HIGHBD_MBFP(BLOCK_32X8, aom_highbd_masked_sad32x8_bits10,
1983 aom_highbd_10_masked_sub_pixel_variance32x8)
1984 HIGHBD_MBFP(BLOCK_8X32, aom_highbd_masked_sad8x32_bits10,
1985 aom_highbd_10_masked_sub_pixel_variance8x32)
1986 HIGHBD_MBFP(BLOCK_16X4, aom_highbd_masked_sad16x4_bits10,
1987 aom_highbd_10_masked_sub_pixel_variance16x4)
1988 HIGHBD_MBFP(BLOCK_4X16, aom_highbd_masked_sad4x16_bits10,
1989 aom_highbd_10_masked_sub_pixel_variance4x16)
1990 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)
1999 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)
2038
2039 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
2047 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)
2062 break;
2063
2064 case AOM_BITS_12:
2065 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,
2068 aom_highbd_12_sub_pixel_avg_variance64x16,
2069 aom_highbd_sad64x16x4d_bits12,
2070 aom_highbd_dist_wtd_sad64x16_avg_bits12,
2071 aom_highbd_12_dist_wtd_sub_pixel_avg_variance64x16);
2072
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,
2076 aom_highbd_12_sub_pixel_avg_variance16x64,
2077 aom_highbd_sad16x64x4d_bits12,
2078 aom_highbd_dist_wtd_sad16x64_avg_bits12,
2079 aom_highbd_12_dist_wtd_sub_pixel_avg_variance16x64);
2080
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,
2084 aom_highbd_12_sub_pixel_avg_variance32x8,
2085 aom_highbd_sad32x8x4d_bits12,
2086 aom_highbd_dist_wtd_sad32x8_avg_bits12,
2087 aom_highbd_12_dist_wtd_sub_pixel_avg_variance32x8);
2088
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,
2092 aom_highbd_12_sub_pixel_avg_variance8x32,
2093 aom_highbd_sad8x32x4d_bits12,
2094 aom_highbd_dist_wtd_sad8x32_avg_bits12,
2095 aom_highbd_12_dist_wtd_sub_pixel_avg_variance8x32);
2096
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,
2100 aom_highbd_12_sub_pixel_avg_variance16x4,
2101 aom_highbd_sad16x4x4d_bits12,
2102 aom_highbd_dist_wtd_sad16x4_avg_bits12,
2103 aom_highbd_12_dist_wtd_sub_pixel_avg_variance16x4);
2104
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,
2108 aom_highbd_12_sub_pixel_avg_variance4x16,
2109 aom_highbd_sad4x16x4d_bits12,
2110 aom_highbd_dist_wtd_sad4x16_avg_bits12,
2111 aom_highbd_12_dist_wtd_sub_pixel_avg_variance4x16);
2112
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,
2116 aom_highbd_12_sub_pixel_avg_variance32x16,
2117 aom_highbd_sad32x16x4d_bits12,
2118 aom_highbd_dist_wtd_sad32x16_avg_bits12,
2119 aom_highbd_12_dist_wtd_sub_pixel_avg_variance32x16);
2120
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,
2124 aom_highbd_12_sub_pixel_avg_variance16x32,
2125 aom_highbd_sad16x32x4d_bits12,
2126 aom_highbd_dist_wtd_sad16x32_avg_bits12,
2127 aom_highbd_12_dist_wtd_sub_pixel_avg_variance16x32);
2128
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,
2132 aom_highbd_12_sub_pixel_avg_variance64x32,
2133 aom_highbd_sad64x32x4d_bits12,
2134 aom_highbd_dist_wtd_sad64x32_avg_bits12,
2135 aom_highbd_12_dist_wtd_sub_pixel_avg_variance64x32);
2136
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,
2140 aom_highbd_12_sub_pixel_avg_variance32x64,
2141 aom_highbd_sad32x64x4d_bits12,
2142 aom_highbd_dist_wtd_sad32x64_avg_bits12,
2143 aom_highbd_12_dist_wtd_sub_pixel_avg_variance32x64);
2144
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,
2149 aom_highbd_sad32x32x4d_bits12,
2150 aom_highbd_dist_wtd_sad32x32_avg_bits12,
2151 aom_highbd_12_dist_wtd_sub_pixel_avg_variance32x32);
2152
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,
2157 aom_highbd_sad64x64x4d_bits12,
2158 aom_highbd_dist_wtd_sad64x64_avg_bits12,
2159 aom_highbd_12_dist_wtd_sub_pixel_avg_variance64x64);
2160
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,
2165 aom_highbd_sad16x16x4d_bits12,
2166 aom_highbd_dist_wtd_sad16x16_avg_bits12,
2167 aom_highbd_12_dist_wtd_sub_pixel_avg_variance16x16);
2168
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,
2173 aom_highbd_sad16x8x4d_bits12,
2174 aom_highbd_dist_wtd_sad16x8_avg_bits12,
2175 aom_highbd_12_dist_wtd_sub_pixel_avg_variance16x8);
2176
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,
2181 aom_highbd_sad8x16x4d_bits12,
2182 aom_highbd_dist_wtd_sad8x16_avg_bits12,
2183 aom_highbd_12_dist_wtd_sub_pixel_avg_variance8x16);
2184
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,
2188 aom_highbd_12_sub_pixel_avg_variance8x8,
2189 aom_highbd_sad8x8x4d_bits12, aom_highbd_dist_wtd_sad8x8_avg_bits12,
2190 aom_highbd_12_dist_wtd_sub_pixel_avg_variance8x8);
2191
2192 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,
2196 aom_highbd_sad8x4x4d_bits12, aom_highbd_dist_wtd_sad8x4_avg_bits12,
2197 aom_highbd_12_dist_wtd_sub_pixel_avg_variance8x4);
2198
2199 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,
2203 aom_highbd_sad4x8x4d_bits12, aom_highbd_dist_wtd_sad4x8_avg_bits12,
2204 aom_highbd_12_dist_wtd_sub_pixel_avg_variance4x8);
2205
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,
2209 aom_highbd_12_sub_pixel_avg_variance4x4,
2210 aom_highbd_sad4x4x4d_bits12, aom_highbd_dist_wtd_sad4x4_avg_bits12,
2211 aom_highbd_12_dist_wtd_sub_pixel_avg_variance4x4);
2212
2213 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,
2219 aom_highbd_dist_wtd_sad128x128_avg_bits12,
2220 aom_highbd_12_dist_wtd_sub_pixel_avg_variance128x128);
2221
2222 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);
2230
2231 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);
2239
2240 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)
2246 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)
2272 HIGHBD_MBFP(BLOCK_64X16, aom_highbd_masked_sad64x16_bits12,
2273 aom_highbd_12_masked_sub_pixel_variance64x16)
2274 HIGHBD_MBFP(BLOCK_16X64, aom_highbd_masked_sad16x64_bits12,
2275 aom_highbd_12_masked_sub_pixel_variance16x64)
2276 HIGHBD_MBFP(BLOCK_32X8, aom_highbd_masked_sad32x8_bits12,
2277 aom_highbd_12_masked_sub_pixel_variance32x8)
2278 HIGHBD_MBFP(BLOCK_8X32, aom_highbd_masked_sad8x32_bits12,
2279 aom_highbd_12_masked_sub_pixel_variance8x32)
2280 HIGHBD_MBFP(BLOCK_16X4, aom_highbd_masked_sad16x4_bits12,
2281 aom_highbd_12_masked_sub_pixel_variance16x4)
2282 HIGHBD_MBFP(BLOCK_4X16, aom_highbd_masked_sad4x16_bits12,
2283 aom_highbd_12_masked_sub_pixel_variance4x16)
2284 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)
2293 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)
2332 HIGHBD_OBFP(BLOCK_64X16, aom_highbd_obmc_sad64x16_bits12,
2333 aom_highbd_12_obmc_variance64x16,
2334 aom_highbd_12_obmc_sub_pixel_variance64x16)
2335 HIGHBD_OBFP(BLOCK_16X64, aom_highbd_obmc_sad16x64_bits12,
2336 aom_highbd_12_obmc_variance16x64,
2337 aom_highbd_12_obmc_sub_pixel_variance16x64)
2338 HIGHBD_OBFP(BLOCK_32X8, aom_highbd_obmc_sad32x8_bits12,
2339 aom_highbd_12_obmc_variance32x8,
2340 aom_highbd_12_obmc_sub_pixel_variance32x8)
2341 HIGHBD_OBFP(BLOCK_8X32, aom_highbd_obmc_sad8x32_bits12,
2342 aom_highbd_12_obmc_variance8x32,
2343 aom_highbd_12_obmc_sub_pixel_variance8x32)
2344 HIGHBD_OBFP(BLOCK_16X4, aom_highbd_obmc_sad16x4_bits12,
2345 aom_highbd_12_obmc_variance16x4,
2346 aom_highbd_12_obmc_sub_pixel_variance16x4)
2347 HIGHBD_OBFP(BLOCK_4X16, aom_highbd_obmc_sad4x16_bits12,
2348 aom_highbd_12_obmc_variance4x16,
2349 aom_highbd_12_obmc_sub_pixel_variance4x16)
2350 break;
2351
2352 default:
2353 assert(0 &&
2354 "cm->seq_params.bit_depth should be AOM_BITS_8, "
2355 "AOM_BITS_10 or AOM_BITS_12");
2356 }
2357 }
2358 }
2359
realloc_segmentation_maps(AV1_COMP * cpi)2360 static void realloc_segmentation_maps(AV1_COMP *cpi) {
2361 AV1_COMMON *const cm = &cpi->common;
2362
2363 // Create the encoder segmentation map and set all entries to 0
2364 aom_free(cpi->segmentation_map);
2365 CHECK_MEM_ERROR(cm, cpi->segmentation_map,
2366 aom_calloc(cm->mi_rows * cm->mi_cols, 1));
2367
2368 // Create a map used for cyclic background refresh.
2369 if (cpi->cyclic_refresh) av1_cyclic_refresh_free(cpi->cyclic_refresh);
2370 CHECK_MEM_ERROR(cm, cpi->cyclic_refresh,
2371 av1_cyclic_refresh_alloc(cm->mi_rows, cm->mi_cols));
2372
2373 // Create a map used to mark inactive areas.
2374 aom_free(cpi->active_map.map);
2375 CHECK_MEM_ERROR(cm, cpi->active_map.map,
2376 aom_calloc(cm->mi_rows * cm->mi_cols, 1));
2377 }
2378
av1_change_config(struct AV1_COMP * cpi,const AV1EncoderConfig * oxcf)2379 void av1_change_config(struct AV1_COMP *cpi, const AV1EncoderConfig *oxcf) {
2380 AV1_COMMON *const cm = &cpi->common;
2381 SequenceHeader *const seq_params = &cm->seq_params;
2382 const int num_planes = av1_num_planes(cm);
2383 RATE_CONTROL *const rc = &cpi->rc;
2384 MACROBLOCK *const x = &cpi->td.mb;
2385
2386 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;
2394
2395 assert(IMPLIES(seq_params->profile <= PROFILE_1,
2396 seq_params->bit_depth <= AOM_BITS_10));
2397
2398 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 }
2407
2408 cm->timing_info_present = oxcf->timing_info_present;
2409 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
2417 seq_params->display_model_info_present_flag =
2418 oxcf->display_model_info_present_flag;
2419 seq_params->decoder_model_info_present_flag =
2420 oxcf->decoder_model_info_present_flag;
2421 if (oxcf->decoder_model_info_present_flag) {
2422 // set the decoder model parameters in schedule mode
2423 cm->buffer_model.num_units_in_decoding_tick =
2424 oxcf->buffer_model.num_units_in_decoding_tick;
2425 cm->buffer_removal_time_present = 1;
2426 set_aom_dec_model_info(&cm->buffer_model);
2427 set_dec_model_op_parameters(&cm->op_params[0]);
2428 } else if (cm->timing_info_present &&
2429 cm->timing_info.equal_picture_interval &&
2430 !seq_params->decoder_model_info_present_flag) {
2431 // set the decoder model parameters in resource availability mode
2432 set_resource_availability_parameters(&cm->op_params[0]);
2433 } else {
2434 cm->op_params[0].initial_display_delay =
2435 10; // Default value (not signaled)
2436 }
2437
2438 update_film_grain_parameters(cpi, oxcf);
2439
2440 cpi->oxcf = *oxcf;
2441 cpi->common.options = oxcf->cfg;
2442 x->e_mbd.bd = (int)seq_params->bit_depth;
2443 x->e_mbd.global_motion = cm->global_motion;
2444
2445 if ((oxcf->pass == 0) && (oxcf->rc_mode == AOM_Q)) {
2446 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;
2453 cpi->refresh_bwd_ref_frame = 0;
2454 cpi->refresh_alt2_ref_frame = 0;
2455
2456 cm->refresh_frame_context = (oxcf->frame_parallel_decoding_mode)
2457 ? REFRESH_FRAME_CONTEXT_DISABLED
2458 : REFRESH_FRAME_CONTEXT_BACKWARD;
2459 if (oxcf->large_scale_tile)
2460 cm->refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED;
2461
2462 if (x->palette_buffer == NULL) {
2463 CHECK_MEM_ERROR(cm, x->palette_buffer,
2464 aom_memalign(16, sizeof(*x->palette_buffer)));
2465 }
2466
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)));
2471 x->e_mbd.tmp_conv_dst = x->tmp_conv_dst;
2472 }
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],
2476 aom_memalign(32, 2 * MAX_MB_PLANE * MAX_SB_SQUARE *
2477 sizeof(*x->tmp_obmc_bufs[i])));
2478 x->e_mbd.tmp_obmc_bufs[i] = x->tmp_obmc_bufs[i];
2479 }
2480 }
2481
2482 av1_reset_segment_features(cm);
2483 set_high_precision_mv(cpi, 1, 0);
2484
2485 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.
2489 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);
2491
2492 // Set up frame rate and related parameters rate control values.
2493 av1_new_framerate(cpi, cpi->framerate);
2494
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
2499 cm->interp_filter = oxcf->large_scale_tile ? EIGHTTAP_REGULAR : SWITCHABLE;
2500 cm->switchable_motion_mode = 1;
2501
2502 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
2512 int sb_size = seq_params->sb_size;
2513 // 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));
2516 for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i)
2517 seq_params->tier[i] = (oxcf->tier_mask >> i) & 1;
2518 }
2519
2520 if (cpi->initial_width || sb_size != seq_params->sb_size) {
2521 if (cm->width > cpi->initial_width || cm->height > cpi->initial_height ||
2522 seq_params->sb_size != sb_size) {
2523 av1_free_context_buffers(cm);
2524 av1_free_pc_tree(&cpi->td, num_planes);
2525 alloc_compressor_data(cpi);
2526 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
2535 set_tile_info(cpi);
2536
2537 cpi->ext_refresh_frame_flags_pending = 0;
2538 cpi->ext_refresh_frame_context_pending = 0;
2539
2540 highbd_set_var_fns(cpi);
2541
2542 // Init sequence level coding tools
2543 // This should not be called after the first key frame.
2544 if (!cpi->seq_params_locked) {
2545 seq_params->operating_points_cnt_minus_1 =
2546 cm->number_spatial_layers > 1 ? cm->number_spatial_layers - 1 : 0;
2547 init_seq_coding_tools(&cm->seq_params, cm, oxcf);
2548 }
2549 }
2550
init_level_info(AV1LevelInfo * level_info)2551 static void init_level_info(AV1LevelInfo *level_info) {
2552 memset(level_info, 0, MAX_NUM_OPERATING_POINTS * sizeof(*level_info));
2553 for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i) {
2554 AV1LevelSpec *const level_spec = &level_info[i].level_spec;
2555 level_spec->level = SEQ_LEVEL_MAX;
2556 AV1LevelStats *const level_stats = &level_info[i].level_stats;
2557 level_stats->min_cropped_tile_width = INT_MAX;
2558 level_stats->min_cropped_tile_height = INT_MAX;
2559 level_stats->min_frame_width = INT_MAX;
2560 level_stats->min_frame_height = INT_MAX;
2561 level_stats->tile_width_is_valid = 1;
2562 level_stats->min_cr = 1e8;
2563 }
2564 }
2565
av1_create_compressor(AV1EncoderConfig * oxcf,BufferPool * const pool)2566 AV1_COMP *av1_create_compressor(AV1EncoderConfig *oxcf,
2567 BufferPool *const pool) {
2568 unsigned int i;
2569 AV1_COMP *volatile const cpi = aom_memalign(32, sizeof(AV1_COMP));
2570 AV1_COMMON *volatile const cm = cpi != NULL ? &cpi->common : NULL;
2571
2572 if (!cm) return NULL;
2573
2574 av1_zero(*cpi);
2575
2576 // The jmp_buf is valid only for the duration of the function that calls
2577 // setjmp(). Therefore, this function must reset the 'setjmp' field to 0
2578 // before it returns.
2579 if (setjmp(cm->error.jmp)) {
2580 cm->error.setjmp = 0;
2581 av1_remove_compressor(cpi);
2582 return 0;
2583 }
2584
2585 cm->error.setjmp = 1;
2586 cm->alloc_mi = enc_alloc_mi;
2587 cm->free_mi = enc_free_mi;
2588 cm->setup_mi = enc_setup_mi;
2589
2590 CHECK_MEM_ERROR(cm, cm->fc,
2591 (FRAME_CONTEXT *)aom_memalign(32, sizeof(*cm->fc)));
2592 CHECK_MEM_ERROR(
2593 cm, cm->default_frame_context,
2594 (FRAME_CONTEXT *)aom_memalign(32, sizeof(*cm->default_frame_context)));
2595 memset(cm->fc, 0, sizeof(*cm->fc));
2596 memset(cm->default_frame_context, 0, sizeof(*cm->default_frame_context));
2597
2598 cpi->resize_state = 0;
2599 cpi->resize_avg_qp = 0;
2600 cpi->resize_buffer_underflow = 0;
2601
2602 cpi->common.buffer_pool = pool;
2603
2604 init_config(cpi, oxcf);
2605 av1_rc_init(&cpi->oxcf, oxcf->pass, &cpi->rc);
2606
2607 cm->current_frame.frame_number = 0;
2608 cm->current_frame_id = -1;
2609 cpi->seq_params_locked = 0;
2610 cpi->partition_search_skippable_frame = 0;
2611 cpi->tile_data = NULL;
2612 cpi->last_show_frame_buf = NULL;
2613 realloc_segmentation_maps(cpi);
2614
2615 memset(cpi->nmv_costs, 0, sizeof(cpi->nmv_costs));
2616 memset(cpi->nmv_costs_hp, 0, sizeof(cpi->nmv_costs_hp));
2617
2618 for (i = 0; i < (sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]));
2619 i++) {
2620 CHECK_MEM_ERROR(
2621 cm, cpi->mbgraph_stats[i].mb_stats,
2622 aom_calloc(cm->MBs * sizeof(*cpi->mbgraph_stats[i].mb_stats), 1));
2623 }
2624
2625 cpi->refresh_alt_ref_frame = 0;
2626
2627 init_level_info(cpi->level_info);
2628
2629 cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS;
2630 #if CONFIG_INTERNAL_STATS
2631 cpi->b_calculate_blockiness = 1;
2632 cpi->b_calculate_consistency = 1;
2633 cpi->total_inconsistency = 0;
2634 cpi->psnr.worst = 100.0;
2635 cpi->worst_ssim = 100.0;
2636
2637 cpi->count = 0;
2638 cpi->bytes = 0;
2639 #if CONFIG_SPEED_STATS
2640 cpi->tx_search_count = 0;
2641 #endif // CONFIG_SPEED_STATS
2642
2643 if (cpi->b_calculate_psnr) {
2644 cpi->total_sq_error = 0;
2645 cpi->total_samples = 0;
2646 cpi->tot_recode_hits = 0;
2647 cpi->summed_quality = 0;
2648 cpi->summed_weights = 0;
2649 }
2650
2651 cpi->fastssim.worst = 100.0;
2652 cpi->psnrhvs.worst = 100.0;
2653
2654 if (cpi->b_calculate_blockiness) {
2655 cpi->total_blockiness = 0;
2656 cpi->worst_blockiness = 0.0;
2657 }
2658
2659 if (cpi->b_calculate_consistency) {
2660 CHECK_MEM_ERROR(cm, cpi->ssim_vars,
2661 aom_malloc(sizeof(*cpi->ssim_vars) * 4 *
2662 cpi->common.mi_rows * cpi->common.mi_cols));
2663 cpi->worst_consistency = 100.0;
2664 }
2665 #endif
2666 #if CONFIG_ENTROPY_STATS
2667 av1_zero(aggregate_fc);
2668 #endif // CONFIG_ENTROPY_STATS
2669
2670 cpi->first_time_stamp_ever = INT64_MAX;
2671
2672 cpi->td.mb.nmvcost[0] = &cpi->nmv_costs[0][MV_MAX];
2673 cpi->td.mb.nmvcost[1] = &cpi->nmv_costs[1][MV_MAX];
2674 cpi->td.mb.nmvcost_hp[0] = &cpi->nmv_costs_hp[0][MV_MAX];
2675 cpi->td.mb.nmvcost_hp[1] = &cpi->nmv_costs_hp[1][MV_MAX];
2676
2677 #ifdef OUTPUT_YUV_SKINMAP
2678 yuv_skinmap_file = fopen("skinmap.yuv", "ab");
2679 #endif
2680 #ifdef OUTPUT_YUV_REC
2681 yuv_rec_file = fopen("rec.yuv", "wb");
2682 #endif
2683
2684 if (oxcf->pass == 1) {
2685 av1_init_first_pass(cpi);
2686 } else if (oxcf->pass == 2) {
2687 const size_t packet_sz = sizeof(FIRSTPASS_STATS);
2688 const int packets = (int)(oxcf->two_pass_stats_in.sz / packet_sz);
2689
2690 cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf;
2691 cpi->twopass.stats_in = cpi->twopass.stats_in_start;
2692 cpi->twopass.stats_in_end = &cpi->twopass.stats_in[packets - 1];
2693
2694 av1_init_second_pass(cpi);
2695 }
2696
2697 CHECK_MEM_ERROR(
2698 cm, cpi->td.mb.above_pred_buf,
2699 (uint8_t *)aom_memalign(16, MAX_MB_PLANE * MAX_SB_SQUARE *
2700 sizeof(*cpi->td.mb.above_pred_buf)));
2701 CHECK_MEM_ERROR(
2702 cm, cpi->td.mb.left_pred_buf,
2703 (uint8_t *)aom_memalign(16, MAX_MB_PLANE * MAX_SB_SQUARE *
2704 sizeof(*cpi->td.mb.left_pred_buf)));
2705
2706 CHECK_MEM_ERROR(cm, cpi->td.mb.wsrc_buf,
2707 (int32_t *)aom_memalign(
2708 16, MAX_SB_SQUARE * sizeof(*cpi->td.mb.wsrc_buf)));
2709
2710 CHECK_MEM_ERROR(
2711 cm, cpi->td.mb.inter_modes_info,
2712 (InterModesInfo *)aom_malloc(sizeof(*cpi->td.mb.inter_modes_info)));
2713
2714 for (int x = 0; x < 2; x++)
2715 for (int y = 0; y < 2; y++)
2716 CHECK_MEM_ERROR(
2717 cm, cpi->td.mb.hash_value_buffer[x][y],
2718 (uint32_t *)aom_malloc(AOM_BUFFER_SIZE_FOR_BLOCK_HASH *
2719 sizeof(*cpi->td.mb.hash_value_buffer[0][0])));
2720
2721 cpi->td.mb.g_crc_initialized = 0;
2722
2723 CHECK_MEM_ERROR(cm, cpi->td.mb.mask_buf,
2724 (int32_t *)aom_memalign(
2725 16, MAX_SB_SQUARE * sizeof(*cpi->td.mb.mask_buf)));
2726
2727 av1_set_speed_features_framesize_independent(cpi, oxcf->speed);
2728 av1_set_speed_features_framesize_dependent(cpi, oxcf->speed);
2729
2730 for (int frame = 0; frame < MAX_LAG_BUFFERS; ++frame) {
2731 int mi_cols = ALIGN_POWER_OF_TWO(cm->mi_cols, MAX_MIB_SIZE_LOG2);
2732 int mi_rows = ALIGN_POWER_OF_TWO(cm->mi_rows, MAX_MIB_SIZE_LOG2);
2733
2734 CHECK_MEM_ERROR(cm, cpi->tpl_stats[frame].tpl_stats_ptr,
2735 aom_calloc(mi_rows * mi_cols,
2736 sizeof(*cpi->tpl_stats[frame].tpl_stats_ptr)));
2737 cpi->tpl_stats[frame].is_valid = 0;
2738 cpi->tpl_stats[frame].width = mi_cols;
2739 cpi->tpl_stats[frame].height = mi_rows;
2740 cpi->tpl_stats[frame].stride = mi_cols;
2741 cpi->tpl_stats[frame].mi_rows = cm->mi_rows;
2742 cpi->tpl_stats[frame].mi_cols = cm->mi_cols;
2743 }
2744
2745 #if CONFIG_COLLECT_PARTITION_STATS == 2
2746 av1_zero(cpi->partition_stats);
2747 #endif
2748
2749 #define BFP(BT, SDF, SDAF, VF, SVF, SVAF, SDX4DF, JSDAF, JSVAF) \
2750 cpi->fn_ptr[BT].sdf = SDF; \
2751 cpi->fn_ptr[BT].sdaf = SDAF; \
2752 cpi->fn_ptr[BT].vf = VF; \
2753 cpi->fn_ptr[BT].svf = SVF; \
2754 cpi->fn_ptr[BT].svaf = SVAF; \
2755 cpi->fn_ptr[BT].sdx4df = SDX4DF; \
2756 cpi->fn_ptr[BT].jsdaf = JSDAF; \
2757 cpi->fn_ptr[BT].jsvaf = JSVAF;
2758
2759 BFP(BLOCK_4X16, aom_sad4x16, aom_sad4x16_avg, aom_variance4x16,
2760 aom_sub_pixel_variance4x16, aom_sub_pixel_avg_variance4x16,
2761 aom_sad4x16x4d, aom_dist_wtd_sad4x16_avg,
2762 aom_dist_wtd_sub_pixel_avg_variance4x16)
2763
2764 BFP(BLOCK_16X4, aom_sad16x4, aom_sad16x4_avg, aom_variance16x4,
2765 aom_sub_pixel_variance16x4, aom_sub_pixel_avg_variance16x4,
2766 aom_sad16x4x4d, aom_dist_wtd_sad16x4_avg,
2767 aom_dist_wtd_sub_pixel_avg_variance16x4)
2768
2769 BFP(BLOCK_8X32, aom_sad8x32, aom_sad8x32_avg, aom_variance8x32,
2770 aom_sub_pixel_variance8x32, aom_sub_pixel_avg_variance8x32,
2771 aom_sad8x32x4d, aom_dist_wtd_sad8x32_avg,
2772 aom_dist_wtd_sub_pixel_avg_variance8x32)
2773
2774 BFP(BLOCK_32X8, aom_sad32x8, aom_sad32x8_avg, aom_variance32x8,
2775 aom_sub_pixel_variance32x8, aom_sub_pixel_avg_variance32x8,
2776 aom_sad32x8x4d, aom_dist_wtd_sad32x8_avg,
2777 aom_dist_wtd_sub_pixel_avg_variance32x8)
2778
2779 BFP(BLOCK_16X64, aom_sad16x64, aom_sad16x64_avg, aom_variance16x64,
2780 aom_sub_pixel_variance16x64, aom_sub_pixel_avg_variance16x64,
2781 aom_sad16x64x4d, aom_dist_wtd_sad16x64_avg,
2782 aom_dist_wtd_sub_pixel_avg_variance16x64)
2783
2784 BFP(BLOCK_64X16, aom_sad64x16, aom_sad64x16_avg, aom_variance64x16,
2785 aom_sub_pixel_variance64x16, aom_sub_pixel_avg_variance64x16,
2786 aom_sad64x16x4d, aom_dist_wtd_sad64x16_avg,
2787 aom_dist_wtd_sub_pixel_avg_variance64x16)
2788
2789 BFP(BLOCK_128X128, aom_sad128x128, aom_sad128x128_avg, aom_variance128x128,
2790 aom_sub_pixel_variance128x128, aom_sub_pixel_avg_variance128x128,
2791 aom_sad128x128x4d, aom_dist_wtd_sad128x128_avg,
2792 aom_dist_wtd_sub_pixel_avg_variance128x128)
2793
2794 BFP(BLOCK_128X64, aom_sad128x64, aom_sad128x64_avg, aom_variance128x64,
2795 aom_sub_pixel_variance128x64, aom_sub_pixel_avg_variance128x64,
2796 aom_sad128x64x4d, aom_dist_wtd_sad128x64_avg,
2797 aom_dist_wtd_sub_pixel_avg_variance128x64)
2798
2799 BFP(BLOCK_64X128, aom_sad64x128, aom_sad64x128_avg, aom_variance64x128,
2800 aom_sub_pixel_variance64x128, aom_sub_pixel_avg_variance64x128,
2801 aom_sad64x128x4d, aom_dist_wtd_sad64x128_avg,
2802 aom_dist_wtd_sub_pixel_avg_variance64x128)
2803
2804 BFP(BLOCK_32X16, aom_sad32x16, aom_sad32x16_avg, aom_variance32x16,
2805 aom_sub_pixel_variance32x16, aom_sub_pixel_avg_variance32x16,
2806 aom_sad32x16x4d, aom_dist_wtd_sad32x16_avg,
2807 aom_dist_wtd_sub_pixel_avg_variance32x16)
2808
2809 BFP(BLOCK_16X32, aom_sad16x32, aom_sad16x32_avg, aom_variance16x32,
2810 aom_sub_pixel_variance16x32, aom_sub_pixel_avg_variance16x32,
2811 aom_sad16x32x4d, aom_dist_wtd_sad16x32_avg,
2812 aom_dist_wtd_sub_pixel_avg_variance16x32)
2813
2814 BFP(BLOCK_64X32, aom_sad64x32, aom_sad64x32_avg, aom_variance64x32,
2815 aom_sub_pixel_variance64x32, aom_sub_pixel_avg_variance64x32,
2816 aom_sad64x32x4d, aom_dist_wtd_sad64x32_avg,
2817 aom_dist_wtd_sub_pixel_avg_variance64x32)
2818
2819 BFP(BLOCK_32X64, aom_sad32x64, aom_sad32x64_avg, aom_variance32x64,
2820 aom_sub_pixel_variance32x64, aom_sub_pixel_avg_variance32x64,
2821 aom_sad32x64x4d, aom_dist_wtd_sad32x64_avg,
2822 aom_dist_wtd_sub_pixel_avg_variance32x64)
2823
2824 BFP(BLOCK_32X32, aom_sad32x32, aom_sad32x32_avg, aom_variance32x32,
2825 aom_sub_pixel_variance32x32, aom_sub_pixel_avg_variance32x32,
2826 aom_sad32x32x4d, aom_dist_wtd_sad32x32_avg,
2827 aom_dist_wtd_sub_pixel_avg_variance32x32)
2828
2829 BFP(BLOCK_64X64, aom_sad64x64, aom_sad64x64_avg, aom_variance64x64,
2830 aom_sub_pixel_variance64x64, aom_sub_pixel_avg_variance64x64,
2831 aom_sad64x64x4d, aom_dist_wtd_sad64x64_avg,
2832 aom_dist_wtd_sub_pixel_avg_variance64x64)
2833
2834 BFP(BLOCK_16X16, aom_sad16x16, aom_sad16x16_avg, aom_variance16x16,
2835 aom_sub_pixel_variance16x16, aom_sub_pixel_avg_variance16x16,
2836 aom_sad16x16x4d, aom_dist_wtd_sad16x16_avg,
2837 aom_dist_wtd_sub_pixel_avg_variance16x16)
2838
2839 BFP(BLOCK_16X8, aom_sad16x8, aom_sad16x8_avg, aom_variance16x8,
2840 aom_sub_pixel_variance16x8, aom_sub_pixel_avg_variance16x8,
2841 aom_sad16x8x4d, aom_dist_wtd_sad16x8_avg,
2842 aom_dist_wtd_sub_pixel_avg_variance16x8)
2843
2844 BFP(BLOCK_8X16, aom_sad8x16, aom_sad8x16_avg, aom_variance8x16,
2845 aom_sub_pixel_variance8x16, aom_sub_pixel_avg_variance8x16,
2846 aom_sad8x16x4d, aom_dist_wtd_sad8x16_avg,
2847 aom_dist_wtd_sub_pixel_avg_variance8x16)
2848
2849 BFP(BLOCK_8X8, aom_sad8x8, aom_sad8x8_avg, aom_variance8x8,
2850 aom_sub_pixel_variance8x8, aom_sub_pixel_avg_variance8x8, aom_sad8x8x4d,
2851 aom_dist_wtd_sad8x8_avg, aom_dist_wtd_sub_pixel_avg_variance8x8)
2852
2853 BFP(BLOCK_8X4, aom_sad8x4, aom_sad8x4_avg, aom_variance8x4,
2854 aom_sub_pixel_variance8x4, aom_sub_pixel_avg_variance8x4, aom_sad8x4x4d,
2855 aom_dist_wtd_sad8x4_avg, aom_dist_wtd_sub_pixel_avg_variance8x4)
2856
2857 BFP(BLOCK_4X8, aom_sad4x8, aom_sad4x8_avg, aom_variance4x8,
2858 aom_sub_pixel_variance4x8, aom_sub_pixel_avg_variance4x8, aom_sad4x8x4d,
2859 aom_dist_wtd_sad4x8_avg, aom_dist_wtd_sub_pixel_avg_variance4x8)
2860
2861 BFP(BLOCK_4X4, aom_sad4x4, aom_sad4x4_avg, aom_variance4x4,
2862 aom_sub_pixel_variance4x4, aom_sub_pixel_avg_variance4x4, aom_sad4x4x4d,
2863 aom_dist_wtd_sad4x4_avg, aom_dist_wtd_sub_pixel_avg_variance4x4)
2864
2865 #define OBFP(BT, OSDF, OVF, OSVF) \
2866 cpi->fn_ptr[BT].osdf = OSDF; \
2867 cpi->fn_ptr[BT].ovf = OVF; \
2868 cpi->fn_ptr[BT].osvf = OSVF;
2869
2870 OBFP(BLOCK_128X128, aom_obmc_sad128x128, aom_obmc_variance128x128,
2871 aom_obmc_sub_pixel_variance128x128)
2872 OBFP(BLOCK_128X64, aom_obmc_sad128x64, aom_obmc_variance128x64,
2873 aom_obmc_sub_pixel_variance128x64)
2874 OBFP(BLOCK_64X128, aom_obmc_sad64x128, aom_obmc_variance64x128,
2875 aom_obmc_sub_pixel_variance64x128)
2876 OBFP(BLOCK_64X64, aom_obmc_sad64x64, aom_obmc_variance64x64,
2877 aom_obmc_sub_pixel_variance64x64)
2878 OBFP(BLOCK_64X32, aom_obmc_sad64x32, aom_obmc_variance64x32,
2879 aom_obmc_sub_pixel_variance64x32)
2880 OBFP(BLOCK_32X64, aom_obmc_sad32x64, aom_obmc_variance32x64,
2881 aom_obmc_sub_pixel_variance32x64)
2882 OBFP(BLOCK_32X32, aom_obmc_sad32x32, aom_obmc_variance32x32,
2883 aom_obmc_sub_pixel_variance32x32)
2884 OBFP(BLOCK_32X16, aom_obmc_sad32x16, aom_obmc_variance32x16,
2885 aom_obmc_sub_pixel_variance32x16)
2886 OBFP(BLOCK_16X32, aom_obmc_sad16x32, aom_obmc_variance16x32,
2887 aom_obmc_sub_pixel_variance16x32)
2888 OBFP(BLOCK_16X16, aom_obmc_sad16x16, aom_obmc_variance16x16,
2889 aom_obmc_sub_pixel_variance16x16)
2890 OBFP(BLOCK_16X8, aom_obmc_sad16x8, aom_obmc_variance16x8,
2891 aom_obmc_sub_pixel_variance16x8)
2892 OBFP(BLOCK_8X16, aom_obmc_sad8x16, aom_obmc_variance8x16,
2893 aom_obmc_sub_pixel_variance8x16)
2894 OBFP(BLOCK_8X8, aom_obmc_sad8x8, aom_obmc_variance8x8,
2895 aom_obmc_sub_pixel_variance8x8)
2896 OBFP(BLOCK_4X8, aom_obmc_sad4x8, aom_obmc_variance4x8,
2897 aom_obmc_sub_pixel_variance4x8)
2898 OBFP(BLOCK_8X4, aom_obmc_sad8x4, aom_obmc_variance8x4,
2899 aom_obmc_sub_pixel_variance8x4)
2900 OBFP(BLOCK_4X4, aom_obmc_sad4x4, aom_obmc_variance4x4,
2901 aom_obmc_sub_pixel_variance4x4)
2902 OBFP(BLOCK_4X16, aom_obmc_sad4x16, aom_obmc_variance4x16,
2903 aom_obmc_sub_pixel_variance4x16)
2904 OBFP(BLOCK_16X4, aom_obmc_sad16x4, aom_obmc_variance16x4,
2905 aom_obmc_sub_pixel_variance16x4)
2906 OBFP(BLOCK_8X32, aom_obmc_sad8x32, aom_obmc_variance8x32,
2907 aom_obmc_sub_pixel_variance8x32)
2908 OBFP(BLOCK_32X8, aom_obmc_sad32x8, aom_obmc_variance32x8,
2909 aom_obmc_sub_pixel_variance32x8)
2910 OBFP(BLOCK_16X64, aom_obmc_sad16x64, aom_obmc_variance16x64,
2911 aom_obmc_sub_pixel_variance16x64)
2912 OBFP(BLOCK_64X16, aom_obmc_sad64x16, aom_obmc_variance64x16,
2913 aom_obmc_sub_pixel_variance64x16)
2914
2915 #define MBFP(BT, MCSDF, MCSVF) \
2916 cpi->fn_ptr[BT].msdf = MCSDF; \
2917 cpi->fn_ptr[BT].msvf = MCSVF;
2918
2919 MBFP(BLOCK_128X128, aom_masked_sad128x128,
2920 aom_masked_sub_pixel_variance128x128)
2921 MBFP(BLOCK_128X64, aom_masked_sad128x64, aom_masked_sub_pixel_variance128x64)
2922 MBFP(BLOCK_64X128, aom_masked_sad64x128, aom_masked_sub_pixel_variance64x128)
2923 MBFP(BLOCK_64X64, aom_masked_sad64x64, aom_masked_sub_pixel_variance64x64)
2924 MBFP(BLOCK_64X32, aom_masked_sad64x32, aom_masked_sub_pixel_variance64x32)
2925 MBFP(BLOCK_32X64, aom_masked_sad32x64, aom_masked_sub_pixel_variance32x64)
2926 MBFP(BLOCK_32X32, aom_masked_sad32x32, aom_masked_sub_pixel_variance32x32)
2927 MBFP(BLOCK_32X16, aom_masked_sad32x16, aom_masked_sub_pixel_variance32x16)
2928 MBFP(BLOCK_16X32, aom_masked_sad16x32, aom_masked_sub_pixel_variance16x32)
2929 MBFP(BLOCK_16X16, aom_masked_sad16x16, aom_masked_sub_pixel_variance16x16)
2930 MBFP(BLOCK_16X8, aom_masked_sad16x8, aom_masked_sub_pixel_variance16x8)
2931 MBFP(BLOCK_8X16, aom_masked_sad8x16, aom_masked_sub_pixel_variance8x16)
2932 MBFP(BLOCK_8X8, aom_masked_sad8x8, aom_masked_sub_pixel_variance8x8)
2933 MBFP(BLOCK_4X8, aom_masked_sad4x8, aom_masked_sub_pixel_variance4x8)
2934 MBFP(BLOCK_8X4, aom_masked_sad8x4, aom_masked_sub_pixel_variance8x4)
2935 MBFP(BLOCK_4X4, aom_masked_sad4x4, aom_masked_sub_pixel_variance4x4)
2936
2937 MBFP(BLOCK_4X16, aom_masked_sad4x16, aom_masked_sub_pixel_variance4x16)
2938
2939 MBFP(BLOCK_16X4, aom_masked_sad16x4, aom_masked_sub_pixel_variance16x4)
2940
2941 MBFP(BLOCK_8X32, aom_masked_sad8x32, aom_masked_sub_pixel_variance8x32)
2942
2943 MBFP(BLOCK_32X8, aom_masked_sad32x8, aom_masked_sub_pixel_variance32x8)
2944
2945 MBFP(BLOCK_16X64, aom_masked_sad16x64, aom_masked_sub_pixel_variance16x64)
2946
2947 MBFP(BLOCK_64X16, aom_masked_sad64x16, aom_masked_sub_pixel_variance64x16)
2948
2949 highbd_set_var_fns(cpi);
2950
2951 /* av1_init_quantizer() is first called here. Add check in
2952 * av1_frame_init_quantizer() so that av1_init_quantizer is only
2953 * called later when needed. This will avoid unnecessary calls of
2954 * av1_init_quantizer() for every frame.
2955 */
2956 av1_init_quantizer(cpi);
2957 av1_qm_init(cm);
2958
2959 av1_loop_filter_init(cm);
2960 cm->superres_scale_denominator = SCALE_NUMERATOR;
2961 cm->superres_upscaled_width = oxcf->width;
2962 cm->superres_upscaled_height = oxcf->height;
2963 av1_loop_restoration_precal();
2964
2965 cm->error.setjmp = 0;
2966
2967 return cpi;
2968 }
2969
2970 #if CONFIG_INTERNAL_STATS
2971 #define SNPRINT(H, T) snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T))
2972
2973 #define SNPRINT2(H, T, V) \
2974 snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T), (V))
2975 #endif // CONFIG_INTERNAL_STATS
2976
av1_remove_compressor(AV1_COMP * cpi)2977 void av1_remove_compressor(AV1_COMP *cpi) {
2978 AV1_COMMON *cm;
2979 unsigned int i;
2980 int t;
2981
2982 if (!cpi) return;
2983
2984 cm = &cpi->common;
2985 const int num_planes = av1_num_planes(cm);
2986
2987 if (cm->current_frame.frame_number > 0) {
2988 #if CONFIG_ENTROPY_STATS
2989 if (cpi->oxcf.pass != 1) {
2990 fprintf(stderr, "Writing counts.stt\n");
2991 FILE *f = fopen("counts.stt", "wb");
2992 fwrite(&aggregate_fc, sizeof(aggregate_fc), 1, f);
2993 fclose(f);
2994 }
2995 #endif // CONFIG_ENTROPY_STATS
2996 #if CONFIG_INTERNAL_STATS
2997 aom_clear_system_state();
2998
2999 if (cpi->oxcf.pass != 1) {
3000 char headings[512] = { 0 };
3001 char results[512] = { 0 };
3002 FILE *f = fopen("opsnr.stt", "a");
3003 double time_encoded =
3004 (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) /
3005 10000000.000;
3006 double total_encode_time =
3007 (cpi->time_receive_data + cpi->time_compress_data) / 1000.000;
3008 const double dr =
3009 (double)cpi->bytes * (double)8 / (double)1000 / time_encoded;
3010 const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1);
3011 const double target_rate = (double)cpi->oxcf.target_bandwidth / 1000;
3012 const double rate_err = ((100.0 * (dr - target_rate)) / target_rate);
3013
3014 if (cpi->b_calculate_psnr) {
3015 const double total_psnr = aom_sse_to_psnr(
3016 (double)cpi->total_samples, peak, (double)cpi->total_sq_error);
3017 const double total_ssim =
3018 100 * pow(cpi->summed_quality / cpi->summed_weights, 8.0);
3019 snprintf(headings, sizeof(headings),
3020 "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\t"
3021 "AOMSSIM\tVPSSIMP\tFASTSIM\tPSNRHVS\t"
3022 "WstPsnr\tWstSsim\tWstFast\tWstHVS\t"
3023 "AVPsrnY\tAPsnrCb\tAPsnrCr");
3024 snprintf(results, sizeof(results),
3025 "%7.2f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
3026 "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
3027 "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
3028 "%7.3f\t%7.3f\t%7.3f",
3029 dr, cpi->psnr.stat[STAT_ALL] / cpi->count, total_psnr,
3030 cpi->psnr.stat[STAT_ALL] / cpi->count, total_psnr, total_ssim,
3031 total_ssim, cpi->fastssim.stat[STAT_ALL] / cpi->count,
3032 cpi->psnrhvs.stat[STAT_ALL] / cpi->count, cpi->psnr.worst,
3033 cpi->worst_ssim, cpi->fastssim.worst, cpi->psnrhvs.worst,
3034 cpi->psnr.stat[STAT_Y] / cpi->count,
3035 cpi->psnr.stat[STAT_U] / cpi->count,
3036 cpi->psnr.stat[STAT_V] / cpi->count);
3037
3038 if (cpi->b_calculate_blockiness) {
3039 SNPRINT(headings, "\t Block\tWstBlck");
3040 SNPRINT2(results, "\t%7.3f", cpi->total_blockiness / cpi->count);
3041 SNPRINT2(results, "\t%7.3f", cpi->worst_blockiness);
3042 }
3043
3044 if (cpi->b_calculate_consistency) {
3045 double consistency =
3046 aom_sse_to_psnr((double)cpi->total_samples, peak,
3047 (double)cpi->total_inconsistency);
3048
3049 SNPRINT(headings, "\tConsist\tWstCons");
3050 SNPRINT2(results, "\t%7.3f", consistency);
3051 SNPRINT2(results, "\t%7.3f", cpi->worst_consistency);
3052 }
3053 fprintf(f, "%s\t Time\tRcErr\tAbsErr\n", headings);
3054 fprintf(f, "%s\t%8.0f\t%7.2f\t%7.2f\n", results, total_encode_time,
3055 rate_err, fabs(rate_err));
3056 }
3057
3058 fclose(f);
3059 }
3060 #endif // CONFIG_INTERNAL_STATS
3061 #if CONFIG_SPEED_STATS
3062 if (cpi->oxcf.pass != 1) {
3063 fprintf(stdout, "tx_search_count = %d\n", cpi->tx_search_count);
3064 }
3065 #endif // CONFIG_SPEED_STATS
3066
3067 #if CONFIG_COLLECT_PARTITION_STATS == 2
3068 if (cpi->oxcf.pass != 1) {
3069 av1_print_partition_stats(&cpi->partition_stats);
3070 }
3071 #endif
3072 }
3073
3074 for (int frame = 0; frame < MAX_LAG_BUFFERS; ++frame) {
3075 aom_free(cpi->tpl_stats[frame].tpl_stats_ptr);
3076 cpi->tpl_stats[frame].is_valid = 0;
3077 }
3078
3079 for (t = cpi->num_workers - 1; t >= 0; --t) {
3080 AVxWorker *const worker = &cpi->workers[t];
3081 EncWorkerData *const thread_data = &cpi->tile_thr_data[t];
3082
3083 // Deallocate allocated threads.
3084 aom_get_worker_interface()->end(worker);
3085
3086 // Deallocate allocated thread data.
3087 if (cpi->row_mt == 1) aom_free(thread_data->td->tctx);
3088 if (t > 0) {
3089 aom_free(thread_data->td->palette_buffer);
3090 aom_free(thread_data->td->tmp_conv_dst);
3091 for (int j = 0; j < 2; ++j) {
3092 aom_free(thread_data->td->tmp_obmc_bufs[j]);
3093 }
3094 aom_free(thread_data->td->above_pred_buf);
3095 aom_free(thread_data->td->left_pred_buf);
3096 aom_free(thread_data->td->wsrc_buf);
3097
3098 aom_free(thread_data->td->inter_modes_info);
3099 for (int x = 0; x < 2; x++) {
3100 for (int y = 0; y < 2; y++) {
3101 aom_free(thread_data->td->hash_value_buffer[x][y]);
3102 thread_data->td->hash_value_buffer[x][y] = NULL;
3103 }
3104 }
3105 aom_free(thread_data->td->mask_buf);
3106 aom_free(thread_data->td->counts);
3107 av1_free_pc_tree(thread_data->td, num_planes);
3108 aom_free(thread_data->td);
3109 }
3110 }
3111 #if CONFIG_MULTITHREAD
3112 if (cpi->row_mt == 1) {
3113 if (cpi->row_mt_mutex_ != NULL) {
3114 pthread_mutex_destroy(cpi->row_mt_mutex_);
3115 aom_free(cpi->row_mt_mutex_);
3116 }
3117 }
3118 #endif
3119 av1_row_mt_mem_dealloc(cpi);
3120 aom_free(cpi->tile_thr_data);
3121 aom_free(cpi->workers);
3122
3123 if (cpi->num_workers > 1) {
3124 av1_loop_filter_dealloc(&cpi->lf_row_sync);
3125 av1_loop_restoration_dealloc(&cpi->lr_row_sync, cpi->num_workers);
3126 }
3127
3128 dealloc_compressor_data(cpi);
3129
3130 for (i = 0; i < sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]);
3131 ++i) {
3132 aom_free(cpi->mbgraph_stats[i].mb_stats);
3133 }
3134
3135 #if CONFIG_INTERNAL_STATS
3136 aom_free(cpi->ssim_vars);
3137 cpi->ssim_vars = NULL;
3138 #endif // CONFIG_INTERNAL_STATS
3139
3140 av1_remove_common(cm);
3141 for (i = 0; i < FRAME_BUFFERS; ++i) {
3142 av1_hash_table_destroy(&cm->buffer_pool->frame_bufs[i].hash_table);
3143 }
3144 if (cpi->sf.use_hash_based_trellis) hbt_destroy();
3145 av1_free_ref_frame_buffers(cm->buffer_pool);
3146 aom_free(cpi);
3147
3148 #ifdef OUTPUT_YUV_SKINMAP
3149 fclose(yuv_skinmap_file);
3150 #endif
3151 #ifdef OUTPUT_YUV_REC
3152 fclose(yuv_rec_file);
3153 #endif
3154 }
3155
generate_psnr_packet(AV1_COMP * cpi)3156 static void generate_psnr_packet(AV1_COMP *cpi) {
3157 struct aom_codec_cx_pkt pkt;
3158 int i;
3159 PSNR_STATS psnr;
3160 aom_calc_highbd_psnr(cpi->source, &cpi->common.cur_frame->buf, &psnr,
3161 cpi->td.mb.e_mbd.bd, cpi->oxcf.input_bit_depth);
3162
3163 for (i = 0; i < 4; ++i) {
3164 pkt.data.psnr.samples[i] = psnr.samples[i];
3165 pkt.data.psnr.sse[i] = psnr.sse[i];
3166 pkt.data.psnr.psnr[i] = psnr.psnr[i];
3167 }
3168 pkt.kind = AOM_CODEC_PSNR_PKT;
3169 aom_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
3170 }
3171
av1_use_as_reference(AV1_COMP * cpi,int ref_frame_flags)3172 int av1_use_as_reference(AV1_COMP *cpi, int ref_frame_flags) {
3173 if (ref_frame_flags > ((1 << INTER_REFS_PER_FRAME) - 1)) return -1;
3174
3175 cpi->ext_ref_frame_flags = ref_frame_flags;
3176 return 0;
3177 }
3178
av1_copy_reference_enc(AV1_COMP * cpi,int idx,YV12_BUFFER_CONFIG * sd)3179 int av1_copy_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd) {
3180 AV1_COMMON *const cm = &cpi->common;
3181 const int num_planes = av1_num_planes(cm);
3182 YV12_BUFFER_CONFIG *cfg = get_ref_frame(cm, idx);
3183 if (cfg) {
3184 aom_yv12_copy_frame(cfg, sd, num_planes);
3185 return 0;
3186 } else {
3187 return -1;
3188 }
3189 }
3190
av1_set_reference_enc(AV1_COMP * cpi,int idx,YV12_BUFFER_CONFIG * sd)3191 int av1_set_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd) {
3192 AV1_COMMON *const cm = &cpi->common;
3193 const int num_planes = av1_num_planes(cm);
3194 YV12_BUFFER_CONFIG *cfg = get_ref_frame(cm, idx);
3195 if (cfg) {
3196 aom_yv12_copy_frame(sd, cfg, num_planes);
3197 return 0;
3198 } else {
3199 return -1;
3200 }
3201 }
3202
av1_update_entropy(AV1_COMP * cpi,int update)3203 int av1_update_entropy(AV1_COMP *cpi, int update) {
3204 cpi->ext_refresh_frame_context = update;
3205 cpi->ext_refresh_frame_context_pending = 1;
3206 return 0;
3207 }
3208
3209 #if defined(OUTPUT_YUV_DENOISED) || defined(OUTPUT_YUV_SKINMAP)
3210 // The denoiser buffer is allocated as a YUV 440 buffer. This function writes it
3211 // as YUV 420. We simply use the top-left pixels of the UV buffers, since we do
3212 // not denoise the UV channels at this time. If ever we implement UV channel
3213 // denoising we will have to modify this.
aom_write_yuv_frame_420(YV12_BUFFER_CONFIG * s,FILE * f)3214 void aom_write_yuv_frame_420(YV12_BUFFER_CONFIG *s, FILE *f) {
3215 uint8_t *src = s->y_buffer;
3216 int h = s->y_height;
3217
3218 do {
3219 fwrite(src, s->y_width, 1, f);
3220 src += s->y_stride;
3221 } while (--h);
3222
3223 src = s->u_buffer;
3224 h = s->uv_height;
3225
3226 do {
3227 fwrite(src, s->uv_width, 1, f);
3228 src += s->uv_stride;
3229 } while (--h);
3230
3231 src = s->v_buffer;
3232 h = s->uv_height;
3233
3234 do {
3235 fwrite(src, s->uv_width, 1, f);
3236 src += s->uv_stride;
3237 } while (--h);
3238 }
3239 #endif
3240
3241 #ifdef OUTPUT_YUV_REC
aom_write_one_yuv_frame(AV1_COMMON * cm,YV12_BUFFER_CONFIG * s)3242 void aom_write_one_yuv_frame(AV1_COMMON *cm, YV12_BUFFER_CONFIG *s) {
3243 uint8_t *src = s->y_buffer;
3244 int h = cm->height;
3245 if (yuv_rec_file == NULL) return;
3246 if (s->flags & YV12_FLAG_HIGHBITDEPTH) {
3247 uint16_t *src16 = CONVERT_TO_SHORTPTR(s->y_buffer);
3248
3249 do {
3250 fwrite(src16, s->y_width, 2, yuv_rec_file);
3251 src16 += s->y_stride;
3252 } while (--h);
3253
3254 src16 = CONVERT_TO_SHORTPTR(s->u_buffer);
3255 h = s->uv_height;
3256
3257 do {
3258 fwrite(src16, s->uv_width, 2, yuv_rec_file);
3259 src16 += s->uv_stride;
3260 } while (--h);
3261
3262 src16 = CONVERT_TO_SHORTPTR(s->v_buffer);
3263 h = s->uv_height;
3264
3265 do {
3266 fwrite(src16, s->uv_width, 2, yuv_rec_file);
3267 src16 += s->uv_stride;
3268 } while (--h);
3269
3270 fflush(yuv_rec_file);
3271 return;
3272 }
3273
3274 do {
3275 fwrite(src, s->y_width, 1, yuv_rec_file);
3276 src += s->y_stride;
3277 } while (--h);
3278
3279 src = s->u_buffer;
3280 h = s->uv_height;
3281
3282 do {
3283 fwrite(src, s->uv_width, 1, yuv_rec_file);
3284 src += s->uv_stride;
3285 } while (--h);
3286
3287 src = s->v_buffer;
3288 h = s->uv_height;
3289
3290 do {
3291 fwrite(src, s->uv_width, 1, yuv_rec_file);
3292 src += s->uv_stride;
3293 } while (--h);
3294
3295 fflush(yuv_rec_file);
3296 }
3297 #endif // OUTPUT_YUV_REC
3298
3299 #define GM_RECODE_LOOP_NUM4X4_FACTOR 192
recode_loop_test_global_motion(AV1_COMP * cpi)3300 static int recode_loop_test_global_motion(AV1_COMP *cpi) {
3301 int i;
3302 int recode = 0;
3303 RD_COUNTS *const rdc = &cpi->td.rd_counts;
3304 AV1_COMMON *const cm = &cpi->common;
3305 for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
3306 if (cm->global_motion[i].wmtype != IDENTITY &&
3307 rdc->global_motion_used[i] * GM_RECODE_LOOP_NUM4X4_FACTOR <
3308 cpi->gmparams_cost[i]) {
3309 cm->global_motion[i] = default_warp_params;
3310 assert(cm->global_motion[i].wmtype == IDENTITY);
3311 cpi->gmparams_cost[i] = 0;
3312 recode = 1;
3313 // TODO(sarahparker): The earlier condition for recoding here was:
3314 // "recode |= (rdc->global_motion_used[i] > 0);". Can we bring something
3315 // similar to that back to speed up global motion?
3316 }
3317 }
3318 return recode;
3319 }
3320
3321 // Function to test for conditions that indicate we should loop
3322 // back and recode a frame.
recode_loop_test(AV1_COMP * cpi,int high_limit,int low_limit,int q,int maxq,int minq)3323 static int recode_loop_test(AV1_COMP *cpi, int high_limit, int low_limit, int q,
3324 int maxq, int minq) {
3325 const RATE_CONTROL *const rc = &cpi->rc;
3326 const AV1EncoderConfig *const oxcf = &cpi->oxcf;
3327 const int frame_is_kfgfarf = frame_is_kf_gf_arf(cpi);
3328 int force_recode = 0;
3329
3330 if ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
3331 (cpi->sf.recode_loop == ALLOW_RECODE) ||
3332 (frame_is_kfgfarf && (cpi->sf.recode_loop == ALLOW_RECODE_KFARFGF))) {
3333 // TODO(agrange) high_limit could be greater than the scale-down threshold.
3334 if ((rc->projected_frame_size > high_limit && q < maxq) ||
3335 (rc->projected_frame_size < low_limit && q > minq)) {
3336 force_recode = 1;
3337 } else if (cpi->oxcf.rc_mode == AOM_CQ) {
3338 // Deal with frame undershoot and whether or not we are
3339 // below the automatically set cq level.
3340 if (q > oxcf->cq_level &&
3341 rc->projected_frame_size < ((rc->this_frame_target * 7) >> 3)) {
3342 force_recode = 1;
3343 }
3344 }
3345 }
3346 return force_recode;
3347 }
3348
scale_references(AV1_COMP * cpi)3349 static void scale_references(AV1_COMP *cpi) {
3350 AV1_COMMON *cm = &cpi->common;
3351 const int num_planes = av1_num_planes(cm);
3352 MV_REFERENCE_FRAME ref_frame;
3353 const AOM_REFFRAME ref_mask[INTER_REFS_PER_FRAME] = {
3354 AOM_LAST_FLAG, AOM_LAST2_FLAG, AOM_LAST3_FLAG, AOM_GOLD_FLAG,
3355 AOM_BWD_FLAG, AOM_ALT2_FLAG, AOM_ALT_FLAG
3356 };
3357
3358 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3359 // Need to convert from AOM_REFFRAME to index into ref_mask (subtract 1).
3360 if (cpi->ref_frame_flags & ref_mask[ref_frame - 1]) {
3361 BufferPool *const pool = cm->buffer_pool;
3362 const YV12_BUFFER_CONFIG *const ref =
3363 get_ref_frame_yv12_buf(cm, ref_frame);
3364
3365 if (ref == NULL) {
3366 cpi->scaled_ref_buf[ref_frame - 1] = NULL;
3367 continue;
3368 }
3369
3370 if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) {
3371 // Replace the reference buffer with a copy having a thicker border,
3372 // if the reference buffer is higher resolution than the current
3373 // frame, and the border is thin.
3374 if ((ref->y_crop_width > cm->width ||
3375 ref->y_crop_height > cm->height) &&
3376 ref->border < AOM_BORDER_IN_PIXELS) {
3377 RefCntBuffer *ref_fb = get_ref_frame_buf(cm, ref_frame);
3378 if (aom_yv12_realloc_with_new_border(
3379 &ref_fb->buf, AOM_BORDER_IN_PIXELS, cm->byte_alignment,
3380 num_planes) != 0) {
3381 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
3382 "Failed to allocate frame buffer");
3383 }
3384 }
3385 int force_scaling = 0;
3386 RefCntBuffer *new_fb = cpi->scaled_ref_buf[ref_frame - 1];
3387 if (new_fb == NULL) {
3388 const int new_fb_idx = get_free_fb(cm);
3389 if (new_fb_idx == INVALID_IDX) {
3390 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
3391 "Unable to find free frame buffer");
3392 }
3393 force_scaling = 1;
3394 new_fb = &pool->frame_bufs[new_fb_idx];
3395 }
3396
3397 if (force_scaling || new_fb->buf.y_crop_width != cm->width ||
3398 new_fb->buf.y_crop_height != cm->height) {
3399 if (aom_realloc_frame_buffer(
3400 &new_fb->buf, cm->width, cm->height,
3401 cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,
3402 cm->seq_params.use_highbitdepth, AOM_BORDER_IN_PIXELS,
3403 cm->byte_alignment, NULL, NULL, NULL)) {
3404 if (force_scaling) {
3405 // Release the reference acquired in the get_free_fb() call above.
3406 --new_fb->ref_count;
3407 }
3408 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
3409 "Failed to allocate frame buffer");
3410 }
3411 av1_resize_and_extend_frame(
3412 ref, &new_fb->buf, (int)cm->seq_params.bit_depth, num_planes);
3413 cpi->scaled_ref_buf[ref_frame - 1] = new_fb;
3414 alloc_frame_mvs(cm, new_fb);
3415 }
3416 } else {
3417 RefCntBuffer *buf = get_ref_frame_buf(cm, ref_frame);
3418 buf->buf.y_crop_width = ref->y_crop_width;
3419 buf->buf.y_crop_height = ref->y_crop_height;
3420 cpi->scaled_ref_buf[ref_frame - 1] = buf;
3421 ++buf->ref_count;
3422 }
3423 } else {
3424 if (cpi->oxcf.pass != 0) cpi->scaled_ref_buf[ref_frame - 1] = NULL;
3425 }
3426 }
3427 }
3428
release_scaled_references(AV1_COMP * cpi)3429 static void release_scaled_references(AV1_COMP *cpi) {
3430 // TODO(isbs): only refresh the necessary frames, rather than all of them
3431 for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
3432 RefCntBuffer *const buf = cpi->scaled_ref_buf[i];
3433 if (buf != NULL) {
3434 --buf->ref_count;
3435 cpi->scaled_ref_buf[i] = NULL;
3436 }
3437 }
3438 }
3439
set_mv_search_params(AV1_COMP * cpi)3440 static void set_mv_search_params(AV1_COMP *cpi) {
3441 const AV1_COMMON *const cm = &cpi->common;
3442 const unsigned int max_mv_def = AOMMIN(cm->width, cm->height);
3443
3444 // Default based on max resolution.
3445 cpi->mv_step_param = av1_init_search_range(max_mv_def);
3446
3447 if (cpi->sf.mv.auto_mv_step_size) {
3448 if (frame_is_intra_only(cm)) {
3449 // Initialize max_mv_magnitude for use in the first INTER frame
3450 // after a key/intra-only frame.
3451 cpi->max_mv_magnitude = max_mv_def;
3452 } else {
3453 if (cm->show_frame) {
3454 // Allow mv_steps to correspond to twice the max mv magnitude found
3455 // in the previous frame, capped by the default max_mv_magnitude based
3456 // on resolution.
3457 cpi->mv_step_param = av1_init_search_range(
3458 AOMMIN(max_mv_def, 2 * cpi->max_mv_magnitude));
3459 }
3460 cpi->max_mv_magnitude = 0;
3461 }
3462 }
3463 }
3464
set_screen_content_options(AV1_COMP * cpi)3465 static void set_screen_content_options(AV1_COMP *cpi) {
3466 AV1_COMMON *cm = &cpi->common;
3467
3468 if (cm->seq_params.force_screen_content_tools != 2) {
3469 cm->allow_screen_content_tools = cm->allow_intrabc =
3470 cm->seq_params.force_screen_content_tools;
3471 return;
3472 }
3473
3474 if (cpi->oxcf.content == AOM_CONTENT_SCREEN) {
3475 cm->allow_screen_content_tools = cm->allow_intrabc = 1;
3476 return;
3477 }
3478
3479 // Estimate if the source frame is screen content, based on the portion of
3480 // blocks that have few luma colors.
3481 const uint8_t *src = cpi->source->y_buffer;
3482 assert(src != NULL);
3483 const int use_hbd = cpi->source->flags & YV12_FLAG_HIGHBITDEPTH;
3484 const int stride = cpi->source->y_stride;
3485 const int width = cpi->source->y_width;
3486 const int height = cpi->source->y_height;
3487 const int bd = cm->seq_params.bit_depth;
3488 const int blk_w = 16;
3489 const int blk_h = 16;
3490 // These threshold values are selected experimentally.
3491 const int color_thresh = 4;
3492 const unsigned int var_thresh = 0;
3493 // Counts of blocks with no more than color_thresh colors.
3494 int counts_1 = 0;
3495 // Counts of blocks with no more than color_thresh colors and variance larger
3496 // than var_thresh.
3497 int counts_2 = 0;
3498
3499 for (int r = 0; r + blk_h <= height; r += blk_h) {
3500 for (int c = 0; c + blk_w <= width; c += blk_w) {
3501 int count_buf[1 << 12]; // Maximum (1 << 12) color levels.
3502 const uint8_t *const this_src = src + r * stride + c;
3503 const int n_colors =
3504 use_hbd ? av1_count_colors_highbd(this_src, stride, blk_w, blk_h, bd,
3505 count_buf)
3506 : av1_count_colors(this_src, stride, blk_w, blk_h, count_buf);
3507 if (n_colors > 1 && n_colors <= color_thresh) {
3508 ++counts_1;
3509 struct buf_2d buf;
3510 buf.stride = stride;
3511 buf.buf = (uint8_t *)this_src;
3512 const unsigned int var =
3513 use_hbd
3514 ? av1_high_get_sby_perpixel_variance(cpi, &buf, BLOCK_16X16, bd)
3515 : av1_get_sby_perpixel_variance(cpi, &buf, BLOCK_16X16);
3516 if (var > var_thresh) ++counts_2;
3517 }
3518 }
3519 }
3520
3521 // The threshold values are selected experimentally.
3522 cm->allow_screen_content_tools =
3523 counts_1 * blk_h * blk_w * 10 > width * height;
3524 // IntraBC would force loop filters off, so we use more strict rules that also
3525 // requires that the block has high variance.
3526 cm->allow_intrabc = cm->allow_screen_content_tools &&
3527 counts_2 * blk_h * blk_w * 15 > width * height;
3528 }
3529
set_size_independent_vars(AV1_COMP * cpi)3530 static void set_size_independent_vars(AV1_COMP *cpi) {
3531 int i;
3532 AV1_COMMON *cm = &cpi->common;
3533 for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
3534 cm->global_motion[i] = default_warp_params;
3535 }
3536 cpi->global_motion_search_done = 0;
3537
3538 if (frame_is_intra_only(cm)) set_screen_content_options(cpi);
3539 cpi->is_screen_content_type = (cm->allow_screen_content_tools != 0);
3540
3541 av1_set_speed_features_framesize_independent(cpi, cpi->speed);
3542 av1_set_rd_speed_thresholds(cpi);
3543 cm->interp_filter = SWITCHABLE;
3544 cm->switchable_motion_mode = 1;
3545 }
3546
set_size_dependent_vars(AV1_COMP * cpi,int * q,int * bottom_index,int * top_index)3547 static void set_size_dependent_vars(AV1_COMP *cpi, int *q, int *bottom_index,
3548 int *top_index) {
3549 AV1_COMMON *const cm = &cpi->common;
3550 const AV1EncoderConfig *const oxcf = &cpi->oxcf;
3551
3552 // Setup variables that depend on the dimensions of the frame.
3553 av1_set_speed_features_framesize_dependent(cpi, cpi->speed);
3554
3555 // Decide q and q bounds.
3556 *q = av1_rc_pick_q_and_bounds(cpi, cm->width, cm->height, bottom_index,
3557 top_index);
3558
3559 if (!frame_is_intra_only(cm)) {
3560 set_high_precision_mv(cpi, (*q) < HIGH_PRECISION_MV_QTHRESH,
3561 cpi->common.cur_frame_force_integer_mv);
3562 }
3563
3564 // Configure experimental use of segmentation for enhanced coding of
3565 // static regions if indicated.
3566 // Only allowed in the second pass of a two pass encode, as it requires
3567 // lagged coding, and if the relevant speed feature flag is set.
3568 if (oxcf->pass == 2 && cpi->sf.static_segmentation)
3569 configure_static_seg_features(cpi);
3570 }
3571
init_motion_estimation(AV1_COMP * cpi)3572 static void init_motion_estimation(AV1_COMP *cpi) {
3573 int y_stride = cpi->scaled_source.y_stride;
3574 int y_stride_src = (cpi->oxcf.resize_mode || cpi->oxcf.superres_mode)
3575 ? y_stride
3576 : cpi->lookahead->buf->img.y_stride;
3577
3578 if (cpi->sf.mv.search_method == NSTEP) {
3579 av1_init3smotion_compensation(&cpi->ss_cfg[SS_CFG_SRC], y_stride);
3580 av1_init3smotion_compensation(&cpi->ss_cfg[SS_CFG_LOOKAHEAD], y_stride_src);
3581 } else if (cpi->sf.mv.search_method == DIAMOND) {
3582 av1_init_dsmotion_compensation(&cpi->ss_cfg[SS_CFG_SRC], y_stride);
3583 av1_init_dsmotion_compensation(&cpi->ss_cfg[SS_CFG_LOOKAHEAD],
3584 y_stride_src);
3585 }
3586 }
3587
3588 #define COUPLED_CHROMA_FROM_LUMA_RESTORATION 0
set_restoration_unit_size(int width,int height,int sx,int sy,RestorationInfo * rst)3589 static void set_restoration_unit_size(int width, int height, int sx, int sy,
3590 RestorationInfo *rst) {
3591 (void)width;
3592 (void)height;
3593 (void)sx;
3594 (void)sy;
3595 #if COUPLED_CHROMA_FROM_LUMA_RESTORATION
3596 int s = AOMMIN(sx, sy);
3597 #else
3598 int s = 0;
3599 #endif // !COUPLED_CHROMA_FROM_LUMA_RESTORATION
3600
3601 if (width * height > 352 * 288)
3602 rst[0].restoration_unit_size = RESTORATION_UNITSIZE_MAX;
3603 else
3604 rst[0].restoration_unit_size = (RESTORATION_UNITSIZE_MAX >> 1);
3605 rst[1].restoration_unit_size = rst[0].restoration_unit_size >> s;
3606 rst[2].restoration_unit_size = rst[1].restoration_unit_size;
3607 }
3608
init_ref_frame_bufs(AV1_COMP * cpi)3609 static void init_ref_frame_bufs(AV1_COMP *cpi) {
3610 AV1_COMMON *const cm = &cpi->common;
3611 int i;
3612 BufferPool *const pool = cm->buffer_pool;
3613 cm->cur_frame = NULL;
3614 for (i = 0; i < REF_FRAMES; ++i) {
3615 cm->ref_frame_map[i] = NULL;
3616 }
3617 for (i = 0; i < FRAME_BUFFERS; ++i) {
3618 pool->frame_bufs[i].ref_count = 0;
3619 }
3620 if (cm->seq_params.force_screen_content_tools) {
3621 for (i = 0; i < FRAME_BUFFERS; ++i) {
3622 av1_hash_table_init(&pool->frame_bufs[i].hash_table, &cpi->td.mb);
3623 }
3624 }
3625 }
3626
check_initial_width(AV1_COMP * cpi,int use_highbitdepth,int subsampling_x,int subsampling_y)3627 static void check_initial_width(AV1_COMP *cpi, int use_highbitdepth,
3628 int subsampling_x, int subsampling_y) {
3629 AV1_COMMON *const cm = &cpi->common;
3630 SequenceHeader *const seq_params = &cm->seq_params;
3631
3632 if (!cpi->initial_width || seq_params->use_highbitdepth != use_highbitdepth ||
3633 seq_params->subsampling_x != subsampling_x ||
3634 seq_params->subsampling_y != subsampling_y) {
3635 seq_params->subsampling_x = subsampling_x;
3636 seq_params->subsampling_y = subsampling_y;
3637 seq_params->use_highbitdepth = use_highbitdepth;
3638
3639 alloc_raw_frame_buffers(cpi);
3640 init_ref_frame_bufs(cpi);
3641 alloc_util_frame_buffers(cpi);
3642
3643 init_motion_estimation(cpi); // TODO(agrange) This can be removed.
3644
3645 cpi->initial_width = cm->width;
3646 cpi->initial_height = cm->height;
3647 cpi->initial_mbs = cm->MBs;
3648 }
3649 }
3650
3651 // Returns 1 if the assigned width or height was <= 0.
set_size_literal(AV1_COMP * cpi,int width,int height)3652 static int set_size_literal(AV1_COMP *cpi, int width, int height) {
3653 AV1_COMMON *cm = &cpi->common;
3654 const int num_planes = av1_num_planes(cm);
3655 check_initial_width(cpi, cm->seq_params.use_highbitdepth,
3656 cm->seq_params.subsampling_x,
3657 cm->seq_params.subsampling_y);
3658
3659 if (width <= 0 || height <= 0) return 1;
3660
3661 cm->width = width;
3662 cm->height = height;
3663
3664 if (cpi->initial_width && cpi->initial_height &&
3665 (cm->width > cpi->initial_width || cm->height > cpi->initial_height)) {
3666 av1_free_context_buffers(cm);
3667 av1_free_pc_tree(&cpi->td, num_planes);
3668 alloc_compressor_data(cpi);
3669 realloc_segmentation_maps(cpi);
3670 cpi->initial_width = cpi->initial_height = 0;
3671 }
3672 update_frame_size(cpi);
3673
3674 return 0;
3675 }
3676
av1_set_frame_size(AV1_COMP * cpi,int width,int height)3677 void av1_set_frame_size(AV1_COMP *cpi, int width, int height) {
3678 AV1_COMMON *const cm = &cpi->common;
3679 const SequenceHeader *const seq_params = &cm->seq_params;
3680 const int num_planes = av1_num_planes(cm);
3681 MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
3682 int ref_frame;
3683
3684 if (width != cm->width || height != cm->height) {
3685 // There has been a change in the encoded frame size
3686 set_size_literal(cpi, width, height);
3687 set_mv_search_params(cpi);
3688 // Recalculate 'all_lossless' in case super-resolution was (un)selected.
3689 cm->all_lossless = cm->coded_lossless && !av1_superres_scaled(cm);
3690 }
3691
3692 if (cpi->oxcf.pass == 2) {
3693 av1_set_target_rate(cpi, cm->width, cm->height);
3694 }
3695
3696 alloc_frame_mvs(cm, cm->cur_frame);
3697
3698 // Allocate above context buffers
3699 if (cm->num_allocated_above_context_planes < av1_num_planes(cm) ||
3700 cm->num_allocated_above_context_mi_col < cm->mi_cols ||
3701 cm->num_allocated_above_contexts < cm->tile_rows) {
3702 av1_free_above_context_buffers(cm, cm->num_allocated_above_contexts);
3703 if (av1_alloc_above_context_buffers(cm, cm->tile_rows))
3704 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
3705 "Failed to allocate context buffers");
3706 }
3707
3708 // Reset the frame pointers to the current frame size.
3709 if (aom_realloc_frame_buffer(
3710 &cm->cur_frame->buf, cm->width, cm->height, seq_params->subsampling_x,
3711 seq_params->subsampling_y, seq_params->use_highbitdepth,
3712 cpi->oxcf.border_in_pixels, cm->byte_alignment, NULL, NULL, NULL))
3713 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
3714 "Failed to allocate frame buffer");
3715
3716 const int frame_width = cm->superres_upscaled_width;
3717 const int frame_height = cm->superres_upscaled_height;
3718 set_restoration_unit_size(frame_width, frame_height,
3719 seq_params->subsampling_x,
3720 seq_params->subsampling_y, cm->rst_info);
3721 for (int i = 0; i < num_planes; ++i)
3722 cm->rst_info[i].frame_restoration_type = RESTORE_NONE;
3723
3724 av1_alloc_restoration_buffers(cm);
3725 alloc_util_frame_buffers(cpi);
3726 init_motion_estimation(cpi);
3727
3728 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3729 RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
3730 if (buf != NULL) {
3731 struct scale_factors *sf = get_ref_scale_factors(cm, ref_frame);
3732 av1_setup_scale_factors_for_frame(sf, buf->buf.y_crop_width,
3733 buf->buf.y_crop_height, cm->width,
3734 cm->height);
3735 if (av1_is_scaled(sf)) aom_extend_frame_borders(&buf->buf, num_planes);
3736 }
3737 }
3738
3739 av1_setup_scale_factors_for_frame(&cm->sf_identity, cm->width, cm->height,
3740 cm->width, cm->height);
3741
3742 set_ref_ptrs(cm, xd, LAST_FRAME, LAST_FRAME);
3743 }
3744
calculate_next_resize_scale(const AV1_COMP * cpi)3745 static uint8_t calculate_next_resize_scale(const AV1_COMP *cpi) {
3746 // Choose an arbitrary random number
3747 static unsigned int seed = 56789;
3748 const AV1EncoderConfig *oxcf = &cpi->oxcf;
3749 if (oxcf->pass == 1) return SCALE_NUMERATOR;
3750 uint8_t new_denom = SCALE_NUMERATOR;
3751
3752 if (cpi->common.seq_params.reduced_still_picture_hdr) return SCALE_NUMERATOR;
3753 switch (oxcf->resize_mode) {
3754 case RESIZE_NONE: new_denom = SCALE_NUMERATOR; break;
3755 case RESIZE_FIXED:
3756 if (cpi->common.current_frame.frame_type == KEY_FRAME)
3757 new_denom = oxcf->resize_kf_scale_denominator;
3758 else
3759 new_denom = oxcf->resize_scale_denominator;
3760 break;
3761 case RESIZE_RANDOM: new_denom = lcg_rand16(&seed) % 9 + 8; break;
3762 default: assert(0);
3763 }
3764 return new_denom;
3765 }
3766
3767 #define ENERGY_BY_Q2_THRESH 0.01
3768 #define ENERGY_BY_AC_THRESH 0.2
3769
get_superres_denom_from_qindex_energy(int qindex,double * energy,double threshq,double threshp)3770 static uint8_t get_superres_denom_from_qindex_energy(int qindex, double *energy,
3771 double threshq,
3772 double threshp) {
3773 const double q = av1_convert_qindex_to_q(qindex, AOM_BITS_8);
3774 const double tq = threshq * q * q;
3775 const double tp = threshp * energy[1];
3776 const double thresh = AOMMIN(tq, tp);
3777 int k;
3778 for (k = 16; k > 8; --k) {
3779 if (energy[k - 1] > thresh) break;
3780 }
3781 return 3 * SCALE_NUMERATOR - k;
3782 }
3783
get_superres_denom_for_qindex(const AV1_COMP * cpi,int qindex)3784 static uint8_t get_superres_denom_for_qindex(const AV1_COMP *cpi, int qindex) {
3785 double energy[16];
3786 analyze_hor_freq(cpi, energy);
3787 /*
3788 printf("\nenergy = [");
3789 for (int k = 1; k < 16; ++k) printf("%f, ", energy[k]);
3790 printf("]\n");
3791 */
3792 return get_superres_denom_from_qindex_energy(
3793 qindex, energy, ENERGY_BY_Q2_THRESH, ENERGY_BY_AC_THRESH);
3794 }
3795
calculate_next_superres_scale(AV1_COMP * cpi)3796 static uint8_t calculate_next_superres_scale(AV1_COMP *cpi) {
3797 // Choose an arbitrary random number
3798 static unsigned int seed = 34567;
3799 const AV1EncoderConfig *oxcf = &cpi->oxcf;
3800 if (oxcf->pass == 1) return SCALE_NUMERATOR;
3801 uint8_t new_denom = SCALE_NUMERATOR;
3802
3803 // Make sure that superres mode of the frame is consistent with the
3804 // sequence-level flag.
3805 assert(IMPLIES(oxcf->superres_mode != SUPERRES_NONE,
3806 cpi->common.seq_params.enable_superres));
3807 assert(IMPLIES(!cpi->common.seq_params.enable_superres,
3808 oxcf->superres_mode == SUPERRES_NONE));
3809
3810 switch (oxcf->superres_mode) {
3811 case SUPERRES_NONE: new_denom = SCALE_NUMERATOR; break;
3812 case SUPERRES_FIXED:
3813 if (cpi->common.current_frame.frame_type == KEY_FRAME)
3814 new_denom = oxcf->superres_kf_scale_denominator;
3815 else
3816 new_denom = oxcf->superres_scale_denominator;
3817 break;
3818 case SUPERRES_RANDOM: new_denom = lcg_rand16(&seed) % 9 + 8; break;
3819 case SUPERRES_QTHRESH: {
3820 // Do not use superres when screen content tools are used.
3821 if (cpi->common.allow_screen_content_tools) break;
3822 if (oxcf->rc_mode == AOM_VBR || oxcf->rc_mode == AOM_CQ)
3823 av1_set_target_rate(cpi, cpi->oxcf.width, cpi->oxcf.height);
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 = (frame_is_intra_only(&cpi->common))
3829 ? oxcf->superres_kf_qthresh
3830 : oxcf->superres_qthresh;
3831 if (q <= qthresh) {
3832 new_denom = SCALE_NUMERATOR;
3833 } else {
3834 new_denom = get_superres_denom_for_qindex(cpi, q);
3835 }
3836 break;
3837 }
3838 case SUPERRES_AUTO: {
3839 // Don't use when screen content tools are used.
3840 if (cpi->common.allow_screen_content_tools) break;
3841 // Don't use for inter frames.
3842 if (!frame_is_intra_only(&cpi->common)) break;
3843 // Don't use for keyframes that can be used as references.
3844 if (cpi->rc.frames_to_key != 1) break;
3845
3846 // Now decide the use of superres based on 'q'.
3847 int bottom_index, top_index;
3848 const int q = av1_rc_pick_q_and_bounds(
3849 cpi, cpi->oxcf.width, cpi->oxcf.height, &bottom_index, &top_index);
3850
3851 const int qthresh = 128;
3852 if (q <= qthresh) {
3853 new_denom = SCALE_NUMERATOR;
3854 } else {
3855 new_denom = get_superres_denom_for_qindex(cpi, q);
3856 }
3857 break;
3858 }
3859 default: assert(0);
3860 }
3861 return new_denom;
3862 }
3863
dimension_is_ok(int orig_dim,int resized_dim,int denom)3864 static int dimension_is_ok(int orig_dim, int resized_dim, int denom) {
3865 return (resized_dim * SCALE_NUMERATOR >= orig_dim * denom / 2);
3866 }
3867
dimensions_are_ok(int owidth,int oheight,size_params_type * rsz)3868 static int dimensions_are_ok(int owidth, int oheight, size_params_type *rsz) {
3869 // Only need to check the width, as scaling is horizontal only.
3870 (void)oheight;
3871 return dimension_is_ok(owidth, rsz->resize_width, rsz->superres_denom);
3872 }
3873
validate_size_scales(RESIZE_MODE resize_mode,SUPERRES_MODE superres_mode,int owidth,int oheight,size_params_type * rsz)3874 static int validate_size_scales(RESIZE_MODE resize_mode,
3875 SUPERRES_MODE superres_mode, int owidth,
3876 int oheight, size_params_type *rsz) {
3877 if (dimensions_are_ok(owidth, oheight, rsz)) { // Nothing to do.
3878 return 1;
3879 }
3880
3881 // Calculate current resize scale.
3882 int resize_denom =
3883 AOMMAX(DIVIDE_AND_ROUND(owidth * SCALE_NUMERATOR, rsz->resize_width),
3884 DIVIDE_AND_ROUND(oheight * SCALE_NUMERATOR, rsz->resize_height));
3885
3886 if (resize_mode != RESIZE_RANDOM && superres_mode == SUPERRES_RANDOM) {
3887 // Alter superres scale as needed to enforce conformity.
3888 rsz->superres_denom =
3889 (2 * SCALE_NUMERATOR * SCALE_NUMERATOR) / resize_denom;
3890 if (!dimensions_are_ok(owidth, oheight, rsz)) {
3891 if (rsz->superres_denom > SCALE_NUMERATOR) --rsz->superres_denom;
3892 }
3893 } else if (resize_mode == RESIZE_RANDOM && superres_mode != SUPERRES_RANDOM) {
3894 // Alter resize scale as needed to enforce conformity.
3895 resize_denom =
3896 (2 * SCALE_NUMERATOR * SCALE_NUMERATOR) / rsz->superres_denom;
3897 rsz->resize_width = owidth;
3898 rsz->resize_height = oheight;
3899 av1_calculate_scaled_size(&rsz->resize_width, &rsz->resize_height,
3900 resize_denom);
3901 if (!dimensions_are_ok(owidth, oheight, rsz)) {
3902 if (resize_denom > SCALE_NUMERATOR) {
3903 --resize_denom;
3904 rsz->resize_width = owidth;
3905 rsz->resize_height = oheight;
3906 av1_calculate_scaled_size(&rsz->resize_width, &rsz->resize_height,
3907 resize_denom);
3908 }
3909 }
3910 } else if (resize_mode == RESIZE_RANDOM && superres_mode == SUPERRES_RANDOM) {
3911 // Alter both resize and superres scales as needed to enforce conformity.
3912 do {
3913 if (resize_denom > rsz->superres_denom)
3914 --resize_denom;
3915 else
3916 --rsz->superres_denom;
3917 rsz->resize_width = owidth;
3918 rsz->resize_height = oheight;
3919 av1_calculate_scaled_size(&rsz->resize_width, &rsz->resize_height,
3920 resize_denom);
3921 } while (!dimensions_are_ok(owidth, oheight, rsz) &&
3922 (resize_denom > SCALE_NUMERATOR ||
3923 rsz->superres_denom > SCALE_NUMERATOR));
3924 } else { // We are allowed to alter neither resize scale nor superres
3925 // scale.
3926 return 0;
3927 }
3928 return dimensions_are_ok(owidth, oheight, rsz);
3929 }
3930
3931 // Calculates resize and superres params for next frame
calculate_next_size_params(AV1_COMP * cpi)3932 static size_params_type calculate_next_size_params(AV1_COMP *cpi) {
3933 const AV1EncoderConfig *oxcf = &cpi->oxcf;
3934 size_params_type rsz = { oxcf->width, oxcf->height, SCALE_NUMERATOR };
3935 int resize_denom;
3936 if (oxcf->pass == 1) return rsz;
3937 if (cpi->resize_pending_width && cpi->resize_pending_height) {
3938 rsz.resize_width = cpi->resize_pending_width;
3939 rsz.resize_height = cpi->resize_pending_height;
3940 cpi->resize_pending_width = cpi->resize_pending_height = 0;
3941 } else {
3942 resize_denom = calculate_next_resize_scale(cpi);
3943 rsz.resize_width = cpi->oxcf.width;
3944 rsz.resize_height = cpi->oxcf.height;
3945 av1_calculate_scaled_size(&rsz.resize_width, &rsz.resize_height,
3946 resize_denom);
3947 }
3948 rsz.superres_denom = calculate_next_superres_scale(cpi);
3949 if (!validate_size_scales(oxcf->resize_mode, oxcf->superres_mode, oxcf->width,
3950 oxcf->height, &rsz))
3951 assert(0 && "Invalid scale parameters");
3952 return rsz;
3953 }
3954
setup_frame_size_from_params(AV1_COMP * cpi,const size_params_type * rsz)3955 static void setup_frame_size_from_params(AV1_COMP *cpi,
3956 const size_params_type *rsz) {
3957 int encode_width = rsz->resize_width;
3958 int encode_height = rsz->resize_height;
3959
3960 AV1_COMMON *cm = &cpi->common;
3961 cm->superres_upscaled_width = encode_width;
3962 cm->superres_upscaled_height = encode_height;
3963 cm->superres_scale_denominator = rsz->superres_denom;
3964 av1_calculate_scaled_superres_size(&encode_width, &encode_height,
3965 rsz->superres_denom);
3966 av1_set_frame_size(cpi, encode_width, encode_height);
3967 }
3968
av1_setup_frame_size(AV1_COMP * cpi)3969 void av1_setup_frame_size(AV1_COMP *cpi) {
3970 AV1_COMMON *cm = &cpi->common;
3971 // Reset superres params from previous frame.
3972 cm->superres_scale_denominator = SCALE_NUMERATOR;
3973 const size_params_type rsz = calculate_next_size_params(cpi);
3974 setup_frame_size_from_params(cpi, &rsz);
3975
3976 assert(is_min_tile_width_satisfied(cm));
3977 }
3978
superres_post_encode(AV1_COMP * cpi)3979 static void superres_post_encode(AV1_COMP *cpi) {
3980 AV1_COMMON *cm = &cpi->common;
3981 const int num_planes = av1_num_planes(cm);
3982
3983 if (!av1_superres_scaled(cm)) return;
3984
3985 assert(cpi->oxcf.enable_superres);
3986 assert(!is_lossless_requested(&cpi->oxcf));
3987 assert(!cm->all_lossless);
3988
3989 av1_superres_upscale(cm, NULL);
3990
3991 // If regular resizing is occurring the source will need to be downscaled to
3992 // match the upscaled superres resolution. Otherwise the original source is
3993 // used.
3994 if (!av1_resize_scaled(cm)) {
3995 cpi->source = cpi->unscaled_source;
3996 if (cpi->last_source != NULL) cpi->last_source = cpi->unscaled_last_source;
3997 } else {
3998 assert(cpi->unscaled_source->y_crop_width != cm->superres_upscaled_width);
3999 assert(cpi->unscaled_source->y_crop_height != cm->superres_upscaled_height);
4000 // Do downscale. cm->(width|height) has been updated by
4001 // av1_superres_upscale
4002 if (aom_realloc_frame_buffer(
4003 &cpi->scaled_source, cm->superres_upscaled_width,
4004 cm->superres_upscaled_height, cm->seq_params.subsampling_x,
4005 cm->seq_params.subsampling_y, cm->seq_params.use_highbitdepth,
4006 AOM_BORDER_IN_PIXELS, cm->byte_alignment, NULL, NULL, NULL))
4007 aom_internal_error(
4008 &cm->error, AOM_CODEC_MEM_ERROR,
4009 "Failed to reallocate scaled source buffer for superres");
4010 assert(cpi->scaled_source.y_crop_width == cm->superres_upscaled_width);
4011 assert(cpi->scaled_source.y_crop_height == cm->superres_upscaled_height);
4012 av1_resize_and_extend_frame(cpi->unscaled_source, &cpi->scaled_source,
4013 (int)cm->seq_params.bit_depth, num_planes);
4014 cpi->source = &cpi->scaled_source;
4015 }
4016 }
4017
loopfilter_frame(AV1_COMP * cpi,AV1_COMMON * cm)4018 static void loopfilter_frame(AV1_COMP *cpi, AV1_COMMON *cm) {
4019 const int num_planes = av1_num_planes(cm);
4020 MACROBLOCKD *xd = &cpi->td.mb.e_mbd;
4021
4022 assert(IMPLIES(is_lossless_requested(&cpi->oxcf),
4023 cm->coded_lossless && cm->all_lossless));
4024
4025 const int use_loopfilter = !cm->coded_lossless && !cm->large_scale_tile;
4026 const int use_cdef = cm->seq_params.enable_cdef && !cm->coded_lossless &&
4027 !cm->large_scale_tile;
4028 const int use_restoration = cm->seq_params.enable_restoration &&
4029 !cm->all_lossless && !cm->large_scale_tile;
4030
4031 struct loopfilter *lf = &cm->lf;
4032
4033 #if CONFIG_COLLECT_COMPONENT_TIMING
4034 start_timing(cpi, loop_filter_time);
4035 #endif
4036 if (use_loopfilter) {
4037 aom_clear_system_state();
4038 av1_pick_filter_level(cpi->source, cpi, cpi->sf.lpf_pick);
4039 } else {
4040 lf->filter_level[0] = 0;
4041 lf->filter_level[1] = 0;
4042 }
4043
4044 if (lf->filter_level[0] || lf->filter_level[1]) {
4045 if (cpi->num_workers > 1)
4046 av1_loop_filter_frame_mt(&cm->cur_frame->buf, cm, xd, 0, num_planes, 0,
4047 #if LOOP_FILTER_BITMASK
4048 0,
4049 #endif
4050 cpi->workers, cpi->num_workers,
4051 &cpi->lf_row_sync);
4052 else
4053 av1_loop_filter_frame(&cm->cur_frame->buf, cm, xd,
4054 #if LOOP_FILTER_BITMASK
4055 0,
4056 #endif
4057 0, num_planes, 0);
4058 }
4059 #if CONFIG_COLLECT_COMPONENT_TIMING
4060 end_timing(cpi, loop_filter_time);
4061 #endif
4062
4063 if (use_restoration)
4064 av1_loop_restoration_save_boundary_lines(&cm->cur_frame->buf, cm, 0);
4065
4066 if (use_cdef) {
4067 #if CONFIG_COLLECT_COMPONENT_TIMING
4068 start_timing(cpi, cdef_time);
4069 #endif
4070 // Find CDEF parameters
4071 av1_cdef_search(&cm->cur_frame->buf, cpi->source, cm, xd,
4072 cpi->sf.fast_cdef_search);
4073
4074 // Apply the filter
4075 av1_cdef_frame(&cm->cur_frame->buf, cm, xd);
4076 #if CONFIG_COLLECT_COMPONENT_TIMING
4077 end_timing(cpi, cdef_time);
4078 #endif
4079 } else {
4080 cm->cdef_info.cdef_bits = 0;
4081 cm->cdef_info.cdef_strengths[0] = 0;
4082 cm->cdef_info.nb_cdef_strengths = 1;
4083 cm->cdef_info.cdef_uv_strengths[0] = 0;
4084 }
4085
4086 superres_post_encode(cpi);
4087
4088 #if CONFIG_COLLECT_COMPONENT_TIMING
4089 start_timing(cpi, loop_restoration_time);
4090 #endif
4091 if (use_restoration) {
4092 av1_loop_restoration_save_boundary_lines(&cm->cur_frame->buf, cm, 1);
4093 av1_pick_filter_restoration(cpi->source, cpi);
4094 if (cm->rst_info[0].frame_restoration_type != RESTORE_NONE ||
4095 cm->rst_info[1].frame_restoration_type != RESTORE_NONE ||
4096 cm->rst_info[2].frame_restoration_type != RESTORE_NONE) {
4097 if (cpi->num_workers > 1)
4098 av1_loop_restoration_filter_frame_mt(&cm->cur_frame->buf, cm, 0,
4099 cpi->workers, cpi->num_workers,
4100 &cpi->lr_row_sync, &cpi->lr_ctxt);
4101 else
4102 av1_loop_restoration_filter_frame(&cm->cur_frame->buf, cm, 0,
4103 &cpi->lr_ctxt);
4104 }
4105 } else {
4106 cm->rst_info[0].frame_restoration_type = RESTORE_NONE;
4107 cm->rst_info[1].frame_restoration_type = RESTORE_NONE;
4108 cm->rst_info[2].frame_restoration_type = RESTORE_NONE;
4109 }
4110 #if CONFIG_COLLECT_COMPONENT_TIMING
4111 end_timing(cpi, loop_restoration_time);
4112 #endif
4113 }
4114
fix_interp_filter(InterpFilter * const interp_filter,const FRAME_COUNTS * const counts)4115 static void fix_interp_filter(InterpFilter *const interp_filter,
4116 const FRAME_COUNTS *const counts) {
4117 if (*interp_filter == SWITCHABLE) {
4118 // Check to see if only one of the filters is actually used
4119 int count[SWITCHABLE_FILTERS] = { 0 };
4120 int num_filters_used = 0;
4121 for (int i = 0; i < SWITCHABLE_FILTERS; ++i) {
4122 for (int j = 0; j < SWITCHABLE_FILTER_CONTEXTS; ++j)
4123 count[i] += counts->switchable_interp[j][i];
4124 num_filters_used += (count[i] > 0);
4125 }
4126 if (num_filters_used == 1) {
4127 // Only one filter is used. So set the filter at frame level
4128 for (int i = 0; i < SWITCHABLE_FILTERS; ++i) {
4129 if (count[i]) {
4130 if (i == EIGHTTAP_REGULAR) *interp_filter = i;
4131 break;
4132 }
4133 }
4134 }
4135 }
4136 }
4137
finalize_encoded_frame(AV1_COMP * const cpi)4138 static void finalize_encoded_frame(AV1_COMP *const cpi) {
4139 AV1_COMMON *const cm = &cpi->common;
4140 CurrentFrame *const current_frame = &cm->current_frame;
4141
4142 if (!cm->seq_params.reduced_still_picture_hdr &&
4143 encode_show_existing_frame(cm)) {
4144 RefCntBuffer *const frame_to_show =
4145 cm->ref_frame_map[cpi->existing_fb_idx_to_show];
4146
4147 if (frame_to_show == NULL) {
4148 aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
4149 "Buffer does not contain a reconstructed frame");
4150 }
4151 assert(frame_to_show->ref_count > 0);
4152 assign_frame_buffer_p(&cm->cur_frame, frame_to_show);
4153 }
4154
4155 if (!encode_show_existing_frame(cm) &&
4156 cm->seq_params.film_grain_params_present &&
4157 (cm->show_frame || cm->showable_frame)) {
4158 // Copy the current frame's film grain params to the its corresponding
4159 // RefCntBuffer slot.
4160 cm->cur_frame->film_grain_params = cm->film_grain_params;
4161
4162 // We must update the parameters if this is not an INTER_FRAME
4163 if (current_frame->frame_type != INTER_FRAME)
4164 cm->cur_frame->film_grain_params.update_parameters = 1;
4165
4166 // Iterate the random seed for the next frame.
4167 cm->film_grain_params.random_seed += 3381;
4168 if (cm->film_grain_params.random_seed == 0)
4169 cm->film_grain_params.random_seed = 7391;
4170 }
4171
4172 // Initialise all tiles' contexts from the global frame context
4173 for (int tile_col = 0; tile_col < cm->tile_cols; tile_col++) {
4174 for (int tile_row = 0; tile_row < cm->tile_rows; tile_row++) {
4175 const int tile_idx = tile_row * cm->tile_cols + tile_col;
4176 cpi->tile_data[tile_idx].tctx = *cm->fc;
4177 }
4178 }
4179
4180 fix_interp_filter(&cm->interp_filter, cpi->td.counts);
4181 }
4182
get_regulated_q_overshoot(AV1_COMP * const cpi,int q_low,int q_high,int top_index,int bottom_index)4183 static int get_regulated_q_overshoot(AV1_COMP *const cpi, int q_low, int q_high,
4184 int top_index, int bottom_index) {
4185 const AV1_COMMON *const cm = &cpi->common;
4186 const RATE_CONTROL *const rc = &cpi->rc;
4187
4188 av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height);
4189
4190 int q_regulated =
4191 av1_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4192 AOMMAX(q_high, top_index), cm->width, cm->height);
4193
4194 int retries = 0;
4195 while (q_regulated < q_low && retries < 10) {
4196 av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height);
4197 q_regulated =
4198 av1_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4199 AOMMAX(q_high, top_index), cm->width, cm->height);
4200 retries++;
4201 }
4202 return q_regulated;
4203 }
4204
get_regulated_q_undershoot(AV1_COMP * const cpi,int q_high,int top_index,int bottom_index)4205 static int get_regulated_q_undershoot(AV1_COMP *const cpi, int q_high,
4206 int top_index, int bottom_index) {
4207 const AV1_COMMON *const cm = &cpi->common;
4208 const RATE_CONTROL *const rc = &cpi->rc;
4209
4210 av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height);
4211 int q_regulated = av1_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4212 top_index, cm->width, cm->height);
4213
4214 int retries = 0;
4215 while (q_regulated > q_high && retries < 10) {
4216 av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height);
4217 q_regulated = av1_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4218 top_index, cm->width, cm->height);
4219 retries++;
4220 }
4221 return q_regulated;
4222 }
4223
4224 // Called after encode_with_recode_loop() has just encoded a frame and packed
4225 // its bitstream. This function works out whether we under- or over-shot
4226 // our bitrate target and adjusts q as appropriate. Also decides whether
4227 // or not we should do another recode loop, indicated by *loop
recode_loop_update_q(AV1_COMP * const cpi,int * const loop,int * const q,int * const q_low,int * const q_high,const int top_index,const int bottom_index,int * const undershoot_seen,int * const overshoot_seen,const int loop_at_this_size)4228 static void recode_loop_update_q(AV1_COMP *const cpi, int *const loop,
4229 int *const q, int *const q_low,
4230 int *const q_high, const int top_index,
4231 const int bottom_index,
4232 int *const undershoot_seen,
4233 int *const overshoot_seen,
4234 const int loop_at_this_size) {
4235 AV1_COMMON *const cm = &cpi->common;
4236 RATE_CONTROL *const rc = &cpi->rc;
4237
4238 int frame_over_shoot_limit = 0, frame_under_shoot_limit = 0;
4239 av1_rc_compute_frame_size_bounds(cpi, rc->this_frame_target,
4240 &frame_under_shoot_limit,
4241 &frame_over_shoot_limit);
4242 if (frame_over_shoot_limit == 0) frame_over_shoot_limit = 1;
4243
4244 if ((cm->current_frame.frame_type == KEY_FRAME) &&
4245 rc->this_key_frame_forced &&
4246 (rc->projected_frame_size < rc->max_frame_bandwidth)) {
4247 int last_q = *q;
4248 int64_t kf_err;
4249
4250 int64_t high_err_target = cpi->ambient_err;
4251 int64_t low_err_target = cpi->ambient_err >> 1;
4252
4253 if (cm->seq_params.use_highbitdepth) {
4254 kf_err = aom_highbd_get_y_sse(cpi->source, &cm->cur_frame->buf);
4255 } else {
4256 kf_err = aom_get_y_sse(cpi->source, &cm->cur_frame->buf);
4257 }
4258 // Prevent possible divide by zero error below for perfect KF
4259 kf_err += !kf_err;
4260
4261 // The key frame is not good enough or we can afford
4262 // to make it better without undue risk of popping.
4263 if ((kf_err > high_err_target &&
4264 rc->projected_frame_size <= frame_over_shoot_limit) ||
4265 (kf_err > low_err_target &&
4266 rc->projected_frame_size <= frame_under_shoot_limit)) {
4267 // Lower q_high
4268 *q_high = *q > *q_low ? *q - 1 : *q_low;
4269
4270 // Adjust Q
4271 *q = (int)((*q * high_err_target) / kf_err);
4272 *q = AOMMIN(*q, (*q_high + *q_low) >> 1);
4273 } else if (kf_err < low_err_target &&
4274 rc->projected_frame_size >= frame_under_shoot_limit) {
4275 // The key frame is much better than the previous frame
4276 // Raise q_low
4277 *q_low = *q < *q_high ? *q + 1 : *q_high;
4278
4279 // Adjust Q
4280 *q = (int)((*q * low_err_target) / kf_err);
4281 *q = AOMMIN(*q, (*q_high + *q_low + 1) >> 1);
4282 }
4283
4284 // Clamp Q to upper and lower limits:
4285 *q = clamp(*q, *q_low, *q_high);
4286
4287 *loop = *q != last_q;
4288 } else if (recode_loop_test(cpi, frame_over_shoot_limit,
4289 frame_under_shoot_limit, *q,
4290 AOMMAX(*q_high, top_index), bottom_index)) {
4291 // Is the projected frame size out of range and are we allowed
4292 // to attempt to recode.
4293 int last_q = *q;
4294
4295 // Frame size out of permitted range:
4296 // Update correction factor & compute new Q to try...
4297 // Frame is too large
4298 if (rc->projected_frame_size > rc->this_frame_target) {
4299 // Special case if the projected size is > the max allowed.
4300 if (rc->projected_frame_size >= rc->max_frame_bandwidth)
4301 *q_high = rc->worst_quality;
4302
4303 // Raise Qlow as to at least the current value
4304 *q_low = *q < *q_high ? *q + 1 : *q_high;
4305
4306 if (*undershoot_seen || loop_at_this_size > 2 ||
4307 (loop_at_this_size == 2 && !frame_is_intra_only(cm))) {
4308 av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height);
4309
4310 *q = (*q_high + *q_low + 1) / 2;
4311 } else if (loop_at_this_size == 2 && frame_is_intra_only(cm)) {
4312 const int q_mid = (*q_high + *q_low + 1) / 2;
4313 const int q_regulated = get_regulated_q_overshoot(
4314 cpi, *q_low, *q_high, top_index, bottom_index);
4315 // Get 'q' in-between 'q_mid' and 'q_regulated' for a smooth
4316 // transition between loop_at_this_size < 2 and loop_at_this_size > 2.
4317 *q = (q_mid + q_regulated + 1) / 2;
4318 } else {
4319 *q = get_regulated_q_overshoot(cpi, *q_low, *q_high, top_index,
4320 bottom_index);
4321 }
4322
4323 *overshoot_seen = 1;
4324 } else {
4325 // Frame is too small
4326 *q_high = *q > *q_low ? *q - 1 : *q_low;
4327
4328 if (*overshoot_seen || loop_at_this_size > 2 ||
4329 (loop_at_this_size == 2 && !frame_is_intra_only(cm))) {
4330 av1_rc_update_rate_correction_factors(cpi, cm->width, cm->height);
4331 *q = (*q_high + *q_low) / 2;
4332 } else if (loop_at_this_size == 2 && frame_is_intra_only(cm)) {
4333 const int q_mid = (*q_high + *q_low) / 2;
4334 const int q_regulated =
4335 get_regulated_q_undershoot(cpi, *q_high, top_index, bottom_index);
4336 // Get 'q' in-between 'q_mid' and 'q_regulated' for a smooth
4337 // transition between loop_at_this_size < 2 and loop_at_this_size > 2.
4338 *q = (q_mid + q_regulated) / 2;
4339
4340 // Special case reset for qlow for constrained quality.
4341 // This should only trigger where there is very substantial
4342 // undershoot on a frame and the auto cq level is above
4343 // the user passsed in value.
4344 if (cpi->oxcf.rc_mode == AOM_CQ && q_regulated < *q_low) {
4345 *q_low = *q;
4346 }
4347 } else {
4348 *q = get_regulated_q_undershoot(cpi, *q_high, top_index, bottom_index);
4349
4350 // Special case reset for qlow for constrained quality.
4351 // This should only trigger where there is very substantial
4352 // undershoot on a frame and the auto cq level is above
4353 // the user passsed in value.
4354 if (cpi->oxcf.rc_mode == AOM_CQ && *q < *q_low) {
4355 *q_low = *q;
4356 }
4357 }
4358
4359 *undershoot_seen = 1;
4360 }
4361
4362 // Clamp Q to upper and lower limits:
4363 *q = clamp(*q, *q_low, *q_high);
4364
4365 *loop = (*q != last_q);
4366 } else {
4367 *loop = 0;
4368 }
4369 }
4370
encode_with_recode_loop(AV1_COMP * cpi,size_t * size,uint8_t * dest)4371 static int encode_with_recode_loop(AV1_COMP *cpi, size_t *size, uint8_t *dest) {
4372 AV1_COMMON *const cm = &cpi->common;
4373 RATE_CONTROL *const rc = &cpi->rc;
4374 const int allow_recode = cpi->sf.recode_loop != DISALLOW_RECODE;
4375
4376 set_size_independent_vars(cpi);
4377
4378 cpi->source->buf_8bit_valid = 0;
4379
4380 av1_setup_frame_size(cpi);
4381
4382 int top_index = 0, bottom_index = 0;
4383 int q = 0, q_low = 0, q_high = 0;
4384 set_size_dependent_vars(cpi, &q, &bottom_index, &top_index);
4385 q_low = bottom_index;
4386 q_high = top_index;
4387
4388 // Loop variables
4389 int loop_count = 0;
4390 int loop_at_this_size = 0;
4391 int loop = 0;
4392 int overshoot_seen = 0;
4393 int undershoot_seen = 0;
4394
4395 #if CONFIG_COLLECT_COMPONENT_TIMING
4396 printf("\n Encoding a frame:");
4397 #endif
4398 do {
4399 aom_clear_system_state();
4400
4401 // if frame was scaled calculate global_motion_search again if already
4402 // done
4403 if (loop_count > 0 && cpi->source && cpi->global_motion_search_done) {
4404 if (cpi->source->y_crop_width != cm->width ||
4405 cpi->source->y_crop_height != cm->height) {
4406 cpi->global_motion_search_done = 0;
4407 }
4408 }
4409 cpi->source =
4410 av1_scale_if_required(cm, cpi->unscaled_source, &cpi->scaled_source);
4411 if (cpi->unscaled_last_source != NULL) {
4412 cpi->last_source = av1_scale_if_required(cm, cpi->unscaled_last_source,
4413 &cpi->scaled_last_source);
4414 }
4415
4416 if (!frame_is_intra_only(cm)) {
4417 if (loop_count > 0) {
4418 release_scaled_references(cpi);
4419 }
4420 scale_references(cpi);
4421 }
4422 av1_set_quantizer(cm, q);
4423 av1_init_quantizer(cpi);
4424
4425 av1_set_variance_partition_thresholds(cpi, q, 0);
4426
4427 // printf("Frame %d/%d: q = %d, frame_type = %d superres_denom = %d\n",
4428 // cm->current_frame.frame_number, cm->show_frame, q,
4429 // cm->current_frame.frame_type, cm->superres_scale_denominator);
4430
4431 if (loop_count == 0) {
4432 setup_frame(cpi);
4433 } else if (get_primary_ref_frame_buf(cm) == NULL) {
4434 // Base q-index may have changed, so we need to assign proper default coef
4435 // probs before every iteration.
4436 av1_default_coef_probs(cm);
4437 av1_setup_frame_contexts(cm);
4438 }
4439
4440 if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
4441 av1_vaq_frame_setup(cpi);
4442 } else if (cpi->oxcf.aq_mode == COMPLEXITY_AQ) {
4443 av1_setup_in_frame_q_adj(cpi);
4444 } else if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && !allow_recode) {
4445 suppress_active_map(cpi);
4446 av1_cyclic_refresh_setup(cpi);
4447 apply_active_map(cpi);
4448 }
4449
4450 if (cm->seg.enabled) {
4451 if (!cm->seg.update_data && cm->prev_frame) {
4452 segfeatures_copy(&cm->seg, &cm->prev_frame->seg);
4453 } else {
4454 calculate_segdata(&cm->seg);
4455 }
4456 } else {
4457 memset(&cm->seg, 0, sizeof(cm->seg));
4458 }
4459 segfeatures_copy(&cm->cur_frame->seg, &cm->seg);
4460
4461 if (allow_recode) save_coding_context(cpi);
4462 #if CONFIG_COLLECT_COMPONENT_TIMING
4463 start_timing(cpi, av1_encode_frame_time);
4464 #endif
4465 // transform / motion compensation build reconstruction frame
4466 av1_encode_frame(cpi);
4467 #if CONFIG_COLLECT_COMPONENT_TIMING
4468 end_timing(cpi, av1_encode_frame_time);
4469 #endif
4470
4471 aom_clear_system_state();
4472
4473 // Dummy pack of the bitstream using up to date stats to get an
4474 // accurate estimate of output frame size to determine if we need
4475 // to recode.
4476 if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF) {
4477 restore_coding_context(cpi);
4478
4479 finalize_encoded_frame(cpi);
4480 int largest_tile_id = 0; // Output from bitstream: unused here
4481 if (av1_pack_bitstream(cpi, dest, size, &largest_tile_id) != AOM_CODEC_OK)
4482 return AOM_CODEC_ERROR;
4483
4484 rc->projected_frame_size = (int)(*size) << 3;
4485 restore_coding_context(cpi);
4486 }
4487
4488 if (allow_recode && cpi->oxcf.rc_mode != AOM_Q) {
4489 // Update q and decide whether to do a recode loop
4490 recode_loop_update_q(cpi, &loop, &q, &q_low, &q_high, top_index,
4491 bottom_index, &undershoot_seen, &overshoot_seen,
4492 loop_at_this_size);
4493 }
4494
4495 // Special case for overlay frame.
4496 if (rc->is_src_frame_alt_ref &&
4497 rc->projected_frame_size < rc->max_frame_bandwidth)
4498 loop = 0;
4499
4500 if (allow_recode && !cpi->sf.gm_disable_recode &&
4501 recode_loop_test_global_motion(cpi)) {
4502 loop = 1;
4503 }
4504
4505 if (loop) {
4506 ++loop_count;
4507 ++loop_at_this_size;
4508
4509 #if CONFIG_INTERNAL_STATS
4510 ++cpi->tot_recode_hits;
4511 #endif
4512 }
4513 #if CONFIG_COLLECT_COMPONENT_TIMING
4514 if (loop) printf("\n Recoding:");
4515 #endif
4516 } while (loop);
4517
4518 return AOM_CODEC_OK;
4519 }
4520
4521 #define DUMP_RECON_FRAMES 0
4522
4523 #if DUMP_RECON_FRAMES == 1
4524 // NOTE(zoeliu): For debug - Output the filtered reconstructed video.
dump_filtered_recon_frames(AV1_COMP * cpi)4525 static void dump_filtered_recon_frames(AV1_COMP *cpi) {
4526 AV1_COMMON *const cm = &cpi->common;
4527 const CurrentFrame *const current_frame = &cm->current_frame;
4528 const YV12_BUFFER_CONFIG *recon_buf = &cm->cur_frame->buf;
4529
4530 if (recon_buf == NULL) {
4531 printf("Frame %d is not ready.\n", current_frame->frame_number);
4532 return;
4533 }
4534
4535 static const int flag_list[REF_FRAMES] = { 0,
4536 AOM_LAST_FLAG,
4537 AOM_LAST2_FLAG,
4538 AOM_LAST3_FLAG,
4539 AOM_GOLD_FLAG,
4540 AOM_BWD_FLAG,
4541 AOM_ALT2_FLAG,
4542 AOM_ALT_FLAG };
4543 printf(
4544 "\n***Frame=%d (frame_offset=%d, show_frame=%d, "
4545 "show_existing_frame=%d) "
4546 "[LAST LAST2 LAST3 GOLDEN BWD ALT2 ALT]=[",
4547 current_frame->frame_number, current_frame->order_hint, cm->show_frame,
4548 cm->show_existing_frame);
4549 for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
4550 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
4551 const int ref_offset = buf != NULL ? (int)buf->order_hint : -1;
4552 printf(" %d(%c)", ref_offset,
4553 (cpi->ref_frame_flags & flag_list[ref_frame]) ? 'Y' : 'N');
4554 }
4555 printf(" ]\n");
4556
4557 if (!cm->show_frame) {
4558 printf("Frame %d is a no show frame, so no image dump.\n",
4559 current_frame->frame_number);
4560 return;
4561 }
4562
4563 int h;
4564 char file_name[256] = "/tmp/enc_filtered_recon.yuv";
4565 FILE *f_recon = NULL;
4566
4567 if (current_frame->frame_number == 0) {
4568 if ((f_recon = fopen(file_name, "wb")) == NULL) {
4569 printf("Unable to open file %s to write.\n", file_name);
4570 return;
4571 }
4572 } else {
4573 if ((f_recon = fopen(file_name, "ab")) == NULL) {
4574 printf("Unable to open file %s to append.\n", file_name);
4575 return;
4576 }
4577 }
4578 printf(
4579 "\nFrame=%5d, encode_update_type[%5d]=%1d, frame_offset=%d, "
4580 "show_frame=%d, show_existing_frame=%d, source_alt_ref_active=%d, "
4581 "refresh_alt_ref_frame=%d, "
4582 "y_stride=%4d, uv_stride=%4d, cm->width=%4d, cm->height=%4d\n\n",
4583 current_frame->frame_number, cpi->twopass.gf_group.index,
4584 cpi->twopass.gf_group.update_type[cpi->twopass.gf_group.index],
4585 current_frame->order_hint, cm->show_frame, cm->show_existing_frame,
4586 cpi->rc.source_alt_ref_active, cpi->refresh_alt_ref_frame,
4587 recon_buf->y_stride, recon_buf->uv_stride, cm->width, cm->height);
4588 #if 0
4589 int ref_frame;
4590 printf("get_ref_frame_map_idx: [");
4591 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame)
4592 printf(" %d", get_ref_frame_map_idx(cm, ref_frame));
4593 printf(" ]\n");
4594 #endif // 0
4595
4596 // --- Y ---
4597 for (h = 0; h < cm->height; ++h) {
4598 fwrite(&recon_buf->y_buffer[h * recon_buf->y_stride], 1, cm->width,
4599 f_recon);
4600 }
4601 // --- U ---
4602 for (h = 0; h < (cm->height >> 1); ++h) {
4603 fwrite(&recon_buf->u_buffer[h * recon_buf->uv_stride], 1, (cm->width >> 1),
4604 f_recon);
4605 }
4606 // --- V ---
4607 for (h = 0; h < (cm->height >> 1); ++h) {
4608 fwrite(&recon_buf->v_buffer[h * recon_buf->uv_stride], 1, (cm->width >> 1),
4609 f_recon);
4610 }
4611
4612 fclose(f_recon);
4613 }
4614 #endif // DUMP_RECON_FRAMES
4615
get_interp_filter_selected(const AV1_COMMON * const cm,MV_REFERENCE_FRAME ref,InterpFilters ifilter)4616 static int get_interp_filter_selected(const AV1_COMMON *const cm,
4617 MV_REFERENCE_FRAME ref,
4618 InterpFilters ifilter) {
4619 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref);
4620 if (buf == NULL) return 0;
4621 return buf->interp_filter_selected[ifilter];
4622 }
4623
setup_interp_filter_search_mask(AV1_COMP * cpi)4624 static int setup_interp_filter_search_mask(AV1_COMP *cpi) {
4625 const AV1_COMMON *const cm = &cpi->common;
4626 int ref_total[REF_FRAMES] = { 0 };
4627
4628 if (cpi->common.last_frame_type == KEY_FRAME || cpi->refresh_alt_ref_frame)
4629 return 0;
4630
4631 for (MV_REFERENCE_FRAME ref = LAST_FRAME; ref <= ALTREF_FRAME; ++ref) {
4632 for (InterpFilters ifilter = EIGHTTAP_REGULAR; ifilter <= MULTITAP_SHARP;
4633 ++ifilter) {
4634 ref_total[ref] += get_interp_filter_selected(cm, ref, ifilter);
4635 }
4636 }
4637 int ref_total_total = (ref_total[LAST2_FRAME] + ref_total[LAST3_FRAME] +
4638 ref_total[GOLDEN_FRAME] + ref_total[BWDREF_FRAME] +
4639 ref_total[ALTREF2_FRAME] + ref_total[ALTREF_FRAME]);
4640
4641 int mask = 0;
4642 for (InterpFilters ifilter = EIGHTTAP_REGULAR; ifilter <= MULTITAP_SHARP;
4643 ++ifilter) {
4644 int last_score = get_interp_filter_selected(cm, LAST_FRAME, ifilter) * 30;
4645 if (ref_total[LAST_FRAME] && last_score <= ref_total[LAST_FRAME]) {
4646 int filter_score =
4647 get_interp_filter_selected(cm, LAST2_FRAME, ifilter) * 20 +
4648 get_interp_filter_selected(cm, LAST3_FRAME, ifilter) * 20 +
4649 get_interp_filter_selected(cm, GOLDEN_FRAME, ifilter) * 20 +
4650 get_interp_filter_selected(cm, BWDREF_FRAME, ifilter) * 10 +
4651 get_interp_filter_selected(cm, ALTREF2_FRAME, ifilter) * 10 +
4652 get_interp_filter_selected(cm, ALTREF_FRAME, ifilter) * 10;
4653 if (filter_score < ref_total_total) mask |= 1 << ifilter;
4654 }
4655 }
4656 return mask;
4657 }
4658
is_integer_mv(AV1_COMP * cpi,const YV12_BUFFER_CONFIG * cur_picture,const YV12_BUFFER_CONFIG * last_picture,hash_table * last_hash_table)4659 static int is_integer_mv(AV1_COMP *cpi, const YV12_BUFFER_CONFIG *cur_picture,
4660 const YV12_BUFFER_CONFIG *last_picture,
4661 hash_table *last_hash_table) {
4662 aom_clear_system_state();
4663 // check use hash ME
4664 int k;
4665 uint32_t hash_value_1;
4666 uint32_t hash_value_2;
4667
4668 const int block_size = 8;
4669 const double threshold_current = 0.8;
4670 const double threshold_average = 0.95;
4671 const int max_history_size = 32;
4672 int T = 0; // total block
4673 int C = 0; // match with collocated block
4674 int S = 0; // smooth region but not match with collocated block
4675 int M = 0; // match with other block
4676
4677 const int pic_width = cur_picture->y_width;
4678 const int pic_height = cur_picture->y_height;
4679 for (int i = 0; i + block_size <= pic_height; i += block_size) {
4680 for (int j = 0; j + block_size <= pic_width; j += block_size) {
4681 const int x_pos = j;
4682 const int y_pos = i;
4683 int match = 1;
4684 T++;
4685
4686 // check whether collocated block match with current
4687 uint8_t *p_cur = cur_picture->y_buffer;
4688 uint8_t *p_ref = last_picture->y_buffer;
4689 int stride_cur = cur_picture->y_stride;
4690 int stride_ref = last_picture->y_stride;
4691 p_cur += (y_pos * stride_cur + x_pos);
4692 p_ref += (y_pos * stride_ref + x_pos);
4693
4694 if (cur_picture->flags & YV12_FLAG_HIGHBITDEPTH) {
4695 uint16_t *p16_cur = CONVERT_TO_SHORTPTR(p_cur);
4696 uint16_t *p16_ref = CONVERT_TO_SHORTPTR(p_ref);
4697 for (int tmpY = 0; tmpY < block_size && match; tmpY++) {
4698 for (int tmpX = 0; tmpX < block_size && match; tmpX++) {
4699 if (p16_cur[tmpX] != p16_ref[tmpX]) {
4700 match = 0;
4701 }
4702 }
4703 p16_cur += stride_cur;
4704 p16_ref += stride_ref;
4705 }
4706 } else {
4707 for (int tmpY = 0; tmpY < block_size && match; tmpY++) {
4708 for (int tmpX = 0; tmpX < block_size && match; tmpX++) {
4709 if (p_cur[tmpX] != p_ref[tmpX]) {
4710 match = 0;
4711 }
4712 }
4713 p_cur += stride_cur;
4714 p_ref += stride_ref;
4715 }
4716 }
4717
4718 if (match) {
4719 C++;
4720 continue;
4721 }
4722
4723 if (av1_hash_is_horizontal_perfect(cur_picture, block_size, x_pos,
4724 y_pos) ||
4725 av1_hash_is_vertical_perfect(cur_picture, block_size, x_pos, y_pos)) {
4726 S++;
4727 continue;
4728 }
4729
4730 av1_get_block_hash_value(
4731 cur_picture->y_buffer + y_pos * stride_cur + x_pos, stride_cur,
4732 block_size, &hash_value_1, &hash_value_2,
4733 (cur_picture->flags & YV12_FLAG_HIGHBITDEPTH), &cpi->td.mb);
4734 // Hashing does not work for highbitdepth currently.
4735 // TODO(Roger): Make it work for highbitdepth.
4736 if (av1_use_hash_me(&cpi->common)) {
4737 if (av1_has_exact_match(last_hash_table, hash_value_1, hash_value_2)) {
4738 M++;
4739 }
4740 }
4741 }
4742 }
4743
4744 assert(T > 0);
4745 double csm_rate = ((double)(C + S + M)) / ((double)(T));
4746 double m_rate = ((double)(M)) / ((double)(T));
4747
4748 cpi->csm_rate_array[cpi->rate_index] = csm_rate;
4749 cpi->m_rate_array[cpi->rate_index] = m_rate;
4750
4751 cpi->rate_index = (cpi->rate_index + 1) % max_history_size;
4752 cpi->rate_size++;
4753 cpi->rate_size = AOMMIN(cpi->rate_size, max_history_size);
4754
4755 if (csm_rate < threshold_current) {
4756 return 0;
4757 }
4758
4759 if (C == T) {
4760 return 1;
4761 }
4762
4763 double csm_average = 0.0;
4764 double m_average = 0.0;
4765
4766 for (k = 0; k < cpi->rate_size; k++) {
4767 csm_average += cpi->csm_rate_array[k];
4768 m_average += cpi->m_rate_array[k];
4769 }
4770 csm_average /= cpi->rate_size;
4771 m_average /= cpi->rate_size;
4772
4773 if (csm_average < threshold_average) {
4774 return 0;
4775 }
4776
4777 if (M > (T - C - S) / 3) {
4778 return 1;
4779 }
4780
4781 if (csm_rate > 0.99 && m_rate > 0.01) {
4782 return 1;
4783 }
4784
4785 if (csm_average + m_average > 1.01) {
4786 return 1;
4787 }
4788
4789 return 0;
4790 }
4791
4792 // Refresh reference frame buffers according to refresh_frame_flags.
refresh_reference_frames(AV1_COMP * cpi)4793 static void refresh_reference_frames(AV1_COMP *cpi) {
4794 AV1_COMMON *const cm = &cpi->common;
4795 // All buffers are refreshed for shown keyframes and S-frames.
4796
4797 for (int ref_frame = 0; ref_frame < REF_FRAMES; ref_frame++) {
4798 if (((cm->current_frame.refresh_frame_flags >> ref_frame) & 1) == 1) {
4799 assign_frame_buffer_p(&cm->ref_frame_map[ref_frame], cm->cur_frame);
4800 }
4801 }
4802 }
4803
encode_frame_to_data_rate(AV1_COMP * cpi,size_t * size,uint8_t * dest)4804 static int encode_frame_to_data_rate(AV1_COMP *cpi, size_t *size,
4805 uint8_t *dest) {
4806 AV1_COMMON *const cm = &cpi->common;
4807 SequenceHeader *const seq_params = &cm->seq_params;
4808 CurrentFrame *const current_frame = &cm->current_frame;
4809 const AV1EncoderConfig *const oxcf = &cpi->oxcf;
4810 struct segmentation *const seg = &cm->seg;
4811
4812 #if CONFIG_COLLECT_COMPONENT_TIMING
4813 start_timing(cpi, encode_frame_to_data_rate_time);
4814 #endif
4815
4816 // frame type has been decided outside of this function call
4817 cm->cur_frame->frame_type = current_frame->frame_type;
4818
4819 cm->large_scale_tile = cpi->oxcf.large_scale_tile;
4820 cm->single_tile_decoding = cpi->oxcf.single_tile_decoding;
4821
4822 cm->allow_ref_frame_mvs &= frame_might_allow_ref_frame_mvs(cm);
4823 // cm->allow_ref_frame_mvs needs to be written into the frame header while
4824 // cm->large_scale_tile is 1, therefore, "cm->large_scale_tile=1" case is
4825 // separated from frame_might_allow_ref_frame_mvs().
4826 cm->allow_ref_frame_mvs &= !cm->large_scale_tile;
4827
4828 cm->allow_warped_motion =
4829 cpi->oxcf.allow_warped_motion && frame_might_allow_warped_motion(cm);
4830
4831 cm->last_frame_type = current_frame->frame_type;
4832 if (cpi->oxcf.pass == 2 && cpi->sf.adaptive_interp_filter_search)
4833 cpi->sf.interp_filter_search_mask = setup_interp_filter_search_mask(cpi);
4834
4835 cpi->two_pass_partition_search = cpi->sf.two_pass_partition_search &&
4836 !cpi->partition_search_skippable_frame;
4837
4838 if (encode_show_existing_frame(cm)) {
4839 restore_coding_context(cpi);
4840
4841 finalize_encoded_frame(cpi);
4842 // Build the bitstream
4843 int largest_tile_id = 0; // Output from bitstream: unused here
4844 if (av1_pack_bitstream(cpi, dest, size, &largest_tile_id) != AOM_CODEC_OK)
4845 return AOM_CODEC_ERROR;
4846
4847 if (seq_params->frame_id_numbers_present_flag &&
4848 current_frame->frame_type == KEY_FRAME) {
4849 // Displaying a forward key-frame, so reset the ref buffer IDs
4850 int display_frame_id = cm->ref_frame_id[cpi->existing_fb_idx_to_show];
4851 for (int i = 0; i < REF_FRAMES; i++)
4852 cm->ref_frame_id[i] = display_frame_id;
4853 }
4854
4855 cpi->seq_params_locked = 1;
4856
4857 #if DUMP_RECON_FRAMES == 1
4858 // NOTE(zoeliu): For debug - Output the filtered reconstructed video.
4859 dump_filtered_recon_frames(cpi);
4860 #endif // DUMP_RECON_FRAMES
4861
4862 // NOTE: Save the new show frame buffer index for --test-code=warn, i.e.,
4863 // for the purpose to verify no mismatch between encoder and decoder.
4864 if (cm->show_frame) cpi->last_show_frame_buf = cm->cur_frame;
4865
4866 refresh_reference_frames(cpi);
4867
4868 // Since we allocate a spot for the OVERLAY frame in the gf group, we need
4869 // to do post-encoding update accordingly.
4870 if (cpi->rc.is_src_frame_alt_ref) {
4871 av1_set_target_rate(cpi, cm->width, cm->height);
4872 av1_rc_postencode_update(cpi, *size);
4873 }
4874
4875 ++current_frame->frame_number;
4876
4877 return AOM_CODEC_OK;
4878 }
4879
4880 // Work out whether to force_integer_mv this frame
4881 if (oxcf->pass != 1 && cpi->common.allow_screen_content_tools &&
4882 !frame_is_intra_only(cm)) {
4883 if (cpi->common.seq_params.force_integer_mv == 2) {
4884 // Adaptive mode: see what previous frame encoded did
4885 if (cpi->unscaled_last_source != NULL) {
4886 cm->cur_frame_force_integer_mv =
4887 is_integer_mv(cpi, cpi->source, cpi->unscaled_last_source,
4888 cpi->previous_hash_table);
4889 } else {
4890 cpi->common.cur_frame_force_integer_mv = 0;
4891 }
4892 } else {
4893 cpi->common.cur_frame_force_integer_mv =
4894 cpi->common.seq_params.force_integer_mv;
4895 }
4896 } else {
4897 cpi->common.cur_frame_force_integer_mv = 0;
4898 }
4899
4900 // Set default state for segment based loop filter update flags.
4901 cm->lf.mode_ref_delta_update = 0;
4902
4903 // Set various flags etc to special state if it is a key frame.
4904 if (frame_is_intra_only(cm) || frame_is_sframe(cm)) {
4905 // Reset the loop filter deltas and segmentation map.
4906 av1_reset_segment_features(cm);
4907
4908 // If segmentation is enabled force a map update for key frames.
4909 if (seg->enabled) {
4910 seg->update_map = 1;
4911 seg->update_data = 1;
4912 }
4913
4914 // The alternate reference frame cannot be active for a key frame.
4915 cpi->rc.source_alt_ref_active = 0;
4916 }
4917 if (cpi->oxcf.mtu == 0) {
4918 cm->num_tg = cpi->oxcf.num_tile_groups;
4919 } else {
4920 // Use a default value for the purposes of weighting costs in probability
4921 // updates
4922 cm->num_tg = DEFAULT_MAX_NUM_TG;
4923 }
4924
4925 // For 1 pass CBR, check if we are dropping this frame.
4926 // Never drop on key frame.
4927 if (oxcf->pass == 0 && oxcf->rc_mode == AOM_CBR &&
4928 current_frame->frame_type != KEY_FRAME) {
4929 if (av1_rc_drop_frame(cpi)) {
4930 av1_rc_postencode_update_drop_frame(cpi);
4931 release_scaled_references(cpi);
4932 return AOM_CODEC_OK;
4933 }
4934 }
4935
4936 aom_clear_system_state();
4937
4938 #if CONFIG_INTERNAL_STATS
4939 memset(cpi->mode_chosen_counts, 0,
4940 MAX_MODES * sizeof(*cpi->mode_chosen_counts));
4941 #endif
4942
4943 if (seq_params->frame_id_numbers_present_flag) {
4944 /* Non-normative definition of current_frame_id ("frame counter" with
4945 * wraparound) */
4946 if (cm->current_frame_id == -1) {
4947 int lsb, msb;
4948 /* quasi-random initialization of current_frame_id for a key frame */
4949 if (cpi->source->flags & YV12_FLAG_HIGHBITDEPTH) {
4950 lsb = CONVERT_TO_SHORTPTR(cpi->source->y_buffer)[0] & 0xff;
4951 msb = CONVERT_TO_SHORTPTR(cpi->source->y_buffer)[1] & 0xff;
4952 } else {
4953 lsb = cpi->source->y_buffer[0] & 0xff;
4954 msb = cpi->source->y_buffer[1] & 0xff;
4955 }
4956 cm->current_frame_id =
4957 ((msb << 8) + lsb) % (1 << seq_params->frame_id_length);
4958
4959 // S_frame is meant for stitching different streams of different
4960 // resolutions together, so current_frame_id must be the
4961 // same across different streams of the same content current_frame_id
4962 // should be the same and not random. 0x37 is a chosen number as start
4963 // point
4964 if (cpi->oxcf.sframe_enabled) cm->current_frame_id = 0x37;
4965 } else {
4966 cm->current_frame_id =
4967 (cm->current_frame_id + 1 + (1 << seq_params->frame_id_length)) %
4968 (1 << seq_params->frame_id_length);
4969 }
4970 }
4971
4972 switch (cpi->oxcf.cdf_update_mode) {
4973 case 0: // No CDF update for any frames(4~6% compression loss).
4974 cm->disable_cdf_update = 1;
4975 break;
4976 case 1: // Enable CDF update for all frames.
4977 cm->disable_cdf_update = 0;
4978 break;
4979 case 2:
4980 // Strategically determine at which frames to do CDF update.
4981 // Currently only enable CDF update for all-intra and no-show frames(1.5%
4982 // compression loss).
4983 // TODO(huisu@google.com): design schemes for various trade-offs between
4984 // compression quality and decoding speed.
4985 cm->disable_cdf_update =
4986 (frame_is_intra_only(cm) || !cm->show_frame) ? 0 : 1;
4987 break;
4988 }
4989 cm->timing_info_present &= !seq_params->reduced_still_picture_hdr;
4990
4991 #if CONFIG_COLLECT_COMPONENT_TIMING
4992 start_timing(cpi, encode_with_recode_loop_time);
4993 #endif
4994 if (encode_with_recode_loop(cpi, size, dest) != AOM_CODEC_OK)
4995 return AOM_CODEC_ERROR;
4996 #if CONFIG_COLLECT_COMPONENT_TIMING
4997 end_timing(cpi, encode_with_recode_loop_time);
4998 #endif
4999
5000 #ifdef OUTPUT_YUV_SKINMAP
5001 if (cpi->common.current_frame.frame_number > 1) {
5002 av1_compute_skin_map(cpi, yuv_skinmap_file);
5003 }
5004 #endif // OUTPUT_YUV_SKINMAP
5005
5006 // Special case code to reduce pulsing when key frames are forced at a
5007 // fixed interval. Note the reconstruction error if it is the frame before
5008 // the force key frame
5009 if (cpi->rc.next_key_frame_forced && cpi->rc.frames_to_key == 1) {
5010 if (seq_params->use_highbitdepth) {
5011 cpi->ambient_err = aom_highbd_get_y_sse(cpi->source, &cm->cur_frame->buf);
5012 } else {
5013 cpi->ambient_err = aom_get_y_sse(cpi->source, &cm->cur_frame->buf);
5014 }
5015 }
5016
5017 cm->cur_frame->buf.color_primaries = seq_params->color_primaries;
5018 cm->cur_frame->buf.transfer_characteristics =
5019 seq_params->transfer_characteristics;
5020 cm->cur_frame->buf.matrix_coefficients = seq_params->matrix_coefficients;
5021 cm->cur_frame->buf.monochrome = seq_params->monochrome;
5022 cm->cur_frame->buf.chroma_sample_position =
5023 seq_params->chroma_sample_position;
5024 cm->cur_frame->buf.color_range = seq_params->color_range;
5025 cm->cur_frame->buf.render_width = cm->render_width;
5026 cm->cur_frame->buf.render_height = cm->render_height;
5027
5028 // TODO(zoeliu): For non-ref frames, loop filtering may need to be turned
5029 // off.
5030
5031 // Pick the loop filter level for the frame.
5032 if (!cm->allow_intrabc) {
5033 loopfilter_frame(cpi, cm);
5034 } else {
5035 cm->lf.filter_level[0] = 0;
5036 cm->lf.filter_level[1] = 0;
5037 cm->cdef_info.cdef_bits = 0;
5038 cm->cdef_info.cdef_strengths[0] = 0;
5039 cm->cdef_info.nb_cdef_strengths = 1;
5040 cm->cdef_info.cdef_uv_strengths[0] = 0;
5041 cm->rst_info[0].frame_restoration_type = RESTORE_NONE;
5042 cm->rst_info[1].frame_restoration_type = RESTORE_NONE;
5043 cm->rst_info[2].frame_restoration_type = RESTORE_NONE;
5044 }
5045
5046 // TODO(debargha): Fix mv search range on encoder side
5047 // aom_extend_frame_inner_borders(&cm->cur_frame->buf, av1_num_planes(cm));
5048 aom_extend_frame_borders(&cm->cur_frame->buf, av1_num_planes(cm));
5049
5050 #ifdef OUTPUT_YUV_REC
5051 aom_write_one_yuv_frame(cm, &cm->cur_frame->buf);
5052 #endif
5053
5054 finalize_encoded_frame(cpi);
5055 // Build the bitstream
5056 int largest_tile_id = 0; // Output from pack_bitstream
5057 #if CONFIG_COLLECT_COMPONENT_TIMING
5058 start_timing(cpi, av1_pack_bitstream_final_time);
5059 #endif
5060 if (av1_pack_bitstream(cpi, dest, size, &largest_tile_id) != AOM_CODEC_OK)
5061 return AOM_CODEC_ERROR;
5062 #if CONFIG_COLLECT_COMPONENT_TIMING
5063 end_timing(cpi, av1_pack_bitstream_final_time);
5064 #endif
5065
5066 cpi->seq_params_locked = 1;
5067
5068 // Update reference frame ids for reference frames this frame will overwrite
5069 if (seq_params->frame_id_numbers_present_flag) {
5070 for (int i = 0; i < REF_FRAMES; i++) {
5071 if ((current_frame->refresh_frame_flags >> i) & 1) {
5072 cm->ref_frame_id[i] = cm->current_frame_id;
5073 }
5074 }
5075 }
5076
5077 #if DUMP_RECON_FRAMES == 1
5078 // NOTE(zoeliu): For debug - Output the filtered reconstructed video.
5079 dump_filtered_recon_frames(cpi);
5080 #endif // DUMP_RECON_FRAMES
5081
5082 if (cm->seg.enabled) {
5083 if (cm->seg.update_map) {
5084 update_reference_segmentation_map(cpi);
5085 } else if (cm->last_frame_seg_map) {
5086 memcpy(cm->cur_frame->seg_map, cm->last_frame_seg_map,
5087 cm->mi_cols * cm->mi_rows * sizeof(uint8_t));
5088 }
5089 }
5090
5091 if (frame_is_intra_only(cm) == 0) {
5092 release_scaled_references(cpi);
5093 }
5094
5095 // NOTE: Save the new show frame buffer index for --test-code=warn, i.e.,
5096 // for the purpose to verify no mismatch between encoder and decoder.
5097 if (cm->show_frame) cpi->last_show_frame_buf = cm->cur_frame;
5098
5099 refresh_reference_frames(cpi);
5100
5101 #if CONFIG_ENTROPY_STATS
5102 av1_accumulate_frame_counts(&aggregate_fc, &cpi->counts);
5103 #endif // CONFIG_ENTROPY_STATS
5104
5105 if (cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD) {
5106 *cm->fc = cpi->tile_data[largest_tile_id].tctx;
5107 av1_reset_cdf_symbol_counters(cm->fc);
5108 }
5109 if (!cm->large_scale_tile) {
5110 cm->cur_frame->frame_context = *cm->fc;
5111 }
5112 #define EXT_TILE_DEBUG 0
5113 #if EXT_TILE_DEBUG
5114 if (cm->large_scale_tile && oxcf->pass == 2) {
5115 char fn[20] = "./fc";
5116 fn[4] = current_frame->frame_number / 100 + '0';
5117 fn[5] = (current_frame->frame_number % 100) / 10 + '0';
5118 fn[6] = (current_frame->frame_number % 10) + '0';
5119 fn[7] = '\0';
5120 av1_print_frame_contexts(cm->fc, fn);
5121 }
5122 #endif // EXT_TILE_DEBUG
5123 #undef EXT_TILE_DEBUG
5124
5125 #if CONFIG_COLLECT_COMPONENT_TIMING
5126 end_timing(cpi, encode_frame_to_data_rate_time);
5127
5128 // Print out timing information.
5129 int i;
5130 fprintf(stderr, "\n Frame number: %d, Frame type: %s, Show Frame: %d\n",
5131 cm->current_frame.frame_number,
5132 get_frame_type_enum(cm->current_frame.frame_type), cm->show_frame);
5133 for (i = 0; i < kTimingComponents; i++) {
5134 cpi->component_time[i] += cpi->frame_component_time[i];
5135 fprintf(stderr, " %s: %" PRId64 " us (total: %" PRId64 " us)\n",
5136 get_component_name(i), cpi->frame_component_time[i],
5137 cpi->component_time[i]);
5138 cpi->frame_component_time[i] = 0;
5139 }
5140 #endif
5141
5142 cm->last_frame_type = current_frame->frame_type;
5143
5144 av1_rc_postencode_update(cpi, *size);
5145
5146 // Store encoded frame's hash table for is_integer_mv() next time
5147 if (oxcf->pass != 1 && cpi->common.allow_screen_content_tools) {
5148 cpi->previous_hash_table = &cm->cur_frame->hash_table;
5149 }
5150
5151 // Clear the one shot update flags for segmentation map and mode/ref loop
5152 // filter deltas.
5153 cm->seg.update_map = 0;
5154 cm->seg.update_data = 0;
5155 cm->lf.mode_ref_delta_update = 0;
5156
5157 // A droppable frame might not be shown but it always
5158 // takes a space in the gf group. Therefore, even when
5159 // it is not shown, we still need update the count down.
5160
5161 if (cm->show_frame) {
5162 // TODO(zoeliu): We may only swamp mi and prev_mi for those frames that
5163 // are
5164 // being used as reference.
5165 swap_mi_and_prev_mi(cm);
5166 // Don't increment frame counters if this was an altref buffer
5167 // update not a real frame
5168
5169 ++current_frame->frame_number;
5170 }
5171
5172 return AOM_CODEC_OK;
5173 }
5174
av1_encode(AV1_COMP * const cpi,uint8_t * const dest,const EncodeFrameInput * const frame_input,const EncodeFrameParams * const frame_params,EncodeFrameResults * const frame_results)5175 int av1_encode(AV1_COMP *const cpi, uint8_t *const dest,
5176 const EncodeFrameInput *const frame_input,
5177 const EncodeFrameParams *const frame_params,
5178 EncodeFrameResults *const frame_results) {
5179 AV1_COMMON *const cm = &cpi->common;
5180 CurrentFrame *const current_frame = &cm->current_frame;
5181
5182 cpi->unscaled_source = frame_input->source;
5183 cpi->source = frame_input->source;
5184 cpi->unscaled_last_source = frame_input->last_source;
5185
5186 current_frame->refresh_frame_flags = frame_params->refresh_frame_flags;
5187 cm->error_resilient_mode = frame_params->error_resilient_mode;
5188 cm->primary_ref_frame = frame_params->primary_ref_frame;
5189 cm->current_frame.frame_type = frame_params->frame_type;
5190 cm->show_frame = frame_params->show_frame;
5191 cpi->ref_frame_flags = frame_params->ref_frame_flags;
5192 cpi->speed = frame_params->speed;
5193 cm->show_existing_frame = frame_params->show_existing_frame;
5194 cpi->existing_fb_idx_to_show = frame_params->existing_fb_idx_to_show;
5195
5196 memcpy(cm->remapped_ref_idx, frame_params->remapped_ref_idx,
5197 REF_FRAMES * sizeof(*cm->remapped_ref_idx));
5198
5199 cpi->refresh_last_frame = frame_params->refresh_last_frame;
5200 cpi->refresh_golden_frame = frame_params->refresh_golden_frame;
5201 cpi->refresh_bwd_ref_frame = frame_params->refresh_bwd_ref_frame;
5202 cpi->refresh_alt2_ref_frame = frame_params->refresh_alt2_ref_frame;
5203 cpi->refresh_alt_ref_frame = frame_params->refresh_alt_ref_frame;
5204
5205 if (current_frame->frame_type == KEY_FRAME && cm->show_frame)
5206 current_frame->frame_number = 0;
5207
5208 if (cm->show_existing_frame) {
5209 current_frame->order_hint = cm->cur_frame->order_hint;
5210 } else {
5211 current_frame->order_hint =
5212 current_frame->frame_number + frame_params->order_offset;
5213 current_frame->order_hint %=
5214 (1 << (cm->seq_params.order_hint_info.order_hint_bits_minus_1 + 1));
5215 }
5216
5217 if (cpi->oxcf.pass == 1) {
5218 av1_first_pass(cpi, frame_input->ts_duration);
5219 } else if (cpi->oxcf.pass == 0 || cpi->oxcf.pass == 2) {
5220 if (encode_frame_to_data_rate(cpi, &frame_results->size, dest) !=
5221 AOM_CODEC_OK) {
5222 return AOM_CODEC_ERROR;
5223 }
5224 } else {
5225 return AOM_CODEC_ERROR;
5226 }
5227
5228 return AOM_CODEC_OK;
5229 }
5230
5231 #if CONFIG_DENOISE
apply_denoise_2d(AV1_COMP * cpi,YV12_BUFFER_CONFIG * sd,int block_size,float noise_level,int64_t time_stamp,int64_t end_time)5232 static int apply_denoise_2d(AV1_COMP *cpi, YV12_BUFFER_CONFIG *sd,
5233 int block_size, float noise_level,
5234 int64_t time_stamp, int64_t end_time) {
5235 AV1_COMMON *const cm = &cpi->common;
5236 if (!cpi->denoise_and_model) {
5237 cpi->denoise_and_model = aom_denoise_and_model_alloc(
5238 cm->seq_params.bit_depth, block_size, noise_level);
5239 if (!cpi->denoise_and_model) {
5240 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
5241 "Error allocating denoise and model");
5242 return -1;
5243 }
5244 }
5245 if (!cpi->film_grain_table) {
5246 cpi->film_grain_table = aom_malloc(sizeof(*cpi->film_grain_table));
5247 if (!cpi->film_grain_table) {
5248 aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
5249 "Error allocating grain table");
5250 return -1;
5251 }
5252 memset(cpi->film_grain_table, 0, sizeof(*cpi->film_grain_table));
5253 }
5254 if (aom_denoise_and_model_run(cpi->denoise_and_model, sd,
5255 &cm->film_grain_params)) {
5256 if (cm->film_grain_params.apply_grain) {
5257 aom_film_grain_table_append(cpi->film_grain_table, time_stamp, end_time,
5258 &cm->film_grain_params);
5259 }
5260 }
5261 return 0;
5262 }
5263 #endif
5264
av1_receive_raw_frame(AV1_COMP * cpi,aom_enc_frame_flags_t frame_flags,YV12_BUFFER_CONFIG * sd,int64_t time_stamp,int64_t end_time)5265 int av1_receive_raw_frame(AV1_COMP *cpi, aom_enc_frame_flags_t frame_flags,
5266 YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
5267 int64_t end_time) {
5268 AV1_COMMON *const cm = &cpi->common;
5269 const SequenceHeader *const seq_params = &cm->seq_params;
5270 int res = 0;
5271 const int subsampling_x = sd->subsampling_x;
5272 const int subsampling_y = sd->subsampling_y;
5273 const int use_highbitdepth = (sd->flags & YV12_FLAG_HIGHBITDEPTH) != 0;
5274
5275 check_initial_width(cpi, use_highbitdepth, subsampling_x, subsampling_y);
5276
5277 #if CONFIG_INTERNAL_STATS
5278 struct aom_usec_timer timer;
5279 aom_usec_timer_start(&timer);
5280 #endif
5281 #if CONFIG_DENOISE
5282 if (cpi->oxcf.noise_level > 0)
5283 if (apply_denoise_2d(cpi, sd, cpi->oxcf.noise_block_size,
5284 cpi->oxcf.noise_level, time_stamp, end_time) < 0)
5285 res = -1;
5286 #endif // CONFIG_DENOISE
5287
5288 if (av1_lookahead_push(cpi->lookahead, sd, time_stamp, end_time,
5289 use_highbitdepth, frame_flags))
5290 res = -1;
5291 #if CONFIG_INTERNAL_STATS
5292 aom_usec_timer_mark(&timer);
5293 cpi->time_receive_data += aom_usec_timer_elapsed(&timer);
5294 #endif
5295 if ((seq_params->profile == PROFILE_0) && !seq_params->monochrome &&
5296 (subsampling_x != 1 || subsampling_y != 1)) {
5297 aom_internal_error(&cm->error, AOM_CODEC_INVALID_PARAM,
5298 "Non-4:2:0 color format requires profile 1 or 2");
5299 res = -1;
5300 }
5301 if ((seq_params->profile == PROFILE_1) &&
5302 !(subsampling_x == 0 && subsampling_y == 0)) {
5303 aom_internal_error(&cm->error, AOM_CODEC_INVALID_PARAM,
5304 "Profile 1 requires 4:4:4 color format");
5305 res = -1;
5306 }
5307 if ((seq_params->profile == PROFILE_2) &&
5308 (seq_params->bit_depth <= AOM_BITS_10) &&
5309 !(subsampling_x == 1 && subsampling_y == 0)) {
5310 aom_internal_error(&cm->error, AOM_CODEC_INVALID_PARAM,
5311 "Profile 2 bit-depth < 10 requires 4:2:2 color format");
5312 res = -1;
5313 }
5314
5315 return res;
5316 }
5317
5318 #if CONFIG_INTERNAL_STATS
5319 extern double av1_get_blockiness(const unsigned char *img1, int img1_pitch,
5320 const unsigned char *img2, int img2_pitch,
5321 int width, int height);
5322
adjust_image_stat(double y,double u,double v,double all,ImageStat * s)5323 static void adjust_image_stat(double y, double u, double v, double all,
5324 ImageStat *s) {
5325 s->stat[STAT_Y] += y;
5326 s->stat[STAT_U] += u;
5327 s->stat[STAT_V] += v;
5328 s->stat[STAT_ALL] += all;
5329 s->worst = AOMMIN(s->worst, all);
5330 }
5331
compute_internal_stats(AV1_COMP * cpi,int frame_bytes)5332 static void compute_internal_stats(AV1_COMP *cpi, int frame_bytes) {
5333 AV1_COMMON *const cm = &cpi->common;
5334 double samples = 0.0;
5335 uint32_t in_bit_depth = 8;
5336 uint32_t bit_depth = 8;
5337
5338 #if CONFIG_INTER_STATS_ONLY
5339 if (cm->current_frame.frame_type == KEY_FRAME) return; // skip key frame
5340 #endif
5341 cpi->bytes += frame_bytes;
5342
5343 if (cm->seq_params.use_highbitdepth) {
5344 in_bit_depth = cpi->oxcf.input_bit_depth;
5345 bit_depth = cm->seq_params.bit_depth;
5346 }
5347 if (cm->show_frame) {
5348 const YV12_BUFFER_CONFIG *orig = cpi->source;
5349 const YV12_BUFFER_CONFIG *recon = &cpi->common.cur_frame->buf;
5350 double y, u, v, frame_all;
5351
5352 cpi->count++;
5353 if (cpi->b_calculate_psnr) {
5354 PSNR_STATS psnr;
5355 double frame_ssim2 = 0.0, weight = 0.0;
5356 aom_clear_system_state();
5357 // TODO(yaowu): unify these two versions into one.
5358 aom_calc_highbd_psnr(orig, recon, &psnr, bit_depth, in_bit_depth);
5359
5360 adjust_image_stat(psnr.psnr[1], psnr.psnr[2], psnr.psnr[3], psnr.psnr[0],
5361 &cpi->psnr);
5362 cpi->total_sq_error += psnr.sse[0];
5363 cpi->total_samples += psnr.samples[0];
5364 samples = psnr.samples[0];
5365 // TODO(yaowu): unify these two versions into one.
5366 if (cm->seq_params.use_highbitdepth)
5367 frame_ssim2 =
5368 aom_highbd_calc_ssim(orig, recon, &weight, bit_depth, in_bit_depth);
5369 else
5370 frame_ssim2 = aom_calc_ssim(orig, recon, &weight);
5371
5372 cpi->worst_ssim = AOMMIN(cpi->worst_ssim, frame_ssim2);
5373 cpi->summed_quality += frame_ssim2 * weight;
5374 cpi->summed_weights += weight;
5375
5376 #if 0
5377 {
5378 FILE *f = fopen("q_used.stt", "a");
5379 double y2 = psnr.psnr[1];
5380 double u2 = psnr.psnr[2];
5381 double v2 = psnr.psnr[3];
5382 double frame_psnr2 = psnr.psnr[0];
5383 fprintf(f, "%5d : Y%f7.3:U%f7.3:V%f7.3:F%f7.3:S%7.3f\n",
5384 cm->current_frame.frame_number, y2, u2, v2,
5385 frame_psnr2, frame_ssim2);
5386 fclose(f);
5387 }
5388 #endif
5389 }
5390 if (cpi->b_calculate_blockiness) {
5391 if (!cm->seq_params.use_highbitdepth) {
5392 const double frame_blockiness =
5393 av1_get_blockiness(orig->y_buffer, orig->y_stride, recon->y_buffer,
5394 recon->y_stride, orig->y_width, orig->y_height);
5395 cpi->worst_blockiness = AOMMAX(cpi->worst_blockiness, frame_blockiness);
5396 cpi->total_blockiness += frame_blockiness;
5397 }
5398
5399 if (cpi->b_calculate_consistency) {
5400 if (!cm->seq_params.use_highbitdepth) {
5401 const double this_inconsistency = aom_get_ssim_metrics(
5402 orig->y_buffer, orig->y_stride, recon->y_buffer, recon->y_stride,
5403 orig->y_width, orig->y_height, cpi->ssim_vars, &cpi->metrics, 1);
5404
5405 const double peak = (double)((1 << in_bit_depth) - 1);
5406 const double consistency =
5407 aom_sse_to_psnr(samples, peak, cpi->total_inconsistency);
5408 if (consistency > 0.0)
5409 cpi->worst_consistency =
5410 AOMMIN(cpi->worst_consistency, consistency);
5411 cpi->total_inconsistency += this_inconsistency;
5412 }
5413 }
5414 }
5415
5416 frame_all =
5417 aom_calc_fastssim(orig, recon, &y, &u, &v, bit_depth, in_bit_depth);
5418 adjust_image_stat(y, u, v, frame_all, &cpi->fastssim);
5419 frame_all = aom_psnrhvs(orig, recon, &y, &u, &v, bit_depth, in_bit_depth);
5420 adjust_image_stat(y, u, v, frame_all, &cpi->psnrhvs);
5421 }
5422 }
5423 #endif // CONFIG_INTERNAL_STATS
av1_get_compressed_data(AV1_COMP * cpi,unsigned int * frame_flags,size_t * size,uint8_t * dest,int64_t * time_stamp,int64_t * time_end,int flush,const aom_rational_t * timebase)5424 int av1_get_compressed_data(AV1_COMP *cpi, unsigned int *frame_flags,
5425 size_t *size, uint8_t *dest, int64_t *time_stamp,
5426 int64_t *time_end, int flush,
5427 const aom_rational_t *timebase) {
5428 const AV1EncoderConfig *const oxcf = &cpi->oxcf;
5429 AV1_COMMON *const cm = &cpi->common;
5430
5431 #if CONFIG_BITSTREAM_DEBUG
5432 assert(cpi->oxcf.max_threads == 0 &&
5433 "bitstream debug tool does not support multithreading");
5434 bitstream_queue_record_write();
5435 bitstream_queue_set_frame_write(cm->current_frame.frame_number * 2 +
5436 cm->show_frame);
5437 #endif
5438
5439 // Indicates whether or not to use an adaptive quantize b rather than
5440 // the traditional version
5441 cm->use_quant_b_adapt = cpi->oxcf.quant_b_adapt;
5442
5443 cm->showable_frame = 0;
5444 *size = 0;
5445 #if CONFIG_INTERNAL_STATS
5446 struct aom_usec_timer cmptimer;
5447 aom_usec_timer_start(&cmptimer);
5448 #endif
5449 set_high_precision_mv(cpi, ALTREF_HIGH_PRECISION_MV, 0);
5450
5451 // Normal defaults
5452 cm->refresh_frame_context = oxcf->frame_parallel_decoding_mode
5453 ? REFRESH_FRAME_CONTEXT_DISABLED
5454 : REFRESH_FRAME_CONTEXT_BACKWARD;
5455 if (oxcf->large_scale_tile)
5456 cm->refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED;
5457
5458 // Initialize fields related to forward keyframes
5459 cpi->no_show_kf = 0;
5460
5461 if (assign_cur_frame_new_fb(cm) == NULL) return AOM_CODEC_ERROR;
5462
5463 const int result = av1_encode_strategy(cpi, size, dest, frame_flags,
5464 time_stamp, time_end, timebase, flush);
5465 if (result != AOM_CODEC_OK && result != -1) {
5466 return AOM_CODEC_ERROR;
5467 } else if (result == -1) {
5468 // Returning -1 indicates no frame encoded; more input is required
5469 return -1;
5470 }
5471 #if CONFIG_INTERNAL_STATS
5472 aom_usec_timer_mark(&cmptimer);
5473 cpi->time_compress_data += aom_usec_timer_elapsed(&cmptimer);
5474 #endif
5475 if (cpi->b_calculate_psnr) {
5476 if (cm->show_existing_frame || (oxcf->pass != 1 && cm->show_frame)) {
5477 generate_psnr_packet(cpi);
5478 }
5479 }
5480 if (cpi->keep_level_stats && oxcf->pass != 1)
5481 av1_update_level_info(cpi, *size, *time_stamp, *time_end);
5482
5483 #if CONFIG_INTERNAL_STATS
5484 if (oxcf->pass != 1) {
5485 compute_internal_stats(cpi, (int)(*size));
5486 }
5487 #endif // CONFIG_INTERNAL_STATS
5488 #if CONFIG_SPEED_STATS
5489 if (cpi->oxcf.pass != 1 && !cm->show_existing_frame) {
5490 cpi->tx_search_count += cpi->td.mb.tx_search_count;
5491 cpi->td.mb.tx_search_count = 0;
5492 }
5493 #endif // CONFIG_SPEED_STATS
5494
5495 aom_clear_system_state();
5496
5497 return 0;
5498 }
5499
av1_get_preview_raw_frame(AV1_COMP * cpi,YV12_BUFFER_CONFIG * dest)5500 int av1_get_preview_raw_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *dest) {
5501 AV1_COMMON *cm = &cpi->common;
5502 if (!cm->show_frame) {
5503 return -1;
5504 } else {
5505 int ret;
5506 if (cm->cur_frame != NULL) {
5507 *dest = cm->cur_frame->buf;
5508 dest->y_width = cm->width;
5509 dest->y_height = cm->height;
5510 dest->uv_width = cm->width >> cm->seq_params.subsampling_x;
5511 dest->uv_height = cm->height >> cm->seq_params.subsampling_y;
5512 ret = 0;
5513 } else {
5514 ret = -1;
5515 }
5516 aom_clear_system_state();
5517 return ret;
5518 }
5519 }
5520
av1_get_last_show_frame(AV1_COMP * cpi,YV12_BUFFER_CONFIG * frame)5521 int av1_get_last_show_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *frame) {
5522 if (cpi->last_show_frame_buf == NULL) return -1;
5523
5524 *frame = cpi->last_show_frame_buf->buf;
5525 return 0;
5526 }
5527
equal_dimensions_and_border(const YV12_BUFFER_CONFIG * a,const YV12_BUFFER_CONFIG * b)5528 static int equal_dimensions_and_border(const YV12_BUFFER_CONFIG *a,
5529 const YV12_BUFFER_CONFIG *b) {
5530 return a->y_height == b->y_height && a->y_width == b->y_width &&
5531 a->uv_height == b->uv_height && a->uv_width == b->uv_width &&
5532 a->y_stride == b->y_stride && a->uv_stride == b->uv_stride &&
5533 a->border == b->border &&
5534 (a->flags & YV12_FLAG_HIGHBITDEPTH) ==
5535 (b->flags & YV12_FLAG_HIGHBITDEPTH);
5536 }
5537
av1_copy_new_frame_enc(AV1_COMMON * cm,YV12_BUFFER_CONFIG * new_frame,YV12_BUFFER_CONFIG * sd)5538 aom_codec_err_t av1_copy_new_frame_enc(AV1_COMMON *cm,
5539 YV12_BUFFER_CONFIG *new_frame,
5540 YV12_BUFFER_CONFIG *sd) {
5541 const int num_planes = av1_num_planes(cm);
5542 if (!equal_dimensions_and_border(new_frame, sd))
5543 aom_internal_error(&cm->error, AOM_CODEC_ERROR,
5544 "Incorrect buffer dimensions");
5545 else
5546 aom_yv12_copy_frame(new_frame, sd, num_planes);
5547
5548 return cm->error.error_code;
5549 }
5550
av1_set_internal_size(AV1_COMP * cpi,AOM_SCALING horiz_mode,AOM_SCALING vert_mode)5551 int av1_set_internal_size(AV1_COMP *cpi, AOM_SCALING horiz_mode,
5552 AOM_SCALING vert_mode) {
5553 int hr = 0, hs = 0, vr = 0, vs = 0;
5554
5555 if (horiz_mode > ONETWO || vert_mode > ONETWO) return -1;
5556
5557 Scale2Ratio(horiz_mode, &hr, &hs);
5558 Scale2Ratio(vert_mode, &vr, &vs);
5559
5560 // always go to the next whole number
5561 cpi->resize_pending_width = (hs - 1 + cpi->oxcf.width * hr) / hs;
5562 cpi->resize_pending_height = (vs - 1 + cpi->oxcf.height * vr) / vs;
5563
5564 return 0;
5565 }
5566
av1_get_quantizer(AV1_COMP * cpi)5567 int av1_get_quantizer(AV1_COMP *cpi) { return cpi->common.base_qindex; }
5568
av1_convert_sect5obus_to_annexb(uint8_t * buffer,size_t * frame_size)5569 int av1_convert_sect5obus_to_annexb(uint8_t *buffer, size_t *frame_size) {
5570 size_t output_size = 0;
5571 size_t total_bytes_read = 0;
5572 size_t remaining_size = *frame_size;
5573 uint8_t *buff_ptr = buffer;
5574
5575 // go through each OBUs
5576 while (total_bytes_read < *frame_size) {
5577 uint8_t saved_obu_header[2];
5578 uint64_t obu_payload_size;
5579 size_t length_of_payload_size;
5580 size_t length_of_obu_size;
5581 uint32_t obu_header_size = (buff_ptr[0] >> 2) & 0x1 ? 2 : 1;
5582 size_t obu_bytes_read = obu_header_size; // bytes read for current obu
5583
5584 // save the obu header (1 or 2 bytes)
5585 memmove(saved_obu_header, buff_ptr, obu_header_size);
5586 // clear the obu_has_size_field
5587 saved_obu_header[0] = saved_obu_header[0] & (~0x2);
5588
5589 // get the payload_size and length of payload_size
5590 if (aom_uleb_decode(buff_ptr + obu_header_size, remaining_size,
5591 &obu_payload_size, &length_of_payload_size) != 0) {
5592 return AOM_CODEC_ERROR;
5593 }
5594 obu_bytes_read += length_of_payload_size;
5595
5596 // calculate the length of size of the obu header plus payload
5597 length_of_obu_size =
5598 aom_uleb_size_in_bytes((uint64_t)(obu_header_size + obu_payload_size));
5599
5600 // move the rest of data to new location
5601 memmove(buff_ptr + length_of_obu_size + obu_header_size,
5602 buff_ptr + obu_bytes_read, remaining_size - obu_bytes_read);
5603 obu_bytes_read += (size_t)obu_payload_size;
5604
5605 // write the new obu size
5606 const uint64_t obu_size = obu_header_size + obu_payload_size;
5607 size_t coded_obu_size;
5608 if (aom_uleb_encode(obu_size, sizeof(obu_size), buff_ptr,
5609 &coded_obu_size) != 0) {
5610 return AOM_CODEC_ERROR;
5611 }
5612
5613 // write the saved (modified) obu_header following obu size
5614 memmove(buff_ptr + length_of_obu_size, saved_obu_header, obu_header_size);
5615
5616 total_bytes_read += obu_bytes_read;
5617 remaining_size -= obu_bytes_read;
5618 buff_ptr += length_of_obu_size + obu_size;
5619 output_size += length_of_obu_size + (size_t)obu_size;
5620 }
5621
5622 *frame_size = output_size;
5623 return AOM_CODEC_OK;
5624 }
5625
av1_apply_encoding_flags(AV1_COMP * cpi,aom_enc_frame_flags_t flags)5626 void av1_apply_encoding_flags(AV1_COMP *cpi, aom_enc_frame_flags_t flags) {
5627 // TODO(yunqingwang): For what references to use, external encoding flags
5628 // should be consistent with internal reference frame selection. Need to
5629 // ensure that there is not conflict between the two. In AV1 encoder, the
5630 // priority rank for 7 reference frames are: LAST, ALTREF, LAST2, LAST3,
5631 // GOLDEN, BWDREF, ALTREF2. If only one reference frame is used, it must be
5632 // LAST.
5633 cpi->ext_ref_frame_flags = AOM_REFFRAME_ALL;
5634 if (flags &
5635 (AOM_EFLAG_NO_REF_LAST | AOM_EFLAG_NO_REF_LAST2 | AOM_EFLAG_NO_REF_LAST3 |
5636 AOM_EFLAG_NO_REF_GF | AOM_EFLAG_NO_REF_ARF | AOM_EFLAG_NO_REF_BWD |
5637 AOM_EFLAG_NO_REF_ARF2)) {
5638 if (flags & AOM_EFLAG_NO_REF_LAST) {
5639 cpi->ext_ref_frame_flags = 0;
5640 } else {
5641 int ref = AOM_REFFRAME_ALL;
5642
5643 if (flags & AOM_EFLAG_NO_REF_LAST2) ref ^= AOM_LAST2_FLAG;
5644 if (flags & AOM_EFLAG_NO_REF_LAST3) ref ^= AOM_LAST3_FLAG;
5645
5646 if (flags & AOM_EFLAG_NO_REF_GF) ref ^= AOM_GOLD_FLAG;
5647
5648 if (flags & AOM_EFLAG_NO_REF_ARF) {
5649 ref ^= AOM_ALT_FLAG;
5650 ref ^= AOM_BWD_FLAG;
5651 ref ^= AOM_ALT2_FLAG;
5652 } else {
5653 if (flags & AOM_EFLAG_NO_REF_BWD) ref ^= AOM_BWD_FLAG;
5654 if (flags & AOM_EFLAG_NO_REF_ARF2) ref ^= AOM_ALT2_FLAG;
5655 }
5656
5657 av1_use_as_reference(cpi, ref);
5658 }
5659 }
5660
5661 if (flags &
5662 (AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF)) {
5663 int upd = AOM_REFFRAME_ALL;
5664
5665 // Refreshing LAST/LAST2/LAST3 is handled by 1 common flag.
5666 if (flags & AOM_EFLAG_NO_UPD_LAST) upd ^= AOM_LAST_FLAG;
5667
5668 if (flags & AOM_EFLAG_NO_UPD_GF) upd ^= AOM_GOLD_FLAG;
5669
5670 if (flags & AOM_EFLAG_NO_UPD_ARF) {
5671 upd ^= AOM_ALT_FLAG;
5672 upd ^= AOM_BWD_FLAG;
5673 upd ^= AOM_ALT2_FLAG;
5674 }
5675
5676 cpi->ext_refresh_last_frame = (upd & AOM_LAST_FLAG) != 0;
5677 cpi->ext_refresh_golden_frame = (upd & AOM_GOLD_FLAG) != 0;
5678 cpi->ext_refresh_alt_ref_frame = (upd & AOM_ALT_FLAG) != 0;
5679 cpi->ext_refresh_bwd_ref_frame = (upd & AOM_BWD_FLAG) != 0;
5680 cpi->ext_refresh_alt2_ref_frame = (upd & AOM_ALT2_FLAG) != 0;
5681 cpi->ext_refresh_frame_flags_pending = 1;
5682 } else {
5683 cpi->ext_refresh_frame_flags_pending = 0;
5684 }
5685
5686 cpi->ext_use_ref_frame_mvs = cpi->oxcf.allow_ref_frame_mvs &
5687 ((flags & AOM_EFLAG_NO_REF_FRAME_MVS) == 0);
5688 cpi->ext_use_error_resilient = cpi->oxcf.error_resilient_mode |
5689 ((flags & AOM_EFLAG_ERROR_RESILIENT) != 0);
5690 cpi->ext_use_s_frame =
5691 cpi->oxcf.s_frame_mode | ((flags & AOM_EFLAG_SET_S_FRAME) != 0);
5692 cpi->ext_use_primary_ref_none = (flags & AOM_EFLAG_SET_PRIMARY_REF_NONE) != 0;
5693
5694 if (flags & AOM_EFLAG_NO_UPD_ENTROPY) {
5695 av1_update_entropy(cpi, 0);
5696 }
5697 }
5698
av1_get_global_headers(AV1_COMP * cpi)5699 aom_fixed_buf_t *av1_get_global_headers(AV1_COMP *cpi) {
5700 if (!cpi) return NULL;
5701
5702 uint8_t header_buf[512] = { 0 };
5703 const uint32_t sequence_header_size =
5704 write_sequence_header_obu(cpi, &header_buf[0]);
5705 assert(sequence_header_size <= sizeof(header_buf));
5706 if (sequence_header_size == 0) return NULL;
5707
5708 const size_t obu_header_size = 1;
5709 const size_t size_field_size = aom_uleb_size_in_bytes(sequence_header_size);
5710 const size_t payload_offset = obu_header_size + size_field_size;
5711
5712 if (payload_offset + sequence_header_size > sizeof(header_buf)) return NULL;
5713 memmove(&header_buf[payload_offset], &header_buf[0], sequence_header_size);
5714
5715 if (av1_write_obu_header(cpi, OBU_SEQUENCE_HEADER, 0, &header_buf[0]) !=
5716 obu_header_size) {
5717 return NULL;
5718 }
5719
5720 size_t coded_size_field_size = 0;
5721 if (aom_uleb_encode(sequence_header_size, size_field_size,
5722 &header_buf[obu_header_size],
5723 &coded_size_field_size) != 0) {
5724 return NULL;
5725 }
5726 assert(coded_size_field_size == size_field_size);
5727
5728 aom_fixed_buf_t *global_headers =
5729 (aom_fixed_buf_t *)malloc(sizeof(*global_headers));
5730 if (!global_headers) return NULL;
5731
5732 const size_t global_header_buf_size =
5733 obu_header_size + size_field_size + sequence_header_size;
5734
5735 global_headers->buf = malloc(global_header_buf_size);
5736 if (!global_headers->buf) {
5737 free(global_headers);
5738 return NULL;
5739 }
5740
5741 memcpy(global_headers->buf, &header_buf[0], global_header_buf_size);
5742 global_headers->sz = global_header_buf_size;
5743 return global_headers;
5744 }
5745