2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
16 #include "./vp9_rtcd.h"
17 #include "./vpx_config.h"
18 #include "./vpx_dsp_rtcd.h"
19 #include "./vpx_scale_rtcd.h"
20 #include "vpx_dsp/psnr.h"
21 #include "vpx_dsp/vpx_dsp_common.h"
22 #include "vpx_dsp/vpx_filter.h"
23 #if CONFIG_INTERNAL_STATS
24 #include "vpx_dsp/ssim.h"
26 #include "vpx_ports/mem.h"
27 #include "vpx_ports/system_state.h"
28 #include "vpx_ports/vpx_timer.h"
29 #if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
30 #include "vpx_util/vpx_debug_util.h"
31 #endif // CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
33 #include "vp9/common/vp9_alloccommon.h"
34 #include "vp9/common/vp9_filter.h"
35 #include "vp9/common/vp9_idct.h"
36 #if CONFIG_NON_GREEDY_MV
37 #include "vp9/common/vp9_mvref_common.h"
39 #if CONFIG_VP9_POSTPROC
40 #include "vp9/common/vp9_postproc.h"
42 #include "vp9/common/vp9_reconinter.h"
43 #include "vp9/common/vp9_reconintra.h"
44 #include "vp9/common/vp9_tile_common.h"
45 #include "vp9/common/vp9_scan.h"
47 #if !CONFIG_REALTIME_ONLY
48 #include "vp9/encoder/vp9_alt_ref_aq.h"
49 #include "vp9/encoder/vp9_aq_360.h"
50 #include "vp9/encoder/vp9_aq_complexity.h"
52 #include "vp9/encoder/vp9_aq_cyclicrefresh.h"
53 #if !CONFIG_REALTIME_ONLY
54 #include "vp9/encoder/vp9_aq_variance.h"
56 #include "vp9/encoder/vp9_bitstream.h"
57 #if CONFIG_INTERNAL_STATS
58 #include "vp9/encoder/vp9_blockiness.h"
60 #include "vp9/encoder/vp9_context_tree.h"
61 #include "vp9/encoder/vp9_encodeframe.h"
62 #include "vp9/encoder/vp9_encodemb.h"
63 #include "vp9/encoder/vp9_encodemv.h"
64 #include "vp9/encoder/vp9_encoder.h"
65 #include "vp9/encoder/vp9_ethread.h"
66 #include "vp9/encoder/vp9_extend.h"
67 #include "vp9/encoder/vp9_firstpass.h"
68 #include "vp9/encoder/vp9_mbgraph.h"
69 #if CONFIG_NON_GREEDY_MV
70 #include "vp9/encoder/vp9_mcomp.h"
72 #include "vp9/encoder/vp9_multi_thread.h"
73 #include "vp9/encoder/vp9_noise_estimate.h"
74 #include "vp9/encoder/vp9_picklpf.h"
75 #include "vp9/encoder/vp9_ratectrl.h"
76 #include "vp9/encoder/vp9_rd.h"
77 #include "vp9/encoder/vp9_resize.h"
78 #include "vp9/encoder/vp9_segmentation.h"
79 #include "vp9/encoder/vp9_skin_detection.h"
80 #include "vp9/encoder/vp9_speed_features.h"
81 #include "vp9/encoder/vp9_svc_layercontext.h"
82 #include "vp9/encoder/vp9_temporal_filter.h"
84 #define AM_SEGMENT_ID_INACTIVE 7
85 #define AM_SEGMENT_ID_ACTIVE 0
87 // Whether to use high precision mv for altref computation.
88 #define ALTREF_HIGH_PRECISION_MV 1
90 // Q threshold for high precision mv. Choose a very high value for now so that
91 // HIGH_PRECISION is always chosen.
92 #define HIGH_PRECISION_MV_QTHRESH 200
94 #define FRAME_SIZE_FACTOR 128 // empirical params for context model threshold
95 #define FRAME_RATE_FACTOR 8
97 #ifdef OUTPUT_YUV_DENOISED
98 FILE *yuv_denoised_file = NULL;
100 #ifdef OUTPUT_YUV_SKINMAP
101 static FILE *yuv_skinmap_file = NULL;
103 #ifdef OUTPUT_YUV_REC
106 #ifdef OUTPUT_YUV_SVC_SRC
107 FILE *yuv_svc_src[3] = { NULL, NULL, NULL };
116 #ifdef ENABLE_KF_DENOISE
117 // Test condition for spatial denoise of source.
118 static int is_spatial_denoise_enabled(VP9_COMP *cpi) {
119 VP9_COMMON *const cm = &cpi->common;
120 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
122 return (oxcf->pass != 1) && !is_lossless_requested(&cpi->oxcf) &&
123 frame_is_intra_only(cm);
127 #if CONFIG_VP9_HIGHBITDEPTH
128 void highbd_wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
131 void wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
134 #if !CONFIG_REALTIME_ONLY
135 // compute adaptive threshold for skip recoding
136 static int compute_context_model_thresh(const VP9_COMP *const cpi) {
137 const VP9_COMMON *const cm = &cpi->common;
138 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
139 const int frame_size = (cm->width * cm->height) >> 10;
140 const int bitrate = (int)(oxcf->target_bandwidth >> 10);
141 const int qindex_factor = cm->base_qindex + (MAXQ >> 1);
143 // This equation makes the threshold adaptive to frame size.
144 // Coding gain obtained by recoding comes from alternate frames of large
145 // content change. We skip recoding if the difference of previous and current
146 // frame context probability model is less than a certain threshold.
147 // The first component is the most critical part to guarantee adaptivity.
148 // Other parameters are estimated based on normal setting of hd resolution
149 // parameters. e.g frame_size = 1920x1080, bitrate = 8000, qindex_factor < 50
151 ((FRAME_SIZE_FACTOR * frame_size - FRAME_RATE_FACTOR * bitrate) *
158 // compute the total cost difference between current
159 // and previous frame context prob model.
160 static int compute_context_model_diff(const VP9_COMMON *const cm) {
161 const FRAME_CONTEXT *const pre_fc =
162 &cm->frame_contexts[cm->frame_context_idx];
163 const FRAME_CONTEXT *const cur_fc = cm->fc;
164 const FRAME_COUNTS *counts = &cm->counts;
165 vpx_prob pre_last_prob, cur_last_prob;
167 int i, j, k, l, m, n;
170 for (i = 0; i < BLOCK_SIZE_GROUPS; ++i) {
171 for (j = 0; j < INTRA_MODES - 1; ++j) {
172 diff += (int)counts->y_mode[i][j] *
173 (pre_fc->y_mode_prob[i][j] - cur_fc->y_mode_prob[i][j]);
175 pre_last_prob = MAX_PROB - pre_fc->y_mode_prob[i][INTRA_MODES - 2];
176 cur_last_prob = MAX_PROB - cur_fc->y_mode_prob[i][INTRA_MODES - 2];
178 diff += (int)counts->y_mode[i][INTRA_MODES - 1] *
179 (pre_last_prob - cur_last_prob);
183 for (i = 0; i < INTRA_MODES; ++i) {
184 for (j = 0; j < INTRA_MODES - 1; ++j) {
185 diff += (int)counts->uv_mode[i][j] *
186 (pre_fc->uv_mode_prob[i][j] - cur_fc->uv_mode_prob[i][j]);
188 pre_last_prob = MAX_PROB - pre_fc->uv_mode_prob[i][INTRA_MODES - 2];
189 cur_last_prob = MAX_PROB - cur_fc->uv_mode_prob[i][INTRA_MODES - 2];
191 diff += (int)counts->uv_mode[i][INTRA_MODES - 1] *
192 (pre_last_prob - cur_last_prob);
196 for (i = 0; i < PARTITION_CONTEXTS; ++i) {
197 for (j = 0; j < PARTITION_TYPES - 1; ++j) {
198 diff += (int)counts->partition[i][j] *
199 (pre_fc->partition_prob[i][j] - cur_fc->partition_prob[i][j]);
201 pre_last_prob = MAX_PROB - pre_fc->partition_prob[i][PARTITION_TYPES - 2];
202 cur_last_prob = MAX_PROB - cur_fc->partition_prob[i][PARTITION_TYPES - 2];
204 diff += (int)counts->partition[i][PARTITION_TYPES - 1] *
205 (pre_last_prob - cur_last_prob);
209 for (i = 0; i < TX_SIZES; ++i) {
210 for (j = 0; j < PLANE_TYPES; ++j) {
211 for (k = 0; k < REF_TYPES; ++k) {
212 for (l = 0; l < COEF_BANDS; ++l) {
213 for (m = 0; m < BAND_COEFF_CONTEXTS(l); ++m) {
214 for (n = 0; n < UNCONSTRAINED_NODES; ++n) {
215 diff += (int)counts->coef[i][j][k][l][m][n] *
216 (pre_fc->coef_probs[i][j][k][l][m][n] -
217 cur_fc->coef_probs[i][j][k][l][m][n]);
222 pre_fc->coef_probs[i][j][k][l][m][UNCONSTRAINED_NODES - 1];
225 cur_fc->coef_probs[i][j][k][l][m][UNCONSTRAINED_NODES - 1];
227 diff += (int)counts->coef[i][j][k][l][m][UNCONSTRAINED_NODES] *
228 (pre_last_prob - cur_last_prob);
235 // switchable_interp_prob
236 for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i) {
237 for (j = 0; j < SWITCHABLE_FILTERS - 1; ++j) {
238 diff += (int)counts->switchable_interp[i][j] *
239 (pre_fc->switchable_interp_prob[i][j] -
240 cur_fc->switchable_interp_prob[i][j]);
243 MAX_PROB - pre_fc->switchable_interp_prob[i][SWITCHABLE_FILTERS - 2];
245 MAX_PROB - cur_fc->switchable_interp_prob[i][SWITCHABLE_FILTERS - 2];
247 diff += (int)counts->switchable_interp[i][SWITCHABLE_FILTERS - 1] *
248 (pre_last_prob - cur_last_prob);
252 for (i = 0; i < INTER_MODE_CONTEXTS; ++i) {
253 for (j = 0; j < INTER_MODES - 1; ++j) {
254 diff += (int)counts->inter_mode[i][j] *
255 (pre_fc->inter_mode_probs[i][j] - cur_fc->inter_mode_probs[i][j]);
257 pre_last_prob = MAX_PROB - pre_fc->inter_mode_probs[i][INTER_MODES - 2];
258 cur_last_prob = MAX_PROB - cur_fc->inter_mode_probs[i][INTER_MODES - 2];
260 diff += (int)counts->inter_mode[i][INTER_MODES - 1] *
261 (pre_last_prob - cur_last_prob);
265 for (i = 0; i < INTRA_INTER_CONTEXTS; ++i) {
266 diff += (int)counts->intra_inter[i][0] *
267 (pre_fc->intra_inter_prob[i] - cur_fc->intra_inter_prob[i]);
269 pre_last_prob = MAX_PROB - pre_fc->intra_inter_prob[i];
270 cur_last_prob = MAX_PROB - cur_fc->intra_inter_prob[i];
272 diff += (int)counts->intra_inter[i][1] * (pre_last_prob - cur_last_prob);
276 for (i = 0; i < COMP_INTER_CONTEXTS; ++i) {
277 diff += (int)counts->comp_inter[i][0] *
278 (pre_fc->comp_inter_prob[i] - cur_fc->comp_inter_prob[i]);
280 pre_last_prob = MAX_PROB - pre_fc->comp_inter_prob[i];
281 cur_last_prob = MAX_PROB - cur_fc->comp_inter_prob[i];
283 diff += (int)counts->comp_inter[i][1] * (pre_last_prob - cur_last_prob);
287 for (i = 0; i < REF_CONTEXTS; ++i) {
288 for (j = 0; j < 2; ++j) {
289 diff += (int)counts->single_ref[i][j][0] *
290 (pre_fc->single_ref_prob[i][j] - cur_fc->single_ref_prob[i][j]);
292 pre_last_prob = MAX_PROB - pre_fc->single_ref_prob[i][j];
293 cur_last_prob = MAX_PROB - cur_fc->single_ref_prob[i][j];
296 (int)counts->single_ref[i][j][1] * (pre_last_prob - cur_last_prob);
301 for (i = 0; i < REF_CONTEXTS; ++i) {
302 diff += (int)counts->comp_ref[i][0] *
303 (pre_fc->comp_ref_prob[i] - cur_fc->comp_ref_prob[i]);
305 pre_last_prob = MAX_PROB - pre_fc->comp_ref_prob[i];
306 cur_last_prob = MAX_PROB - cur_fc->comp_ref_prob[i];
308 diff += (int)counts->comp_ref[i][1] * (pre_last_prob - cur_last_prob);
312 for (i = 0; i < TX_SIZE_CONTEXTS; ++i) {
314 for (j = 0; j < TX_SIZES - 1; ++j) {
315 diff += (int)counts->tx.p32x32[i][j] *
316 (pre_fc->tx_probs.p32x32[i][j] - cur_fc->tx_probs.p32x32[i][j]);
318 pre_last_prob = MAX_PROB - pre_fc->tx_probs.p32x32[i][TX_SIZES - 2];
319 cur_last_prob = MAX_PROB - cur_fc->tx_probs.p32x32[i][TX_SIZES - 2];
321 diff += (int)counts->tx.p32x32[i][TX_SIZES - 1] *
322 (pre_last_prob - cur_last_prob);
325 for (j = 0; j < TX_SIZES - 2; ++j) {
326 diff += (int)counts->tx.p16x16[i][j] *
327 (pre_fc->tx_probs.p16x16[i][j] - cur_fc->tx_probs.p16x16[i][j]);
329 pre_last_prob = MAX_PROB - pre_fc->tx_probs.p16x16[i][TX_SIZES - 3];
330 cur_last_prob = MAX_PROB - cur_fc->tx_probs.p16x16[i][TX_SIZES - 3];
332 diff += (int)counts->tx.p16x16[i][TX_SIZES - 2] *
333 (pre_last_prob - cur_last_prob);
336 for (j = 0; j < TX_SIZES - 3; ++j) {
337 diff += (int)counts->tx.p8x8[i][j] *
338 (pre_fc->tx_probs.p8x8[i][j] - cur_fc->tx_probs.p8x8[i][j]);
340 pre_last_prob = MAX_PROB - pre_fc->tx_probs.p8x8[i][TX_SIZES - 4];
341 cur_last_prob = MAX_PROB - cur_fc->tx_probs.p8x8[i][TX_SIZES - 4];
344 (int)counts->tx.p8x8[i][TX_SIZES - 3] * (pre_last_prob - cur_last_prob);
348 for (i = 0; i < SKIP_CONTEXTS; ++i) {
349 diff += (int)counts->skip[i][0] *
350 (pre_fc->skip_probs[i] - cur_fc->skip_probs[i]);
352 pre_last_prob = MAX_PROB - pre_fc->skip_probs[i];
353 cur_last_prob = MAX_PROB - cur_fc->skip_probs[i];
355 diff += (int)counts->skip[i][1] * (pre_last_prob - cur_last_prob);
359 for (i = 0; i < MV_JOINTS - 1; ++i) {
360 diff += (int)counts->mv.joints[i] *
361 (pre_fc->nmvc.joints[i] - cur_fc->nmvc.joints[i]);
363 pre_last_prob = MAX_PROB - pre_fc->nmvc.joints[MV_JOINTS - 2];
364 cur_last_prob = MAX_PROB - cur_fc->nmvc.joints[MV_JOINTS - 2];
367 (int)counts->mv.joints[MV_JOINTS - 1] * (pre_last_prob - cur_last_prob);
369 for (i = 0; i < 2; ++i) {
370 const nmv_component_counts *nmv_count = &counts->mv.comps[i];
371 const nmv_component *pre_nmv_prob = &pre_fc->nmvc.comps[i];
372 const nmv_component *cur_nmv_prob = &cur_fc->nmvc.comps[i];
375 diff += (int)nmv_count->sign[0] * (pre_nmv_prob->sign - cur_nmv_prob->sign);
377 pre_last_prob = MAX_PROB - pre_nmv_prob->sign;
378 cur_last_prob = MAX_PROB - cur_nmv_prob->sign;
380 diff += (int)nmv_count->sign[1] * (pre_last_prob - cur_last_prob);
383 for (j = 0; j < MV_CLASSES - 1; ++j) {
384 diff += (int)nmv_count->classes[j] *
385 (pre_nmv_prob->classes[j] - cur_nmv_prob->classes[j]);
387 pre_last_prob = MAX_PROB - pre_nmv_prob->classes[MV_CLASSES - 2];
388 cur_last_prob = MAX_PROB - cur_nmv_prob->classes[MV_CLASSES - 2];
390 diff += (int)nmv_count->classes[MV_CLASSES - 1] *
391 (pre_last_prob - cur_last_prob);
394 for (j = 0; j < CLASS0_SIZE - 1; ++j) {
395 diff += (int)nmv_count->class0[j] *
396 (pre_nmv_prob->class0[j] - cur_nmv_prob->class0[j]);
398 pre_last_prob = MAX_PROB - pre_nmv_prob->class0[CLASS0_SIZE - 2];
399 cur_last_prob = MAX_PROB - cur_nmv_prob->class0[CLASS0_SIZE - 2];
401 diff += (int)nmv_count->class0[CLASS0_SIZE - 1] *
402 (pre_last_prob - cur_last_prob);
405 for (j = 0; j < MV_OFFSET_BITS; ++j) {
406 diff += (int)nmv_count->bits[j][0] *
407 (pre_nmv_prob->bits[j] - cur_nmv_prob->bits[j]);
409 pre_last_prob = MAX_PROB - pre_nmv_prob->bits[j];
410 cur_last_prob = MAX_PROB - cur_nmv_prob->bits[j];
412 diff += (int)nmv_count->bits[j][1] * (pre_last_prob - cur_last_prob);
416 for (j = 0; j < CLASS0_SIZE; ++j) {
417 for (k = 0; k < MV_FP_SIZE - 1; ++k) {
418 diff += (int)nmv_count->class0_fp[j][k] *
419 (pre_nmv_prob->class0_fp[j][k] - cur_nmv_prob->class0_fp[j][k]);
421 pre_last_prob = MAX_PROB - pre_nmv_prob->class0_fp[j][MV_FP_SIZE - 2];
422 cur_last_prob = MAX_PROB - cur_nmv_prob->class0_fp[j][MV_FP_SIZE - 2];
424 diff += (int)nmv_count->class0_fp[j][MV_FP_SIZE - 1] *
425 (pre_last_prob - cur_last_prob);
429 for (j = 0; j < MV_FP_SIZE - 1; ++j) {
431 (int)nmv_count->fp[j] * (pre_nmv_prob->fp[j] - cur_nmv_prob->fp[j]);
433 pre_last_prob = MAX_PROB - pre_nmv_prob->fp[MV_FP_SIZE - 2];
434 cur_last_prob = MAX_PROB - cur_nmv_prob->fp[MV_FP_SIZE - 2];
437 (int)nmv_count->fp[MV_FP_SIZE - 1] * (pre_last_prob - cur_last_prob);
440 diff += (int)nmv_count->class0_hp[0] *
441 (pre_nmv_prob->class0_hp - cur_nmv_prob->class0_hp);
443 pre_last_prob = MAX_PROB - pre_nmv_prob->class0_hp;
444 cur_last_prob = MAX_PROB - cur_nmv_prob->class0_hp;
446 diff += (int)nmv_count->class0_hp[1] * (pre_last_prob - cur_last_prob);
449 diff += (int)nmv_count->hp[0] * (pre_nmv_prob->hp - cur_nmv_prob->hp);
451 pre_last_prob = MAX_PROB - pre_nmv_prob->hp;
452 cur_last_prob = MAX_PROB - cur_nmv_prob->hp;
454 diff += (int)nmv_count->hp[1] * (pre_last_prob - cur_last_prob);
459 #endif // !CONFIG_REALTIME_ONLY
461 // Test for whether to calculate metrics for the frame.
462 static int is_psnr_calc_enabled(VP9_COMP *cpi) {
463 VP9_COMMON *const cm = &cpi->common;
464 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
466 return cpi->b_calculate_psnr && (oxcf->pass != 1) && cm->show_frame;
469 /* clang-format off */
470 const Vp9LevelSpec vp9_level_defs[VP9_LEVELS] = {
471 // sample rate size breadth bitrate cpb
472 { LEVEL_1, 829440, 36864, 512, 200, 400, 2, 1, 4, 8 },
473 { LEVEL_1_1, 2764800, 73728, 768, 800, 1000, 2, 1, 4, 8 },
474 { LEVEL_2, 4608000, 122880, 960, 1800, 1500, 2, 1, 4, 8 },
475 { LEVEL_2_1, 9216000, 245760, 1344, 3600, 2800, 2, 2, 4, 8 },
476 { LEVEL_3, 20736000, 552960, 2048, 7200, 6000, 2, 4, 4, 8 },
477 { LEVEL_3_1, 36864000, 983040, 2752, 12000, 10000, 2, 4, 4, 8 },
478 { LEVEL_4, 83558400, 2228224, 4160, 18000, 16000, 4, 4, 4, 8 },
479 { LEVEL_4_1, 160432128, 2228224, 4160, 30000, 18000, 4, 4, 5, 6 },
480 { LEVEL_5, 311951360, 8912896, 8384, 60000, 36000, 6, 8, 6, 4 },
481 { LEVEL_5_1, 588251136, 8912896, 8384, 120000, 46000, 8, 8, 10, 4 },
482 // TODO(huisu): update max_cpb_size for level 5_2 ~ 6_2 when
483 // they are finalized (currently tentative).
484 { LEVEL_5_2, 1176502272, 8912896, 8384, 180000, 90000, 8, 8, 10, 4 },
485 { LEVEL_6, 1176502272, 35651584, 16832, 180000, 90000, 8, 16, 10, 4 },
486 { LEVEL_6_1, 2353004544u, 35651584, 16832, 240000, 180000, 8, 16, 10, 4 },
487 { LEVEL_6_2, 4706009088u, 35651584, 16832, 480000, 360000, 8, 16, 10, 4 },
489 /* clang-format on */
491 static const char *level_fail_messages[TARGET_LEVEL_FAIL_IDS] = {
492 "The average bit-rate is too high.",
493 "The picture size is too large.",
494 "The picture width/height is too large.",
495 "The luma sample rate is too large.",
496 "The CPB size is too large.",
497 "The compression ratio is too small",
498 "Too many column tiles are used.",
499 "The alt-ref distance is too small.",
500 "Too many reference buffers are used."
503 static INLINE void Scale2Ratio(VPX_SCALING mode, int *hr, int *hs) {
518 assert(mode == ONETWO);
525 // Mark all inactive blocks as active. Other segmentation features may be set
526 // so memset cannot be used, instead only inactive blocks should be reset.
527 static void suppress_active_map(VP9_COMP *cpi) {
528 unsigned char *const seg_map = cpi->segmentation_map;
530 if (cpi->active_map.enabled || cpi->active_map.update) {
531 const int rows = cpi->common.mi_rows;
532 const int cols = cpi->common.mi_cols;
535 for (i = 0; i < rows * cols; ++i)
536 if (seg_map[i] == AM_SEGMENT_ID_INACTIVE)
537 seg_map[i] = AM_SEGMENT_ID_ACTIVE;
541 static void apply_active_map(VP9_COMP *cpi) {
542 struct segmentation *const seg = &cpi->common.seg;
543 unsigned char *const seg_map = cpi->segmentation_map;
544 const unsigned char *const active_map = cpi->active_map.map;
547 assert(AM_SEGMENT_ID_ACTIVE == CR_SEGMENT_ID_BASE);
549 if (frame_is_intra_only(&cpi->common)) {
550 cpi->active_map.enabled = 0;
551 cpi->active_map.update = 1;
554 if (cpi->active_map.update) {
555 if (cpi->active_map.enabled) {
556 for (i = 0; i < cpi->common.mi_rows * cpi->common.mi_cols; ++i)
557 if (seg_map[i] == AM_SEGMENT_ID_ACTIVE) seg_map[i] = active_map[i];
558 vp9_enable_segmentation(seg);
559 vp9_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_SKIP);
560 vp9_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF);
561 // Setting the data to -MAX_LOOP_FILTER will result in the computed loop
562 // filter level being zero regardless of the value of seg->abs_delta.
563 vp9_set_segdata(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF,
566 vp9_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_SKIP);
567 vp9_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF);
569 seg->update_data = 1;
573 cpi->active_map.update = 0;
577 static void apply_roi_map(VP9_COMP *cpi) {
578 VP9_COMMON *cm = &cpi->common;
579 struct segmentation *const seg = &cm->seg;
580 vpx_roi_map_t *roi = &cpi->roi;
581 const int *delta_q = roi->delta_q;
582 const int *delta_lf = roi->delta_lf;
583 const int *skip = roi->skip;
585 int internal_delta_q[MAX_SEGMENTS];
587 static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG,
590 // TODO(jianj): Investigate why ROI not working in speed < 5 or in non
592 if (cpi->oxcf.mode != REALTIME || cpi->oxcf.speed < 5) return;
593 if (!roi->enabled) return;
595 memcpy(&ref_frame, roi->ref_frame, sizeof(ref_frame));
597 vp9_enable_segmentation(seg);
598 vp9_clearall_segfeatures(seg);
599 // Select delta coding method;
600 seg->abs_delta = SEGMENT_DELTADATA;
602 memcpy(cpi->segmentation_map, roi->roi_map, (cm->mi_rows * cm->mi_cols));
604 for (i = 0; i < MAX_SEGMENTS; ++i) {
605 // Translate the external delta q values to internal values.
606 internal_delta_q[i] = vp9_quantizer_to_qindex(abs(delta_q[i]));
607 if (delta_q[i] < 0) internal_delta_q[i] = -internal_delta_q[i];
608 vp9_disable_segfeature(seg, i, SEG_LVL_ALT_Q);
609 vp9_disable_segfeature(seg, i, SEG_LVL_ALT_LF);
610 if (internal_delta_q[i] != 0) {
611 vp9_enable_segfeature(seg, i, SEG_LVL_ALT_Q);
612 vp9_set_segdata(seg, i, SEG_LVL_ALT_Q, internal_delta_q[i]);
614 if (delta_lf[i] != 0) {
615 vp9_enable_segfeature(seg, i, SEG_LVL_ALT_LF);
616 vp9_set_segdata(seg, i, SEG_LVL_ALT_LF, delta_lf[i]);
619 vp9_enable_segfeature(seg, i, SEG_LVL_SKIP);
620 vp9_set_segdata(seg, i, SEG_LVL_SKIP, skip[i]);
622 if (ref_frame[i] >= 0) {
624 // ALTREF is not used as reference for nonrd_pickmode with 0 lag.
625 if (ref_frame[i] == ALTREF_FRAME && cpi->sf.use_nonrd_pick_mode)
627 // If GOLDEN is selected, make sure it's set as reference.
628 if (ref_frame[i] == GOLDEN_FRAME &&
629 !(cpi->ref_frame_flags & flag_list[ref_frame[i]])) {
632 // GOLDEN was updated in previous encoded frame, so GOLDEN and LAST are
634 if (ref_frame[i] == GOLDEN_FRAME && cpi->rc.frames_since_golden == 0)
635 ref_frame[i] = LAST_FRAME;
637 vp9_enable_segfeature(seg, i, SEG_LVL_REF_FRAME);
638 vp9_set_segdata(seg, i, SEG_LVL_REF_FRAME, ref_frame[i]);
645 static void init_level_info(Vp9LevelInfo *level_info) {
646 Vp9LevelStats *const level_stats = &level_info->level_stats;
647 Vp9LevelSpec *const level_spec = &level_info->level_spec;
649 memset(level_stats, 0, sizeof(*level_stats));
650 memset(level_spec, 0, sizeof(*level_spec));
651 level_spec->level = LEVEL_UNKNOWN;
652 level_spec->min_altref_distance = INT_MAX;
655 static int check_seg_range(int seg_data[8], int range) {
656 return !(abs(seg_data[0]) > range || abs(seg_data[1]) > range ||
657 abs(seg_data[2]) > range || abs(seg_data[3]) > range ||
658 abs(seg_data[4]) > range || abs(seg_data[5]) > range ||
659 abs(seg_data[6]) > range || abs(seg_data[7]) > range);
662 VP9_LEVEL vp9_get_level(const Vp9LevelSpec *const level_spec) {
664 const Vp9LevelSpec *this_level;
666 vpx_clear_system_state();
668 for (i = 0; i < VP9_LEVELS; ++i) {
669 this_level = &vp9_level_defs[i];
670 if ((double)level_spec->max_luma_sample_rate >
671 (double)this_level->max_luma_sample_rate *
672 (1 + SAMPLE_RATE_GRACE_P) ||
673 level_spec->max_luma_picture_size > this_level->max_luma_picture_size ||
674 level_spec->max_luma_picture_breadth >
675 this_level->max_luma_picture_breadth ||
676 level_spec->average_bitrate > this_level->average_bitrate ||
677 level_spec->max_cpb_size > this_level->max_cpb_size ||
678 level_spec->compression_ratio < this_level->compression_ratio ||
679 level_spec->max_col_tiles > this_level->max_col_tiles ||
680 level_spec->min_altref_distance < this_level->min_altref_distance ||
681 level_spec->max_ref_frame_buffers > this_level->max_ref_frame_buffers)
685 return (i == VP9_LEVELS) ? LEVEL_UNKNOWN : vp9_level_defs[i].level;
688 int vp9_set_roi_map(VP9_COMP *cpi, unsigned char *map, unsigned int rows,
689 unsigned int cols, int delta_q[8], int delta_lf[8],
690 int skip[8], int ref_frame[8]) {
691 VP9_COMMON *cm = &cpi->common;
692 vpx_roi_map_t *roi = &cpi->roi;
693 const int range = 63;
694 const int ref_frame_range = 3; // Alt-ref
695 const int skip_range = 1;
696 const int frame_rows = cpi->common.mi_rows;
697 const int frame_cols = cpi->common.mi_cols;
699 // Check number of rows and columns match
700 if (frame_rows != (int)rows || frame_cols != (int)cols) {
704 if (!check_seg_range(delta_q, range) || !check_seg_range(delta_lf, range) ||
705 !check_seg_range(ref_frame, ref_frame_range) ||
706 !check_seg_range(skip, skip_range))
709 // Also disable segmentation if no deltas are specified.
711 (!(delta_q[0] | delta_q[1] | delta_q[2] | delta_q[3] | delta_q[4] |
712 delta_q[5] | delta_q[6] | delta_q[7] | delta_lf[0] | delta_lf[1] |
713 delta_lf[2] | delta_lf[3] | delta_lf[4] | delta_lf[5] | delta_lf[6] |
714 delta_lf[7] | skip[0] | skip[1] | skip[2] | skip[3] | skip[4] |
715 skip[5] | skip[6] | skip[7]) &&
716 (ref_frame[0] == -1 && ref_frame[1] == -1 && ref_frame[2] == -1 &&
717 ref_frame[3] == -1 && ref_frame[4] == -1 && ref_frame[5] == -1 &&
718 ref_frame[6] == -1 && ref_frame[7] == -1))) {
719 vp9_disable_segmentation(&cm->seg);
720 cpi->roi.enabled = 0;
725 vpx_free(roi->roi_map);
728 CHECK_MEM_ERROR(cm, roi->roi_map, vpx_malloc(rows * cols));
730 // Copy to ROI sturcture in the compressor.
731 memcpy(roi->roi_map, map, rows * cols);
732 memcpy(&roi->delta_q, delta_q, MAX_SEGMENTS * sizeof(delta_q[0]));
733 memcpy(&roi->delta_lf, delta_lf, MAX_SEGMENTS * sizeof(delta_lf[0]));
734 memcpy(&roi->skip, skip, MAX_SEGMENTS * sizeof(skip[0]));
735 memcpy(&roi->ref_frame, ref_frame, MAX_SEGMENTS * sizeof(ref_frame[0]));
743 int vp9_set_active_map(VP9_COMP *cpi, unsigned char *new_map_16x16, int rows,
745 if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols) {
746 unsigned char *const active_map_8x8 = cpi->active_map.map;
747 const int mi_rows = cpi->common.mi_rows;
748 const int mi_cols = cpi->common.mi_cols;
749 cpi->active_map.update = 1;
752 for (r = 0; r < mi_rows; ++r) {
753 for (c = 0; c < mi_cols; ++c) {
754 active_map_8x8[r * mi_cols + c] =
755 new_map_16x16[(r >> 1) * cols + (c >> 1)]
756 ? AM_SEGMENT_ID_ACTIVE
757 : AM_SEGMENT_ID_INACTIVE;
760 cpi->active_map.enabled = 1;
762 cpi->active_map.enabled = 0;
770 int vp9_get_active_map(VP9_COMP *cpi, unsigned char *new_map_16x16, int rows,
772 if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols &&
774 unsigned char *const seg_map_8x8 = cpi->segmentation_map;
775 const int mi_rows = cpi->common.mi_rows;
776 const int mi_cols = cpi->common.mi_cols;
777 memset(new_map_16x16, !cpi->active_map.enabled, rows * cols);
778 if (cpi->active_map.enabled) {
780 for (r = 0; r < mi_rows; ++r) {
781 for (c = 0; c < mi_cols; ++c) {
782 // Cyclic refresh segments are considered active despite not having
783 // AM_SEGMENT_ID_ACTIVE
784 new_map_16x16[(r >> 1) * cols + (c >> 1)] |=
785 seg_map_8x8[r * mi_cols + c] != AM_SEGMENT_ID_INACTIVE;
795 void vp9_set_high_precision_mv(VP9_COMP *cpi, int allow_high_precision_mv) {
796 MACROBLOCK *const mb = &cpi->td.mb;
797 cpi->common.allow_high_precision_mv = allow_high_precision_mv;
798 if (cpi->common.allow_high_precision_mv) {
799 mb->mvcost = mb->nmvcost_hp;
800 mb->mvsadcost = mb->nmvsadcost_hp;
802 mb->mvcost = mb->nmvcost;
803 mb->mvsadcost = mb->nmvsadcost;
807 static void setup_frame(VP9_COMP *cpi) {
808 VP9_COMMON *const cm = &cpi->common;
809 // Set up entropy context depending on frame type. The decoder mandates
810 // the use of the default context, index 0, for keyframes and inter
811 // frames where the error_resilient_mode or intra_only flag is set. For
812 // other inter-frames the encoder currently uses only two contexts;
813 // context 1 for ALTREF frames and context 0 for the others.
814 if (frame_is_intra_only(cm) || cm->error_resilient_mode) {
815 vp9_setup_past_independence(cm);
817 if (!cpi->use_svc) cm->frame_context_idx = cpi->refresh_alt_ref_frame;
820 // TODO(jingning): Overwrite the frame_context_idx index in multi-layer ARF
821 // case. Need some further investigation on if we could apply this to single
822 // layer ARF case as well.
823 if (cpi->multi_layer_arf && !cpi->use_svc) {
824 GF_GROUP *const gf_group = &cpi->twopass.gf_group;
825 const int gf_group_index = gf_group->index;
826 const int boost_frame =
827 !cpi->rc.is_src_frame_alt_ref &&
828 (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame);
830 // frame_context_idx Frame Type
831 // 0 Intra only frame, base layer ARF
832 // 1 ARFs with layer depth = 2,3
833 // 2 ARFs with layer depth > 3
834 // 3 Non-boosted frames
835 if (frame_is_intra_only(cm)) {
836 cm->frame_context_idx = 0;
837 } else if (boost_frame) {
838 if (gf_group->rf_level[gf_group_index] == GF_ARF_STD)
839 cm->frame_context_idx = 0;
840 else if (gf_group->layer_depth[gf_group_index] <= 3)
841 cm->frame_context_idx = 1;
843 cm->frame_context_idx = 2;
845 cm->frame_context_idx = 3;
849 if (cm->frame_type == KEY_FRAME) {
850 cpi->refresh_golden_frame = 1;
851 cpi->refresh_alt_ref_frame = 1;
852 vp9_zero(cpi->interp_filter_selected);
854 *cm->fc = cm->frame_contexts[cm->frame_context_idx];
855 vp9_zero(cpi->interp_filter_selected[0]);
859 static void vp9_enc_setup_mi(VP9_COMMON *cm) {
861 cm->mi = cm->mip + cm->mi_stride + 1;
862 memset(cm->mip, 0, cm->mi_stride * (cm->mi_rows + 1) * sizeof(*cm->mip));
863 cm->prev_mi = cm->prev_mip + cm->mi_stride + 1;
864 // Clear top border row
865 memset(cm->prev_mip, 0, sizeof(*cm->prev_mip) * cm->mi_stride);
866 // Clear left border column
867 for (i = 1; i < cm->mi_rows + 1; ++i)
868 memset(&cm->prev_mip[i * cm->mi_stride], 0, sizeof(*cm->prev_mip));
870 cm->mi_grid_visible = cm->mi_grid_base + cm->mi_stride + 1;
871 cm->prev_mi_grid_visible = cm->prev_mi_grid_base + cm->mi_stride + 1;
873 memset(cm->mi_grid_base, 0,
874 cm->mi_stride * (cm->mi_rows + 1) * sizeof(*cm->mi_grid_base));
877 static int vp9_enc_alloc_mi(VP9_COMMON *cm, int mi_size) {
878 cm->mip = vpx_calloc(mi_size, sizeof(*cm->mip));
879 if (!cm->mip) return 1;
880 cm->prev_mip = vpx_calloc(mi_size, sizeof(*cm->prev_mip));
881 if (!cm->prev_mip) return 1;
882 cm->mi_alloc_size = mi_size;
884 cm->mi_grid_base = (MODE_INFO **)vpx_calloc(mi_size, sizeof(MODE_INFO *));
885 if (!cm->mi_grid_base) return 1;
886 cm->prev_mi_grid_base =
887 (MODE_INFO **)vpx_calloc(mi_size, sizeof(MODE_INFO *));
888 if (!cm->prev_mi_grid_base) return 1;
893 static void vp9_enc_free_mi(VP9_COMMON *cm) {
896 vpx_free(cm->prev_mip);
898 vpx_free(cm->mi_grid_base);
899 cm->mi_grid_base = NULL;
900 vpx_free(cm->prev_mi_grid_base);
901 cm->prev_mi_grid_base = NULL;
902 cm->mi_alloc_size = 0;
905 static void vp9_swap_mi_and_prev_mi(VP9_COMMON *cm) {
906 // Current mip will be the prev_mip for the next frame.
907 MODE_INFO **temp_base = cm->prev_mi_grid_base;
908 MODE_INFO *temp = cm->prev_mip;
910 // Skip update prev_mi frame in show_existing_frame mode.
911 if (cm->show_existing_frame) return;
913 cm->prev_mip = cm->mip;
916 // Update the upper left visible macroblock ptrs.
917 cm->mi = cm->mip + cm->mi_stride + 1;
918 cm->prev_mi = cm->prev_mip + cm->mi_stride + 1;
920 cm->prev_mi_grid_base = cm->mi_grid_base;
921 cm->mi_grid_base = temp_base;
922 cm->mi_grid_visible = cm->mi_grid_base + cm->mi_stride + 1;
923 cm->prev_mi_grid_visible = cm->prev_mi_grid_base + cm->mi_stride + 1;
926 void vp9_initialize_enc(void) {
927 static volatile int init_done = 0;
933 vp9_init_intra_predictors();
935 vp9_rc_init_minq_luts();
936 vp9_entropy_mv_init();
937 #if !CONFIG_REALTIME_ONLY
938 vp9_temporal_filter_init();
944 static void dealloc_compressor_data(VP9_COMP *cpi) {
945 VP9_COMMON *const cm = &cpi->common;
948 vpx_free(cpi->mbmi_ext_base);
949 cpi->mbmi_ext_base = NULL;
951 vpx_free(cpi->tile_data);
952 cpi->tile_data = NULL;
954 vpx_free(cpi->segmentation_map);
955 cpi->segmentation_map = NULL;
956 vpx_free(cpi->coding_context.last_frame_seg_map_copy);
957 cpi->coding_context.last_frame_seg_map_copy = NULL;
959 vpx_free(cpi->nmvcosts[0]);
960 vpx_free(cpi->nmvcosts[1]);
961 cpi->nmvcosts[0] = NULL;
962 cpi->nmvcosts[1] = NULL;
964 vpx_free(cpi->nmvcosts_hp[0]);
965 vpx_free(cpi->nmvcosts_hp[1]);
966 cpi->nmvcosts_hp[0] = NULL;
967 cpi->nmvcosts_hp[1] = NULL;
969 vpx_free(cpi->nmvsadcosts[0]);
970 vpx_free(cpi->nmvsadcosts[1]);
971 cpi->nmvsadcosts[0] = NULL;
972 cpi->nmvsadcosts[1] = NULL;
974 vpx_free(cpi->nmvsadcosts_hp[0]);
975 vpx_free(cpi->nmvsadcosts_hp[1]);
976 cpi->nmvsadcosts_hp[0] = NULL;
977 cpi->nmvsadcosts_hp[1] = NULL;
979 vpx_free(cpi->skin_map);
980 cpi->skin_map = NULL;
982 vpx_free(cpi->prev_partition);
983 cpi->prev_partition = NULL;
985 vpx_free(cpi->svc.prev_partition_svc);
986 cpi->svc.prev_partition_svc = NULL;
988 vpx_free(cpi->prev_segment_id);
989 cpi->prev_segment_id = NULL;
991 vpx_free(cpi->prev_variance_low);
992 cpi->prev_variance_low = NULL;
994 vpx_free(cpi->copied_frame_cnt);
995 cpi->copied_frame_cnt = NULL;
997 vpx_free(cpi->content_state_sb_fd);
998 cpi->content_state_sb_fd = NULL;
1000 vpx_free(cpi->count_arf_frame_usage);
1001 cpi->count_arf_frame_usage = NULL;
1002 vpx_free(cpi->count_lastgolden_frame_usage);
1003 cpi->count_lastgolden_frame_usage = NULL;
1005 vp9_cyclic_refresh_free(cpi->cyclic_refresh);
1006 cpi->cyclic_refresh = NULL;
1008 vpx_free(cpi->active_map.map);
1009 cpi->active_map.map = NULL;
1011 vpx_free(cpi->roi.roi_map);
1012 cpi->roi.roi_map = NULL;
1014 vpx_free(cpi->consec_zero_mv);
1015 cpi->consec_zero_mv = NULL;
1017 vpx_free(cpi->mb_wiener_variance);
1018 cpi->mb_wiener_variance = NULL;
1020 vpx_free(cpi->mi_ssim_rdmult_scaling_factors);
1021 cpi->mi_ssim_rdmult_scaling_factors = NULL;
1023 vp9_free_ref_frame_buffers(cm->buffer_pool);
1024 #if CONFIG_VP9_POSTPROC
1025 vp9_free_postproc_buffers(cm);
1027 vp9_free_context_buffers(cm);
1029 vpx_free_frame_buffer(&cpi->last_frame_uf);
1030 vpx_free_frame_buffer(&cpi->scaled_source);
1031 vpx_free_frame_buffer(&cpi->scaled_last_source);
1032 vpx_free_frame_buffer(&cpi->alt_ref_buffer);
1033 #ifdef ENABLE_KF_DENOISE
1034 vpx_free_frame_buffer(&cpi->raw_unscaled_source);
1035 vpx_free_frame_buffer(&cpi->raw_scaled_source);
1038 vp9_lookahead_destroy(cpi->lookahead);
1040 vpx_free(cpi->tile_tok[0][0]);
1041 cpi->tile_tok[0][0] = 0;
1043 vpx_free(cpi->tplist[0][0]);
1044 cpi->tplist[0][0] = NULL;
1046 vp9_free_pc_tree(&cpi->td);
1048 for (i = 0; i < cpi->svc.number_spatial_layers; ++i) {
1049 LAYER_CONTEXT *const lc = &cpi->svc.layer_context[i];
1050 vpx_free(lc->rc_twopass_stats_in.buf);
1051 lc->rc_twopass_stats_in.buf = NULL;
1052 lc->rc_twopass_stats_in.sz = 0;
1055 if (cpi->source_diff_var != NULL) {
1056 vpx_free(cpi->source_diff_var);
1057 cpi->source_diff_var = NULL;
1060 for (i = 0; i < MAX_LAG_BUFFERS; ++i) {
1061 vpx_free_frame_buffer(&cpi->svc.scaled_frames[i]);
1063 memset(&cpi->svc.scaled_frames[0], 0,
1064 MAX_LAG_BUFFERS * sizeof(cpi->svc.scaled_frames[0]));
1066 vpx_free_frame_buffer(&cpi->svc.scaled_temp);
1067 memset(&cpi->svc.scaled_temp, 0, sizeof(cpi->svc.scaled_temp));
1069 vpx_free_frame_buffer(&cpi->svc.empty_frame.img);
1070 memset(&cpi->svc.empty_frame, 0, sizeof(cpi->svc.empty_frame));
1072 vp9_free_svc_cyclic_refresh(cpi);
1075 static void save_coding_context(VP9_COMP *cpi) {
1076 CODING_CONTEXT *const cc = &cpi->coding_context;
1077 VP9_COMMON *cm = &cpi->common;
1079 // Stores a snapshot of key state variables which can subsequently be
1080 // restored with a call to vp9_restore_coding_context. These functions are
1081 // intended for use in a re-code loop in vp9_compress_frame where the
1082 // quantizer value is adjusted between loop iterations.
1083 vp9_copy(cc->nmvjointcost, cpi->td.mb.nmvjointcost);
1085 memcpy(cc->nmvcosts[0], cpi->nmvcosts[0],
1086 MV_VALS * sizeof(*cpi->nmvcosts[0]));
1087 memcpy(cc->nmvcosts[1], cpi->nmvcosts[1],
1088 MV_VALS * sizeof(*cpi->nmvcosts[1]));
1089 memcpy(cc->nmvcosts_hp[0], cpi->nmvcosts_hp[0],
1090 MV_VALS * sizeof(*cpi->nmvcosts_hp[0]));
1091 memcpy(cc->nmvcosts_hp[1], cpi->nmvcosts_hp[1],
1092 MV_VALS * sizeof(*cpi->nmvcosts_hp[1]));
1094 vp9_copy(cc->segment_pred_probs, cm->seg.pred_probs);
1096 memcpy(cpi->coding_context.last_frame_seg_map_copy, cm->last_frame_seg_map,
1097 (cm->mi_rows * cm->mi_cols));
1099 vp9_copy(cc->last_ref_lf_deltas, cm->lf.last_ref_deltas);
1100 vp9_copy(cc->last_mode_lf_deltas, cm->lf.last_mode_deltas);
1105 static void restore_coding_context(VP9_COMP *cpi) {
1106 CODING_CONTEXT *const cc = &cpi->coding_context;
1107 VP9_COMMON *cm = &cpi->common;
1109 // Restore key state variables to the snapshot state stored in the
1110 // previous call to vp9_save_coding_context.
1111 vp9_copy(cpi->td.mb.nmvjointcost, cc->nmvjointcost);
1113 memcpy(cpi->nmvcosts[0], cc->nmvcosts[0], MV_VALS * sizeof(*cc->nmvcosts[0]));
1114 memcpy(cpi->nmvcosts[1], cc->nmvcosts[1], MV_VALS * sizeof(*cc->nmvcosts[1]));
1115 memcpy(cpi->nmvcosts_hp[0], cc->nmvcosts_hp[0],
1116 MV_VALS * sizeof(*cc->nmvcosts_hp[0]));
1117 memcpy(cpi->nmvcosts_hp[1], cc->nmvcosts_hp[1],
1118 MV_VALS * sizeof(*cc->nmvcosts_hp[1]));
1120 vp9_copy(cm->seg.pred_probs, cc->segment_pred_probs);
1122 memcpy(cm->last_frame_seg_map, cpi->coding_context.last_frame_seg_map_copy,
1123 (cm->mi_rows * cm->mi_cols));
1125 vp9_copy(cm->lf.last_ref_deltas, cc->last_ref_lf_deltas);
1126 vp9_copy(cm->lf.last_mode_deltas, cc->last_mode_lf_deltas);
1131 #if !CONFIG_REALTIME_ONLY
1132 static void configure_static_seg_features(VP9_COMP *cpi) {
1133 VP9_COMMON *const cm = &cpi->common;
1134 const RATE_CONTROL *const rc = &cpi->rc;
1135 struct segmentation *const seg = &cm->seg;
1137 int high_q = (int)(rc->avg_q > 48.0);
1140 // Disable and clear down for KF
1141 if (cm->frame_type == KEY_FRAME) {
1142 // Clear down the global segmentation map
1143 memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
1144 seg->update_map = 0;
1145 seg->update_data = 0;
1146 cpi->static_mb_pct = 0;
1148 // Disable segmentation
1149 vp9_disable_segmentation(seg);
1151 // Clear down the segment features.
1152 vp9_clearall_segfeatures(seg);
1153 } else if (cpi->refresh_alt_ref_frame) {
1154 // If this is an alt ref frame
1155 // Clear down the global segmentation map
1156 memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
1157 seg->update_map = 0;
1158 seg->update_data = 0;
1159 cpi->static_mb_pct = 0;
1161 // Disable segmentation and individual segment features by default
1162 vp9_disable_segmentation(seg);
1163 vp9_clearall_segfeatures(seg);
1165 // Scan frames from current to arf frame.
1166 // This function re-enables segmentation if appropriate.
1167 vp9_update_mbgraph_stats(cpi);
1169 // If segmentation was enabled set those features needed for the
1172 seg->update_map = 1;
1173 seg->update_data = 1;
1176 vp9_compute_qdelta(rc, rc->avg_q, rc->avg_q * 0.875, cm->bit_depth);
1177 vp9_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta - 2);
1178 vp9_set_segdata(seg, 1, SEG_LVL_ALT_LF, -2);
1180 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
1181 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_LF);
1183 // Where relevant assume segment data is delta data
1184 seg->abs_delta = SEGMENT_DELTADATA;
1186 } else if (seg->enabled) {
1187 // All other frames if segmentation has been enabled
1189 // First normal frame in a valid gf or alt ref group
1190 if (rc->frames_since_golden == 0) {
1191 // Set up segment features for normal frames in an arf group
1192 if (rc->source_alt_ref_active) {
1193 seg->update_map = 0;
1194 seg->update_data = 1;
1195 seg->abs_delta = SEGMENT_DELTADATA;
1198 vp9_compute_qdelta(rc, rc->avg_q, rc->avg_q * 1.125, cm->bit_depth);
1199 vp9_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta + 2);
1200 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
1202 vp9_set_segdata(seg, 1, SEG_LVL_ALT_LF, -2);
1203 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_LF);
1205 // Segment coding disabled for compred testing
1206 if (high_q || (cpi->static_mb_pct == 100)) {
1207 vp9_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME);
1208 vp9_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME);
1209 vp9_enable_segfeature(seg, 1, SEG_LVL_SKIP);
1212 // Disable segmentation and clear down features if alt ref
1213 // is not active for this group
1215 vp9_disable_segmentation(seg);
1217 memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
1219 seg->update_map = 0;
1220 seg->update_data = 0;
1222 vp9_clearall_segfeatures(seg);
1224 } else if (rc->is_src_frame_alt_ref) {
1225 // Special case where we are coding over the top of a previous
1227 // Segment coding disabled for compred testing
1229 // Enable ref frame features for segment 0 as well
1230 vp9_enable_segfeature(seg, 0, SEG_LVL_REF_FRAME);
1231 vp9_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME);
1233 // All mbs should use ALTREF_FRAME
1234 vp9_clear_segdata(seg, 0, SEG_LVL_REF_FRAME);
1235 vp9_set_segdata(seg, 0, SEG_LVL_REF_FRAME, ALTREF_FRAME);
1236 vp9_clear_segdata(seg, 1, SEG_LVL_REF_FRAME);
1237 vp9_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME);
1239 // Skip all MBs if high Q (0,0 mv and skip coeffs)
1241 vp9_enable_segfeature(seg, 0, SEG_LVL_SKIP);
1242 vp9_enable_segfeature(seg, 1, SEG_LVL_SKIP);
1244 // Enable data update
1245 seg->update_data = 1;
1247 // All other frames.
1249 // No updates.. leave things as they are.
1250 seg->update_map = 0;
1251 seg->update_data = 0;
1255 #endif // !CONFIG_REALTIME_ONLY
1257 static void update_reference_segmentation_map(VP9_COMP *cpi) {
1258 VP9_COMMON *const cm = &cpi->common;
1259 MODE_INFO **mi_8x8_ptr = cm->mi_grid_visible;
1260 uint8_t *cache_ptr = cm->last_frame_seg_map;
1263 for (row = 0; row < cm->mi_rows; row++) {
1264 MODE_INFO **mi_8x8 = mi_8x8_ptr;
1265 uint8_t *cache = cache_ptr;
1266 for (col = 0; col < cm->mi_cols; col++, mi_8x8++, cache++)
1267 cache[0] = mi_8x8[0]->segment_id;
1268 mi_8x8_ptr += cm->mi_stride;
1269 cache_ptr += cm->mi_cols;
1273 static void alloc_raw_frame_buffers(VP9_COMP *cpi) {
1274 VP9_COMMON *cm = &cpi->common;
1275 const VP9EncoderConfig *oxcf = &cpi->oxcf;
1277 if (!cpi->lookahead)
1278 cpi->lookahead = vp9_lookahead_init(oxcf->width, oxcf->height,
1279 cm->subsampling_x, cm->subsampling_y,
1280 #if CONFIG_VP9_HIGHBITDEPTH
1281 cm->use_highbitdepth,
1283 oxcf->lag_in_frames);
1284 if (!cpi->lookahead)
1285 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1286 "Failed to allocate lag buffers");
1288 // TODO(agrange) Check if ARF is enabled and skip allocation if not.
1289 if (vpx_realloc_frame_buffer(&cpi->alt_ref_buffer, oxcf->width, oxcf->height,
1290 cm->subsampling_x, cm->subsampling_y,
1291 #if CONFIG_VP9_HIGHBITDEPTH
1292 cm->use_highbitdepth,
1294 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1296 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1297 "Failed to allocate altref buffer");
1300 static void alloc_util_frame_buffers(VP9_COMP *cpi) {
1301 VP9_COMMON *const cm = &cpi->common;
1302 if (vpx_realloc_frame_buffer(&cpi->last_frame_uf, cm->width, cm->height,
1303 cm->subsampling_x, cm->subsampling_y,
1304 #if CONFIG_VP9_HIGHBITDEPTH
1305 cm->use_highbitdepth,
1307 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1309 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1310 "Failed to allocate last frame buffer");
1312 if (vpx_realloc_frame_buffer(&cpi->scaled_source, cm->width, cm->height,
1313 cm->subsampling_x, cm->subsampling_y,
1314 #if CONFIG_VP9_HIGHBITDEPTH
1315 cm->use_highbitdepth,
1317 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1319 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1320 "Failed to allocate scaled source buffer");
1322 // For 1 pass cbr: allocate scaled_frame that may be used as an intermediate
1323 // buffer for a 2 stage down-sampling: two stages of 1:2 down-sampling for a
1324 // target of 1/4x1/4. number_spatial_layers must be greater than 2.
1325 if (is_one_pass_cbr_svc(cpi) && !cpi->svc.scaled_temp_is_alloc &&
1326 cpi->svc.number_spatial_layers > 2) {
1327 cpi->svc.scaled_temp_is_alloc = 1;
1328 if (vpx_realloc_frame_buffer(
1329 &cpi->svc.scaled_temp, cm->width >> 1, cm->height >> 1,
1330 cm->subsampling_x, cm->subsampling_y,
1331 #if CONFIG_VP9_HIGHBITDEPTH
1332 cm->use_highbitdepth,
1334 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment, NULL, NULL, NULL))
1335 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1336 "Failed to allocate scaled_frame for svc ");
1339 if (vpx_realloc_frame_buffer(&cpi->scaled_last_source, cm->width, cm->height,
1340 cm->subsampling_x, cm->subsampling_y,
1341 #if CONFIG_VP9_HIGHBITDEPTH
1342 cm->use_highbitdepth,
1344 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1346 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1347 "Failed to allocate scaled last source buffer");
1348 #ifdef ENABLE_KF_DENOISE
1349 if (vpx_realloc_frame_buffer(&cpi->raw_unscaled_source, cm->width, cm->height,
1350 cm->subsampling_x, cm->subsampling_y,
1351 #if CONFIG_VP9_HIGHBITDEPTH
1352 cm->use_highbitdepth,
1354 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1356 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1357 "Failed to allocate unscaled raw source frame buffer");
1359 if (vpx_realloc_frame_buffer(&cpi->raw_scaled_source, cm->width, cm->height,
1360 cm->subsampling_x, cm->subsampling_y,
1361 #if CONFIG_VP9_HIGHBITDEPTH
1362 cm->use_highbitdepth,
1364 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1366 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1367 "Failed to allocate scaled raw source frame buffer");
1371 static int alloc_context_buffers_ext(VP9_COMP *cpi) {
1372 VP9_COMMON *cm = &cpi->common;
1373 int mi_size = cm->mi_cols * cm->mi_rows;
1375 cpi->mbmi_ext_base = vpx_calloc(mi_size, sizeof(*cpi->mbmi_ext_base));
1376 if (!cpi->mbmi_ext_base) return 1;
1381 static void alloc_compressor_data(VP9_COMP *cpi) {
1382 VP9_COMMON *cm = &cpi->common;
1385 vp9_alloc_context_buffers(cm, cm->width, cm->height);
1387 alloc_context_buffers_ext(cpi);
1389 vpx_free(cpi->tile_tok[0][0]);
1392 unsigned int tokens = get_token_alloc(cm->mb_rows, cm->mb_cols);
1393 CHECK_MEM_ERROR(cm, cpi->tile_tok[0][0],
1394 vpx_calloc(tokens, sizeof(*cpi->tile_tok[0][0])));
1397 sb_rows = mi_cols_aligned_to_sb(cm->mi_rows) >> MI_BLOCK_SIZE_LOG2;
1398 vpx_free(cpi->tplist[0][0]);
1400 cm, cpi->tplist[0][0],
1401 vpx_calloc(sb_rows * 4 * (1 << 6), sizeof(*cpi->tplist[0][0])));
1403 vp9_setup_pc_tree(&cpi->common, &cpi->td);
1406 void vp9_new_framerate(VP9_COMP *cpi, double framerate) {
1407 cpi->framerate = framerate < 0.1 ? 30 : framerate;
1408 vp9_rc_update_framerate(cpi);
1411 static void set_tile_limits(VP9_COMP *cpi) {
1412 VP9_COMMON *const cm = &cpi->common;
1414 int min_log2_tile_cols, max_log2_tile_cols;
1415 vp9_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols);
1417 cm->log2_tile_cols =
1418 clamp(cpi->oxcf.tile_columns, min_log2_tile_cols, max_log2_tile_cols);
1419 cm->log2_tile_rows = cpi->oxcf.tile_rows;
1421 if (cpi->oxcf.target_level == LEVEL_AUTO) {
1422 const int level_tile_cols =
1423 log_tile_cols_from_picsize_level(cpi->common.width, cpi->common.height);
1424 if (cm->log2_tile_cols > level_tile_cols) {
1425 cm->log2_tile_cols = VPXMAX(level_tile_cols, min_log2_tile_cols);
1430 static void update_frame_size(VP9_COMP *cpi) {
1431 VP9_COMMON *const cm = &cpi->common;
1432 MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
1434 vp9_set_mb_mi(cm, cm->width, cm->height);
1435 vp9_init_context_buffers(cm);
1436 vp9_init_macroblockd(cm, xd, NULL);
1437 cpi->td.mb.mbmi_ext_base = cpi->mbmi_ext_base;
1438 memset(cpi->mbmi_ext_base, 0,
1439 cm->mi_rows * cm->mi_cols * sizeof(*cpi->mbmi_ext_base));
1441 set_tile_limits(cpi);
1444 static void init_buffer_indices(VP9_COMP *cpi) {
1447 for (ref_frame = 0; ref_frame < REF_FRAMES; ++ref_frame)
1448 cpi->ref_fb_idx[ref_frame] = ref_frame;
1450 cpi->lst_fb_idx = cpi->ref_fb_idx[LAST_FRAME - 1];
1451 cpi->gld_fb_idx = cpi->ref_fb_idx[GOLDEN_FRAME - 1];
1452 cpi->alt_fb_idx = cpi->ref_fb_idx[ALTREF_FRAME - 1];
1455 static void init_level_constraint(LevelConstraint *lc) {
1456 lc->level_index = -1;
1457 lc->max_cpb_size = INT_MAX;
1458 lc->max_frame_size = INT_MAX;
1459 lc->rc_config_updated = 0;
1463 static void set_level_constraint(LevelConstraint *ls, int8_t level_index) {
1464 vpx_clear_system_state();
1465 ls->level_index = level_index;
1466 if (level_index >= 0) {
1467 ls->max_cpb_size = vp9_level_defs[level_index].max_cpb_size * (double)1000;
1471 static void init_config(struct VP9_COMP *cpi, VP9EncoderConfig *oxcf) {
1472 VP9_COMMON *const cm = &cpi->common;
1475 cpi->framerate = oxcf->init_framerate;
1476 cm->profile = oxcf->profile;
1477 cm->bit_depth = oxcf->bit_depth;
1478 #if CONFIG_VP9_HIGHBITDEPTH
1479 cm->use_highbitdepth = oxcf->use_highbitdepth;
1481 cm->color_space = oxcf->color_space;
1482 cm->color_range = oxcf->color_range;
1484 cpi->target_level = oxcf->target_level;
1485 cpi->keep_level_stats = oxcf->target_level != LEVEL_MAX;
1486 set_level_constraint(&cpi->level_constraint,
1487 get_level_index(cpi->target_level));
1489 cm->width = oxcf->width;
1490 cm->height = oxcf->height;
1491 alloc_compressor_data(cpi);
1493 cpi->svc.temporal_layering_mode = oxcf->temporal_layering_mode;
1495 // Single thread case: use counts in common.
1496 cpi->td.counts = &cm->counts;
1498 // Spatial scalability.
1499 cpi->svc.number_spatial_layers = oxcf->ss_number_layers;
1500 // Temporal scalability.
1501 cpi->svc.number_temporal_layers = oxcf->ts_number_layers;
1503 if ((cpi->svc.number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) ||
1504 ((cpi->svc.number_temporal_layers > 1 ||
1505 cpi->svc.number_spatial_layers > 1) &&
1506 cpi->oxcf.pass != 1)) {
1507 vp9_init_layer_context(cpi);
1510 // change includes all joint functionality
1511 vp9_change_config(cpi, oxcf);
1513 cpi->static_mb_pct = 0;
1514 cpi->ref_frame_flags = 0;
1516 init_buffer_indices(cpi);
1518 vp9_noise_estimate_init(&cpi->noise_estimate, cm->width, cm->height);
1521 static void set_rc_buffer_sizes(RATE_CONTROL *rc,
1522 const VP9EncoderConfig *oxcf) {
1523 const int64_t bandwidth = oxcf->target_bandwidth;
1524 const int64_t starting = oxcf->starting_buffer_level_ms;
1525 const int64_t optimal = oxcf->optimal_buffer_level_ms;
1526 const int64_t maximum = oxcf->maximum_buffer_size_ms;
1528 rc->starting_buffer_level = starting * bandwidth / 1000;
1529 rc->optimal_buffer_level =
1530 (optimal == 0) ? bandwidth / 8 : optimal * bandwidth / 1000;
1531 rc->maximum_buffer_size =
1532 (maximum == 0) ? bandwidth / 8 : maximum * bandwidth / 1000;
1535 #if CONFIG_VP9_HIGHBITDEPTH
1536 // TODO(angiebird): make sdx8f available for highbitdepth if needed
1537 #define HIGHBD_BFP(BT, SDF, SDAF, VF, SVF, SVAF, SDX4DF) \
1538 cpi->fn_ptr[BT].sdf = SDF; \
1539 cpi->fn_ptr[BT].sdaf = SDAF; \
1540 cpi->fn_ptr[BT].vf = VF; \
1541 cpi->fn_ptr[BT].svf = SVF; \
1542 cpi->fn_ptr[BT].svaf = SVAF; \
1543 cpi->fn_ptr[BT].sdx4df = SDX4DF; \
1544 cpi->fn_ptr[BT].sdx8f = NULL;
1546 #define MAKE_BFP_SAD_WRAPPER(fnname) \
1547 static unsigned int fnname##_bits8(const uint8_t *src_ptr, \
1548 int source_stride, \
1549 const uint8_t *ref_ptr, int ref_stride) { \
1550 return fnname(src_ptr, source_stride, ref_ptr, ref_stride); \
1552 static unsigned int fnname##_bits10( \
1553 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1555 return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 2; \
1557 static unsigned int fnname##_bits12( \
1558 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1560 return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 4; \
1563 #define MAKE_BFP_SADAVG_WRAPPER(fnname) \
1564 static unsigned int fnname##_bits8( \
1565 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1566 int ref_stride, const uint8_t *second_pred) { \
1567 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred); \
1569 static unsigned int fnname##_bits10( \
1570 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1571 int ref_stride, const uint8_t *second_pred) { \
1572 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred) >> \
1575 static unsigned int fnname##_bits12( \
1576 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1577 int ref_stride, const uint8_t *second_pred) { \
1578 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred) >> \
1582 #define MAKE_BFP_SAD4D_WRAPPER(fnname) \
1583 static void fnname##_bits8(const uint8_t *src_ptr, int source_stride, \
1584 const uint8_t *const ref_ptr[], int ref_stride, \
1585 unsigned int *sad_array) { \
1586 fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array); \
1588 static void fnname##_bits10(const uint8_t *src_ptr, int source_stride, \
1589 const uint8_t *const ref_ptr[], int ref_stride, \
1590 unsigned int *sad_array) { \
1592 fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array); \
1593 for (i = 0; i < 4; i++) sad_array[i] >>= 2; \
1595 static void fnname##_bits12(const uint8_t *src_ptr, int source_stride, \
1596 const uint8_t *const ref_ptr[], int ref_stride, \
1597 unsigned int *sad_array) { \
1599 fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array); \
1600 for (i = 0; i < 4; i++) sad_array[i] >>= 4; \
1603 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad32x16)
1604 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad32x16_avg)
1605 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad32x16x4d)
1606 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad16x32)
1607 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad16x32_avg)
1608 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad16x32x4d)
1609 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad64x32)
1610 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad64x32_avg)
1611 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad64x32x4d)
1612 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad32x64)
1613 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad32x64_avg)
1614 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad32x64x4d)
1615 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad32x32)
1616 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad32x32_avg)
1617 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad32x32x4d)
1618 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad64x64)
1619 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad64x64_avg)
1620 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad64x64x4d)
1621 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad16x16)
1622 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad16x16_avg)
1623 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad16x16x4d)
1624 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad16x8)
1625 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad16x8_avg)
1626 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad16x8x4d)
1627 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad8x16)
1628 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad8x16_avg)
1629 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad8x16x4d)
1630 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad8x8)
1631 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad8x8_avg)
1632 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad8x8x4d)
1633 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad8x4)
1634 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad8x4_avg)
1635 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad8x4x4d)
1636 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad4x8)
1637 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad4x8_avg)
1638 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad4x8x4d)
1639 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad4x4)
1640 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad4x4_avg)
1641 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad4x4x4d)
1643 static void highbd_set_var_fns(VP9_COMP *const cpi) {
1644 VP9_COMMON *const cm = &cpi->common;
1645 if (cm->use_highbitdepth) {
1646 switch (cm->bit_depth) {
1648 HIGHBD_BFP(BLOCK_32X16, vpx_highbd_sad32x16_bits8,
1649 vpx_highbd_sad32x16_avg_bits8, vpx_highbd_8_variance32x16,
1650 vpx_highbd_8_sub_pixel_variance32x16,
1651 vpx_highbd_8_sub_pixel_avg_variance32x16,
1652 vpx_highbd_sad32x16x4d_bits8)
1654 HIGHBD_BFP(BLOCK_16X32, vpx_highbd_sad16x32_bits8,
1655 vpx_highbd_sad16x32_avg_bits8, vpx_highbd_8_variance16x32,
1656 vpx_highbd_8_sub_pixel_variance16x32,
1657 vpx_highbd_8_sub_pixel_avg_variance16x32,
1658 vpx_highbd_sad16x32x4d_bits8)
1660 HIGHBD_BFP(BLOCK_64X32, vpx_highbd_sad64x32_bits8,
1661 vpx_highbd_sad64x32_avg_bits8, vpx_highbd_8_variance64x32,
1662 vpx_highbd_8_sub_pixel_variance64x32,
1663 vpx_highbd_8_sub_pixel_avg_variance64x32,
1664 vpx_highbd_sad64x32x4d_bits8)
1666 HIGHBD_BFP(BLOCK_32X64, vpx_highbd_sad32x64_bits8,
1667 vpx_highbd_sad32x64_avg_bits8, vpx_highbd_8_variance32x64,
1668 vpx_highbd_8_sub_pixel_variance32x64,
1669 vpx_highbd_8_sub_pixel_avg_variance32x64,
1670 vpx_highbd_sad32x64x4d_bits8)
1672 HIGHBD_BFP(BLOCK_32X32, vpx_highbd_sad32x32_bits8,
1673 vpx_highbd_sad32x32_avg_bits8, vpx_highbd_8_variance32x32,
1674 vpx_highbd_8_sub_pixel_variance32x32,
1675 vpx_highbd_8_sub_pixel_avg_variance32x32,
1676 vpx_highbd_sad32x32x4d_bits8)
1678 HIGHBD_BFP(BLOCK_64X64, vpx_highbd_sad64x64_bits8,
1679 vpx_highbd_sad64x64_avg_bits8, vpx_highbd_8_variance64x64,
1680 vpx_highbd_8_sub_pixel_variance64x64,
1681 vpx_highbd_8_sub_pixel_avg_variance64x64,
1682 vpx_highbd_sad64x64x4d_bits8)
1684 HIGHBD_BFP(BLOCK_16X16, vpx_highbd_sad16x16_bits8,
1685 vpx_highbd_sad16x16_avg_bits8, vpx_highbd_8_variance16x16,
1686 vpx_highbd_8_sub_pixel_variance16x16,
1687 vpx_highbd_8_sub_pixel_avg_variance16x16,
1688 vpx_highbd_sad16x16x4d_bits8)
1690 HIGHBD_BFP(BLOCK_16X8, vpx_highbd_sad16x8_bits8,
1691 vpx_highbd_sad16x8_avg_bits8, vpx_highbd_8_variance16x8,
1692 vpx_highbd_8_sub_pixel_variance16x8,
1693 vpx_highbd_8_sub_pixel_avg_variance16x8,
1694 vpx_highbd_sad16x8x4d_bits8)
1696 HIGHBD_BFP(BLOCK_8X16, vpx_highbd_sad8x16_bits8,
1697 vpx_highbd_sad8x16_avg_bits8, vpx_highbd_8_variance8x16,
1698 vpx_highbd_8_sub_pixel_variance8x16,
1699 vpx_highbd_8_sub_pixel_avg_variance8x16,
1700 vpx_highbd_sad8x16x4d_bits8)
1703 BLOCK_8X8, vpx_highbd_sad8x8_bits8, vpx_highbd_sad8x8_avg_bits8,
1704 vpx_highbd_8_variance8x8, vpx_highbd_8_sub_pixel_variance8x8,
1705 vpx_highbd_8_sub_pixel_avg_variance8x8, vpx_highbd_sad8x8x4d_bits8)
1708 BLOCK_8X4, vpx_highbd_sad8x4_bits8, vpx_highbd_sad8x4_avg_bits8,
1709 vpx_highbd_8_variance8x4, vpx_highbd_8_sub_pixel_variance8x4,
1710 vpx_highbd_8_sub_pixel_avg_variance8x4, vpx_highbd_sad8x4x4d_bits8)
1713 BLOCK_4X8, vpx_highbd_sad4x8_bits8, vpx_highbd_sad4x8_avg_bits8,
1714 vpx_highbd_8_variance4x8, vpx_highbd_8_sub_pixel_variance4x8,
1715 vpx_highbd_8_sub_pixel_avg_variance4x8, vpx_highbd_sad4x8x4d_bits8)
1718 BLOCK_4X4, vpx_highbd_sad4x4_bits8, vpx_highbd_sad4x4_avg_bits8,
1719 vpx_highbd_8_variance4x4, vpx_highbd_8_sub_pixel_variance4x4,
1720 vpx_highbd_8_sub_pixel_avg_variance4x4, vpx_highbd_sad4x4x4d_bits8)
1724 HIGHBD_BFP(BLOCK_32X16, vpx_highbd_sad32x16_bits10,
1725 vpx_highbd_sad32x16_avg_bits10, vpx_highbd_10_variance32x16,
1726 vpx_highbd_10_sub_pixel_variance32x16,
1727 vpx_highbd_10_sub_pixel_avg_variance32x16,
1728 vpx_highbd_sad32x16x4d_bits10)
1730 HIGHBD_BFP(BLOCK_16X32, vpx_highbd_sad16x32_bits10,
1731 vpx_highbd_sad16x32_avg_bits10, vpx_highbd_10_variance16x32,
1732 vpx_highbd_10_sub_pixel_variance16x32,
1733 vpx_highbd_10_sub_pixel_avg_variance16x32,
1734 vpx_highbd_sad16x32x4d_bits10)
1736 HIGHBD_BFP(BLOCK_64X32, vpx_highbd_sad64x32_bits10,
1737 vpx_highbd_sad64x32_avg_bits10, vpx_highbd_10_variance64x32,
1738 vpx_highbd_10_sub_pixel_variance64x32,
1739 vpx_highbd_10_sub_pixel_avg_variance64x32,
1740 vpx_highbd_sad64x32x4d_bits10)
1742 HIGHBD_BFP(BLOCK_32X64, vpx_highbd_sad32x64_bits10,
1743 vpx_highbd_sad32x64_avg_bits10, vpx_highbd_10_variance32x64,
1744 vpx_highbd_10_sub_pixel_variance32x64,
1745 vpx_highbd_10_sub_pixel_avg_variance32x64,
1746 vpx_highbd_sad32x64x4d_bits10)
1748 HIGHBD_BFP(BLOCK_32X32, vpx_highbd_sad32x32_bits10,
1749 vpx_highbd_sad32x32_avg_bits10, vpx_highbd_10_variance32x32,
1750 vpx_highbd_10_sub_pixel_variance32x32,
1751 vpx_highbd_10_sub_pixel_avg_variance32x32,
1752 vpx_highbd_sad32x32x4d_bits10)
1754 HIGHBD_BFP(BLOCK_64X64, vpx_highbd_sad64x64_bits10,
1755 vpx_highbd_sad64x64_avg_bits10, vpx_highbd_10_variance64x64,
1756 vpx_highbd_10_sub_pixel_variance64x64,
1757 vpx_highbd_10_sub_pixel_avg_variance64x64,
1758 vpx_highbd_sad64x64x4d_bits10)
1760 HIGHBD_BFP(BLOCK_16X16, vpx_highbd_sad16x16_bits10,
1761 vpx_highbd_sad16x16_avg_bits10, vpx_highbd_10_variance16x16,
1762 vpx_highbd_10_sub_pixel_variance16x16,
1763 vpx_highbd_10_sub_pixel_avg_variance16x16,
1764 vpx_highbd_sad16x16x4d_bits10)
1766 HIGHBD_BFP(BLOCK_16X8, vpx_highbd_sad16x8_bits10,
1767 vpx_highbd_sad16x8_avg_bits10, vpx_highbd_10_variance16x8,
1768 vpx_highbd_10_sub_pixel_variance16x8,
1769 vpx_highbd_10_sub_pixel_avg_variance16x8,
1770 vpx_highbd_sad16x8x4d_bits10)
1772 HIGHBD_BFP(BLOCK_8X16, vpx_highbd_sad8x16_bits10,
1773 vpx_highbd_sad8x16_avg_bits10, vpx_highbd_10_variance8x16,
1774 vpx_highbd_10_sub_pixel_variance8x16,
1775 vpx_highbd_10_sub_pixel_avg_variance8x16,
1776 vpx_highbd_sad8x16x4d_bits10)
1778 HIGHBD_BFP(BLOCK_8X8, vpx_highbd_sad8x8_bits10,
1779 vpx_highbd_sad8x8_avg_bits10, vpx_highbd_10_variance8x8,
1780 vpx_highbd_10_sub_pixel_variance8x8,
1781 vpx_highbd_10_sub_pixel_avg_variance8x8,
1782 vpx_highbd_sad8x8x4d_bits10)
1784 HIGHBD_BFP(BLOCK_8X4, vpx_highbd_sad8x4_bits10,
1785 vpx_highbd_sad8x4_avg_bits10, vpx_highbd_10_variance8x4,
1786 vpx_highbd_10_sub_pixel_variance8x4,
1787 vpx_highbd_10_sub_pixel_avg_variance8x4,
1788 vpx_highbd_sad8x4x4d_bits10)
1790 HIGHBD_BFP(BLOCK_4X8, vpx_highbd_sad4x8_bits10,
1791 vpx_highbd_sad4x8_avg_bits10, vpx_highbd_10_variance4x8,
1792 vpx_highbd_10_sub_pixel_variance4x8,
1793 vpx_highbd_10_sub_pixel_avg_variance4x8,
1794 vpx_highbd_sad4x8x4d_bits10)
1796 HIGHBD_BFP(BLOCK_4X4, vpx_highbd_sad4x4_bits10,
1797 vpx_highbd_sad4x4_avg_bits10, vpx_highbd_10_variance4x4,
1798 vpx_highbd_10_sub_pixel_variance4x4,
1799 vpx_highbd_10_sub_pixel_avg_variance4x4,
1800 vpx_highbd_sad4x4x4d_bits10)
1804 assert(cm->bit_depth == VPX_BITS_12);
1805 HIGHBD_BFP(BLOCK_32X16, vpx_highbd_sad32x16_bits12,
1806 vpx_highbd_sad32x16_avg_bits12, vpx_highbd_12_variance32x16,
1807 vpx_highbd_12_sub_pixel_variance32x16,
1808 vpx_highbd_12_sub_pixel_avg_variance32x16,
1809 vpx_highbd_sad32x16x4d_bits12)
1811 HIGHBD_BFP(BLOCK_16X32, vpx_highbd_sad16x32_bits12,
1812 vpx_highbd_sad16x32_avg_bits12, vpx_highbd_12_variance16x32,
1813 vpx_highbd_12_sub_pixel_variance16x32,
1814 vpx_highbd_12_sub_pixel_avg_variance16x32,
1815 vpx_highbd_sad16x32x4d_bits12)
1817 HIGHBD_BFP(BLOCK_64X32, vpx_highbd_sad64x32_bits12,
1818 vpx_highbd_sad64x32_avg_bits12, vpx_highbd_12_variance64x32,
1819 vpx_highbd_12_sub_pixel_variance64x32,
1820 vpx_highbd_12_sub_pixel_avg_variance64x32,
1821 vpx_highbd_sad64x32x4d_bits12)
1823 HIGHBD_BFP(BLOCK_32X64, vpx_highbd_sad32x64_bits12,
1824 vpx_highbd_sad32x64_avg_bits12, vpx_highbd_12_variance32x64,
1825 vpx_highbd_12_sub_pixel_variance32x64,
1826 vpx_highbd_12_sub_pixel_avg_variance32x64,
1827 vpx_highbd_sad32x64x4d_bits12)
1829 HIGHBD_BFP(BLOCK_32X32, vpx_highbd_sad32x32_bits12,
1830 vpx_highbd_sad32x32_avg_bits12, vpx_highbd_12_variance32x32,
1831 vpx_highbd_12_sub_pixel_variance32x32,
1832 vpx_highbd_12_sub_pixel_avg_variance32x32,
1833 vpx_highbd_sad32x32x4d_bits12)
1835 HIGHBD_BFP(BLOCK_64X64, vpx_highbd_sad64x64_bits12,
1836 vpx_highbd_sad64x64_avg_bits12, vpx_highbd_12_variance64x64,
1837 vpx_highbd_12_sub_pixel_variance64x64,
1838 vpx_highbd_12_sub_pixel_avg_variance64x64,
1839 vpx_highbd_sad64x64x4d_bits12)
1841 HIGHBD_BFP(BLOCK_16X16, vpx_highbd_sad16x16_bits12,
1842 vpx_highbd_sad16x16_avg_bits12, vpx_highbd_12_variance16x16,
1843 vpx_highbd_12_sub_pixel_variance16x16,
1844 vpx_highbd_12_sub_pixel_avg_variance16x16,
1845 vpx_highbd_sad16x16x4d_bits12)
1847 HIGHBD_BFP(BLOCK_16X8, vpx_highbd_sad16x8_bits12,
1848 vpx_highbd_sad16x8_avg_bits12, vpx_highbd_12_variance16x8,
1849 vpx_highbd_12_sub_pixel_variance16x8,
1850 vpx_highbd_12_sub_pixel_avg_variance16x8,
1851 vpx_highbd_sad16x8x4d_bits12)
1853 HIGHBD_BFP(BLOCK_8X16, vpx_highbd_sad8x16_bits12,
1854 vpx_highbd_sad8x16_avg_bits12, vpx_highbd_12_variance8x16,
1855 vpx_highbd_12_sub_pixel_variance8x16,
1856 vpx_highbd_12_sub_pixel_avg_variance8x16,
1857 vpx_highbd_sad8x16x4d_bits12)
1859 HIGHBD_BFP(BLOCK_8X8, vpx_highbd_sad8x8_bits12,
1860 vpx_highbd_sad8x8_avg_bits12, vpx_highbd_12_variance8x8,
1861 vpx_highbd_12_sub_pixel_variance8x8,
1862 vpx_highbd_12_sub_pixel_avg_variance8x8,
1863 vpx_highbd_sad8x8x4d_bits12)
1865 HIGHBD_BFP(BLOCK_8X4, vpx_highbd_sad8x4_bits12,
1866 vpx_highbd_sad8x4_avg_bits12, vpx_highbd_12_variance8x4,
1867 vpx_highbd_12_sub_pixel_variance8x4,
1868 vpx_highbd_12_sub_pixel_avg_variance8x4,
1869 vpx_highbd_sad8x4x4d_bits12)
1871 HIGHBD_BFP(BLOCK_4X8, vpx_highbd_sad4x8_bits12,
1872 vpx_highbd_sad4x8_avg_bits12, vpx_highbd_12_variance4x8,
1873 vpx_highbd_12_sub_pixel_variance4x8,
1874 vpx_highbd_12_sub_pixel_avg_variance4x8,
1875 vpx_highbd_sad4x8x4d_bits12)
1877 HIGHBD_BFP(BLOCK_4X4, vpx_highbd_sad4x4_bits12,
1878 vpx_highbd_sad4x4_avg_bits12, vpx_highbd_12_variance4x4,
1879 vpx_highbd_12_sub_pixel_variance4x4,
1880 vpx_highbd_12_sub_pixel_avg_variance4x4,
1881 vpx_highbd_sad4x4x4d_bits12)
1886 #endif // CONFIG_VP9_HIGHBITDEPTH
1888 static void realloc_segmentation_maps(VP9_COMP *cpi) {
1889 VP9_COMMON *const cm = &cpi->common;
1891 // Create the encoder segmentation map and set all entries to 0
1892 vpx_free(cpi->segmentation_map);
1893 CHECK_MEM_ERROR(cm, cpi->segmentation_map,
1894 vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1896 // Create a map used for cyclic background refresh.
1897 if (cpi->cyclic_refresh) vp9_cyclic_refresh_free(cpi->cyclic_refresh);
1898 CHECK_MEM_ERROR(cm, cpi->cyclic_refresh,
1899 vp9_cyclic_refresh_alloc(cm->mi_rows, cm->mi_cols));
1901 // Create a map used to mark inactive areas.
1902 vpx_free(cpi->active_map.map);
1903 CHECK_MEM_ERROR(cm, cpi->active_map.map,
1904 vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1906 // And a place holder structure is the coding context
1907 // for use if we want to save and restore it
1908 vpx_free(cpi->coding_context.last_frame_seg_map_copy);
1909 CHECK_MEM_ERROR(cm, cpi->coding_context.last_frame_seg_map_copy,
1910 vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1913 static void alloc_copy_partition_data(VP9_COMP *cpi) {
1914 VP9_COMMON *const cm = &cpi->common;
1915 if (cpi->prev_partition == NULL) {
1916 CHECK_MEM_ERROR(cm, cpi->prev_partition,
1917 (BLOCK_SIZE *)vpx_calloc(cm->mi_stride * cm->mi_rows,
1918 sizeof(*cpi->prev_partition)));
1920 if (cpi->prev_segment_id == NULL) {
1922 cm, cpi->prev_segment_id,
1923 (int8_t *)vpx_calloc((cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1),
1924 sizeof(*cpi->prev_segment_id)));
1926 if (cpi->prev_variance_low == NULL) {
1927 CHECK_MEM_ERROR(cm, cpi->prev_variance_low,
1928 (uint8_t *)vpx_calloc(
1929 (cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1) * 25,
1930 sizeof(*cpi->prev_variance_low)));
1932 if (cpi->copied_frame_cnt == NULL) {
1934 cm, cpi->copied_frame_cnt,
1935 (uint8_t *)vpx_calloc((cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1),
1936 sizeof(*cpi->copied_frame_cnt)));
1940 void vp9_change_config(struct VP9_COMP *cpi, const VP9EncoderConfig *oxcf) {
1941 VP9_COMMON *const cm = &cpi->common;
1942 RATE_CONTROL *const rc = &cpi->rc;
1943 int last_w = cpi->oxcf.width;
1944 int last_h = cpi->oxcf.height;
1946 vp9_init_quantizer(cpi);
1947 if (cm->profile != oxcf->profile) cm->profile = oxcf->profile;
1948 cm->bit_depth = oxcf->bit_depth;
1949 cm->color_space = oxcf->color_space;
1950 cm->color_range = oxcf->color_range;
1952 cpi->target_level = oxcf->target_level;
1953 cpi->keep_level_stats = oxcf->target_level != LEVEL_MAX;
1954 set_level_constraint(&cpi->level_constraint,
1955 get_level_index(cpi->target_level));
1957 if (cm->profile <= PROFILE_1)
1958 assert(cm->bit_depth == VPX_BITS_8);
1960 assert(cm->bit_depth > VPX_BITS_8);
1963 #if CONFIG_VP9_HIGHBITDEPTH
1964 cpi->td.mb.e_mbd.bd = (int)cm->bit_depth;
1965 #endif // CONFIG_VP9_HIGHBITDEPTH
1967 if ((oxcf->pass == 0) && (oxcf->rc_mode == VPX_Q)) {
1968 rc->baseline_gf_interval = FIXED_GF_INTERVAL;
1970 rc->baseline_gf_interval = (MIN_GF_INTERVAL + MAX_GF_INTERVAL) / 2;
1973 cpi->refresh_golden_frame = 0;
1974 cpi->refresh_last_frame = 1;
1975 cm->refresh_frame_context = 1;
1976 cm->reset_frame_context = 0;
1978 vp9_reset_segment_features(&cm->seg);
1979 vp9_set_high_precision_mv(cpi, 0);
1984 for (i = 0; i < MAX_SEGMENTS; i++)
1985 cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout;
1987 cpi->encode_breakout = cpi->oxcf.encode_breakout;
1989 set_rc_buffer_sizes(rc, &cpi->oxcf);
1991 // Under a configuration change, where maximum_buffer_size may change,
1992 // keep buffer level clipped to the maximum allowed buffer size.
1993 rc->bits_off_target = VPXMIN(rc->bits_off_target, rc->maximum_buffer_size);
1994 rc->buffer_level = VPXMIN(rc->buffer_level, rc->maximum_buffer_size);
1996 // Set up frame rate and related parameters rate control values.
1997 vp9_new_framerate(cpi, cpi->framerate);
1999 // Set absolute upper and lower quality limits
2000 rc->worst_quality = cpi->oxcf.worst_allowed_q;
2001 rc->best_quality = cpi->oxcf.best_allowed_q;
2003 cm->interp_filter = cpi->sf.default_interp_filter;
2005 if (cpi->oxcf.render_width > 0 && cpi->oxcf.render_height > 0) {
2006 cm->render_width = cpi->oxcf.render_width;
2007 cm->render_height = cpi->oxcf.render_height;
2009 cm->render_width = cpi->oxcf.width;
2010 cm->render_height = cpi->oxcf.height;
2012 if (last_w != cpi->oxcf.width || last_h != cpi->oxcf.height) {
2013 cm->width = cpi->oxcf.width;
2014 cm->height = cpi->oxcf.height;
2015 cpi->external_resize = 1;
2018 if (cpi->initial_width) {
2019 int new_mi_size = 0;
2020 vp9_set_mb_mi(cm, cm->width, cm->height);
2021 new_mi_size = cm->mi_stride * calc_mi_size(cm->mi_rows);
2022 if (cm->mi_alloc_size < new_mi_size) {
2023 vp9_free_context_buffers(cm);
2024 alloc_compressor_data(cpi);
2025 realloc_segmentation_maps(cpi);
2026 cpi->initial_width = cpi->initial_height = 0;
2027 cpi->external_resize = 0;
2028 } else if (cm->mi_alloc_size == new_mi_size &&
2029 (cpi->oxcf.width > last_w || cpi->oxcf.height > last_h)) {
2030 vp9_alloc_loop_filter(cm);
2034 if (cm->current_video_frame == 0 || last_w != cpi->oxcf.width ||
2035 last_h != cpi->oxcf.height)
2036 update_frame_size(cpi);
2038 if (last_w != cpi->oxcf.width || last_h != cpi->oxcf.height) {
2039 memset(cpi->consec_zero_mv, 0,
2040 cm->mi_rows * cm->mi_cols * sizeof(*cpi->consec_zero_mv));
2041 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ)
2042 vp9_cyclic_refresh_reset_resize(cpi);
2047 if ((cpi->svc.number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) ||
2048 ((cpi->svc.number_temporal_layers > 1 ||
2049 cpi->svc.number_spatial_layers > 1) &&
2050 cpi->oxcf.pass != 1)) {
2051 vp9_update_layer_context_change_config(cpi,
2052 (int)cpi->oxcf.target_bandwidth);
2055 // Check for resetting the rc flags (rc_1_frame, rc_2_frame) if the
2056 // configuration change has a large change in avg_frame_bandwidth.
2057 // For SVC check for resetting based on spatial layer average bandwidth.
2058 // Also reset buffer level to optimal level.
2059 if (cm->current_video_frame > 0) {
2061 vp9_svc_check_reset_layer_rc_flag(cpi);
2063 if (rc->avg_frame_bandwidth > (3 * rc->last_avg_frame_bandwidth >> 1) ||
2064 rc->avg_frame_bandwidth < (rc->last_avg_frame_bandwidth >> 1)) {
2067 rc->bits_off_target = rc->optimal_buffer_level;
2068 rc->buffer_level = rc->optimal_buffer_level;
2073 cpi->alt_ref_source = NULL;
2074 rc->is_src_frame_alt_ref = 0;
2077 // Experimental RD Code
2078 cpi->frame_distortion = 0;
2079 cpi->last_frame_distortion = 0;
2082 set_tile_limits(cpi);
2084 cpi->ext_refresh_frame_flags_pending = 0;
2085 cpi->ext_refresh_frame_context_pending = 0;
2087 #if CONFIG_VP9_HIGHBITDEPTH
2088 highbd_set_var_fns(cpi);
2091 vp9_set_row_mt(cpi);
2095 #define M_LOG2_E 0.693147180559945309417
2097 #define log2f(x) (log(x) / (float)M_LOG2_E)
2099 /***********************************************************************
2100 * Read before modifying 'cal_nmvjointsadcost' or 'cal_nmvsadcosts' *
2101 ***********************************************************************
2102 * The following 2 functions ('cal_nmvjointsadcost' and *
2103 * 'cal_nmvsadcosts') are used to calculate cost lookup tables *
2104 * used by 'vp9_diamond_search_sad'. The C implementation of the *
2105 * function is generic, but the AVX intrinsics optimised version *
2106 * relies on the following properties of the computed tables: *
2107 * For cal_nmvjointsadcost: *
2108 * - mvjointsadcost[1] == mvjointsadcost[2] == mvjointsadcost[3] *
2109 * For cal_nmvsadcosts: *
2110 * - For all i: mvsadcost[0][i] == mvsadcost[1][i] *
2111 * (Equal costs for both components) *
2112 * - For all i: mvsadcost[0][i] == mvsadcost[0][-i] *
2113 * (Cost function is even) *
2114 * If these do not hold, then the AVX optimised version of the *
2115 * 'vp9_diamond_search_sad' function cannot be used as it is, in which *
2116 * case you can revert to using the C function instead. *
2117 ***********************************************************************/
2119 static void cal_nmvjointsadcost(int *mvjointsadcost) {
2120 /*********************************************************************
2121 * Warning: Read the comments above before modifying this function *
2122 *********************************************************************/
2123 mvjointsadcost[0] = 600;
2124 mvjointsadcost[1] = 300;
2125 mvjointsadcost[2] = 300;
2126 mvjointsadcost[3] = 300;
2129 static void cal_nmvsadcosts(int *mvsadcost[2]) {
2130 /*********************************************************************
2131 * Warning: Read the comments above before modifying this function *
2132 *********************************************************************/
2135 mvsadcost[0][0] = 0;
2136 mvsadcost[1][0] = 0;
2139 double z = 256 * (2 * (log2f(8 * i) + .6));
2140 mvsadcost[0][i] = (int)z;
2141 mvsadcost[1][i] = (int)z;
2142 mvsadcost[0][-i] = (int)z;
2143 mvsadcost[1][-i] = (int)z;
2144 } while (++i <= MV_MAX);
2147 static void cal_nmvsadcosts_hp(int *mvsadcost[2]) {
2150 mvsadcost[0][0] = 0;
2151 mvsadcost[1][0] = 0;
2154 double z = 256 * (2 * (log2f(8 * i) + .6));
2155 mvsadcost[0][i] = (int)z;
2156 mvsadcost[1][i] = (int)z;
2157 mvsadcost[0][-i] = (int)z;
2158 mvsadcost[1][-i] = (int)z;
2159 } while (++i <= MV_MAX);
2162 VP9_COMP *vp9_create_compressor(VP9EncoderConfig *oxcf,
2163 BufferPool *const pool) {
2165 VP9_COMP *volatile const cpi = vpx_memalign(32, sizeof(VP9_COMP));
2166 VP9_COMMON *volatile const cm = cpi != NULL ? &cpi->common : NULL;
2168 if (!cm) return NULL;
2172 if (setjmp(cm->error.jmp)) {
2173 cm->error.setjmp = 0;
2174 vp9_remove_compressor(cpi);
2178 cm->error.setjmp = 1;
2179 cm->alloc_mi = vp9_enc_alloc_mi;
2180 cm->free_mi = vp9_enc_free_mi;
2181 cm->setup_mi = vp9_enc_setup_mi;
2183 CHECK_MEM_ERROR(cm, cm->fc, (FRAME_CONTEXT *)vpx_calloc(1, sizeof(*cm->fc)));
2185 cm, cm->frame_contexts,
2186 (FRAME_CONTEXT *)vpx_calloc(FRAME_CONTEXTS, sizeof(*cm->frame_contexts)));
2189 cpi->resize_state = ORIG;
2190 cpi->external_resize = 0;
2191 cpi->resize_avg_qp = 0;
2192 cpi->resize_buffer_underflow = 0;
2193 cpi->use_skin_detection = 0;
2194 cpi->common.buffer_pool = pool;
2196 cpi->force_update_segmentation = 0;
2198 init_config(cpi, oxcf);
2199 vp9_rc_init(&cpi->oxcf, oxcf->pass, &cpi->rc);
2201 cm->current_video_frame = 0;
2202 cpi->partition_search_skippable_frame = 0;
2203 cpi->tile_data = NULL;
2205 realloc_segmentation_maps(cpi);
2209 vpx_calloc(cm->mi_rows * cm->mi_cols, sizeof(cpi->skin_map[0])));
2211 #if !CONFIG_REALTIME_ONLY
2212 CHECK_MEM_ERROR(cm, cpi->alt_ref_aq, vp9_alt_ref_aq_create());
2216 cm, cpi->consec_zero_mv,
2217 vpx_calloc(cm->mi_rows * cm->mi_cols, sizeof(*cpi->consec_zero_mv)));
2219 CHECK_MEM_ERROR(cm, cpi->nmvcosts[0],
2220 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts[0])));
2221 CHECK_MEM_ERROR(cm, cpi->nmvcosts[1],
2222 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts[1])));
2223 CHECK_MEM_ERROR(cm, cpi->nmvcosts_hp[0],
2224 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts_hp[0])));
2225 CHECK_MEM_ERROR(cm, cpi->nmvcosts_hp[1],
2226 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts_hp[1])));
2227 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts[0],
2228 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts[0])));
2229 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts[1],
2230 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts[1])));
2231 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts_hp[0],
2232 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts_hp[0])));
2233 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts_hp[1],
2234 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts_hp[1])));
2236 for (i = 0; i < (sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]));
2239 cm, cpi->mbgraph_stats[i].mb_stats,
2240 vpx_calloc(cm->MBs * sizeof(*cpi->mbgraph_stats[i].mb_stats), 1));
2243 #if CONFIG_FP_MB_STATS
2244 cpi->use_fp_mb_stats = 0;
2245 if (cpi->use_fp_mb_stats) {
2246 // a place holder used to store the first pass mb stats in the first pass
2247 CHECK_MEM_ERROR(cm, cpi->twopass.frame_mb_stats_buf,
2248 vpx_calloc(cm->MBs * sizeof(uint8_t), 1));
2250 cpi->twopass.frame_mb_stats_buf = NULL;
2254 cpi->refresh_alt_ref_frame = 0;
2255 cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS;
2257 init_level_info(&cpi->level_info);
2258 init_level_constraint(&cpi->level_constraint);
2260 #if CONFIG_INTERNAL_STATS
2261 cpi->b_calculate_blockiness = 1;
2262 cpi->b_calculate_consistency = 1;
2263 cpi->total_inconsistency = 0;
2264 cpi->psnr.worst = 100.0;
2265 cpi->worst_ssim = 100.0;
2270 if (cpi->b_calculate_psnr) {
2271 cpi->total_sq_error = 0;
2272 cpi->total_samples = 0;
2274 cpi->totalp_sq_error = 0;
2275 cpi->totalp_samples = 0;
2277 cpi->tot_recode_hits = 0;
2278 cpi->summed_quality = 0;
2279 cpi->summed_weights = 0;
2280 cpi->summedp_quality = 0;
2281 cpi->summedp_weights = 0;
2284 cpi->fastssim.worst = 100.0;
2286 cpi->psnrhvs.worst = 100.0;
2288 if (cpi->b_calculate_blockiness) {
2289 cpi->total_blockiness = 0;
2290 cpi->worst_blockiness = 0.0;
2293 if (cpi->b_calculate_consistency) {
2294 CHECK_MEM_ERROR(cm, cpi->ssim_vars,
2295 vpx_calloc(cpi->common.mi_rows * cpi->common.mi_cols,
2296 sizeof(*cpi->ssim_vars) * 4));
2297 cpi->worst_consistency = 100.0;
2299 cpi->ssim_vars = NULL;
2304 cpi->first_time_stamp_ever = INT64_MAX;
2306 /*********************************************************************
2307 * Warning: Read the comments around 'cal_nmvjointsadcost' and *
2308 * 'cal_nmvsadcosts' before modifying how these tables are computed. *
2309 *********************************************************************/
2310 cal_nmvjointsadcost(cpi->td.mb.nmvjointsadcost);
2311 cpi->td.mb.nmvcost[0] = &cpi->nmvcosts[0][MV_MAX];
2312 cpi->td.mb.nmvcost[1] = &cpi->nmvcosts[1][MV_MAX];
2313 cpi->td.mb.nmvsadcost[0] = &cpi->nmvsadcosts[0][MV_MAX];
2314 cpi->td.mb.nmvsadcost[1] = &cpi->nmvsadcosts[1][MV_MAX];
2315 cal_nmvsadcosts(cpi->td.mb.nmvsadcost);
2317 cpi->td.mb.nmvcost_hp[0] = &cpi->nmvcosts_hp[0][MV_MAX];
2318 cpi->td.mb.nmvcost_hp[1] = &cpi->nmvcosts_hp[1][MV_MAX];
2319 cpi->td.mb.nmvsadcost_hp[0] = &cpi->nmvsadcosts_hp[0][MV_MAX];
2320 cpi->td.mb.nmvsadcost_hp[1] = &cpi->nmvsadcosts_hp[1][MV_MAX];
2321 cal_nmvsadcosts_hp(cpi->td.mb.nmvsadcost_hp);
2323 #if CONFIG_VP9_TEMPORAL_DENOISING
2324 #ifdef OUTPUT_YUV_DENOISED
2325 yuv_denoised_file = fopen("denoised.yuv", "ab");
2328 #ifdef OUTPUT_YUV_SKINMAP
2329 yuv_skinmap_file = fopen("skinmap.yuv", "wb");
2331 #ifdef OUTPUT_YUV_REC
2332 yuv_rec_file = fopen("rec.yuv", "wb");
2334 #ifdef OUTPUT_YUV_SVC_SRC
2335 yuv_svc_src[0] = fopen("svc_src_0.yuv", "wb");
2336 yuv_svc_src[1] = fopen("svc_src_1.yuv", "wb");
2337 yuv_svc_src[2] = fopen("svc_src_2.yuv", "wb");
2341 framepsnr = fopen("framepsnr.stt", "a");
2342 kf_list = fopen("kf_list.stt", "w");
2345 cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED;
2347 #if !CONFIG_REALTIME_ONLY
2348 if (oxcf->pass == 1) {
2349 vp9_init_first_pass(cpi);
2350 } else if (oxcf->pass == 2) {
2351 const size_t packet_sz = sizeof(FIRSTPASS_STATS);
2352 const int packets = (int)(oxcf->two_pass_stats_in.sz / packet_sz);
2354 if (cpi->svc.number_spatial_layers > 1 ||
2355 cpi->svc.number_temporal_layers > 1) {
2356 FIRSTPASS_STATS *const stats = oxcf->two_pass_stats_in.buf;
2357 FIRSTPASS_STATS *stats_copy[VPX_SS_MAX_LAYERS] = { 0 };
2360 for (i = 0; i < oxcf->ss_number_layers; ++i) {
2361 FIRSTPASS_STATS *const last_packet_for_layer =
2362 &stats[packets - oxcf->ss_number_layers + i];
2363 const int layer_id = (int)last_packet_for_layer->spatial_layer_id;
2364 const int packets_in_layer = (int)last_packet_for_layer->count + 1;
2365 if (layer_id >= 0 && layer_id < oxcf->ss_number_layers) {
2366 LAYER_CONTEXT *const lc = &cpi->svc.layer_context[layer_id];
2368 vpx_free(lc->rc_twopass_stats_in.buf);
2370 lc->rc_twopass_stats_in.sz = packets_in_layer * packet_sz;
2371 CHECK_MEM_ERROR(cm, lc->rc_twopass_stats_in.buf,
2372 vpx_malloc(lc->rc_twopass_stats_in.sz));
2373 lc->twopass.stats_in_start = lc->rc_twopass_stats_in.buf;
2374 lc->twopass.stats_in = lc->twopass.stats_in_start;
2375 lc->twopass.stats_in_end =
2376 lc->twopass.stats_in_start + packets_in_layer - 1;
2377 stats_copy[layer_id] = lc->rc_twopass_stats_in.buf;
2381 for (i = 0; i < packets; ++i) {
2382 const int layer_id = (int)stats[i].spatial_layer_id;
2383 if (layer_id >= 0 && layer_id < oxcf->ss_number_layers &&
2384 stats_copy[layer_id] != NULL) {
2385 *stats_copy[layer_id] = stats[i];
2386 ++stats_copy[layer_id];
2390 vp9_init_second_pass_spatial_svc(cpi);
2392 #if CONFIG_FP_MB_STATS
2393 if (cpi->use_fp_mb_stats) {
2394 const size_t psz = cpi->common.MBs * sizeof(uint8_t);
2395 const int ps = (int)(oxcf->firstpass_mb_stats_in.sz / psz);
2397 cpi->twopass.firstpass_mb_stats.mb_stats_start =
2398 oxcf->firstpass_mb_stats_in.buf;
2399 cpi->twopass.firstpass_mb_stats.mb_stats_end =
2400 cpi->twopass.firstpass_mb_stats.mb_stats_start +
2401 (ps - 1) * cpi->common.MBs * sizeof(uint8_t);
2405 cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf;
2406 cpi->twopass.stats_in = cpi->twopass.stats_in_start;
2407 cpi->twopass.stats_in_end = &cpi->twopass.stats_in[packets - 1];
2409 vp9_init_second_pass(cpi);
2412 #endif // !CONFIG_REALTIME_ONLY
2414 cpi->mb_wiener_var_cols = 0;
2415 cpi->mb_wiener_var_rows = 0;
2416 cpi->mb_wiener_variance = NULL;
2418 vp9_set_speed_features_framesize_independent(cpi, oxcf->speed);
2419 vp9_set_speed_features_framesize_dependent(cpi, oxcf->speed);
2422 const int bsize = BLOCK_16X16;
2423 const int w = num_8x8_blocks_wide_lookup[bsize];
2424 const int h = num_8x8_blocks_high_lookup[bsize];
2425 const int num_cols = (cm->mi_cols + w - 1) / w;
2426 const int num_rows = (cm->mi_rows + h - 1) / h;
2427 CHECK_MEM_ERROR(cm, cpi->mi_ssim_rdmult_scaling_factors,
2428 vpx_calloc(num_rows * num_cols,
2429 sizeof(*cpi->mi_ssim_rdmult_scaling_factors)));
2432 cpi->kmeans_data_arr_alloc = 0;
2433 #if CONFIG_NON_GREEDY_MV
2434 cpi->feature_score_loc_alloc = 0;
2436 #endif // CONFIG_NON_GREEDY_MV
2437 for (i = 0; i < MAX_ARF_GOP_SIZE; ++i) cpi->tpl_stats[i].tpl_stats_ptr = NULL;
2439 // Allocate memory to store variances for a frame.
2440 CHECK_MEM_ERROR(cm, cpi->source_diff_var, vpx_calloc(cm->MBs, sizeof(diff)));
2441 cpi->source_var_thresh = 0;
2442 cpi->frames_till_next_var_check = 0;
2443 #define BFP(BT, SDF, SDAF, VF, SVF, SVAF, SDX4DF, SDX8F) \
2444 cpi->fn_ptr[BT].sdf = SDF; \
2445 cpi->fn_ptr[BT].sdaf = SDAF; \
2446 cpi->fn_ptr[BT].vf = VF; \
2447 cpi->fn_ptr[BT].svf = SVF; \
2448 cpi->fn_ptr[BT].svaf = SVAF; \
2449 cpi->fn_ptr[BT].sdx4df = SDX4DF; \
2450 cpi->fn_ptr[BT].sdx8f = SDX8F;
2452 // TODO(angiebird): make sdx8f available for every block size
2453 BFP(BLOCK_32X16, vpx_sad32x16, vpx_sad32x16_avg, vpx_variance32x16,
2454 vpx_sub_pixel_variance32x16, vpx_sub_pixel_avg_variance32x16,
2455 vpx_sad32x16x4d, NULL)
2457 BFP(BLOCK_16X32, vpx_sad16x32, vpx_sad16x32_avg, vpx_variance16x32,
2458 vpx_sub_pixel_variance16x32, vpx_sub_pixel_avg_variance16x32,
2459 vpx_sad16x32x4d, NULL)
2461 BFP(BLOCK_64X32, vpx_sad64x32, vpx_sad64x32_avg, vpx_variance64x32,
2462 vpx_sub_pixel_variance64x32, vpx_sub_pixel_avg_variance64x32,
2463 vpx_sad64x32x4d, NULL)
2465 BFP(BLOCK_32X64, vpx_sad32x64, vpx_sad32x64_avg, vpx_variance32x64,
2466 vpx_sub_pixel_variance32x64, vpx_sub_pixel_avg_variance32x64,
2467 vpx_sad32x64x4d, NULL)
2469 BFP(BLOCK_32X32, vpx_sad32x32, vpx_sad32x32_avg, vpx_variance32x32,
2470 vpx_sub_pixel_variance32x32, vpx_sub_pixel_avg_variance32x32,
2471 vpx_sad32x32x4d, vpx_sad32x32x8)
2473 BFP(BLOCK_64X64, vpx_sad64x64, vpx_sad64x64_avg, vpx_variance64x64,
2474 vpx_sub_pixel_variance64x64, vpx_sub_pixel_avg_variance64x64,
2475 vpx_sad64x64x4d, NULL)
2477 BFP(BLOCK_16X16, vpx_sad16x16, vpx_sad16x16_avg, vpx_variance16x16,
2478 vpx_sub_pixel_variance16x16, vpx_sub_pixel_avg_variance16x16,
2479 vpx_sad16x16x4d, vpx_sad16x16x8)
2481 BFP(BLOCK_16X8, vpx_sad16x8, vpx_sad16x8_avg, vpx_variance16x8,
2482 vpx_sub_pixel_variance16x8, vpx_sub_pixel_avg_variance16x8,
2483 vpx_sad16x8x4d, vpx_sad16x8x8)
2485 BFP(BLOCK_8X16, vpx_sad8x16, vpx_sad8x16_avg, vpx_variance8x16,
2486 vpx_sub_pixel_variance8x16, vpx_sub_pixel_avg_variance8x16,
2487 vpx_sad8x16x4d, vpx_sad8x16x8)
2489 BFP(BLOCK_8X8, vpx_sad8x8, vpx_sad8x8_avg, vpx_variance8x8,
2490 vpx_sub_pixel_variance8x8, vpx_sub_pixel_avg_variance8x8, vpx_sad8x8x4d,
2493 BFP(BLOCK_8X4, vpx_sad8x4, vpx_sad8x4_avg, vpx_variance8x4,
2494 vpx_sub_pixel_variance8x4, vpx_sub_pixel_avg_variance8x4, vpx_sad8x4x4d,
2497 BFP(BLOCK_4X8, vpx_sad4x8, vpx_sad4x8_avg, vpx_variance4x8,
2498 vpx_sub_pixel_variance4x8, vpx_sub_pixel_avg_variance4x8, vpx_sad4x8x4d,
2501 BFP(BLOCK_4X4, vpx_sad4x4, vpx_sad4x4_avg, vpx_variance4x4,
2502 vpx_sub_pixel_variance4x4, vpx_sub_pixel_avg_variance4x4, vpx_sad4x4x4d,
2505 #if CONFIG_VP9_HIGHBITDEPTH
2506 highbd_set_var_fns(cpi);
2509 /* vp9_init_quantizer() is first called here. Add check in
2510 * vp9_frame_init_quantizer() so that vp9_init_quantizer is only
2511 * called later when needed. This will avoid unnecessary calls of
2512 * vp9_init_quantizer() for every frame.
2514 vp9_init_quantizer(cpi);
2516 vp9_loop_filter_init(cm);
2518 // Set up the unit scaling factor used during motion search.
2519 #if CONFIG_VP9_HIGHBITDEPTH
2520 vp9_setup_scale_factors_for_frame(&cpi->me_sf, cm->width, cm->height,
2521 cm->width, cm->height,
2522 cm->use_highbitdepth);
2524 vp9_setup_scale_factors_for_frame(&cpi->me_sf, cm->width, cm->height,
2525 cm->width, cm->height);
2526 #endif // CONFIG_VP9_HIGHBITDEPTH
2527 cpi->td.mb.me_sf = &cpi->me_sf;
2529 cm->error.setjmp = 0;
2534 #if CONFIG_INTERNAL_STATS
2535 #define SNPRINT(H, T) snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T))
2537 #define SNPRINT2(H, T, V) \
2538 snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T), (V))
2539 #endif // CONFIG_INTERNAL_STATS
2541 static void free_tpl_buffer(VP9_COMP *cpi);
2543 void vp9_remove_compressor(VP9_COMP *cpi) {
2550 #if CONFIG_INTERNAL_STATS
2551 vpx_free(cpi->ssim_vars);
2555 if (cm->current_video_frame > 0) {
2556 #if CONFIG_INTERNAL_STATS
2557 vpx_clear_system_state();
2559 if (cpi->oxcf.pass != 1) {
2560 char headings[512] = { 0 };
2561 char results[512] = { 0 };
2562 FILE *f = fopen("opsnr.stt", "a");
2563 double time_encoded =
2564 (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) /
2566 double total_encode_time =
2567 (cpi->time_receive_data + cpi->time_compress_data) / 1000.000;
2569 (double)cpi->bytes * (double)8 / (double)1000 / time_encoded;
2570 const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1);
2571 const double target_rate = (double)cpi->oxcf.target_bandwidth / 1000;
2572 const double rate_err = ((100.0 * (dr - target_rate)) / target_rate);
2574 if (cpi->b_calculate_psnr) {
2575 const double total_psnr = vpx_sse_to_psnr(
2576 (double)cpi->total_samples, peak, (double)cpi->total_sq_error);
2577 const double totalp_psnr = vpx_sse_to_psnr(
2578 (double)cpi->totalp_samples, peak, (double)cpi->totalp_sq_error);
2579 const double total_ssim =
2580 100 * pow(cpi->summed_quality / cpi->summed_weights, 8.0);
2581 const double totalp_ssim =
2582 100 * pow(cpi->summedp_quality / cpi->summedp_weights, 8.0);
2584 snprintf(headings, sizeof(headings),
2585 "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\t"
2586 "VPXSSIM\tVPSSIMP\tFASTSIM\tPSNRHVS\t"
2587 "WstPsnr\tWstSsim\tWstFast\tWstHVS\t"
2588 "AVPsnrY\tAPsnrCb\tAPsnrCr");
2589 snprintf(results, sizeof(results),
2590 "%7.2f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2591 "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2592 "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2593 "%7.3f\t%7.3f\t%7.3f",
2594 dr, cpi->psnr.stat[ALL] / cpi->count, total_psnr,
2595 cpi->psnrp.stat[ALL] / cpi->count, totalp_psnr, total_ssim,
2596 totalp_ssim, cpi->fastssim.stat[ALL] / cpi->count,
2597 cpi->psnrhvs.stat[ALL] / cpi->count, cpi->psnr.worst,
2598 cpi->worst_ssim, cpi->fastssim.worst, cpi->psnrhvs.worst,
2599 cpi->psnr.stat[Y] / cpi->count, cpi->psnr.stat[U] / cpi->count,
2600 cpi->psnr.stat[V] / cpi->count);
2602 if (cpi->b_calculate_blockiness) {
2603 SNPRINT(headings, "\t Block\tWstBlck");
2604 SNPRINT2(results, "\t%7.3f", cpi->total_blockiness / cpi->count);
2605 SNPRINT2(results, "\t%7.3f", cpi->worst_blockiness);
2608 if (cpi->b_calculate_consistency) {
2609 double consistency =
2610 vpx_sse_to_psnr((double)cpi->totalp_samples, peak,
2611 (double)cpi->total_inconsistency);
2613 SNPRINT(headings, "\tConsist\tWstCons");
2614 SNPRINT2(results, "\t%7.3f", consistency);
2615 SNPRINT2(results, "\t%7.3f", cpi->worst_consistency);
2618 SNPRINT(headings, "\t Time\tRcErr\tAbsErr");
2619 SNPRINT2(results, "\t%8.0f", total_encode_time);
2620 SNPRINT2(results, "\t%7.2f", rate_err);
2621 SNPRINT2(results, "\t%7.2f", fabs(rate_err));
2623 fprintf(f, "%s\tAPsnr611\n", headings);
2625 f, "%s\t%7.3f\n", results,
2626 (6 * cpi->psnr.stat[Y] + cpi->psnr.stat[U] + cpi->psnr.stat[V]) /
2636 printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000);
2637 printf("\n_frames recive_data encod_mb_row compress_frame Total\n");
2638 printf("%6d %10ld %10ld %10ld %10ld\n", cpi->common.current_video_frame,
2639 cpi->time_receive_data / 1000, cpi->time_encode_sb_row / 1000,
2640 cpi->time_compress_data / 1000,
2641 (cpi->time_receive_data + cpi->time_compress_data) / 1000);
2646 #if CONFIG_VP9_TEMPORAL_DENOISING
2647 vp9_denoiser_free(&(cpi->denoiser));
2650 if (cpi->kmeans_data_arr_alloc) {
2651 #if CONFIG_MULTITHREAD
2652 pthread_mutex_destroy(&cpi->kmeans_mutex);
2654 vpx_free(cpi->kmeans_data_arr);
2657 free_tpl_buffer(cpi);
2659 for (t = 0; t < cpi->num_workers; ++t) {
2660 VPxWorker *const worker = &cpi->workers[t];
2661 EncWorkerData *const thread_data = &cpi->tile_thr_data[t];
2663 // Deallocate allocated threads.
2664 vpx_get_worker_interface()->end(worker);
2666 // Deallocate allocated thread data.
2667 if (t < cpi->num_workers - 1) {
2668 vpx_free(thread_data->td->counts);
2669 vp9_free_pc_tree(thread_data->td);
2670 vpx_free(thread_data->td);
2673 vpx_free(cpi->tile_thr_data);
2674 vpx_free(cpi->workers);
2675 vp9_row_mt_mem_dealloc(cpi);
2677 if (cpi->num_workers > 1) {
2678 vp9_loop_filter_dealloc(&cpi->lf_row_sync);
2679 vp9_bitstream_encode_tiles_buffer_dealloc(cpi);
2682 #if !CONFIG_REALTIME_ONLY
2683 vp9_alt_ref_aq_destroy(cpi->alt_ref_aq);
2686 dealloc_compressor_data(cpi);
2688 for (i = 0; i < sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]);
2690 vpx_free(cpi->mbgraph_stats[i].mb_stats);
2693 #if CONFIG_FP_MB_STATS
2694 if (cpi->use_fp_mb_stats) {
2695 vpx_free(cpi->twopass.frame_mb_stats_buf);
2696 cpi->twopass.frame_mb_stats_buf = NULL;
2700 vp9_remove_common(cm);
2701 vp9_free_ref_frame_buffers(cm->buffer_pool);
2702 #if CONFIG_VP9_POSTPROC
2703 vp9_free_postproc_buffers(cm);
2707 #if CONFIG_VP9_TEMPORAL_DENOISING
2708 #ifdef OUTPUT_YUV_DENOISED
2709 fclose(yuv_denoised_file);
2712 #ifdef OUTPUT_YUV_SKINMAP
2713 fclose(yuv_skinmap_file);
2715 #ifdef OUTPUT_YUV_REC
2716 fclose(yuv_rec_file);
2718 #ifdef OUTPUT_YUV_SVC_SRC
2719 fclose(yuv_svc_src[0]);
2720 fclose(yuv_svc_src[1]);
2721 fclose(yuv_svc_src[2]);
2738 static void generate_psnr_packet(VP9_COMP *cpi) {
2739 struct vpx_codec_cx_pkt pkt;
2742 #if CONFIG_VP9_HIGHBITDEPTH
2743 vpx_calc_highbd_psnr(cpi->raw_source_frame, cpi->common.frame_to_show, &psnr,
2744 cpi->td.mb.e_mbd.bd, cpi->oxcf.input_bit_depth);
2746 vpx_calc_psnr(cpi->raw_source_frame, cpi->common.frame_to_show, &psnr);
2749 for (i = 0; i < 4; ++i) {
2750 pkt.data.psnr.samples[i] = psnr.samples[i];
2751 pkt.data.psnr.sse[i] = psnr.sse[i];
2752 pkt.data.psnr.psnr[i] = psnr.psnr[i];
2754 pkt.kind = VPX_CODEC_PSNR_PKT;
2757 .layer_context[cpi->svc.spatial_layer_id *
2758 cpi->svc.number_temporal_layers]
2759 .psnr_pkt = pkt.data.psnr;
2761 vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
2764 int vp9_use_as_reference(VP9_COMP *cpi, int ref_frame_flags) {
2765 if (ref_frame_flags > 7) return -1;
2767 cpi->ref_frame_flags = ref_frame_flags;
2771 void vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags) {
2772 cpi->ext_refresh_golden_frame = (ref_frame_flags & VP9_GOLD_FLAG) != 0;
2773 cpi->ext_refresh_alt_ref_frame = (ref_frame_flags & VP9_ALT_FLAG) != 0;
2774 cpi->ext_refresh_last_frame = (ref_frame_flags & VP9_LAST_FLAG) != 0;
2775 cpi->ext_refresh_frame_flags_pending = 1;
2778 static YV12_BUFFER_CONFIG *get_vp9_ref_frame_buffer(
2779 VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag) {
2780 MV_REFERENCE_FRAME ref_frame = NONE;
2781 if (ref_frame_flag == VP9_LAST_FLAG)
2782 ref_frame = LAST_FRAME;
2783 else if (ref_frame_flag == VP9_GOLD_FLAG)
2784 ref_frame = GOLDEN_FRAME;
2785 else if (ref_frame_flag == VP9_ALT_FLAG)
2786 ref_frame = ALTREF_FRAME;
2788 return ref_frame == NONE ? NULL : get_ref_frame_buffer(cpi, ref_frame);
2791 int vp9_copy_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
2792 YV12_BUFFER_CONFIG *sd) {
2793 YV12_BUFFER_CONFIG *cfg = get_vp9_ref_frame_buffer(cpi, ref_frame_flag);
2795 vpx_yv12_copy_frame(cfg, sd);
2802 int vp9_set_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
2803 YV12_BUFFER_CONFIG *sd) {
2804 YV12_BUFFER_CONFIG *cfg = get_vp9_ref_frame_buffer(cpi, ref_frame_flag);
2806 vpx_yv12_copy_frame(sd, cfg);
2813 int vp9_update_entropy(VP9_COMP *cpi, int update) {
2814 cpi->ext_refresh_frame_context = update;
2815 cpi->ext_refresh_frame_context_pending = 1;
2819 #ifdef OUTPUT_YUV_REC
2820 void vp9_write_yuv_rec_frame(VP9_COMMON *cm) {
2821 YV12_BUFFER_CONFIG *s = cm->frame_to_show;
2822 uint8_t *src = s->y_buffer;
2825 #if CONFIG_VP9_HIGHBITDEPTH
2826 if (s->flags & YV12_FLAG_HIGHBITDEPTH) {
2827 uint16_t *src16 = CONVERT_TO_SHORTPTR(s->y_buffer);
2830 fwrite(src16, s->y_width, 2, yuv_rec_file);
2831 src16 += s->y_stride;
2834 src16 = CONVERT_TO_SHORTPTR(s->u_buffer);
2838 fwrite(src16, s->uv_width, 2, yuv_rec_file);
2839 src16 += s->uv_stride;
2842 src16 = CONVERT_TO_SHORTPTR(s->v_buffer);
2846 fwrite(src16, s->uv_width, 2, yuv_rec_file);
2847 src16 += s->uv_stride;
2850 fflush(yuv_rec_file);
2853 #endif // CONFIG_VP9_HIGHBITDEPTH
2856 fwrite(src, s->y_width, 1, yuv_rec_file);
2864 fwrite(src, s->uv_width, 1, yuv_rec_file);
2865 src += s->uv_stride;
2872 fwrite(src, s->uv_width, 1, yuv_rec_file);
2873 src += s->uv_stride;
2876 fflush(yuv_rec_file);
2880 #if CONFIG_VP9_HIGHBITDEPTH
2881 static void scale_and_extend_frame_nonnormative(const YV12_BUFFER_CONFIG *src,
2882 YV12_BUFFER_CONFIG *dst,
2885 static void scale_and_extend_frame_nonnormative(const YV12_BUFFER_CONFIG *src,
2886 YV12_BUFFER_CONFIG *dst) {
2887 #endif // CONFIG_VP9_HIGHBITDEPTH
2888 // TODO(dkovalev): replace YV12_BUFFER_CONFIG with vpx_image_t
2890 const uint8_t *const srcs[3] = { src->y_buffer, src->u_buffer,
2892 const int src_strides[3] = { src->y_stride, src->uv_stride, src->uv_stride };
2893 const int src_widths[3] = { src->y_crop_width, src->uv_crop_width,
2894 src->uv_crop_width };
2895 const int src_heights[3] = { src->y_crop_height, src->uv_crop_height,
2896 src->uv_crop_height };
2897 uint8_t *const dsts[3] = { dst->y_buffer, dst->u_buffer, dst->v_buffer };
2898 const int dst_strides[3] = { dst->y_stride, dst->uv_stride, dst->uv_stride };
2899 const int dst_widths[3] = { dst->y_crop_width, dst->uv_crop_width,
2900 dst->uv_crop_width };
2901 const int dst_heights[3] = { dst->y_crop_height, dst->uv_crop_height,
2902 dst->uv_crop_height };
2904 for (i = 0; i < MAX_MB_PLANE; ++i) {
2905 #if CONFIG_VP9_HIGHBITDEPTH
2906 if (src->flags & YV12_FLAG_HIGHBITDEPTH) {
2907 vp9_highbd_resize_plane(srcs[i], src_heights[i], src_widths[i],
2908 src_strides[i], dsts[i], dst_heights[i],
2909 dst_widths[i], dst_strides[i], bd);
2911 vp9_resize_plane(srcs[i], src_heights[i], src_widths[i], src_strides[i],
2912 dsts[i], dst_heights[i], dst_widths[i], dst_strides[i]);
2915 vp9_resize_plane(srcs[i], src_heights[i], src_widths[i], src_strides[i],
2916 dsts[i], dst_heights[i], dst_widths[i], dst_strides[i]);
2917 #endif // CONFIG_VP9_HIGHBITDEPTH
2919 vpx_extend_frame_borders(dst);
2922 #if CONFIG_VP9_HIGHBITDEPTH
2923 static void scale_and_extend_frame(const YV12_BUFFER_CONFIG *src,
2924 YV12_BUFFER_CONFIG *dst, int bd,
2925 INTERP_FILTER filter_type,
2927 const int src_w = src->y_crop_width;
2928 const int src_h = src->y_crop_height;
2929 const int dst_w = dst->y_crop_width;
2930 const int dst_h = dst->y_crop_height;
2931 const uint8_t *const srcs[3] = { src->y_buffer, src->u_buffer,
2933 const int src_strides[3] = { src->y_stride, src->uv_stride, src->uv_stride };
2934 uint8_t *const dsts[3] = { dst->y_buffer, dst->u_buffer, dst->v_buffer };
2935 const int dst_strides[3] = { dst->y_stride, dst->uv_stride, dst->uv_stride };
2936 const InterpKernel *const kernel = vp9_filter_kernels[filter_type];
2939 for (i = 0; i < MAX_MB_PLANE; ++i) {
2940 const int factor = (i == 0 || i == 3 ? 1 : 2);
2941 const int src_stride = src_strides[i];
2942 const int dst_stride = dst_strides[i];
2943 for (y = 0; y < dst_h; y += 16) {
2944 const int y_q4 = y * (16 / factor) * src_h / dst_h + phase_scaler;
2945 for (x = 0; x < dst_w; x += 16) {
2946 const int x_q4 = x * (16 / factor) * src_w / dst_w + phase_scaler;
2947 const uint8_t *src_ptr = srcs[i] +
2948 (y / factor) * src_h / dst_h * src_stride +
2949 (x / factor) * src_w / dst_w;
2950 uint8_t *dst_ptr = dsts[i] + (y / factor) * dst_stride + (x / factor);
2952 if (src->flags & YV12_FLAG_HIGHBITDEPTH) {
2953 vpx_highbd_convolve8(CONVERT_TO_SHORTPTR(src_ptr), src_stride,
2954 CONVERT_TO_SHORTPTR(dst_ptr), dst_stride, kernel,
2955 x_q4 & 0xf, 16 * src_w / dst_w, y_q4 & 0xf,
2956 16 * src_h / dst_h, 16 / factor, 16 / factor,
2959 vpx_scaled_2d(src_ptr, src_stride, dst_ptr, dst_stride, kernel,
2960 x_q4 & 0xf, 16 * src_w / dst_w, y_q4 & 0xf,
2961 16 * src_h / dst_h, 16 / factor, 16 / factor);
2967 vpx_extend_frame_borders(dst);
2969 #endif // CONFIG_VP9_HIGHBITDEPTH
2971 #if !CONFIG_REALTIME_ONLY
2972 static int scale_down(VP9_COMP *cpi, int q) {
2973 RATE_CONTROL *const rc = &cpi->rc;
2974 GF_GROUP *const gf_group = &cpi->twopass.gf_group;
2976 assert(frame_is_kf_gf_arf(cpi));
2978 if (rc->frame_size_selector == UNSCALED &&
2979 q >= rc->rf_level_maxq[gf_group->rf_level[gf_group->index]]) {
2980 const int max_size_thresh =
2981 (int)(rate_thresh_mult[SCALE_STEP1] *
2982 VPXMAX(rc->this_frame_target, rc->avg_frame_bandwidth));
2983 scale = rc->projected_frame_size > max_size_thresh ? 1 : 0;
2988 static int big_rate_miss_high_threshold(VP9_COMP *cpi) {
2989 const RATE_CONTROL *const rc = &cpi->rc;
2992 if (frame_is_kf_gf_arf(cpi))
2993 big_miss_high = rc->this_frame_target * 3 / 2;
2995 big_miss_high = rc->this_frame_target * 2;
2997 return big_miss_high;
3000 static int big_rate_miss(VP9_COMP *cpi) {
3001 const RATE_CONTROL *const rc = &cpi->rc;
3005 // Ignore for overlay frames
3006 if (rc->is_src_frame_alt_ref) {
3009 big_miss_low = (rc->this_frame_target / 2);
3010 big_miss_high = big_rate_miss_high_threshold(cpi);
3012 return (rc->projected_frame_size > big_miss_high) ||
3013 (rc->projected_frame_size < big_miss_low);
3017 // test in two pass for the first
3018 static int two_pass_first_group_inter(VP9_COMP *cpi) {
3019 if (cpi->oxcf.pass == 2) {
3020 TWO_PASS *const twopass = &cpi->twopass;
3021 GF_GROUP *const gf_group = &twopass->gf_group;
3022 const int gfg_index = gf_group->index;
3024 if (gfg_index == 0) return gf_group->update_type[gfg_index] == LF_UPDATE;
3025 return gf_group->update_type[gfg_index - 1] != LF_UPDATE &&
3026 gf_group->update_type[gfg_index] == LF_UPDATE;
3032 // Function to test for conditions that indicate we should loop
3033 // back and recode a frame.
3034 static int recode_loop_test(VP9_COMP *cpi, int high_limit, int low_limit, int q,
3035 int maxq, int minq) {
3036 const RATE_CONTROL *const rc = &cpi->rc;
3037 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
3038 const int frame_is_kfgfarf = frame_is_kf_gf_arf(cpi);
3039 int force_recode = 0;
3041 if ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
3042 big_rate_miss(cpi) || (cpi->sf.recode_loop == ALLOW_RECODE) ||
3043 (two_pass_first_group_inter(cpi) &&
3044 (cpi->sf.recode_loop == ALLOW_RECODE_FIRST)) ||
3045 (frame_is_kfgfarf && (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF))) {
3046 if (frame_is_kfgfarf && (oxcf->resize_mode == RESIZE_DYNAMIC) &&
3047 scale_down(cpi, q)) {
3048 // Code this group at a lower resolution.
3049 cpi->resize_pending = 1;
3053 // Force recode for extreme overshoot.
3054 if ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
3055 (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF &&
3056 rc->projected_frame_size >= big_rate_miss_high_threshold(cpi))) {
3060 // TODO(agrange) high_limit could be greater than the scale-down threshold.
3061 if ((rc->projected_frame_size > high_limit && q < maxq) ||
3062 (rc->projected_frame_size < low_limit && q > minq)) {
3064 } else if (cpi->oxcf.rc_mode == VPX_CQ) {
3065 // Deal with frame undershoot and whether or not we are
3066 // below the automatically set cq level.
3067 if (q > oxcf->cq_level &&
3068 rc->projected_frame_size < ((rc->this_frame_target * 7) >> 3)) {
3073 return force_recode;
3075 #endif // !CONFIG_REALTIME_ONLY
3077 static void update_ref_frames(VP9_COMP *cpi) {
3078 VP9_COMMON *const cm = &cpi->common;
3079 BufferPool *const pool = cm->buffer_pool;
3080 GF_GROUP *const gf_group = &cpi->twopass.gf_group;
3082 if (cpi->rc.show_arf_as_gld) {
3083 int tmp = cpi->alt_fb_idx;
3084 cpi->alt_fb_idx = cpi->gld_fb_idx;
3085 cpi->gld_fb_idx = tmp;
3086 } else if (cm->show_existing_frame) {
3088 cpi->lst_fb_idx = cpi->alt_fb_idx;
3090 stack_pop(gf_group->arf_index_stack, gf_group->stack_size);
3091 --gf_group->stack_size;
3094 // At this point the new frame has been encoded.
3095 // If any buffer copy / swapping is signaled it should be done here.
3096 if (cm->frame_type == KEY_FRAME) {
3097 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
3099 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->alt_fb_idx],
3101 } else if (vp9_preserve_existing_gf(cpi)) {
3102 // We have decided to preserve the previously existing golden frame as our
3103 // new ARF frame. However, in the short term in function
3104 // vp9_get_refresh_mask() we left it in the GF slot and, if
3105 // we're updating the GF with the current decoded frame, we save it to the
3106 // ARF slot instead.
3107 // We now have to update the ARF with the current frame and swap gld_fb_idx
3108 // and alt_fb_idx so that, overall, we've stored the old GF in the new ARF
3109 // slot and, if we're updating the GF, the current frame becomes the new GF.
3112 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->alt_fb_idx],
3115 tmp = cpi->alt_fb_idx;
3116 cpi->alt_fb_idx = cpi->gld_fb_idx;
3117 cpi->gld_fb_idx = tmp;
3118 } else { /* For non key/golden frames */
3119 if (cpi->refresh_alt_ref_frame) {
3120 int arf_idx = gf_group->top_arf_idx;
3122 // Push new ARF into stack.
3123 stack_push(gf_group->arf_index_stack, cpi->alt_fb_idx,
3124 gf_group->stack_size);
3125 ++gf_group->stack_size;
3127 assert(arf_idx < REF_FRAMES);
3129 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[arf_idx], cm->new_fb_idx);
3130 memcpy(cpi->interp_filter_selected[ALTREF_FRAME],
3131 cpi->interp_filter_selected[0],
3132 sizeof(cpi->interp_filter_selected[0]));
3134 cpi->alt_fb_idx = arf_idx;
3137 if (cpi->refresh_golden_frame) {
3138 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
3140 if (!cpi->rc.is_src_frame_alt_ref)
3141 memcpy(cpi->interp_filter_selected[GOLDEN_FRAME],
3142 cpi->interp_filter_selected[0],
3143 sizeof(cpi->interp_filter_selected[0]));
3145 memcpy(cpi->interp_filter_selected[GOLDEN_FRAME],
3146 cpi->interp_filter_selected[ALTREF_FRAME],
3147 sizeof(cpi->interp_filter_selected[ALTREF_FRAME]));
3151 if (cpi->refresh_last_frame) {
3152 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->lst_fb_idx],
3154 if (!cpi->rc.is_src_frame_alt_ref)
3155 memcpy(cpi->interp_filter_selected[LAST_FRAME],
3156 cpi->interp_filter_selected[0],
3157 sizeof(cpi->interp_filter_selected[0]));
3160 if (gf_group->update_type[gf_group->index] == MID_OVERLAY_UPDATE) {
3162 stack_pop(gf_group->arf_index_stack, gf_group->stack_size);
3163 --gf_group->stack_size;
3167 void vp9_update_reference_frames(VP9_COMP *cpi) {
3168 update_ref_frames(cpi);
3170 #if CONFIG_VP9_TEMPORAL_DENOISING
3171 vp9_denoiser_update_ref_frame(cpi);
3174 if (is_one_pass_cbr_svc(cpi)) vp9_svc_update_ref_frame(cpi);
3177 static void loopfilter_frame(VP9_COMP *cpi, VP9_COMMON *cm) {
3178 MACROBLOCKD *xd = &cpi->td.mb.e_mbd;
3179 struct loopfilter *lf = &cm->lf;
3180 int is_reference_frame =
3181 (cm->frame_type == KEY_FRAME || cpi->refresh_last_frame ||
3182 cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame);
3184 cpi->svc.temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS)
3185 is_reference_frame = !cpi->svc.non_reference_frame;
3187 // Skip loop filter in show_existing_frame mode.
3188 if (cm->show_existing_frame) {
3189 lf->filter_level = 0;
3194 lf->filter_level = 0;
3195 lf->last_filt_level = 0;
3197 struct vpx_usec_timer timer;
3199 vpx_clear_system_state();
3201 vpx_usec_timer_start(&timer);
3203 if (!cpi->rc.is_src_frame_alt_ref) {
3204 if ((cpi->common.frame_type == KEY_FRAME) &&
3205 (!cpi->rc.this_key_frame_forced)) {
3206 lf->last_filt_level = 0;
3208 vp9_pick_filter_level(cpi->Source, cpi, cpi->sf.lpf_pick);
3209 lf->last_filt_level = lf->filter_level;
3211 lf->filter_level = 0;
3214 vpx_usec_timer_mark(&timer);
3215 cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
3218 if (lf->filter_level > 0 && is_reference_frame) {
3219 vp9_build_mask_frame(cm, lf->filter_level, 0);
3221 if (cpi->num_workers > 1)
3222 vp9_loop_filter_frame_mt(cm->frame_to_show, cm, xd->plane,
3223 lf->filter_level, 0, 0, cpi->workers,
3224 cpi->num_workers, &cpi->lf_row_sync);
3226 vp9_loop_filter_frame(cm->frame_to_show, cm, xd, lf->filter_level, 0, 0);
3229 vpx_extend_frame_inner_borders(cm->frame_to_show);
3232 static INLINE void alloc_frame_mvs(VP9_COMMON *const cm, int buffer_idx) {
3233 RefCntBuffer *const new_fb_ptr = &cm->buffer_pool->frame_bufs[buffer_idx];
3234 if (new_fb_ptr->mvs == NULL || new_fb_ptr->mi_rows < cm->mi_rows ||
3235 new_fb_ptr->mi_cols < cm->mi_cols) {
3236 vpx_free(new_fb_ptr->mvs);
3237 CHECK_MEM_ERROR(cm, new_fb_ptr->mvs,
3238 (MV_REF *)vpx_calloc(cm->mi_rows * cm->mi_cols,
3239 sizeof(*new_fb_ptr->mvs)));
3240 new_fb_ptr->mi_rows = cm->mi_rows;
3241 new_fb_ptr->mi_cols = cm->mi_cols;
3245 void vp9_scale_references(VP9_COMP *cpi) {
3246 VP9_COMMON *cm = &cpi->common;
3247 MV_REFERENCE_FRAME ref_frame;
3248 const VP9_REFFRAME ref_mask[3] = { VP9_LAST_FLAG, VP9_GOLD_FLAG,
3251 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3252 // Need to convert from VP9_REFFRAME to index into ref_mask (subtract 1).
3253 if (cpi->ref_frame_flags & ref_mask[ref_frame - 1]) {
3254 BufferPool *const pool = cm->buffer_pool;
3255 const YV12_BUFFER_CONFIG *const ref =
3256 get_ref_frame_buffer(cpi, ref_frame);
3259 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3263 #if CONFIG_VP9_HIGHBITDEPTH
3264 if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) {
3265 RefCntBuffer *new_fb_ptr = NULL;
3266 int force_scaling = 0;
3267 int new_fb = cpi->scaled_ref_idx[ref_frame - 1];
3268 if (new_fb == INVALID_IDX) {
3269 new_fb = get_free_fb(cm);
3272 if (new_fb == INVALID_IDX) return;
3273 new_fb_ptr = &pool->frame_bufs[new_fb];
3274 if (force_scaling || new_fb_ptr->buf.y_crop_width != cm->width ||
3275 new_fb_ptr->buf.y_crop_height != cm->height) {
3276 if (vpx_realloc_frame_buffer(&new_fb_ptr->buf, cm->width, cm->height,
3277 cm->subsampling_x, cm->subsampling_y,
3278 cm->use_highbitdepth,
3279 VP9_ENC_BORDER_IN_PIXELS,
3280 cm->byte_alignment, NULL, NULL, NULL))
3281 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3282 "Failed to allocate frame buffer");
3283 scale_and_extend_frame(ref, &new_fb_ptr->buf, (int)cm->bit_depth,
3285 cpi->scaled_ref_idx[ref_frame - 1] = new_fb;
3286 alloc_frame_mvs(cm, new_fb);
3289 if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) {
3290 RefCntBuffer *new_fb_ptr = NULL;
3291 int force_scaling = 0;
3292 int new_fb = cpi->scaled_ref_idx[ref_frame - 1];
3293 if (new_fb == INVALID_IDX) {
3294 new_fb = get_free_fb(cm);
3297 if (new_fb == INVALID_IDX) return;
3298 new_fb_ptr = &pool->frame_bufs[new_fb];
3299 if (force_scaling || new_fb_ptr->buf.y_crop_width != cm->width ||
3300 new_fb_ptr->buf.y_crop_height != cm->height) {
3301 if (vpx_realloc_frame_buffer(&new_fb_ptr->buf, cm->width, cm->height,
3302 cm->subsampling_x, cm->subsampling_y,
3303 VP9_ENC_BORDER_IN_PIXELS,
3304 cm->byte_alignment, NULL, NULL, NULL))
3305 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3306 "Failed to allocate frame buffer");
3307 vp9_scale_and_extend_frame(ref, &new_fb_ptr->buf, EIGHTTAP, 0);
3308 cpi->scaled_ref_idx[ref_frame - 1] = new_fb;
3309 alloc_frame_mvs(cm, new_fb);
3311 #endif // CONFIG_VP9_HIGHBITDEPTH
3314 RefCntBuffer *buf = NULL;
3315 if (cpi->oxcf.pass == 0 && !cpi->use_svc) {
3316 // Check for release of scaled reference.
3317 buf_idx = cpi->scaled_ref_idx[ref_frame - 1];
3318 if (buf_idx != INVALID_IDX) {
3319 buf = &pool->frame_bufs[buf_idx];
3321 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3324 buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
3325 buf = &pool->frame_bufs[buf_idx];
3326 buf->buf.y_crop_width = ref->y_crop_width;
3327 buf->buf.y_crop_height = ref->y_crop_height;
3328 cpi->scaled_ref_idx[ref_frame - 1] = buf_idx;
3332 if (cpi->oxcf.pass != 0 || cpi->use_svc)
3333 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3338 static void release_scaled_references(VP9_COMP *cpi) {
3339 VP9_COMMON *cm = &cpi->common;
3341 if (cpi->oxcf.pass == 0 && !cpi->use_svc) {
3342 // Only release scaled references under certain conditions:
3343 // if reference will be updated, or if scaled reference has same resolution.
3345 refresh[0] = (cpi->refresh_last_frame) ? 1 : 0;
3346 refresh[1] = (cpi->refresh_golden_frame) ? 1 : 0;
3347 refresh[2] = (cpi->refresh_alt_ref_frame) ? 1 : 0;
3348 for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
3349 const int idx = cpi->scaled_ref_idx[i - 1];
3350 if (idx != INVALID_IDX) {
3351 RefCntBuffer *const buf = &cm->buffer_pool->frame_bufs[idx];
3352 const YV12_BUFFER_CONFIG *const ref = get_ref_frame_buffer(cpi, i);
3353 if (refresh[i - 1] || (buf->buf.y_crop_width == ref->y_crop_width &&
3354 buf->buf.y_crop_height == ref->y_crop_height)) {
3356 cpi->scaled_ref_idx[i - 1] = INVALID_IDX;
3361 for (i = 0; i < REFS_PER_FRAME; ++i) {
3362 const int idx = cpi->scaled_ref_idx[i];
3363 if (idx != INVALID_IDX) {
3364 RefCntBuffer *const buf = &cm->buffer_pool->frame_bufs[idx];
3366 cpi->scaled_ref_idx[i] = INVALID_IDX;
3372 static void full_to_model_count(unsigned int *model_count,
3373 unsigned int *full_count) {
3375 model_count[ZERO_TOKEN] = full_count[ZERO_TOKEN];
3376 model_count[ONE_TOKEN] = full_count[ONE_TOKEN];
3377 model_count[TWO_TOKEN] = full_count[TWO_TOKEN];
3378 for (n = THREE_TOKEN; n < EOB_TOKEN; ++n)
3379 model_count[TWO_TOKEN] += full_count[n];
3380 model_count[EOB_MODEL_TOKEN] = full_count[EOB_TOKEN];
3383 static void full_to_model_counts(vp9_coeff_count_model *model_count,
3384 vp9_coeff_count *full_count) {
3387 for (i = 0; i < PLANE_TYPES; ++i)
3388 for (j = 0; j < REF_TYPES; ++j)
3389 for (k = 0; k < COEF_BANDS; ++k)
3390 for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l)
3391 full_to_model_count(model_count[i][j][k][l], full_count[i][j][k][l]);
3394 #if 0 && CONFIG_INTERNAL_STATS
3395 static void output_frame_level_debug_stats(VP9_COMP *cpi) {
3396 VP9_COMMON *const cm = &cpi->common;
3397 FILE *const f = fopen("tmp.stt", cm->current_video_frame ? "a" : "w");
3400 vpx_clear_system_state();
3402 #if CONFIG_VP9_HIGHBITDEPTH
3403 if (cm->use_highbitdepth) {
3404 recon_err = vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3406 recon_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3409 recon_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3410 #endif // CONFIG_VP9_HIGHBITDEPTH
3413 if (cpi->twopass.total_left_stats.coded_error != 0.0) {
3414 double dc_quant_devisor;
3415 #if CONFIG_VP9_HIGHBITDEPTH
3416 switch (cm->bit_depth) {
3418 dc_quant_devisor = 4.0;
3421 dc_quant_devisor = 16.0;
3424 assert(cm->bit_depth == VPX_BITS_12);
3425 dc_quant_devisor = 64.0;
3429 dc_quant_devisor = 4.0;
3432 if (!cm->current_video_frame) {
3433 fprintf(f, "frame, width, height, last ts, last end ts, "
3434 "source_alt_ref_pending, source_alt_ref_active, "
3435 "this_frame_target, projected_frame_size, "
3436 "projected_frame_size / MBs, "
3437 "projected_frame_size - this_frame_target, "
3438 "vbr_bits_off_target, vbr_bits_off_target_fast, "
3439 "twopass.extend_minq, twopass.extend_minq_fast, "
3440 "total_target_vs_actual, "
3441 "starting_buffer_level - bits_off_target, "
3442 "total_actual_bits, base_qindex, q for base_qindex, "
3443 "dc quant, q for active_worst_quality, avg_q, q for oxcf.cq_level, "
3444 "refresh_last_frame, refresh_golden_frame, refresh_alt_ref_frame, "
3445 "frame_type, gfu_boost, "
3446 "twopass.bits_left, "
3447 "twopass.total_left_stats.coded_error, "
3448 "twopass.bits_left / (1 + twopass.total_left_stats.coded_error), "
3449 "tot_recode_hits, recon_err, kf_boost, "
3450 "twopass.kf_zeromotion_pct, twopass.fr_content_type, "
3451 "filter_level, seg.aq_av_offset\n");
3454 fprintf(f, "%10u, %d, %d, %10"PRId64", %10"PRId64", %d, %d, %10d, %10d, "
3455 "%10d, %10d, %10"PRId64", %10"PRId64", %5d, %5d, %10"PRId64", "
3456 "%10"PRId64", %10"PRId64", %10d, %7.2lf, %7.2lf, %7.2lf, %7.2lf, "
3457 "%7.2lf, %6d, %6d, %5d, %5d, %5d, %10"PRId64", %10.3lf, %10lf, %8u, "
3458 "%10"PRId64", %10d, %10d, %10d, %10d, %10d\n",
3459 cpi->common.current_video_frame,
3460 cm->width, cm->height,
3461 cpi->last_time_stamp_seen,
3462 cpi->last_end_time_stamp_seen,
3463 cpi->rc.source_alt_ref_pending,
3464 cpi->rc.source_alt_ref_active,
3465 cpi->rc.this_frame_target,
3466 cpi->rc.projected_frame_size,
3467 cpi->rc.projected_frame_size / cpi->common.MBs,
3468 (cpi->rc.projected_frame_size - cpi->rc.this_frame_target),
3469 cpi->rc.vbr_bits_off_target,
3470 cpi->rc.vbr_bits_off_target_fast,
3471 cpi->twopass.extend_minq,
3472 cpi->twopass.extend_minq_fast,
3473 cpi->rc.total_target_vs_actual,
3474 (cpi->rc.starting_buffer_level - cpi->rc.bits_off_target),
3475 cpi->rc.total_actual_bits, cm->base_qindex,
3476 vp9_convert_qindex_to_q(cm->base_qindex, cm->bit_depth),
3477 (double)vp9_dc_quant(cm->base_qindex, 0, cm->bit_depth) /
3479 vp9_convert_qindex_to_q(cpi->twopass.active_worst_quality,
3482 vp9_convert_qindex_to_q(cpi->oxcf.cq_level, cm->bit_depth),
3483 cpi->refresh_last_frame, cpi->refresh_golden_frame,
3484 cpi->refresh_alt_ref_frame, cm->frame_type, cpi->rc.gfu_boost,
3485 cpi->twopass.bits_left,
3486 cpi->twopass.total_left_stats.coded_error,
3487 cpi->twopass.bits_left /
3488 (1 + cpi->twopass.total_left_stats.coded_error),
3489 cpi->tot_recode_hits, recon_err, cpi->rc.kf_boost,
3490 cpi->twopass.kf_zeromotion_pct,
3491 cpi->twopass.fr_content_type,
3492 cm->lf.filter_level,
3493 cm->seg.aq_av_offset);
3498 FILE *const fmodes = fopen("Modes.stt", "a");
3501 fprintf(fmodes, "%6d:%1d:%1d:%1d ", cpi->common.current_video_frame,
3502 cm->frame_type, cpi->refresh_golden_frame,
3503 cpi->refresh_alt_ref_frame);
3505 for (i = 0; i < MAX_MODES; ++i)
3506 fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
3508 fprintf(fmodes, "\n");
3515 static void set_mv_search_params(VP9_COMP *cpi) {
3516 const VP9_COMMON *const cm = &cpi->common;
3517 const unsigned int max_mv_def = VPXMIN(cm->width, cm->height);
3519 // Default based on max resolution.
3520 cpi->mv_step_param = vp9_init_search_range(max_mv_def);
3522 if (cpi->sf.mv.auto_mv_step_size) {
3523 if (frame_is_intra_only(cm)) {
3524 // Initialize max_mv_magnitude for use in the first INTER frame
3525 // after a key/intra-only frame.
3526 cpi->max_mv_magnitude = max_mv_def;
3528 if (cm->show_frame) {
3529 // Allow mv_steps to correspond to twice the max mv magnitude found
3530 // in the previous frame, capped by the default max_mv_magnitude based
3532 cpi->mv_step_param = vp9_init_search_range(
3533 VPXMIN(max_mv_def, 2 * cpi->max_mv_magnitude));
3535 cpi->max_mv_magnitude = 0;
3540 static void set_size_independent_vars(VP9_COMP *cpi) {
3541 vp9_set_speed_features_framesize_independent(cpi, cpi->oxcf.speed);
3542 vp9_set_rd_speed_thresholds(cpi);
3543 vp9_set_rd_speed_thresholds_sub8x8(cpi);
3544 cpi->common.interp_filter = cpi->sf.default_interp_filter;
3547 static void set_size_dependent_vars(VP9_COMP *cpi, int *q, int *bottom_index,
3549 VP9_COMMON *const cm = &cpi->common;
3551 // Setup variables that depend on the dimensions of the frame.
3552 vp9_set_speed_features_framesize_dependent(cpi, cpi->oxcf.speed);
3554 // Decide q and q bounds.
3555 *q = vp9_rc_pick_q_and_bounds(cpi, bottom_index, top_index);
3557 if (cpi->oxcf.rc_mode == VPX_CBR && cpi->rc.force_max_q) {
3558 *q = cpi->rc.worst_quality;
3559 cpi->rc.force_max_q = 0;
3562 if (!frame_is_intra_only(cm)) {
3563 vp9_set_high_precision_mv(cpi, (*q) < HIGH_PRECISION_MV_QTHRESH);
3566 #if !CONFIG_REALTIME_ONLY
3567 // Configure experimental use of segmentation for enhanced coding of
3568 // static regions if indicated.
3569 // Only allowed in the second pass of a two pass encode, as it requires
3570 // lagged coding, and if the relevant speed feature flag is set.
3571 if (cpi->oxcf.pass == 2 && cpi->sf.static_segmentation)
3572 configure_static_seg_features(cpi);
3573 #endif // !CONFIG_REALTIME_ONLY
3575 #if CONFIG_VP9_POSTPROC && !(CONFIG_VP9_TEMPORAL_DENOISING)
3576 if (cpi->oxcf.noise_sensitivity > 0) {
3578 switch (cpi->oxcf.noise_sensitivity) {
3579 case 1: l = 20; break;
3580 case 2: l = 40; break;
3581 case 3: l = 60; break;
3583 case 5: l = 100; break;
3584 case 6: l = 150; break;
3586 if (!cpi->common.postproc_state.limits) {
3587 cpi->common.postproc_state.limits =
3588 vpx_calloc(cpi->un_scaled_source->y_width,
3589 sizeof(*cpi->common.postproc_state.limits));
3591 vp9_denoise(&cpi->common, cpi->Source, cpi->Source, l,
3592 cpi->common.postproc_state.limits);
3594 #endif // CONFIG_VP9_POSTPROC
3597 #if CONFIG_VP9_TEMPORAL_DENOISING
3598 static void setup_denoiser_buffer(VP9_COMP *cpi) {
3599 VP9_COMMON *const cm = &cpi->common;
3600 if (cpi->oxcf.noise_sensitivity > 0 &&
3601 !cpi->denoiser.frame_buffer_initialized) {
3602 if (vp9_denoiser_alloc(cm, &cpi->svc, &cpi->denoiser, cpi->use_svc,
3603 cpi->oxcf.noise_sensitivity, cm->width, cm->height,
3604 cm->subsampling_x, cm->subsampling_y,
3605 #if CONFIG_VP9_HIGHBITDEPTH
3606 cm->use_highbitdepth,
3608 VP9_ENC_BORDER_IN_PIXELS))
3609 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3610 "Failed to allocate denoiser");
3615 static void init_motion_estimation(VP9_COMP *cpi) {
3616 int y_stride = cpi->scaled_source.y_stride;
3618 if (cpi->sf.mv.search_method == NSTEP) {
3619 vp9_init3smotion_compensation(&cpi->ss_cfg, y_stride);
3620 } else if (cpi->sf.mv.search_method == DIAMOND) {
3621 vp9_init_dsmotion_compensation(&cpi->ss_cfg, y_stride);
3625 static void set_frame_size(VP9_COMP *cpi) {
3627 VP9_COMMON *const cm = &cpi->common;
3628 VP9EncoderConfig *const oxcf = &cpi->oxcf;
3629 MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
3631 #if !CONFIG_REALTIME_ONLY
3632 if (oxcf->pass == 2 && oxcf->rc_mode == VPX_VBR &&
3633 ((oxcf->resize_mode == RESIZE_FIXED && cm->current_video_frame == 0) ||
3634 (oxcf->resize_mode == RESIZE_DYNAMIC && cpi->resize_pending))) {
3635 calculate_coded_size(cpi, &oxcf->scaled_frame_width,
3636 &oxcf->scaled_frame_height);
3638 // There has been a change in frame size.
3639 vp9_set_size_literal(cpi, oxcf->scaled_frame_width,
3640 oxcf->scaled_frame_height);
3642 #endif // !CONFIG_REALTIME_ONLY
3644 if (oxcf->pass == 0 && oxcf->rc_mode == VPX_CBR && !cpi->use_svc &&
3645 oxcf->resize_mode == RESIZE_DYNAMIC && cpi->resize_pending != 0) {
3646 oxcf->scaled_frame_width =
3647 (oxcf->width * cpi->resize_scale_num) / cpi->resize_scale_den;
3648 oxcf->scaled_frame_height =
3649 (oxcf->height * cpi->resize_scale_num) / cpi->resize_scale_den;
3650 // There has been a change in frame size.
3651 vp9_set_size_literal(cpi, oxcf->scaled_frame_width,
3652 oxcf->scaled_frame_height);
3654 // TODO(agrange) Scale cpi->max_mv_magnitude if frame-size has changed.
3655 set_mv_search_params(cpi);
3657 vp9_noise_estimate_init(&cpi->noise_estimate, cm->width, cm->height);
3658 #if CONFIG_VP9_TEMPORAL_DENOISING
3659 // Reset the denoiser on the resized frame.
3660 if (cpi->oxcf.noise_sensitivity > 0) {
3661 vp9_denoiser_free(&(cpi->denoiser));
3662 setup_denoiser_buffer(cpi);
3663 // Dynamic resize is only triggered for non-SVC, so we can force
3664 // golden frame update here as temporary fix to denoiser.
3665 cpi->refresh_golden_frame = 1;
3670 if ((oxcf->pass == 2) && !cpi->use_svc) {
3671 vp9_set_target_rate(cpi);
3674 alloc_frame_mvs(cm, cm->new_fb_idx);
3676 // Reset the frame pointers to the current frame size.
3677 if (vpx_realloc_frame_buffer(get_frame_new_buffer(cm), cm->width, cm->height,
3678 cm->subsampling_x, cm->subsampling_y,
3679 #if CONFIG_VP9_HIGHBITDEPTH
3680 cm->use_highbitdepth,
3682 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
3684 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3685 "Failed to allocate frame buffer");
3687 alloc_util_frame_buffers(cpi);
3688 init_motion_estimation(cpi);
3690 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3691 RefBuffer *const ref_buf = &cm->frame_refs[ref_frame - 1];
3692 const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
3694 ref_buf->idx = buf_idx;
3696 if (buf_idx != INVALID_IDX) {
3697 YV12_BUFFER_CONFIG *const buf = &cm->buffer_pool->frame_bufs[buf_idx].buf;
3699 #if CONFIG_VP9_HIGHBITDEPTH
3700 vp9_setup_scale_factors_for_frame(
3701 &ref_buf->sf, buf->y_crop_width, buf->y_crop_height, cm->width,
3702 cm->height, (buf->flags & YV12_FLAG_HIGHBITDEPTH) ? 1 : 0);
3704 vp9_setup_scale_factors_for_frame(&ref_buf->sf, buf->y_crop_width,
3705 buf->y_crop_height, cm->width,
3707 #endif // CONFIG_VP9_HIGHBITDEPTH
3708 if (vp9_is_scaled(&ref_buf->sf)) vpx_extend_frame_borders(buf);
3710 ref_buf->buf = NULL;
3714 set_ref_ptrs(cm, xd, LAST_FRAME, LAST_FRAME);
3717 #if CONFIG_CONSISTENT_RECODE
3718 static void save_encode_params(VP9_COMP *cpi) {
3719 VP9_COMMON *const cm = &cpi->common;
3720 const int tile_cols = 1 << cm->log2_tile_cols;
3721 const int tile_rows = 1 << cm->log2_tile_rows;
3722 int tile_col, tile_row;
3724 RD_OPT *rd_opt = &cpi->rd;
3725 for (i = 0; i < MAX_REF_FRAMES; i++) {
3726 for (j = 0; j < REFERENCE_MODES; j++)
3727 rd_opt->prediction_type_threshes_prev[i][j] =
3728 rd_opt->prediction_type_threshes[i][j];
3730 for (j = 0; j < SWITCHABLE_FILTER_CONTEXTS; j++)
3731 rd_opt->filter_threshes_prev[i][j] = rd_opt->filter_threshes[i][j];
3734 if (cpi->tile_data != NULL) {
3735 for (tile_row = 0; tile_row < tile_rows; ++tile_row)
3736 for (tile_col = 0; tile_col < tile_cols; ++tile_col) {
3737 TileDataEnc *tile_data =
3738 &cpi->tile_data[tile_row * tile_cols + tile_col];
3739 for (i = 0; i < BLOCK_SIZES; ++i) {
3740 for (j = 0; j < MAX_MODES; ++j) {
3741 tile_data->thresh_freq_fact_prev[i][j] =
3742 tile_data->thresh_freq_fact[i][j];
3750 static INLINE void set_raw_source_frame(VP9_COMP *cpi) {
3751 #ifdef ENABLE_KF_DENOISE
3752 if (is_spatial_denoise_enabled(cpi)) {
3753 cpi->raw_source_frame = vp9_scale_if_required(
3754 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
3755 (oxcf->pass == 0), EIGHTTAP, 0);
3757 cpi->raw_source_frame = cpi->Source;
3760 cpi->raw_source_frame = cpi->Source;
3764 static int encode_without_recode_loop(VP9_COMP *cpi, size_t *size,
3766 VP9_COMMON *const cm = &cpi->common;
3767 SVC *const svc = &cpi->svc;
3768 int q = 0, bottom_index = 0, top_index = 0;
3769 int no_drop_scene_change = 0;
3770 const INTERP_FILTER filter_scaler =
3771 (is_one_pass_cbr_svc(cpi))
3772 ? svc->downsample_filter_type[svc->spatial_layer_id]
3774 const int phase_scaler =
3775 (is_one_pass_cbr_svc(cpi))
3776 ? svc->downsample_filter_phase[svc->spatial_layer_id]
3779 if (cm->show_existing_frame) {
3780 cpi->rc.this_frame_target = 0;
3781 if (is_psnr_calc_enabled(cpi)) set_raw_source_frame(cpi);
3785 svc->time_stamp_prev[svc->spatial_layer_id] = svc->time_stamp_superframe;
3787 // Flag to check if its valid to compute the source sad (used for
3788 // scene detection and for superblock content state in CBR mode).
3789 // The flag may get reset below based on SVC or resizing state.
3790 cpi->compute_source_sad_onepass = cpi->oxcf.mode == REALTIME;
3792 vpx_clear_system_state();
3794 set_frame_size(cpi);
3796 if (is_one_pass_cbr_svc(cpi) &&
3797 cpi->un_scaled_source->y_width == cm->width << 2 &&
3798 cpi->un_scaled_source->y_height == cm->height << 2 &&
3799 svc->scaled_temp.y_width == cm->width << 1 &&
3800 svc->scaled_temp.y_height == cm->height << 1) {
3801 // For svc, if it is a 1/4x1/4 downscaling, do a two-stage scaling to take
3802 // advantage of the 1:2 optimized scaler. In the process, the 1/2x1/2
3803 // result will be saved in scaled_temp and might be used later.
3804 const INTERP_FILTER filter_scaler2 = svc->downsample_filter_type[1];
3805 const int phase_scaler2 = svc->downsample_filter_phase[1];
3806 cpi->Source = vp9_svc_twostage_scale(
3807 cm, cpi->un_scaled_source, &cpi->scaled_source, &svc->scaled_temp,
3808 filter_scaler, phase_scaler, filter_scaler2, phase_scaler2);
3809 svc->scaled_one_half = 1;
3810 } else if (is_one_pass_cbr_svc(cpi) &&
3811 cpi->un_scaled_source->y_width == cm->width << 1 &&
3812 cpi->un_scaled_source->y_height == cm->height << 1 &&
3813 svc->scaled_one_half) {
3814 // If the spatial layer is 1/2x1/2 and the scaling is already done in the
3815 // two-stage scaling, use the result directly.
3816 cpi->Source = &svc->scaled_temp;
3817 svc->scaled_one_half = 0;
3819 cpi->Source = vp9_scale_if_required(
3820 cm, cpi->un_scaled_source, &cpi->scaled_source, (cpi->oxcf.pass == 0),
3821 filter_scaler, phase_scaler);
3823 #ifdef OUTPUT_YUV_SVC_SRC
3824 // Write out at most 3 spatial layers.
3825 if (is_one_pass_cbr_svc(cpi) && svc->spatial_layer_id < 3) {
3826 vpx_write_yuv_frame(yuv_svc_src[svc->spatial_layer_id], cpi->Source);
3829 // Unfiltered raw source used in metrics calculation if the source
3830 // has been filtered.
3831 if (is_psnr_calc_enabled(cpi)) {
3832 #ifdef ENABLE_KF_DENOISE
3833 if (is_spatial_denoise_enabled(cpi)) {
3834 cpi->raw_source_frame = vp9_scale_if_required(
3835 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
3836 (cpi->oxcf.pass == 0), EIGHTTAP, phase_scaler);
3838 cpi->raw_source_frame = cpi->Source;
3841 cpi->raw_source_frame = cpi->Source;
3845 if ((cpi->use_svc &&
3846 (svc->spatial_layer_id < svc->number_spatial_layers - 1 ||
3847 svc->temporal_layer_id < svc->number_temporal_layers - 1 ||
3848 svc->current_superframe < 1)) ||
3849 cpi->resize_pending || cpi->resize_state || cpi->external_resize ||
3850 cpi->resize_state != ORIG) {
3851 cpi->compute_source_sad_onepass = 0;
3852 if (cpi->content_state_sb_fd != NULL)
3853 memset(cpi->content_state_sb_fd, 0,
3854 (cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1) *
3855 sizeof(*cpi->content_state_sb_fd));
3858 // Avoid scaling last_source unless its needed.
3859 // Last source is needed if avg_source_sad() is used, or if
3860 // partition_search_type == SOURCE_VAR_BASED_PARTITION, or if noise
3861 // estimation is enabled.
3862 if (cpi->unscaled_last_source != NULL &&
3863 (cpi->oxcf.content == VP9E_CONTENT_SCREEN ||
3864 (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == VPX_VBR &&
3865 cpi->oxcf.mode == REALTIME && cpi->oxcf.speed >= 5) ||
3866 cpi->sf.partition_search_type == SOURCE_VAR_BASED_PARTITION ||
3867 (cpi->noise_estimate.enabled && !cpi->oxcf.noise_sensitivity) ||
3868 cpi->compute_source_sad_onepass))
3869 cpi->Last_Source = vp9_scale_if_required(
3870 cm, cpi->unscaled_last_source, &cpi->scaled_last_source,
3871 (cpi->oxcf.pass == 0), EIGHTTAP, 0);
3873 if (cpi->Last_Source == NULL ||
3874 cpi->Last_Source->y_width != cpi->Source->y_width ||
3875 cpi->Last_Source->y_height != cpi->Source->y_height)
3876 cpi->compute_source_sad_onepass = 0;
3878 if (frame_is_intra_only(cm) || cpi->resize_pending != 0) {
3879 memset(cpi->consec_zero_mv, 0,
3880 cm->mi_rows * cm->mi_cols * sizeof(*cpi->consec_zero_mv));
3883 #if CONFIG_VP9_TEMPORAL_DENOISING
3884 if (cpi->oxcf.noise_sensitivity > 0 && cpi->use_svc)
3885 vp9_denoiser_reset_on_first_frame(cpi);
3888 // Scene detection is always used for VBR mode or screen-content case.
3889 // For other cases (e.g., CBR mode) use it for 5 <= speed < 8 for now
3890 // (need to check encoding time cost for doing this for speed 8).
3891 cpi->rc.high_source_sad = 0;
3892 cpi->rc.hybrid_intra_scene_change = 0;
3893 cpi->rc.re_encode_maxq_scene_change = 0;
3894 if (cm->show_frame && cpi->oxcf.mode == REALTIME &&
3895 (cpi->oxcf.rc_mode == VPX_VBR ||
3896 cpi->oxcf.content == VP9E_CONTENT_SCREEN ||
3897 (cpi->oxcf.speed >= 5 && cpi->oxcf.speed < 8)))
3898 vp9_scene_detection_onepass(cpi);
3900 if (svc->spatial_layer_id == svc->first_spatial_layer_to_encode) {
3901 svc->high_source_sad_superframe = cpi->rc.high_source_sad;
3902 svc->high_num_blocks_with_motion = cpi->rc.high_num_blocks_with_motion;
3903 // On scene change reset temporal layer pattern to TL0.
3904 // Note that if the base/lower spatial layers are skipped: instead of
3905 // inserting base layer here, we force max-q for the next superframe
3906 // with lower spatial layers: this is done in vp9_encodedframe_overshoot()
3907 // when max-q is decided for the current layer.
3908 // Only do this reset for bypass/flexible mode.
3909 if (svc->high_source_sad_superframe && svc->temporal_layer_id > 0 &&
3910 svc->temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS) {
3911 // rc->high_source_sad will get reset so copy it to restore it.
3912 int tmp_high_source_sad = cpi->rc.high_source_sad;
3913 vp9_svc_reset_temporal_layers(cpi, cm->frame_type == KEY_FRAME);
3914 cpi->rc.high_source_sad = tmp_high_source_sad;
3918 vp9_update_noise_estimate(cpi);
3920 // For 1 pass CBR, check if we are dropping this frame.
3921 // Never drop on key frame, if base layer is key for svc,
3922 // on scene change, or if superframe has layer sync.
3923 if ((cpi->rc.high_source_sad || svc->high_source_sad_superframe) &&
3924 !(cpi->rc.use_post_encode_drop && svc->last_layer_dropped[0]))
3925 no_drop_scene_change = 1;
3926 if (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == VPX_CBR &&
3927 !frame_is_intra_only(cm) && !no_drop_scene_change &&
3928 !svc->superframe_has_layer_sync &&
3930 !svc->layer_context[svc->temporal_layer_id].is_key_frame)) {
3931 if (vp9_rc_drop_frame(cpi)) return 0;
3934 // For 1 pass CBR SVC, only ZEROMV is allowed for spatial reference frame
3935 // when svc->force_zero_mode_spatial_ref = 1. Under those conditions we can
3936 // avoid this frame-level upsampling (for non intra_only frames).
3937 if (frame_is_intra_only(cm) == 0 &&
3938 !(is_one_pass_cbr_svc(cpi) && svc->force_zero_mode_spatial_ref)) {
3939 vp9_scale_references(cpi);
3942 set_size_independent_vars(cpi);
3943 set_size_dependent_vars(cpi, &q, &bottom_index, &top_index);
3945 // search method and step parameter might be changed in speed settings.
3946 init_motion_estimation(cpi);
3948 if (cpi->sf.copy_partition_flag) alloc_copy_partition_data(cpi);
3950 if (cpi->sf.svc_use_lowres_part &&
3951 svc->spatial_layer_id == svc->number_spatial_layers - 2) {
3952 if (svc->prev_partition_svc == NULL) {
3954 cm, svc->prev_partition_svc,
3955 (BLOCK_SIZE *)vpx_calloc(cm->mi_stride * cm->mi_rows,
3956 sizeof(*svc->prev_partition_svc)));
3960 // TODO(jianj): Look into issue of skin detection with high bitdepth.
3961 if (cm->bit_depth == 8 && cpi->oxcf.speed >= 5 && cpi->oxcf.pass == 0 &&
3962 cpi->oxcf.rc_mode == VPX_CBR &&
3963 cpi->oxcf.content != VP9E_CONTENT_SCREEN &&
3964 cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
3965 cpi->use_skin_detection = 1;
3968 // Enable post encode frame dropping for CBR on non key frame, when
3969 // ext_use_post_encode_drop is specified by user.
3970 cpi->rc.use_post_encode_drop = cpi->rc.ext_use_post_encode_drop &&
3971 cpi->oxcf.rc_mode == VPX_CBR &&
3972 cm->frame_type != KEY_FRAME;
3974 vp9_set_quantizer(cm, q);
3975 vp9_set_variance_partition_thresholds(cpi, q, 0);
3979 suppress_active_map(cpi);
3982 // On non-zero spatial layer, check for disabling inter-layer
3984 if (svc->spatial_layer_id > 0) vp9_svc_constrain_inter_layer_pred(cpi);
3985 vp9_svc_assert_constraints_pattern(cpi);
3988 if (cpi->rc.last_post_encode_dropped_scene_change) {
3989 cpi->rc.high_source_sad = 1;
3990 svc->high_source_sad_superframe = 1;
3991 // For now disable use_source_sad since Last_Source will not be the previous
3992 // encoded but the dropped one.
3993 cpi->sf.use_source_sad = 0;
3994 cpi->rc.last_post_encode_dropped_scene_change = 0;
3996 // Check if this high_source_sad (scene/slide change) frame should be
3997 // encoded at high/max QP, and if so, set the q and adjust some rate
3998 // control parameters.
3999 if (cpi->sf.overshoot_detection_cbr_rt == FAST_DETECTION_MAXQ &&
4000 (cpi->rc.high_source_sad ||
4001 (cpi->use_svc && svc->high_source_sad_superframe))) {
4002 if (vp9_encodedframe_overshoot(cpi, -1, &q)) {
4003 vp9_set_quantizer(cm, q);
4004 vp9_set_variance_partition_thresholds(cpi, q, 0);
4008 #if !CONFIG_REALTIME_ONLY
4009 // Variance adaptive and in frame q adjustment experiments are mutually
4011 if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
4012 vp9_vaq_frame_setup(cpi);
4013 } else if (cpi->oxcf.aq_mode == EQUATOR360_AQ) {
4014 vp9_360aq_frame_setup(cpi);
4015 } else if (cpi->oxcf.aq_mode == COMPLEXITY_AQ) {
4016 vp9_setup_in_frame_q_adj(cpi);
4017 } else if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ) {
4018 // it may be pretty bad for rate-control,
4019 // and I should handle it somehow
4020 vp9_alt_ref_aq_setup_map(cpi->alt_ref_aq, cpi);
4023 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
4024 vp9_cyclic_refresh_setup(cpi);
4025 } else if (cpi->roi.enabled && !frame_is_intra_only(cm)) {
4028 #if !CONFIG_REALTIME_ONLY
4032 apply_active_map(cpi);
4034 vp9_encode_frame(cpi);
4036 // Check if we should re-encode this frame at high Q because of high
4037 // overshoot based on the encoded frame size. Only for frames where
4038 // high temporal-source SAD is detected.
4039 // For SVC: all spatial layers are checked for re-encoding.
4040 if (cpi->sf.overshoot_detection_cbr_rt == RE_ENCODE_MAXQ &&
4041 (cpi->rc.high_source_sad ||
4042 (cpi->use_svc && svc->high_source_sad_superframe))) {
4044 // Get an estimate of the encoded frame size.
4045 save_coding_context(cpi);
4046 vp9_pack_bitstream(cpi, dest, size);
4047 restore_coding_context(cpi);
4048 frame_size = (int)(*size) << 3;
4049 // Check if encoded frame will overshoot too much, and if so, set the q and
4050 // adjust some rate control parameters, and return to re-encode the frame.
4051 if (vp9_encodedframe_overshoot(cpi, frame_size, &q)) {
4052 vpx_clear_system_state();
4053 vp9_set_quantizer(cm, q);
4054 vp9_set_variance_partition_thresholds(cpi, q, 0);
4055 suppress_active_map(cpi);
4056 // Turn-off cyclic refresh for re-encoded frame.
4057 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
4058 CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
4059 unsigned char *const seg_map = cpi->segmentation_map;
4060 memset(seg_map, 0, cm->mi_rows * cm->mi_cols);
4061 memset(cr->last_coded_q_map, MAXQ,
4062 cm->mi_rows * cm->mi_cols * sizeof(*cr->last_coded_q_map));
4064 vp9_disable_segmentation(&cm->seg);
4066 apply_active_map(cpi);
4067 vp9_encode_frame(cpi);
4071 // Update some stats from cyclic refresh, and check for golden frame update.
4072 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && cm->seg.enabled &&
4073 !frame_is_intra_only(cm))
4074 vp9_cyclic_refresh_postencode(cpi);
4076 // Update the skip mb flag probabilities based on the distribution
4077 // seen in the last encoder iteration.
4078 // update_base_skip_probs(cpi);
4079 vpx_clear_system_state();
4083 #if !CONFIG_REALTIME_ONLY
4084 #define MAX_QSTEP_ADJ 4
4085 static int get_qstep_adj(int rate_excess, int rate_limit) {
4087 rate_limit ? ((rate_excess + rate_limit / 2) / rate_limit) : INT_MAX;
4088 return VPXMIN(qstep, MAX_QSTEP_ADJ);
4091 static void encode_with_recode_loop(VP9_COMP *cpi, size_t *size,
4093 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
4094 VP9_COMMON *const cm = &cpi->common;
4095 RATE_CONTROL *const rc = &cpi->rc;
4096 int bottom_index, top_index;
4098 int loop_at_this_size = 0;
4100 int overshoot_seen = 0;
4101 int undershoot_seen = 0;
4102 int frame_over_shoot_limit;
4103 int frame_under_shoot_limit;
4104 int q = 0, q_low = 0, q_high = 0;
4106 #ifdef AGGRESSIVE_VBR
4110 if (cm->show_existing_frame) {
4111 rc->this_frame_target = 0;
4112 if (is_psnr_calc_enabled(cpi)) set_raw_source_frame(cpi);
4116 set_size_independent_vars(cpi);
4118 enable_acl = cpi->sf.allow_acl ? (cm->frame_type == KEY_FRAME) ||
4119 (cpi->twopass.gf_group.index == 1)
4123 vpx_clear_system_state();
4125 set_frame_size(cpi);
4127 if (loop_count == 0 || cpi->resize_pending != 0) {
4128 set_size_dependent_vars(cpi, &q, &bottom_index, &top_index);
4130 #ifdef AGGRESSIVE_VBR
4131 if (two_pass_first_group_inter(cpi)) {
4132 // Adjustment limits for min and max q
4133 qrange_adj = VPXMAX(1, (top_index - bottom_index) / 2);
4136 VPXMAX(bottom_index - qrange_adj / 2, oxcf->best_allowed_q);
4137 top_index = VPXMIN(oxcf->worst_allowed_q, top_index + qrange_adj / 2);
4140 // TODO(agrange) Scale cpi->max_mv_magnitude if frame-size has changed.
4141 set_mv_search_params(cpi);
4143 // Reset the loop state for new frame size.
4145 undershoot_seen = 0;
4147 // Reconfiguration for change in frame size has concluded.
4148 cpi->resize_pending = 0;
4150 q_low = bottom_index;
4153 loop_at_this_size = 0;
4156 // Decide frame size bounds first time through.
4157 if (loop_count == 0) {
4158 vp9_rc_compute_frame_size_bounds(cpi, rc->this_frame_target,
4159 &frame_under_shoot_limit,
4160 &frame_over_shoot_limit);
4164 vp9_scale_if_required(cm, cpi->un_scaled_source, &cpi->scaled_source,
4165 (oxcf->pass == 0), EIGHTTAP, 0);
4167 // Unfiltered raw source used in metrics calculation if the source
4168 // has been filtered.
4169 if (is_psnr_calc_enabled(cpi)) {
4170 #ifdef ENABLE_KF_DENOISE
4171 if (is_spatial_denoise_enabled(cpi)) {
4172 cpi->raw_source_frame = vp9_scale_if_required(
4173 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
4174 (oxcf->pass == 0), EIGHTTAP, 0);
4176 cpi->raw_source_frame = cpi->Source;
4179 cpi->raw_source_frame = cpi->Source;
4183 if (cpi->unscaled_last_source != NULL)
4184 cpi->Last_Source = vp9_scale_if_required(cm, cpi->unscaled_last_source,
4185 &cpi->scaled_last_source,
4186 (oxcf->pass == 0), EIGHTTAP, 0);
4188 if (frame_is_intra_only(cm) == 0) {
4189 if (loop_count > 0) {
4190 release_scaled_references(cpi);
4192 vp9_scale_references(cpi);
4195 vp9_set_quantizer(cm, q);
4197 if (loop_count == 0) setup_frame(cpi);
4199 // Variance adaptive and in frame q adjustment experiments are mutually
4201 if (oxcf->aq_mode == VARIANCE_AQ) {
4202 vp9_vaq_frame_setup(cpi);
4203 } else if (oxcf->aq_mode == EQUATOR360_AQ) {
4204 vp9_360aq_frame_setup(cpi);
4205 } else if (oxcf->aq_mode == COMPLEXITY_AQ) {
4206 vp9_setup_in_frame_q_adj(cpi);
4207 } else if (oxcf->aq_mode == LOOKAHEAD_AQ) {
4208 vp9_alt_ref_aq_setup_map(cpi->alt_ref_aq, cpi);
4209 } else if (oxcf->aq_mode == PSNR_AQ) {
4210 vp9_psnr_aq_mode_setup(&cm->seg);
4213 vp9_encode_frame(cpi);
4215 // Update the skip mb flag probabilities based on the distribution
4216 // seen in the last encoder iteration.
4217 // update_base_skip_probs(cpi);
4219 vpx_clear_system_state();
4221 // Dummy pack of the bitstream using up to date stats to get an
4222 // accurate estimate of output frame size to determine if we need
4224 if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF) {
4225 save_coding_context(cpi);
4226 if (!cpi->sf.use_nonrd_pick_mode) vp9_pack_bitstream(cpi, dest, size);
4228 rc->projected_frame_size = (int)(*size) << 3;
4230 if (frame_over_shoot_limit == 0) frame_over_shoot_limit = 1;
4233 if (oxcf->rc_mode == VPX_Q) {
4236 if ((cm->frame_type == KEY_FRAME) && rc->this_key_frame_forced &&
4237 (rc->projected_frame_size < rc->max_frame_bandwidth)) {
4241 int64_t high_err_target = cpi->ambient_err;
4242 int64_t low_err_target = cpi->ambient_err >> 1;
4244 #if CONFIG_VP9_HIGHBITDEPTH
4245 if (cm->use_highbitdepth) {
4246 kf_err = vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4248 kf_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4251 kf_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4252 #endif // CONFIG_VP9_HIGHBITDEPTH
4254 // Prevent possible divide by zero error below for perfect KF
4257 // The key frame is not good enough or we can afford
4258 // to make it better without undue risk of popping.
4259 if ((kf_err > high_err_target &&
4260 rc->projected_frame_size <= frame_over_shoot_limit) ||
4261 (kf_err > low_err_target &&
4262 rc->projected_frame_size <= frame_under_shoot_limit)) {
4264 q_high = q > q_low ? q - 1 : q_low;
4267 q = (int)((q * high_err_target) / kf_err);
4268 q = VPXMIN(q, (q_high + q_low) >> 1);
4269 } else if (kf_err < low_err_target &&
4270 rc->projected_frame_size >= frame_under_shoot_limit) {
4271 // The key frame is much better than the previous frame
4273 q_low = q < q_high ? q + 1 : q_high;
4276 q = (int)((q * low_err_target) / kf_err);
4277 q = VPXMIN(q, (q_high + q_low + 1) >> 1);
4280 // Clamp Q to upper and lower limits:
4281 q = clamp(q, q_low, q_high);
4284 } else if (recode_loop_test(cpi, frame_over_shoot_limit,
4285 frame_under_shoot_limit, q,
4286 VPXMAX(q_high, top_index), bottom_index)) {
4287 // Is the projected frame size out of range and are we allowed
4288 // to attempt to recode.
4293 if (cpi->resize_pending == 1) {
4294 // Change in frame size so go back around the recode loop.
4295 cpi->rc.frame_size_selector =
4296 SCALE_STEP1 - cpi->rc.frame_size_selector;
4297 cpi->rc.next_frame_size_selector = cpi->rc.frame_size_selector;
4299 #if CONFIG_INTERNAL_STATS
4300 ++cpi->tot_recode_hits;
4307 // Frame size out of permitted range:
4308 // Update correction factor & compute new Q to try...
4310 // Frame is too large
4311 if (rc->projected_frame_size > rc->this_frame_target) {
4312 // Special case if the projected size is > the max allowed.
4313 if ((q == q_high) &&
4314 ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
4315 (!rc->is_src_frame_alt_ref &&
4316 (rc->projected_frame_size >=
4317 big_rate_miss_high_threshold(cpi))))) {
4318 int max_rate = VPXMAX(1, VPXMIN(rc->max_frame_bandwidth,
4319 big_rate_miss_high_threshold(cpi)));
4321 q_val_high = vp9_convert_qindex_to_q(q_high, cm->bit_depth);
4323 q_val_high * ((double)rc->projected_frame_size / max_rate);
4324 q_high = vp9_convert_q_to_qindex(q_val_high, cm->bit_depth);
4325 q_high = clamp(q_high, rc->best_quality, rc->worst_quality);
4328 // Raise Qlow as to at least the current value
4330 get_qstep_adj(rc->projected_frame_size, rc->this_frame_target);
4331 q_low = VPXMIN(q + qstep, q_high);
4333 if (undershoot_seen || loop_at_this_size > 1) {
4334 // Update rate_correction_factor unless
4335 vp9_rc_update_rate_correction_factors(cpi);
4337 q = (q_high + q_low + 1) / 2;
4339 // Update rate_correction_factor unless
4340 vp9_rc_update_rate_correction_factors(cpi);
4342 q = vp9_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4343 VPXMAX(q_high, top_index));
4345 while (q < q_low && retries < 10) {
4346 vp9_rc_update_rate_correction_factors(cpi);
4347 q = vp9_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4348 VPXMAX(q_high, top_index));
4355 // Frame is too small
4357 get_qstep_adj(rc->this_frame_target, rc->projected_frame_size);
4358 q_high = VPXMAX(q - qstep, q_low);
4360 if (overshoot_seen || loop_at_this_size > 1) {
4361 vp9_rc_update_rate_correction_factors(cpi);
4362 q = (q_high + q_low) / 2;
4364 vp9_rc_update_rate_correction_factors(cpi);
4365 q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
4366 VPXMIN(q_low, bottom_index), top_index);
4367 // Special case reset for qlow for constrained quality.
4368 // This should only trigger where there is very substantial
4369 // undershoot on a frame and the auto cq level is above
4370 // the user passsed in value.
4371 if (oxcf->rc_mode == VPX_CQ && q < q_low) {
4375 while (q > q_high && retries < 10) {
4376 vp9_rc_update_rate_correction_factors(cpi);
4377 q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
4378 VPXMIN(q_low, bottom_index), top_index);
4382 undershoot_seen = 1;
4385 // Clamp Q to upper and lower limits:
4386 q = clamp(q, q_low, q_high);
4388 loop = (q != last_q);
4394 // Special case for overlay frame.
4395 if (rc->is_src_frame_alt_ref &&
4396 rc->projected_frame_size < rc->max_frame_bandwidth)
4401 ++loop_at_this_size;
4403 #if CONFIG_INTERNAL_STATS
4404 ++cpi->tot_recode_hits;
4408 if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF)
4409 if (loop || !enable_acl) restore_coding_context(cpi);
4412 #ifdef AGGRESSIVE_VBR
4413 if (two_pass_first_group_inter(cpi)) {
4414 cpi->twopass.active_worst_quality =
4415 VPXMIN(q + qrange_adj, oxcf->worst_allowed_q);
4416 } else if (!frame_is_kf_gf_arf(cpi)) {
4418 if (!frame_is_kf_gf_arf(cpi)) {
4420 // Have we been forced to adapt Q outside the expected range by an extreme
4421 // rate miss. If so adjust the active maxQ for the subsequent frames.
4422 if (!rc->is_src_frame_alt_ref && (q > cpi->twopass.active_worst_quality)) {
4423 cpi->twopass.active_worst_quality = q;
4424 } else if (oxcf->vbr_corpus_complexity && q == q_low &&
4425 rc->projected_frame_size < rc->this_frame_target) {
4426 cpi->twopass.active_worst_quality =
4427 VPXMAX(q, cpi->twopass.active_worst_quality - 1);
4432 // Skip recoding, if model diff is below threshold
4433 const int thresh = compute_context_model_thresh(cpi);
4434 const int diff = compute_context_model_diff(cm);
4435 if (diff < thresh) {
4436 vpx_clear_system_state();
4437 restore_coding_context(cpi);
4441 vp9_encode_frame(cpi);
4442 vpx_clear_system_state();
4443 restore_coding_context(cpi);
4446 #endif // !CONFIG_REALTIME_ONLY
4448 static int get_ref_frame_flags(const VP9_COMP *cpi) {
4449 const int *const map = cpi->common.ref_frame_map;
4450 const int gold_is_last = map[cpi->gld_fb_idx] == map[cpi->lst_fb_idx];
4451 const int alt_is_last = map[cpi->alt_fb_idx] == map[cpi->lst_fb_idx];
4452 const int gold_is_alt = map[cpi->gld_fb_idx] == map[cpi->alt_fb_idx];
4453 int flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;
4455 if (gold_is_last) flags &= ~VP9_GOLD_FLAG;
4457 if (cpi->rc.frames_till_gf_update_due == INT_MAX &&
4458 (cpi->svc.number_temporal_layers == 1 &&
4459 cpi->svc.number_spatial_layers == 1))
4460 flags &= ~VP9_GOLD_FLAG;
4462 if (alt_is_last) flags &= ~VP9_ALT_FLAG;
4464 if (gold_is_alt) flags &= ~VP9_ALT_FLAG;
4469 static void set_ext_overrides(VP9_COMP *cpi) {
4470 // Overrides the defaults with the externally supplied values with
4471 // vp9_update_reference() and vp9_update_entropy() calls
4472 // Note: The overrides are valid only for the next frame passed
4473 // to encode_frame_to_data_rate() function
4474 if (cpi->ext_refresh_frame_context_pending) {
4475 cpi->common.refresh_frame_context = cpi->ext_refresh_frame_context;
4476 cpi->ext_refresh_frame_context_pending = 0;
4478 if (cpi->ext_refresh_frame_flags_pending) {
4479 cpi->refresh_last_frame = cpi->ext_refresh_last_frame;
4480 cpi->refresh_golden_frame = cpi->ext_refresh_golden_frame;
4481 cpi->refresh_alt_ref_frame = cpi->ext_refresh_alt_ref_frame;
4485 YV12_BUFFER_CONFIG *vp9_svc_twostage_scale(
4486 VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled,
4487 YV12_BUFFER_CONFIG *scaled_temp, INTERP_FILTER filter_type,
4488 int phase_scaler, INTERP_FILTER filter_type2, int phase_scaler2) {
4489 if (cm->mi_cols * MI_SIZE != unscaled->y_width ||
4490 cm->mi_rows * MI_SIZE != unscaled->y_height) {
4491 #if CONFIG_VP9_HIGHBITDEPTH
4492 if (cm->bit_depth == VPX_BITS_8) {
4493 vp9_scale_and_extend_frame(unscaled, scaled_temp, filter_type2,
4495 vp9_scale_and_extend_frame(scaled_temp, scaled, filter_type,
4498 scale_and_extend_frame(unscaled, scaled_temp, (int)cm->bit_depth,
4499 filter_type2, phase_scaler2);
4500 scale_and_extend_frame(scaled_temp, scaled, (int)cm->bit_depth,
4501 filter_type, phase_scaler);
4504 vp9_scale_and_extend_frame(unscaled, scaled_temp, filter_type2,
4506 vp9_scale_and_extend_frame(scaled_temp, scaled, filter_type, phase_scaler);
4507 #endif // CONFIG_VP9_HIGHBITDEPTH
4514 YV12_BUFFER_CONFIG *vp9_scale_if_required(
4515 VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled,
4516 int use_normative_scaler, INTERP_FILTER filter_type, int phase_scaler) {
4517 if (cm->mi_cols * MI_SIZE != unscaled->y_width ||
4518 cm->mi_rows * MI_SIZE != unscaled->y_height) {
4519 #if CONFIG_VP9_HIGHBITDEPTH
4520 if (use_normative_scaler && unscaled->y_width <= (scaled->y_width << 1) &&
4521 unscaled->y_height <= (scaled->y_height << 1))
4522 if (cm->bit_depth == VPX_BITS_8)
4523 vp9_scale_and_extend_frame(unscaled, scaled, filter_type, phase_scaler);
4525 scale_and_extend_frame(unscaled, scaled, (int)cm->bit_depth,
4526 filter_type, phase_scaler);
4528 scale_and_extend_frame_nonnormative(unscaled, scaled, (int)cm->bit_depth);
4530 if (use_normative_scaler && unscaled->y_width <= (scaled->y_width << 1) &&
4531 unscaled->y_height <= (scaled->y_height << 1))
4532 vp9_scale_and_extend_frame(unscaled, scaled, filter_type, phase_scaler);
4534 scale_and_extend_frame_nonnormative(unscaled, scaled);
4535 #endif // CONFIG_VP9_HIGHBITDEPTH
4542 static void set_ref_sign_bias(VP9_COMP *cpi) {
4543 VP9_COMMON *const cm = &cpi->common;
4544 RefCntBuffer *const ref_buffer = get_ref_cnt_buffer(cm, cm->new_fb_idx);
4545 const int cur_frame_index = ref_buffer->frame_index;
4546 MV_REFERENCE_FRAME ref_frame;
4548 for (ref_frame = LAST_FRAME; ref_frame < MAX_REF_FRAMES; ++ref_frame) {
4549 const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
4550 const RefCntBuffer *const ref_cnt_buf =
4551 get_ref_cnt_buffer(&cpi->common, buf_idx);
4553 cm->ref_frame_sign_bias[ref_frame] =
4554 cur_frame_index < ref_cnt_buf->frame_index;
4559 static int setup_interp_filter_search_mask(VP9_COMP *cpi) {
4560 INTERP_FILTER ifilter;
4561 int ref_total[MAX_REF_FRAMES] = { 0 };
4562 MV_REFERENCE_FRAME ref;
4564 if (cpi->common.last_frame_type == KEY_FRAME || cpi->refresh_alt_ref_frame)
4566 for (ref = LAST_FRAME; ref <= ALTREF_FRAME; ++ref)
4567 for (ifilter = EIGHTTAP; ifilter <= EIGHTTAP_SHARP; ++ifilter)
4568 ref_total[ref] += cpi->interp_filter_selected[ref][ifilter];
4570 for (ifilter = EIGHTTAP; ifilter <= EIGHTTAP_SHARP; ++ifilter) {
4571 if ((ref_total[LAST_FRAME] &&
4572 cpi->interp_filter_selected[LAST_FRAME][ifilter] == 0) &&
4573 (ref_total[GOLDEN_FRAME] == 0 ||
4574 cpi->interp_filter_selected[GOLDEN_FRAME][ifilter] * 50 <
4575 ref_total[GOLDEN_FRAME]) &&
4576 (ref_total[ALTREF_FRAME] == 0 ||
4577 cpi->interp_filter_selected[ALTREF_FRAME][ifilter] * 50 <
4578 ref_total[ALTREF_FRAME]))
4579 mask |= 1 << ifilter;
4584 #ifdef ENABLE_KF_DENOISE
4585 // Baseline Kernal weights for denoise
4586 static uint8_t dn_kernal_3[9] = { 1, 2, 1, 2, 4, 2, 1, 2, 1 };
4587 static uint8_t dn_kernal_5[25] = { 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 4,
4588 2, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1 };
4590 static INLINE void add_denoise_point(int centre_val, int data_val, int thresh,
4591 uint8_t point_weight, int *sum_val,
4593 if (abs(centre_val - data_val) <= thresh) {
4594 *sum_weight += point_weight;
4595 *sum_val += (int)data_val * (int)point_weight;
4599 static void spatial_denoise_point(uint8_t *src_ptr, const int stride,
4600 const int strength) {
4603 int thresh = strength;
4604 int kernal_size = 5;
4605 int half_k_size = 2;
4609 uint8_t *kernal_ptr;
4611 // Find the maximum deviation from the source point in the locale.
4612 tmp_ptr = src_ptr - (stride * (half_k_size + 1)) - (half_k_size + 1);
4613 for (i = 0; i < kernal_size + 2; ++i) {
4614 for (j = 0; j < kernal_size + 2; ++j) {
4615 max_diff = VPXMAX(max_diff, abs((int)*src_ptr - (int)tmp_ptr[j]));
4620 // Select the kernal size.
4621 if (max_diff > (strength + (strength >> 1))) {
4624 thresh = thresh >> 1;
4626 kernal_ptr = (kernal_size == 3) ? dn_kernal_3 : dn_kernal_5;
4629 tmp_ptr = src_ptr - (stride * half_k_size) - half_k_size;
4630 for (i = 0; i < kernal_size; ++i) {
4631 for (j = 0; j < kernal_size; ++j) {
4632 add_denoise_point((int)*src_ptr, (int)tmp_ptr[j], thresh, *kernal_ptr,
4633 &sum_val, &sum_weight);
4639 // Update the source value with the new filtered value
4640 *src_ptr = (uint8_t)((sum_val + (sum_weight >> 1)) / sum_weight);
4643 #if CONFIG_VP9_HIGHBITDEPTH
4644 static void highbd_spatial_denoise_point(uint16_t *src_ptr, const int stride,
4645 const int strength) {
4648 int thresh = strength;
4649 int kernal_size = 5;
4650 int half_k_size = 2;
4654 uint8_t *kernal_ptr;
4656 // Find the maximum deviation from the source point in the locale.
4657 tmp_ptr = src_ptr - (stride * (half_k_size + 1)) - (half_k_size + 1);
4658 for (i = 0; i < kernal_size + 2; ++i) {
4659 for (j = 0; j < kernal_size + 2; ++j) {
4660 max_diff = VPXMAX(max_diff, abs((int)src_ptr - (int)tmp_ptr[j]));
4665 // Select the kernal size.
4666 if (max_diff > (strength + (strength >> 1))) {
4669 thresh = thresh >> 1;
4671 kernal_ptr = (kernal_size == 3) ? dn_kernal_3 : dn_kernal_5;
4674 tmp_ptr = src_ptr - (stride * half_k_size) - half_k_size;
4675 for (i = 0; i < kernal_size; ++i) {
4676 for (j = 0; j < kernal_size; ++j) {
4677 add_denoise_point((int)*src_ptr, (int)tmp_ptr[j], thresh, *kernal_ptr,
4678 &sum_val, &sum_weight);
4684 // Update the source value with the new filtered value
4685 *src_ptr = (uint16_t)((sum_val + (sum_weight >> 1)) / sum_weight);
4687 #endif // CONFIG_VP9_HIGHBITDEPTH
4689 // Apply thresholded spatial noise supression to a given buffer.
4690 static void spatial_denoise_buffer(VP9_COMP *cpi, uint8_t *buffer,
4691 const int stride, const int width,
4692 const int height, const int strength) {
4693 VP9_COMMON *const cm = &cpi->common;
4694 uint8_t *src_ptr = buffer;
4698 for (row = 0; row < height; ++row) {
4699 for (col = 0; col < width; ++col) {
4700 #if CONFIG_VP9_HIGHBITDEPTH
4701 if (cm->use_highbitdepth)
4702 highbd_spatial_denoise_point(CONVERT_TO_SHORTPTR(&src_ptr[col]), stride,
4705 spatial_denoise_point(&src_ptr[col], stride, strength);
4707 spatial_denoise_point(&src_ptr[col], stride, strength);
4708 #endif // CONFIG_VP9_HIGHBITDEPTH
4714 // Apply thresholded spatial noise supression to source.
4715 static void spatial_denoise_frame(VP9_COMP *cpi) {
4716 YV12_BUFFER_CONFIG *src = cpi->Source;
4717 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
4718 TWO_PASS *const twopass = &cpi->twopass;
4719 VP9_COMMON *const cm = &cpi->common;
4721 // Base the filter strength on the current active max Q.
4722 const int q = (int)(vp9_convert_qindex_to_q(twopass->active_worst_quality,
4725 VPXMAX(oxcf->arnr_strength >> 2, VPXMIN(oxcf->arnr_strength, (q >> 4)));
4727 // Denoise each of Y,U and V buffers.
4728 spatial_denoise_buffer(cpi, src->y_buffer, src->y_stride, src->y_width,
4729 src->y_height, strength);
4731 strength += (strength >> 1);
4732 spatial_denoise_buffer(cpi, src->u_buffer, src->uv_stride, src->uv_width,
4733 src->uv_height, strength << 1);
4735 spatial_denoise_buffer(cpi, src->v_buffer, src->uv_stride, src->uv_width,
4736 src->uv_height, strength << 1);
4738 #endif // ENABLE_KF_DENOISE
4740 #if !CONFIG_REALTIME_ONLY
4741 static void vp9_try_disable_lookahead_aq(VP9_COMP *cpi, size_t *size,
4743 if (cpi->common.seg.enabled)
4744 if (ALT_REF_AQ_PROTECT_GAIN) {
4745 size_t nsize = *size;
4748 // TODO(yuryg): optimize this, as
4749 // we don't really need to repack
4751 save_coding_context(cpi);
4752 vp9_disable_segmentation(&cpi->common.seg);
4753 vp9_pack_bitstream(cpi, dest, &nsize);
4754 restore_coding_context(cpi);
4756 overhead = (int)*size - (int)nsize;
4758 if (vp9_alt_ref_aq_disable_if(cpi->alt_ref_aq, overhead, (int)*size))
4759 vp9_encode_frame(cpi);
4761 vp9_enable_segmentation(&cpi->common.seg);
4766 static void set_frame_index(VP9_COMP *cpi, VP9_COMMON *cm) {
4767 RefCntBuffer *const ref_buffer = get_ref_cnt_buffer(cm, cm->new_fb_idx);
4770 const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
4771 ref_buffer->frame_index =
4772 cm->current_video_frame + gf_group->arf_src_offset[gf_group->index];
4776 // Implementation and modifications of C. Yeo, H. L. Tan, and Y. H. Tan, "On
4777 // rate distortion optimization using SSIM," Circuits and Systems for Video
4778 // Technology, IEEE Transactions on, vol. 23, no. 7, pp. 1170-1181, 2013.
4779 // SSIM_VAR_SCALE defines the strength of the bias towards SSIM in RDO.
4780 // Some sample values are:
4781 // (for midres test set)
4782 // SSIM_VAR_SCALE avg_psnr ssim ms_ssim
4783 // 8.0 9.421 -5.537 -6.898
4784 // 16.0 4.703 -5.378 -6.238
4785 // 32.0 1.929 -4.308 -4.807
4786 #define SSIM_VAR_SCALE 16.0
4787 static void set_mb_ssim_rdmult_scaling(VP9_COMP *cpi) {
4788 VP9_COMMON *cm = &cpi->common;
4789 ThreadData *td = &cpi->td;
4790 MACROBLOCK *x = &td->mb;
4791 MACROBLOCKD *xd = &x->e_mbd;
4792 uint8_t *y_buffer = cpi->Source->y_buffer;
4793 const int y_stride = cpi->Source->y_stride;
4794 const int block_size = BLOCK_16X16;
4796 const int num_8x8_w = num_8x8_blocks_wide_lookup[block_size];
4797 const int num_8x8_h = num_8x8_blocks_high_lookup[block_size];
4798 const int num_cols = (cm->mi_cols + num_8x8_w - 1) / num_8x8_w;
4799 const int num_rows = (cm->mi_rows + num_8x8_h - 1) / num_8x8_h;
4800 double log_sum = 0.0;
4803 const double c2 = 58.5225 * SSIM_VAR_SCALE; // 58.5225 = (.03*255)^2
4805 // Loop through each 64x64 block.
4806 for (row = 0; row < num_rows; ++row) {
4807 for (col = 0; col < num_cols; ++col) {
4809 double var = 0.0, num_of_var = 0.0;
4810 const int index = row * num_cols + col;
4812 for (mi_row = row * num_8x8_h;
4813 mi_row < cm->mi_rows && mi_row < (row + 1) * num_8x8_h; ++mi_row) {
4814 for (mi_col = col * num_8x8_w;
4815 mi_col < cm->mi_cols && mi_col < (col + 1) * num_8x8_w; ++mi_col) {
4817 const int row_offset_y = mi_row << 3;
4818 const int col_offset_y = mi_col << 3;
4820 buf.buf = y_buffer + row_offset_y * y_stride + col_offset_y;
4821 buf.stride = y_stride;
4823 // In order to make SSIM_VAR_SCALE in a same scale for both 8 bit
4824 // and high bit videos, the variance needs to be divided by 2.0 or
4826 // TODO(sdeng): need to tune for 12bit videos.
4827 #if CONFIG_VP9_HIGHBITDEPTH
4828 if (cpi->Source->flags & YV12_FLAG_HIGHBITDEPTH)
4829 var += vp9_high_get_sby_variance(cpi, &buf, BLOCK_8X8, xd->bd);
4832 var += vp9_get_sby_variance(cpi, &buf, BLOCK_8X8);
4837 var = var / num_of_var / 64.0;
4838 var = 2.0 * var + c2;
4839 cpi->mi_ssim_rdmult_scaling_factors[index] = var;
4840 log_sum += log(var);
4843 log_sum = exp(log_sum / (double)(num_rows * num_cols));
4845 for (row = 0; row < num_rows; ++row) {
4846 for (col = 0; col < num_cols; ++col) {
4847 const int index = row * num_cols + col;
4848 cpi->mi_ssim_rdmult_scaling_factors[index] /= log_sum;
4855 // Process the wiener variance in 16x16 block basis.
4856 static int qsort_comp(const void *elem1, const void *elem2) {
4857 int a = *((const int *)elem1);
4858 int b = *((const int *)elem2);
4859 if (a > b) return 1;
4860 if (a < b) return -1;
4864 static void init_mb_wiener_var_buffer(VP9_COMP *cpi) {
4865 VP9_COMMON *cm = &cpi->common;
4867 if (cpi->mb_wiener_variance && cpi->mb_wiener_var_rows >= cm->mb_rows &&
4868 cpi->mb_wiener_var_cols >= cm->mb_cols)
4871 vpx_free(cpi->mb_wiener_variance);
4872 cpi->mb_wiener_variance = NULL;
4875 cm, cpi->mb_wiener_variance,
4876 vpx_calloc(cm->mb_rows * cm->mb_cols, sizeof(*cpi->mb_wiener_variance)));
4877 cpi->mb_wiener_var_rows = cm->mb_rows;
4878 cpi->mb_wiener_var_cols = cm->mb_cols;
4881 static void set_mb_wiener_variance(VP9_COMP *cpi) {
4882 VP9_COMMON *cm = &cpi->common;
4883 uint8_t *buffer = cpi->Source->y_buffer;
4884 int buf_stride = cpi->Source->y_stride;
4886 #if CONFIG_VP9_HIGHBITDEPTH
4887 ThreadData *td = &cpi->td;
4888 MACROBLOCK *x = &td->mb;
4889 MACROBLOCKD *xd = &x->e_mbd;
4890 DECLARE_ALIGNED(16, uint16_t, zero_pred16[32 * 32]);
4891 DECLARE_ALIGNED(16, uint8_t, zero_pred8[32 * 32]);
4894 DECLARE_ALIGNED(16, uint8_t, zero_pred[32 * 32]);
4897 DECLARE_ALIGNED(16, int16_t, src_diff[32 * 32]);
4898 DECLARE_ALIGNED(16, tran_low_t, coeff[32 * 32]);
4900 int mb_row, mb_col, count = 0;
4901 // Hard coded operating block size
4902 const int block_size = 16;
4903 const int coeff_count = block_size * block_size;
4904 const TX_SIZE tx_size = TX_16X16;
4906 #if CONFIG_VP9_HIGHBITDEPTH
4907 xd->cur_buf = cpi->Source;
4908 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
4909 zero_pred = CONVERT_TO_BYTEPTR(zero_pred16);
4910 memset(zero_pred16, 0, sizeof(*zero_pred16) * coeff_count);
4912 zero_pred = zero_pred8;
4913 memset(zero_pred8, 0, sizeof(*zero_pred8) * coeff_count);
4916 memset(zero_pred, 0, sizeof(*zero_pred) * coeff_count);
4919 cpi->norm_wiener_variance = 0;
4921 for (mb_row = 0; mb_row < cm->mb_rows; ++mb_row) {
4922 for (mb_col = 0; mb_col < cm->mb_cols; ++mb_col) {
4924 int16_t median_val = 0;
4925 uint8_t *mb_buffer =
4926 buffer + mb_row * block_size * buf_stride + mb_col * block_size;
4927 int64_t wiener_variance = 0;
4929 #if CONFIG_VP9_HIGHBITDEPTH
4930 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
4931 vpx_highbd_subtract_block(block_size, block_size, src_diff, block_size,
4932 mb_buffer, buf_stride, zero_pred, block_size,
4934 highbd_wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
4936 vpx_subtract_block(block_size, block_size, src_diff, block_size,
4937 mb_buffer, buf_stride, zero_pred, block_size);
4938 wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
4941 vpx_subtract_block(block_size, block_size, src_diff, block_size,
4942 mb_buffer, buf_stride, zero_pred, block_size);
4943 wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
4944 #endif // CONFIG_VP9_HIGHBITDEPTH
4947 for (idx = 1; idx < coeff_count; ++idx) coeff[idx] = abs(coeff[idx]);
4949 qsort(coeff, coeff_count - 1, sizeof(*coeff), qsort_comp);
4951 // Noise level estimation
4952 median_val = coeff[coeff_count / 2];
4955 for (idx = 1; idx < coeff_count; ++idx) {
4956 int64_t sqr_coeff = (int64_t)coeff[idx] * coeff[idx];
4957 int64_t tmp_coeff = (int64_t)coeff[idx];
4959 tmp_coeff = (sqr_coeff * coeff[idx]) /
4960 (sqr_coeff + (int64_t)median_val * median_val);
4962 wiener_variance += tmp_coeff * tmp_coeff;
4964 cpi->mb_wiener_variance[mb_row * cm->mb_cols + mb_col] =
4965 wiener_variance / coeff_count;
4966 cpi->norm_wiener_variance +=
4967 cpi->mb_wiener_variance[mb_row * cm->mb_cols + mb_col];
4972 if (count) cpi->norm_wiener_variance /= count;
4973 cpi->norm_wiener_variance = VPXMAX(1, cpi->norm_wiener_variance);
4976 static void encode_frame_to_data_rate(VP9_COMP *cpi, size_t *size,
4978 unsigned int *frame_flags) {
4979 VP9_COMMON *const cm = &cpi->common;
4980 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
4981 struct segmentation *const seg = &cm->seg;
4984 // SVC: skip encoding of enhancement layer if the layer target bandwidth = 0.
4985 // If in constrained layer drop mode (svc.framedrop_mode != LAYER_DROP) and
4986 // base spatial layer was dropped, no need to set svc.skip_enhancement_layer,
4987 // as whole superframe will be dropped.
4988 if (cpi->use_svc && cpi->svc.spatial_layer_id > 0 &&
4989 cpi->oxcf.target_bandwidth == 0 &&
4990 !(cpi->svc.framedrop_mode != LAYER_DROP &&
4991 cpi->svc.drop_spatial_layer[0])) {
4992 cpi->svc.skip_enhancement_layer = 1;
4993 vp9_rc_postencode_update_drop_frame(cpi);
4994 cpi->ext_refresh_frame_flags_pending = 0;
4995 cpi->last_frame_dropped = 1;
4996 cpi->svc.last_layer_dropped[cpi->svc.spatial_layer_id] = 1;
4997 cpi->svc.drop_spatial_layer[cpi->svc.spatial_layer_id] = 1;
4998 if (cpi->svc.framedrop_mode == LAYER_DROP ||
4999 cpi->svc.drop_spatial_layer[0] == 0) {
5000 // For the case of constrained drop mode where the base is dropped
5001 // (drop_spatial_layer[0] == 1), which means full superframe dropped,
5002 // we don't increment the svc frame counters. In particular temporal
5003 // layer counter (which is incremented in vp9_inc_frame_in_layer())
5004 // won't be incremented, so on a dropped frame we try the same
5005 // temporal_layer_id on next incoming frame. This is to avoid an
5006 // issue with temporal alignement with full superframe dropping.
5007 vp9_inc_frame_in_layer(cpi);
5012 set_ext_overrides(cpi);
5013 vpx_clear_system_state();
5015 #ifdef ENABLE_KF_DENOISE
5016 // Spatial denoise of key frame.
5017 if (is_spatial_denoise_enabled(cpi)) spatial_denoise_frame(cpi);
5020 if (cm->show_existing_frame == 0) {
5021 // Update frame index
5022 set_frame_index(cpi, cm);
5024 // Set the arf sign bias for this frame.
5025 set_ref_sign_bias(cpi);
5028 // Set default state for segment based loop filter update flags.
5029 cm->lf.mode_ref_delta_update = 0;
5031 if (cpi->oxcf.pass == 2 && cpi->sf.adaptive_interp_filter_search)
5032 cpi->sf.interp_filter_search_mask = setup_interp_filter_search_mask(cpi);
5034 // Set various flags etc to special state if it is a key frame.
5035 if (frame_is_intra_only(cm)) {
5036 // Reset the loop filter deltas and segmentation map.
5037 vp9_reset_segment_features(&cm->seg);
5039 // If segmentation is enabled force a map update for key frames.
5041 seg->update_map = 1;
5042 seg->update_data = 1;
5045 // The alternate reference frame cannot be active for a key frame.
5046 cpi->rc.source_alt_ref_active = 0;
5048 cm->error_resilient_mode = oxcf->error_resilient_mode;
5049 cm->frame_parallel_decoding_mode = oxcf->frame_parallel_decoding_mode;
5051 // By default, encoder assumes decoder can use prev_mi.
5052 if (cm->error_resilient_mode) {
5053 cm->frame_parallel_decoding_mode = 1;
5054 cm->reset_frame_context = 0;
5055 cm->refresh_frame_context = 0;
5056 } else if (cm->intra_only) {
5057 // Only reset the current context.
5058 cm->reset_frame_context = 2;
5062 if (oxcf->tuning == VP8_TUNE_SSIM) set_mb_ssim_rdmult_scaling(cpi);
5064 if (oxcf->aq_mode == PERCEPTUAL_AQ) {
5065 init_mb_wiener_var_buffer(cpi);
5066 set_mb_wiener_variance(cpi);
5069 vpx_clear_system_state();
5071 #if CONFIG_INTERNAL_STATS
5072 memset(cpi->mode_chosen_counts, 0,
5073 MAX_MODES * sizeof(*cpi->mode_chosen_counts));
5075 #if CONFIG_CONSISTENT_RECODE
5076 // Backup to ensure consistency between recodes
5077 save_encode_params(cpi);
5080 if (cpi->sf.recode_loop == DISALLOW_RECODE) {
5081 if (!encode_without_recode_loop(cpi, size, dest)) return;
5083 #if !CONFIG_REALTIME_ONLY
5084 encode_with_recode_loop(cpi, size, dest);
5088 // TODO(jingning): When using show existing frame mode, we assume that the
5089 // current ARF will be directly used as the final reconstructed frame. This is
5090 // an encoder control scheme. One could in principle explore other
5091 // possibilities to arrange the reference frame buffer and their coding order.
5092 if (cm->show_existing_frame) {
5093 ref_cnt_fb(cm->buffer_pool->frame_bufs, &cm->new_fb_idx,
5094 cm->ref_frame_map[cpi->alt_fb_idx]);
5097 #if !CONFIG_REALTIME_ONLY
5098 // Disable segmentation if it decrease rate/distortion ratio
5099 if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ)
5100 vp9_try_disable_lookahead_aq(cpi, size, dest);
5103 #if CONFIG_VP9_TEMPORAL_DENOISING
5104 #ifdef OUTPUT_YUV_DENOISED
5105 if (oxcf->noise_sensitivity > 0 && denoise_svc(cpi)) {
5106 vpx_write_yuv_frame(yuv_denoised_file,
5107 &cpi->denoiser.running_avg_y[INTRA_FRAME]);
5111 #ifdef OUTPUT_YUV_SKINMAP
5112 if (cpi->common.current_video_frame > 1) {
5113 vp9_output_skin_map(cpi, yuv_skinmap_file);
5117 // Special case code to reduce pulsing when key frames are forced at a
5118 // fixed interval. Note the reconstruction error if it is the frame before
5119 // the force key frame
5120 if (cpi->rc.next_key_frame_forced && cpi->rc.frames_to_key == 1) {
5121 #if CONFIG_VP9_HIGHBITDEPTH
5122 if (cm->use_highbitdepth) {
5124 vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5126 cpi->ambient_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5129 cpi->ambient_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5130 #endif // CONFIG_VP9_HIGHBITDEPTH
5133 // If the encoder forced a KEY_FRAME decision
5134 if (cm->frame_type == KEY_FRAME) cpi->refresh_last_frame = 1;
5136 cm->frame_to_show = get_frame_new_buffer(cm);
5137 cm->frame_to_show->color_space = cm->color_space;
5138 cm->frame_to_show->color_range = cm->color_range;
5139 cm->frame_to_show->render_width = cm->render_width;
5140 cm->frame_to_show->render_height = cm->render_height;
5142 // Pick the loop filter level for the frame.
5143 loopfilter_frame(cpi, cm);
5145 if (cpi->rc.use_post_encode_drop) save_coding_context(cpi);
5147 // build the bitstream
5148 vp9_pack_bitstream(cpi, dest, size);
5150 if (cpi->rc.use_post_encode_drop && cm->base_qindex < cpi->rc.worst_quality &&
5151 cpi->svc.spatial_layer_id == 0 && post_encode_drop_cbr(cpi, size)) {
5152 restore_coding_context(cpi);
5156 cpi->last_frame_dropped = 0;
5157 cpi->svc.last_layer_dropped[cpi->svc.spatial_layer_id] = 0;
5158 if (cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1)
5159 cpi->svc.num_encoded_top_layer++;
5161 // Keep track of the frame buffer index updated/refreshed for the
5162 // current encoded TL0 superframe.
5163 if (cpi->svc.temporal_layer_id == 0) {
5164 if (cpi->refresh_last_frame)
5165 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->lst_fb_idx;
5166 else if (cpi->refresh_golden_frame)
5167 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->gld_fb_idx;
5168 else if (cpi->refresh_alt_ref_frame)
5169 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->alt_fb_idx;
5172 if (cm->seg.update_map) update_reference_segmentation_map(cpi);
5174 if (frame_is_intra_only(cm) == 0) {
5175 release_scaled_references(cpi);
5177 vp9_update_reference_frames(cpi);
5179 if (!cm->show_existing_frame) {
5180 for (t = TX_4X4; t <= TX_32X32; ++t) {
5181 full_to_model_counts(cpi->td.counts->coef[t],
5182 cpi->td.rd_counts.coef_counts[t]);
5185 if (!cm->error_resilient_mode && !cm->frame_parallel_decoding_mode) {
5186 if (!frame_is_intra_only(cm)) {
5187 vp9_adapt_mode_probs(cm);
5188 vp9_adapt_mv_probs(cm, cm->allow_high_precision_mv);
5190 vp9_adapt_coef_probs(cm);
5194 cpi->ext_refresh_frame_flags_pending = 0;
5196 if (cpi->refresh_golden_frame == 1)
5197 cpi->frame_flags |= FRAMEFLAGS_GOLDEN;
5199 cpi->frame_flags &= ~FRAMEFLAGS_GOLDEN;
5201 if (cpi->refresh_alt_ref_frame == 1)
5202 cpi->frame_flags |= FRAMEFLAGS_ALTREF;
5204 cpi->frame_flags &= ~FRAMEFLAGS_ALTREF;
5206 cpi->ref_frame_flags = get_ref_frame_flags(cpi);
5208 cm->last_frame_type = cm->frame_type;
5210 vp9_rc_postencode_update(cpi, *size);
5212 *size = VPXMAX(1, *size);
5215 output_frame_level_debug_stats(cpi);
5218 if (cm->frame_type == KEY_FRAME) {
5219 // Tell the caller that the frame was coded as a key frame
5220 *frame_flags = cpi->frame_flags | FRAMEFLAGS_KEY;
5222 *frame_flags = cpi->frame_flags & ~FRAMEFLAGS_KEY;
5225 // Clear the one shot update flags for segmentation map and mode/ref loop
5227 cm->seg.update_map = 0;
5228 cm->seg.update_data = 0;
5229 cm->lf.mode_ref_delta_update = 0;
5231 // keep track of the last coded dimensions
5232 cm->last_width = cm->width;
5233 cm->last_height = cm->height;
5235 // reset to normal state now that we are done.
5236 if (!cm->show_existing_frame) {
5237 cm->last_show_frame = cm->show_frame;
5238 cm->prev_frame = cm->cur_frame;
5241 if (cm->show_frame) {
5242 vp9_swap_mi_and_prev_mi(cm);
5243 // Don't increment frame counters if this was an altref buffer
5244 // update not a real frame
5245 ++cm->current_video_frame;
5246 if (cpi->use_svc) vp9_inc_frame_in_layer(cpi);
5251 .layer_context[cpi->svc.spatial_layer_id *
5252 cpi->svc.number_temporal_layers +
5253 cpi->svc.temporal_layer_id]
5254 .last_frame_type = cm->frame_type;
5255 // Reset layer_sync back to 0 for next frame.
5256 cpi->svc.spatial_layer_sync[cpi->svc.spatial_layer_id] = 0;
5259 cpi->force_update_segmentation = 0;
5261 #if !CONFIG_REALTIME_ONLY
5262 if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ)
5263 vp9_alt_ref_aq_unset_all(cpi->alt_ref_aq, cpi);
5266 cpi->svc.previous_frame_is_intra_only = cm->intra_only;
5267 cpi->svc.set_intra_only_frame = 0;
5270 static void SvcEncode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5271 unsigned int *frame_flags) {
5272 vp9_rc_get_svc_params(cpi);
5273 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5276 static void Pass0Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5277 unsigned int *frame_flags) {
5278 if (cpi->oxcf.rc_mode == VPX_CBR) {
5279 vp9_rc_get_one_pass_cbr_params(cpi);
5281 vp9_rc_get_one_pass_vbr_params(cpi);
5283 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5286 #if !CONFIG_REALTIME_ONLY
5287 static void Pass2Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5288 unsigned int *frame_flags) {
5289 cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED;
5290 #if CONFIG_MISMATCH_DEBUG
5291 mismatch_move_frame_idx_w();
5293 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5295 vp9_twopass_postencode_update(cpi);
5297 #endif // !CONFIG_REALTIME_ONLY
5299 static void init_ref_frame_bufs(VP9_COMMON *cm) {
5301 BufferPool *const pool = cm->buffer_pool;
5302 cm->new_fb_idx = INVALID_IDX;
5303 for (i = 0; i < REF_FRAMES; ++i) {
5304 cm->ref_frame_map[i] = INVALID_IDX;
5306 for (i = 0; i < FRAME_BUFFERS; ++i) {
5307 pool->frame_bufs[i].ref_count = 0;
5311 static void check_initial_width(VP9_COMP *cpi,
5312 #if CONFIG_VP9_HIGHBITDEPTH
5313 int use_highbitdepth,
5315 int subsampling_x, int subsampling_y) {
5316 VP9_COMMON *const cm = &cpi->common;
5318 if (!cpi->initial_width ||
5319 #if CONFIG_VP9_HIGHBITDEPTH
5320 cm->use_highbitdepth != use_highbitdepth ||
5322 cm->subsampling_x != subsampling_x ||
5323 cm->subsampling_y != subsampling_y) {
5324 cm->subsampling_x = subsampling_x;
5325 cm->subsampling_y = subsampling_y;
5326 #if CONFIG_VP9_HIGHBITDEPTH
5327 cm->use_highbitdepth = use_highbitdepth;
5330 alloc_raw_frame_buffers(cpi);
5331 init_ref_frame_bufs(cm);
5332 alloc_util_frame_buffers(cpi);
5334 init_motion_estimation(cpi); // TODO(agrange) This can be removed.
5336 cpi->initial_width = cm->width;
5337 cpi->initial_height = cm->height;
5338 cpi->initial_mbs = cm->MBs;
5342 int vp9_receive_raw_frame(VP9_COMP *cpi, vpx_enc_frame_flags_t frame_flags,
5343 YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
5345 VP9_COMMON *const cm = &cpi->common;
5346 struct vpx_usec_timer timer;
5348 const int subsampling_x = sd->subsampling_x;
5349 const int subsampling_y = sd->subsampling_y;
5350 #if CONFIG_VP9_HIGHBITDEPTH
5351 const int use_highbitdepth = (sd->flags & YV12_FLAG_HIGHBITDEPTH) != 0;
5354 #if CONFIG_VP9_HIGHBITDEPTH
5355 check_initial_width(cpi, use_highbitdepth, subsampling_x, subsampling_y);
5357 check_initial_width(cpi, subsampling_x, subsampling_y);
5358 #endif // CONFIG_VP9_HIGHBITDEPTH
5360 #if CONFIG_VP9_HIGHBITDEPTH
5361 // Disable denoiser for high bitdepth since vp9_denoiser_filter only works for
5363 if (cm->bit_depth > 8) cpi->oxcf.noise_sensitivity = 0;
5366 #if CONFIG_VP9_TEMPORAL_DENOISING
5367 setup_denoiser_buffer(cpi);
5369 vpx_usec_timer_start(&timer);
5371 if (vp9_lookahead_push(cpi->lookahead, sd, time_stamp, end_time,
5372 #if CONFIG_VP9_HIGHBITDEPTH
5374 #endif // CONFIG_VP9_HIGHBITDEPTH
5377 vpx_usec_timer_mark(&timer);
5378 cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
5380 if ((cm->profile == PROFILE_0 || cm->profile == PROFILE_2) &&
5381 (subsampling_x != 1 || subsampling_y != 1)) {
5382 vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM,
5383 "Non-4:2:0 color format requires profile 1 or 3");
5386 if ((cm->profile == PROFILE_1 || cm->profile == PROFILE_3) &&
5387 (subsampling_x == 1 && subsampling_y == 1)) {
5388 vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM,
5389 "4:2:0 color format requires profile 0 or 2");
5396 static int frame_is_reference(const VP9_COMP *cpi) {
5397 const VP9_COMMON *cm = &cpi->common;
5399 return cm->frame_type == KEY_FRAME || cpi->refresh_last_frame ||
5400 cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame ||
5401 cm->refresh_frame_context || cm->lf.mode_ref_delta_update ||
5402 cm->seg.update_map || cm->seg.update_data;
5405 static void adjust_frame_rate(VP9_COMP *cpi,
5406 const struct lookahead_entry *source) {
5407 int64_t this_duration;
5410 if (source->ts_start == cpi->first_time_stamp_ever) {
5411 this_duration = source->ts_end - source->ts_start;
5414 int64_t last_duration =
5415 cpi->last_end_time_stamp_seen - cpi->last_time_stamp_seen;
5417 this_duration = source->ts_end - cpi->last_end_time_stamp_seen;
5419 // do a step update if the duration changes by 10%
5421 step = (int)((this_duration - last_duration) * 10 / last_duration);
5424 if (this_duration) {
5426 vp9_new_framerate(cpi, 10000000.0 / this_duration);
5428 // Average this frame's rate into the last second's average
5429 // frame rate. If we haven't seen 1 second yet, then average
5430 // over the whole interval seen.
5431 const double interval = VPXMIN(
5432 (double)(source->ts_end - cpi->first_time_stamp_ever), 10000000.0);
5433 double avg_duration = 10000000.0 / cpi->framerate;
5434 avg_duration *= (interval - avg_duration + this_duration);
5435 avg_duration /= interval;
5437 vp9_new_framerate(cpi, 10000000.0 / avg_duration);
5440 cpi->last_time_stamp_seen = source->ts_start;
5441 cpi->last_end_time_stamp_seen = source->ts_end;
5444 // Returns 0 if this is not an alt ref else the offset of the source frame
5445 // used as the arf midpoint.
5446 static int get_arf_src_index(VP9_COMP *cpi) {
5447 RATE_CONTROL *const rc = &cpi->rc;
5448 int arf_src_index = 0;
5449 if (is_altref_enabled(cpi)) {
5450 if (cpi->oxcf.pass == 2) {
5451 const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
5452 if (gf_group->update_type[gf_group->index] == ARF_UPDATE) {
5453 arf_src_index = gf_group->arf_src_offset[gf_group->index];
5455 } else if (rc->source_alt_ref_pending) {
5456 arf_src_index = rc->frames_till_gf_update_due;
5459 return arf_src_index;
5462 static void check_src_altref(VP9_COMP *cpi,
5463 const struct lookahead_entry *source) {
5464 RATE_CONTROL *const rc = &cpi->rc;
5466 if (cpi->oxcf.pass == 2) {
5467 const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
5468 rc->is_src_frame_alt_ref =
5469 (gf_group->update_type[gf_group->index] == OVERLAY_UPDATE);
5471 rc->is_src_frame_alt_ref =
5472 cpi->alt_ref_source && (source == cpi->alt_ref_source);
5475 if (rc->is_src_frame_alt_ref) {
5476 // Current frame is an ARF overlay frame.
5477 cpi->alt_ref_source = NULL;
5479 // Don't refresh the last buffer for an ARF overlay frame. It will
5480 // become the GF so preserve last as an alternative prediction option.
5481 cpi->refresh_last_frame = 0;
5485 #if CONFIG_INTERNAL_STATS
5486 static void adjust_image_stat(double y, double u, double v, double all,
5491 s->stat[ALL] += all;
5492 s->worst = VPXMIN(s->worst, all);
5494 #endif // CONFIG_INTERNAL_STATS
5496 // Adjust the maximum allowable frame size for the target level.
5497 static void level_rc_framerate(VP9_COMP *cpi, int arf_src_index) {
5498 RATE_CONTROL *const rc = &cpi->rc;
5499 LevelConstraint *const ls = &cpi->level_constraint;
5500 VP9_COMMON *const cm = &cpi->common;
5501 const double max_cpb_size = ls->max_cpb_size;
5502 vpx_clear_system_state();
5503 rc->max_frame_bandwidth = VPXMIN(rc->max_frame_bandwidth, ls->max_frame_size);
5504 if (frame_is_intra_only(cm)) {
5505 rc->max_frame_bandwidth =
5506 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.5));
5507 } else if (arf_src_index > 0) {
5508 rc->max_frame_bandwidth =
5509 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.4));
5511 rc->max_frame_bandwidth =
5512 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.2));
5516 static void update_level_info(VP9_COMP *cpi, size_t *size, int arf_src_index) {
5517 VP9_COMMON *const cm = &cpi->common;
5518 Vp9LevelInfo *const level_info = &cpi->level_info;
5519 Vp9LevelSpec *const level_spec = &level_info->level_spec;
5520 Vp9LevelStats *const level_stats = &level_info->level_stats;
5522 uint64_t luma_samples, dur_end;
5523 const uint32_t luma_pic_size = cm->width * cm->height;
5524 const uint32_t luma_pic_breadth = VPXMAX(cm->width, cm->height);
5525 LevelConstraint *const level_constraint = &cpi->level_constraint;
5526 const int8_t level_index = level_constraint->level_index;
5527 double cpb_data_size;
5529 vpx_clear_system_state();
5531 // update level_stats
5532 level_stats->total_compressed_size += *size;
5533 if (cm->show_frame) {
5534 level_stats->total_uncompressed_size +=
5536 2 * (luma_pic_size >> (cm->subsampling_x + cm->subsampling_y));
5537 level_stats->time_encoded =
5538 (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) /
5539 (double)TICKS_PER_SEC;
5542 if (arf_src_index > 0) {
5543 if (!level_stats->seen_first_altref) {
5544 level_stats->seen_first_altref = 1;
5545 } else if (level_stats->frames_since_last_altref <
5546 level_spec->min_altref_distance) {
5547 level_spec->min_altref_distance = level_stats->frames_since_last_altref;
5549 level_stats->frames_since_last_altref = 0;
5551 ++level_stats->frames_since_last_altref;
5554 if (level_stats->frame_window_buffer.len < FRAME_WINDOW_SIZE - 1) {
5555 idx = (level_stats->frame_window_buffer.start +
5556 level_stats->frame_window_buffer.len++) %
5559 idx = level_stats->frame_window_buffer.start;
5560 level_stats->frame_window_buffer.start = (idx + 1) % FRAME_WINDOW_SIZE;
5562 level_stats->frame_window_buffer.buf[idx].ts = cpi->last_time_stamp_seen;
5563 level_stats->frame_window_buffer.buf[idx].size = (uint32_t)(*size);
5564 level_stats->frame_window_buffer.buf[idx].luma_samples = luma_pic_size;
5566 if (cm->frame_type == KEY_FRAME) {
5567 level_stats->ref_refresh_map = 0;
5570 level_stats->ref_refresh_map |= vp9_get_refresh_mask(cpi);
5571 // Also need to consider the case where the encoder refers to a buffer
5572 // that has been implicitly refreshed after encoding a keyframe.
5573 if (!cm->intra_only) {
5574 level_stats->ref_refresh_map |= (1 << cpi->lst_fb_idx);
5575 level_stats->ref_refresh_map |= (1 << cpi->gld_fb_idx);
5576 level_stats->ref_refresh_map |= (1 << cpi->alt_fb_idx);
5578 for (i = 0; i < REF_FRAMES; ++i) {
5579 count += (level_stats->ref_refresh_map >> i) & 1;
5581 if (count > level_spec->max_ref_frame_buffers) {
5582 level_spec->max_ref_frame_buffers = count;
5586 // update average_bitrate
5587 level_spec->average_bitrate = (double)level_stats->total_compressed_size /
5588 125.0 / level_stats->time_encoded;
5590 // update max_luma_sample_rate
5592 for (i = 0; i < level_stats->frame_window_buffer.len; ++i) {
5593 idx = (level_stats->frame_window_buffer.start +
5594 level_stats->frame_window_buffer.len - 1 - i) %
5597 dur_end = level_stats->frame_window_buffer.buf[idx].ts;
5599 if (dur_end - level_stats->frame_window_buffer.buf[idx].ts >=
5603 luma_samples += level_stats->frame_window_buffer.buf[idx].luma_samples;
5605 if (luma_samples > level_spec->max_luma_sample_rate) {
5606 level_spec->max_luma_sample_rate = luma_samples;
5609 // update max_cpb_size
5611 for (i = 0; i < CPB_WINDOW_SIZE; ++i) {
5612 if (i >= level_stats->frame_window_buffer.len) break;
5613 idx = (level_stats->frame_window_buffer.start +
5614 level_stats->frame_window_buffer.len - 1 - i) %
5616 cpb_data_size += level_stats->frame_window_buffer.buf[idx].size;
5618 cpb_data_size = cpb_data_size / 125.0;
5619 if (cpb_data_size > level_spec->max_cpb_size) {
5620 level_spec->max_cpb_size = cpb_data_size;
5623 // update max_luma_picture_size
5624 if (luma_pic_size > level_spec->max_luma_picture_size) {
5625 level_spec->max_luma_picture_size = luma_pic_size;
5628 // update max_luma_picture_breadth
5629 if (luma_pic_breadth > level_spec->max_luma_picture_breadth) {
5630 level_spec->max_luma_picture_breadth = luma_pic_breadth;
5633 // update compression_ratio
5634 level_spec->compression_ratio = (double)level_stats->total_uncompressed_size *
5636 level_stats->total_compressed_size / 8.0;
5638 // update max_col_tiles
5639 if (level_spec->max_col_tiles < (1 << cm->log2_tile_cols)) {
5640 level_spec->max_col_tiles = (1 << cm->log2_tile_cols);
5643 if (level_index >= 0 && level_constraint->fail_flag == 0) {
5644 if (level_spec->max_luma_picture_size >
5645 vp9_level_defs[level_index].max_luma_picture_size) {
5646 level_constraint->fail_flag |= (1 << LUMA_PIC_SIZE_TOO_LARGE);
5647 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5648 "Failed to encode to the target level %d. %s",
5649 vp9_level_defs[level_index].level,
5650 level_fail_messages[LUMA_PIC_SIZE_TOO_LARGE]);
5653 if (level_spec->max_luma_picture_breadth >
5654 vp9_level_defs[level_index].max_luma_picture_breadth) {
5655 level_constraint->fail_flag |= (1 << LUMA_PIC_BREADTH_TOO_LARGE);
5656 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5657 "Failed to encode to the target level %d. %s",
5658 vp9_level_defs[level_index].level,
5659 level_fail_messages[LUMA_PIC_BREADTH_TOO_LARGE]);
5662 if ((double)level_spec->max_luma_sample_rate >
5663 (double)vp9_level_defs[level_index].max_luma_sample_rate *
5664 (1 + SAMPLE_RATE_GRACE_P)) {
5665 level_constraint->fail_flag |= (1 << LUMA_SAMPLE_RATE_TOO_LARGE);
5666 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5667 "Failed to encode to the target level %d. %s",
5668 vp9_level_defs[level_index].level,
5669 level_fail_messages[LUMA_SAMPLE_RATE_TOO_LARGE]);
5672 if (level_spec->max_col_tiles > vp9_level_defs[level_index].max_col_tiles) {
5673 level_constraint->fail_flag |= (1 << TOO_MANY_COLUMN_TILE);
5674 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5675 "Failed to encode to the target level %d. %s",
5676 vp9_level_defs[level_index].level,
5677 level_fail_messages[TOO_MANY_COLUMN_TILE]);
5680 if (level_spec->min_altref_distance <
5681 vp9_level_defs[level_index].min_altref_distance) {
5682 level_constraint->fail_flag |= (1 << ALTREF_DIST_TOO_SMALL);
5683 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5684 "Failed to encode to the target level %d. %s",
5685 vp9_level_defs[level_index].level,
5686 level_fail_messages[ALTREF_DIST_TOO_SMALL]);
5689 if (level_spec->max_ref_frame_buffers >
5690 vp9_level_defs[level_index].max_ref_frame_buffers) {
5691 level_constraint->fail_flag |= (1 << TOO_MANY_REF_BUFFER);
5692 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5693 "Failed to encode to the target level %d. %s",
5694 vp9_level_defs[level_index].level,
5695 level_fail_messages[TOO_MANY_REF_BUFFER]);
5698 if (level_spec->max_cpb_size > vp9_level_defs[level_index].max_cpb_size) {
5699 level_constraint->fail_flag |= (1 << CPB_TOO_LARGE);
5700 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5701 "Failed to encode to the target level %d. %s",
5702 vp9_level_defs[level_index].level,
5703 level_fail_messages[CPB_TOO_LARGE]);
5706 // Set an upper bound for the next frame size. It will be used in
5707 // level_rc_framerate() before encoding the next frame.
5709 for (i = 0; i < CPB_WINDOW_SIZE - 1; ++i) {
5710 if (i >= level_stats->frame_window_buffer.len) break;
5711 idx = (level_stats->frame_window_buffer.start +
5712 level_stats->frame_window_buffer.len - 1 - i) %
5714 cpb_data_size += level_stats->frame_window_buffer.buf[idx].size;
5716 cpb_data_size = cpb_data_size / 125.0;
5717 level_constraint->max_frame_size =
5718 (int)((vp9_level_defs[level_index].max_cpb_size - cpb_data_size) *
5720 if (level_stats->frame_window_buffer.len < CPB_WINDOW_SIZE - 1)
5721 level_constraint->max_frame_size >>= 1;
5725 typedef struct GF_PICTURE {
5726 YV12_BUFFER_CONFIG *frame;
5728 FRAME_UPDATE_TYPE update_type;
5731 static void init_gop_frames(VP9_COMP *cpi, GF_PICTURE *gf_picture,
5732 const GF_GROUP *gf_group, int *tpl_group_frames) {
5733 VP9_COMMON *cm = &cpi->common;
5739 int arf_index_stack[MAX_ARF_LAYERS];
5740 int arf_stack_size = 0;
5741 int extend_frame_count = 0;
5742 int pframe_qindex = cpi->tpl_stats[2].base_qindex;
5743 int frame_gop_offset = 0;
5745 RefCntBuffer *frame_bufs = cm->buffer_pool->frame_bufs;
5746 int8_t recon_frame_index[REFS_PER_FRAME + MAX_ARF_LAYERS];
5748 memset(recon_frame_index, -1, sizeof(recon_frame_index));
5749 stack_init(arf_index_stack, MAX_ARF_LAYERS);
5751 // TODO(jingning): To be used later for gf frame type parsing.
5754 for (i = 0; i < FRAME_BUFFERS; ++i) {
5755 if (frame_bufs[i].ref_count == 0) {
5756 alloc_frame_mvs(cm, i);
5757 if (vpx_realloc_frame_buffer(&frame_bufs[i].buf, cm->width, cm->height,
5758 cm->subsampling_x, cm->subsampling_y,
5759 #if CONFIG_VP9_HIGHBITDEPTH
5760 cm->use_highbitdepth,
5762 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
5764 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
5765 "Failed to allocate frame buffer");
5767 recon_frame_index[frame_idx] = i;
5770 if (frame_idx >= REFS_PER_FRAME + cpi->oxcf.enable_auto_arf) break;
5774 for (i = 0; i < REFS_PER_FRAME + 1; ++i) {
5775 assert(recon_frame_index[i] >= 0);
5776 cpi->tpl_recon_frames[i] = &frame_bufs[recon_frame_index[i]].buf;
5779 *tpl_group_frames = 0;
5781 // Initialize Golden reference frame.
5782 gf_picture[0].frame = get_ref_frame_buffer(cpi, GOLDEN_FRAME);
5783 for (i = 0; i < 3; ++i) gf_picture[0].ref_frame[i] = -1;
5784 gf_picture[0].update_type = gf_group->update_type[0];
5786 ++*tpl_group_frames;
5788 // Initialize base layer ARF frame
5789 gf_picture[1].frame = cpi->Source;
5790 gf_picture[1].ref_frame[0] = gld_index;
5791 gf_picture[1].ref_frame[1] = lst_index;
5792 gf_picture[1].ref_frame[2] = alt_index;
5793 gf_picture[1].update_type = gf_group->update_type[1];
5795 ++*tpl_group_frames;
5797 // Initialize P frames
5798 for (frame_idx = 2; frame_idx < MAX_ARF_GOP_SIZE; ++frame_idx) {
5799 struct lookahead_entry *buf;
5800 frame_gop_offset = gf_group->frame_gop_index[frame_idx];
5801 buf = vp9_lookahead_peek(cpi->lookahead, frame_gop_offset - 1);
5803 if (buf == NULL) break;
5805 gf_picture[frame_idx].frame = &buf->img;
5806 gf_picture[frame_idx].ref_frame[0] = gld_index;
5807 gf_picture[frame_idx].ref_frame[1] = lst_index;
5808 gf_picture[frame_idx].ref_frame[2] = alt_index;
5809 gf_picture[frame_idx].update_type = gf_group->update_type[frame_idx];
5811 switch (gf_group->update_type[frame_idx]) {
5813 stack_push(arf_index_stack, alt_index, arf_stack_size);
5815 alt_index = frame_idx;
5817 case LF_UPDATE: lst_index = frame_idx; break;
5818 case OVERLAY_UPDATE:
5819 gld_index = frame_idx;
5820 alt_index = stack_pop(arf_index_stack, arf_stack_size);
5824 lst_index = alt_index;
5825 alt_index = stack_pop(arf_index_stack, arf_stack_size);
5831 ++*tpl_group_frames;
5833 // The length of group of pictures is baseline_gf_interval, plus the
5834 // beginning golden frame from last GOP, plus the last overlay frame in
5836 if (frame_idx == gf_group->gf_group_size) break;
5843 // Extend two frames outside the current gf group.
5844 for (; frame_idx < MAX_LAG_BUFFERS && extend_frame_count < 2; ++frame_idx) {
5845 struct lookahead_entry *buf =
5846 vp9_lookahead_peek(cpi->lookahead, frame_gop_offset - 1);
5848 if (buf == NULL) break;
5850 cpi->tpl_stats[frame_idx].base_qindex = pframe_qindex;
5852 gf_picture[frame_idx].frame = &buf->img;
5853 gf_picture[frame_idx].ref_frame[0] = gld_index;
5854 gf_picture[frame_idx].ref_frame[1] = lst_index;
5855 gf_picture[frame_idx].ref_frame[2] = alt_index;
5856 gf_picture[frame_idx].update_type = LF_UPDATE;
5857 lst_index = frame_idx;
5858 ++*tpl_group_frames;
5859 ++extend_frame_count;
5864 static void init_tpl_stats(VP9_COMP *cpi) {
5866 for (frame_idx = 0; frame_idx < MAX_ARF_GOP_SIZE; ++frame_idx) {
5867 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
5868 memset(tpl_frame->tpl_stats_ptr, 0,
5869 tpl_frame->height * tpl_frame->width *
5870 sizeof(*tpl_frame->tpl_stats_ptr));
5871 tpl_frame->is_valid = 0;
5875 #if CONFIG_NON_GREEDY_MV
5876 static uint32_t full_pixel_motion_search(VP9_COMP *cpi, ThreadData *td,
5877 MotionField *motion_field,
5878 int frame_idx, uint8_t *cur_frame_buf,
5879 uint8_t *ref_frame_buf, int stride,
5880 BLOCK_SIZE bsize, int mi_row,
5881 int mi_col, MV *mv) {
5882 MACROBLOCK *const x = &td->mb;
5883 MACROBLOCKD *const xd = &x->e_mbd;
5884 MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
5886 uint32_t bestsme = UINT_MAX;
5887 const MvLimits tmp_mv_limits = x->mv_limits;
5888 // lambda is used to adjust the importance of motion vector consitency.
5889 // TODO(angiebird): Figure out lambda's proper value.
5890 const int lambda = cpi->tpl_stats[frame_idx].lambda;
5891 int_mv nb_full_mvs[NB_MVS_NUM];
5894 MV best_ref_mv1 = { 0, 0 };
5895 MV best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */
5897 best_ref_mv1_full.col = best_ref_mv1.col >> 3;
5898 best_ref_mv1_full.row = best_ref_mv1.row >> 3;
5900 // Setup frame pointers
5901 x->plane[0].src.buf = cur_frame_buf;
5902 x->plane[0].src.stride = stride;
5903 xd->plane[0].pre[0].buf = ref_frame_buf;
5904 xd->plane[0].pre[0].stride = stride;
5906 step_param = mv_sf->reduce_first_step_size;
5907 step_param = VPXMIN(step_param, MAX_MVSEARCH_STEPS - 2);
5909 vp9_set_mv_search_range(&x->mv_limits, &best_ref_mv1);
5912 vp9_prepare_nb_full_mvs(motion_field, mi_row, mi_col, nb_full_mvs);
5913 vp9_full_pixel_diamond_new(cpi, x, bsize, &best_ref_mv1_full, step_param,
5914 lambda, 1, nb_full_mvs, nb_full_mv_num, mv);
5916 /* restore UMV window */
5917 x->mv_limits = tmp_mv_limits;
5922 static uint32_t sub_pixel_motion_search(VP9_COMP *cpi, ThreadData *td,
5923 uint8_t *cur_frame_buf,
5924 uint8_t *ref_frame_buf, int stride,
5925 BLOCK_SIZE bsize, MV *mv) {
5926 MACROBLOCK *const x = &td->mb;
5927 MACROBLOCKD *const xd = &x->e_mbd;
5928 MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
5929 uint32_t bestsme = UINT_MAX;
5930 uint32_t distortion;
5934 MV best_ref_mv1 = { 0, 0 };
5936 // Setup frame pointers
5937 x->plane[0].src.buf = cur_frame_buf;
5938 x->plane[0].src.stride = stride;
5939 xd->plane[0].pre[0].buf = ref_frame_buf;
5940 xd->plane[0].pre[0].stride = stride;
5942 // TODO(yunqing): may use higher tap interp filter than 2 taps.
5943 // Ignore mv costing by sending NULL pointer instead of cost array
5944 bestsme = cpi->find_fractional_mv_step(
5945 x, mv, &best_ref_mv1, cpi->common.allow_high_precision_mv, x->errorperbit,
5946 &cpi->fn_ptr[bsize], 0, mv_sf->subpel_search_level,
5947 cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL, 0, 0,
5953 #else // CONFIG_NON_GREEDY_MV
5954 static uint32_t motion_compensated_prediction(VP9_COMP *cpi, ThreadData *td,
5955 uint8_t *cur_frame_buf,
5956 uint8_t *ref_frame_buf,
5957 int stride, BLOCK_SIZE bsize,
5959 MACROBLOCK *const x = &td->mb;
5960 MACROBLOCKD *const xd = &x->e_mbd;
5961 MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
5962 const SEARCH_METHODS search_method = NSTEP;
5964 int sadpb = x->sadperbit16;
5965 uint32_t bestsme = UINT_MAX;
5966 uint32_t distortion;
5969 const MvLimits tmp_mv_limits = x->mv_limits;
5971 MV best_ref_mv1 = { 0, 0 };
5972 MV best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */
5974 best_ref_mv1_full.col = best_ref_mv1.col >> 3;
5975 best_ref_mv1_full.row = best_ref_mv1.row >> 3;
5977 // Setup frame pointers
5978 x->plane[0].src.buf = cur_frame_buf;
5979 x->plane[0].src.stride = stride;
5980 xd->plane[0].pre[0].buf = ref_frame_buf;
5981 xd->plane[0].pre[0].stride = stride;
5983 step_param = mv_sf->reduce_first_step_size;
5984 step_param = VPXMIN(step_param, MAX_MVSEARCH_STEPS - 2);
5986 vp9_set_mv_search_range(&x->mv_limits, &best_ref_mv1);
5988 vp9_full_pixel_search(cpi, x, bsize, &best_ref_mv1_full, step_param,
5989 search_method, sadpb, cond_cost_list(cpi, cost_list),
5990 &best_ref_mv1, mv, 0, 0);
5992 /* restore UMV window */
5993 x->mv_limits = tmp_mv_limits;
5995 // TODO(yunqing): may use higher tap interp filter than 2 taps.
5996 // Ignore mv costing by sending NULL pointer instead of cost array
5997 bestsme = cpi->find_fractional_mv_step(
5998 x, mv, &best_ref_mv1, cpi->common.allow_high_precision_mv, x->errorperbit,
5999 &cpi->fn_ptr[bsize], 0, mv_sf->subpel_search_level,
6000 cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL, 0, 0,
6007 static int get_overlap_area(int grid_pos_row, int grid_pos_col, int ref_pos_row,
6008 int ref_pos_col, int block, BLOCK_SIZE bsize) {
6009 int width = 0, height = 0;
6010 int bw = 4 << b_width_log2_lookup[bsize];
6011 int bh = 4 << b_height_log2_lookup[bsize];
6015 width = grid_pos_col + bw - ref_pos_col;
6016 height = grid_pos_row + bh - ref_pos_row;
6019 width = ref_pos_col + bw - grid_pos_col;
6020 height = grid_pos_row + bh - ref_pos_row;
6023 width = grid_pos_col + bw - ref_pos_col;
6024 height = ref_pos_row + bh - grid_pos_row;
6027 width = ref_pos_col + bw - grid_pos_col;
6028 height = ref_pos_row + bh - grid_pos_row;
6033 return width * height;
6036 static int round_floor(int ref_pos, int bsize_pix) {
6039 round = -(1 + (-ref_pos - 1) / bsize_pix);
6041 round = ref_pos / bsize_pix;
6046 static void tpl_model_store(TplDepStats *tpl_stats, int mi_row, int mi_col,
6047 BLOCK_SIZE bsize, int stride) {
6048 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6049 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6050 const TplDepStats *src_stats = &tpl_stats[mi_row * stride + mi_col];
6053 for (idy = 0; idy < mi_height; ++idy) {
6054 for (idx = 0; idx < mi_width; ++idx) {
6055 TplDepStats *tpl_ptr = &tpl_stats[(mi_row + idy) * stride + mi_col + idx];
6056 const int64_t mc_flow = tpl_ptr->mc_flow;
6057 const int64_t mc_ref_cost = tpl_ptr->mc_ref_cost;
6058 *tpl_ptr = *src_stats;
6059 tpl_ptr->mc_flow = mc_flow;
6060 tpl_ptr->mc_ref_cost = mc_ref_cost;
6061 tpl_ptr->mc_dep_cost = tpl_ptr->intra_cost + tpl_ptr->mc_flow;
6066 static void tpl_model_update_b(TplDepFrame *tpl_frame, TplDepStats *tpl_stats,
6067 int mi_row, int mi_col, const BLOCK_SIZE bsize) {
6068 TplDepFrame *ref_tpl_frame = &tpl_frame[tpl_stats->ref_frame_index];
6069 TplDepStats *ref_stats = ref_tpl_frame->tpl_stats_ptr;
6070 MV mv = tpl_stats->mv.as_mv;
6071 int mv_row = mv.row >> 3;
6072 int mv_col = mv.col >> 3;
6074 int ref_pos_row = mi_row * MI_SIZE + mv_row;
6075 int ref_pos_col = mi_col * MI_SIZE + mv_col;
6077 const int bw = 4 << b_width_log2_lookup[bsize];
6078 const int bh = 4 << b_height_log2_lookup[bsize];
6079 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6080 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6081 const int pix_num = bw * bh;
6083 // top-left on grid block location in pixel
6084 int grid_pos_row_base = round_floor(ref_pos_row, bh) * bh;
6085 int grid_pos_col_base = round_floor(ref_pos_col, bw) * bw;
6088 for (block = 0; block < 4; ++block) {
6089 int grid_pos_row = grid_pos_row_base + bh * (block >> 1);
6090 int grid_pos_col = grid_pos_col_base + bw * (block & 0x01);
6092 if (grid_pos_row >= 0 && grid_pos_row < ref_tpl_frame->mi_rows * MI_SIZE &&
6093 grid_pos_col >= 0 && grid_pos_col < ref_tpl_frame->mi_cols * MI_SIZE) {
6094 int overlap_area = get_overlap_area(
6095 grid_pos_row, grid_pos_col, ref_pos_row, ref_pos_col, block, bsize);
6096 int ref_mi_row = round_floor(grid_pos_row, bh) * mi_height;
6097 int ref_mi_col = round_floor(grid_pos_col, bw) * mi_width;
6099 int64_t mc_flow = tpl_stats->mc_dep_cost -
6100 (tpl_stats->mc_dep_cost * tpl_stats->inter_cost) /
6101 tpl_stats->intra_cost;
6105 for (idy = 0; idy < mi_height; ++idy) {
6106 for (idx = 0; idx < mi_width; ++idx) {
6107 TplDepStats *des_stats =
6108 &ref_stats[(ref_mi_row + idy) * ref_tpl_frame->stride +
6109 (ref_mi_col + idx)];
6111 des_stats->mc_flow += (mc_flow * overlap_area) / pix_num;
6112 des_stats->mc_ref_cost +=
6113 ((tpl_stats->intra_cost - tpl_stats->inter_cost) * overlap_area) /
6115 assert(overlap_area >= 0);
6122 static void tpl_model_update(TplDepFrame *tpl_frame, TplDepStats *tpl_stats,
6123 int mi_row, int mi_col, const BLOCK_SIZE bsize) {
6125 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6126 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6128 for (idy = 0; idy < mi_height; ++idy) {
6129 for (idx = 0; idx < mi_width; ++idx) {
6130 TplDepStats *tpl_ptr =
6131 &tpl_stats[(mi_row + idy) * tpl_frame->stride + (mi_col + idx)];
6132 tpl_model_update_b(tpl_frame, tpl_ptr, mi_row + idy, mi_col + idx,
6138 static void get_quantize_error(MACROBLOCK *x, int plane, tran_low_t *coeff,
6139 tran_low_t *qcoeff, tran_low_t *dqcoeff,
6140 TX_SIZE tx_size, int64_t *recon_error,
6142 MACROBLOCKD *const xd = &x->e_mbd;
6143 const struct macroblock_plane *const p = &x->plane[plane];
6144 const struct macroblockd_plane *const pd = &xd->plane[plane];
6145 const scan_order *const scan_order = &vp9_default_scan_orders[tx_size];
6147 int pix_num = 1 << num_pels_log2_lookup[txsize_to_bsize[tx_size]];
6148 const int shift = tx_size == TX_32X32 ? 0 : 2;
6150 #if CONFIG_VP9_HIGHBITDEPTH
6151 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6152 vp9_highbd_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp,
6153 p->quant_fp, qcoeff, dqcoeff, pd->dequant,
6154 &eob, scan_order->scan, scan_order->iscan);
6156 vp9_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp,
6157 p->quant_fp, qcoeff, dqcoeff, pd->dequant, &eob,
6158 scan_order->scan, scan_order->iscan);
6161 vp9_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp, p->quant_fp,
6162 qcoeff, dqcoeff, pd->dequant, &eob, scan_order->scan,
6164 #endif // CONFIG_VP9_HIGHBITDEPTH
6166 *recon_error = vp9_block_error(coeff, dqcoeff, pix_num, sse) >> shift;
6167 *recon_error = VPXMAX(*recon_error, 1);
6169 *sse = (*sse) >> shift;
6170 *sse = VPXMAX(*sse, 1);
6173 #if CONFIG_VP9_HIGHBITDEPTH
6174 void highbd_wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
6176 // TODO(sdeng): Implement SIMD based high bit-depth Hadamard transforms.
6178 case TX_8X8: vpx_highbd_hadamard_8x8(src_diff, bw, coeff); break;
6179 case TX_16X16: vpx_highbd_hadamard_16x16(src_diff, bw, coeff); break;
6180 case TX_32X32: vpx_highbd_hadamard_32x32(src_diff, bw, coeff); break;
6184 #endif // CONFIG_VP9_HIGHBITDEPTH
6186 void wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
6189 case TX_8X8: vpx_hadamard_8x8(src_diff, bw, coeff); break;
6190 case TX_16X16: vpx_hadamard_16x16(src_diff, bw, coeff); break;
6191 case TX_32X32: vpx_hadamard_32x32(src_diff, bw, coeff); break;
6196 static void set_mv_limits(const VP9_COMMON *cm, MACROBLOCK *x, int mi_row,
6198 x->mv_limits.row_min = -((mi_row * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND));
6199 x->mv_limits.row_max =
6200 (cm->mi_rows - 1 - mi_row) * MI_SIZE + (17 - 2 * VP9_INTERP_EXTEND);
6201 x->mv_limits.col_min = -((mi_col * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND));
6202 x->mv_limits.col_max =
6203 ((cm->mi_cols - 1 - mi_col) * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND);
6206 static void mode_estimation(VP9_COMP *cpi, MACROBLOCK *x, MACROBLOCKD *xd,
6207 struct scale_factors *sf, GF_PICTURE *gf_picture,
6208 int frame_idx, TplDepFrame *tpl_frame,
6209 int16_t *src_diff, tran_low_t *coeff,
6210 tran_low_t *qcoeff, tran_low_t *dqcoeff, int mi_row,
6211 int mi_col, BLOCK_SIZE bsize, TX_SIZE tx_size,
6212 YV12_BUFFER_CONFIG *ref_frame[], uint8_t *predictor,
6213 int64_t *recon_error, int64_t *sse) {
6214 VP9_COMMON *cm = &cpi->common;
6215 ThreadData *td = &cpi->td;
6217 const int bw = 4 << b_width_log2_lookup[bsize];
6218 const int bh = 4 << b_height_log2_lookup[bsize];
6219 const int pix_num = bw * bh;
6220 int best_rf_idx = -1;
6222 int64_t best_inter_cost = INT64_MAX;
6225 const InterpKernel *const kernel = vp9_filter_kernels[EIGHTTAP];
6227 int64_t best_intra_cost = INT64_MAX;
6229 PREDICTION_MODE mode;
6230 int mb_y_offset = mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6231 MODE_INFO mi_above, mi_left;
6232 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6233 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6234 TplDepStats *tpl_stats =
6235 &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
6237 xd->mb_to_top_edge = -((mi_row * MI_SIZE) * 8);
6238 xd->mb_to_bottom_edge = ((cm->mi_rows - 1 - mi_row) * MI_SIZE) * 8;
6239 xd->mb_to_left_edge = -((mi_col * MI_SIZE) * 8);
6240 xd->mb_to_right_edge = ((cm->mi_cols - 1 - mi_col) * MI_SIZE) * 8;
6241 xd->above_mi = (mi_row > 0) ? &mi_above : NULL;
6242 xd->left_mi = (mi_col > 0) ? &mi_left : NULL;
6244 // Intra prediction search
6245 for (mode = DC_PRED; mode <= TM_PRED; ++mode) {
6247 int src_stride, dst_stride;
6249 src = xd->cur_buf->y_buffer + mb_y_offset;
6250 src_stride = xd->cur_buf->y_stride;
6252 dst = &predictor[0];
6255 xd->mi[0]->sb_type = bsize;
6256 xd->mi[0]->ref_frame[0] = INTRA_FRAME;
6258 vp9_predict_intra_block(xd, b_width_log2_lookup[bsize], tx_size, mode, src,
6259 src_stride, dst, dst_stride, 0, 0, 0);
6261 #if CONFIG_VP9_HIGHBITDEPTH
6262 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6263 vpx_highbd_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst,
6264 dst_stride, xd->bd);
6265 highbd_wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6266 intra_cost = vpx_highbd_satd(coeff, pix_num);
6268 vpx_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst,
6270 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6271 intra_cost = vpx_satd(coeff, pix_num);
6274 vpx_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst, dst_stride);
6275 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6276 intra_cost = vpx_satd(coeff, pix_num);
6277 #endif // CONFIG_VP9_HIGHBITDEPTH
6279 if (intra_cost < best_intra_cost) best_intra_cost = intra_cost;
6282 // Motion compensated prediction
6285 set_mv_limits(cm, x, mi_row, mi_col);
6287 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6289 #if CONFIG_NON_GREEDY_MV
6290 MotionField *motion_field;
6292 if (ref_frame[rf_idx] == NULL) continue;
6294 #if CONFIG_NON_GREEDY_MV
6296 motion_field = vp9_motion_field_info_get_motion_field(
6297 &cpi->motion_field_info, frame_idx, rf_idx, bsize);
6298 mv = vp9_motion_field_mi_get_mv(motion_field, mi_row, mi_col);
6300 motion_compensated_prediction(cpi, td, xd->cur_buf->y_buffer + mb_y_offset,
6301 ref_frame[rf_idx]->y_buffer + mb_y_offset,
6302 xd->cur_buf->y_stride, bsize, &mv.as_mv);
6305 #if CONFIG_VP9_HIGHBITDEPTH
6306 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6307 vp9_highbd_build_inter_predictor(
6308 CONVERT_TO_SHORTPTR(ref_frame[rf_idx]->y_buffer + mb_y_offset),
6309 ref_frame[rf_idx]->y_stride, CONVERT_TO_SHORTPTR(&predictor[0]), bw,
6310 &mv.as_mv, sf, bw, bh, 0, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE,
6311 mi_row * MI_SIZE, xd->bd);
6312 vpx_highbd_subtract_block(
6313 bh, bw, src_diff, bw, xd->cur_buf->y_buffer + mb_y_offset,
6314 xd->cur_buf->y_stride, &predictor[0], bw, xd->bd);
6315 highbd_wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6316 inter_cost = vpx_highbd_satd(coeff, pix_num);
6318 vp9_build_inter_predictor(
6319 ref_frame[rf_idx]->y_buffer + mb_y_offset,
6320 ref_frame[rf_idx]->y_stride, &predictor[0], bw, &mv.as_mv, sf, bw, bh,
6321 0, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE, mi_row * MI_SIZE);
6322 vpx_subtract_block(bh, bw, src_diff, bw,
6323 xd->cur_buf->y_buffer + mb_y_offset,
6324 xd->cur_buf->y_stride, &predictor[0], bw);
6325 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6326 inter_cost = vpx_satd(coeff, pix_num);
6329 vp9_build_inter_predictor(ref_frame[rf_idx]->y_buffer + mb_y_offset,
6330 ref_frame[rf_idx]->y_stride, &predictor[0], bw,
6331 &mv.as_mv, sf, bw, bh, 0, kernel, MV_PRECISION_Q3,
6332 mi_col * MI_SIZE, mi_row * MI_SIZE);
6333 vpx_subtract_block(bh, bw, src_diff, bw,
6334 xd->cur_buf->y_buffer + mb_y_offset,
6335 xd->cur_buf->y_stride, &predictor[0], bw);
6336 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6337 inter_cost = vpx_satd(coeff, pix_num);
6340 if (inter_cost < best_inter_cost) {
6341 best_rf_idx = rf_idx;
6342 best_inter_cost = inter_cost;
6343 best_mv.as_int = mv.as_int;
6344 get_quantize_error(x, 0, coeff, qcoeff, dqcoeff, tx_size, recon_error,
6348 best_intra_cost = VPXMAX(best_intra_cost, 1);
6349 best_inter_cost = VPXMIN(best_intra_cost, best_inter_cost);
6350 tpl_stats->inter_cost = VPXMAX(
6351 1, (best_inter_cost << TPL_DEP_COST_SCALE_LOG2) / (mi_height * mi_width));
6352 tpl_stats->intra_cost = VPXMAX(
6353 1, (best_intra_cost << TPL_DEP_COST_SCALE_LOG2) / (mi_height * mi_width));
6354 tpl_stats->ref_frame_index = gf_picture[frame_idx].ref_frame[best_rf_idx];
6355 tpl_stats->mv.as_int = best_mv.as_int;
6358 #if CONFIG_NON_GREEDY_MV
6359 static int get_block_src_pred_buf(MACROBLOCKD *xd, GF_PICTURE *gf_picture,
6360 int frame_idx, int rf_idx, int mi_row,
6361 int mi_col, struct buf_2d *src,
6362 struct buf_2d *pre) {
6363 const int mb_y_offset =
6364 mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6365 YV12_BUFFER_CONFIG *ref_frame = NULL;
6366 int ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
6367 if (ref_frame_idx != -1) {
6368 ref_frame = gf_picture[ref_frame_idx].frame;
6369 src->buf = xd->cur_buf->y_buffer + mb_y_offset;
6370 src->stride = xd->cur_buf->y_stride;
6371 pre->buf = ref_frame->y_buffer + mb_y_offset;
6372 pre->stride = ref_frame->y_stride;
6373 assert(src->stride == pre->stride);
6376 printf("invalid ref_frame_idx");
6377 assert(ref_frame_idx != -1);
6382 #define kMvPreCheckLines 5
6383 #define kMvPreCheckSize 15
6385 #define MV_REF_POS_NUM 3
6386 POSITION mv_ref_pos[MV_REF_POS_NUM] = {
6392 static int_mv *get_select_mv(VP9_COMP *cpi, TplDepFrame *tpl_frame, int mi_row,
6394 return &cpi->select_mv_arr[mi_row * tpl_frame->stride + mi_col];
6397 static int_mv find_ref_mv(int mv_mode, VP9_COMP *cpi, TplDepFrame *tpl_frame,
6398 BLOCK_SIZE bsize, int mi_row, int mi_col) {
6400 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6401 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6402 int_mv nearest_mv, near_mv, invalid_mv;
6403 nearest_mv.as_int = INVALID_MV;
6404 near_mv.as_int = INVALID_MV;
6405 invalid_mv.as_int = INVALID_MV;
6406 for (i = 0; i < MV_REF_POS_NUM; ++i) {
6407 int nb_row = mi_row + mv_ref_pos[i].row * mi_height;
6408 int nb_col = mi_col + mv_ref_pos[i].col * mi_width;
6409 assert(mv_ref_pos[i].row <= 0);
6410 assert(mv_ref_pos[i].col <= 0);
6411 if (nb_row >= 0 && nb_col >= 0) {
6412 if (nearest_mv.as_int == INVALID_MV) {
6413 nearest_mv = *get_select_mv(cpi, tpl_frame, nb_row, nb_col);
6415 int_mv mv = *get_select_mv(cpi, tpl_frame, nb_row, nb_col);
6416 if (mv.as_int == nearest_mv.as_int) {
6425 if (nearest_mv.as_int == INVALID_MV) {
6426 nearest_mv.as_mv.row = 0;
6427 nearest_mv.as_mv.col = 0;
6429 if (near_mv.as_int == INVALID_MV) {
6430 near_mv.as_mv.row = 0;
6431 near_mv.as_mv.col = 0;
6433 if (mv_mode == NEAREST_MV_MODE) {
6436 if (mv_mode == NEAR_MV_MODE) {
6443 static int_mv get_mv_from_mv_mode(int mv_mode, VP9_COMP *cpi,
6444 MotionField *motion_field,
6445 TplDepFrame *tpl_frame, BLOCK_SIZE bsize,
6446 int mi_row, int mi_col) {
6454 mv = vp9_motion_field_mi_get_mv(motion_field, mi_row, mi_col);
6456 case NEAREST_MV_MODE:
6457 mv = find_ref_mv(mv_mode, cpi, tpl_frame, bsize, mi_row, mi_col);
6460 mv = find_ref_mv(mv_mode, cpi, tpl_frame, bsize, mi_row, mi_col);
6463 mv.as_int = INVALID_MV;
6470 static double get_mv_dist(int mv_mode, VP9_COMP *cpi, MACROBLOCKD *xd,
6471 GF_PICTURE *gf_picture, MotionField *motion_field,
6472 int frame_idx, TplDepFrame *tpl_frame, int rf_idx,
6473 BLOCK_SIZE bsize, int mi_row, int mi_col,
6479 *mv = get_mv_from_mv_mode(mv_mode, cpi, motion_field, tpl_frame, bsize,
6481 full_mv = get_full_mv(&mv->as_mv);
6482 if (get_block_src_pred_buf(xd, gf_picture, frame_idx, rf_idx, mi_row, mi_col,
6484 // TODO(angiebird): Consider subpixel when computing the sse.
6485 cpi->fn_ptr[bsize].vf(src.buf, src.stride, get_buf_from_mv(&pre, &full_mv),
6487 return (double)(sse << VP9_DIST_SCALE_LOG2);
6494 static int get_mv_mode_cost(int mv_mode) {
6495 // TODO(angiebird): The probabilities are roughly inferred from
6496 // default_inter_mode_probs. Check if there is a better way to set the
6498 const int zero_mv_prob = 16;
6499 const int new_mv_prob = 24 * 1;
6500 const int ref_mv_prob = 256 - zero_mv_prob - new_mv_prob;
6501 assert(zero_mv_prob + new_mv_prob + ref_mv_prob == 256);
6503 case ZERO_MV_MODE: return vp9_prob_cost[zero_mv_prob]; break;
6504 case NEW_MV_MODE: return vp9_prob_cost[new_mv_prob]; break;
6505 case NEAREST_MV_MODE: return vp9_prob_cost[ref_mv_prob]; break;
6506 case NEAR_MV_MODE: return vp9_prob_cost[ref_mv_prob]; break;
6507 default: assert(0); return -1;
6511 static INLINE double get_mv_diff_cost(MV *new_mv, MV *ref_mv) {
6512 double mv_diff_cost = log2(1 + abs(new_mv->row - ref_mv->row)) +
6513 log2(1 + abs(new_mv->col - ref_mv->col));
6514 mv_diff_cost *= (1 << VP9_PROB_COST_SHIFT);
6515 return mv_diff_cost;
6517 static double get_mv_cost(int mv_mode, VP9_COMP *cpi, MotionField *motion_field,
6518 TplDepFrame *tpl_frame, BLOCK_SIZE bsize, int mi_row,
6520 double mv_cost = get_mv_mode_cost(mv_mode);
6521 if (mv_mode == NEW_MV_MODE) {
6522 MV new_mv = get_mv_from_mv_mode(mv_mode, cpi, motion_field, tpl_frame,
6523 bsize, mi_row, mi_col)
6525 MV nearest_mv = get_mv_from_mv_mode(NEAREST_MV_MODE, cpi, motion_field,
6526 tpl_frame, bsize, mi_row, mi_col)
6528 MV near_mv = get_mv_from_mv_mode(NEAR_MV_MODE, cpi, motion_field, tpl_frame,
6529 bsize, mi_row, mi_col)
6531 double nearest_cost = get_mv_diff_cost(&new_mv, &nearest_mv);
6532 double near_cost = get_mv_diff_cost(&new_mv, &near_mv);
6533 mv_cost += nearest_cost < near_cost ? nearest_cost : near_cost;
6538 static double eval_mv_mode(int mv_mode, VP9_COMP *cpi, MACROBLOCK *x,
6539 GF_PICTURE *gf_picture, MotionField *motion_field,
6540 int frame_idx, TplDepFrame *tpl_frame, int rf_idx,
6541 BLOCK_SIZE bsize, int mi_row, int mi_col,
6543 MACROBLOCKD *xd = &x->e_mbd;
6545 get_mv_dist(mv_mode, cpi, xd, gf_picture, motion_field, frame_idx,
6546 tpl_frame, rf_idx, bsize, mi_row, mi_col, mv);
6548 get_mv_cost(mv_mode, cpi, motion_field, tpl_frame, bsize, mi_row, mi_col);
6551 return mv_cost + mult * log2f(1 + mv_dist);
6554 static int find_best_ref_mv_mode(VP9_COMP *cpi, MACROBLOCK *x,
6555 GF_PICTURE *gf_picture,
6556 MotionField *motion_field, int frame_idx,
6557 TplDepFrame *tpl_frame, int rf_idx,
6558 BLOCK_SIZE bsize, int mi_row, int mi_col,
6559 double *rd, int_mv *mv) {
6560 int best_mv_mode = ZERO_MV_MODE;
6564 for (mv_mode = 0; mv_mode < MAX_MV_MODE; ++mv_mode) {
6567 if (mv_mode == NEW_MV_MODE) {
6570 this_rd = eval_mv_mode(mv_mode, cpi, x, gf_picture, motion_field, frame_idx,
6571 tpl_frame, rf_idx, bsize, mi_row, mi_col, &this_mv);
6575 best_mv_mode = mv_mode;
6578 if (this_rd < *rd) {
6581 best_mv_mode = mv_mode;
6585 return best_mv_mode;
6588 static void predict_mv_mode(VP9_COMP *cpi, MACROBLOCK *x,
6589 GF_PICTURE *gf_picture, MotionField *motion_field,
6590 int frame_idx, TplDepFrame *tpl_frame, int rf_idx,
6591 BLOCK_SIZE bsize, int mi_row, int mi_col) {
6592 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6593 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6594 int tmp_mv_mode_arr[kMvPreCheckSize];
6595 int *mv_mode_arr = tpl_frame->mv_mode_arr[rf_idx];
6596 double *rd_diff_arr = tpl_frame->rd_diff_arr[rf_idx];
6597 int_mv *select_mv_arr = cpi->select_mv_arr;
6598 int_mv tmp_select_mv_arr[kMvPreCheckSize];
6599 int stride = tpl_frame->stride;
6600 double new_mv_rd = 0;
6601 double no_new_mv_rd = 0;
6602 double this_new_mv_rd = 0;
6603 double this_no_new_mv_rd = 0;
6606 assert(kMvPreCheckSize == (kMvPreCheckLines * (kMvPreCheckLines + 1)) >> 1);
6609 // diagnal scan order
6611 for (idx = 0; idx < kMvPreCheckLines; ++idx) {
6613 for (r = 0; r <= idx; ++r) {
6615 int nb_row = mi_row + r * mi_height;
6616 int nb_col = mi_col + c * mi_width;
6617 if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6619 int_mv *mv = &select_mv_arr[nb_row * stride + nb_col];
6620 mv_mode_arr[nb_row * stride + nb_col] = find_best_ref_mv_mode(
6621 cpi, x, gf_picture, motion_field, frame_idx, tpl_frame, rf_idx,
6622 bsize, nb_row, nb_col, &this_rd, mv);
6623 if (r == 0 && c == 0) {
6624 this_no_new_mv_rd = this_rd;
6626 no_new_mv_rd += this_rd;
6627 tmp_mv_mode_arr[tmp_idx] = mv_mode_arr[nb_row * stride + nb_col];
6628 tmp_select_mv_arr[tmp_idx] = select_mv_arr[nb_row * stride + nb_col];
6635 mv_mode_arr[mi_row * stride + mi_col] = NEW_MV_MODE;
6636 this_new_mv_rd = eval_mv_mode(
6637 NEW_MV_MODE, cpi, x, gf_picture, motion_field, frame_idx, tpl_frame,
6638 rf_idx, bsize, mi_row, mi_col, &select_mv_arr[mi_row * stride + mi_col]);
6639 new_mv_rd = this_new_mv_rd;
6640 // We start from idx = 1 because idx = 0 is evaluated as NEW_MV_MODE
6642 for (idx = 1; idx < kMvPreCheckLines; ++idx) {
6644 for (r = 0; r <= idx; ++r) {
6646 int nb_row = mi_row + r * mi_height;
6647 int nb_col = mi_col + c * mi_width;
6648 if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6650 int_mv *mv = &select_mv_arr[nb_row * stride + nb_col];
6651 mv_mode_arr[nb_row * stride + nb_col] = find_best_ref_mv_mode(
6652 cpi, x, gf_picture, motion_field, frame_idx, tpl_frame, rf_idx,
6653 bsize, nb_row, nb_col, &this_rd, mv);
6654 new_mv_rd += this_rd;
6659 // update best_mv_mode
6661 if (no_new_mv_rd < new_mv_rd) {
6662 for (idx = 0; idx < kMvPreCheckLines; ++idx) {
6664 for (r = 0; r <= idx; ++r) {
6666 int nb_row = mi_row + r * mi_height;
6667 int nb_col = mi_col + c * mi_width;
6668 if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6669 mv_mode_arr[nb_row * stride + nb_col] = tmp_mv_mode_arr[tmp_idx];
6670 select_mv_arr[nb_row * stride + nb_col] = tmp_select_mv_arr[tmp_idx];
6675 rd_diff_arr[mi_row * stride + mi_col] = 0;
6677 rd_diff_arr[mi_row * stride + mi_col] =
6678 (no_new_mv_rd - this_no_new_mv_rd) - (new_mv_rd - this_new_mv_rd);
6682 static void predict_mv_mode_arr(VP9_COMP *cpi, MACROBLOCK *x,
6683 GF_PICTURE *gf_picture,
6684 MotionField *motion_field, int frame_idx,
6685 TplDepFrame *tpl_frame, int rf_idx,
6687 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6688 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6689 const int unit_rows = tpl_frame->mi_rows / mi_height;
6690 const int unit_cols = tpl_frame->mi_cols / mi_width;
6691 const int max_diagonal_lines = unit_rows + unit_cols - 1;
6693 for (idx = 0; idx < max_diagonal_lines; ++idx) {
6695 for (r = VPXMAX(idx - unit_cols + 1, 0); r <= VPXMIN(idx, unit_rows - 1);
6698 int mi_row = r * mi_height;
6699 int mi_col = c * mi_width;
6700 assert(c >= 0 && c < unit_cols);
6701 assert(mi_row >= 0 && mi_row < tpl_frame->mi_rows);
6702 assert(mi_col >= 0 && mi_col < tpl_frame->mi_cols);
6703 predict_mv_mode(cpi, x, gf_picture, motion_field, frame_idx, tpl_frame,
6704 rf_idx, bsize, mi_row, mi_col);
6709 static double get_feature_score(uint8_t *buf, ptrdiff_t stride, int rows,
6716 vpx_clear_system_state();
6717 for (r = 0; r + 1 < rows; ++r) {
6718 for (c = 0; c + 1 < cols; ++c) {
6719 int diff_x = buf[r * stride + c] - buf[r * stride + c + 1];
6720 int diff_y = buf[r * stride + c] - buf[(r + 1) * stride + c];
6721 IxIx += diff_x * diff_x;
6722 IxIy += diff_x * diff_y;
6723 IyIy += diff_y * diff_y;
6726 IxIx /= (rows - 1) * (cols - 1);
6727 IxIy /= (rows - 1) * (cols - 1);
6728 IyIy /= (rows - 1) * (cols - 1);
6729 score = (IxIx * IyIy - IxIy * IxIy + 0.0001) / (IxIx + IyIy + 0.0001);
6733 static int compare_feature_score(const void *a, const void *b) {
6734 const FEATURE_SCORE_LOC *aa = *(FEATURE_SCORE_LOC *const *)a;
6735 const FEATURE_SCORE_LOC *bb = *(FEATURE_SCORE_LOC *const *)b;
6736 if (aa->feature_score < bb->feature_score) {
6738 } else if (aa->feature_score > bb->feature_score) {
6745 static void do_motion_search(VP9_COMP *cpi, ThreadData *td,
6746 MotionField *motion_field, int frame_idx,
6747 YV12_BUFFER_CONFIG *ref_frame, BLOCK_SIZE bsize,
6748 int mi_row, int mi_col) {
6749 VP9_COMMON *cm = &cpi->common;
6750 MACROBLOCK *x = &td->mb;
6751 MACROBLOCKD *xd = &x->e_mbd;
6752 const int mb_y_offset =
6753 mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6754 assert(ref_frame != NULL);
6755 set_mv_limits(cm, x, mi_row, mi_col);
6757 int_mv mv = vp9_motion_field_mi_get_mv(motion_field, mi_row, mi_col);
6758 uint8_t *cur_frame_buf = xd->cur_buf->y_buffer + mb_y_offset;
6759 uint8_t *ref_frame_buf = ref_frame->y_buffer + mb_y_offset;
6760 const int stride = xd->cur_buf->y_stride;
6761 full_pixel_motion_search(cpi, td, motion_field, frame_idx, cur_frame_buf,
6762 ref_frame_buf, stride, bsize, mi_row, mi_col,
6764 sub_pixel_motion_search(cpi, td, cur_frame_buf, ref_frame_buf, stride,
6766 vp9_motion_field_mi_set_mv(motion_field, mi_row, mi_col, mv);
6770 #define CHANGE_MV_SEARCH_ORDER 1
6771 #define USE_PQSORT 1
6773 #if CHANGE_MV_SEARCH_ORDER
6775 static void max_heap_pop(FEATURE_SCORE_LOC **heap, int *size,
6776 FEATURE_SCORE_LOC **output) {
6782 heap[0] = heap[*size];
6787 FEATURE_SCORE_LOC *tmp;
6789 if (r < *size && heap[r]->feature_score > heap[l]->feature_score) {
6792 if (heap[p]->feature_score >= heap[c]->feature_score) {
6808 static void max_heap_push(FEATURE_SCORE_LOC **heap, int *size,
6809 FEATURE_SCORE_LOC *input) {
6811 FEATURE_SCORE_LOC *tmp;
6813 heap[*size] = input;
6817 while (c > 0 && heap[c]->feature_score > heap[p]->feature_score) {
6826 static void add_nb_blocks_to_heap(VP9_COMP *cpi, const TplDepFrame *tpl_frame,
6827 BLOCK_SIZE bsize, int mi_row, int mi_col,
6829 const int mi_unit = num_8x8_blocks_wide_lookup[bsize];
6830 const int dirs[NB_MVS_NUM][2] = { { -1, 0 }, { 0, -1 }, { 1, 0 }, { 0, 1 } };
6832 for (i = 0; i < NB_MVS_NUM; ++i) {
6833 int r = dirs[i][0] * mi_unit;
6834 int c = dirs[i][1] * mi_unit;
6835 if (mi_row + r >= 0 && mi_row + r < tpl_frame->mi_rows && mi_col + c >= 0 &&
6836 mi_col + c < tpl_frame->mi_cols) {
6837 FEATURE_SCORE_LOC *fs_loc =
6838 &cpi->feature_score_loc_arr[(mi_row + r) * tpl_frame->stride +
6840 if (fs_loc->visited == 0) {
6841 max_heap_push(cpi->feature_score_loc_heap, heap_size, fs_loc);
6846 #endif // USE_PQSORT
6847 #endif // CHANGE_MV_SEARCH_ORDER
6849 static void build_motion_field(
6850 VP9_COMP *cpi, MACROBLOCKD *xd, int frame_idx,
6851 YV12_BUFFER_CONFIG *ref_frame[MAX_INTER_REF_FRAMES], BLOCK_SIZE bsize) {
6852 VP9_COMMON *cm = &cpi->common;
6853 ThreadData *td = &cpi->td;
6854 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6855 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6856 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6857 const int pw = num_4x4_blocks_wide_lookup[bsize] << 2;
6858 const int ph = num_4x4_blocks_high_lookup[bsize] << 2;
6859 int fs_loc_sort_size;
6860 int fs_loc_heap_size;
6864 tpl_frame->lambda = (pw * ph) >> 2;
6865 assert(pw * ph == tpl_frame->lambda << 2);
6867 fs_loc_sort_size = 0;
6868 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6869 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6870 const int mb_y_offset =
6871 mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6872 const int bw = 4 << b_width_log2_lookup[bsize];
6873 const int bh = 4 << b_height_log2_lookup[bsize];
6874 FEATURE_SCORE_LOC *fs_loc =
6875 &cpi->feature_score_loc_arr[mi_row * tpl_frame->stride + mi_col];
6876 fs_loc->feature_score = get_feature_score(
6877 xd->cur_buf->y_buffer + mb_y_offset, xd->cur_buf->y_stride, bw, bh);
6878 fs_loc->visited = 0;
6879 fs_loc->mi_row = mi_row;
6880 fs_loc->mi_col = mi_col;
6881 cpi->feature_score_loc_sort[fs_loc_sort_size] = fs_loc;
6886 qsort(cpi->feature_score_loc_sort, fs_loc_sort_size,
6887 sizeof(*cpi->feature_score_loc_sort), compare_feature_score);
6889 // TODO(angiebird): Clean up this part.
6890 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6892 MotionField *motion_field = vp9_motion_field_info_get_motion_field(
6893 &cpi->motion_field_info, frame_idx, rf_idx, bsize);
6894 if (ref_frame[rf_idx] == NULL) {
6897 vp9_motion_field_reset_mvs(motion_field);
6898 #if CHANGE_MV_SEARCH_ORDER
6900 for (i = 0; i < fs_loc_sort_size; ++i) {
6901 FEATURE_SCORE_LOC *fs_loc = cpi->feature_score_loc_sort[i];
6902 do_motion_search(cpi, td, motion_field, frame_idx, ref_frame[rf_idx],
6903 bsize, fs_loc->mi_row, fs_loc->mi_col);
6905 #else // !USE_PQSORT
6906 fs_loc_heap_size = 0;
6907 max_heap_push(cpi->feature_score_loc_heap, &fs_loc_heap_size,
6908 cpi->feature_score_loc_sort[0]);
6910 for (i = 0; i < fs_loc_sort_size; ++i) {
6911 cpi->feature_score_loc_sort[i]->visited = 0;
6914 while (fs_loc_heap_size > 0) {
6915 FEATURE_SCORE_LOC *fs_loc;
6916 max_heap_pop(cpi->feature_score_loc_heap, &fs_loc_heap_size, &fs_loc);
6918 do_motion_search(cpi, td, motion_field, frame_idx, ref_frame[rf_idx],
6919 bsize, fs_loc->mi_row, fs_loc->mi_col);
6921 add_nb_blocks_to_heap(cpi, tpl_frame, bsize, fs_loc->mi_row,
6922 fs_loc->mi_col, &fs_loc_heap_size);
6924 #endif // !USE_PQSORT
6925 #else // CHANGE_MV_SEARCH_ORDER
6926 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6927 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6928 do_motion_search(cpi, td, motion_field, frame_idx, ref_frame[rf_idx],
6929 bsize, mi_row, mi_col);
6932 #endif // CHANGE_MV_SEARCH_ORDER
6935 #endif // CONFIG_NON_GREEDY_MV
6937 static void mc_flow_dispenser(VP9_COMP *cpi, GF_PICTURE *gf_picture,
6938 int frame_idx, BLOCK_SIZE bsize) {
6939 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6940 YV12_BUFFER_CONFIG *this_frame = gf_picture[frame_idx].frame;
6941 YV12_BUFFER_CONFIG *ref_frame[MAX_INTER_REF_FRAMES] = { NULL, NULL, NULL };
6943 VP9_COMMON *cm = &cpi->common;
6944 struct scale_factors sf;
6946 ThreadData *td = &cpi->td;
6947 MACROBLOCK *x = &td->mb;
6948 MACROBLOCKD *xd = &x->e_mbd;
6951 #if CONFIG_VP9_HIGHBITDEPTH
6952 DECLARE_ALIGNED(16, uint16_t, predictor16[32 * 32 * 3]);
6953 DECLARE_ALIGNED(16, uint8_t, predictor8[32 * 32 * 3]);
6956 DECLARE_ALIGNED(16, uint8_t, predictor[32 * 32 * 3]);
6958 DECLARE_ALIGNED(16, int16_t, src_diff[32 * 32]);
6959 DECLARE_ALIGNED(16, tran_low_t, coeff[32 * 32]);
6960 DECLARE_ALIGNED(16, tran_low_t, qcoeff[32 * 32]);
6961 DECLARE_ALIGNED(16, tran_low_t, dqcoeff[32 * 32]);
6963 const TX_SIZE tx_size = max_txsize_lookup[bsize];
6964 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6965 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6966 int64_t recon_error, sse;
6967 #if CONFIG_NON_GREEDY_MV
6968 int square_block_idx;
6972 // Setup scaling factor
6973 #if CONFIG_VP9_HIGHBITDEPTH
6974 vp9_setup_scale_factors_for_frame(
6975 &sf, this_frame->y_crop_width, this_frame->y_crop_height,
6976 this_frame->y_crop_width, this_frame->y_crop_height,
6977 cpi->common.use_highbitdepth);
6979 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH)
6980 predictor = CONVERT_TO_BYTEPTR(predictor16);
6982 predictor = predictor8;
6984 vp9_setup_scale_factors_for_frame(
6985 &sf, this_frame->y_crop_width, this_frame->y_crop_height,
6986 this_frame->y_crop_width, this_frame->y_crop_height);
6987 #endif // CONFIG_VP9_HIGHBITDEPTH
6989 // Prepare reference frame pointers. If any reference frame slot is
6990 // unavailable, the pointer will be set to Null.
6991 for (idx = 0; idx < MAX_INTER_REF_FRAMES; ++idx) {
6992 int rf_idx = gf_picture[frame_idx].ref_frame[idx];
6993 if (rf_idx != -1) ref_frame[idx] = gf_picture[rf_idx].frame;
6996 xd->mi = cm->mi_grid_visible;
6998 xd->cur_buf = this_frame;
7000 // Get rd multiplier set up.
7001 rdmult = vp9_compute_rd_mult_based_on_qindex(cpi, tpl_frame->base_qindex);
7002 set_error_per_bit(&cpi->td.mb, rdmult);
7003 vp9_initialize_me_consts(cpi, &cpi->td.mb, tpl_frame->base_qindex);
7005 tpl_frame->is_valid = 1;
7007 cm->base_qindex = tpl_frame->base_qindex;
7008 vp9_frame_init_quantizer(cpi);
7010 #if CONFIG_NON_GREEDY_MV
7011 for (square_block_idx = 0; square_block_idx < SQUARE_BLOCK_SIZES;
7012 ++square_block_idx) {
7013 BLOCK_SIZE square_bsize = square_block_idx_to_bsize(square_block_idx);
7014 build_motion_field(cpi, xd, frame_idx, ref_frame, square_bsize);
7016 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
7017 int ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
7018 if (ref_frame_idx != -1) {
7019 MotionField *motion_field = vp9_motion_field_info_get_motion_field(
7020 &cpi->motion_field_info, frame_idx, rf_idx, bsize);
7021 predict_mv_mode_arr(cpi, x, gf_picture, motion_field, frame_idx,
7022 tpl_frame, rf_idx, bsize);
7027 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
7028 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
7029 mode_estimation(cpi, x, xd, &sf, gf_picture, frame_idx, tpl_frame,
7030 src_diff, coeff, qcoeff, dqcoeff, mi_row, mi_col, bsize,
7031 tx_size, ref_frame, predictor, &recon_error, &sse);
7032 // Motion flow dependency dispenser.
7033 tpl_model_store(tpl_frame->tpl_stats_ptr, mi_row, mi_col, bsize,
7036 tpl_model_update(cpi->tpl_stats, tpl_frame->tpl_stats_ptr, mi_row, mi_col,
7042 #if CONFIG_NON_GREEDY_MV
7043 #define DUMP_TPL_STATS 0
7045 static void dump_buf(uint8_t *buf, int stride, int row, int col, int h, int w) {
7047 printf("%d %d\n", h, w);
7048 for (i = 0; i < h; ++i) {
7049 for (j = 0; j < w; ++j) {
7050 printf("%d ", buf[(row + i) * stride + col + j]);
7056 static void dump_frame_buf(const YV12_BUFFER_CONFIG *frame_buf) {
7057 dump_buf(frame_buf->y_buffer, frame_buf->y_stride, 0, 0, frame_buf->y_height,
7058 frame_buf->y_width);
7059 dump_buf(frame_buf->u_buffer, frame_buf->uv_stride, 0, 0,
7060 frame_buf->uv_height, frame_buf->uv_width);
7061 dump_buf(frame_buf->v_buffer, frame_buf->uv_stride, 0, 0,
7062 frame_buf->uv_height, frame_buf->uv_width);
7065 static void dump_tpl_stats(const VP9_COMP *cpi, int tpl_group_frames,
7066 const GF_GROUP *gf_group,
7067 const GF_PICTURE *gf_picture, BLOCK_SIZE bsize) {
7069 const VP9_COMMON *cm = &cpi->common;
7071 for (frame_idx = 1; frame_idx < tpl_group_frames; ++frame_idx) {
7072 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
7073 const TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
7076 const int mi_height = num_8x8_blocks_high_lookup[bsize];
7077 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
7078 ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
7079 if (ref_frame_idx != -1) {
7080 YV12_BUFFER_CONFIG *ref_frame_buf = gf_picture[ref_frame_idx].frame;
7081 const int gf_frame_offset = gf_group->frame_gop_index[frame_idx];
7082 const int ref_gf_frame_offset =
7083 gf_group->frame_gop_index[ref_frame_idx];
7086 "frame_idx %d mi_rows %d mi_cols %d bsize %d ref_frame_idx %d "
7087 "rf_idx %d gf_frame_offset %d ref_gf_frame_offset %d\n",
7088 frame_idx, cm->mi_rows, cm->mi_cols, mi_width * MI_SIZE,
7089 ref_frame_idx, rf_idx, gf_frame_offset, ref_gf_frame_offset);
7090 for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row) {
7091 for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) {
7092 if ((mi_row % mi_height) == 0 && (mi_col % mi_width) == 0) {
7093 int_mv mv = vp9_motion_field_info_get_mv(&cpi->motion_field_info,
7094 frame_idx, rf_idx, bsize,
7096 printf("%d %d %d %d\n", mi_row, mi_col, mv.as_mv.row,
7101 for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row) {
7102 for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) {
7103 if ((mi_row % mi_height) == 0 && (mi_col % mi_width) == 0) {
7104 const TplDepStats *tpl_ptr =
7106 ->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
7107 printf("%f ", tpl_ptr->feature_score);
7113 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
7114 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
7117 ->mv_mode_arr[rf_idx][mi_row * tpl_frame->stride + mi_col];
7118 printf("%d ", mv_mode);
7123 dump_frame_buf(gf_picture[frame_idx].frame);
7124 dump_frame_buf(ref_frame_buf);
7129 #endif // DUMP_TPL_STATS
7130 #endif // CONFIG_NON_GREEDY_MV
7132 static void init_tpl_buffer(VP9_COMP *cpi) {
7133 VP9_COMMON *cm = &cpi->common;
7136 const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
7137 const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
7138 #if CONFIG_NON_GREEDY_MV
7141 // TODO(angiebird): This probably needs further modifications to support
7142 // frame scaling later on.
7143 Status status = vp9_alloc_motion_field_info(
7144 &cpi->motion_field_info, MAX_ARF_GOP_SIZE, mi_rows, mi_cols);
7145 if (status == STATUS_FAILED) {
7146 vpx_internal_error(&(cm)->error, VPX_CODEC_MEM_ERROR,
7147 "vp9_alloc_motion_field_info failed");
7150 if (cpi->feature_score_loc_alloc == 0) {
7151 // The smallest block size of motion field is 4x4, but the mi_unit is 8x8,
7152 // therefore the number of units is "mi_rows * mi_cols * 4" here.
7154 cm, cpi->feature_score_loc_arr,
7155 vpx_calloc(mi_rows * mi_cols * 4, sizeof(*cpi->feature_score_loc_arr)));
7156 CHECK_MEM_ERROR(cm, cpi->feature_score_loc_sort,
7157 vpx_calloc(mi_rows * mi_cols * 4,
7158 sizeof(*cpi->feature_score_loc_sort)));
7159 CHECK_MEM_ERROR(cm, cpi->feature_score_loc_heap,
7160 vpx_calloc(mi_rows * mi_cols * 4,
7161 sizeof(*cpi->feature_score_loc_heap)));
7163 cpi->feature_score_loc_alloc = 1;
7165 vpx_free(cpi->select_mv_arr);
7167 cm, cpi->select_mv_arr,
7168 vpx_calloc(mi_rows * mi_cols * 4, sizeof(*cpi->select_mv_arr)));
7171 // TODO(jingning): Reduce the actual memory use for tpl model build up.
7172 for (frame = 0; frame < MAX_ARF_GOP_SIZE; ++frame) {
7173 if (cpi->tpl_stats[frame].width >= mi_cols &&
7174 cpi->tpl_stats[frame].height >= mi_rows &&
7175 cpi->tpl_stats[frame].tpl_stats_ptr)
7178 #if CONFIG_NON_GREEDY_MV
7179 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
7180 vpx_free(cpi->tpl_stats[frame].mv_mode_arr[rf_idx]);
7182 cm, cpi->tpl_stats[frame].mv_mode_arr[rf_idx],
7183 vpx_calloc(mi_rows * mi_cols * 4,
7184 sizeof(*cpi->tpl_stats[frame].mv_mode_arr[rf_idx])));
7185 vpx_free(cpi->tpl_stats[frame].rd_diff_arr[rf_idx]);
7187 cm, cpi->tpl_stats[frame].rd_diff_arr[rf_idx],
7188 vpx_calloc(mi_rows * mi_cols * 4,
7189 sizeof(*cpi->tpl_stats[frame].rd_diff_arr[rf_idx])));
7192 vpx_free(cpi->tpl_stats[frame].tpl_stats_ptr);
7193 CHECK_MEM_ERROR(cm, cpi->tpl_stats[frame].tpl_stats_ptr,
7194 vpx_calloc(mi_rows * mi_cols,
7195 sizeof(*cpi->tpl_stats[frame].tpl_stats_ptr)));
7196 cpi->tpl_stats[frame].is_valid = 0;
7197 cpi->tpl_stats[frame].width = mi_cols;
7198 cpi->tpl_stats[frame].height = mi_rows;
7199 cpi->tpl_stats[frame].stride = mi_cols;
7200 cpi->tpl_stats[frame].mi_rows = cm->mi_rows;
7201 cpi->tpl_stats[frame].mi_cols = cm->mi_cols;
7204 for (frame = 0; frame < REF_FRAMES; ++frame) {
7205 cpi->enc_frame_buf[frame].mem_valid = 0;
7206 cpi->enc_frame_buf[frame].released = 1;
7210 static void free_tpl_buffer(VP9_COMP *cpi) {
7212 #if CONFIG_NON_GREEDY_MV
7213 vp9_free_motion_field_info(&cpi->motion_field_info);
7214 vpx_free(cpi->feature_score_loc_arr);
7215 vpx_free(cpi->feature_score_loc_sort);
7216 vpx_free(cpi->feature_score_loc_heap);
7217 vpx_free(cpi->select_mv_arr);
7219 for (frame = 0; frame < MAX_ARF_GOP_SIZE; ++frame) {
7220 #if CONFIG_NON_GREEDY_MV
7222 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
7223 vpx_free(cpi->tpl_stats[frame].mv_mode_arr[rf_idx]);
7224 vpx_free(cpi->tpl_stats[frame].rd_diff_arr[rf_idx]);
7227 vpx_free(cpi->tpl_stats[frame].tpl_stats_ptr);
7228 cpi->tpl_stats[frame].is_valid = 0;
7232 static void setup_tpl_stats(VP9_COMP *cpi) {
7233 GF_PICTURE gf_picture[MAX_ARF_GOP_SIZE];
7234 const GF_GROUP *gf_group = &cpi->twopass.gf_group;
7235 int tpl_group_frames = 0;
7237 cpi->tpl_bsize = BLOCK_32X32;
7239 init_gop_frames(cpi, gf_picture, gf_group, &tpl_group_frames);
7241 init_tpl_stats(cpi);
7243 // Backward propagation from tpl_group_frames to 1.
7244 for (frame_idx = tpl_group_frames - 1; frame_idx > 0; --frame_idx) {
7245 if (gf_picture[frame_idx].update_type == USE_BUF_FRAME) continue;
7246 mc_flow_dispenser(cpi, gf_picture, frame_idx, cpi->tpl_bsize);
7248 #if CONFIG_NON_GREEDY_MV
7251 dump_tpl_stats(cpi, tpl_group_frames, gf_group, gf_picture, cpi->tpl_bsize);
7252 #endif // DUMP_TPL_STATS
7253 #endif // CONFIG_NON_GREEDY_MV
7256 int vp9_get_compressed_data(VP9_COMP *cpi, unsigned int *frame_flags,
7257 size_t *size, uint8_t *dest, int64_t *time_stamp,
7258 int64_t *time_end, int flush) {
7259 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
7260 VP9_COMMON *const cm = &cpi->common;
7261 BufferPool *const pool = cm->buffer_pool;
7262 RATE_CONTROL *const rc = &cpi->rc;
7263 struct vpx_usec_timer cmptimer;
7264 YV12_BUFFER_CONFIG *force_src_buffer = NULL;
7265 struct lookahead_entry *last_source = NULL;
7266 struct lookahead_entry *source = NULL;
7268 const int gf_group_index = cpi->twopass.gf_group.index;
7271 if (is_one_pass_cbr_svc(cpi)) {
7272 vp9_one_pass_cbr_svc_start_layer(cpi);
7275 vpx_usec_timer_start(&cmptimer);
7277 vp9_set_high_precision_mv(cpi, ALTREF_HIGH_PRECISION_MV);
7279 // Is multi-arf enabled.
7280 // Note that at the moment multi_arf is only configured for 2 pass VBR and
7281 // will not work properly with svc.
7282 // Enable the Jingning's new "multi_layer_arf" code if "enable_auto_arf"
7283 // is greater than or equal to 2.
7284 if ((oxcf->pass == 2) && !cpi->use_svc && (cpi->oxcf.enable_auto_arf >= 2))
7285 cpi->multi_layer_arf = 1;
7287 cpi->multi_layer_arf = 0;
7290 cm->reset_frame_context = 0;
7291 cm->refresh_frame_context = 1;
7292 if (!is_one_pass_cbr_svc(cpi)) {
7293 cpi->refresh_last_frame = 1;
7294 cpi->refresh_golden_frame = 0;
7295 cpi->refresh_alt_ref_frame = 0;
7298 // Should we encode an arf frame.
7299 arf_src_index = get_arf_src_index(cpi);
7301 if (arf_src_index) {
7302 for (i = 0; i <= arf_src_index; ++i) {
7303 struct lookahead_entry *e = vp9_lookahead_peek(cpi->lookahead, i);
7304 // Avoid creating an alt-ref if there's a forced keyframe pending.
7307 } else if (e->flags == VPX_EFLAG_FORCE_KF) {
7315 // Clear arf index stack before group of pictures processing starts.
7316 if (gf_group_index == 1) {
7317 stack_init(cpi->twopass.gf_group.arf_index_stack, MAX_LAG_BUFFERS * 2);
7318 cpi->twopass.gf_group.stack_size = 0;
7321 if (arf_src_index) {
7322 assert(arf_src_index <= rc->frames_to_key);
7323 if ((source = vp9_lookahead_peek(cpi->lookahead, arf_src_index)) != NULL) {
7324 cpi->alt_ref_source = source;
7326 #if !CONFIG_REALTIME_ONLY
7327 if ((oxcf->mode != REALTIME) && (oxcf->arnr_max_frames > 0) &&
7328 (oxcf->arnr_strength > 0)) {
7329 int bitrate = cpi->rc.avg_frame_bandwidth / 40;
7330 int not_low_bitrate = bitrate > ALT_REF_AQ_LOW_BITRATE_BOUNDARY;
7332 int not_last_frame = (cpi->lookahead->sz - arf_src_index > 1);
7333 not_last_frame |= ALT_REF_AQ_APPLY_TO_LAST_FRAME;
7335 // Produce the filtered ARF frame.
7336 vp9_temporal_filter(cpi, arf_src_index);
7337 vpx_extend_frame_borders(&cpi->alt_ref_buffer);
7339 // for small bitrates segmentation overhead usually
7340 // eats all bitrate gain from enabling delta quantizers
7341 if (cpi->oxcf.alt_ref_aq != 0 && not_low_bitrate && not_last_frame)
7342 vp9_alt_ref_aq_setup_mode(cpi->alt_ref_aq, cpi);
7344 force_src_buffer = &cpi->alt_ref_buffer;
7349 cpi->refresh_alt_ref_frame = 1;
7350 cpi->refresh_golden_frame = 0;
7351 cpi->refresh_last_frame = 0;
7352 rc->is_src_frame_alt_ref = 0;
7353 rc->source_alt_ref_pending = 0;
7355 rc->source_alt_ref_pending = 0;
7360 // Get last frame source.
7361 if (cm->current_video_frame > 0) {
7362 if ((last_source = vp9_lookahead_peek(cpi->lookahead, -1)) == NULL)
7366 // Read in the source frame.
7367 if (cpi->use_svc || cpi->svc.set_intra_only_frame)
7368 source = vp9_svc_lookahead_pop(cpi, cpi->lookahead, flush);
7370 source = vp9_lookahead_pop(cpi->lookahead, flush);
7372 if (source != NULL) {
7375 // if the flags indicate intra frame, but if the current picture is for
7376 // non-zero spatial layer, it should not be an intra picture.
7377 if ((source->flags & VPX_EFLAG_FORCE_KF) && cpi->use_svc &&
7378 cpi->svc.spatial_layer_id > 0) {
7379 source->flags &= ~(unsigned int)(VPX_EFLAG_FORCE_KF);
7382 // Check to see if the frame should be encoded as an arf overlay.
7383 check_src_altref(cpi, source);
7388 cpi->un_scaled_source = cpi->Source =
7389 force_src_buffer ? force_src_buffer : &source->img;
7391 #ifdef ENABLE_KF_DENOISE
7392 // Copy of raw source for metrics calculation.
7393 if (is_psnr_calc_enabled(cpi))
7394 vp9_copy_and_extend_frame(cpi->Source, &cpi->raw_unscaled_source);
7397 cpi->unscaled_last_source = last_source != NULL ? &last_source->img : NULL;
7399 *time_stamp = source->ts_start;
7400 *time_end = source->ts_end;
7401 *frame_flags = (source->flags & VPX_EFLAG_FORCE_KF) ? FRAMEFLAGS_KEY : 0;
7404 #if !CONFIG_REALTIME_ONLY
7405 if (flush && oxcf->pass == 1 && !cpi->twopass.first_pass_done) {
7406 vp9_end_first_pass(cpi); /* get last stats packet */
7407 cpi->twopass.first_pass_done = 1;
7409 #endif // !CONFIG_REALTIME_ONLY
7413 if (source->ts_start < cpi->first_time_stamp_ever) {
7414 cpi->first_time_stamp_ever = source->ts_start;
7415 cpi->last_end_time_stamp_seen = source->ts_start;
7418 // Clear down mmx registers
7419 vpx_clear_system_state();
7421 // adjust frame rates based on timestamps given
7422 if (cm->show_frame) {
7423 if (cpi->use_svc && cpi->svc.use_set_ref_frame_config &&
7424 cpi->svc.duration[cpi->svc.spatial_layer_id] > 0)
7425 vp9_svc_adjust_frame_rate(cpi);
7427 adjust_frame_rate(cpi, source);
7430 if (is_one_pass_cbr_svc(cpi)) {
7431 vp9_update_temporal_layer_framerate(cpi);
7432 vp9_restore_layer_context(cpi);
7435 // Find a free buffer for the new frame, releasing the reference previously
7437 if (cm->new_fb_idx != INVALID_IDX) {
7438 --pool->frame_bufs[cm->new_fb_idx].ref_count;
7440 cm->new_fb_idx = get_free_fb(cm);
7442 if (cm->new_fb_idx == INVALID_IDX) return -1;
7444 cm->cur_frame = &pool->frame_bufs[cm->new_fb_idx];
7446 // Start with a 0 size frame.
7449 cpi->frame_flags = *frame_flags;
7451 #if !CONFIG_REALTIME_ONLY
7452 if ((oxcf->pass == 2) && !cpi->use_svc) {
7453 vp9_rc_get_second_pass_params(cpi);
7454 } else if (oxcf->pass == 1) {
7455 set_frame_size(cpi);
7457 #endif // !CONFIG_REALTIME_ONLY
7459 if (oxcf->pass != 1 && cpi->level_constraint.level_index >= 0 &&
7460 cpi->level_constraint.fail_flag == 0)
7461 level_rc_framerate(cpi, arf_src_index);
7463 if (cpi->oxcf.pass != 0 || cpi->use_svc || frame_is_intra_only(cm) == 1) {
7464 for (i = 0; i < REFS_PER_FRAME; ++i) cpi->scaled_ref_idx[i] = INVALID_IDX;
7467 if (cpi->kmeans_data_arr_alloc == 0) {
7468 const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
7469 const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
7470 #if CONFIG_MULTITHREAD
7471 pthread_mutex_init(&cpi->kmeans_mutex, NULL);
7474 cm, cpi->kmeans_data_arr,
7475 vpx_calloc(mi_rows * mi_cols, sizeof(*cpi->kmeans_data_arr)));
7476 cpi->kmeans_data_stride = mi_cols;
7477 cpi->kmeans_data_arr_alloc = 1;
7480 if (gf_group_index == 1 &&
7481 cpi->twopass.gf_group.update_type[gf_group_index] == ARF_UPDATE &&
7482 cpi->sf.enable_tpl_model) {
7483 init_tpl_buffer(cpi);
7484 vp9_estimate_qp_gop(cpi);
7485 setup_tpl_stats(cpi);
7488 #if CONFIG_BITSTREAM_DEBUG
7489 assert(cpi->oxcf.max_threads == 0 &&
7490 "bitstream debug tool does not support multithreading");
7491 bitstream_queue_record_write();
7493 #if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
7494 bitstream_queue_set_frame_write(cm->current_video_frame * 2 + cm->show_frame);
7497 cpi->td.mb.fp_src_pred = 0;
7498 #if CONFIG_REALTIME_ONLY
7500 SvcEncode(cpi, size, dest, frame_flags);
7503 Pass0Encode(cpi, size, dest, frame_flags);
7505 #else // !CONFIG_REALTIME_ONLY
7506 if (oxcf->pass == 1 && !cpi->use_svc) {
7507 const int lossless = is_lossless_requested(oxcf);
7508 #if CONFIG_VP9_HIGHBITDEPTH
7509 if (cpi->oxcf.use_highbitdepth)
7510 cpi->td.mb.fwd_txfm4x4 =
7511 lossless ? vp9_highbd_fwht4x4 : vpx_highbd_fdct4x4;
7513 cpi->td.mb.fwd_txfm4x4 = lossless ? vp9_fwht4x4 : vpx_fdct4x4;
7514 cpi->td.mb.highbd_inv_txfm_add =
7515 lossless ? vp9_highbd_iwht4x4_add : vp9_highbd_idct4x4_add;
7517 cpi->td.mb.fwd_txfm4x4 = lossless ? vp9_fwht4x4 : vpx_fdct4x4;
7518 #endif // CONFIG_VP9_HIGHBITDEPTH
7519 cpi->td.mb.inv_txfm_add = lossless ? vp9_iwht4x4_add : vp9_idct4x4_add;
7520 vp9_first_pass(cpi, source);
7521 } else if (oxcf->pass == 2 && !cpi->use_svc) {
7522 Pass2Encode(cpi, size, dest, frame_flags);
7523 } else if (cpi->use_svc) {
7524 SvcEncode(cpi, size, dest, frame_flags);
7527 Pass0Encode(cpi, size, dest, frame_flags);
7529 #endif // CONFIG_REALTIME_ONLY
7531 if (cm->show_frame) cm->cur_show_frame_fb_idx = cm->new_fb_idx;
7533 if (cm->refresh_frame_context)
7534 cm->frame_contexts[cm->frame_context_idx] = *cm->fc;
7536 // No frame encoded, or frame was dropped, release scaled references.
7537 if ((*size == 0) && (frame_is_intra_only(cm) == 0)) {
7538 release_scaled_references(cpi);
7542 cpi->droppable = !frame_is_reference(cpi);
7545 // Save layer specific state.
7546 if (is_one_pass_cbr_svc(cpi) || ((cpi->svc.number_temporal_layers > 1 ||
7547 cpi->svc.number_spatial_layers > 1) &&
7549 vp9_save_layer_context(cpi);
7552 vpx_usec_timer_mark(&cmptimer);
7553 cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
7555 // Should we calculate metrics for the frame.
7556 if (is_psnr_calc_enabled(cpi)) generate_psnr_packet(cpi);
7558 if (cpi->keep_level_stats && oxcf->pass != 1)
7559 update_level_info(cpi, size, arf_src_index);
7561 #if CONFIG_INTERNAL_STATS
7563 if (oxcf->pass != 1) {
7564 double samples = 0.0;
7565 cpi->bytes += (int)(*size);
7567 if (cm->show_frame) {
7568 uint32_t bit_depth = 8;
7569 uint32_t in_bit_depth = 8;
7571 #if CONFIG_VP9_HIGHBITDEPTH
7572 if (cm->use_highbitdepth) {
7573 in_bit_depth = cpi->oxcf.input_bit_depth;
7574 bit_depth = cm->bit_depth;
7578 if (cpi->b_calculate_psnr) {
7579 YV12_BUFFER_CONFIG *orig = cpi->raw_source_frame;
7580 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
7581 YV12_BUFFER_CONFIG *pp = &cm->post_proc_buffer;
7583 #if CONFIG_VP9_HIGHBITDEPTH
7584 vpx_calc_highbd_psnr(orig, recon, &psnr, cpi->td.mb.e_mbd.bd,
7587 vpx_calc_psnr(orig, recon, &psnr);
7588 #endif // CONFIG_VP9_HIGHBITDEPTH
7590 adjust_image_stat(psnr.psnr[1], psnr.psnr[2], psnr.psnr[3],
7591 psnr.psnr[0], &cpi->psnr);
7592 cpi->total_sq_error += psnr.sse[0];
7593 cpi->total_samples += psnr.samples[0];
7594 samples = psnr.samples[0];
7598 double frame_ssim2 = 0, weight = 0;
7599 #if CONFIG_VP9_POSTPROC
7600 if (vpx_alloc_frame_buffer(
7601 pp, recon->y_crop_width, recon->y_crop_height,
7602 cm->subsampling_x, cm->subsampling_y,
7603 #if CONFIG_VP9_HIGHBITDEPTH
7604 cm->use_highbitdepth,
7606 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment) < 0) {
7607 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
7608 "Failed to allocate post processing buffer");
7611 vp9_ppflags_t ppflags;
7612 ppflags.post_proc_flag = VP9D_DEBLOCK;
7613 ppflags.deblocking_level = 0; // not used in vp9_post_proc_frame()
7614 ppflags.noise_level = 0; // not used in vp9_post_proc_frame()
7615 vp9_post_proc_frame(cm, pp, &ppflags,
7616 cpi->un_scaled_source->y_width);
7619 vpx_clear_system_state();
7621 #if CONFIG_VP9_HIGHBITDEPTH
7622 vpx_calc_highbd_psnr(orig, pp, &psnr2, cpi->td.mb.e_mbd.bd,
7623 cpi->oxcf.input_bit_depth);
7625 vpx_calc_psnr(orig, pp, &psnr2);
7626 #endif // CONFIG_VP9_HIGHBITDEPTH
7628 cpi->totalp_sq_error += psnr2.sse[0];
7629 cpi->totalp_samples += psnr2.samples[0];
7630 adjust_image_stat(psnr2.psnr[1], psnr2.psnr[2], psnr2.psnr[3],
7631 psnr2.psnr[0], &cpi->psnrp);
7633 #if CONFIG_VP9_HIGHBITDEPTH
7634 if (cm->use_highbitdepth) {
7635 frame_ssim2 = vpx_highbd_calc_ssim(orig, recon, &weight, bit_depth,
7638 frame_ssim2 = vpx_calc_ssim(orig, recon, &weight);
7641 frame_ssim2 = vpx_calc_ssim(orig, recon, &weight);
7642 #endif // CONFIG_VP9_HIGHBITDEPTH
7644 cpi->worst_ssim = VPXMIN(cpi->worst_ssim, frame_ssim2);
7645 cpi->summed_quality += frame_ssim2 * weight;
7646 cpi->summed_weights += weight;
7648 #if CONFIG_VP9_HIGHBITDEPTH
7649 if (cm->use_highbitdepth) {
7650 frame_ssim2 = vpx_highbd_calc_ssim(orig, pp, &weight, bit_depth,
7653 frame_ssim2 = vpx_calc_ssim(orig, pp, &weight);
7656 frame_ssim2 = vpx_calc_ssim(orig, pp, &weight);
7657 #endif // CONFIG_VP9_HIGHBITDEPTH
7659 cpi->summedp_quality += frame_ssim2 * weight;
7660 cpi->summedp_weights += weight;
7662 if (cm->show_frame) {
7663 FILE *f = fopen("q_used.stt", "a");
7664 fprintf(f, "%5d : Y%f7.3:U%f7.3:V%f7.3:F%f7.3:S%7.3f\n",
7665 cpi->common.current_video_frame, psnr2.psnr[1],
7666 psnr2.psnr[2], psnr2.psnr[3], psnr2.psnr[0], frame_ssim2);
7672 if (cpi->b_calculate_blockiness) {
7673 #if CONFIG_VP9_HIGHBITDEPTH
7674 if (!cm->use_highbitdepth)
7677 double frame_blockiness = vp9_get_blockiness(
7678 cpi->Source->y_buffer, cpi->Source->y_stride,
7679 cm->frame_to_show->y_buffer, cm->frame_to_show->y_stride,
7680 cpi->Source->y_width, cpi->Source->y_height);
7681 cpi->worst_blockiness =
7682 VPXMAX(cpi->worst_blockiness, frame_blockiness);
7683 cpi->total_blockiness += frame_blockiness;
7687 if (cpi->b_calculate_consistency) {
7688 #if CONFIG_VP9_HIGHBITDEPTH
7689 if (!cm->use_highbitdepth)
7692 double this_inconsistency = vpx_get_ssim_metrics(
7693 cpi->Source->y_buffer, cpi->Source->y_stride,
7694 cm->frame_to_show->y_buffer, cm->frame_to_show->y_stride,
7695 cpi->Source->y_width, cpi->Source->y_height, cpi->ssim_vars,
7698 const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1);
7699 double consistency =
7700 vpx_sse_to_psnr(samples, peak, (double)cpi->total_inconsistency);
7701 if (consistency > 0.0)
7702 cpi->worst_consistency =
7703 VPXMIN(cpi->worst_consistency, consistency);
7704 cpi->total_inconsistency += this_inconsistency;
7709 double y, u, v, frame_all;
7710 frame_all = vpx_calc_fastssim(cpi->Source, cm->frame_to_show, &y, &u,
7711 &v, bit_depth, in_bit_depth);
7712 adjust_image_stat(y, u, v, frame_all, &cpi->fastssim);
7715 double y, u, v, frame_all;
7716 frame_all = vpx_psnrhvs(cpi->Source, cm->frame_to_show, &y, &u, &v,
7717 bit_depth, in_bit_depth);
7718 adjust_image_stat(y, u, v, frame_all, &cpi->psnrhvs);
7725 if (is_one_pass_cbr_svc(cpi)) {
7726 if (cm->show_frame) {
7727 ++cpi->svc.spatial_layer_to_encode;
7728 if (cpi->svc.spatial_layer_to_encode >= cpi->svc.number_spatial_layers)
7729 cpi->svc.spatial_layer_to_encode = 0;
7733 vpx_clear_system_state();
7737 int vp9_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest,
7738 vp9_ppflags_t *flags) {
7739 VP9_COMMON *cm = &cpi->common;
7740 #if !CONFIG_VP9_POSTPROC
7744 if (!cm->show_frame) {
7748 #if CONFIG_VP9_POSTPROC
7749 ret = vp9_post_proc_frame(cm, dest, flags, cpi->un_scaled_source->y_width);
7751 if (cm->frame_to_show) {
7752 *dest = *cm->frame_to_show;
7753 dest->y_width = cm->width;
7754 dest->y_height = cm->height;
7755 dest->uv_width = cm->width >> cm->subsampling_x;
7756 dest->uv_height = cm->height >> cm->subsampling_y;
7761 #endif // !CONFIG_VP9_POSTPROC
7762 vpx_clear_system_state();
7767 int vp9_set_internal_size(VP9_COMP *cpi, VPX_SCALING horiz_mode,
7768 VPX_SCALING vert_mode) {
7769 VP9_COMMON *cm = &cpi->common;
7770 int hr = 0, hs = 0, vr = 0, vs = 0;
7772 if (horiz_mode > ONETWO || vert_mode > ONETWO) return -1;
7774 Scale2Ratio(horiz_mode, &hr, &hs);
7775 Scale2Ratio(vert_mode, &vr, &vs);
7777 // always go to the next whole number
7778 cm->width = (hs - 1 + cpi->oxcf.width * hr) / hs;
7779 cm->height = (vs - 1 + cpi->oxcf.height * vr) / vs;
7780 if (cm->current_video_frame) {
7781 assert(cm->width <= cpi->initial_width);
7782 assert(cm->height <= cpi->initial_height);
7785 update_frame_size(cpi);
7790 int vp9_set_size_literal(VP9_COMP *cpi, unsigned int width,
7791 unsigned int height) {
7792 VP9_COMMON *cm = &cpi->common;
7793 #if CONFIG_VP9_HIGHBITDEPTH
7794 check_initial_width(cpi, cm->use_highbitdepth, 1, 1);
7796 check_initial_width(cpi, 1, 1);
7797 #endif // CONFIG_VP9_HIGHBITDEPTH
7799 #if CONFIG_VP9_TEMPORAL_DENOISING
7800 setup_denoiser_buffer(cpi);
7805 if (cm->width > cpi->initial_width) {
7806 cm->width = cpi->initial_width;
7807 printf("Warning: Desired width too large, changed to %d\n", cm->width);
7812 cm->height = height;
7813 if (cm->height > cpi->initial_height) {
7814 cm->height = cpi->initial_height;
7815 printf("Warning: Desired height too large, changed to %d\n", cm->height);
7818 assert(cm->width <= cpi->initial_width);
7819 assert(cm->height <= cpi->initial_height);
7821 update_frame_size(cpi);
7826 void vp9_set_svc(VP9_COMP *cpi, int use_svc) {
7827 cpi->use_svc = use_svc;
7831 int vp9_get_quantizer(VP9_COMP *cpi) { return cpi->common.base_qindex; }
7833 void vp9_apply_encoding_flags(VP9_COMP *cpi, vpx_enc_frame_flags_t flags) {
7835 (VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF)) {
7838 if (flags & VP8_EFLAG_NO_REF_LAST) ref ^= VP9_LAST_FLAG;
7840 if (flags & VP8_EFLAG_NO_REF_GF) ref ^= VP9_GOLD_FLAG;
7842 if (flags & VP8_EFLAG_NO_REF_ARF) ref ^= VP9_ALT_FLAG;
7844 vp9_use_as_reference(cpi, ref);
7848 (VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
7849 VP8_EFLAG_FORCE_GF | VP8_EFLAG_FORCE_ARF)) {
7852 if (flags & VP8_EFLAG_NO_UPD_LAST) upd ^= VP9_LAST_FLAG;
7854 if (flags & VP8_EFLAG_NO_UPD_GF) upd ^= VP9_GOLD_FLAG;
7856 if (flags & VP8_EFLAG_NO_UPD_ARF) upd ^= VP9_ALT_FLAG;
7858 vp9_update_reference(cpi, upd);
7861 if (flags & VP8_EFLAG_NO_UPD_ENTROPY) {
7862 vp9_update_entropy(cpi, 0);
7866 void vp9_set_row_mt(VP9_COMP *cpi) {
7867 // Enable row based multi-threading for supported modes of encoding
7869 if (((cpi->oxcf.mode == GOOD || cpi->oxcf.mode == BEST) &&
7870 cpi->oxcf.speed < 5 && cpi->oxcf.pass == 1) &&
7871 cpi->oxcf.row_mt && !cpi->use_svc)
7874 if (cpi->oxcf.mode == GOOD && cpi->oxcf.speed < 5 &&
7875 (cpi->oxcf.pass == 0 || cpi->oxcf.pass == 2) && cpi->oxcf.row_mt &&
7879 // In realtime mode, enable row based multi-threading for all the speed levels
7880 // where non-rd path is used.
7881 if (cpi->oxcf.mode == REALTIME && cpi->oxcf.speed >= 5 && cpi->oxcf.row_mt) {
7886 cpi->row_mt_bit_exact = 1;
7888 cpi->row_mt_bit_exact = 0;