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 void vp9_remove_compressor(VP9_COMP *cpi) {
2543 unsigned int i, frame;
2548 #if CONFIG_INTERNAL_STATS
2549 vpx_free(cpi->ssim_vars);
2553 if (cm->current_video_frame > 0) {
2554 #if CONFIG_INTERNAL_STATS
2555 vpx_clear_system_state();
2557 if (cpi->oxcf.pass != 1) {
2558 char headings[512] = { 0 };
2559 char results[512] = { 0 };
2560 FILE *f = fopen("opsnr.stt", "a");
2561 double time_encoded =
2562 (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) /
2564 double total_encode_time =
2565 (cpi->time_receive_data + cpi->time_compress_data) / 1000.000;
2567 (double)cpi->bytes * (double)8 / (double)1000 / time_encoded;
2568 const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1);
2569 const double target_rate = (double)cpi->oxcf.target_bandwidth / 1000;
2570 const double rate_err = ((100.0 * (dr - target_rate)) / target_rate);
2572 if (cpi->b_calculate_psnr) {
2573 const double total_psnr = vpx_sse_to_psnr(
2574 (double)cpi->total_samples, peak, (double)cpi->total_sq_error);
2575 const double totalp_psnr = vpx_sse_to_psnr(
2576 (double)cpi->totalp_samples, peak, (double)cpi->totalp_sq_error);
2577 const double total_ssim =
2578 100 * pow(cpi->summed_quality / cpi->summed_weights, 8.0);
2579 const double totalp_ssim =
2580 100 * pow(cpi->summedp_quality / cpi->summedp_weights, 8.0);
2582 snprintf(headings, sizeof(headings),
2583 "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\t"
2584 "VPXSSIM\tVPSSIMP\tFASTSIM\tPSNRHVS\t"
2585 "WstPsnr\tWstSsim\tWstFast\tWstHVS\t"
2586 "AVPsnrY\tAPsnrCb\tAPsnrCr");
2587 snprintf(results, sizeof(results),
2588 "%7.2f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2589 "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2590 "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2591 "%7.3f\t%7.3f\t%7.3f",
2592 dr, cpi->psnr.stat[ALL] / cpi->count, total_psnr,
2593 cpi->psnrp.stat[ALL] / cpi->count, totalp_psnr, total_ssim,
2594 totalp_ssim, cpi->fastssim.stat[ALL] / cpi->count,
2595 cpi->psnrhvs.stat[ALL] / cpi->count, cpi->psnr.worst,
2596 cpi->worst_ssim, cpi->fastssim.worst, cpi->psnrhvs.worst,
2597 cpi->psnr.stat[Y] / cpi->count, cpi->psnr.stat[U] / cpi->count,
2598 cpi->psnr.stat[V] / cpi->count);
2600 if (cpi->b_calculate_blockiness) {
2601 SNPRINT(headings, "\t Block\tWstBlck");
2602 SNPRINT2(results, "\t%7.3f", cpi->total_blockiness / cpi->count);
2603 SNPRINT2(results, "\t%7.3f", cpi->worst_blockiness);
2606 if (cpi->b_calculate_consistency) {
2607 double consistency =
2608 vpx_sse_to_psnr((double)cpi->totalp_samples, peak,
2609 (double)cpi->total_inconsistency);
2611 SNPRINT(headings, "\tConsist\tWstCons");
2612 SNPRINT2(results, "\t%7.3f", consistency);
2613 SNPRINT2(results, "\t%7.3f", cpi->worst_consistency);
2616 SNPRINT(headings, "\t Time\tRcErr\tAbsErr");
2617 SNPRINT2(results, "\t%8.0f", total_encode_time);
2618 SNPRINT2(results, "\t%7.2f", rate_err);
2619 SNPRINT2(results, "\t%7.2f", fabs(rate_err));
2621 fprintf(f, "%s\tAPsnr611\n", headings);
2623 f, "%s\t%7.3f\n", results,
2624 (6 * cpi->psnr.stat[Y] + cpi->psnr.stat[U] + cpi->psnr.stat[V]) /
2634 printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000);
2635 printf("\n_frames recive_data encod_mb_row compress_frame Total\n");
2636 printf("%6d %10ld %10ld %10ld %10ld\n", cpi->common.current_video_frame,
2637 cpi->time_receive_data / 1000, cpi->time_encode_sb_row / 1000,
2638 cpi->time_compress_data / 1000,
2639 (cpi->time_receive_data + cpi->time_compress_data) / 1000);
2644 #if CONFIG_VP9_TEMPORAL_DENOISING
2645 vp9_denoiser_free(&(cpi->denoiser));
2648 if (cpi->kmeans_data_arr_alloc) {
2649 #if CONFIG_MULTITHREAD
2650 pthread_mutex_destroy(&cpi->kmeans_mutex);
2652 vpx_free(cpi->kmeans_data_arr);
2655 #if CONFIG_NON_GREEDY_MV
2656 vpx_free(cpi->feature_score_loc_arr);
2657 vpx_free(cpi->feature_score_loc_sort);
2658 vpx_free(cpi->feature_score_loc_heap);
2659 vpx_free(cpi->select_mv_arr);
2661 for (frame = 0; frame < MAX_ARF_GOP_SIZE; ++frame) {
2662 #if CONFIG_NON_GREEDY_MV
2664 for (rf_idx = 0; rf_idx < 3; ++rf_idx) {
2666 for (sqr_bsize = 0; sqr_bsize < SQUARE_BLOCK_SIZES; ++sqr_bsize) {
2667 vpx_free(cpi->tpl_stats[frame].pyramid_mv_arr[rf_idx][sqr_bsize]);
2669 vpx_free(cpi->tpl_stats[frame].mv_mode_arr[rf_idx]);
2670 vpx_free(cpi->tpl_stats[frame].rd_diff_arr[rf_idx]);
2673 vpx_free(cpi->tpl_stats[frame].tpl_stats_ptr);
2674 cpi->tpl_stats[frame].is_valid = 0;
2677 for (t = 0; t < cpi->num_workers; ++t) {
2678 VPxWorker *const worker = &cpi->workers[t];
2679 EncWorkerData *const thread_data = &cpi->tile_thr_data[t];
2681 // Deallocate allocated threads.
2682 vpx_get_worker_interface()->end(worker);
2684 // Deallocate allocated thread data.
2685 if (t < cpi->num_workers - 1) {
2686 vpx_free(thread_data->td->counts);
2687 vp9_free_pc_tree(thread_data->td);
2688 vpx_free(thread_data->td);
2691 vpx_free(cpi->tile_thr_data);
2692 vpx_free(cpi->workers);
2693 vp9_row_mt_mem_dealloc(cpi);
2695 if (cpi->num_workers > 1) {
2696 vp9_loop_filter_dealloc(&cpi->lf_row_sync);
2697 vp9_bitstream_encode_tiles_buffer_dealloc(cpi);
2700 #if !CONFIG_REALTIME_ONLY
2701 vp9_alt_ref_aq_destroy(cpi->alt_ref_aq);
2704 dealloc_compressor_data(cpi);
2706 for (i = 0; i < sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]);
2708 vpx_free(cpi->mbgraph_stats[i].mb_stats);
2711 #if CONFIG_FP_MB_STATS
2712 if (cpi->use_fp_mb_stats) {
2713 vpx_free(cpi->twopass.frame_mb_stats_buf);
2714 cpi->twopass.frame_mb_stats_buf = NULL;
2718 vp9_remove_common(cm);
2719 vp9_free_ref_frame_buffers(cm->buffer_pool);
2720 #if CONFIG_VP9_POSTPROC
2721 vp9_free_postproc_buffers(cm);
2725 #if CONFIG_VP9_TEMPORAL_DENOISING
2726 #ifdef OUTPUT_YUV_DENOISED
2727 fclose(yuv_denoised_file);
2730 #ifdef OUTPUT_YUV_SKINMAP
2731 fclose(yuv_skinmap_file);
2733 #ifdef OUTPUT_YUV_REC
2734 fclose(yuv_rec_file);
2736 #ifdef OUTPUT_YUV_SVC_SRC
2737 fclose(yuv_svc_src[0]);
2738 fclose(yuv_svc_src[1]);
2739 fclose(yuv_svc_src[2]);
2756 static void generate_psnr_packet(VP9_COMP *cpi) {
2757 struct vpx_codec_cx_pkt pkt;
2760 #if CONFIG_VP9_HIGHBITDEPTH
2761 vpx_calc_highbd_psnr(cpi->raw_source_frame, cpi->common.frame_to_show, &psnr,
2762 cpi->td.mb.e_mbd.bd, cpi->oxcf.input_bit_depth);
2764 vpx_calc_psnr(cpi->raw_source_frame, cpi->common.frame_to_show, &psnr);
2767 for (i = 0; i < 4; ++i) {
2768 pkt.data.psnr.samples[i] = psnr.samples[i];
2769 pkt.data.psnr.sse[i] = psnr.sse[i];
2770 pkt.data.psnr.psnr[i] = psnr.psnr[i];
2772 pkt.kind = VPX_CODEC_PSNR_PKT;
2775 .layer_context[cpi->svc.spatial_layer_id *
2776 cpi->svc.number_temporal_layers]
2777 .psnr_pkt = pkt.data.psnr;
2779 vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
2782 int vp9_use_as_reference(VP9_COMP *cpi, int ref_frame_flags) {
2783 if (ref_frame_flags > 7) return -1;
2785 cpi->ref_frame_flags = ref_frame_flags;
2789 void vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags) {
2790 cpi->ext_refresh_golden_frame = (ref_frame_flags & VP9_GOLD_FLAG) != 0;
2791 cpi->ext_refresh_alt_ref_frame = (ref_frame_flags & VP9_ALT_FLAG) != 0;
2792 cpi->ext_refresh_last_frame = (ref_frame_flags & VP9_LAST_FLAG) != 0;
2793 cpi->ext_refresh_frame_flags_pending = 1;
2796 static YV12_BUFFER_CONFIG *get_vp9_ref_frame_buffer(
2797 VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag) {
2798 MV_REFERENCE_FRAME ref_frame = NONE;
2799 if (ref_frame_flag == VP9_LAST_FLAG)
2800 ref_frame = LAST_FRAME;
2801 else if (ref_frame_flag == VP9_GOLD_FLAG)
2802 ref_frame = GOLDEN_FRAME;
2803 else if (ref_frame_flag == VP9_ALT_FLAG)
2804 ref_frame = ALTREF_FRAME;
2806 return ref_frame == NONE ? NULL : get_ref_frame_buffer(cpi, ref_frame);
2809 int vp9_copy_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
2810 YV12_BUFFER_CONFIG *sd) {
2811 YV12_BUFFER_CONFIG *cfg = get_vp9_ref_frame_buffer(cpi, ref_frame_flag);
2813 vpx_yv12_copy_frame(cfg, sd);
2820 int vp9_set_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
2821 YV12_BUFFER_CONFIG *sd) {
2822 YV12_BUFFER_CONFIG *cfg = get_vp9_ref_frame_buffer(cpi, ref_frame_flag);
2824 vpx_yv12_copy_frame(sd, cfg);
2831 int vp9_update_entropy(VP9_COMP *cpi, int update) {
2832 cpi->ext_refresh_frame_context = update;
2833 cpi->ext_refresh_frame_context_pending = 1;
2837 #ifdef OUTPUT_YUV_REC
2838 void vp9_write_yuv_rec_frame(VP9_COMMON *cm) {
2839 YV12_BUFFER_CONFIG *s = cm->frame_to_show;
2840 uint8_t *src = s->y_buffer;
2843 #if CONFIG_VP9_HIGHBITDEPTH
2844 if (s->flags & YV12_FLAG_HIGHBITDEPTH) {
2845 uint16_t *src16 = CONVERT_TO_SHORTPTR(s->y_buffer);
2848 fwrite(src16, s->y_width, 2, yuv_rec_file);
2849 src16 += s->y_stride;
2852 src16 = CONVERT_TO_SHORTPTR(s->u_buffer);
2856 fwrite(src16, s->uv_width, 2, yuv_rec_file);
2857 src16 += s->uv_stride;
2860 src16 = CONVERT_TO_SHORTPTR(s->v_buffer);
2864 fwrite(src16, s->uv_width, 2, yuv_rec_file);
2865 src16 += s->uv_stride;
2868 fflush(yuv_rec_file);
2871 #endif // CONFIG_VP9_HIGHBITDEPTH
2874 fwrite(src, s->y_width, 1, yuv_rec_file);
2882 fwrite(src, s->uv_width, 1, yuv_rec_file);
2883 src += s->uv_stride;
2890 fwrite(src, s->uv_width, 1, yuv_rec_file);
2891 src += s->uv_stride;
2894 fflush(yuv_rec_file);
2898 #if CONFIG_VP9_HIGHBITDEPTH
2899 static void scale_and_extend_frame_nonnormative(const YV12_BUFFER_CONFIG *src,
2900 YV12_BUFFER_CONFIG *dst,
2903 static void scale_and_extend_frame_nonnormative(const YV12_BUFFER_CONFIG *src,
2904 YV12_BUFFER_CONFIG *dst) {
2905 #endif // CONFIG_VP9_HIGHBITDEPTH
2906 // TODO(dkovalev): replace YV12_BUFFER_CONFIG with vpx_image_t
2908 const uint8_t *const srcs[3] = { src->y_buffer, src->u_buffer,
2910 const int src_strides[3] = { src->y_stride, src->uv_stride, src->uv_stride };
2911 const int src_widths[3] = { src->y_crop_width, src->uv_crop_width,
2912 src->uv_crop_width };
2913 const int src_heights[3] = { src->y_crop_height, src->uv_crop_height,
2914 src->uv_crop_height };
2915 uint8_t *const dsts[3] = { dst->y_buffer, dst->u_buffer, dst->v_buffer };
2916 const int dst_strides[3] = { dst->y_stride, dst->uv_stride, dst->uv_stride };
2917 const int dst_widths[3] = { dst->y_crop_width, dst->uv_crop_width,
2918 dst->uv_crop_width };
2919 const int dst_heights[3] = { dst->y_crop_height, dst->uv_crop_height,
2920 dst->uv_crop_height };
2922 for (i = 0; i < MAX_MB_PLANE; ++i) {
2923 #if CONFIG_VP9_HIGHBITDEPTH
2924 if (src->flags & YV12_FLAG_HIGHBITDEPTH) {
2925 vp9_highbd_resize_plane(srcs[i], src_heights[i], src_widths[i],
2926 src_strides[i], dsts[i], dst_heights[i],
2927 dst_widths[i], dst_strides[i], bd);
2929 vp9_resize_plane(srcs[i], src_heights[i], src_widths[i], src_strides[i],
2930 dsts[i], dst_heights[i], dst_widths[i], dst_strides[i]);
2933 vp9_resize_plane(srcs[i], src_heights[i], src_widths[i], src_strides[i],
2934 dsts[i], dst_heights[i], dst_widths[i], dst_strides[i]);
2935 #endif // CONFIG_VP9_HIGHBITDEPTH
2937 vpx_extend_frame_borders(dst);
2940 #if CONFIG_VP9_HIGHBITDEPTH
2941 static void scale_and_extend_frame(const YV12_BUFFER_CONFIG *src,
2942 YV12_BUFFER_CONFIG *dst, int bd,
2943 INTERP_FILTER filter_type,
2945 const int src_w = src->y_crop_width;
2946 const int src_h = src->y_crop_height;
2947 const int dst_w = dst->y_crop_width;
2948 const int dst_h = dst->y_crop_height;
2949 const uint8_t *const srcs[3] = { src->y_buffer, src->u_buffer,
2951 const int src_strides[3] = { src->y_stride, src->uv_stride, src->uv_stride };
2952 uint8_t *const dsts[3] = { dst->y_buffer, dst->u_buffer, dst->v_buffer };
2953 const int dst_strides[3] = { dst->y_stride, dst->uv_stride, dst->uv_stride };
2954 const InterpKernel *const kernel = vp9_filter_kernels[filter_type];
2957 for (i = 0; i < MAX_MB_PLANE; ++i) {
2958 const int factor = (i == 0 || i == 3 ? 1 : 2);
2959 const int src_stride = src_strides[i];
2960 const int dst_stride = dst_strides[i];
2961 for (y = 0; y < dst_h; y += 16) {
2962 const int y_q4 = y * (16 / factor) * src_h / dst_h + phase_scaler;
2963 for (x = 0; x < dst_w; x += 16) {
2964 const int x_q4 = x * (16 / factor) * src_w / dst_w + phase_scaler;
2965 const uint8_t *src_ptr = srcs[i] +
2966 (y / factor) * src_h / dst_h * src_stride +
2967 (x / factor) * src_w / dst_w;
2968 uint8_t *dst_ptr = dsts[i] + (y / factor) * dst_stride + (x / factor);
2970 if (src->flags & YV12_FLAG_HIGHBITDEPTH) {
2971 vpx_highbd_convolve8(CONVERT_TO_SHORTPTR(src_ptr), src_stride,
2972 CONVERT_TO_SHORTPTR(dst_ptr), dst_stride, kernel,
2973 x_q4 & 0xf, 16 * src_w / dst_w, y_q4 & 0xf,
2974 16 * src_h / dst_h, 16 / factor, 16 / factor,
2977 vpx_scaled_2d(src_ptr, src_stride, dst_ptr, dst_stride, kernel,
2978 x_q4 & 0xf, 16 * src_w / dst_w, y_q4 & 0xf,
2979 16 * src_h / dst_h, 16 / factor, 16 / factor);
2985 vpx_extend_frame_borders(dst);
2987 #endif // CONFIG_VP9_HIGHBITDEPTH
2989 #if !CONFIG_REALTIME_ONLY
2990 static int scale_down(VP9_COMP *cpi, int q) {
2991 RATE_CONTROL *const rc = &cpi->rc;
2992 GF_GROUP *const gf_group = &cpi->twopass.gf_group;
2994 assert(frame_is_kf_gf_arf(cpi));
2996 if (rc->frame_size_selector == UNSCALED &&
2997 q >= rc->rf_level_maxq[gf_group->rf_level[gf_group->index]]) {
2998 const int max_size_thresh =
2999 (int)(rate_thresh_mult[SCALE_STEP1] *
3000 VPXMAX(rc->this_frame_target, rc->avg_frame_bandwidth));
3001 scale = rc->projected_frame_size > max_size_thresh ? 1 : 0;
3006 static int big_rate_miss_high_threshold(VP9_COMP *cpi) {
3007 const RATE_CONTROL *const rc = &cpi->rc;
3010 if (frame_is_kf_gf_arf(cpi))
3011 big_miss_high = rc->this_frame_target * 3 / 2;
3013 big_miss_high = rc->this_frame_target * 2;
3015 return big_miss_high;
3018 static int big_rate_miss(VP9_COMP *cpi) {
3019 const RATE_CONTROL *const rc = &cpi->rc;
3023 // Ignore for overlay frames
3024 if (rc->is_src_frame_alt_ref) {
3027 big_miss_low = (rc->this_frame_target / 2);
3028 big_miss_high = big_rate_miss_high_threshold(cpi);
3030 return (rc->projected_frame_size > big_miss_high) ||
3031 (rc->projected_frame_size < big_miss_low);
3035 // test in two pass for the first
3036 static int two_pass_first_group_inter(VP9_COMP *cpi) {
3037 if (cpi->oxcf.pass == 2) {
3038 TWO_PASS *const twopass = &cpi->twopass;
3039 GF_GROUP *const gf_group = &twopass->gf_group;
3040 const int gfg_index = gf_group->index;
3042 if (gfg_index == 0) return gf_group->update_type[gfg_index] == LF_UPDATE;
3043 return gf_group->update_type[gfg_index - 1] != LF_UPDATE &&
3044 gf_group->update_type[gfg_index] == LF_UPDATE;
3050 // Function to test for conditions that indicate we should loop
3051 // back and recode a frame.
3052 static int recode_loop_test(VP9_COMP *cpi, int high_limit, int low_limit, int q,
3053 int maxq, int minq) {
3054 const RATE_CONTROL *const rc = &cpi->rc;
3055 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
3056 const int frame_is_kfgfarf = frame_is_kf_gf_arf(cpi);
3057 int force_recode = 0;
3059 if ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
3060 big_rate_miss(cpi) || (cpi->sf.recode_loop == ALLOW_RECODE) ||
3061 (two_pass_first_group_inter(cpi) &&
3062 (cpi->sf.recode_loop == ALLOW_RECODE_FIRST)) ||
3063 (frame_is_kfgfarf && (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF))) {
3064 if (frame_is_kfgfarf && (oxcf->resize_mode == RESIZE_DYNAMIC) &&
3065 scale_down(cpi, q)) {
3066 // Code this group at a lower resolution.
3067 cpi->resize_pending = 1;
3071 // Force recode for extreme overshoot.
3072 if ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
3073 (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF &&
3074 rc->projected_frame_size >= big_rate_miss_high_threshold(cpi))) {
3078 // TODO(agrange) high_limit could be greater than the scale-down threshold.
3079 if ((rc->projected_frame_size > high_limit && q < maxq) ||
3080 (rc->projected_frame_size < low_limit && q > minq)) {
3082 } else if (cpi->oxcf.rc_mode == VPX_CQ) {
3083 // Deal with frame undershoot and whether or not we are
3084 // below the automatically set cq level.
3085 if (q > oxcf->cq_level &&
3086 rc->projected_frame_size < ((rc->this_frame_target * 7) >> 3)) {
3091 return force_recode;
3093 #endif // !CONFIG_REALTIME_ONLY
3095 static void update_ref_frames(VP9_COMP *cpi) {
3096 VP9_COMMON *const cm = &cpi->common;
3097 BufferPool *const pool = cm->buffer_pool;
3098 GF_GROUP *const gf_group = &cpi->twopass.gf_group;
3100 if (cpi->rc.show_arf_as_gld) {
3101 int tmp = cpi->alt_fb_idx;
3102 cpi->alt_fb_idx = cpi->gld_fb_idx;
3103 cpi->gld_fb_idx = tmp;
3104 } else if (cm->show_existing_frame) {
3106 cpi->lst_fb_idx = cpi->alt_fb_idx;
3108 stack_pop(gf_group->arf_index_stack, gf_group->stack_size);
3109 --gf_group->stack_size;
3112 // At this point the new frame has been encoded.
3113 // If any buffer copy / swapping is signaled it should be done here.
3114 if (cm->frame_type == KEY_FRAME) {
3115 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
3117 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->alt_fb_idx],
3119 } else if (vp9_preserve_existing_gf(cpi)) {
3120 // We have decided to preserve the previously existing golden frame as our
3121 // new ARF frame. However, in the short term in function
3122 // vp9_get_refresh_mask() we left it in the GF slot and, if
3123 // we're updating the GF with the current decoded frame, we save it to the
3124 // ARF slot instead.
3125 // We now have to update the ARF with the current frame and swap gld_fb_idx
3126 // and alt_fb_idx so that, overall, we've stored the old GF in the new ARF
3127 // slot and, if we're updating the GF, the current frame becomes the new GF.
3130 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->alt_fb_idx],
3133 tmp = cpi->alt_fb_idx;
3134 cpi->alt_fb_idx = cpi->gld_fb_idx;
3135 cpi->gld_fb_idx = tmp;
3136 } else { /* For non key/golden frames */
3137 if (cpi->refresh_alt_ref_frame) {
3138 int arf_idx = gf_group->top_arf_idx;
3140 // Push new ARF into stack.
3141 stack_push(gf_group->arf_index_stack, cpi->alt_fb_idx,
3142 gf_group->stack_size);
3143 ++gf_group->stack_size;
3145 assert(arf_idx < REF_FRAMES);
3147 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[arf_idx], cm->new_fb_idx);
3148 memcpy(cpi->interp_filter_selected[ALTREF_FRAME],
3149 cpi->interp_filter_selected[0],
3150 sizeof(cpi->interp_filter_selected[0]));
3152 cpi->alt_fb_idx = arf_idx;
3155 if (cpi->refresh_golden_frame) {
3156 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
3158 if (!cpi->rc.is_src_frame_alt_ref)
3159 memcpy(cpi->interp_filter_selected[GOLDEN_FRAME],
3160 cpi->interp_filter_selected[0],
3161 sizeof(cpi->interp_filter_selected[0]));
3163 memcpy(cpi->interp_filter_selected[GOLDEN_FRAME],
3164 cpi->interp_filter_selected[ALTREF_FRAME],
3165 sizeof(cpi->interp_filter_selected[ALTREF_FRAME]));
3169 if (cpi->refresh_last_frame) {
3170 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->lst_fb_idx],
3172 if (!cpi->rc.is_src_frame_alt_ref)
3173 memcpy(cpi->interp_filter_selected[LAST_FRAME],
3174 cpi->interp_filter_selected[0],
3175 sizeof(cpi->interp_filter_selected[0]));
3178 if (gf_group->update_type[gf_group->index] == MID_OVERLAY_UPDATE) {
3180 stack_pop(gf_group->arf_index_stack, gf_group->stack_size);
3181 --gf_group->stack_size;
3185 void vp9_update_reference_frames(VP9_COMP *cpi) {
3186 update_ref_frames(cpi);
3188 #if CONFIG_VP9_TEMPORAL_DENOISING
3189 vp9_denoiser_update_ref_frame(cpi);
3192 if (is_one_pass_cbr_svc(cpi)) vp9_svc_update_ref_frame(cpi);
3195 static void loopfilter_frame(VP9_COMP *cpi, VP9_COMMON *cm) {
3196 MACROBLOCKD *xd = &cpi->td.mb.e_mbd;
3197 struct loopfilter *lf = &cm->lf;
3198 int is_reference_frame =
3199 (cm->frame_type == KEY_FRAME || cpi->refresh_last_frame ||
3200 cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame);
3202 cpi->svc.temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS)
3203 is_reference_frame = !cpi->svc.non_reference_frame;
3205 // Skip loop filter in show_existing_frame mode.
3206 if (cm->show_existing_frame) {
3207 lf->filter_level = 0;
3212 lf->filter_level = 0;
3213 lf->last_filt_level = 0;
3215 struct vpx_usec_timer timer;
3217 vpx_clear_system_state();
3219 vpx_usec_timer_start(&timer);
3221 if (!cpi->rc.is_src_frame_alt_ref) {
3222 if ((cpi->common.frame_type == KEY_FRAME) &&
3223 (!cpi->rc.this_key_frame_forced)) {
3224 lf->last_filt_level = 0;
3226 vp9_pick_filter_level(cpi->Source, cpi, cpi->sf.lpf_pick);
3227 lf->last_filt_level = lf->filter_level;
3229 lf->filter_level = 0;
3232 vpx_usec_timer_mark(&timer);
3233 cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
3236 if (lf->filter_level > 0 && is_reference_frame) {
3237 vp9_build_mask_frame(cm, lf->filter_level, 0);
3239 if (cpi->num_workers > 1)
3240 vp9_loop_filter_frame_mt(cm->frame_to_show, cm, xd->plane,
3241 lf->filter_level, 0, 0, cpi->workers,
3242 cpi->num_workers, &cpi->lf_row_sync);
3244 vp9_loop_filter_frame(cm->frame_to_show, cm, xd, lf->filter_level, 0, 0);
3247 vpx_extend_frame_inner_borders(cm->frame_to_show);
3250 static INLINE void alloc_frame_mvs(VP9_COMMON *const cm, int buffer_idx) {
3251 RefCntBuffer *const new_fb_ptr = &cm->buffer_pool->frame_bufs[buffer_idx];
3252 if (new_fb_ptr->mvs == NULL || new_fb_ptr->mi_rows < cm->mi_rows ||
3253 new_fb_ptr->mi_cols < cm->mi_cols) {
3254 vpx_free(new_fb_ptr->mvs);
3255 CHECK_MEM_ERROR(cm, new_fb_ptr->mvs,
3256 (MV_REF *)vpx_calloc(cm->mi_rows * cm->mi_cols,
3257 sizeof(*new_fb_ptr->mvs)));
3258 new_fb_ptr->mi_rows = cm->mi_rows;
3259 new_fb_ptr->mi_cols = cm->mi_cols;
3263 void vp9_scale_references(VP9_COMP *cpi) {
3264 VP9_COMMON *cm = &cpi->common;
3265 MV_REFERENCE_FRAME ref_frame;
3266 const VP9_REFFRAME ref_mask[3] = { VP9_LAST_FLAG, VP9_GOLD_FLAG,
3269 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3270 // Need to convert from VP9_REFFRAME to index into ref_mask (subtract 1).
3271 if (cpi->ref_frame_flags & ref_mask[ref_frame - 1]) {
3272 BufferPool *const pool = cm->buffer_pool;
3273 const YV12_BUFFER_CONFIG *const ref =
3274 get_ref_frame_buffer(cpi, ref_frame);
3277 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3281 #if CONFIG_VP9_HIGHBITDEPTH
3282 if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) {
3283 RefCntBuffer *new_fb_ptr = NULL;
3284 int force_scaling = 0;
3285 int new_fb = cpi->scaled_ref_idx[ref_frame - 1];
3286 if (new_fb == INVALID_IDX) {
3287 new_fb = get_free_fb(cm);
3290 if (new_fb == INVALID_IDX) return;
3291 new_fb_ptr = &pool->frame_bufs[new_fb];
3292 if (force_scaling || new_fb_ptr->buf.y_crop_width != cm->width ||
3293 new_fb_ptr->buf.y_crop_height != cm->height) {
3294 if (vpx_realloc_frame_buffer(&new_fb_ptr->buf, cm->width, cm->height,
3295 cm->subsampling_x, cm->subsampling_y,
3296 cm->use_highbitdepth,
3297 VP9_ENC_BORDER_IN_PIXELS,
3298 cm->byte_alignment, NULL, NULL, NULL))
3299 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3300 "Failed to allocate frame buffer");
3301 scale_and_extend_frame(ref, &new_fb_ptr->buf, (int)cm->bit_depth,
3303 cpi->scaled_ref_idx[ref_frame - 1] = new_fb;
3304 alloc_frame_mvs(cm, new_fb);
3307 if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) {
3308 RefCntBuffer *new_fb_ptr = NULL;
3309 int force_scaling = 0;
3310 int new_fb = cpi->scaled_ref_idx[ref_frame - 1];
3311 if (new_fb == INVALID_IDX) {
3312 new_fb = get_free_fb(cm);
3315 if (new_fb == INVALID_IDX) return;
3316 new_fb_ptr = &pool->frame_bufs[new_fb];
3317 if (force_scaling || new_fb_ptr->buf.y_crop_width != cm->width ||
3318 new_fb_ptr->buf.y_crop_height != cm->height) {
3319 if (vpx_realloc_frame_buffer(&new_fb_ptr->buf, cm->width, cm->height,
3320 cm->subsampling_x, cm->subsampling_y,
3321 VP9_ENC_BORDER_IN_PIXELS,
3322 cm->byte_alignment, NULL, NULL, NULL))
3323 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3324 "Failed to allocate frame buffer");
3325 vp9_scale_and_extend_frame(ref, &new_fb_ptr->buf, EIGHTTAP, 0);
3326 cpi->scaled_ref_idx[ref_frame - 1] = new_fb;
3327 alloc_frame_mvs(cm, new_fb);
3329 #endif // CONFIG_VP9_HIGHBITDEPTH
3332 RefCntBuffer *buf = NULL;
3333 if (cpi->oxcf.pass == 0 && !cpi->use_svc) {
3334 // Check for release of scaled reference.
3335 buf_idx = cpi->scaled_ref_idx[ref_frame - 1];
3336 if (buf_idx != INVALID_IDX) {
3337 buf = &pool->frame_bufs[buf_idx];
3339 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3342 buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
3343 buf = &pool->frame_bufs[buf_idx];
3344 buf->buf.y_crop_width = ref->y_crop_width;
3345 buf->buf.y_crop_height = ref->y_crop_height;
3346 cpi->scaled_ref_idx[ref_frame - 1] = buf_idx;
3350 if (cpi->oxcf.pass != 0 || cpi->use_svc)
3351 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3356 static void release_scaled_references(VP9_COMP *cpi) {
3357 VP9_COMMON *cm = &cpi->common;
3359 if (cpi->oxcf.pass == 0 && !cpi->use_svc) {
3360 // Only release scaled references under certain conditions:
3361 // if reference will be updated, or if scaled reference has same resolution.
3363 refresh[0] = (cpi->refresh_last_frame) ? 1 : 0;
3364 refresh[1] = (cpi->refresh_golden_frame) ? 1 : 0;
3365 refresh[2] = (cpi->refresh_alt_ref_frame) ? 1 : 0;
3366 for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
3367 const int idx = cpi->scaled_ref_idx[i - 1];
3368 if (idx != INVALID_IDX) {
3369 RefCntBuffer *const buf = &cm->buffer_pool->frame_bufs[idx];
3370 const YV12_BUFFER_CONFIG *const ref = get_ref_frame_buffer(cpi, i);
3371 if (refresh[i - 1] || (buf->buf.y_crop_width == ref->y_crop_width &&
3372 buf->buf.y_crop_height == ref->y_crop_height)) {
3374 cpi->scaled_ref_idx[i - 1] = INVALID_IDX;
3379 for (i = 0; i < REFS_PER_FRAME; ++i) {
3380 const int idx = cpi->scaled_ref_idx[i];
3381 if (idx != INVALID_IDX) {
3382 RefCntBuffer *const buf = &cm->buffer_pool->frame_bufs[idx];
3384 cpi->scaled_ref_idx[i] = INVALID_IDX;
3390 static void full_to_model_count(unsigned int *model_count,
3391 unsigned int *full_count) {
3393 model_count[ZERO_TOKEN] = full_count[ZERO_TOKEN];
3394 model_count[ONE_TOKEN] = full_count[ONE_TOKEN];
3395 model_count[TWO_TOKEN] = full_count[TWO_TOKEN];
3396 for (n = THREE_TOKEN; n < EOB_TOKEN; ++n)
3397 model_count[TWO_TOKEN] += full_count[n];
3398 model_count[EOB_MODEL_TOKEN] = full_count[EOB_TOKEN];
3401 static void full_to_model_counts(vp9_coeff_count_model *model_count,
3402 vp9_coeff_count *full_count) {
3405 for (i = 0; i < PLANE_TYPES; ++i)
3406 for (j = 0; j < REF_TYPES; ++j)
3407 for (k = 0; k < COEF_BANDS; ++k)
3408 for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l)
3409 full_to_model_count(model_count[i][j][k][l], full_count[i][j][k][l]);
3412 #if 0 && CONFIG_INTERNAL_STATS
3413 static void output_frame_level_debug_stats(VP9_COMP *cpi) {
3414 VP9_COMMON *const cm = &cpi->common;
3415 FILE *const f = fopen("tmp.stt", cm->current_video_frame ? "a" : "w");
3418 vpx_clear_system_state();
3420 #if CONFIG_VP9_HIGHBITDEPTH
3421 if (cm->use_highbitdepth) {
3422 recon_err = vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3424 recon_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3427 recon_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3428 #endif // CONFIG_VP9_HIGHBITDEPTH
3431 if (cpi->twopass.total_left_stats.coded_error != 0.0) {
3432 double dc_quant_devisor;
3433 #if CONFIG_VP9_HIGHBITDEPTH
3434 switch (cm->bit_depth) {
3436 dc_quant_devisor = 4.0;
3439 dc_quant_devisor = 16.0;
3442 assert(cm->bit_depth == VPX_BITS_12);
3443 dc_quant_devisor = 64.0;
3447 dc_quant_devisor = 4.0;
3450 if (!cm->current_video_frame) {
3451 fprintf(f, "frame, width, height, last ts, last end ts, "
3452 "source_alt_ref_pending, source_alt_ref_active, "
3453 "this_frame_target, projected_frame_size, "
3454 "projected_frame_size / MBs, "
3455 "projected_frame_size - this_frame_target, "
3456 "vbr_bits_off_target, vbr_bits_off_target_fast, "
3457 "twopass.extend_minq, twopass.extend_minq_fast, "
3458 "total_target_vs_actual, "
3459 "starting_buffer_level - bits_off_target, "
3460 "total_actual_bits, base_qindex, q for base_qindex, "
3461 "dc quant, q for active_worst_quality, avg_q, q for oxcf.cq_level, "
3462 "refresh_last_frame, refresh_golden_frame, refresh_alt_ref_frame, "
3463 "frame_type, gfu_boost, "
3464 "twopass.bits_left, "
3465 "twopass.total_left_stats.coded_error, "
3466 "twopass.bits_left / (1 + twopass.total_left_stats.coded_error), "
3467 "tot_recode_hits, recon_err, kf_boost, "
3468 "twopass.kf_zeromotion_pct, twopass.fr_content_type, "
3469 "filter_level, seg.aq_av_offset\n");
3472 fprintf(f, "%10u, %d, %d, %10"PRId64", %10"PRId64", %d, %d, %10d, %10d, "
3473 "%10d, %10d, %10"PRId64", %10"PRId64", %5d, %5d, %10"PRId64", "
3474 "%10"PRId64", %10"PRId64", %10d, %7.2lf, %7.2lf, %7.2lf, %7.2lf, "
3475 "%7.2lf, %6d, %6d, %5d, %5d, %5d, %10"PRId64", %10.3lf, %10lf, %8u, "
3476 "%10"PRId64", %10d, %10d, %10d, %10d, %10d\n",
3477 cpi->common.current_video_frame,
3478 cm->width, cm->height,
3479 cpi->last_time_stamp_seen,
3480 cpi->last_end_time_stamp_seen,
3481 cpi->rc.source_alt_ref_pending,
3482 cpi->rc.source_alt_ref_active,
3483 cpi->rc.this_frame_target,
3484 cpi->rc.projected_frame_size,
3485 cpi->rc.projected_frame_size / cpi->common.MBs,
3486 (cpi->rc.projected_frame_size - cpi->rc.this_frame_target),
3487 cpi->rc.vbr_bits_off_target,
3488 cpi->rc.vbr_bits_off_target_fast,
3489 cpi->twopass.extend_minq,
3490 cpi->twopass.extend_minq_fast,
3491 cpi->rc.total_target_vs_actual,
3492 (cpi->rc.starting_buffer_level - cpi->rc.bits_off_target),
3493 cpi->rc.total_actual_bits, cm->base_qindex,
3494 vp9_convert_qindex_to_q(cm->base_qindex, cm->bit_depth),
3495 (double)vp9_dc_quant(cm->base_qindex, 0, cm->bit_depth) /
3497 vp9_convert_qindex_to_q(cpi->twopass.active_worst_quality,
3500 vp9_convert_qindex_to_q(cpi->oxcf.cq_level, cm->bit_depth),
3501 cpi->refresh_last_frame, cpi->refresh_golden_frame,
3502 cpi->refresh_alt_ref_frame, cm->frame_type, cpi->rc.gfu_boost,
3503 cpi->twopass.bits_left,
3504 cpi->twopass.total_left_stats.coded_error,
3505 cpi->twopass.bits_left /
3506 (1 + cpi->twopass.total_left_stats.coded_error),
3507 cpi->tot_recode_hits, recon_err, cpi->rc.kf_boost,
3508 cpi->twopass.kf_zeromotion_pct,
3509 cpi->twopass.fr_content_type,
3510 cm->lf.filter_level,
3511 cm->seg.aq_av_offset);
3516 FILE *const fmodes = fopen("Modes.stt", "a");
3519 fprintf(fmodes, "%6d:%1d:%1d:%1d ", cpi->common.current_video_frame,
3520 cm->frame_type, cpi->refresh_golden_frame,
3521 cpi->refresh_alt_ref_frame);
3523 for (i = 0; i < MAX_MODES; ++i)
3524 fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
3526 fprintf(fmodes, "\n");
3533 static void set_mv_search_params(VP9_COMP *cpi) {
3534 const VP9_COMMON *const cm = &cpi->common;
3535 const unsigned int max_mv_def = VPXMIN(cm->width, cm->height);
3537 // Default based on max resolution.
3538 cpi->mv_step_param = vp9_init_search_range(max_mv_def);
3540 if (cpi->sf.mv.auto_mv_step_size) {
3541 if (frame_is_intra_only(cm)) {
3542 // Initialize max_mv_magnitude for use in the first INTER frame
3543 // after a key/intra-only frame.
3544 cpi->max_mv_magnitude = max_mv_def;
3546 if (cm->show_frame) {
3547 // Allow mv_steps to correspond to twice the max mv magnitude found
3548 // in the previous frame, capped by the default max_mv_magnitude based
3550 cpi->mv_step_param = vp9_init_search_range(
3551 VPXMIN(max_mv_def, 2 * cpi->max_mv_magnitude));
3553 cpi->max_mv_magnitude = 0;
3558 static void set_size_independent_vars(VP9_COMP *cpi) {
3559 vp9_set_speed_features_framesize_independent(cpi, cpi->oxcf.speed);
3560 vp9_set_rd_speed_thresholds(cpi);
3561 vp9_set_rd_speed_thresholds_sub8x8(cpi);
3562 cpi->common.interp_filter = cpi->sf.default_interp_filter;
3565 static void set_size_dependent_vars(VP9_COMP *cpi, int *q, int *bottom_index,
3567 VP9_COMMON *const cm = &cpi->common;
3569 // Setup variables that depend on the dimensions of the frame.
3570 vp9_set_speed_features_framesize_dependent(cpi, cpi->oxcf.speed);
3572 // Decide q and q bounds.
3573 *q = vp9_rc_pick_q_and_bounds(cpi, bottom_index, top_index);
3575 if (cpi->oxcf.rc_mode == VPX_CBR && cpi->rc.force_max_q) {
3576 *q = cpi->rc.worst_quality;
3577 cpi->rc.force_max_q = 0;
3580 if (!frame_is_intra_only(cm)) {
3581 vp9_set_high_precision_mv(cpi, (*q) < HIGH_PRECISION_MV_QTHRESH);
3584 #if !CONFIG_REALTIME_ONLY
3585 // Configure experimental use of segmentation for enhanced coding of
3586 // static regions if indicated.
3587 // Only allowed in the second pass of a two pass encode, as it requires
3588 // lagged coding, and if the relevant speed feature flag is set.
3589 if (cpi->oxcf.pass == 2 && cpi->sf.static_segmentation)
3590 configure_static_seg_features(cpi);
3591 #endif // !CONFIG_REALTIME_ONLY
3593 #if CONFIG_VP9_POSTPROC && !(CONFIG_VP9_TEMPORAL_DENOISING)
3594 if (cpi->oxcf.noise_sensitivity > 0) {
3596 switch (cpi->oxcf.noise_sensitivity) {
3597 case 1: l = 20; break;
3598 case 2: l = 40; break;
3599 case 3: l = 60; break;
3601 case 5: l = 100; break;
3602 case 6: l = 150; break;
3604 if (!cpi->common.postproc_state.limits) {
3605 cpi->common.postproc_state.limits =
3606 vpx_calloc(cpi->un_scaled_source->y_width,
3607 sizeof(*cpi->common.postproc_state.limits));
3609 vp9_denoise(&cpi->common, cpi->Source, cpi->Source, l,
3610 cpi->common.postproc_state.limits);
3612 #endif // CONFIG_VP9_POSTPROC
3615 #if CONFIG_VP9_TEMPORAL_DENOISING
3616 static void setup_denoiser_buffer(VP9_COMP *cpi) {
3617 VP9_COMMON *const cm = &cpi->common;
3618 if (cpi->oxcf.noise_sensitivity > 0 &&
3619 !cpi->denoiser.frame_buffer_initialized) {
3620 if (vp9_denoiser_alloc(cm, &cpi->svc, &cpi->denoiser, cpi->use_svc,
3621 cpi->oxcf.noise_sensitivity, cm->width, cm->height,
3622 cm->subsampling_x, cm->subsampling_y,
3623 #if CONFIG_VP9_HIGHBITDEPTH
3624 cm->use_highbitdepth,
3626 VP9_ENC_BORDER_IN_PIXELS))
3627 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3628 "Failed to allocate denoiser");
3633 static void init_motion_estimation(VP9_COMP *cpi) {
3634 int y_stride = cpi->scaled_source.y_stride;
3636 if (cpi->sf.mv.search_method == NSTEP) {
3637 vp9_init3smotion_compensation(&cpi->ss_cfg, y_stride);
3638 } else if (cpi->sf.mv.search_method == DIAMOND) {
3639 vp9_init_dsmotion_compensation(&cpi->ss_cfg, y_stride);
3643 static void set_frame_size(VP9_COMP *cpi) {
3645 VP9_COMMON *const cm = &cpi->common;
3646 VP9EncoderConfig *const oxcf = &cpi->oxcf;
3647 MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
3649 #if !CONFIG_REALTIME_ONLY
3650 if (oxcf->pass == 2 && oxcf->rc_mode == VPX_VBR &&
3651 ((oxcf->resize_mode == RESIZE_FIXED && cm->current_video_frame == 0) ||
3652 (oxcf->resize_mode == RESIZE_DYNAMIC && cpi->resize_pending))) {
3653 calculate_coded_size(cpi, &oxcf->scaled_frame_width,
3654 &oxcf->scaled_frame_height);
3656 // There has been a change in frame size.
3657 vp9_set_size_literal(cpi, oxcf->scaled_frame_width,
3658 oxcf->scaled_frame_height);
3660 #endif // !CONFIG_REALTIME_ONLY
3662 if (oxcf->pass == 0 && oxcf->rc_mode == VPX_CBR && !cpi->use_svc &&
3663 oxcf->resize_mode == RESIZE_DYNAMIC && cpi->resize_pending != 0) {
3664 oxcf->scaled_frame_width =
3665 (oxcf->width * cpi->resize_scale_num) / cpi->resize_scale_den;
3666 oxcf->scaled_frame_height =
3667 (oxcf->height * cpi->resize_scale_num) / cpi->resize_scale_den;
3668 // There has been a change in frame size.
3669 vp9_set_size_literal(cpi, oxcf->scaled_frame_width,
3670 oxcf->scaled_frame_height);
3672 // TODO(agrange) Scale cpi->max_mv_magnitude if frame-size has changed.
3673 set_mv_search_params(cpi);
3675 vp9_noise_estimate_init(&cpi->noise_estimate, cm->width, cm->height);
3676 #if CONFIG_VP9_TEMPORAL_DENOISING
3677 // Reset the denoiser on the resized frame.
3678 if (cpi->oxcf.noise_sensitivity > 0) {
3679 vp9_denoiser_free(&(cpi->denoiser));
3680 setup_denoiser_buffer(cpi);
3681 // Dynamic resize is only triggered for non-SVC, so we can force
3682 // golden frame update here as temporary fix to denoiser.
3683 cpi->refresh_golden_frame = 1;
3688 if ((oxcf->pass == 2) && !cpi->use_svc) {
3689 vp9_set_target_rate(cpi);
3692 alloc_frame_mvs(cm, cm->new_fb_idx);
3694 // Reset the frame pointers to the current frame size.
3695 if (vpx_realloc_frame_buffer(get_frame_new_buffer(cm), cm->width, cm->height,
3696 cm->subsampling_x, cm->subsampling_y,
3697 #if CONFIG_VP9_HIGHBITDEPTH
3698 cm->use_highbitdepth,
3700 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
3702 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3703 "Failed to allocate frame buffer");
3705 alloc_util_frame_buffers(cpi);
3706 init_motion_estimation(cpi);
3708 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3709 RefBuffer *const ref_buf = &cm->frame_refs[ref_frame - 1];
3710 const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
3712 ref_buf->idx = buf_idx;
3714 if (buf_idx != INVALID_IDX) {
3715 YV12_BUFFER_CONFIG *const buf = &cm->buffer_pool->frame_bufs[buf_idx].buf;
3717 #if CONFIG_VP9_HIGHBITDEPTH
3718 vp9_setup_scale_factors_for_frame(
3719 &ref_buf->sf, buf->y_crop_width, buf->y_crop_height, cm->width,
3720 cm->height, (buf->flags & YV12_FLAG_HIGHBITDEPTH) ? 1 : 0);
3722 vp9_setup_scale_factors_for_frame(&ref_buf->sf, buf->y_crop_width,
3723 buf->y_crop_height, cm->width,
3725 #endif // CONFIG_VP9_HIGHBITDEPTH
3726 if (vp9_is_scaled(&ref_buf->sf)) vpx_extend_frame_borders(buf);
3728 ref_buf->buf = NULL;
3732 set_ref_ptrs(cm, xd, LAST_FRAME, LAST_FRAME);
3735 #if CONFIG_CONSISTENT_RECODE
3736 static void save_encode_params(VP9_COMP *cpi) {
3737 VP9_COMMON *const cm = &cpi->common;
3738 const int tile_cols = 1 << cm->log2_tile_cols;
3739 const int tile_rows = 1 << cm->log2_tile_rows;
3740 int tile_col, tile_row;
3742 RD_OPT *rd_opt = &cpi->rd;
3743 for (i = 0; i < MAX_REF_FRAMES; i++) {
3744 for (j = 0; j < REFERENCE_MODES; j++)
3745 rd_opt->prediction_type_threshes_prev[i][j] =
3746 rd_opt->prediction_type_threshes[i][j];
3748 for (j = 0; j < SWITCHABLE_FILTER_CONTEXTS; j++)
3749 rd_opt->filter_threshes_prev[i][j] = rd_opt->filter_threshes[i][j];
3752 if (cpi->tile_data != NULL) {
3753 for (tile_row = 0; tile_row < tile_rows; ++tile_row)
3754 for (tile_col = 0; tile_col < tile_cols; ++tile_col) {
3755 TileDataEnc *tile_data =
3756 &cpi->tile_data[tile_row * tile_cols + tile_col];
3757 for (i = 0; i < BLOCK_SIZES; ++i) {
3758 for (j = 0; j < MAX_MODES; ++j) {
3759 tile_data->thresh_freq_fact_prev[i][j] =
3760 tile_data->thresh_freq_fact[i][j];
3768 static INLINE void set_raw_source_frame(VP9_COMP *cpi) {
3769 #ifdef ENABLE_KF_DENOISE
3770 if (is_spatial_denoise_enabled(cpi)) {
3771 cpi->raw_source_frame = vp9_scale_if_required(
3772 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
3773 (oxcf->pass == 0), EIGHTTAP, 0);
3775 cpi->raw_source_frame = cpi->Source;
3778 cpi->raw_source_frame = cpi->Source;
3782 static int encode_without_recode_loop(VP9_COMP *cpi, size_t *size,
3784 VP9_COMMON *const cm = &cpi->common;
3785 SVC *const svc = &cpi->svc;
3786 int q = 0, bottom_index = 0, top_index = 0;
3787 int no_drop_scene_change = 0;
3788 const INTERP_FILTER filter_scaler =
3789 (is_one_pass_cbr_svc(cpi))
3790 ? svc->downsample_filter_type[svc->spatial_layer_id]
3792 const int phase_scaler =
3793 (is_one_pass_cbr_svc(cpi))
3794 ? svc->downsample_filter_phase[svc->spatial_layer_id]
3797 if (cm->show_existing_frame) {
3798 cpi->rc.this_frame_target = 0;
3799 if (is_psnr_calc_enabled(cpi)) set_raw_source_frame(cpi);
3803 svc->time_stamp_prev[svc->spatial_layer_id] = svc->time_stamp_superframe;
3805 // Flag to check if its valid to compute the source sad (used for
3806 // scene detection and for superblock content state in CBR mode).
3807 // The flag may get reset below based on SVC or resizing state.
3808 cpi->compute_source_sad_onepass = cpi->oxcf.mode == REALTIME;
3810 vpx_clear_system_state();
3812 set_frame_size(cpi);
3814 if (is_one_pass_cbr_svc(cpi) &&
3815 cpi->un_scaled_source->y_width == cm->width << 2 &&
3816 cpi->un_scaled_source->y_height == cm->height << 2 &&
3817 svc->scaled_temp.y_width == cm->width << 1 &&
3818 svc->scaled_temp.y_height == cm->height << 1) {
3819 // For svc, if it is a 1/4x1/4 downscaling, do a two-stage scaling to take
3820 // advantage of the 1:2 optimized scaler. In the process, the 1/2x1/2
3821 // result will be saved in scaled_temp and might be used later.
3822 const INTERP_FILTER filter_scaler2 = svc->downsample_filter_type[1];
3823 const int phase_scaler2 = svc->downsample_filter_phase[1];
3824 cpi->Source = vp9_svc_twostage_scale(
3825 cm, cpi->un_scaled_source, &cpi->scaled_source, &svc->scaled_temp,
3826 filter_scaler, phase_scaler, filter_scaler2, phase_scaler2);
3827 svc->scaled_one_half = 1;
3828 } else if (is_one_pass_cbr_svc(cpi) &&
3829 cpi->un_scaled_source->y_width == cm->width << 1 &&
3830 cpi->un_scaled_source->y_height == cm->height << 1 &&
3831 svc->scaled_one_half) {
3832 // If the spatial layer is 1/2x1/2 and the scaling is already done in the
3833 // two-stage scaling, use the result directly.
3834 cpi->Source = &svc->scaled_temp;
3835 svc->scaled_one_half = 0;
3837 cpi->Source = vp9_scale_if_required(
3838 cm, cpi->un_scaled_source, &cpi->scaled_source, (cpi->oxcf.pass == 0),
3839 filter_scaler, phase_scaler);
3841 #ifdef OUTPUT_YUV_SVC_SRC
3842 // Write out at most 3 spatial layers.
3843 if (is_one_pass_cbr_svc(cpi) && svc->spatial_layer_id < 3) {
3844 vpx_write_yuv_frame(yuv_svc_src[svc->spatial_layer_id], cpi->Source);
3847 // Unfiltered raw source used in metrics calculation if the source
3848 // has been filtered.
3849 if (is_psnr_calc_enabled(cpi)) {
3850 #ifdef ENABLE_KF_DENOISE
3851 if (is_spatial_denoise_enabled(cpi)) {
3852 cpi->raw_source_frame = vp9_scale_if_required(
3853 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
3854 (cpi->oxcf.pass == 0), EIGHTTAP, phase_scaler);
3856 cpi->raw_source_frame = cpi->Source;
3859 cpi->raw_source_frame = cpi->Source;
3863 if ((cpi->use_svc &&
3864 (svc->spatial_layer_id < svc->number_spatial_layers - 1 ||
3865 svc->temporal_layer_id < svc->number_temporal_layers - 1 ||
3866 svc->current_superframe < 1)) ||
3867 cpi->resize_pending || cpi->resize_state || cpi->external_resize ||
3868 cpi->resize_state != ORIG) {
3869 cpi->compute_source_sad_onepass = 0;
3870 if (cpi->content_state_sb_fd != NULL)
3871 memset(cpi->content_state_sb_fd, 0,
3872 (cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1) *
3873 sizeof(*cpi->content_state_sb_fd));
3876 // Avoid scaling last_source unless its needed.
3877 // Last source is needed if avg_source_sad() is used, or if
3878 // partition_search_type == SOURCE_VAR_BASED_PARTITION, or if noise
3879 // estimation is enabled.
3880 if (cpi->unscaled_last_source != NULL &&
3881 (cpi->oxcf.content == VP9E_CONTENT_SCREEN ||
3882 (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == VPX_VBR &&
3883 cpi->oxcf.mode == REALTIME && cpi->oxcf.speed >= 5) ||
3884 cpi->sf.partition_search_type == SOURCE_VAR_BASED_PARTITION ||
3885 (cpi->noise_estimate.enabled && !cpi->oxcf.noise_sensitivity) ||
3886 cpi->compute_source_sad_onepass))
3887 cpi->Last_Source = vp9_scale_if_required(
3888 cm, cpi->unscaled_last_source, &cpi->scaled_last_source,
3889 (cpi->oxcf.pass == 0), EIGHTTAP, 0);
3891 if (cpi->Last_Source == NULL ||
3892 cpi->Last_Source->y_width != cpi->Source->y_width ||
3893 cpi->Last_Source->y_height != cpi->Source->y_height)
3894 cpi->compute_source_sad_onepass = 0;
3896 if (frame_is_intra_only(cm) || cpi->resize_pending != 0) {
3897 memset(cpi->consec_zero_mv, 0,
3898 cm->mi_rows * cm->mi_cols * sizeof(*cpi->consec_zero_mv));
3901 #if CONFIG_VP9_TEMPORAL_DENOISING
3902 if (cpi->oxcf.noise_sensitivity > 0 && cpi->use_svc)
3903 vp9_denoiser_reset_on_first_frame(cpi);
3906 // Scene detection is always used for VBR mode or screen-content case.
3907 // For other cases (e.g., CBR mode) use it for 5 <= speed < 8 for now
3908 // (need to check encoding time cost for doing this for speed 8).
3909 cpi->rc.high_source_sad = 0;
3910 cpi->rc.hybrid_intra_scene_change = 0;
3911 cpi->rc.re_encode_maxq_scene_change = 0;
3912 if (cm->show_frame && cpi->oxcf.mode == REALTIME &&
3913 (cpi->oxcf.rc_mode == VPX_VBR ||
3914 cpi->oxcf.content == VP9E_CONTENT_SCREEN ||
3915 (cpi->oxcf.speed >= 5 && cpi->oxcf.speed < 8)))
3916 vp9_scene_detection_onepass(cpi);
3918 if (svc->spatial_layer_id == svc->first_spatial_layer_to_encode) {
3919 svc->high_source_sad_superframe = cpi->rc.high_source_sad;
3920 svc->high_num_blocks_with_motion = cpi->rc.high_num_blocks_with_motion;
3921 // On scene change reset temporal layer pattern to TL0.
3922 // Note that if the base/lower spatial layers are skipped: instead of
3923 // inserting base layer here, we force max-q for the next superframe
3924 // with lower spatial layers: this is done in vp9_encodedframe_overshoot()
3925 // when max-q is decided for the current layer.
3926 // Only do this reset for bypass/flexible mode.
3927 if (svc->high_source_sad_superframe && svc->temporal_layer_id > 0 &&
3928 svc->temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS) {
3929 // rc->high_source_sad will get reset so copy it to restore it.
3930 int tmp_high_source_sad = cpi->rc.high_source_sad;
3931 vp9_svc_reset_temporal_layers(cpi, cm->frame_type == KEY_FRAME);
3932 cpi->rc.high_source_sad = tmp_high_source_sad;
3936 vp9_update_noise_estimate(cpi);
3938 // For 1 pass CBR, check if we are dropping this frame.
3939 // Never drop on key frame, if base layer is key for svc,
3940 // on scene change, or if superframe has layer sync.
3941 if ((cpi->rc.high_source_sad || svc->high_source_sad_superframe) &&
3942 !(cpi->rc.use_post_encode_drop && svc->last_layer_dropped[0]))
3943 no_drop_scene_change = 1;
3944 if (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == VPX_CBR &&
3945 !frame_is_intra_only(cm) && !no_drop_scene_change &&
3946 !svc->superframe_has_layer_sync &&
3948 !svc->layer_context[svc->temporal_layer_id].is_key_frame)) {
3949 if (vp9_rc_drop_frame(cpi)) return 0;
3952 // For 1 pass CBR SVC, only ZEROMV is allowed for spatial reference frame
3953 // when svc->force_zero_mode_spatial_ref = 1. Under those conditions we can
3954 // avoid this frame-level upsampling (for non intra_only frames).
3955 if (frame_is_intra_only(cm) == 0 &&
3956 !(is_one_pass_cbr_svc(cpi) && svc->force_zero_mode_spatial_ref)) {
3957 vp9_scale_references(cpi);
3960 set_size_independent_vars(cpi);
3961 set_size_dependent_vars(cpi, &q, &bottom_index, &top_index);
3963 // search method and step parameter might be changed in speed settings.
3964 init_motion_estimation(cpi);
3966 if (cpi->sf.copy_partition_flag) alloc_copy_partition_data(cpi);
3968 if (cpi->sf.svc_use_lowres_part &&
3969 svc->spatial_layer_id == svc->number_spatial_layers - 2) {
3970 if (svc->prev_partition_svc == NULL) {
3972 cm, svc->prev_partition_svc,
3973 (BLOCK_SIZE *)vpx_calloc(cm->mi_stride * cm->mi_rows,
3974 sizeof(*svc->prev_partition_svc)));
3978 // TODO(jianj): Look into issue of skin detection with high bitdepth.
3979 if (cm->bit_depth == 8 && cpi->oxcf.speed >= 5 && cpi->oxcf.pass == 0 &&
3980 cpi->oxcf.rc_mode == VPX_CBR &&
3981 cpi->oxcf.content != VP9E_CONTENT_SCREEN &&
3982 cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
3983 cpi->use_skin_detection = 1;
3986 // Enable post encode frame dropping for CBR on non key frame, when
3987 // ext_use_post_encode_drop is specified by user.
3988 cpi->rc.use_post_encode_drop = cpi->rc.ext_use_post_encode_drop &&
3989 cpi->oxcf.rc_mode == VPX_CBR &&
3990 cm->frame_type != KEY_FRAME;
3992 vp9_set_quantizer(cm, q);
3993 vp9_set_variance_partition_thresholds(cpi, q, 0);
3997 suppress_active_map(cpi);
4000 // On non-zero spatial layer, check for disabling inter-layer
4002 if (svc->spatial_layer_id > 0) vp9_svc_constrain_inter_layer_pred(cpi);
4003 vp9_svc_assert_constraints_pattern(cpi);
4006 if (cpi->rc.last_post_encode_dropped_scene_change) {
4007 cpi->rc.high_source_sad = 1;
4008 svc->high_source_sad_superframe = 1;
4009 // For now disable use_source_sad since Last_Source will not be the previous
4010 // encoded but the dropped one.
4011 cpi->sf.use_source_sad = 0;
4012 cpi->rc.last_post_encode_dropped_scene_change = 0;
4014 // Check if this high_source_sad (scene/slide change) frame should be
4015 // encoded at high/max QP, and if so, set the q and adjust some rate
4016 // control parameters.
4017 if (cpi->sf.overshoot_detection_cbr_rt == FAST_DETECTION_MAXQ &&
4018 (cpi->rc.high_source_sad ||
4019 (cpi->use_svc && svc->high_source_sad_superframe))) {
4020 if (vp9_encodedframe_overshoot(cpi, -1, &q)) {
4021 vp9_set_quantizer(cm, q);
4022 vp9_set_variance_partition_thresholds(cpi, q, 0);
4026 #if !CONFIG_REALTIME_ONLY
4027 // Variance adaptive and in frame q adjustment experiments are mutually
4029 if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
4030 vp9_vaq_frame_setup(cpi);
4031 } else if (cpi->oxcf.aq_mode == EQUATOR360_AQ) {
4032 vp9_360aq_frame_setup(cpi);
4033 } else if (cpi->oxcf.aq_mode == COMPLEXITY_AQ) {
4034 vp9_setup_in_frame_q_adj(cpi);
4035 } else if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ) {
4036 // it may be pretty bad for rate-control,
4037 // and I should handle it somehow
4038 vp9_alt_ref_aq_setup_map(cpi->alt_ref_aq, cpi);
4041 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
4042 vp9_cyclic_refresh_setup(cpi);
4043 } else if (cpi->roi.enabled && !frame_is_intra_only(cm)) {
4046 #if !CONFIG_REALTIME_ONLY
4050 apply_active_map(cpi);
4052 vp9_encode_frame(cpi);
4054 // Check if we should re-encode this frame at high Q because of high
4055 // overshoot based on the encoded frame size. Only for frames where
4056 // high temporal-source SAD is detected.
4057 // For SVC: all spatial layers are checked for re-encoding.
4058 if (cpi->sf.overshoot_detection_cbr_rt == RE_ENCODE_MAXQ &&
4059 (cpi->rc.high_source_sad ||
4060 (cpi->use_svc && svc->high_source_sad_superframe))) {
4062 // Get an estimate of the encoded frame size.
4063 save_coding_context(cpi);
4064 vp9_pack_bitstream(cpi, dest, size);
4065 restore_coding_context(cpi);
4066 frame_size = (int)(*size) << 3;
4067 // Check if encoded frame will overshoot too much, and if so, set the q and
4068 // adjust some rate control parameters, and return to re-encode the frame.
4069 if (vp9_encodedframe_overshoot(cpi, frame_size, &q)) {
4070 vpx_clear_system_state();
4071 vp9_set_quantizer(cm, q);
4072 vp9_set_variance_partition_thresholds(cpi, q, 0);
4073 suppress_active_map(cpi);
4074 // Turn-off cyclic refresh for re-encoded frame.
4075 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
4076 CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
4077 unsigned char *const seg_map = cpi->segmentation_map;
4078 memset(seg_map, 0, cm->mi_rows * cm->mi_cols);
4079 memset(cr->last_coded_q_map, MAXQ,
4080 cm->mi_rows * cm->mi_cols * sizeof(*cr->last_coded_q_map));
4082 vp9_disable_segmentation(&cm->seg);
4084 apply_active_map(cpi);
4085 vp9_encode_frame(cpi);
4089 // Update some stats from cyclic refresh, and check for golden frame update.
4090 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && cm->seg.enabled &&
4091 !frame_is_intra_only(cm))
4092 vp9_cyclic_refresh_postencode(cpi);
4094 // Update the skip mb flag probabilities based on the distribution
4095 // seen in the last encoder iteration.
4096 // update_base_skip_probs(cpi);
4097 vpx_clear_system_state();
4101 #if !CONFIG_REALTIME_ONLY
4102 #define MAX_QSTEP_ADJ 4
4103 static int get_qstep_adj(int rate_excess, int rate_limit) {
4105 rate_limit ? ((rate_excess + rate_limit / 2) / rate_limit) : INT_MAX;
4106 return VPXMIN(qstep, MAX_QSTEP_ADJ);
4109 static void encode_with_recode_loop(VP9_COMP *cpi, size_t *size,
4111 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
4112 VP9_COMMON *const cm = &cpi->common;
4113 RATE_CONTROL *const rc = &cpi->rc;
4114 int bottom_index, top_index;
4116 int loop_at_this_size = 0;
4118 int overshoot_seen = 0;
4119 int undershoot_seen = 0;
4120 int frame_over_shoot_limit;
4121 int frame_under_shoot_limit;
4122 int q = 0, q_low = 0, q_high = 0;
4124 #ifdef AGGRESSIVE_VBR
4128 if (cm->show_existing_frame) {
4129 rc->this_frame_target = 0;
4130 if (is_psnr_calc_enabled(cpi)) set_raw_source_frame(cpi);
4134 set_size_independent_vars(cpi);
4136 enable_acl = cpi->sf.allow_acl ? (cm->frame_type == KEY_FRAME) ||
4137 (cpi->twopass.gf_group.index == 1)
4141 vpx_clear_system_state();
4143 set_frame_size(cpi);
4145 if (loop_count == 0 || cpi->resize_pending != 0) {
4146 set_size_dependent_vars(cpi, &q, &bottom_index, &top_index);
4148 #ifdef AGGRESSIVE_VBR
4149 if (two_pass_first_group_inter(cpi)) {
4150 // Adjustment limits for min and max q
4151 qrange_adj = VPXMAX(1, (top_index - bottom_index) / 2);
4154 VPXMAX(bottom_index - qrange_adj / 2, oxcf->best_allowed_q);
4155 top_index = VPXMIN(oxcf->worst_allowed_q, top_index + qrange_adj / 2);
4158 // TODO(agrange) Scale cpi->max_mv_magnitude if frame-size has changed.
4159 set_mv_search_params(cpi);
4161 // Reset the loop state for new frame size.
4163 undershoot_seen = 0;
4165 // Reconfiguration for change in frame size has concluded.
4166 cpi->resize_pending = 0;
4168 q_low = bottom_index;
4171 loop_at_this_size = 0;
4174 // Decide frame size bounds first time through.
4175 if (loop_count == 0) {
4176 vp9_rc_compute_frame_size_bounds(cpi, rc->this_frame_target,
4177 &frame_under_shoot_limit,
4178 &frame_over_shoot_limit);
4182 vp9_scale_if_required(cm, cpi->un_scaled_source, &cpi->scaled_source,
4183 (oxcf->pass == 0), EIGHTTAP, 0);
4185 // Unfiltered raw source used in metrics calculation if the source
4186 // has been filtered.
4187 if (is_psnr_calc_enabled(cpi)) {
4188 #ifdef ENABLE_KF_DENOISE
4189 if (is_spatial_denoise_enabled(cpi)) {
4190 cpi->raw_source_frame = vp9_scale_if_required(
4191 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
4192 (oxcf->pass == 0), EIGHTTAP, 0);
4194 cpi->raw_source_frame = cpi->Source;
4197 cpi->raw_source_frame = cpi->Source;
4201 if (cpi->unscaled_last_source != NULL)
4202 cpi->Last_Source = vp9_scale_if_required(cm, cpi->unscaled_last_source,
4203 &cpi->scaled_last_source,
4204 (oxcf->pass == 0), EIGHTTAP, 0);
4206 if (frame_is_intra_only(cm) == 0) {
4207 if (loop_count > 0) {
4208 release_scaled_references(cpi);
4210 vp9_scale_references(cpi);
4213 vp9_set_quantizer(cm, q);
4215 if (loop_count == 0) setup_frame(cpi);
4217 // Variance adaptive and in frame q adjustment experiments are mutually
4219 if (oxcf->aq_mode == VARIANCE_AQ) {
4220 vp9_vaq_frame_setup(cpi);
4221 } else if (oxcf->aq_mode == EQUATOR360_AQ) {
4222 vp9_360aq_frame_setup(cpi);
4223 } else if (oxcf->aq_mode == COMPLEXITY_AQ) {
4224 vp9_setup_in_frame_q_adj(cpi);
4225 } else if (oxcf->aq_mode == LOOKAHEAD_AQ) {
4226 vp9_alt_ref_aq_setup_map(cpi->alt_ref_aq, cpi);
4227 } else if (oxcf->aq_mode == PSNR_AQ) {
4228 vp9_psnr_aq_mode_setup(&cm->seg);
4231 vp9_encode_frame(cpi);
4233 // Update the skip mb flag probabilities based on the distribution
4234 // seen in the last encoder iteration.
4235 // update_base_skip_probs(cpi);
4237 vpx_clear_system_state();
4239 // Dummy pack of the bitstream using up to date stats to get an
4240 // accurate estimate of output frame size to determine if we need
4242 if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF) {
4243 save_coding_context(cpi);
4244 if (!cpi->sf.use_nonrd_pick_mode) vp9_pack_bitstream(cpi, dest, size);
4246 rc->projected_frame_size = (int)(*size) << 3;
4248 if (frame_over_shoot_limit == 0) frame_over_shoot_limit = 1;
4251 if (oxcf->rc_mode == VPX_Q) {
4254 if ((cm->frame_type == KEY_FRAME) && rc->this_key_frame_forced &&
4255 (rc->projected_frame_size < rc->max_frame_bandwidth)) {
4259 int64_t high_err_target = cpi->ambient_err;
4260 int64_t low_err_target = cpi->ambient_err >> 1;
4262 #if CONFIG_VP9_HIGHBITDEPTH
4263 if (cm->use_highbitdepth) {
4264 kf_err = vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4266 kf_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4269 kf_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4270 #endif // CONFIG_VP9_HIGHBITDEPTH
4272 // Prevent possible divide by zero error below for perfect KF
4275 // The key frame is not good enough or we can afford
4276 // to make it better without undue risk of popping.
4277 if ((kf_err > high_err_target &&
4278 rc->projected_frame_size <= frame_over_shoot_limit) ||
4279 (kf_err > low_err_target &&
4280 rc->projected_frame_size <= frame_under_shoot_limit)) {
4282 q_high = q > q_low ? q - 1 : q_low;
4285 q = (int)((q * high_err_target) / kf_err);
4286 q = VPXMIN(q, (q_high + q_low) >> 1);
4287 } else if (kf_err < low_err_target &&
4288 rc->projected_frame_size >= frame_under_shoot_limit) {
4289 // The key frame is much better than the previous frame
4291 q_low = q < q_high ? q + 1 : q_high;
4294 q = (int)((q * low_err_target) / kf_err);
4295 q = VPXMIN(q, (q_high + q_low + 1) >> 1);
4298 // Clamp Q to upper and lower limits:
4299 q = clamp(q, q_low, q_high);
4302 } else if (recode_loop_test(cpi, frame_over_shoot_limit,
4303 frame_under_shoot_limit, q,
4304 VPXMAX(q_high, top_index), bottom_index)) {
4305 // Is the projected frame size out of range and are we allowed
4306 // to attempt to recode.
4311 if (cpi->resize_pending == 1) {
4312 // Change in frame size so go back around the recode loop.
4313 cpi->rc.frame_size_selector =
4314 SCALE_STEP1 - cpi->rc.frame_size_selector;
4315 cpi->rc.next_frame_size_selector = cpi->rc.frame_size_selector;
4317 #if CONFIG_INTERNAL_STATS
4318 ++cpi->tot_recode_hits;
4325 // Frame size out of permitted range:
4326 // Update correction factor & compute new Q to try...
4328 // Frame is too large
4329 if (rc->projected_frame_size > rc->this_frame_target) {
4330 // Special case if the projected size is > the max allowed.
4331 if ((q == q_high) &&
4332 ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
4333 (!rc->is_src_frame_alt_ref &&
4334 (rc->projected_frame_size >=
4335 big_rate_miss_high_threshold(cpi))))) {
4336 int max_rate = VPXMAX(1, VPXMIN(rc->max_frame_bandwidth,
4337 big_rate_miss_high_threshold(cpi)));
4339 q_val_high = vp9_convert_qindex_to_q(q_high, cm->bit_depth);
4341 q_val_high * ((double)rc->projected_frame_size / max_rate);
4342 q_high = vp9_convert_q_to_qindex(q_val_high, cm->bit_depth);
4343 q_high = clamp(q_high, rc->best_quality, rc->worst_quality);
4346 // Raise Qlow as to at least the current value
4348 get_qstep_adj(rc->projected_frame_size, rc->this_frame_target);
4349 q_low = VPXMIN(q + qstep, q_high);
4351 if (undershoot_seen || loop_at_this_size > 1) {
4352 // Update rate_correction_factor unless
4353 vp9_rc_update_rate_correction_factors(cpi);
4355 q = (q_high + q_low + 1) / 2;
4357 // Update rate_correction_factor unless
4358 vp9_rc_update_rate_correction_factors(cpi);
4360 q = vp9_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4361 VPXMAX(q_high, top_index));
4363 while (q < q_low && retries < 10) {
4364 vp9_rc_update_rate_correction_factors(cpi);
4365 q = vp9_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4366 VPXMAX(q_high, top_index));
4373 // Frame is too small
4375 get_qstep_adj(rc->this_frame_target, rc->projected_frame_size);
4376 q_high = VPXMAX(q - qstep, q_low);
4378 if (overshoot_seen || loop_at_this_size > 1) {
4379 vp9_rc_update_rate_correction_factors(cpi);
4380 q = (q_high + q_low) / 2;
4382 vp9_rc_update_rate_correction_factors(cpi);
4383 q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
4384 VPXMIN(q_low, bottom_index), top_index);
4385 // Special case reset for qlow for constrained quality.
4386 // This should only trigger where there is very substantial
4387 // undershoot on a frame and the auto cq level is above
4388 // the user passsed in value.
4389 if (oxcf->rc_mode == VPX_CQ && q < q_low) {
4393 while (q > q_high && retries < 10) {
4394 vp9_rc_update_rate_correction_factors(cpi);
4395 q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
4396 VPXMIN(q_low, bottom_index), top_index);
4400 undershoot_seen = 1;
4403 // Clamp Q to upper and lower limits:
4404 q = clamp(q, q_low, q_high);
4406 loop = (q != last_q);
4412 // Special case for overlay frame.
4413 if (rc->is_src_frame_alt_ref &&
4414 rc->projected_frame_size < rc->max_frame_bandwidth)
4419 ++loop_at_this_size;
4421 #if CONFIG_INTERNAL_STATS
4422 ++cpi->tot_recode_hits;
4426 if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF)
4427 if (loop || !enable_acl) restore_coding_context(cpi);
4430 #ifdef AGGRESSIVE_VBR
4431 if (two_pass_first_group_inter(cpi)) {
4432 cpi->twopass.active_worst_quality =
4433 VPXMIN(q + qrange_adj, oxcf->worst_allowed_q);
4434 } else if (!frame_is_kf_gf_arf(cpi)) {
4436 if (!frame_is_kf_gf_arf(cpi)) {
4438 // Have we been forced to adapt Q outside the expected range by an extreme
4439 // rate miss. If so adjust the active maxQ for the subsequent frames.
4440 if (!rc->is_src_frame_alt_ref && (q > cpi->twopass.active_worst_quality)) {
4441 cpi->twopass.active_worst_quality = q;
4442 } else if (oxcf->vbr_corpus_complexity && q == q_low &&
4443 rc->projected_frame_size < rc->this_frame_target) {
4444 cpi->twopass.active_worst_quality =
4445 VPXMAX(q, cpi->twopass.active_worst_quality - 1);
4450 // Skip recoding, if model diff is below threshold
4451 const int thresh = compute_context_model_thresh(cpi);
4452 const int diff = compute_context_model_diff(cm);
4453 if (diff < thresh) {
4454 vpx_clear_system_state();
4455 restore_coding_context(cpi);
4459 vp9_encode_frame(cpi);
4460 vpx_clear_system_state();
4461 restore_coding_context(cpi);
4464 #endif // !CONFIG_REALTIME_ONLY
4466 static int get_ref_frame_flags(const VP9_COMP *cpi) {
4467 const int *const map = cpi->common.ref_frame_map;
4468 const int gold_is_last = map[cpi->gld_fb_idx] == map[cpi->lst_fb_idx];
4469 const int alt_is_last = map[cpi->alt_fb_idx] == map[cpi->lst_fb_idx];
4470 const int gold_is_alt = map[cpi->gld_fb_idx] == map[cpi->alt_fb_idx];
4471 int flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;
4473 if (gold_is_last) flags &= ~VP9_GOLD_FLAG;
4475 if (cpi->rc.frames_till_gf_update_due == INT_MAX &&
4476 (cpi->svc.number_temporal_layers == 1 &&
4477 cpi->svc.number_spatial_layers == 1))
4478 flags &= ~VP9_GOLD_FLAG;
4480 if (alt_is_last) flags &= ~VP9_ALT_FLAG;
4482 if (gold_is_alt) flags &= ~VP9_ALT_FLAG;
4487 static void set_ext_overrides(VP9_COMP *cpi) {
4488 // Overrides the defaults with the externally supplied values with
4489 // vp9_update_reference() and vp9_update_entropy() calls
4490 // Note: The overrides are valid only for the next frame passed
4491 // to encode_frame_to_data_rate() function
4492 if (cpi->ext_refresh_frame_context_pending) {
4493 cpi->common.refresh_frame_context = cpi->ext_refresh_frame_context;
4494 cpi->ext_refresh_frame_context_pending = 0;
4496 if (cpi->ext_refresh_frame_flags_pending) {
4497 cpi->refresh_last_frame = cpi->ext_refresh_last_frame;
4498 cpi->refresh_golden_frame = cpi->ext_refresh_golden_frame;
4499 cpi->refresh_alt_ref_frame = cpi->ext_refresh_alt_ref_frame;
4503 YV12_BUFFER_CONFIG *vp9_svc_twostage_scale(
4504 VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled,
4505 YV12_BUFFER_CONFIG *scaled_temp, INTERP_FILTER filter_type,
4506 int phase_scaler, INTERP_FILTER filter_type2, int phase_scaler2) {
4507 if (cm->mi_cols * MI_SIZE != unscaled->y_width ||
4508 cm->mi_rows * MI_SIZE != unscaled->y_height) {
4509 #if CONFIG_VP9_HIGHBITDEPTH
4510 if (cm->bit_depth == VPX_BITS_8) {
4511 vp9_scale_and_extend_frame(unscaled, scaled_temp, filter_type2,
4513 vp9_scale_and_extend_frame(scaled_temp, scaled, filter_type,
4516 scale_and_extend_frame(unscaled, scaled_temp, (int)cm->bit_depth,
4517 filter_type2, phase_scaler2);
4518 scale_and_extend_frame(scaled_temp, scaled, (int)cm->bit_depth,
4519 filter_type, phase_scaler);
4522 vp9_scale_and_extend_frame(unscaled, scaled_temp, filter_type2,
4524 vp9_scale_and_extend_frame(scaled_temp, scaled, filter_type, phase_scaler);
4525 #endif // CONFIG_VP9_HIGHBITDEPTH
4532 YV12_BUFFER_CONFIG *vp9_scale_if_required(
4533 VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled,
4534 int use_normative_scaler, INTERP_FILTER filter_type, int phase_scaler) {
4535 if (cm->mi_cols * MI_SIZE != unscaled->y_width ||
4536 cm->mi_rows * MI_SIZE != unscaled->y_height) {
4537 #if CONFIG_VP9_HIGHBITDEPTH
4538 if (use_normative_scaler && unscaled->y_width <= (scaled->y_width << 1) &&
4539 unscaled->y_height <= (scaled->y_height << 1))
4540 if (cm->bit_depth == VPX_BITS_8)
4541 vp9_scale_and_extend_frame(unscaled, scaled, filter_type, phase_scaler);
4543 scale_and_extend_frame(unscaled, scaled, (int)cm->bit_depth,
4544 filter_type, phase_scaler);
4546 scale_and_extend_frame_nonnormative(unscaled, scaled, (int)cm->bit_depth);
4548 if (use_normative_scaler && unscaled->y_width <= (scaled->y_width << 1) &&
4549 unscaled->y_height <= (scaled->y_height << 1))
4550 vp9_scale_and_extend_frame(unscaled, scaled, filter_type, phase_scaler);
4552 scale_and_extend_frame_nonnormative(unscaled, scaled);
4553 #endif // CONFIG_VP9_HIGHBITDEPTH
4560 static void set_ref_sign_bias(VP9_COMP *cpi) {
4561 VP9_COMMON *const cm = &cpi->common;
4562 RefCntBuffer *const ref_buffer = get_ref_cnt_buffer(cm, cm->new_fb_idx);
4563 const int cur_frame_index = ref_buffer->frame_index;
4564 MV_REFERENCE_FRAME ref_frame;
4566 for (ref_frame = LAST_FRAME; ref_frame < MAX_REF_FRAMES; ++ref_frame) {
4567 const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
4568 const RefCntBuffer *const ref_cnt_buf =
4569 get_ref_cnt_buffer(&cpi->common, buf_idx);
4571 cm->ref_frame_sign_bias[ref_frame] =
4572 cur_frame_index < ref_cnt_buf->frame_index;
4577 static int setup_interp_filter_search_mask(VP9_COMP *cpi) {
4578 INTERP_FILTER ifilter;
4579 int ref_total[MAX_REF_FRAMES] = { 0 };
4580 MV_REFERENCE_FRAME ref;
4582 if (cpi->common.last_frame_type == KEY_FRAME || cpi->refresh_alt_ref_frame)
4584 for (ref = LAST_FRAME; ref <= ALTREF_FRAME; ++ref)
4585 for (ifilter = EIGHTTAP; ifilter <= EIGHTTAP_SHARP; ++ifilter)
4586 ref_total[ref] += cpi->interp_filter_selected[ref][ifilter];
4588 for (ifilter = EIGHTTAP; ifilter <= EIGHTTAP_SHARP; ++ifilter) {
4589 if ((ref_total[LAST_FRAME] &&
4590 cpi->interp_filter_selected[LAST_FRAME][ifilter] == 0) &&
4591 (ref_total[GOLDEN_FRAME] == 0 ||
4592 cpi->interp_filter_selected[GOLDEN_FRAME][ifilter] * 50 <
4593 ref_total[GOLDEN_FRAME]) &&
4594 (ref_total[ALTREF_FRAME] == 0 ||
4595 cpi->interp_filter_selected[ALTREF_FRAME][ifilter] * 50 <
4596 ref_total[ALTREF_FRAME]))
4597 mask |= 1 << ifilter;
4602 #ifdef ENABLE_KF_DENOISE
4603 // Baseline Kernal weights for denoise
4604 static uint8_t dn_kernal_3[9] = { 1, 2, 1, 2, 4, 2, 1, 2, 1 };
4605 static uint8_t dn_kernal_5[25] = { 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 4,
4606 2, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1 };
4608 static INLINE void add_denoise_point(int centre_val, int data_val, int thresh,
4609 uint8_t point_weight, int *sum_val,
4611 if (abs(centre_val - data_val) <= thresh) {
4612 *sum_weight += point_weight;
4613 *sum_val += (int)data_val * (int)point_weight;
4617 static void spatial_denoise_point(uint8_t *src_ptr, const int stride,
4618 const int strength) {
4621 int thresh = strength;
4622 int kernal_size = 5;
4623 int half_k_size = 2;
4627 uint8_t *kernal_ptr;
4629 // Find the maximum deviation from the source point in the locale.
4630 tmp_ptr = src_ptr - (stride * (half_k_size + 1)) - (half_k_size + 1);
4631 for (i = 0; i < kernal_size + 2; ++i) {
4632 for (j = 0; j < kernal_size + 2; ++j) {
4633 max_diff = VPXMAX(max_diff, abs((int)*src_ptr - (int)tmp_ptr[j]));
4638 // Select the kernal size.
4639 if (max_diff > (strength + (strength >> 1))) {
4642 thresh = thresh >> 1;
4644 kernal_ptr = (kernal_size == 3) ? dn_kernal_3 : dn_kernal_5;
4647 tmp_ptr = src_ptr - (stride * half_k_size) - half_k_size;
4648 for (i = 0; i < kernal_size; ++i) {
4649 for (j = 0; j < kernal_size; ++j) {
4650 add_denoise_point((int)*src_ptr, (int)tmp_ptr[j], thresh, *kernal_ptr,
4651 &sum_val, &sum_weight);
4657 // Update the source value with the new filtered value
4658 *src_ptr = (uint8_t)((sum_val + (sum_weight >> 1)) / sum_weight);
4661 #if CONFIG_VP9_HIGHBITDEPTH
4662 static void highbd_spatial_denoise_point(uint16_t *src_ptr, const int stride,
4663 const int strength) {
4666 int thresh = strength;
4667 int kernal_size = 5;
4668 int half_k_size = 2;
4672 uint8_t *kernal_ptr;
4674 // Find the maximum deviation from the source point in the locale.
4675 tmp_ptr = src_ptr - (stride * (half_k_size + 1)) - (half_k_size + 1);
4676 for (i = 0; i < kernal_size + 2; ++i) {
4677 for (j = 0; j < kernal_size + 2; ++j) {
4678 max_diff = VPXMAX(max_diff, abs((int)src_ptr - (int)tmp_ptr[j]));
4683 // Select the kernal size.
4684 if (max_diff > (strength + (strength >> 1))) {
4687 thresh = thresh >> 1;
4689 kernal_ptr = (kernal_size == 3) ? dn_kernal_3 : dn_kernal_5;
4692 tmp_ptr = src_ptr - (stride * half_k_size) - half_k_size;
4693 for (i = 0; i < kernal_size; ++i) {
4694 for (j = 0; j < kernal_size; ++j) {
4695 add_denoise_point((int)*src_ptr, (int)tmp_ptr[j], thresh, *kernal_ptr,
4696 &sum_val, &sum_weight);
4702 // Update the source value with the new filtered value
4703 *src_ptr = (uint16_t)((sum_val + (sum_weight >> 1)) / sum_weight);
4705 #endif // CONFIG_VP9_HIGHBITDEPTH
4707 // Apply thresholded spatial noise supression to a given buffer.
4708 static void spatial_denoise_buffer(VP9_COMP *cpi, uint8_t *buffer,
4709 const int stride, const int width,
4710 const int height, const int strength) {
4711 VP9_COMMON *const cm = &cpi->common;
4712 uint8_t *src_ptr = buffer;
4716 for (row = 0; row < height; ++row) {
4717 for (col = 0; col < width; ++col) {
4718 #if CONFIG_VP9_HIGHBITDEPTH
4719 if (cm->use_highbitdepth)
4720 highbd_spatial_denoise_point(CONVERT_TO_SHORTPTR(&src_ptr[col]), stride,
4723 spatial_denoise_point(&src_ptr[col], stride, strength);
4725 spatial_denoise_point(&src_ptr[col], stride, strength);
4726 #endif // CONFIG_VP9_HIGHBITDEPTH
4732 // Apply thresholded spatial noise supression to source.
4733 static void spatial_denoise_frame(VP9_COMP *cpi) {
4734 YV12_BUFFER_CONFIG *src = cpi->Source;
4735 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
4736 TWO_PASS *const twopass = &cpi->twopass;
4737 VP9_COMMON *const cm = &cpi->common;
4739 // Base the filter strength on the current active max Q.
4740 const int q = (int)(vp9_convert_qindex_to_q(twopass->active_worst_quality,
4743 VPXMAX(oxcf->arnr_strength >> 2, VPXMIN(oxcf->arnr_strength, (q >> 4)));
4745 // Denoise each of Y,U and V buffers.
4746 spatial_denoise_buffer(cpi, src->y_buffer, src->y_stride, src->y_width,
4747 src->y_height, strength);
4749 strength += (strength >> 1);
4750 spatial_denoise_buffer(cpi, src->u_buffer, src->uv_stride, src->uv_width,
4751 src->uv_height, strength << 1);
4753 spatial_denoise_buffer(cpi, src->v_buffer, src->uv_stride, src->uv_width,
4754 src->uv_height, strength << 1);
4756 #endif // ENABLE_KF_DENOISE
4758 #if !CONFIG_REALTIME_ONLY
4759 static void vp9_try_disable_lookahead_aq(VP9_COMP *cpi, size_t *size,
4761 if (cpi->common.seg.enabled)
4762 if (ALT_REF_AQ_PROTECT_GAIN) {
4763 size_t nsize = *size;
4766 // TODO(yuryg): optimize this, as
4767 // we don't really need to repack
4769 save_coding_context(cpi);
4770 vp9_disable_segmentation(&cpi->common.seg);
4771 vp9_pack_bitstream(cpi, dest, &nsize);
4772 restore_coding_context(cpi);
4774 overhead = (int)*size - (int)nsize;
4776 if (vp9_alt_ref_aq_disable_if(cpi->alt_ref_aq, overhead, (int)*size))
4777 vp9_encode_frame(cpi);
4779 vp9_enable_segmentation(&cpi->common.seg);
4784 static void set_frame_index(VP9_COMP *cpi, VP9_COMMON *cm) {
4785 RefCntBuffer *const ref_buffer = get_ref_cnt_buffer(cm, cm->new_fb_idx);
4788 const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
4789 ref_buffer->frame_index =
4790 cm->current_video_frame + gf_group->arf_src_offset[gf_group->index];
4794 // Implementation and modifications of C. Yeo, H. L. Tan, and Y. H. Tan, "On
4795 // rate distortion optimization using SSIM," Circuits and Systems for Video
4796 // Technology, IEEE Transactions on, vol. 23, no. 7, pp. 1170-1181, 2013.
4797 // SSIM_VAR_SCALE defines the strength of the bias towards SSIM in RDO.
4798 // Some sample values are:
4799 // (for midres test set)
4800 // SSIM_VAR_SCALE avg_psnr ssim ms_ssim
4801 // 8.0 9.421 -5.537 -6.898
4802 // 16.0 4.703 -5.378 -6.238
4803 // 32.0 1.929 -4.308 -4.807
4804 #define SSIM_VAR_SCALE 16.0
4805 static void set_mb_ssim_rdmult_scaling(VP9_COMP *cpi) {
4806 VP9_COMMON *cm = &cpi->common;
4807 ThreadData *td = &cpi->td;
4808 MACROBLOCK *x = &td->mb;
4809 MACROBLOCKD *xd = &x->e_mbd;
4810 uint8_t *y_buffer = cpi->Source->y_buffer;
4811 const int y_stride = cpi->Source->y_stride;
4812 const int block_size = BLOCK_16X16;
4814 const int num_8x8_w = num_8x8_blocks_wide_lookup[block_size];
4815 const int num_8x8_h = num_8x8_blocks_high_lookup[block_size];
4816 const int num_cols = (cm->mi_cols + num_8x8_w - 1) / num_8x8_w;
4817 const int num_rows = (cm->mi_rows + num_8x8_h - 1) / num_8x8_h;
4818 double log_sum = 0.0;
4821 const double c2 = 58.5225 * SSIM_VAR_SCALE; // 58.5225 = (.03*255)^2
4823 // Loop through each 64x64 block.
4824 for (row = 0; row < num_rows; ++row) {
4825 for (col = 0; col < num_cols; ++col) {
4827 double var = 0.0, num_of_var = 0.0;
4828 const int index = row * num_cols + col;
4830 for (mi_row = row * num_8x8_h;
4831 mi_row < cm->mi_rows && mi_row < (row + 1) * num_8x8_h; ++mi_row) {
4832 for (mi_col = col * num_8x8_w;
4833 mi_col < cm->mi_cols && mi_col < (col + 1) * num_8x8_w; ++mi_col) {
4835 const int row_offset_y = mi_row << 3;
4836 const int col_offset_y = mi_col << 3;
4838 buf.buf = y_buffer + row_offset_y * y_stride + col_offset_y;
4839 buf.stride = y_stride;
4841 // In order to make SSIM_VAR_SCALE in a same scale for both 8 bit
4842 // and high bit videos, the variance needs to be divided by 2.0 or
4844 // TODO(sdeng): need to tune for 12bit videos.
4845 #if CONFIG_VP9_HIGHBITDEPTH
4846 if (cpi->Source->flags & YV12_FLAG_HIGHBITDEPTH)
4847 var += vp9_high_get_sby_variance(cpi, &buf, BLOCK_8X8, xd->bd);
4850 var += vp9_get_sby_variance(cpi, &buf, BLOCK_8X8);
4855 var = var / num_of_var / 64.0;
4856 var = 2.0 * var + c2;
4857 cpi->mi_ssim_rdmult_scaling_factors[index] = var;
4858 log_sum += log(var);
4861 log_sum = exp(log_sum / (double)(num_rows * num_cols));
4863 for (row = 0; row < num_rows; ++row) {
4864 for (col = 0; col < num_cols; ++col) {
4865 const int index = row * num_cols + col;
4866 cpi->mi_ssim_rdmult_scaling_factors[index] /= log_sum;
4873 // Process the wiener variance in 16x16 block basis.
4874 static int qsort_comp(const void *elem1, const void *elem2) {
4875 int a = *((const int *)elem1);
4876 int b = *((const int *)elem2);
4877 if (a > b) return 1;
4878 if (a < b) return -1;
4882 static void init_mb_wiener_var_buffer(VP9_COMP *cpi) {
4883 VP9_COMMON *cm = &cpi->common;
4885 if (cpi->mb_wiener_variance && cpi->mb_wiener_var_rows >= cm->mb_rows &&
4886 cpi->mb_wiener_var_cols >= cm->mb_cols)
4889 vpx_free(cpi->mb_wiener_variance);
4890 cpi->mb_wiener_variance = NULL;
4893 cm, cpi->mb_wiener_variance,
4894 vpx_calloc(cm->mb_rows * cm->mb_cols, sizeof(*cpi->mb_wiener_variance)));
4895 cpi->mb_wiener_var_rows = cm->mb_rows;
4896 cpi->mb_wiener_var_cols = cm->mb_cols;
4899 static void set_mb_wiener_variance(VP9_COMP *cpi) {
4900 VP9_COMMON *cm = &cpi->common;
4901 uint8_t *buffer = cpi->Source->y_buffer;
4902 int buf_stride = cpi->Source->y_stride;
4904 #if CONFIG_VP9_HIGHBITDEPTH
4905 ThreadData *td = &cpi->td;
4906 MACROBLOCK *x = &td->mb;
4907 MACROBLOCKD *xd = &x->e_mbd;
4908 DECLARE_ALIGNED(16, uint16_t, zero_pred16[32 * 32]);
4909 DECLARE_ALIGNED(16, uint8_t, zero_pred8[32 * 32]);
4912 DECLARE_ALIGNED(16, uint8_t, zero_pred[32 * 32]);
4915 DECLARE_ALIGNED(16, int16_t, src_diff[32 * 32]);
4916 DECLARE_ALIGNED(16, tran_low_t, coeff[32 * 32]);
4918 int mb_row, mb_col, count = 0;
4919 // Hard coded operating block size
4920 const int block_size = 16;
4921 const int coeff_count = block_size * block_size;
4922 const TX_SIZE tx_size = TX_16X16;
4924 #if CONFIG_VP9_HIGHBITDEPTH
4925 xd->cur_buf = cpi->Source;
4926 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
4927 zero_pred = CONVERT_TO_BYTEPTR(zero_pred16);
4928 memset(zero_pred16, 0, sizeof(*zero_pred16) * coeff_count);
4930 zero_pred = zero_pred8;
4931 memset(zero_pred8, 0, sizeof(*zero_pred8) * coeff_count);
4934 memset(zero_pred, 0, sizeof(*zero_pred) * coeff_count);
4937 cpi->norm_wiener_variance = 0;
4939 for (mb_row = 0; mb_row < cm->mb_rows; ++mb_row) {
4940 for (mb_col = 0; mb_col < cm->mb_cols; ++mb_col) {
4942 int16_t median_val = 0;
4943 uint8_t *mb_buffer =
4944 buffer + mb_row * block_size * buf_stride + mb_col * block_size;
4945 int64_t wiener_variance = 0;
4947 #if CONFIG_VP9_HIGHBITDEPTH
4948 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
4949 vpx_highbd_subtract_block(block_size, block_size, src_diff, block_size,
4950 mb_buffer, buf_stride, zero_pred, block_size,
4952 highbd_wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
4954 vpx_subtract_block(block_size, block_size, src_diff, block_size,
4955 mb_buffer, buf_stride, zero_pred, block_size);
4956 wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
4959 vpx_subtract_block(block_size, block_size, src_diff, block_size,
4960 mb_buffer, buf_stride, zero_pred, block_size);
4961 wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
4962 #endif // CONFIG_VP9_HIGHBITDEPTH
4965 for (idx = 1; idx < coeff_count; ++idx) coeff[idx] = abs(coeff[idx]);
4967 qsort(coeff, coeff_count - 1, sizeof(*coeff), qsort_comp);
4969 // Noise level estimation
4970 median_val = coeff[coeff_count / 2];
4973 for (idx = 1; idx < coeff_count; ++idx) {
4974 int64_t sqr_coeff = (int64_t)coeff[idx] * coeff[idx];
4975 int64_t tmp_coeff = (int64_t)coeff[idx];
4977 tmp_coeff = (sqr_coeff * coeff[idx]) /
4978 (sqr_coeff + (int64_t)median_val * median_val);
4980 wiener_variance += tmp_coeff * tmp_coeff;
4982 cpi->mb_wiener_variance[mb_row * cm->mb_cols + mb_col] =
4983 wiener_variance / coeff_count;
4984 cpi->norm_wiener_variance +=
4985 cpi->mb_wiener_variance[mb_row * cm->mb_cols + mb_col];
4990 if (count) cpi->norm_wiener_variance /= count;
4991 cpi->norm_wiener_variance = VPXMAX(1, cpi->norm_wiener_variance);
4994 static void encode_frame_to_data_rate(VP9_COMP *cpi, size_t *size,
4996 unsigned int *frame_flags) {
4997 VP9_COMMON *const cm = &cpi->common;
4998 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
4999 struct segmentation *const seg = &cm->seg;
5002 // SVC: skip encoding of enhancement layer if the layer target bandwidth = 0.
5003 // If in constrained layer drop mode (svc.framedrop_mode != LAYER_DROP) and
5004 // base spatial layer was dropped, no need to set svc.skip_enhancement_layer,
5005 // as whole superframe will be dropped.
5006 if (cpi->use_svc && cpi->svc.spatial_layer_id > 0 &&
5007 cpi->oxcf.target_bandwidth == 0 &&
5008 !(cpi->svc.framedrop_mode != LAYER_DROP &&
5009 cpi->svc.drop_spatial_layer[0])) {
5010 cpi->svc.skip_enhancement_layer = 1;
5011 vp9_rc_postencode_update_drop_frame(cpi);
5012 cpi->ext_refresh_frame_flags_pending = 0;
5013 cpi->last_frame_dropped = 1;
5014 cpi->svc.last_layer_dropped[cpi->svc.spatial_layer_id] = 1;
5015 cpi->svc.drop_spatial_layer[cpi->svc.spatial_layer_id] = 1;
5016 if (cpi->svc.framedrop_mode == LAYER_DROP ||
5017 cpi->svc.drop_spatial_layer[0] == 0) {
5018 // For the case of constrained drop mode where the base is dropped
5019 // (drop_spatial_layer[0] == 1), which means full superframe dropped,
5020 // we don't increment the svc frame counters. In particular temporal
5021 // layer counter (which is incremented in vp9_inc_frame_in_layer())
5022 // won't be incremented, so on a dropped frame we try the same
5023 // temporal_layer_id on next incoming frame. This is to avoid an
5024 // issue with temporal alignement with full superframe dropping.
5025 vp9_inc_frame_in_layer(cpi);
5030 set_ext_overrides(cpi);
5031 vpx_clear_system_state();
5033 #ifdef ENABLE_KF_DENOISE
5034 // Spatial denoise of key frame.
5035 if (is_spatial_denoise_enabled(cpi)) spatial_denoise_frame(cpi);
5038 if (cm->show_existing_frame == 0) {
5039 // Update frame index
5040 set_frame_index(cpi, cm);
5042 // Set the arf sign bias for this frame.
5043 set_ref_sign_bias(cpi);
5046 // Set default state for segment based loop filter update flags.
5047 cm->lf.mode_ref_delta_update = 0;
5049 if (cpi->oxcf.pass == 2 && cpi->sf.adaptive_interp_filter_search)
5050 cpi->sf.interp_filter_search_mask = setup_interp_filter_search_mask(cpi);
5052 // Set various flags etc to special state if it is a key frame.
5053 if (frame_is_intra_only(cm)) {
5054 // Reset the loop filter deltas and segmentation map.
5055 vp9_reset_segment_features(&cm->seg);
5057 // If segmentation is enabled force a map update for key frames.
5059 seg->update_map = 1;
5060 seg->update_data = 1;
5063 // The alternate reference frame cannot be active for a key frame.
5064 cpi->rc.source_alt_ref_active = 0;
5066 cm->error_resilient_mode = oxcf->error_resilient_mode;
5067 cm->frame_parallel_decoding_mode = oxcf->frame_parallel_decoding_mode;
5069 // By default, encoder assumes decoder can use prev_mi.
5070 if (cm->error_resilient_mode) {
5071 cm->frame_parallel_decoding_mode = 1;
5072 cm->reset_frame_context = 0;
5073 cm->refresh_frame_context = 0;
5074 } else if (cm->intra_only) {
5075 // Only reset the current context.
5076 cm->reset_frame_context = 2;
5080 if (oxcf->tuning == VP8_TUNE_SSIM) set_mb_ssim_rdmult_scaling(cpi);
5082 if (oxcf->aq_mode == PERCEPTUAL_AQ) {
5083 init_mb_wiener_var_buffer(cpi);
5084 set_mb_wiener_variance(cpi);
5087 vpx_clear_system_state();
5089 #if CONFIG_INTERNAL_STATS
5090 memset(cpi->mode_chosen_counts, 0,
5091 MAX_MODES * sizeof(*cpi->mode_chosen_counts));
5093 #if CONFIG_CONSISTENT_RECODE
5094 // Backup to ensure consistency between recodes
5095 save_encode_params(cpi);
5098 if (cpi->sf.recode_loop == DISALLOW_RECODE) {
5099 if (!encode_without_recode_loop(cpi, size, dest)) return;
5101 #if !CONFIG_REALTIME_ONLY
5102 encode_with_recode_loop(cpi, size, dest);
5106 // TODO(jingning): When using show existing frame mode, we assume that the
5107 // current ARF will be directly used as the final reconstructed frame. This is
5108 // an encoder control scheme. One could in principle explore other
5109 // possibilities to arrange the reference frame buffer and their coding order.
5110 if (cm->show_existing_frame) {
5111 ref_cnt_fb(cm->buffer_pool->frame_bufs, &cm->new_fb_idx,
5112 cm->ref_frame_map[cpi->alt_fb_idx]);
5115 #if !CONFIG_REALTIME_ONLY
5116 // Disable segmentation if it decrease rate/distortion ratio
5117 if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ)
5118 vp9_try_disable_lookahead_aq(cpi, size, dest);
5121 #if CONFIG_VP9_TEMPORAL_DENOISING
5122 #ifdef OUTPUT_YUV_DENOISED
5123 if (oxcf->noise_sensitivity > 0 && denoise_svc(cpi)) {
5124 vpx_write_yuv_frame(yuv_denoised_file,
5125 &cpi->denoiser.running_avg_y[INTRA_FRAME]);
5129 #ifdef OUTPUT_YUV_SKINMAP
5130 if (cpi->common.current_video_frame > 1) {
5131 vp9_output_skin_map(cpi, yuv_skinmap_file);
5135 // Special case code to reduce pulsing when key frames are forced at a
5136 // fixed interval. Note the reconstruction error if it is the frame before
5137 // the force key frame
5138 if (cpi->rc.next_key_frame_forced && cpi->rc.frames_to_key == 1) {
5139 #if CONFIG_VP9_HIGHBITDEPTH
5140 if (cm->use_highbitdepth) {
5142 vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5144 cpi->ambient_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5147 cpi->ambient_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5148 #endif // CONFIG_VP9_HIGHBITDEPTH
5151 // If the encoder forced a KEY_FRAME decision
5152 if (cm->frame_type == KEY_FRAME) cpi->refresh_last_frame = 1;
5154 cm->frame_to_show = get_frame_new_buffer(cm);
5155 cm->frame_to_show->color_space = cm->color_space;
5156 cm->frame_to_show->color_range = cm->color_range;
5157 cm->frame_to_show->render_width = cm->render_width;
5158 cm->frame_to_show->render_height = cm->render_height;
5160 // Pick the loop filter level for the frame.
5161 loopfilter_frame(cpi, cm);
5163 if (cpi->rc.use_post_encode_drop) save_coding_context(cpi);
5165 // build the bitstream
5166 vp9_pack_bitstream(cpi, dest, size);
5168 if (cpi->rc.use_post_encode_drop && cm->base_qindex < cpi->rc.worst_quality &&
5169 cpi->svc.spatial_layer_id == 0 && post_encode_drop_cbr(cpi, size)) {
5170 restore_coding_context(cpi);
5174 cpi->last_frame_dropped = 0;
5175 cpi->svc.last_layer_dropped[cpi->svc.spatial_layer_id] = 0;
5176 if (cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1)
5177 cpi->svc.num_encoded_top_layer++;
5179 // Keep track of the frame buffer index updated/refreshed for the
5180 // current encoded TL0 superframe.
5181 if (cpi->svc.temporal_layer_id == 0) {
5182 if (cpi->refresh_last_frame)
5183 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->lst_fb_idx;
5184 else if (cpi->refresh_golden_frame)
5185 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->gld_fb_idx;
5186 else if (cpi->refresh_alt_ref_frame)
5187 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->alt_fb_idx;
5190 if (cm->seg.update_map) update_reference_segmentation_map(cpi);
5192 if (frame_is_intra_only(cm) == 0) {
5193 release_scaled_references(cpi);
5195 vp9_update_reference_frames(cpi);
5197 if (!cm->show_existing_frame) {
5198 for (t = TX_4X4; t <= TX_32X32; ++t) {
5199 full_to_model_counts(cpi->td.counts->coef[t],
5200 cpi->td.rd_counts.coef_counts[t]);
5203 if (!cm->error_resilient_mode && !cm->frame_parallel_decoding_mode) {
5204 if (!frame_is_intra_only(cm)) {
5205 vp9_adapt_mode_probs(cm);
5206 vp9_adapt_mv_probs(cm, cm->allow_high_precision_mv);
5208 vp9_adapt_coef_probs(cm);
5212 cpi->ext_refresh_frame_flags_pending = 0;
5214 if (cpi->refresh_golden_frame == 1)
5215 cpi->frame_flags |= FRAMEFLAGS_GOLDEN;
5217 cpi->frame_flags &= ~FRAMEFLAGS_GOLDEN;
5219 if (cpi->refresh_alt_ref_frame == 1)
5220 cpi->frame_flags |= FRAMEFLAGS_ALTREF;
5222 cpi->frame_flags &= ~FRAMEFLAGS_ALTREF;
5224 cpi->ref_frame_flags = get_ref_frame_flags(cpi);
5226 cm->last_frame_type = cm->frame_type;
5228 vp9_rc_postencode_update(cpi, *size);
5230 *size = VPXMAX(1, *size);
5233 output_frame_level_debug_stats(cpi);
5236 if (cm->frame_type == KEY_FRAME) {
5237 // Tell the caller that the frame was coded as a key frame
5238 *frame_flags = cpi->frame_flags | FRAMEFLAGS_KEY;
5240 *frame_flags = cpi->frame_flags & ~FRAMEFLAGS_KEY;
5243 // Clear the one shot update flags for segmentation map and mode/ref loop
5245 cm->seg.update_map = 0;
5246 cm->seg.update_data = 0;
5247 cm->lf.mode_ref_delta_update = 0;
5249 // keep track of the last coded dimensions
5250 cm->last_width = cm->width;
5251 cm->last_height = cm->height;
5253 // reset to normal state now that we are done.
5254 if (!cm->show_existing_frame) {
5255 cm->last_show_frame = cm->show_frame;
5256 cm->prev_frame = cm->cur_frame;
5259 if (cm->show_frame) {
5260 vp9_swap_mi_and_prev_mi(cm);
5261 // Don't increment frame counters if this was an altref buffer
5262 // update not a real frame
5263 ++cm->current_video_frame;
5264 if (cpi->use_svc) vp9_inc_frame_in_layer(cpi);
5269 .layer_context[cpi->svc.spatial_layer_id *
5270 cpi->svc.number_temporal_layers +
5271 cpi->svc.temporal_layer_id]
5272 .last_frame_type = cm->frame_type;
5273 // Reset layer_sync back to 0 for next frame.
5274 cpi->svc.spatial_layer_sync[cpi->svc.spatial_layer_id] = 0;
5277 cpi->force_update_segmentation = 0;
5279 #if !CONFIG_REALTIME_ONLY
5280 if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ)
5281 vp9_alt_ref_aq_unset_all(cpi->alt_ref_aq, cpi);
5284 cpi->svc.previous_frame_is_intra_only = cm->intra_only;
5285 cpi->svc.set_intra_only_frame = 0;
5288 static void SvcEncode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5289 unsigned int *frame_flags) {
5290 vp9_rc_get_svc_params(cpi);
5291 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5294 static void Pass0Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5295 unsigned int *frame_flags) {
5296 if (cpi->oxcf.rc_mode == VPX_CBR) {
5297 vp9_rc_get_one_pass_cbr_params(cpi);
5299 vp9_rc_get_one_pass_vbr_params(cpi);
5301 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5304 #if !CONFIG_REALTIME_ONLY
5305 static void Pass2Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5306 unsigned int *frame_flags) {
5307 cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED;
5308 #if CONFIG_MISMATCH_DEBUG
5309 mismatch_move_frame_idx_w();
5311 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5313 vp9_twopass_postencode_update(cpi);
5315 #endif // !CONFIG_REALTIME_ONLY
5317 static void init_ref_frame_bufs(VP9_COMMON *cm) {
5319 BufferPool *const pool = cm->buffer_pool;
5320 cm->new_fb_idx = INVALID_IDX;
5321 for (i = 0; i < REF_FRAMES; ++i) {
5322 cm->ref_frame_map[i] = INVALID_IDX;
5324 for (i = 0; i < FRAME_BUFFERS; ++i) {
5325 pool->frame_bufs[i].ref_count = 0;
5329 static void check_initial_width(VP9_COMP *cpi,
5330 #if CONFIG_VP9_HIGHBITDEPTH
5331 int use_highbitdepth,
5333 int subsampling_x, int subsampling_y) {
5334 VP9_COMMON *const cm = &cpi->common;
5336 if (!cpi->initial_width ||
5337 #if CONFIG_VP9_HIGHBITDEPTH
5338 cm->use_highbitdepth != use_highbitdepth ||
5340 cm->subsampling_x != subsampling_x ||
5341 cm->subsampling_y != subsampling_y) {
5342 cm->subsampling_x = subsampling_x;
5343 cm->subsampling_y = subsampling_y;
5344 #if CONFIG_VP9_HIGHBITDEPTH
5345 cm->use_highbitdepth = use_highbitdepth;
5348 alloc_raw_frame_buffers(cpi);
5349 init_ref_frame_bufs(cm);
5350 alloc_util_frame_buffers(cpi);
5352 init_motion_estimation(cpi); // TODO(agrange) This can be removed.
5354 cpi->initial_width = cm->width;
5355 cpi->initial_height = cm->height;
5356 cpi->initial_mbs = cm->MBs;
5360 int vp9_receive_raw_frame(VP9_COMP *cpi, vpx_enc_frame_flags_t frame_flags,
5361 YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
5363 VP9_COMMON *const cm = &cpi->common;
5364 struct vpx_usec_timer timer;
5366 const int subsampling_x = sd->subsampling_x;
5367 const int subsampling_y = sd->subsampling_y;
5368 #if CONFIG_VP9_HIGHBITDEPTH
5369 const int use_highbitdepth = (sd->flags & YV12_FLAG_HIGHBITDEPTH) != 0;
5372 #if CONFIG_VP9_HIGHBITDEPTH
5373 check_initial_width(cpi, use_highbitdepth, subsampling_x, subsampling_y);
5375 check_initial_width(cpi, subsampling_x, subsampling_y);
5376 #endif // CONFIG_VP9_HIGHBITDEPTH
5378 #if CONFIG_VP9_HIGHBITDEPTH
5379 // Disable denoiser for high bitdepth since vp9_denoiser_filter only works for
5381 if (cm->bit_depth > 8) cpi->oxcf.noise_sensitivity = 0;
5384 #if CONFIG_VP9_TEMPORAL_DENOISING
5385 setup_denoiser_buffer(cpi);
5387 vpx_usec_timer_start(&timer);
5389 if (vp9_lookahead_push(cpi->lookahead, sd, time_stamp, end_time,
5390 #if CONFIG_VP9_HIGHBITDEPTH
5392 #endif // CONFIG_VP9_HIGHBITDEPTH
5395 vpx_usec_timer_mark(&timer);
5396 cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
5398 if ((cm->profile == PROFILE_0 || cm->profile == PROFILE_2) &&
5399 (subsampling_x != 1 || subsampling_y != 1)) {
5400 vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM,
5401 "Non-4:2:0 color format requires profile 1 or 3");
5404 if ((cm->profile == PROFILE_1 || cm->profile == PROFILE_3) &&
5405 (subsampling_x == 1 && subsampling_y == 1)) {
5406 vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM,
5407 "4:2:0 color format requires profile 0 or 2");
5414 static int frame_is_reference(const VP9_COMP *cpi) {
5415 const VP9_COMMON *cm = &cpi->common;
5417 return cm->frame_type == KEY_FRAME || cpi->refresh_last_frame ||
5418 cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame ||
5419 cm->refresh_frame_context || cm->lf.mode_ref_delta_update ||
5420 cm->seg.update_map || cm->seg.update_data;
5423 static void adjust_frame_rate(VP9_COMP *cpi,
5424 const struct lookahead_entry *source) {
5425 int64_t this_duration;
5428 if (source->ts_start == cpi->first_time_stamp_ever) {
5429 this_duration = source->ts_end - source->ts_start;
5432 int64_t last_duration =
5433 cpi->last_end_time_stamp_seen - cpi->last_time_stamp_seen;
5435 this_duration = source->ts_end - cpi->last_end_time_stamp_seen;
5437 // do a step update if the duration changes by 10%
5439 step = (int)((this_duration - last_duration) * 10 / last_duration);
5442 if (this_duration) {
5444 vp9_new_framerate(cpi, 10000000.0 / this_duration);
5446 // Average this frame's rate into the last second's average
5447 // frame rate. If we haven't seen 1 second yet, then average
5448 // over the whole interval seen.
5449 const double interval = VPXMIN(
5450 (double)(source->ts_end - cpi->first_time_stamp_ever), 10000000.0);
5451 double avg_duration = 10000000.0 / cpi->framerate;
5452 avg_duration *= (interval - avg_duration + this_duration);
5453 avg_duration /= interval;
5455 vp9_new_framerate(cpi, 10000000.0 / avg_duration);
5458 cpi->last_time_stamp_seen = source->ts_start;
5459 cpi->last_end_time_stamp_seen = source->ts_end;
5462 // Returns 0 if this is not an alt ref else the offset of the source frame
5463 // used as the arf midpoint.
5464 static int get_arf_src_index(VP9_COMP *cpi) {
5465 RATE_CONTROL *const rc = &cpi->rc;
5466 int arf_src_index = 0;
5467 if (is_altref_enabled(cpi)) {
5468 if (cpi->oxcf.pass == 2) {
5469 const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
5470 if (gf_group->update_type[gf_group->index] == ARF_UPDATE) {
5471 arf_src_index = gf_group->arf_src_offset[gf_group->index];
5473 } else if (rc->source_alt_ref_pending) {
5474 arf_src_index = rc->frames_till_gf_update_due;
5477 return arf_src_index;
5480 static void check_src_altref(VP9_COMP *cpi,
5481 const struct lookahead_entry *source) {
5482 RATE_CONTROL *const rc = &cpi->rc;
5484 if (cpi->oxcf.pass == 2) {
5485 const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
5486 rc->is_src_frame_alt_ref =
5487 (gf_group->update_type[gf_group->index] == OVERLAY_UPDATE);
5489 rc->is_src_frame_alt_ref =
5490 cpi->alt_ref_source && (source == cpi->alt_ref_source);
5493 if (rc->is_src_frame_alt_ref) {
5494 // Current frame is an ARF overlay frame.
5495 cpi->alt_ref_source = NULL;
5497 // Don't refresh the last buffer for an ARF overlay frame. It will
5498 // become the GF so preserve last as an alternative prediction option.
5499 cpi->refresh_last_frame = 0;
5503 #if CONFIG_INTERNAL_STATS
5504 static void adjust_image_stat(double y, double u, double v, double all,
5509 s->stat[ALL] += all;
5510 s->worst = VPXMIN(s->worst, all);
5512 #endif // CONFIG_INTERNAL_STATS
5514 // Adjust the maximum allowable frame size for the target level.
5515 static void level_rc_framerate(VP9_COMP *cpi, int arf_src_index) {
5516 RATE_CONTROL *const rc = &cpi->rc;
5517 LevelConstraint *const ls = &cpi->level_constraint;
5518 VP9_COMMON *const cm = &cpi->common;
5519 const double max_cpb_size = ls->max_cpb_size;
5520 vpx_clear_system_state();
5521 rc->max_frame_bandwidth = VPXMIN(rc->max_frame_bandwidth, ls->max_frame_size);
5522 if (frame_is_intra_only(cm)) {
5523 rc->max_frame_bandwidth =
5524 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.5));
5525 } else if (arf_src_index > 0) {
5526 rc->max_frame_bandwidth =
5527 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.4));
5529 rc->max_frame_bandwidth =
5530 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.2));
5534 static void update_level_info(VP9_COMP *cpi, size_t *size, int arf_src_index) {
5535 VP9_COMMON *const cm = &cpi->common;
5536 Vp9LevelInfo *const level_info = &cpi->level_info;
5537 Vp9LevelSpec *const level_spec = &level_info->level_spec;
5538 Vp9LevelStats *const level_stats = &level_info->level_stats;
5540 uint64_t luma_samples, dur_end;
5541 const uint32_t luma_pic_size = cm->width * cm->height;
5542 const uint32_t luma_pic_breadth = VPXMAX(cm->width, cm->height);
5543 LevelConstraint *const level_constraint = &cpi->level_constraint;
5544 const int8_t level_index = level_constraint->level_index;
5545 double cpb_data_size;
5547 vpx_clear_system_state();
5549 // update level_stats
5550 level_stats->total_compressed_size += *size;
5551 if (cm->show_frame) {
5552 level_stats->total_uncompressed_size +=
5554 2 * (luma_pic_size >> (cm->subsampling_x + cm->subsampling_y));
5555 level_stats->time_encoded =
5556 (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) /
5557 (double)TICKS_PER_SEC;
5560 if (arf_src_index > 0) {
5561 if (!level_stats->seen_first_altref) {
5562 level_stats->seen_first_altref = 1;
5563 } else if (level_stats->frames_since_last_altref <
5564 level_spec->min_altref_distance) {
5565 level_spec->min_altref_distance = level_stats->frames_since_last_altref;
5567 level_stats->frames_since_last_altref = 0;
5569 ++level_stats->frames_since_last_altref;
5572 if (level_stats->frame_window_buffer.len < FRAME_WINDOW_SIZE - 1) {
5573 idx = (level_stats->frame_window_buffer.start +
5574 level_stats->frame_window_buffer.len++) %
5577 idx = level_stats->frame_window_buffer.start;
5578 level_stats->frame_window_buffer.start = (idx + 1) % FRAME_WINDOW_SIZE;
5580 level_stats->frame_window_buffer.buf[idx].ts = cpi->last_time_stamp_seen;
5581 level_stats->frame_window_buffer.buf[idx].size = (uint32_t)(*size);
5582 level_stats->frame_window_buffer.buf[idx].luma_samples = luma_pic_size;
5584 if (cm->frame_type == KEY_FRAME) {
5585 level_stats->ref_refresh_map = 0;
5588 level_stats->ref_refresh_map |= vp9_get_refresh_mask(cpi);
5589 // Also need to consider the case where the encoder refers to a buffer
5590 // that has been implicitly refreshed after encoding a keyframe.
5591 if (!cm->intra_only) {
5592 level_stats->ref_refresh_map |= (1 << cpi->lst_fb_idx);
5593 level_stats->ref_refresh_map |= (1 << cpi->gld_fb_idx);
5594 level_stats->ref_refresh_map |= (1 << cpi->alt_fb_idx);
5596 for (i = 0; i < REF_FRAMES; ++i) {
5597 count += (level_stats->ref_refresh_map >> i) & 1;
5599 if (count > level_spec->max_ref_frame_buffers) {
5600 level_spec->max_ref_frame_buffers = count;
5604 // update average_bitrate
5605 level_spec->average_bitrate = (double)level_stats->total_compressed_size /
5606 125.0 / level_stats->time_encoded;
5608 // update max_luma_sample_rate
5610 for (i = 0; i < level_stats->frame_window_buffer.len; ++i) {
5611 idx = (level_stats->frame_window_buffer.start +
5612 level_stats->frame_window_buffer.len - 1 - i) %
5615 dur_end = level_stats->frame_window_buffer.buf[idx].ts;
5617 if (dur_end - level_stats->frame_window_buffer.buf[idx].ts >=
5621 luma_samples += level_stats->frame_window_buffer.buf[idx].luma_samples;
5623 if (luma_samples > level_spec->max_luma_sample_rate) {
5624 level_spec->max_luma_sample_rate = luma_samples;
5627 // update max_cpb_size
5629 for (i = 0; i < CPB_WINDOW_SIZE; ++i) {
5630 if (i >= level_stats->frame_window_buffer.len) break;
5631 idx = (level_stats->frame_window_buffer.start +
5632 level_stats->frame_window_buffer.len - 1 - i) %
5634 cpb_data_size += level_stats->frame_window_buffer.buf[idx].size;
5636 cpb_data_size = cpb_data_size / 125.0;
5637 if (cpb_data_size > level_spec->max_cpb_size) {
5638 level_spec->max_cpb_size = cpb_data_size;
5641 // update max_luma_picture_size
5642 if (luma_pic_size > level_spec->max_luma_picture_size) {
5643 level_spec->max_luma_picture_size = luma_pic_size;
5646 // update max_luma_picture_breadth
5647 if (luma_pic_breadth > level_spec->max_luma_picture_breadth) {
5648 level_spec->max_luma_picture_breadth = luma_pic_breadth;
5651 // update compression_ratio
5652 level_spec->compression_ratio = (double)level_stats->total_uncompressed_size *
5654 level_stats->total_compressed_size / 8.0;
5656 // update max_col_tiles
5657 if (level_spec->max_col_tiles < (1 << cm->log2_tile_cols)) {
5658 level_spec->max_col_tiles = (1 << cm->log2_tile_cols);
5661 if (level_index >= 0 && level_constraint->fail_flag == 0) {
5662 if (level_spec->max_luma_picture_size >
5663 vp9_level_defs[level_index].max_luma_picture_size) {
5664 level_constraint->fail_flag |= (1 << LUMA_PIC_SIZE_TOO_LARGE);
5665 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5666 "Failed to encode to the target level %d. %s",
5667 vp9_level_defs[level_index].level,
5668 level_fail_messages[LUMA_PIC_SIZE_TOO_LARGE]);
5671 if (level_spec->max_luma_picture_breadth >
5672 vp9_level_defs[level_index].max_luma_picture_breadth) {
5673 level_constraint->fail_flag |= (1 << LUMA_PIC_BREADTH_TOO_LARGE);
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[LUMA_PIC_BREADTH_TOO_LARGE]);
5680 if ((double)level_spec->max_luma_sample_rate >
5681 (double)vp9_level_defs[level_index].max_luma_sample_rate *
5682 (1 + SAMPLE_RATE_GRACE_P)) {
5683 level_constraint->fail_flag |= (1 << LUMA_SAMPLE_RATE_TOO_LARGE);
5684 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5685 "Failed to encode to the target level %d. %s",
5686 vp9_level_defs[level_index].level,
5687 level_fail_messages[LUMA_SAMPLE_RATE_TOO_LARGE]);
5690 if (level_spec->max_col_tiles > vp9_level_defs[level_index].max_col_tiles) {
5691 level_constraint->fail_flag |= (1 << TOO_MANY_COLUMN_TILE);
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_COLUMN_TILE]);
5698 if (level_spec->min_altref_distance <
5699 vp9_level_defs[level_index].min_altref_distance) {
5700 level_constraint->fail_flag |= (1 << ALTREF_DIST_TOO_SMALL);
5701 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5702 "Failed to encode to the target level %d. %s",
5703 vp9_level_defs[level_index].level,
5704 level_fail_messages[ALTREF_DIST_TOO_SMALL]);
5707 if (level_spec->max_ref_frame_buffers >
5708 vp9_level_defs[level_index].max_ref_frame_buffers) {
5709 level_constraint->fail_flag |= (1 << TOO_MANY_REF_BUFFER);
5710 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5711 "Failed to encode to the target level %d. %s",
5712 vp9_level_defs[level_index].level,
5713 level_fail_messages[TOO_MANY_REF_BUFFER]);
5716 if (level_spec->max_cpb_size > vp9_level_defs[level_index].max_cpb_size) {
5717 level_constraint->fail_flag |= (1 << CPB_TOO_LARGE);
5718 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5719 "Failed to encode to the target level %d. %s",
5720 vp9_level_defs[level_index].level,
5721 level_fail_messages[CPB_TOO_LARGE]);
5724 // Set an upper bound for the next frame size. It will be used in
5725 // level_rc_framerate() before encoding the next frame.
5727 for (i = 0; i < CPB_WINDOW_SIZE - 1; ++i) {
5728 if (i >= level_stats->frame_window_buffer.len) break;
5729 idx = (level_stats->frame_window_buffer.start +
5730 level_stats->frame_window_buffer.len - 1 - i) %
5732 cpb_data_size += level_stats->frame_window_buffer.buf[idx].size;
5734 cpb_data_size = cpb_data_size / 125.0;
5735 level_constraint->max_frame_size =
5736 (int)((vp9_level_defs[level_index].max_cpb_size - cpb_data_size) *
5738 if (level_stats->frame_window_buffer.len < CPB_WINDOW_SIZE - 1)
5739 level_constraint->max_frame_size >>= 1;
5743 typedef struct GF_PICTURE {
5744 YV12_BUFFER_CONFIG *frame;
5746 FRAME_UPDATE_TYPE update_type;
5749 static void init_gop_frames(VP9_COMP *cpi, GF_PICTURE *gf_picture,
5750 const GF_GROUP *gf_group, int *tpl_group_frames) {
5751 VP9_COMMON *cm = &cpi->common;
5757 int arf_index_stack[MAX_ARF_LAYERS];
5758 int arf_stack_size = 0;
5759 int extend_frame_count = 0;
5760 int pframe_qindex = cpi->tpl_stats[2].base_qindex;
5761 int frame_gop_offset = 0;
5763 RefCntBuffer *frame_bufs = cm->buffer_pool->frame_bufs;
5764 int8_t recon_frame_index[REFS_PER_FRAME + MAX_ARF_LAYERS];
5766 memset(recon_frame_index, -1, sizeof(recon_frame_index));
5767 stack_init(arf_index_stack, MAX_ARF_LAYERS);
5769 // TODO(jingning): To be used later for gf frame type parsing.
5772 for (i = 0; i < FRAME_BUFFERS; ++i) {
5773 if (frame_bufs[i].ref_count == 0) {
5774 alloc_frame_mvs(cm, i);
5775 if (vpx_realloc_frame_buffer(&frame_bufs[i].buf, cm->width, cm->height,
5776 cm->subsampling_x, cm->subsampling_y,
5777 #if CONFIG_VP9_HIGHBITDEPTH
5778 cm->use_highbitdepth,
5780 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
5782 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
5783 "Failed to allocate frame buffer");
5785 recon_frame_index[frame_idx] = i;
5788 if (frame_idx >= REFS_PER_FRAME + cpi->oxcf.enable_auto_arf) break;
5792 for (i = 0; i < REFS_PER_FRAME + 1; ++i) {
5793 assert(recon_frame_index[i] >= 0);
5794 cpi->tpl_recon_frames[i] = &frame_bufs[recon_frame_index[i]].buf;
5797 *tpl_group_frames = 0;
5799 // Initialize Golden reference frame.
5800 gf_picture[0].frame = get_ref_frame_buffer(cpi, GOLDEN_FRAME);
5801 for (i = 0; i < 3; ++i) gf_picture[0].ref_frame[i] = -1;
5802 gf_picture[0].update_type = gf_group->update_type[0];
5804 ++*tpl_group_frames;
5806 // Initialize base layer ARF frame
5807 gf_picture[1].frame = cpi->Source;
5808 gf_picture[1].ref_frame[0] = gld_index;
5809 gf_picture[1].ref_frame[1] = lst_index;
5810 gf_picture[1].ref_frame[2] = alt_index;
5811 gf_picture[1].update_type = gf_group->update_type[1];
5813 ++*tpl_group_frames;
5815 // Initialize P frames
5816 for (frame_idx = 2; frame_idx < MAX_ARF_GOP_SIZE; ++frame_idx) {
5817 struct lookahead_entry *buf;
5818 frame_gop_offset = gf_group->frame_gop_index[frame_idx];
5819 buf = vp9_lookahead_peek(cpi->lookahead, frame_gop_offset - 1);
5821 if (buf == NULL) break;
5823 gf_picture[frame_idx].frame = &buf->img;
5824 gf_picture[frame_idx].ref_frame[0] = gld_index;
5825 gf_picture[frame_idx].ref_frame[1] = lst_index;
5826 gf_picture[frame_idx].ref_frame[2] = alt_index;
5827 gf_picture[frame_idx].update_type = gf_group->update_type[frame_idx];
5829 switch (gf_group->update_type[frame_idx]) {
5831 stack_push(arf_index_stack, alt_index, arf_stack_size);
5833 alt_index = frame_idx;
5835 case LF_UPDATE: lst_index = frame_idx; break;
5836 case OVERLAY_UPDATE:
5837 gld_index = frame_idx;
5838 alt_index = stack_pop(arf_index_stack, arf_stack_size);
5842 lst_index = alt_index;
5843 alt_index = stack_pop(arf_index_stack, arf_stack_size);
5849 ++*tpl_group_frames;
5851 // The length of group of pictures is baseline_gf_interval, plus the
5852 // beginning golden frame from last GOP, plus the last overlay frame in
5854 if (frame_idx == gf_group->gf_group_size) break;
5861 // Extend two frames outside the current gf group.
5862 for (; frame_idx < MAX_LAG_BUFFERS && extend_frame_count < 2; ++frame_idx) {
5863 struct lookahead_entry *buf =
5864 vp9_lookahead_peek(cpi->lookahead, frame_gop_offset - 1);
5866 if (buf == NULL) break;
5868 cpi->tpl_stats[frame_idx].base_qindex = pframe_qindex;
5870 gf_picture[frame_idx].frame = &buf->img;
5871 gf_picture[frame_idx].ref_frame[0] = gld_index;
5872 gf_picture[frame_idx].ref_frame[1] = lst_index;
5873 gf_picture[frame_idx].ref_frame[2] = alt_index;
5874 gf_picture[frame_idx].update_type = LF_UPDATE;
5875 lst_index = frame_idx;
5876 ++*tpl_group_frames;
5877 ++extend_frame_count;
5882 static void init_tpl_stats(VP9_COMP *cpi) {
5884 for (frame_idx = 0; frame_idx < MAX_ARF_GOP_SIZE; ++frame_idx) {
5885 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
5886 memset(tpl_frame->tpl_stats_ptr, 0,
5887 tpl_frame->height * tpl_frame->width *
5888 sizeof(*tpl_frame->tpl_stats_ptr));
5889 tpl_frame->is_valid = 0;
5893 #if CONFIG_NON_GREEDY_MV
5894 static uint32_t full_pixel_motion_search(VP9_COMP *cpi, ThreadData *td,
5895 int frame_idx, uint8_t *cur_frame_buf,
5896 uint8_t *ref_frame_buf, int stride,
5897 BLOCK_SIZE bsize, int mi_row,
5898 int mi_col, MV *mv, int rf_idx) {
5899 MACROBLOCK *const x = &td->mb;
5900 MACROBLOCKD *const xd = &x->e_mbd;
5901 MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
5903 uint32_t bestsme = UINT_MAX;
5904 const MvLimits tmp_mv_limits = x->mv_limits;
5905 // lambda is used to adjust the importance of motion vector consitency.
5906 // TODO(angiebird): Figure out lambda's proper value.
5907 const int lambda = cpi->tpl_stats[frame_idx].lambda;
5908 int_mv nb_full_mvs[NB_MVS_NUM];
5911 MV best_ref_mv1 = { 0, 0 };
5912 MV best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */
5914 best_ref_mv1_full.col = best_ref_mv1.col >> 3;
5915 best_ref_mv1_full.row = best_ref_mv1.row >> 3;
5917 // Setup frame pointers
5918 x->plane[0].src.buf = cur_frame_buf;
5919 x->plane[0].src.stride = stride;
5920 xd->plane[0].pre[0].buf = ref_frame_buf;
5921 xd->plane[0].pre[0].stride = stride;
5923 step_param = mv_sf->reduce_first_step_size;
5924 step_param = VPXMIN(step_param, MAX_MVSEARCH_STEPS - 2);
5926 vp9_set_mv_search_range(&x->mv_limits, &best_ref_mv1);
5928 nb_full_mv_num = vp9_prepare_nb_full_mvs(&cpi->tpl_stats[frame_idx], mi_row,
5929 mi_col, rf_idx, bsize, nb_full_mvs);
5930 vp9_full_pixel_diamond_new(cpi, x, bsize, &best_ref_mv1_full, step_param,
5931 lambda, 1, nb_full_mvs, nb_full_mv_num, mv);
5933 /* restore UMV window */
5934 x->mv_limits = tmp_mv_limits;
5939 static uint32_t sub_pixel_motion_search(VP9_COMP *cpi, ThreadData *td,
5940 uint8_t *cur_frame_buf,
5941 uint8_t *ref_frame_buf, int stride,
5942 BLOCK_SIZE bsize, MV *mv) {
5943 MACROBLOCK *const x = &td->mb;
5944 MACROBLOCKD *const xd = &x->e_mbd;
5945 MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
5946 uint32_t bestsme = UINT_MAX;
5947 uint32_t distortion;
5951 MV best_ref_mv1 = { 0, 0 };
5953 // Setup frame pointers
5954 x->plane[0].src.buf = cur_frame_buf;
5955 x->plane[0].src.stride = stride;
5956 xd->plane[0].pre[0].buf = ref_frame_buf;
5957 xd->plane[0].pre[0].stride = stride;
5959 // TODO(yunqing): may use higher tap interp filter than 2 taps.
5960 // Ignore mv costing by sending NULL pointer instead of cost array
5961 bestsme = cpi->find_fractional_mv_step(
5962 x, mv, &best_ref_mv1, cpi->common.allow_high_precision_mv, x->errorperbit,
5963 &cpi->fn_ptr[bsize], 0, mv_sf->subpel_search_level,
5964 cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL, 0, 0,
5970 #else // CONFIG_NON_GREEDY_MV
5971 static uint32_t motion_compensated_prediction(VP9_COMP *cpi, ThreadData *td,
5972 uint8_t *cur_frame_buf,
5973 uint8_t *ref_frame_buf,
5974 int stride, BLOCK_SIZE bsize,
5976 MACROBLOCK *const x = &td->mb;
5977 MACROBLOCKD *const xd = &x->e_mbd;
5978 MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
5979 const SEARCH_METHODS search_method = NSTEP;
5981 int sadpb = x->sadperbit16;
5982 uint32_t bestsme = UINT_MAX;
5983 uint32_t distortion;
5986 const MvLimits tmp_mv_limits = x->mv_limits;
5988 MV best_ref_mv1 = { 0, 0 };
5989 MV best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */
5991 best_ref_mv1_full.col = best_ref_mv1.col >> 3;
5992 best_ref_mv1_full.row = best_ref_mv1.row >> 3;
5994 // Setup frame pointers
5995 x->plane[0].src.buf = cur_frame_buf;
5996 x->plane[0].src.stride = stride;
5997 xd->plane[0].pre[0].buf = ref_frame_buf;
5998 xd->plane[0].pre[0].stride = stride;
6000 step_param = mv_sf->reduce_first_step_size;
6001 step_param = VPXMIN(step_param, MAX_MVSEARCH_STEPS - 2);
6003 vp9_set_mv_search_range(&x->mv_limits, &best_ref_mv1);
6005 vp9_full_pixel_search(cpi, x, bsize, &best_ref_mv1_full, step_param,
6006 search_method, sadpb, cond_cost_list(cpi, cost_list),
6007 &best_ref_mv1, mv, 0, 0);
6009 /* restore UMV window */
6010 x->mv_limits = tmp_mv_limits;
6012 // TODO(yunqing): may use higher tap interp filter than 2 taps.
6013 // Ignore mv costing by sending NULL pointer instead of cost array
6014 bestsme = cpi->find_fractional_mv_step(
6015 x, mv, &best_ref_mv1, cpi->common.allow_high_precision_mv, x->errorperbit,
6016 &cpi->fn_ptr[bsize], 0, mv_sf->subpel_search_level,
6017 cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL, 0, 0,
6024 static int get_overlap_area(int grid_pos_row, int grid_pos_col, int ref_pos_row,
6025 int ref_pos_col, int block, BLOCK_SIZE bsize) {
6026 int width = 0, height = 0;
6027 int bw = 4 << b_width_log2_lookup[bsize];
6028 int bh = 4 << b_height_log2_lookup[bsize];
6032 width = grid_pos_col + bw - ref_pos_col;
6033 height = grid_pos_row + bh - ref_pos_row;
6036 width = ref_pos_col + bw - grid_pos_col;
6037 height = grid_pos_row + bh - ref_pos_row;
6040 width = grid_pos_col + bw - ref_pos_col;
6041 height = ref_pos_row + bh - grid_pos_row;
6044 width = ref_pos_col + bw - grid_pos_col;
6045 height = ref_pos_row + bh - grid_pos_row;
6050 return width * height;
6053 static int round_floor(int ref_pos, int bsize_pix) {
6056 round = -(1 + (-ref_pos - 1) / bsize_pix);
6058 round = ref_pos / bsize_pix;
6063 static void tpl_model_store(TplDepStats *tpl_stats, int mi_row, int mi_col,
6064 BLOCK_SIZE bsize, int stride) {
6065 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6066 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6067 const TplDepStats *src_stats = &tpl_stats[mi_row * stride + mi_col];
6070 for (idy = 0; idy < mi_height; ++idy) {
6071 for (idx = 0; idx < mi_width; ++idx) {
6072 TplDepStats *tpl_ptr = &tpl_stats[(mi_row + idy) * stride + mi_col + idx];
6073 const int64_t mc_flow = tpl_ptr->mc_flow;
6074 const int64_t mc_ref_cost = tpl_ptr->mc_ref_cost;
6075 *tpl_ptr = *src_stats;
6076 tpl_ptr->mc_flow = mc_flow;
6077 tpl_ptr->mc_ref_cost = mc_ref_cost;
6078 tpl_ptr->mc_dep_cost = tpl_ptr->intra_cost + tpl_ptr->mc_flow;
6083 static void tpl_model_update_b(TplDepFrame *tpl_frame, TplDepStats *tpl_stats,
6084 int mi_row, int mi_col, const BLOCK_SIZE bsize) {
6085 TplDepFrame *ref_tpl_frame = &tpl_frame[tpl_stats->ref_frame_index];
6086 TplDepStats *ref_stats = ref_tpl_frame->tpl_stats_ptr;
6087 MV mv = tpl_stats->mv.as_mv;
6088 int mv_row = mv.row >> 3;
6089 int mv_col = mv.col >> 3;
6091 int ref_pos_row = mi_row * MI_SIZE + mv_row;
6092 int ref_pos_col = mi_col * MI_SIZE + mv_col;
6094 const int bw = 4 << b_width_log2_lookup[bsize];
6095 const int bh = 4 << b_height_log2_lookup[bsize];
6096 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6097 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6098 const int pix_num = bw * bh;
6100 // top-left on grid block location in pixel
6101 int grid_pos_row_base = round_floor(ref_pos_row, bh) * bh;
6102 int grid_pos_col_base = round_floor(ref_pos_col, bw) * bw;
6105 for (block = 0; block < 4; ++block) {
6106 int grid_pos_row = grid_pos_row_base + bh * (block >> 1);
6107 int grid_pos_col = grid_pos_col_base + bw * (block & 0x01);
6109 if (grid_pos_row >= 0 && grid_pos_row < ref_tpl_frame->mi_rows * MI_SIZE &&
6110 grid_pos_col >= 0 && grid_pos_col < ref_tpl_frame->mi_cols * MI_SIZE) {
6111 int overlap_area = get_overlap_area(
6112 grid_pos_row, grid_pos_col, ref_pos_row, ref_pos_col, block, bsize);
6113 int ref_mi_row = round_floor(grid_pos_row, bh) * mi_height;
6114 int ref_mi_col = round_floor(grid_pos_col, bw) * mi_width;
6116 int64_t mc_flow = tpl_stats->mc_dep_cost -
6117 (tpl_stats->mc_dep_cost * tpl_stats->inter_cost) /
6118 tpl_stats->intra_cost;
6122 for (idy = 0; idy < mi_height; ++idy) {
6123 for (idx = 0; idx < mi_width; ++idx) {
6124 TplDepStats *des_stats =
6125 &ref_stats[(ref_mi_row + idy) * ref_tpl_frame->stride +
6126 (ref_mi_col + idx)];
6128 des_stats->mc_flow += (mc_flow * overlap_area) / pix_num;
6129 des_stats->mc_ref_cost +=
6130 ((tpl_stats->intra_cost - tpl_stats->inter_cost) * overlap_area) /
6132 assert(overlap_area >= 0);
6139 static void tpl_model_update(TplDepFrame *tpl_frame, TplDepStats *tpl_stats,
6140 int mi_row, int mi_col, const BLOCK_SIZE bsize) {
6142 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6143 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6145 for (idy = 0; idy < mi_height; ++idy) {
6146 for (idx = 0; idx < mi_width; ++idx) {
6147 TplDepStats *tpl_ptr =
6148 &tpl_stats[(mi_row + idy) * tpl_frame->stride + (mi_col + idx)];
6149 tpl_model_update_b(tpl_frame, tpl_ptr, mi_row + idy, mi_col + idx,
6155 static void get_quantize_error(MACROBLOCK *x, int plane, tran_low_t *coeff,
6156 tran_low_t *qcoeff, tran_low_t *dqcoeff,
6157 TX_SIZE tx_size, int64_t *recon_error,
6159 MACROBLOCKD *const xd = &x->e_mbd;
6160 const struct macroblock_plane *const p = &x->plane[plane];
6161 const struct macroblockd_plane *const pd = &xd->plane[plane];
6162 const scan_order *const scan_order = &vp9_default_scan_orders[tx_size];
6164 int pix_num = 1 << num_pels_log2_lookup[txsize_to_bsize[tx_size]];
6165 const int shift = tx_size == TX_32X32 ? 0 : 2;
6167 #if CONFIG_VP9_HIGHBITDEPTH
6168 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6169 vp9_highbd_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp,
6170 p->quant_fp, qcoeff, dqcoeff, pd->dequant,
6171 &eob, scan_order->scan, scan_order->iscan);
6173 vp9_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp,
6174 p->quant_fp, qcoeff, dqcoeff, pd->dequant, &eob,
6175 scan_order->scan, scan_order->iscan);
6178 vp9_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp, p->quant_fp,
6179 qcoeff, dqcoeff, pd->dequant, &eob, scan_order->scan,
6181 #endif // CONFIG_VP9_HIGHBITDEPTH
6183 *recon_error = vp9_block_error(coeff, dqcoeff, pix_num, sse) >> shift;
6184 *recon_error = VPXMAX(*recon_error, 1);
6186 *sse = (*sse) >> shift;
6187 *sse = VPXMAX(*sse, 1);
6190 #if CONFIG_VP9_HIGHBITDEPTH
6191 void highbd_wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
6193 // TODO(sdeng): Implement SIMD based high bit-depth Hadamard transforms.
6195 case TX_8X8: vpx_highbd_hadamard_8x8(src_diff, bw, coeff); break;
6196 case TX_16X16: vpx_highbd_hadamard_16x16(src_diff, bw, coeff); break;
6197 case TX_32X32: vpx_highbd_hadamard_32x32(src_diff, bw, coeff); break;
6201 #endif // CONFIG_VP9_HIGHBITDEPTH
6203 void wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
6206 case TX_8X8: vpx_hadamard_8x8(src_diff, bw, coeff); break;
6207 case TX_16X16: vpx_hadamard_16x16(src_diff, bw, coeff); break;
6208 case TX_32X32: vpx_hadamard_32x32(src_diff, bw, coeff); break;
6213 static void set_mv_limits(const VP9_COMMON *cm, MACROBLOCK *x, int mi_row,
6215 x->mv_limits.row_min = -((mi_row * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND));
6216 x->mv_limits.row_max =
6217 (cm->mi_rows - 1 - mi_row) * MI_SIZE + (17 - 2 * VP9_INTERP_EXTEND);
6218 x->mv_limits.col_min = -((mi_col * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND));
6219 x->mv_limits.col_max =
6220 ((cm->mi_cols - 1 - mi_col) * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND);
6223 static void mode_estimation(VP9_COMP *cpi, MACROBLOCK *x, MACROBLOCKD *xd,
6224 struct scale_factors *sf, GF_PICTURE *gf_picture,
6225 int frame_idx, TplDepFrame *tpl_frame,
6226 int16_t *src_diff, tran_low_t *coeff,
6227 tran_low_t *qcoeff, tran_low_t *dqcoeff, int mi_row,
6228 int mi_col, BLOCK_SIZE bsize, TX_SIZE tx_size,
6229 YV12_BUFFER_CONFIG *ref_frame[], uint8_t *predictor,
6230 int64_t *recon_error, int64_t *sse) {
6231 VP9_COMMON *cm = &cpi->common;
6232 ThreadData *td = &cpi->td;
6234 const int bw = 4 << b_width_log2_lookup[bsize];
6235 const int bh = 4 << b_height_log2_lookup[bsize];
6236 const int pix_num = bw * bh;
6237 int best_rf_idx = -1;
6239 int64_t best_inter_cost = INT64_MAX;
6242 const InterpKernel *const kernel = vp9_filter_kernels[EIGHTTAP];
6244 int64_t best_intra_cost = INT64_MAX;
6246 PREDICTION_MODE mode;
6247 int mb_y_offset = mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6248 MODE_INFO mi_above, mi_left;
6249 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6250 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6251 TplDepStats *tpl_stats =
6252 &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
6254 xd->mb_to_top_edge = -((mi_row * MI_SIZE) * 8);
6255 xd->mb_to_bottom_edge = ((cm->mi_rows - 1 - mi_row) * MI_SIZE) * 8;
6256 xd->mb_to_left_edge = -((mi_col * MI_SIZE) * 8);
6257 xd->mb_to_right_edge = ((cm->mi_cols - 1 - mi_col) * MI_SIZE) * 8;
6258 xd->above_mi = (mi_row > 0) ? &mi_above : NULL;
6259 xd->left_mi = (mi_col > 0) ? &mi_left : NULL;
6261 // Intra prediction search
6262 for (mode = DC_PRED; mode <= TM_PRED; ++mode) {
6264 int src_stride, dst_stride;
6266 src = xd->cur_buf->y_buffer + mb_y_offset;
6267 src_stride = xd->cur_buf->y_stride;
6269 dst = &predictor[0];
6272 xd->mi[0]->sb_type = bsize;
6273 xd->mi[0]->ref_frame[0] = INTRA_FRAME;
6275 vp9_predict_intra_block(xd, b_width_log2_lookup[bsize], tx_size, mode, src,
6276 src_stride, dst, dst_stride, 0, 0, 0);
6278 #if CONFIG_VP9_HIGHBITDEPTH
6279 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6280 vpx_highbd_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst,
6281 dst_stride, xd->bd);
6282 highbd_wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6283 intra_cost = vpx_highbd_satd(coeff, pix_num);
6285 vpx_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst,
6287 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6288 intra_cost = vpx_satd(coeff, pix_num);
6291 vpx_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst, dst_stride);
6292 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6293 intra_cost = vpx_satd(coeff, pix_num);
6294 #endif // CONFIG_VP9_HIGHBITDEPTH
6296 if (intra_cost < best_intra_cost) best_intra_cost = intra_cost;
6299 // Motion compensated prediction
6302 set_mv_limits(cm, x, mi_row, mi_col);
6304 for (rf_idx = 0; rf_idx < 3; ++rf_idx) {
6306 if (ref_frame[rf_idx] == NULL) continue;
6308 #if CONFIG_NON_GREEDY_MV
6311 get_pyramid_mv(tpl_frame, rf_idx, bsize, mi_row, mi_col)->as_int;
6313 motion_compensated_prediction(cpi, td, xd->cur_buf->y_buffer + mb_y_offset,
6314 ref_frame[rf_idx]->y_buffer + mb_y_offset,
6315 xd->cur_buf->y_stride, bsize, &mv.as_mv);
6318 #if CONFIG_VP9_HIGHBITDEPTH
6319 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6320 vp9_highbd_build_inter_predictor(
6321 CONVERT_TO_SHORTPTR(ref_frame[rf_idx]->y_buffer + mb_y_offset),
6322 ref_frame[rf_idx]->y_stride, CONVERT_TO_SHORTPTR(&predictor[0]), bw,
6323 &mv.as_mv, sf, bw, bh, 0, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE,
6324 mi_row * MI_SIZE, xd->bd);
6325 vpx_highbd_subtract_block(
6326 bh, bw, src_diff, bw, xd->cur_buf->y_buffer + mb_y_offset,
6327 xd->cur_buf->y_stride, &predictor[0], bw, xd->bd);
6328 highbd_wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6329 inter_cost = vpx_highbd_satd(coeff, pix_num);
6331 vp9_build_inter_predictor(
6332 ref_frame[rf_idx]->y_buffer + mb_y_offset,
6333 ref_frame[rf_idx]->y_stride, &predictor[0], bw, &mv.as_mv, sf, bw, bh,
6334 0, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE, mi_row * MI_SIZE);
6335 vpx_subtract_block(bh, bw, src_diff, bw,
6336 xd->cur_buf->y_buffer + mb_y_offset,
6337 xd->cur_buf->y_stride, &predictor[0], bw);
6338 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6339 inter_cost = vpx_satd(coeff, pix_num);
6342 vp9_build_inter_predictor(ref_frame[rf_idx]->y_buffer + mb_y_offset,
6343 ref_frame[rf_idx]->y_stride, &predictor[0], bw,
6344 &mv.as_mv, sf, bw, bh, 0, kernel, MV_PRECISION_Q3,
6345 mi_col * MI_SIZE, mi_row * MI_SIZE);
6346 vpx_subtract_block(bh, bw, src_diff, bw,
6347 xd->cur_buf->y_buffer + mb_y_offset,
6348 xd->cur_buf->y_stride, &predictor[0], bw);
6349 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6350 inter_cost = vpx_satd(coeff, pix_num);
6353 if (inter_cost < best_inter_cost) {
6354 best_rf_idx = rf_idx;
6355 best_inter_cost = inter_cost;
6356 best_mv.as_int = mv.as_int;
6357 get_quantize_error(x, 0, coeff, qcoeff, dqcoeff, tx_size, recon_error,
6361 best_intra_cost = VPXMAX(best_intra_cost, 1);
6362 best_inter_cost = VPXMIN(best_intra_cost, best_inter_cost);
6363 tpl_stats->inter_cost = VPXMAX(
6364 1, (best_inter_cost << TPL_DEP_COST_SCALE_LOG2) / (mi_height * mi_width));
6365 tpl_stats->intra_cost = VPXMAX(
6366 1, (best_intra_cost << TPL_DEP_COST_SCALE_LOG2) / (mi_height * mi_width));
6367 tpl_stats->ref_frame_index = gf_picture[frame_idx].ref_frame[best_rf_idx];
6368 tpl_stats->mv.as_int = best_mv.as_int;
6371 #if CONFIG_NON_GREEDY_MV
6372 static int get_block_src_pred_buf(MACROBLOCKD *xd, GF_PICTURE *gf_picture,
6373 int frame_idx, int rf_idx, int mi_row,
6374 int mi_col, struct buf_2d *src,
6375 struct buf_2d *pre) {
6376 const int mb_y_offset =
6377 mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6378 YV12_BUFFER_CONFIG *ref_frame = NULL;
6379 int ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
6380 if (ref_frame_idx != -1) {
6381 ref_frame = gf_picture[ref_frame_idx].frame;
6382 src->buf = xd->cur_buf->y_buffer + mb_y_offset;
6383 src->stride = xd->cur_buf->y_stride;
6384 pre->buf = ref_frame->y_buffer + mb_y_offset;
6385 pre->stride = ref_frame->y_stride;
6386 assert(src->stride == pre->stride);
6389 printf("invalid ref_frame_idx");
6390 assert(ref_frame_idx != -1);
6395 #define kMvPreCheckLines 5
6396 #define kMvPreCheckSize 15
6398 #define MV_REF_POS_NUM 3
6399 POSITION mv_ref_pos[MV_REF_POS_NUM] = {
6405 static int_mv *get_select_mv(VP9_COMP *cpi, TplDepFrame *tpl_frame, int mi_row,
6407 return &cpi->select_mv_arr[mi_row * tpl_frame->stride + mi_col];
6410 static int_mv find_ref_mv(int mv_mode, VP9_COMP *cpi, TplDepFrame *tpl_frame,
6411 BLOCK_SIZE bsize, int mi_row, int mi_col) {
6413 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6414 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6415 int_mv nearest_mv, near_mv, invalid_mv;
6416 nearest_mv.as_int = INVALID_MV;
6417 near_mv.as_int = INVALID_MV;
6418 invalid_mv.as_int = INVALID_MV;
6419 for (i = 0; i < MV_REF_POS_NUM; ++i) {
6420 int nb_row = mi_row + mv_ref_pos[i].row * mi_height;
6421 int nb_col = mi_col + mv_ref_pos[i].col * mi_width;
6422 assert(mv_ref_pos[i].row <= 0);
6423 assert(mv_ref_pos[i].col <= 0);
6424 if (nb_row >= 0 && nb_col >= 0) {
6425 if (nearest_mv.as_int == INVALID_MV) {
6426 nearest_mv = *get_select_mv(cpi, tpl_frame, nb_row, nb_col);
6428 int_mv mv = *get_select_mv(cpi, tpl_frame, nb_row, nb_col);
6429 if (mv.as_int == nearest_mv.as_int) {
6438 if (nearest_mv.as_int == INVALID_MV) {
6439 nearest_mv.as_mv.row = 0;
6440 nearest_mv.as_mv.col = 0;
6442 if (near_mv.as_int == INVALID_MV) {
6443 near_mv.as_mv.row = 0;
6444 near_mv.as_mv.col = 0;
6446 if (mv_mode == NEAREST_MV_MODE) {
6449 if (mv_mode == NEAR_MV_MODE) {
6456 static int_mv get_mv_from_mv_mode(int mv_mode, VP9_COMP *cpi,
6457 TplDepFrame *tpl_frame, int rf_idx,
6458 BLOCK_SIZE bsize, int mi_row, int mi_col) {
6466 mv = *get_pyramid_mv(tpl_frame, rf_idx, bsize, mi_row, mi_col);
6468 case NEAREST_MV_MODE:
6469 mv = find_ref_mv(mv_mode, cpi, tpl_frame, bsize, mi_row, mi_col);
6472 mv = find_ref_mv(mv_mode, cpi, tpl_frame, bsize, mi_row, mi_col);
6475 mv.as_int = INVALID_MV;
6482 static double get_mv_dist(int mv_mode, VP9_COMP *cpi, MACROBLOCKD *xd,
6483 GF_PICTURE *gf_picture, int frame_idx,
6484 TplDepFrame *tpl_frame, int rf_idx, BLOCK_SIZE bsize,
6485 int mi_row, int mi_col, int_mv *mv) {
6490 *mv = get_mv_from_mv_mode(mv_mode, cpi, tpl_frame, rf_idx, bsize, mi_row,
6492 full_mv = get_full_mv(&mv->as_mv);
6493 if (get_block_src_pred_buf(xd, gf_picture, frame_idx, rf_idx, mi_row, mi_col,
6495 // TODO(angiebird): Consider subpixel when computing the sse.
6496 cpi->fn_ptr[bsize].vf(src.buf, src.stride, get_buf_from_mv(&pre, &full_mv),
6498 return (double)(sse << VP9_DIST_SCALE_LOG2);
6505 static int get_mv_mode_cost(int mv_mode) {
6506 // TODO(angiebird): The probabilities are roughly inferred from
6507 // default_inter_mode_probs. Check if there is a better way to set the
6509 const int zero_mv_prob = 16;
6510 const int new_mv_prob = 24 * 1;
6511 const int ref_mv_prob = 256 - zero_mv_prob - new_mv_prob;
6512 assert(zero_mv_prob + new_mv_prob + ref_mv_prob == 256);
6514 case ZERO_MV_MODE: return vp9_prob_cost[zero_mv_prob]; break;
6515 case NEW_MV_MODE: return vp9_prob_cost[new_mv_prob]; break;
6516 case NEAREST_MV_MODE: return vp9_prob_cost[ref_mv_prob]; break;
6517 case NEAR_MV_MODE: return vp9_prob_cost[ref_mv_prob]; break;
6518 default: assert(0); return -1;
6522 static INLINE double get_mv_diff_cost(MV *new_mv, MV *ref_mv) {
6523 double mv_diff_cost = log2(1 + abs(new_mv->row - ref_mv->row)) +
6524 log2(1 + abs(new_mv->col - ref_mv->col));
6525 mv_diff_cost *= (1 << VP9_PROB_COST_SHIFT);
6526 return mv_diff_cost;
6528 static double get_mv_cost(int mv_mode, VP9_COMP *cpi, TplDepFrame *tpl_frame,
6529 int rf_idx, BLOCK_SIZE bsize, int mi_row,
6531 double mv_cost = get_mv_mode_cost(mv_mode);
6532 if (mv_mode == NEW_MV_MODE) {
6533 MV new_mv = get_mv_from_mv_mode(mv_mode, cpi, tpl_frame, rf_idx, bsize,
6536 MV nearest_mv = get_mv_from_mv_mode(NEAREST_MV_MODE, cpi, tpl_frame, rf_idx,
6537 bsize, mi_row, mi_col)
6539 MV near_mv = get_mv_from_mv_mode(NEAR_MV_MODE, cpi, tpl_frame, rf_idx,
6540 bsize, mi_row, mi_col)
6542 double nearest_cost = get_mv_diff_cost(&new_mv, &nearest_mv);
6543 double near_cost = get_mv_diff_cost(&new_mv, &near_mv);
6544 mv_cost += nearest_cost < near_cost ? nearest_cost : near_cost;
6549 static double eval_mv_mode(int mv_mode, VP9_COMP *cpi, MACROBLOCK *x,
6550 GF_PICTURE *gf_picture, int frame_idx,
6551 TplDepFrame *tpl_frame, int rf_idx, BLOCK_SIZE bsize,
6552 int mi_row, int mi_col, int_mv *mv) {
6553 MACROBLOCKD *xd = &x->e_mbd;
6554 double mv_dist = get_mv_dist(mv_mode, cpi, xd, gf_picture, frame_idx,
6555 tpl_frame, rf_idx, bsize, mi_row, mi_col, mv);
6557 get_mv_cost(mv_mode, cpi, tpl_frame, rf_idx, bsize, mi_row, mi_col);
6560 return mv_cost + mult * log2f(1 + mv_dist);
6563 static int find_best_ref_mv_mode(VP9_COMP *cpi, MACROBLOCK *x,
6564 GF_PICTURE *gf_picture, int frame_idx,
6565 TplDepFrame *tpl_frame, int rf_idx,
6566 BLOCK_SIZE bsize, int mi_row, int mi_col,
6567 double *rd, int_mv *mv) {
6568 int best_mv_mode = ZERO_MV_MODE;
6572 for (mv_mode = 0; mv_mode < MAX_MV_MODE; ++mv_mode) {
6575 if (mv_mode == NEW_MV_MODE) {
6578 this_rd = eval_mv_mode(mv_mode, cpi, x, gf_picture, frame_idx, tpl_frame,
6579 rf_idx, bsize, mi_row, mi_col, &this_mv);
6583 best_mv_mode = mv_mode;
6586 if (this_rd < *rd) {
6589 best_mv_mode = mv_mode;
6593 return best_mv_mode;
6596 static void predict_mv_mode(VP9_COMP *cpi, MACROBLOCK *x,
6597 GF_PICTURE *gf_picture, int frame_idx,
6598 TplDepFrame *tpl_frame, int rf_idx,
6599 BLOCK_SIZE bsize, int mi_row, int mi_col) {
6600 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6601 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6602 int tmp_mv_mode_arr[kMvPreCheckSize];
6603 int *mv_mode_arr = tpl_frame->mv_mode_arr[rf_idx];
6604 double *rd_diff_arr = tpl_frame->rd_diff_arr[rf_idx];
6605 int_mv *select_mv_arr = cpi->select_mv_arr;
6606 int_mv tmp_select_mv_arr[kMvPreCheckSize];
6607 int stride = tpl_frame->stride;
6608 double new_mv_rd = 0;
6609 double no_new_mv_rd = 0;
6610 double this_new_mv_rd = 0;
6611 double this_no_new_mv_rd = 0;
6614 assert(kMvPreCheckSize == (kMvPreCheckLines * (kMvPreCheckLines + 1)) >> 1);
6617 // diagnal scan order
6619 for (idx = 0; idx < kMvPreCheckLines; ++idx) {
6621 for (r = 0; r <= idx; ++r) {
6623 int nb_row = mi_row + r * mi_height;
6624 int nb_col = mi_col + c * mi_width;
6625 if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6627 int_mv *mv = &select_mv_arr[nb_row * stride + nb_col];
6628 mv_mode_arr[nb_row * stride + nb_col] =
6629 find_best_ref_mv_mode(cpi, x, gf_picture, frame_idx, tpl_frame,
6630 rf_idx, bsize, nb_row, nb_col, &this_rd, mv);
6631 if (r == 0 && c == 0) {
6632 this_no_new_mv_rd = this_rd;
6634 no_new_mv_rd += this_rd;
6635 tmp_mv_mode_arr[tmp_idx] = mv_mode_arr[nb_row * stride + nb_col];
6636 tmp_select_mv_arr[tmp_idx] = select_mv_arr[nb_row * stride + nb_col];
6643 mv_mode_arr[mi_row * stride + mi_col] = NEW_MV_MODE;
6644 this_new_mv_rd = eval_mv_mode(NEW_MV_MODE, cpi, x, gf_picture, frame_idx,
6645 tpl_frame, rf_idx, bsize, mi_row, mi_col,
6646 &select_mv_arr[mi_row * stride + mi_col]);
6647 new_mv_rd = this_new_mv_rd;
6648 // We start from idx = 1 because idx = 0 is evaluated as NEW_MV_MODE
6650 for (idx = 1; idx < kMvPreCheckLines; ++idx) {
6652 for (r = 0; r <= idx; ++r) {
6654 int nb_row = mi_row + r * mi_height;
6655 int nb_col = mi_col + c * mi_width;
6656 if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6658 int_mv *mv = &select_mv_arr[nb_row * stride + nb_col];
6659 mv_mode_arr[nb_row * stride + nb_col] =
6660 find_best_ref_mv_mode(cpi, x, gf_picture, frame_idx, tpl_frame,
6661 rf_idx, bsize, nb_row, nb_col, &this_rd, mv);
6662 new_mv_rd += this_rd;
6667 // update best_mv_mode
6669 if (no_new_mv_rd < new_mv_rd) {
6670 for (idx = 0; idx < kMvPreCheckLines; ++idx) {
6672 for (r = 0; r <= idx; ++r) {
6674 int nb_row = mi_row + r * mi_height;
6675 int nb_col = mi_col + c * mi_width;
6676 if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6677 mv_mode_arr[nb_row * stride + nb_col] = tmp_mv_mode_arr[tmp_idx];
6678 select_mv_arr[nb_row * stride + nb_col] = tmp_select_mv_arr[tmp_idx];
6683 rd_diff_arr[mi_row * stride + mi_col] = 0;
6685 rd_diff_arr[mi_row * stride + mi_col] =
6686 (no_new_mv_rd - this_no_new_mv_rd) - (new_mv_rd - this_new_mv_rd);
6690 static void predict_mv_mode_arr(VP9_COMP *cpi, MACROBLOCK *x,
6691 GF_PICTURE *gf_picture, int frame_idx,
6692 TplDepFrame *tpl_frame, int rf_idx,
6694 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6695 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6696 const int unit_rows = tpl_frame->mi_rows / mi_height;
6697 const int unit_cols = tpl_frame->mi_cols / mi_width;
6698 const int max_diagonal_lines = unit_rows + unit_cols - 1;
6700 for (idx = 0; idx < max_diagonal_lines; ++idx) {
6702 for (r = VPXMAX(idx - unit_cols + 1, 0); r <= VPXMIN(idx, unit_rows - 1);
6705 int mi_row = r * mi_height;
6706 int mi_col = c * mi_width;
6707 assert(c >= 0 && c < unit_cols);
6708 assert(mi_row >= 0 && mi_row < tpl_frame->mi_rows);
6709 assert(mi_col >= 0 && mi_col < tpl_frame->mi_cols);
6710 predict_mv_mode(cpi, x, gf_picture, frame_idx, tpl_frame, rf_idx, bsize,
6716 static double get_feature_score(uint8_t *buf, ptrdiff_t stride, int rows,
6723 vpx_clear_system_state();
6724 for (r = 0; r + 1 < rows; ++r) {
6725 for (c = 0; c + 1 < cols; ++c) {
6726 int diff_x = buf[r * stride + c] - buf[r * stride + c + 1];
6727 int diff_y = buf[r * stride + c] - buf[(r + 1) * stride + c];
6728 IxIx += diff_x * diff_x;
6729 IxIy += diff_x * diff_y;
6730 IyIy += diff_y * diff_y;
6733 IxIx /= (rows - 1) * (cols - 1);
6734 IxIy /= (rows - 1) * (cols - 1);
6735 IyIy /= (rows - 1) * (cols - 1);
6736 score = (IxIx * IyIy - IxIy * IxIy + 0.0001) / (IxIx + IyIy + 0.0001);
6740 static int compare_feature_score(const void *a, const void *b) {
6741 const FEATURE_SCORE_LOC *aa = *(FEATURE_SCORE_LOC *const *)a;
6742 const FEATURE_SCORE_LOC *bb = *(FEATURE_SCORE_LOC *const *)b;
6743 if (aa->feature_score < bb->feature_score) {
6745 } else if (aa->feature_score > bb->feature_score) {
6752 static void do_motion_search(VP9_COMP *cpi, ThreadData *td, int frame_idx,
6753 YV12_BUFFER_CONFIG *ref_frame, BLOCK_SIZE bsize,
6754 int mi_row, int mi_col, int rf_idx) {
6755 VP9_COMMON *cm = &cpi->common;
6756 MACROBLOCK *x = &td->mb;
6757 MACROBLOCKD *xd = &x->e_mbd;
6758 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6759 TplDepStats *tpl_stats =
6760 &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
6761 const int mb_y_offset =
6762 mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6763 assert(ref_frame != NULL);
6764 set_mv_limits(cm, x, mi_row, mi_col);
6765 tpl_stats->ready[rf_idx] = 1;
6767 int_mv *mv = get_pyramid_mv(tpl_frame, rf_idx, bsize, mi_row, mi_col);
6768 uint8_t *cur_frame_buf = xd->cur_buf->y_buffer + mb_y_offset;
6769 uint8_t *ref_frame_buf = ref_frame->y_buffer + mb_y_offset;
6770 const int stride = xd->cur_buf->y_stride;
6771 full_pixel_motion_search(cpi, td, frame_idx, cur_frame_buf, ref_frame_buf,
6772 stride, bsize, mi_row, mi_col, &mv->as_mv, rf_idx);
6773 sub_pixel_motion_search(cpi, td, cur_frame_buf, ref_frame_buf, stride,
6778 #define CHANGE_MV_SEARCH_ORDER 1
6779 #define USE_PQSORT 1
6781 #if CHANGE_MV_SEARCH_ORDER
6783 static void max_heap_pop(FEATURE_SCORE_LOC **heap, int *size,
6784 FEATURE_SCORE_LOC **output) {
6790 heap[0] = heap[*size];
6795 FEATURE_SCORE_LOC *tmp;
6797 if (r < *size && heap[r]->feature_score > heap[l]->feature_score) {
6800 if (heap[p]->feature_score >= heap[c]->feature_score) {
6816 static void max_heap_push(FEATURE_SCORE_LOC **heap, int *size,
6817 FEATURE_SCORE_LOC *input) {
6819 FEATURE_SCORE_LOC *tmp;
6821 heap[*size] = input;
6825 while (c > 0 && heap[c]->feature_score > heap[p]->feature_score) {
6834 static void add_nb_blocks_to_heap(VP9_COMP *cpi, const TplDepFrame *tpl_frame,
6835 BLOCK_SIZE bsize, int mi_row, int mi_col,
6837 const int mi_unit = num_8x8_blocks_wide_lookup[bsize];
6838 const int dirs[NB_MVS_NUM][2] = { { -1, 0 }, { 0, -1 }, { 1, 0 }, { 0, 1 } };
6840 for (i = 0; i < NB_MVS_NUM; ++i) {
6841 int r = dirs[i][0] * mi_unit;
6842 int c = dirs[i][1] * mi_unit;
6843 if (mi_row + r >= 0 && mi_row + r < tpl_frame->mi_rows && mi_col + c >= 0 &&
6844 mi_col + c < tpl_frame->mi_cols) {
6845 FEATURE_SCORE_LOC *fs_loc =
6846 &cpi->feature_score_loc_arr[(mi_row + r) * tpl_frame->stride +
6848 if (fs_loc->visited == 0) {
6849 max_heap_push(cpi->feature_score_loc_heap, heap_size, fs_loc);
6854 #endif // USE_PQSORT
6855 #endif // CHANGE_MV_SEARCH_ORDER
6857 static void build_motion_field(VP9_COMP *cpi, MACROBLOCKD *xd, int frame_idx,
6858 YV12_BUFFER_CONFIG *ref_frame[3],
6860 VP9_COMMON *cm = &cpi->common;
6861 ThreadData *td = &cpi->td;
6862 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6863 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6864 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6865 const int pw = num_4x4_blocks_wide_lookup[bsize] << 2;
6866 const int ph = num_4x4_blocks_high_lookup[bsize] << 2;
6867 int fs_loc_sort_size;
6868 int fs_loc_heap_size;
6872 tpl_frame->lambda = (pw * ph) >> 2;
6873 assert(pw * ph == tpl_frame->lambda << 2);
6875 fs_loc_sort_size = 0;
6876 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6877 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6878 const int mb_y_offset =
6879 mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6880 const int bw = 4 << b_width_log2_lookup[bsize];
6881 const int bh = 4 << b_height_log2_lookup[bsize];
6882 TplDepStats *tpl_stats =
6883 &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
6884 FEATURE_SCORE_LOC *fs_loc =
6885 &cpi->feature_score_loc_arr[mi_row * tpl_frame->stride + mi_col];
6886 tpl_stats->feature_score = get_feature_score(
6887 xd->cur_buf->y_buffer + mb_y_offset, xd->cur_buf->y_stride, bw, bh);
6888 fs_loc->visited = 0;
6889 fs_loc->feature_score = tpl_stats->feature_score;
6890 fs_loc->mi_row = mi_row;
6891 fs_loc->mi_col = mi_col;
6892 cpi->feature_score_loc_sort[fs_loc_sort_size] = fs_loc;
6897 qsort(cpi->feature_score_loc_sort, fs_loc_sort_size,
6898 sizeof(*cpi->feature_score_loc_sort), compare_feature_score);
6900 for (rf_idx = 0; rf_idx < 3; ++rf_idx) {
6901 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6902 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6903 TplDepStats *tpl_stats =
6904 &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
6905 tpl_stats->ready[rf_idx] = 0;
6910 // TODO(angiebird): Clean up this part.
6911 for (rf_idx = 0; rf_idx < 3; ++rf_idx) {
6913 if (ref_frame[rf_idx] == NULL) {
6916 #if CHANGE_MV_SEARCH_ORDER
6918 for (i = 0; i < fs_loc_sort_size; ++i) {
6919 FEATURE_SCORE_LOC *fs_loc = cpi->feature_score_loc_sort[i];
6920 do_motion_search(cpi, td, frame_idx, ref_frame[rf_idx], bsize,
6921 fs_loc->mi_row, fs_loc->mi_col, rf_idx);
6923 #else // !USE_PQSORT
6924 fs_loc_heap_size = 0;
6925 max_heap_push(cpi->feature_score_loc_heap, &fs_loc_heap_size,
6926 cpi->feature_score_loc_sort[0]);
6928 for (i = 0; i < fs_loc_sort_size; ++i) {
6929 cpi->feature_score_loc_sort[i]->visited = 0;
6932 while (fs_loc_heap_size > 0) {
6933 FEATURE_SCORE_LOC *fs_loc;
6934 max_heap_pop(cpi->feature_score_loc_heap, &fs_loc_heap_size, &fs_loc);
6936 do_motion_search(cpi, td, frame_idx, ref_frame[rf_idx], bsize,
6937 fs_loc->mi_row, fs_loc->mi_col, rf_idx);
6939 add_nb_blocks_to_heap(cpi, tpl_frame, bsize, fs_loc->mi_row,
6940 fs_loc->mi_col, &fs_loc_heap_size);
6942 #endif // !USE_PQSORT
6943 #else // CHANGE_MV_SEARCH_ORDER
6944 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6945 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6946 do_motion_search(cpi, td, frame_idx, ref_frame[rf_idx], bsize, mi_row,
6950 #endif // CHANGE_MV_SEARCH_ORDER
6953 #endif // CONFIG_NON_GREEDY_MV
6955 static void mc_flow_dispenser(VP9_COMP *cpi, GF_PICTURE *gf_picture,
6956 int frame_idx, BLOCK_SIZE bsize) {
6957 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6958 YV12_BUFFER_CONFIG *this_frame = gf_picture[frame_idx].frame;
6959 YV12_BUFFER_CONFIG *ref_frame[3] = { NULL, NULL, NULL };
6961 VP9_COMMON *cm = &cpi->common;
6962 struct scale_factors sf;
6964 ThreadData *td = &cpi->td;
6965 MACROBLOCK *x = &td->mb;
6966 MACROBLOCKD *xd = &x->e_mbd;
6969 #if CONFIG_VP9_HIGHBITDEPTH
6970 DECLARE_ALIGNED(16, uint16_t, predictor16[32 * 32 * 3]);
6971 DECLARE_ALIGNED(16, uint8_t, predictor8[32 * 32 * 3]);
6974 DECLARE_ALIGNED(16, uint8_t, predictor[32 * 32 * 3]);
6976 DECLARE_ALIGNED(16, int16_t, src_diff[32 * 32]);
6977 DECLARE_ALIGNED(16, tran_low_t, coeff[32 * 32]);
6978 DECLARE_ALIGNED(16, tran_low_t, qcoeff[32 * 32]);
6979 DECLARE_ALIGNED(16, tran_low_t, dqcoeff[32 * 32]);
6981 const TX_SIZE tx_size = max_txsize_lookup[bsize];
6982 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6983 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6984 int64_t recon_error, sse;
6985 #if CONFIG_NON_GREEDY_MV
6986 int square_block_idx;
6990 // Setup scaling factor
6991 #if CONFIG_VP9_HIGHBITDEPTH
6992 vp9_setup_scale_factors_for_frame(
6993 &sf, this_frame->y_crop_width, this_frame->y_crop_height,
6994 this_frame->y_crop_width, this_frame->y_crop_height,
6995 cpi->common.use_highbitdepth);
6997 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH)
6998 predictor = CONVERT_TO_BYTEPTR(predictor16);
7000 predictor = predictor8;
7002 vp9_setup_scale_factors_for_frame(
7003 &sf, this_frame->y_crop_width, this_frame->y_crop_height,
7004 this_frame->y_crop_width, this_frame->y_crop_height);
7005 #endif // CONFIG_VP9_HIGHBITDEPTH
7007 // Prepare reference frame pointers. If any reference frame slot is
7008 // unavailable, the pointer will be set to Null.
7009 for (idx = 0; idx < 3; ++idx) {
7010 int rf_idx = gf_picture[frame_idx].ref_frame[idx];
7011 if (rf_idx != -1) ref_frame[idx] = gf_picture[rf_idx].frame;
7014 xd->mi = cm->mi_grid_visible;
7016 xd->cur_buf = this_frame;
7018 // Get rd multiplier set up.
7019 rdmult = vp9_compute_rd_mult_based_on_qindex(cpi, tpl_frame->base_qindex);
7020 set_error_per_bit(&cpi->td.mb, rdmult);
7021 vp9_initialize_me_consts(cpi, &cpi->td.mb, tpl_frame->base_qindex);
7023 tpl_frame->is_valid = 1;
7025 cm->base_qindex = tpl_frame->base_qindex;
7026 vp9_frame_init_quantizer(cpi);
7028 #if CONFIG_NON_GREEDY_MV
7029 for (square_block_idx = 0; square_block_idx < SQUARE_BLOCK_SIZES;
7030 ++square_block_idx) {
7031 BLOCK_SIZE square_bsize = square_block_idx_to_bsize(square_block_idx);
7032 build_motion_field(cpi, xd, frame_idx, ref_frame, square_bsize);
7034 for (rf_idx = 0; rf_idx < 3; ++rf_idx) {
7035 int ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
7036 if (ref_frame_idx != -1) {
7037 predict_mv_mode_arr(cpi, x, gf_picture, frame_idx, tpl_frame, rf_idx,
7043 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
7044 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
7045 mode_estimation(cpi, x, xd, &sf, gf_picture, frame_idx, tpl_frame,
7046 src_diff, coeff, qcoeff, dqcoeff, mi_row, mi_col, bsize,
7047 tx_size, ref_frame, predictor, &recon_error, &sse);
7048 // Motion flow dependency dispenser.
7049 tpl_model_store(tpl_frame->tpl_stats_ptr, mi_row, mi_col, bsize,
7052 tpl_model_update(cpi->tpl_stats, tpl_frame->tpl_stats_ptr, mi_row, mi_col,
7058 #if CONFIG_NON_GREEDY_MV
7059 #define DUMP_TPL_STATS 0
7061 static void dump_buf(uint8_t *buf, int stride, int row, int col, int h, int w) {
7063 printf("%d %d\n", h, w);
7064 for (i = 0; i < h; ++i) {
7065 for (j = 0; j < w; ++j) {
7066 printf("%d ", buf[(row + i) * stride + col + j]);
7072 static void dump_frame_buf(const YV12_BUFFER_CONFIG *frame_buf) {
7073 dump_buf(frame_buf->y_buffer, frame_buf->y_stride, 0, 0, frame_buf->y_height,
7074 frame_buf->y_width);
7075 dump_buf(frame_buf->u_buffer, frame_buf->uv_stride, 0, 0,
7076 frame_buf->uv_height, frame_buf->uv_width);
7077 dump_buf(frame_buf->v_buffer, frame_buf->uv_stride, 0, 0,
7078 frame_buf->uv_height, frame_buf->uv_width);
7081 static void dump_tpl_stats(const VP9_COMP *cpi, int tpl_group_frames,
7082 const GF_GROUP *gf_group,
7083 const GF_PICTURE *gf_picture, BLOCK_SIZE bsize) {
7085 const VP9_COMMON *cm = &cpi->common;
7087 for (frame_idx = 1; frame_idx < tpl_group_frames; ++frame_idx) {
7088 for (rf_idx = 0; rf_idx < 3; ++rf_idx) {
7089 const TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
7092 const int mi_height = num_8x8_blocks_high_lookup[bsize];
7093 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
7094 ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
7095 if (ref_frame_idx != -1) {
7096 YV12_BUFFER_CONFIG *ref_frame_buf = gf_picture[ref_frame_idx].frame;
7097 const int gf_frame_offset = gf_group->frame_gop_index[frame_idx];
7098 const int ref_gf_frame_offset =
7099 gf_group->frame_gop_index[ref_frame_idx];
7102 "frame_idx %d mi_rows %d mi_cols %d bsize %d ref_frame_idx %d "
7103 "rf_idx %d gf_frame_offset %d ref_gf_frame_offset %d\n",
7104 frame_idx, cm->mi_rows, cm->mi_cols, mi_width * MI_SIZE,
7105 ref_frame_idx, rf_idx, gf_frame_offset, ref_gf_frame_offset);
7106 for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row) {
7107 for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) {
7108 if ((mi_row % mi_height) == 0 && (mi_col % mi_width) == 0) {
7110 *get_pyramid_mv(tpl_frame, rf_idx, bsize, mi_row, mi_col);
7111 printf("%d %d %d %d\n", mi_row, mi_col, mv.as_mv.row,
7116 for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row) {
7117 for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) {
7118 if ((mi_row % mi_height) == 0 && (mi_col % mi_width) == 0) {
7119 const TplDepStats *tpl_ptr =
7121 ->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
7122 printf("%f ", tpl_ptr->feature_score);
7128 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
7129 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
7132 ->mv_mode_arr[rf_idx][mi_row * tpl_frame->stride + mi_col];
7133 printf("%d ", mv_mode);
7138 dump_frame_buf(gf_picture[frame_idx].frame);
7139 dump_frame_buf(ref_frame_buf);
7144 #endif // DUMP_TPL_STATS
7145 #endif // CONFIG_NON_GREEDY_MV
7147 static void init_tpl_buffer(VP9_COMP *cpi) {
7148 VP9_COMMON *cm = &cpi->common;
7151 const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
7152 const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
7153 #if CONFIG_NON_GREEDY_MV
7157 // TODO(angiebird): This probably needs further modifications to support
7158 // frame scaling later on.
7159 if (cpi->feature_score_loc_alloc == 0) {
7160 // The smallest block size of motion field is 4x4, but the mi_unit is 8x8,
7161 // therefore the number of units is "mi_rows * mi_cols * 4" here.
7163 cm, cpi->feature_score_loc_arr,
7164 vpx_calloc(mi_rows * mi_cols * 4, sizeof(*cpi->feature_score_loc_arr)));
7165 CHECK_MEM_ERROR(cm, cpi->feature_score_loc_sort,
7166 vpx_calloc(mi_rows * mi_cols * 4,
7167 sizeof(*cpi->feature_score_loc_sort)));
7168 CHECK_MEM_ERROR(cm, cpi->feature_score_loc_heap,
7169 vpx_calloc(mi_rows * mi_cols * 4,
7170 sizeof(*cpi->feature_score_loc_heap)));
7172 cpi->feature_score_loc_alloc = 1;
7174 vpx_free(cpi->select_mv_arr);
7176 cm, cpi->select_mv_arr,
7177 vpx_calloc(mi_rows * mi_cols * 4, sizeof(*cpi->select_mv_arr)));
7180 // TODO(jingning): Reduce the actual memory use for tpl model build up.
7181 for (frame = 0; frame < MAX_ARF_GOP_SIZE; ++frame) {
7182 if (cpi->tpl_stats[frame].width >= mi_cols &&
7183 cpi->tpl_stats[frame].height >= mi_rows &&
7184 cpi->tpl_stats[frame].tpl_stats_ptr)
7187 #if CONFIG_NON_GREEDY_MV
7188 for (rf_idx = 0; rf_idx < 3; ++rf_idx) {
7189 for (sqr_bsize = 0; sqr_bsize < SQUARE_BLOCK_SIZES; ++sqr_bsize) {
7190 vpx_free(cpi->tpl_stats[frame].pyramid_mv_arr[rf_idx][sqr_bsize]);
7192 cm, cpi->tpl_stats[frame].pyramid_mv_arr[rf_idx][sqr_bsize],
7194 mi_rows * mi_cols * 4,
7196 *cpi->tpl_stats[frame].pyramid_mv_arr[rf_idx][sqr_bsize])));
7198 vpx_free(cpi->tpl_stats[frame].mv_mode_arr[rf_idx]);
7200 cm, cpi->tpl_stats[frame].mv_mode_arr[rf_idx],
7201 vpx_calloc(mi_rows * mi_cols * 4,
7202 sizeof(*cpi->tpl_stats[frame].mv_mode_arr[rf_idx])));
7203 vpx_free(cpi->tpl_stats[frame].rd_diff_arr[rf_idx]);
7205 cm, cpi->tpl_stats[frame].rd_diff_arr[rf_idx],
7206 vpx_calloc(mi_rows * mi_cols * 4,
7207 sizeof(*cpi->tpl_stats[frame].rd_diff_arr[rf_idx])));
7210 vpx_free(cpi->tpl_stats[frame].tpl_stats_ptr);
7211 CHECK_MEM_ERROR(cm, cpi->tpl_stats[frame].tpl_stats_ptr,
7212 vpx_calloc(mi_rows * mi_cols,
7213 sizeof(*cpi->tpl_stats[frame].tpl_stats_ptr)));
7214 cpi->tpl_stats[frame].is_valid = 0;
7215 cpi->tpl_stats[frame].width = mi_cols;
7216 cpi->tpl_stats[frame].height = mi_rows;
7217 cpi->tpl_stats[frame].stride = mi_cols;
7218 cpi->tpl_stats[frame].mi_rows = cm->mi_rows;
7219 cpi->tpl_stats[frame].mi_cols = cm->mi_cols;
7222 for (frame = 0; frame < REF_FRAMES; ++frame) {
7223 cpi->enc_frame_buf[frame].mem_valid = 0;
7224 cpi->enc_frame_buf[frame].released = 1;
7228 static void setup_tpl_stats(VP9_COMP *cpi) {
7229 GF_PICTURE gf_picture[MAX_ARF_GOP_SIZE];
7230 const GF_GROUP *gf_group = &cpi->twopass.gf_group;
7231 int tpl_group_frames = 0;
7233 cpi->tpl_bsize = BLOCK_32X32;
7235 init_gop_frames(cpi, gf_picture, gf_group, &tpl_group_frames);
7237 init_tpl_stats(cpi);
7239 // Backward propagation from tpl_group_frames to 1.
7240 for (frame_idx = tpl_group_frames - 1; frame_idx > 0; --frame_idx) {
7241 if (gf_picture[frame_idx].update_type == USE_BUF_FRAME) continue;
7242 mc_flow_dispenser(cpi, gf_picture, frame_idx, cpi->tpl_bsize);
7244 #if CONFIG_NON_GREEDY_MV
7247 dump_tpl_stats(cpi, tpl_group_frames, gf_group, gf_picture, cpi->tpl_bsize);
7248 #endif // DUMP_TPL_STATS
7249 #endif // CONFIG_NON_GREEDY_MV
7252 int vp9_get_compressed_data(VP9_COMP *cpi, unsigned int *frame_flags,
7253 size_t *size, uint8_t *dest, int64_t *time_stamp,
7254 int64_t *time_end, int flush) {
7255 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
7256 VP9_COMMON *const cm = &cpi->common;
7257 BufferPool *const pool = cm->buffer_pool;
7258 RATE_CONTROL *const rc = &cpi->rc;
7259 struct vpx_usec_timer cmptimer;
7260 YV12_BUFFER_CONFIG *force_src_buffer = NULL;
7261 struct lookahead_entry *last_source = NULL;
7262 struct lookahead_entry *source = NULL;
7264 const int gf_group_index = cpi->twopass.gf_group.index;
7267 if (is_one_pass_cbr_svc(cpi)) {
7268 vp9_one_pass_cbr_svc_start_layer(cpi);
7271 vpx_usec_timer_start(&cmptimer);
7273 vp9_set_high_precision_mv(cpi, ALTREF_HIGH_PRECISION_MV);
7275 // Is multi-arf enabled.
7276 // Note that at the moment multi_arf is only configured for 2 pass VBR and
7277 // will not work properly with svc.
7278 // Enable the Jingning's new "multi_layer_arf" code if "enable_auto_arf"
7279 // is greater than or equal to 2.
7280 if ((oxcf->pass == 2) && !cpi->use_svc && (cpi->oxcf.enable_auto_arf >= 2))
7281 cpi->multi_layer_arf = 1;
7283 cpi->multi_layer_arf = 0;
7286 cm->reset_frame_context = 0;
7287 cm->refresh_frame_context = 1;
7288 if (!is_one_pass_cbr_svc(cpi)) {
7289 cpi->refresh_last_frame = 1;
7290 cpi->refresh_golden_frame = 0;
7291 cpi->refresh_alt_ref_frame = 0;
7294 // Should we encode an arf frame.
7295 arf_src_index = get_arf_src_index(cpi);
7297 if (arf_src_index) {
7298 for (i = 0; i <= arf_src_index; ++i) {
7299 struct lookahead_entry *e = vp9_lookahead_peek(cpi->lookahead, i);
7300 // Avoid creating an alt-ref if there's a forced keyframe pending.
7303 } else if (e->flags == VPX_EFLAG_FORCE_KF) {
7311 // Clear arf index stack before group of pictures processing starts.
7312 if (gf_group_index == 1) {
7313 stack_init(cpi->twopass.gf_group.arf_index_stack, MAX_LAG_BUFFERS * 2);
7314 cpi->twopass.gf_group.stack_size = 0;
7317 if (arf_src_index) {
7318 assert(arf_src_index <= rc->frames_to_key);
7319 if ((source = vp9_lookahead_peek(cpi->lookahead, arf_src_index)) != NULL) {
7320 cpi->alt_ref_source = source;
7322 #if !CONFIG_REALTIME_ONLY
7323 if ((oxcf->mode != REALTIME) && (oxcf->arnr_max_frames > 0) &&
7324 (oxcf->arnr_strength > 0)) {
7325 int bitrate = cpi->rc.avg_frame_bandwidth / 40;
7326 int not_low_bitrate = bitrate > ALT_REF_AQ_LOW_BITRATE_BOUNDARY;
7328 int not_last_frame = (cpi->lookahead->sz - arf_src_index > 1);
7329 not_last_frame |= ALT_REF_AQ_APPLY_TO_LAST_FRAME;
7331 // Produce the filtered ARF frame.
7332 vp9_temporal_filter(cpi, arf_src_index);
7333 vpx_extend_frame_borders(&cpi->alt_ref_buffer);
7335 // for small bitrates segmentation overhead usually
7336 // eats all bitrate gain from enabling delta quantizers
7337 if (cpi->oxcf.alt_ref_aq != 0 && not_low_bitrate && not_last_frame)
7338 vp9_alt_ref_aq_setup_mode(cpi->alt_ref_aq, cpi);
7340 force_src_buffer = &cpi->alt_ref_buffer;
7345 cpi->refresh_alt_ref_frame = 1;
7346 cpi->refresh_golden_frame = 0;
7347 cpi->refresh_last_frame = 0;
7348 rc->is_src_frame_alt_ref = 0;
7349 rc->source_alt_ref_pending = 0;
7351 rc->source_alt_ref_pending = 0;
7356 // Get last frame source.
7357 if (cm->current_video_frame > 0) {
7358 if ((last_source = vp9_lookahead_peek(cpi->lookahead, -1)) == NULL)
7362 // Read in the source frame.
7363 if (cpi->use_svc || cpi->svc.set_intra_only_frame)
7364 source = vp9_svc_lookahead_pop(cpi, cpi->lookahead, flush);
7366 source = vp9_lookahead_pop(cpi->lookahead, flush);
7368 if (source != NULL) {
7371 // if the flags indicate intra frame, but if the current picture is for
7372 // non-zero spatial layer, it should not be an intra picture.
7373 if ((source->flags & VPX_EFLAG_FORCE_KF) && cpi->use_svc &&
7374 cpi->svc.spatial_layer_id > 0) {
7375 source->flags &= ~(unsigned int)(VPX_EFLAG_FORCE_KF);
7378 // Check to see if the frame should be encoded as an arf overlay.
7379 check_src_altref(cpi, source);
7384 cpi->un_scaled_source = cpi->Source =
7385 force_src_buffer ? force_src_buffer : &source->img;
7387 #ifdef ENABLE_KF_DENOISE
7388 // Copy of raw source for metrics calculation.
7389 if (is_psnr_calc_enabled(cpi))
7390 vp9_copy_and_extend_frame(cpi->Source, &cpi->raw_unscaled_source);
7393 cpi->unscaled_last_source = last_source != NULL ? &last_source->img : NULL;
7395 *time_stamp = source->ts_start;
7396 *time_end = source->ts_end;
7397 *frame_flags = (source->flags & VPX_EFLAG_FORCE_KF) ? FRAMEFLAGS_KEY : 0;
7400 #if !CONFIG_REALTIME_ONLY
7401 if (flush && oxcf->pass == 1 && !cpi->twopass.first_pass_done) {
7402 vp9_end_first_pass(cpi); /* get last stats packet */
7403 cpi->twopass.first_pass_done = 1;
7405 #endif // !CONFIG_REALTIME_ONLY
7409 if (source->ts_start < cpi->first_time_stamp_ever) {
7410 cpi->first_time_stamp_ever = source->ts_start;
7411 cpi->last_end_time_stamp_seen = source->ts_start;
7414 // Clear down mmx registers
7415 vpx_clear_system_state();
7417 // adjust frame rates based on timestamps given
7418 if (cm->show_frame) {
7419 if (cpi->use_svc && cpi->svc.use_set_ref_frame_config &&
7420 cpi->svc.duration[cpi->svc.spatial_layer_id] > 0)
7421 vp9_svc_adjust_frame_rate(cpi);
7423 adjust_frame_rate(cpi, source);
7426 if (is_one_pass_cbr_svc(cpi)) {
7427 vp9_update_temporal_layer_framerate(cpi);
7428 vp9_restore_layer_context(cpi);
7431 // Find a free buffer for the new frame, releasing the reference previously
7433 if (cm->new_fb_idx != INVALID_IDX) {
7434 --pool->frame_bufs[cm->new_fb_idx].ref_count;
7436 cm->new_fb_idx = get_free_fb(cm);
7438 if (cm->new_fb_idx == INVALID_IDX) return -1;
7440 cm->cur_frame = &pool->frame_bufs[cm->new_fb_idx];
7442 // Start with a 0 size frame.
7445 cpi->frame_flags = *frame_flags;
7447 #if !CONFIG_REALTIME_ONLY
7448 if ((oxcf->pass == 2) && !cpi->use_svc) {
7449 vp9_rc_get_second_pass_params(cpi);
7450 } else if (oxcf->pass == 1) {
7451 set_frame_size(cpi);
7453 #endif // !CONFIG_REALTIME_ONLY
7455 if (oxcf->pass != 1 && cpi->level_constraint.level_index >= 0 &&
7456 cpi->level_constraint.fail_flag == 0)
7457 level_rc_framerate(cpi, arf_src_index);
7459 if (cpi->oxcf.pass != 0 || cpi->use_svc || frame_is_intra_only(cm) == 1) {
7460 for (i = 0; i < REFS_PER_FRAME; ++i) cpi->scaled_ref_idx[i] = INVALID_IDX;
7463 if (cpi->kmeans_data_arr_alloc == 0) {
7464 const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
7465 const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
7466 #if CONFIG_MULTITHREAD
7467 pthread_mutex_init(&cpi->kmeans_mutex, NULL);
7470 cm, cpi->kmeans_data_arr,
7471 vpx_calloc(mi_rows * mi_cols, sizeof(*cpi->kmeans_data_arr)));
7472 cpi->kmeans_data_stride = mi_cols;
7473 cpi->kmeans_data_arr_alloc = 1;
7476 if (gf_group_index == 1 &&
7477 cpi->twopass.gf_group.update_type[gf_group_index] == ARF_UPDATE &&
7478 cpi->sf.enable_tpl_model) {
7479 init_tpl_buffer(cpi);
7480 vp9_estimate_qp_gop(cpi);
7481 setup_tpl_stats(cpi);
7484 #if CONFIG_BITSTREAM_DEBUG
7485 assert(cpi->oxcf.max_threads == 0 &&
7486 "bitstream debug tool does not support multithreading");
7487 bitstream_queue_record_write();
7489 #if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
7490 bitstream_queue_set_frame_write(cm->current_video_frame * 2 + cm->show_frame);
7493 cpi->td.mb.fp_src_pred = 0;
7494 #if CONFIG_REALTIME_ONLY
7496 SvcEncode(cpi, size, dest, frame_flags);
7499 Pass0Encode(cpi, size, dest, frame_flags);
7501 #else // !CONFIG_REALTIME_ONLY
7502 if (oxcf->pass == 1 && !cpi->use_svc) {
7503 const int lossless = is_lossless_requested(oxcf);
7504 #if CONFIG_VP9_HIGHBITDEPTH
7505 if (cpi->oxcf.use_highbitdepth)
7506 cpi->td.mb.fwd_txfm4x4 =
7507 lossless ? vp9_highbd_fwht4x4 : vpx_highbd_fdct4x4;
7509 cpi->td.mb.fwd_txfm4x4 = lossless ? vp9_fwht4x4 : vpx_fdct4x4;
7510 cpi->td.mb.highbd_inv_txfm_add =
7511 lossless ? vp9_highbd_iwht4x4_add : vp9_highbd_idct4x4_add;
7513 cpi->td.mb.fwd_txfm4x4 = lossless ? vp9_fwht4x4 : vpx_fdct4x4;
7514 #endif // CONFIG_VP9_HIGHBITDEPTH
7515 cpi->td.mb.inv_txfm_add = lossless ? vp9_iwht4x4_add : vp9_idct4x4_add;
7516 vp9_first_pass(cpi, source);
7517 } else if (oxcf->pass == 2 && !cpi->use_svc) {
7518 Pass2Encode(cpi, size, dest, frame_flags);
7519 } else if (cpi->use_svc) {
7520 SvcEncode(cpi, size, dest, frame_flags);
7523 Pass0Encode(cpi, size, dest, frame_flags);
7525 #endif // CONFIG_REALTIME_ONLY
7527 if (cm->show_frame) cm->cur_show_frame_fb_idx = cm->new_fb_idx;
7529 if (cm->refresh_frame_context)
7530 cm->frame_contexts[cm->frame_context_idx] = *cm->fc;
7532 // No frame encoded, or frame was dropped, release scaled references.
7533 if ((*size == 0) && (frame_is_intra_only(cm) == 0)) {
7534 release_scaled_references(cpi);
7538 cpi->droppable = !frame_is_reference(cpi);
7541 // Save layer specific state.
7542 if (is_one_pass_cbr_svc(cpi) || ((cpi->svc.number_temporal_layers > 1 ||
7543 cpi->svc.number_spatial_layers > 1) &&
7545 vp9_save_layer_context(cpi);
7548 vpx_usec_timer_mark(&cmptimer);
7549 cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
7551 // Should we calculate metrics for the frame.
7552 if (is_psnr_calc_enabled(cpi)) generate_psnr_packet(cpi);
7554 if (cpi->keep_level_stats && oxcf->pass != 1)
7555 update_level_info(cpi, size, arf_src_index);
7557 #if CONFIG_INTERNAL_STATS
7559 if (oxcf->pass != 1) {
7560 double samples = 0.0;
7561 cpi->bytes += (int)(*size);
7563 if (cm->show_frame) {
7564 uint32_t bit_depth = 8;
7565 uint32_t in_bit_depth = 8;
7567 #if CONFIG_VP9_HIGHBITDEPTH
7568 if (cm->use_highbitdepth) {
7569 in_bit_depth = cpi->oxcf.input_bit_depth;
7570 bit_depth = cm->bit_depth;
7574 if (cpi->b_calculate_psnr) {
7575 YV12_BUFFER_CONFIG *orig = cpi->raw_source_frame;
7576 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
7577 YV12_BUFFER_CONFIG *pp = &cm->post_proc_buffer;
7579 #if CONFIG_VP9_HIGHBITDEPTH
7580 vpx_calc_highbd_psnr(orig, recon, &psnr, cpi->td.mb.e_mbd.bd,
7583 vpx_calc_psnr(orig, recon, &psnr);
7584 #endif // CONFIG_VP9_HIGHBITDEPTH
7586 adjust_image_stat(psnr.psnr[1], psnr.psnr[2], psnr.psnr[3],
7587 psnr.psnr[0], &cpi->psnr);
7588 cpi->total_sq_error += psnr.sse[0];
7589 cpi->total_samples += psnr.samples[0];
7590 samples = psnr.samples[0];
7594 double frame_ssim2 = 0, weight = 0;
7595 #if CONFIG_VP9_POSTPROC
7596 if (vpx_alloc_frame_buffer(
7597 pp, recon->y_crop_width, recon->y_crop_height,
7598 cm->subsampling_x, cm->subsampling_y,
7599 #if CONFIG_VP9_HIGHBITDEPTH
7600 cm->use_highbitdepth,
7602 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment) < 0) {
7603 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
7604 "Failed to allocate post processing buffer");
7607 vp9_ppflags_t ppflags;
7608 ppflags.post_proc_flag = VP9D_DEBLOCK;
7609 ppflags.deblocking_level = 0; // not used in vp9_post_proc_frame()
7610 ppflags.noise_level = 0; // not used in vp9_post_proc_frame()
7611 vp9_post_proc_frame(cm, pp, &ppflags,
7612 cpi->un_scaled_source->y_width);
7615 vpx_clear_system_state();
7617 #if CONFIG_VP9_HIGHBITDEPTH
7618 vpx_calc_highbd_psnr(orig, pp, &psnr2, cpi->td.mb.e_mbd.bd,
7619 cpi->oxcf.input_bit_depth);
7621 vpx_calc_psnr(orig, pp, &psnr2);
7622 #endif // CONFIG_VP9_HIGHBITDEPTH
7624 cpi->totalp_sq_error += psnr2.sse[0];
7625 cpi->totalp_samples += psnr2.samples[0];
7626 adjust_image_stat(psnr2.psnr[1], psnr2.psnr[2], psnr2.psnr[3],
7627 psnr2.psnr[0], &cpi->psnrp);
7629 #if CONFIG_VP9_HIGHBITDEPTH
7630 if (cm->use_highbitdepth) {
7631 frame_ssim2 = vpx_highbd_calc_ssim(orig, recon, &weight, bit_depth,
7634 frame_ssim2 = vpx_calc_ssim(orig, recon, &weight);
7637 frame_ssim2 = vpx_calc_ssim(orig, recon, &weight);
7638 #endif // CONFIG_VP9_HIGHBITDEPTH
7640 cpi->worst_ssim = VPXMIN(cpi->worst_ssim, frame_ssim2);
7641 cpi->summed_quality += frame_ssim2 * weight;
7642 cpi->summed_weights += weight;
7644 #if CONFIG_VP9_HIGHBITDEPTH
7645 if (cm->use_highbitdepth) {
7646 frame_ssim2 = vpx_highbd_calc_ssim(orig, pp, &weight, bit_depth,
7649 frame_ssim2 = vpx_calc_ssim(orig, pp, &weight);
7652 frame_ssim2 = vpx_calc_ssim(orig, pp, &weight);
7653 #endif // CONFIG_VP9_HIGHBITDEPTH
7655 cpi->summedp_quality += frame_ssim2 * weight;
7656 cpi->summedp_weights += weight;
7658 if (cm->show_frame) {
7659 FILE *f = fopen("q_used.stt", "a");
7660 fprintf(f, "%5d : Y%f7.3:U%f7.3:V%f7.3:F%f7.3:S%7.3f\n",
7661 cpi->common.current_video_frame, psnr2.psnr[1],
7662 psnr2.psnr[2], psnr2.psnr[3], psnr2.psnr[0], frame_ssim2);
7668 if (cpi->b_calculate_blockiness) {
7669 #if CONFIG_VP9_HIGHBITDEPTH
7670 if (!cm->use_highbitdepth)
7673 double frame_blockiness = vp9_get_blockiness(
7674 cpi->Source->y_buffer, cpi->Source->y_stride,
7675 cm->frame_to_show->y_buffer, cm->frame_to_show->y_stride,
7676 cpi->Source->y_width, cpi->Source->y_height);
7677 cpi->worst_blockiness =
7678 VPXMAX(cpi->worst_blockiness, frame_blockiness);
7679 cpi->total_blockiness += frame_blockiness;
7683 if (cpi->b_calculate_consistency) {
7684 #if CONFIG_VP9_HIGHBITDEPTH
7685 if (!cm->use_highbitdepth)
7688 double this_inconsistency = vpx_get_ssim_metrics(
7689 cpi->Source->y_buffer, cpi->Source->y_stride,
7690 cm->frame_to_show->y_buffer, cm->frame_to_show->y_stride,
7691 cpi->Source->y_width, cpi->Source->y_height, cpi->ssim_vars,
7694 const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1);
7695 double consistency =
7696 vpx_sse_to_psnr(samples, peak, (double)cpi->total_inconsistency);
7697 if (consistency > 0.0)
7698 cpi->worst_consistency =
7699 VPXMIN(cpi->worst_consistency, consistency);
7700 cpi->total_inconsistency += this_inconsistency;
7705 double y, u, v, frame_all;
7706 frame_all = vpx_calc_fastssim(cpi->Source, cm->frame_to_show, &y, &u,
7707 &v, bit_depth, in_bit_depth);
7708 adjust_image_stat(y, u, v, frame_all, &cpi->fastssim);
7711 double y, u, v, frame_all;
7712 frame_all = vpx_psnrhvs(cpi->Source, cm->frame_to_show, &y, &u, &v,
7713 bit_depth, in_bit_depth);
7714 adjust_image_stat(y, u, v, frame_all, &cpi->psnrhvs);
7721 if (is_one_pass_cbr_svc(cpi)) {
7722 if (cm->show_frame) {
7723 ++cpi->svc.spatial_layer_to_encode;
7724 if (cpi->svc.spatial_layer_to_encode >= cpi->svc.number_spatial_layers)
7725 cpi->svc.spatial_layer_to_encode = 0;
7729 vpx_clear_system_state();
7733 int vp9_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest,
7734 vp9_ppflags_t *flags) {
7735 VP9_COMMON *cm = &cpi->common;
7736 #if !CONFIG_VP9_POSTPROC
7740 if (!cm->show_frame) {
7744 #if CONFIG_VP9_POSTPROC
7745 ret = vp9_post_proc_frame(cm, dest, flags, cpi->un_scaled_source->y_width);
7747 if (cm->frame_to_show) {
7748 *dest = *cm->frame_to_show;
7749 dest->y_width = cm->width;
7750 dest->y_height = cm->height;
7751 dest->uv_width = cm->width >> cm->subsampling_x;
7752 dest->uv_height = cm->height >> cm->subsampling_y;
7757 #endif // !CONFIG_VP9_POSTPROC
7758 vpx_clear_system_state();
7763 int vp9_set_internal_size(VP9_COMP *cpi, VPX_SCALING horiz_mode,
7764 VPX_SCALING vert_mode) {
7765 VP9_COMMON *cm = &cpi->common;
7766 int hr = 0, hs = 0, vr = 0, vs = 0;
7768 if (horiz_mode > ONETWO || vert_mode > ONETWO) return -1;
7770 Scale2Ratio(horiz_mode, &hr, &hs);
7771 Scale2Ratio(vert_mode, &vr, &vs);
7773 // always go to the next whole number
7774 cm->width = (hs - 1 + cpi->oxcf.width * hr) / hs;
7775 cm->height = (vs - 1 + cpi->oxcf.height * vr) / vs;
7776 if (cm->current_video_frame) {
7777 assert(cm->width <= cpi->initial_width);
7778 assert(cm->height <= cpi->initial_height);
7781 update_frame_size(cpi);
7786 int vp9_set_size_literal(VP9_COMP *cpi, unsigned int width,
7787 unsigned int height) {
7788 VP9_COMMON *cm = &cpi->common;
7789 #if CONFIG_VP9_HIGHBITDEPTH
7790 check_initial_width(cpi, cm->use_highbitdepth, 1, 1);
7792 check_initial_width(cpi, 1, 1);
7793 #endif // CONFIG_VP9_HIGHBITDEPTH
7795 #if CONFIG_VP9_TEMPORAL_DENOISING
7796 setup_denoiser_buffer(cpi);
7801 if (cm->width > cpi->initial_width) {
7802 cm->width = cpi->initial_width;
7803 printf("Warning: Desired width too large, changed to %d\n", cm->width);
7808 cm->height = height;
7809 if (cm->height > cpi->initial_height) {
7810 cm->height = cpi->initial_height;
7811 printf("Warning: Desired height too large, changed to %d\n", cm->height);
7814 assert(cm->width <= cpi->initial_width);
7815 assert(cm->height <= cpi->initial_height);
7817 update_frame_size(cpi);
7822 void vp9_set_svc(VP9_COMP *cpi, int use_svc) {
7823 cpi->use_svc = use_svc;
7827 int vp9_get_quantizer(VP9_COMP *cpi) { return cpi->common.base_qindex; }
7829 void vp9_apply_encoding_flags(VP9_COMP *cpi, vpx_enc_frame_flags_t flags) {
7831 (VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF)) {
7834 if (flags & VP8_EFLAG_NO_REF_LAST) ref ^= VP9_LAST_FLAG;
7836 if (flags & VP8_EFLAG_NO_REF_GF) ref ^= VP9_GOLD_FLAG;
7838 if (flags & VP8_EFLAG_NO_REF_ARF) ref ^= VP9_ALT_FLAG;
7840 vp9_use_as_reference(cpi, ref);
7844 (VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
7845 VP8_EFLAG_FORCE_GF | VP8_EFLAG_FORCE_ARF)) {
7848 if (flags & VP8_EFLAG_NO_UPD_LAST) upd ^= VP9_LAST_FLAG;
7850 if (flags & VP8_EFLAG_NO_UPD_GF) upd ^= VP9_GOLD_FLAG;
7852 if (flags & VP8_EFLAG_NO_UPD_ARF) upd ^= VP9_ALT_FLAG;
7854 vp9_update_reference(cpi, upd);
7857 if (flags & VP8_EFLAG_NO_UPD_ENTROPY) {
7858 vp9_update_entropy(cpi, 0);
7862 void vp9_set_row_mt(VP9_COMP *cpi) {
7863 // Enable row based multi-threading for supported modes of encoding
7865 if (((cpi->oxcf.mode == GOOD || cpi->oxcf.mode == BEST) &&
7866 cpi->oxcf.speed < 5 && cpi->oxcf.pass == 1) &&
7867 cpi->oxcf.row_mt && !cpi->use_svc)
7870 if (cpi->oxcf.mode == GOOD && cpi->oxcf.speed < 5 &&
7871 (cpi->oxcf.pass == 0 || cpi->oxcf.pass == 2) && cpi->oxcf.row_mt &&
7875 // In realtime mode, enable row based multi-threading for all the speed levels
7876 // where non-rd path is used.
7877 if (cpi->oxcf.mode == REALTIME && cpi->oxcf.speed >= 5 && cpi->oxcf.row_mt) {
7882 cpi->row_mt_bit_exact = 1;
7884 cpi->row_mt_bit_exact = 0;