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"
83 #include "vp9/vp9_cx_iface.h"
85 #define AM_SEGMENT_ID_INACTIVE 7
86 #define AM_SEGMENT_ID_ACTIVE 0
88 // Whether to use high precision mv for altref computation.
89 #define ALTREF_HIGH_PRECISION_MV 1
91 // Q threshold for high precision mv. Choose a very high value for now so that
92 // HIGH_PRECISION is always chosen.
93 #define HIGH_PRECISION_MV_QTHRESH 200
95 #define FRAME_SIZE_FACTOR 128 // empirical params for context model threshold
96 #define FRAME_RATE_FACTOR 8
98 #ifdef OUTPUT_YUV_DENOISED
99 FILE *yuv_denoised_file = NULL;
101 #ifdef OUTPUT_YUV_SKINMAP
102 static FILE *yuv_skinmap_file = NULL;
104 #ifdef OUTPUT_YUV_REC
107 #ifdef OUTPUT_YUV_SVC_SRC
108 FILE *yuv_svc_src[3] = { NULL, NULL, NULL };
117 #ifdef ENABLE_KF_DENOISE
118 // Test condition for spatial denoise of source.
119 static int is_spatial_denoise_enabled(VP9_COMP *cpi) {
120 VP9_COMMON *const cm = &cpi->common;
121 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
123 return (oxcf->pass != 1) && !is_lossless_requested(&cpi->oxcf) &&
124 frame_is_intra_only(cm);
128 #if CONFIG_VP9_HIGHBITDEPTH
129 void highbd_wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
132 void wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
135 #if !CONFIG_REALTIME_ONLY
136 // compute adaptive threshold for skip recoding
137 static int compute_context_model_thresh(const VP9_COMP *const cpi) {
138 const VP9_COMMON *const cm = &cpi->common;
139 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
140 const int frame_size = (cm->width * cm->height) >> 10;
141 const int bitrate = (int)(oxcf->target_bandwidth >> 10);
142 const int qindex_factor = cm->base_qindex + (MAXQ >> 1);
144 // This equation makes the threshold adaptive to frame size.
145 // Coding gain obtained by recoding comes from alternate frames of large
146 // content change. We skip recoding if the difference of previous and current
147 // frame context probability model is less than a certain threshold.
148 // The first component is the most critical part to guarantee adaptivity.
149 // Other parameters are estimated based on normal setting of hd resolution
150 // parameters. e.g frame_size = 1920x1080, bitrate = 8000, qindex_factor < 50
152 ((FRAME_SIZE_FACTOR * frame_size - FRAME_RATE_FACTOR * bitrate) *
159 // compute the total cost difference between current
160 // and previous frame context prob model.
161 static int compute_context_model_diff(const VP9_COMMON *const cm) {
162 const FRAME_CONTEXT *const pre_fc =
163 &cm->frame_contexts[cm->frame_context_idx];
164 const FRAME_CONTEXT *const cur_fc = cm->fc;
165 const FRAME_COUNTS *counts = &cm->counts;
166 vpx_prob pre_last_prob, cur_last_prob;
168 int i, j, k, l, m, n;
171 for (i = 0; i < BLOCK_SIZE_GROUPS; ++i) {
172 for (j = 0; j < INTRA_MODES - 1; ++j) {
173 diff += (int)counts->y_mode[i][j] *
174 (pre_fc->y_mode_prob[i][j] - cur_fc->y_mode_prob[i][j]);
176 pre_last_prob = MAX_PROB - pre_fc->y_mode_prob[i][INTRA_MODES - 2];
177 cur_last_prob = MAX_PROB - cur_fc->y_mode_prob[i][INTRA_MODES - 2];
179 diff += (int)counts->y_mode[i][INTRA_MODES - 1] *
180 (pre_last_prob - cur_last_prob);
184 for (i = 0; i < INTRA_MODES; ++i) {
185 for (j = 0; j < INTRA_MODES - 1; ++j) {
186 diff += (int)counts->uv_mode[i][j] *
187 (pre_fc->uv_mode_prob[i][j] - cur_fc->uv_mode_prob[i][j]);
189 pre_last_prob = MAX_PROB - pre_fc->uv_mode_prob[i][INTRA_MODES - 2];
190 cur_last_prob = MAX_PROB - cur_fc->uv_mode_prob[i][INTRA_MODES - 2];
192 diff += (int)counts->uv_mode[i][INTRA_MODES - 1] *
193 (pre_last_prob - cur_last_prob);
197 for (i = 0; i < PARTITION_CONTEXTS; ++i) {
198 for (j = 0; j < PARTITION_TYPES - 1; ++j) {
199 diff += (int)counts->partition[i][j] *
200 (pre_fc->partition_prob[i][j] - cur_fc->partition_prob[i][j]);
202 pre_last_prob = MAX_PROB - pre_fc->partition_prob[i][PARTITION_TYPES - 2];
203 cur_last_prob = MAX_PROB - cur_fc->partition_prob[i][PARTITION_TYPES - 2];
205 diff += (int)counts->partition[i][PARTITION_TYPES - 1] *
206 (pre_last_prob - cur_last_prob);
210 for (i = 0; i < TX_SIZES; ++i) {
211 for (j = 0; j < PLANE_TYPES; ++j) {
212 for (k = 0; k < REF_TYPES; ++k) {
213 for (l = 0; l < COEF_BANDS; ++l) {
214 for (m = 0; m < BAND_COEFF_CONTEXTS(l); ++m) {
215 for (n = 0; n < UNCONSTRAINED_NODES; ++n) {
216 diff += (int)counts->coef[i][j][k][l][m][n] *
217 (pre_fc->coef_probs[i][j][k][l][m][n] -
218 cur_fc->coef_probs[i][j][k][l][m][n]);
223 pre_fc->coef_probs[i][j][k][l][m][UNCONSTRAINED_NODES - 1];
226 cur_fc->coef_probs[i][j][k][l][m][UNCONSTRAINED_NODES - 1];
228 diff += (int)counts->coef[i][j][k][l][m][UNCONSTRAINED_NODES] *
229 (pre_last_prob - cur_last_prob);
236 // switchable_interp_prob
237 for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i) {
238 for (j = 0; j < SWITCHABLE_FILTERS - 1; ++j) {
239 diff += (int)counts->switchable_interp[i][j] *
240 (pre_fc->switchable_interp_prob[i][j] -
241 cur_fc->switchable_interp_prob[i][j]);
244 MAX_PROB - pre_fc->switchable_interp_prob[i][SWITCHABLE_FILTERS - 2];
246 MAX_PROB - cur_fc->switchable_interp_prob[i][SWITCHABLE_FILTERS - 2];
248 diff += (int)counts->switchable_interp[i][SWITCHABLE_FILTERS - 1] *
249 (pre_last_prob - cur_last_prob);
253 for (i = 0; i < INTER_MODE_CONTEXTS; ++i) {
254 for (j = 0; j < INTER_MODES - 1; ++j) {
255 diff += (int)counts->inter_mode[i][j] *
256 (pre_fc->inter_mode_probs[i][j] - cur_fc->inter_mode_probs[i][j]);
258 pre_last_prob = MAX_PROB - pre_fc->inter_mode_probs[i][INTER_MODES - 2];
259 cur_last_prob = MAX_PROB - cur_fc->inter_mode_probs[i][INTER_MODES - 2];
261 diff += (int)counts->inter_mode[i][INTER_MODES - 1] *
262 (pre_last_prob - cur_last_prob);
266 for (i = 0; i < INTRA_INTER_CONTEXTS; ++i) {
267 diff += (int)counts->intra_inter[i][0] *
268 (pre_fc->intra_inter_prob[i] - cur_fc->intra_inter_prob[i]);
270 pre_last_prob = MAX_PROB - pre_fc->intra_inter_prob[i];
271 cur_last_prob = MAX_PROB - cur_fc->intra_inter_prob[i];
273 diff += (int)counts->intra_inter[i][1] * (pre_last_prob - cur_last_prob);
277 for (i = 0; i < COMP_INTER_CONTEXTS; ++i) {
278 diff += (int)counts->comp_inter[i][0] *
279 (pre_fc->comp_inter_prob[i] - cur_fc->comp_inter_prob[i]);
281 pre_last_prob = MAX_PROB - pre_fc->comp_inter_prob[i];
282 cur_last_prob = MAX_PROB - cur_fc->comp_inter_prob[i];
284 diff += (int)counts->comp_inter[i][1] * (pre_last_prob - cur_last_prob);
288 for (i = 0; i < REF_CONTEXTS; ++i) {
289 for (j = 0; j < 2; ++j) {
290 diff += (int)counts->single_ref[i][j][0] *
291 (pre_fc->single_ref_prob[i][j] - cur_fc->single_ref_prob[i][j]);
293 pre_last_prob = MAX_PROB - pre_fc->single_ref_prob[i][j];
294 cur_last_prob = MAX_PROB - cur_fc->single_ref_prob[i][j];
297 (int)counts->single_ref[i][j][1] * (pre_last_prob - cur_last_prob);
302 for (i = 0; i < REF_CONTEXTS; ++i) {
303 diff += (int)counts->comp_ref[i][0] *
304 (pre_fc->comp_ref_prob[i] - cur_fc->comp_ref_prob[i]);
306 pre_last_prob = MAX_PROB - pre_fc->comp_ref_prob[i];
307 cur_last_prob = MAX_PROB - cur_fc->comp_ref_prob[i];
309 diff += (int)counts->comp_ref[i][1] * (pre_last_prob - cur_last_prob);
313 for (i = 0; i < TX_SIZE_CONTEXTS; ++i) {
315 for (j = 0; j < TX_SIZES - 1; ++j) {
316 diff += (int)counts->tx.p32x32[i][j] *
317 (pre_fc->tx_probs.p32x32[i][j] - cur_fc->tx_probs.p32x32[i][j]);
319 pre_last_prob = MAX_PROB - pre_fc->tx_probs.p32x32[i][TX_SIZES - 2];
320 cur_last_prob = MAX_PROB - cur_fc->tx_probs.p32x32[i][TX_SIZES - 2];
322 diff += (int)counts->tx.p32x32[i][TX_SIZES - 1] *
323 (pre_last_prob - cur_last_prob);
326 for (j = 0; j < TX_SIZES - 2; ++j) {
327 diff += (int)counts->tx.p16x16[i][j] *
328 (pre_fc->tx_probs.p16x16[i][j] - cur_fc->tx_probs.p16x16[i][j]);
330 pre_last_prob = MAX_PROB - pre_fc->tx_probs.p16x16[i][TX_SIZES - 3];
331 cur_last_prob = MAX_PROB - cur_fc->tx_probs.p16x16[i][TX_SIZES - 3];
333 diff += (int)counts->tx.p16x16[i][TX_SIZES - 2] *
334 (pre_last_prob - cur_last_prob);
337 for (j = 0; j < TX_SIZES - 3; ++j) {
338 diff += (int)counts->tx.p8x8[i][j] *
339 (pre_fc->tx_probs.p8x8[i][j] - cur_fc->tx_probs.p8x8[i][j]);
341 pre_last_prob = MAX_PROB - pre_fc->tx_probs.p8x8[i][TX_SIZES - 4];
342 cur_last_prob = MAX_PROB - cur_fc->tx_probs.p8x8[i][TX_SIZES - 4];
345 (int)counts->tx.p8x8[i][TX_SIZES - 3] * (pre_last_prob - cur_last_prob);
349 for (i = 0; i < SKIP_CONTEXTS; ++i) {
350 diff += (int)counts->skip[i][0] *
351 (pre_fc->skip_probs[i] - cur_fc->skip_probs[i]);
353 pre_last_prob = MAX_PROB - pre_fc->skip_probs[i];
354 cur_last_prob = MAX_PROB - cur_fc->skip_probs[i];
356 diff += (int)counts->skip[i][1] * (pre_last_prob - cur_last_prob);
360 for (i = 0; i < MV_JOINTS - 1; ++i) {
361 diff += (int)counts->mv.joints[i] *
362 (pre_fc->nmvc.joints[i] - cur_fc->nmvc.joints[i]);
364 pre_last_prob = MAX_PROB - pre_fc->nmvc.joints[MV_JOINTS - 2];
365 cur_last_prob = MAX_PROB - cur_fc->nmvc.joints[MV_JOINTS - 2];
368 (int)counts->mv.joints[MV_JOINTS - 1] * (pre_last_prob - cur_last_prob);
370 for (i = 0; i < 2; ++i) {
371 const nmv_component_counts *nmv_count = &counts->mv.comps[i];
372 const nmv_component *pre_nmv_prob = &pre_fc->nmvc.comps[i];
373 const nmv_component *cur_nmv_prob = &cur_fc->nmvc.comps[i];
376 diff += (int)nmv_count->sign[0] * (pre_nmv_prob->sign - cur_nmv_prob->sign);
378 pre_last_prob = MAX_PROB - pre_nmv_prob->sign;
379 cur_last_prob = MAX_PROB - cur_nmv_prob->sign;
381 diff += (int)nmv_count->sign[1] * (pre_last_prob - cur_last_prob);
384 for (j = 0; j < MV_CLASSES - 1; ++j) {
385 diff += (int)nmv_count->classes[j] *
386 (pre_nmv_prob->classes[j] - cur_nmv_prob->classes[j]);
388 pre_last_prob = MAX_PROB - pre_nmv_prob->classes[MV_CLASSES - 2];
389 cur_last_prob = MAX_PROB - cur_nmv_prob->classes[MV_CLASSES - 2];
391 diff += (int)nmv_count->classes[MV_CLASSES - 1] *
392 (pre_last_prob - cur_last_prob);
395 for (j = 0; j < CLASS0_SIZE - 1; ++j) {
396 diff += (int)nmv_count->class0[j] *
397 (pre_nmv_prob->class0[j] - cur_nmv_prob->class0[j]);
399 pre_last_prob = MAX_PROB - pre_nmv_prob->class0[CLASS0_SIZE - 2];
400 cur_last_prob = MAX_PROB - cur_nmv_prob->class0[CLASS0_SIZE - 2];
402 diff += (int)nmv_count->class0[CLASS0_SIZE - 1] *
403 (pre_last_prob - cur_last_prob);
406 for (j = 0; j < MV_OFFSET_BITS; ++j) {
407 diff += (int)nmv_count->bits[j][0] *
408 (pre_nmv_prob->bits[j] - cur_nmv_prob->bits[j]);
410 pre_last_prob = MAX_PROB - pre_nmv_prob->bits[j];
411 cur_last_prob = MAX_PROB - cur_nmv_prob->bits[j];
413 diff += (int)nmv_count->bits[j][1] * (pre_last_prob - cur_last_prob);
417 for (j = 0; j < CLASS0_SIZE; ++j) {
418 for (k = 0; k < MV_FP_SIZE - 1; ++k) {
419 diff += (int)nmv_count->class0_fp[j][k] *
420 (pre_nmv_prob->class0_fp[j][k] - cur_nmv_prob->class0_fp[j][k]);
422 pre_last_prob = MAX_PROB - pre_nmv_prob->class0_fp[j][MV_FP_SIZE - 2];
423 cur_last_prob = MAX_PROB - cur_nmv_prob->class0_fp[j][MV_FP_SIZE - 2];
425 diff += (int)nmv_count->class0_fp[j][MV_FP_SIZE - 1] *
426 (pre_last_prob - cur_last_prob);
430 for (j = 0; j < MV_FP_SIZE - 1; ++j) {
432 (int)nmv_count->fp[j] * (pre_nmv_prob->fp[j] - cur_nmv_prob->fp[j]);
434 pre_last_prob = MAX_PROB - pre_nmv_prob->fp[MV_FP_SIZE - 2];
435 cur_last_prob = MAX_PROB - cur_nmv_prob->fp[MV_FP_SIZE - 2];
438 (int)nmv_count->fp[MV_FP_SIZE - 1] * (pre_last_prob - cur_last_prob);
441 diff += (int)nmv_count->class0_hp[0] *
442 (pre_nmv_prob->class0_hp - cur_nmv_prob->class0_hp);
444 pre_last_prob = MAX_PROB - pre_nmv_prob->class0_hp;
445 cur_last_prob = MAX_PROB - cur_nmv_prob->class0_hp;
447 diff += (int)nmv_count->class0_hp[1] * (pre_last_prob - cur_last_prob);
450 diff += (int)nmv_count->hp[0] * (pre_nmv_prob->hp - cur_nmv_prob->hp);
452 pre_last_prob = MAX_PROB - pre_nmv_prob->hp;
453 cur_last_prob = MAX_PROB - cur_nmv_prob->hp;
455 diff += (int)nmv_count->hp[1] * (pre_last_prob - cur_last_prob);
460 #endif // !CONFIG_REALTIME_ONLY
462 // Test for whether to calculate metrics for the frame.
463 static int is_psnr_calc_enabled(const VP9_COMP *cpi) {
464 const VP9_COMMON *const cm = &cpi->common;
465 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
467 return cpi->b_calculate_psnr && (oxcf->pass != 1) && cm->show_frame;
470 /* clang-format off */
471 const Vp9LevelSpec vp9_level_defs[VP9_LEVELS] = {
472 // sample rate size breadth bitrate cpb
473 { LEVEL_1, 829440, 36864, 512, 200, 400, 2, 1, 4, 8 },
474 { LEVEL_1_1, 2764800, 73728, 768, 800, 1000, 2, 1, 4, 8 },
475 { LEVEL_2, 4608000, 122880, 960, 1800, 1500, 2, 1, 4, 8 },
476 { LEVEL_2_1, 9216000, 245760, 1344, 3600, 2800, 2, 2, 4, 8 },
477 { LEVEL_3, 20736000, 552960, 2048, 7200, 6000, 2, 4, 4, 8 },
478 { LEVEL_3_1, 36864000, 983040, 2752, 12000, 10000, 2, 4, 4, 8 },
479 { LEVEL_4, 83558400, 2228224, 4160, 18000, 16000, 4, 4, 4, 8 },
480 { LEVEL_4_1, 160432128, 2228224, 4160, 30000, 18000, 4, 4, 5, 6 },
481 { LEVEL_5, 311951360, 8912896, 8384, 60000, 36000, 6, 8, 6, 4 },
482 { LEVEL_5_1, 588251136, 8912896, 8384, 120000, 46000, 8, 8, 10, 4 },
483 // TODO(huisu): update max_cpb_size for level 5_2 ~ 6_2 when
484 // they are finalized (currently tentative).
485 { LEVEL_5_2, 1176502272, 8912896, 8384, 180000, 90000, 8, 8, 10, 4 },
486 { LEVEL_6, 1176502272, 35651584, 16832, 180000, 90000, 8, 16, 10, 4 },
487 { LEVEL_6_1, 2353004544u, 35651584, 16832, 240000, 180000, 8, 16, 10, 4 },
488 { LEVEL_6_2, 4706009088u, 35651584, 16832, 480000, 360000, 8, 16, 10, 4 },
490 /* clang-format on */
492 static const char *level_fail_messages[TARGET_LEVEL_FAIL_IDS] = {
493 "The average bit-rate is too high.",
494 "The picture size is too large.",
495 "The picture width/height is too large.",
496 "The luma sample rate is too large.",
497 "The CPB size is too large.",
498 "The compression ratio is too small",
499 "Too many column tiles are used.",
500 "The alt-ref distance is too small.",
501 "Too many reference buffers are used."
504 static INLINE void Scale2Ratio(VPX_SCALING mode, int *hr, int *hs) {
519 assert(mode == ONETWO);
526 // Mark all inactive blocks as active. Other segmentation features may be set
527 // so memset cannot be used, instead only inactive blocks should be reset.
528 static void suppress_active_map(VP9_COMP *cpi) {
529 unsigned char *const seg_map = cpi->segmentation_map;
531 if (cpi->active_map.enabled || cpi->active_map.update) {
532 const int rows = cpi->common.mi_rows;
533 const int cols = cpi->common.mi_cols;
536 for (i = 0; i < rows * cols; ++i)
537 if (seg_map[i] == AM_SEGMENT_ID_INACTIVE)
538 seg_map[i] = AM_SEGMENT_ID_ACTIVE;
542 static void apply_active_map(VP9_COMP *cpi) {
543 struct segmentation *const seg = &cpi->common.seg;
544 unsigned char *const seg_map = cpi->segmentation_map;
545 const unsigned char *const active_map = cpi->active_map.map;
548 assert(AM_SEGMENT_ID_ACTIVE == CR_SEGMENT_ID_BASE);
550 if (frame_is_intra_only(&cpi->common)) {
551 cpi->active_map.enabled = 0;
552 cpi->active_map.update = 1;
555 if (cpi->active_map.update) {
556 if (cpi->active_map.enabled) {
557 for (i = 0; i < cpi->common.mi_rows * cpi->common.mi_cols; ++i)
558 if (seg_map[i] == AM_SEGMENT_ID_ACTIVE) seg_map[i] = active_map[i];
559 vp9_enable_segmentation(seg);
560 vp9_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_SKIP);
561 vp9_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF);
562 // Setting the data to -MAX_LOOP_FILTER will result in the computed loop
563 // filter level being zero regardless of the value of seg->abs_delta.
564 vp9_set_segdata(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF,
567 vp9_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_SKIP);
568 vp9_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF);
570 seg->update_data = 1;
574 cpi->active_map.update = 0;
578 static void apply_roi_map(VP9_COMP *cpi) {
579 VP9_COMMON *cm = &cpi->common;
580 struct segmentation *const seg = &cm->seg;
581 vpx_roi_map_t *roi = &cpi->roi;
582 const int *delta_q = roi->delta_q;
583 const int *delta_lf = roi->delta_lf;
584 const int *skip = roi->skip;
586 int internal_delta_q[MAX_SEGMENTS];
588 static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG,
591 // TODO(jianj): Investigate why ROI not working in speed < 5 or in non
593 if (cpi->oxcf.mode != REALTIME || cpi->oxcf.speed < 5) return;
594 if (!roi->enabled) return;
596 memcpy(&ref_frame, roi->ref_frame, sizeof(ref_frame));
598 vp9_enable_segmentation(seg);
599 vp9_clearall_segfeatures(seg);
600 // Select delta coding method;
601 seg->abs_delta = SEGMENT_DELTADATA;
603 memcpy(cpi->segmentation_map, roi->roi_map, (cm->mi_rows * cm->mi_cols));
605 for (i = 0; i < MAX_SEGMENTS; ++i) {
606 // Translate the external delta q values to internal values.
607 internal_delta_q[i] = vp9_quantizer_to_qindex(abs(delta_q[i]));
608 if (delta_q[i] < 0) internal_delta_q[i] = -internal_delta_q[i];
609 vp9_disable_segfeature(seg, i, SEG_LVL_ALT_Q);
610 vp9_disable_segfeature(seg, i, SEG_LVL_ALT_LF);
611 if (internal_delta_q[i] != 0) {
612 vp9_enable_segfeature(seg, i, SEG_LVL_ALT_Q);
613 vp9_set_segdata(seg, i, SEG_LVL_ALT_Q, internal_delta_q[i]);
615 if (delta_lf[i] != 0) {
616 vp9_enable_segfeature(seg, i, SEG_LVL_ALT_LF);
617 vp9_set_segdata(seg, i, SEG_LVL_ALT_LF, delta_lf[i]);
620 vp9_enable_segfeature(seg, i, SEG_LVL_SKIP);
621 vp9_set_segdata(seg, i, SEG_LVL_SKIP, skip[i]);
623 if (ref_frame[i] >= 0) {
625 // ALTREF is not used as reference for nonrd_pickmode with 0 lag.
626 if (ref_frame[i] == ALTREF_FRAME && cpi->sf.use_nonrd_pick_mode)
628 // If GOLDEN is selected, make sure it's set as reference.
629 if (ref_frame[i] == GOLDEN_FRAME &&
630 !(cpi->ref_frame_flags & flag_list[ref_frame[i]])) {
633 // GOLDEN was updated in previous encoded frame, so GOLDEN and LAST are
635 if (ref_frame[i] == GOLDEN_FRAME && cpi->rc.frames_since_golden == 0)
636 ref_frame[i] = LAST_FRAME;
638 vp9_enable_segfeature(seg, i, SEG_LVL_REF_FRAME);
639 vp9_set_segdata(seg, i, SEG_LVL_REF_FRAME, ref_frame[i]);
646 static void init_level_info(Vp9LevelInfo *level_info) {
647 Vp9LevelStats *const level_stats = &level_info->level_stats;
648 Vp9LevelSpec *const level_spec = &level_info->level_spec;
650 memset(level_stats, 0, sizeof(*level_stats));
651 memset(level_spec, 0, sizeof(*level_spec));
652 level_spec->level = LEVEL_UNKNOWN;
653 level_spec->min_altref_distance = INT_MAX;
656 static int check_seg_range(int seg_data[8], int range) {
657 return !(abs(seg_data[0]) > range || abs(seg_data[1]) > range ||
658 abs(seg_data[2]) > range || abs(seg_data[3]) > range ||
659 abs(seg_data[4]) > range || abs(seg_data[5]) > range ||
660 abs(seg_data[6]) > range || abs(seg_data[7]) > range);
663 VP9_LEVEL vp9_get_level(const Vp9LevelSpec *const level_spec) {
665 const Vp9LevelSpec *this_level;
667 vpx_clear_system_state();
669 for (i = 0; i < VP9_LEVELS; ++i) {
670 this_level = &vp9_level_defs[i];
671 if ((double)level_spec->max_luma_sample_rate >
672 (double)this_level->max_luma_sample_rate *
673 (1 + SAMPLE_RATE_GRACE_P) ||
674 level_spec->max_luma_picture_size > this_level->max_luma_picture_size ||
675 level_spec->max_luma_picture_breadth >
676 this_level->max_luma_picture_breadth ||
677 level_spec->average_bitrate > this_level->average_bitrate ||
678 level_spec->max_cpb_size > this_level->max_cpb_size ||
679 level_spec->compression_ratio < this_level->compression_ratio ||
680 level_spec->max_col_tiles > this_level->max_col_tiles ||
681 level_spec->min_altref_distance < this_level->min_altref_distance ||
682 level_spec->max_ref_frame_buffers > this_level->max_ref_frame_buffers)
686 return (i == VP9_LEVELS) ? LEVEL_UNKNOWN : vp9_level_defs[i].level;
689 int vp9_set_roi_map(VP9_COMP *cpi, unsigned char *map, unsigned int rows,
690 unsigned int cols, int delta_q[8], int delta_lf[8],
691 int skip[8], int ref_frame[8]) {
692 VP9_COMMON *cm = &cpi->common;
693 vpx_roi_map_t *roi = &cpi->roi;
694 const int range = 63;
695 const int ref_frame_range = 3; // Alt-ref
696 const int skip_range = 1;
697 const int frame_rows = cpi->common.mi_rows;
698 const int frame_cols = cpi->common.mi_cols;
700 // Check number of rows and columns match
701 if (frame_rows != (int)rows || frame_cols != (int)cols) {
705 if (!check_seg_range(delta_q, range) || !check_seg_range(delta_lf, range) ||
706 !check_seg_range(ref_frame, ref_frame_range) ||
707 !check_seg_range(skip, skip_range))
710 // Also disable segmentation if no deltas are specified.
712 (!(delta_q[0] | delta_q[1] | delta_q[2] | delta_q[3] | delta_q[4] |
713 delta_q[5] | delta_q[6] | delta_q[7] | delta_lf[0] | delta_lf[1] |
714 delta_lf[2] | delta_lf[3] | delta_lf[4] | delta_lf[5] | delta_lf[6] |
715 delta_lf[7] | skip[0] | skip[1] | skip[2] | skip[3] | skip[4] |
716 skip[5] | skip[6] | skip[7]) &&
717 (ref_frame[0] == -1 && ref_frame[1] == -1 && ref_frame[2] == -1 &&
718 ref_frame[3] == -1 && ref_frame[4] == -1 && ref_frame[5] == -1 &&
719 ref_frame[6] == -1 && ref_frame[7] == -1))) {
720 vp9_disable_segmentation(&cm->seg);
721 cpi->roi.enabled = 0;
726 vpx_free(roi->roi_map);
729 CHECK_MEM_ERROR(cm, roi->roi_map, vpx_malloc(rows * cols));
731 // Copy to ROI sturcture in the compressor.
732 memcpy(roi->roi_map, map, rows * cols);
733 memcpy(&roi->delta_q, delta_q, MAX_SEGMENTS * sizeof(delta_q[0]));
734 memcpy(&roi->delta_lf, delta_lf, MAX_SEGMENTS * sizeof(delta_lf[0]));
735 memcpy(&roi->skip, skip, MAX_SEGMENTS * sizeof(skip[0]));
736 memcpy(&roi->ref_frame, ref_frame, MAX_SEGMENTS * sizeof(ref_frame[0]));
744 int vp9_set_active_map(VP9_COMP *cpi, unsigned char *new_map_16x16, int rows,
746 if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols) {
747 unsigned char *const active_map_8x8 = cpi->active_map.map;
748 const int mi_rows = cpi->common.mi_rows;
749 const int mi_cols = cpi->common.mi_cols;
750 cpi->active_map.update = 1;
753 for (r = 0; r < mi_rows; ++r) {
754 for (c = 0; c < mi_cols; ++c) {
755 active_map_8x8[r * mi_cols + c] =
756 new_map_16x16[(r >> 1) * cols + (c >> 1)]
757 ? AM_SEGMENT_ID_ACTIVE
758 : AM_SEGMENT_ID_INACTIVE;
761 cpi->active_map.enabled = 1;
763 cpi->active_map.enabled = 0;
771 int vp9_get_active_map(VP9_COMP *cpi, unsigned char *new_map_16x16, int rows,
773 if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols &&
775 unsigned char *const seg_map_8x8 = cpi->segmentation_map;
776 const int mi_rows = cpi->common.mi_rows;
777 const int mi_cols = cpi->common.mi_cols;
778 memset(new_map_16x16, !cpi->active_map.enabled, rows * cols);
779 if (cpi->active_map.enabled) {
781 for (r = 0; r < mi_rows; ++r) {
782 for (c = 0; c < mi_cols; ++c) {
783 // Cyclic refresh segments are considered active despite not having
784 // AM_SEGMENT_ID_ACTIVE
785 new_map_16x16[(r >> 1) * cols + (c >> 1)] |=
786 seg_map_8x8[r * mi_cols + c] != AM_SEGMENT_ID_INACTIVE;
796 void vp9_set_high_precision_mv(VP9_COMP *cpi, int allow_high_precision_mv) {
797 MACROBLOCK *const mb = &cpi->td.mb;
798 cpi->common.allow_high_precision_mv = allow_high_precision_mv;
799 if (cpi->common.allow_high_precision_mv) {
800 mb->mvcost = mb->nmvcost_hp;
801 mb->mvsadcost = mb->nmvsadcost_hp;
803 mb->mvcost = mb->nmvcost;
804 mb->mvsadcost = mb->nmvsadcost;
808 static void setup_frame(VP9_COMP *cpi) {
809 VP9_COMMON *const cm = &cpi->common;
810 // Set up entropy context depending on frame type. The decoder mandates
811 // the use of the default context, index 0, for keyframes and inter
812 // frames where the error_resilient_mode or intra_only flag is set. For
813 // other inter-frames the encoder currently uses only two contexts;
814 // context 1 for ALTREF frames and context 0 for the others.
815 if (frame_is_intra_only(cm) || cm->error_resilient_mode) {
816 vp9_setup_past_independence(cm);
818 if (!cpi->use_svc) cm->frame_context_idx = cpi->refresh_alt_ref_frame;
821 // TODO(jingning): Overwrite the frame_context_idx index in multi-layer ARF
822 // case. Need some further investigation on if we could apply this to single
823 // layer ARF case as well.
824 if (cpi->multi_layer_arf && !cpi->use_svc) {
825 GF_GROUP *const gf_group = &cpi->twopass.gf_group;
826 const int gf_group_index = gf_group->index;
827 const int boost_frame =
828 !cpi->rc.is_src_frame_alt_ref &&
829 (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame);
831 // frame_context_idx Frame Type
832 // 0 Intra only frame, base layer ARF
833 // 1 ARFs with layer depth = 2,3
834 // 2 ARFs with layer depth > 3
835 // 3 Non-boosted frames
836 if (frame_is_intra_only(cm)) {
837 cm->frame_context_idx = 0;
838 } else if (boost_frame) {
839 if (gf_group->rf_level[gf_group_index] == GF_ARF_STD)
840 cm->frame_context_idx = 0;
841 else if (gf_group->layer_depth[gf_group_index] <= 3)
842 cm->frame_context_idx = 1;
844 cm->frame_context_idx = 2;
846 cm->frame_context_idx = 3;
850 if (cm->frame_type == KEY_FRAME) {
851 cpi->refresh_golden_frame = 1;
852 cpi->refresh_alt_ref_frame = 1;
853 vp9_zero(cpi->interp_filter_selected);
855 *cm->fc = cm->frame_contexts[cm->frame_context_idx];
856 vp9_zero(cpi->interp_filter_selected[0]);
860 static void vp9_enc_setup_mi(VP9_COMMON *cm) {
862 cm->mi = cm->mip + cm->mi_stride + 1;
863 memset(cm->mip, 0, cm->mi_stride * (cm->mi_rows + 1) * sizeof(*cm->mip));
864 cm->prev_mi = cm->prev_mip + cm->mi_stride + 1;
865 // Clear top border row
866 memset(cm->prev_mip, 0, sizeof(*cm->prev_mip) * cm->mi_stride);
867 // Clear left border column
868 for (i = 1; i < cm->mi_rows + 1; ++i)
869 memset(&cm->prev_mip[i * cm->mi_stride], 0, sizeof(*cm->prev_mip));
871 cm->mi_grid_visible = cm->mi_grid_base + cm->mi_stride + 1;
872 cm->prev_mi_grid_visible = cm->prev_mi_grid_base + cm->mi_stride + 1;
874 memset(cm->mi_grid_base, 0,
875 cm->mi_stride * (cm->mi_rows + 1) * sizeof(*cm->mi_grid_base));
878 static int vp9_enc_alloc_mi(VP9_COMMON *cm, int mi_size) {
879 cm->mip = vpx_calloc(mi_size, sizeof(*cm->mip));
880 if (!cm->mip) return 1;
881 cm->prev_mip = vpx_calloc(mi_size, sizeof(*cm->prev_mip));
882 if (!cm->prev_mip) return 1;
883 cm->mi_alloc_size = mi_size;
885 cm->mi_grid_base = (MODE_INFO **)vpx_calloc(mi_size, sizeof(MODE_INFO *));
886 if (!cm->mi_grid_base) return 1;
887 cm->prev_mi_grid_base =
888 (MODE_INFO **)vpx_calloc(mi_size, sizeof(MODE_INFO *));
889 if (!cm->prev_mi_grid_base) return 1;
894 static void vp9_enc_free_mi(VP9_COMMON *cm) {
897 vpx_free(cm->prev_mip);
899 vpx_free(cm->mi_grid_base);
900 cm->mi_grid_base = NULL;
901 vpx_free(cm->prev_mi_grid_base);
902 cm->prev_mi_grid_base = NULL;
903 cm->mi_alloc_size = 0;
906 static void vp9_swap_mi_and_prev_mi(VP9_COMMON *cm) {
907 // Current mip will be the prev_mip for the next frame.
908 MODE_INFO **temp_base = cm->prev_mi_grid_base;
909 MODE_INFO *temp = cm->prev_mip;
911 // Skip update prev_mi frame in show_existing_frame mode.
912 if (cm->show_existing_frame) return;
914 cm->prev_mip = cm->mip;
917 // Update the upper left visible macroblock ptrs.
918 cm->mi = cm->mip + cm->mi_stride + 1;
919 cm->prev_mi = cm->prev_mip + cm->mi_stride + 1;
921 cm->prev_mi_grid_base = cm->mi_grid_base;
922 cm->mi_grid_base = temp_base;
923 cm->mi_grid_visible = cm->mi_grid_base + cm->mi_stride + 1;
924 cm->prev_mi_grid_visible = cm->prev_mi_grid_base + cm->mi_stride + 1;
927 void vp9_initialize_enc(void) {
928 static volatile int init_done = 0;
934 vp9_init_intra_predictors();
936 vp9_rc_init_minq_luts();
937 vp9_entropy_mv_init();
938 #if !CONFIG_REALTIME_ONLY
939 vp9_temporal_filter_init();
945 static void dealloc_compressor_data(VP9_COMP *cpi) {
946 VP9_COMMON *const cm = &cpi->common;
949 vpx_free(cpi->mbmi_ext_base);
950 cpi->mbmi_ext_base = NULL;
952 vpx_free(cpi->tile_data);
953 cpi->tile_data = NULL;
955 vpx_free(cpi->segmentation_map);
956 cpi->segmentation_map = NULL;
957 vpx_free(cpi->coding_context.last_frame_seg_map_copy);
958 cpi->coding_context.last_frame_seg_map_copy = NULL;
960 vpx_free(cpi->nmvcosts[0]);
961 vpx_free(cpi->nmvcosts[1]);
962 cpi->nmvcosts[0] = NULL;
963 cpi->nmvcosts[1] = NULL;
965 vpx_free(cpi->nmvcosts_hp[0]);
966 vpx_free(cpi->nmvcosts_hp[1]);
967 cpi->nmvcosts_hp[0] = NULL;
968 cpi->nmvcosts_hp[1] = NULL;
970 vpx_free(cpi->nmvsadcosts[0]);
971 vpx_free(cpi->nmvsadcosts[1]);
972 cpi->nmvsadcosts[0] = NULL;
973 cpi->nmvsadcosts[1] = NULL;
975 vpx_free(cpi->nmvsadcosts_hp[0]);
976 vpx_free(cpi->nmvsadcosts_hp[1]);
977 cpi->nmvsadcosts_hp[0] = NULL;
978 cpi->nmvsadcosts_hp[1] = NULL;
980 vpx_free(cpi->skin_map);
981 cpi->skin_map = NULL;
983 vpx_free(cpi->prev_partition);
984 cpi->prev_partition = NULL;
986 vpx_free(cpi->svc.prev_partition_svc);
987 cpi->svc.prev_partition_svc = NULL;
989 vpx_free(cpi->prev_segment_id);
990 cpi->prev_segment_id = NULL;
992 vpx_free(cpi->prev_variance_low);
993 cpi->prev_variance_low = NULL;
995 vpx_free(cpi->copied_frame_cnt);
996 cpi->copied_frame_cnt = NULL;
998 vpx_free(cpi->content_state_sb_fd);
999 cpi->content_state_sb_fd = NULL;
1001 vpx_free(cpi->count_arf_frame_usage);
1002 cpi->count_arf_frame_usage = NULL;
1003 vpx_free(cpi->count_lastgolden_frame_usage);
1004 cpi->count_lastgolden_frame_usage = NULL;
1006 vp9_cyclic_refresh_free(cpi->cyclic_refresh);
1007 cpi->cyclic_refresh = NULL;
1009 vpx_free(cpi->active_map.map);
1010 cpi->active_map.map = NULL;
1012 vpx_free(cpi->roi.roi_map);
1013 cpi->roi.roi_map = NULL;
1015 vpx_free(cpi->consec_zero_mv);
1016 cpi->consec_zero_mv = NULL;
1018 vpx_free(cpi->mb_wiener_variance);
1019 cpi->mb_wiener_variance = NULL;
1021 vpx_free(cpi->mi_ssim_rdmult_scaling_factors);
1022 cpi->mi_ssim_rdmult_scaling_factors = NULL;
1024 vp9_free_ref_frame_buffers(cm->buffer_pool);
1025 #if CONFIG_VP9_POSTPROC
1026 vp9_free_postproc_buffers(cm);
1028 vp9_free_context_buffers(cm);
1030 vpx_free_frame_buffer(&cpi->last_frame_uf);
1031 vpx_free_frame_buffer(&cpi->scaled_source);
1032 vpx_free_frame_buffer(&cpi->scaled_last_source);
1033 vpx_free_frame_buffer(&cpi->alt_ref_buffer);
1034 #ifdef ENABLE_KF_DENOISE
1035 vpx_free_frame_buffer(&cpi->raw_unscaled_source);
1036 vpx_free_frame_buffer(&cpi->raw_scaled_source);
1039 vp9_lookahead_destroy(cpi->lookahead);
1041 vpx_free(cpi->tile_tok[0][0]);
1042 cpi->tile_tok[0][0] = 0;
1044 vpx_free(cpi->tplist[0][0]);
1045 cpi->tplist[0][0] = NULL;
1047 vp9_free_pc_tree(&cpi->td);
1049 for (i = 0; i < cpi->svc.number_spatial_layers; ++i) {
1050 LAYER_CONTEXT *const lc = &cpi->svc.layer_context[i];
1051 vpx_free(lc->rc_twopass_stats_in.buf);
1052 lc->rc_twopass_stats_in.buf = NULL;
1053 lc->rc_twopass_stats_in.sz = 0;
1056 if (cpi->source_diff_var != NULL) {
1057 vpx_free(cpi->source_diff_var);
1058 cpi->source_diff_var = NULL;
1061 for (i = 0; i < MAX_LAG_BUFFERS; ++i) {
1062 vpx_free_frame_buffer(&cpi->svc.scaled_frames[i]);
1064 memset(&cpi->svc.scaled_frames[0], 0,
1065 MAX_LAG_BUFFERS * sizeof(cpi->svc.scaled_frames[0]));
1067 vpx_free_frame_buffer(&cpi->svc.scaled_temp);
1068 memset(&cpi->svc.scaled_temp, 0, sizeof(cpi->svc.scaled_temp));
1070 vpx_free_frame_buffer(&cpi->svc.empty_frame.img);
1071 memset(&cpi->svc.empty_frame, 0, sizeof(cpi->svc.empty_frame));
1073 vp9_free_svc_cyclic_refresh(cpi);
1076 static void save_coding_context(VP9_COMP *cpi) {
1077 CODING_CONTEXT *const cc = &cpi->coding_context;
1078 VP9_COMMON *cm = &cpi->common;
1080 // Stores a snapshot of key state variables which can subsequently be
1081 // restored with a call to vp9_restore_coding_context. These functions are
1082 // intended for use in a re-code loop in vp9_compress_frame where the
1083 // quantizer value is adjusted between loop iterations.
1084 vp9_copy(cc->nmvjointcost, cpi->td.mb.nmvjointcost);
1086 memcpy(cc->nmvcosts[0], cpi->nmvcosts[0],
1087 MV_VALS * sizeof(*cpi->nmvcosts[0]));
1088 memcpy(cc->nmvcosts[1], cpi->nmvcosts[1],
1089 MV_VALS * sizeof(*cpi->nmvcosts[1]));
1090 memcpy(cc->nmvcosts_hp[0], cpi->nmvcosts_hp[0],
1091 MV_VALS * sizeof(*cpi->nmvcosts_hp[0]));
1092 memcpy(cc->nmvcosts_hp[1], cpi->nmvcosts_hp[1],
1093 MV_VALS * sizeof(*cpi->nmvcosts_hp[1]));
1095 vp9_copy(cc->segment_pred_probs, cm->seg.pred_probs);
1097 memcpy(cpi->coding_context.last_frame_seg_map_copy, cm->last_frame_seg_map,
1098 (cm->mi_rows * cm->mi_cols));
1100 vp9_copy(cc->last_ref_lf_deltas, cm->lf.last_ref_deltas);
1101 vp9_copy(cc->last_mode_lf_deltas, cm->lf.last_mode_deltas);
1106 static void restore_coding_context(VP9_COMP *cpi) {
1107 CODING_CONTEXT *const cc = &cpi->coding_context;
1108 VP9_COMMON *cm = &cpi->common;
1110 // Restore key state variables to the snapshot state stored in the
1111 // previous call to vp9_save_coding_context.
1112 vp9_copy(cpi->td.mb.nmvjointcost, cc->nmvjointcost);
1114 memcpy(cpi->nmvcosts[0], cc->nmvcosts[0], MV_VALS * sizeof(*cc->nmvcosts[0]));
1115 memcpy(cpi->nmvcosts[1], cc->nmvcosts[1], MV_VALS * sizeof(*cc->nmvcosts[1]));
1116 memcpy(cpi->nmvcosts_hp[0], cc->nmvcosts_hp[0],
1117 MV_VALS * sizeof(*cc->nmvcosts_hp[0]));
1118 memcpy(cpi->nmvcosts_hp[1], cc->nmvcosts_hp[1],
1119 MV_VALS * sizeof(*cc->nmvcosts_hp[1]));
1121 vp9_copy(cm->seg.pred_probs, cc->segment_pred_probs);
1123 memcpy(cm->last_frame_seg_map, cpi->coding_context.last_frame_seg_map_copy,
1124 (cm->mi_rows * cm->mi_cols));
1126 vp9_copy(cm->lf.last_ref_deltas, cc->last_ref_lf_deltas);
1127 vp9_copy(cm->lf.last_mode_deltas, cc->last_mode_lf_deltas);
1132 #if !CONFIG_REALTIME_ONLY
1133 static void configure_static_seg_features(VP9_COMP *cpi) {
1134 VP9_COMMON *const cm = &cpi->common;
1135 const RATE_CONTROL *const rc = &cpi->rc;
1136 struct segmentation *const seg = &cm->seg;
1138 int high_q = (int)(rc->avg_q > 48.0);
1141 // Disable and clear down for KF
1142 if (cm->frame_type == KEY_FRAME) {
1143 // Clear down the global segmentation map
1144 memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
1145 seg->update_map = 0;
1146 seg->update_data = 0;
1147 cpi->static_mb_pct = 0;
1149 // Disable segmentation
1150 vp9_disable_segmentation(seg);
1152 // Clear down the segment features.
1153 vp9_clearall_segfeatures(seg);
1154 } else if (cpi->refresh_alt_ref_frame) {
1155 // If this is an alt ref frame
1156 // Clear down the global segmentation map
1157 memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
1158 seg->update_map = 0;
1159 seg->update_data = 0;
1160 cpi->static_mb_pct = 0;
1162 // Disable segmentation and individual segment features by default
1163 vp9_disable_segmentation(seg);
1164 vp9_clearall_segfeatures(seg);
1166 // Scan frames from current to arf frame.
1167 // This function re-enables segmentation if appropriate.
1168 vp9_update_mbgraph_stats(cpi);
1170 // If segmentation was enabled set those features needed for the
1173 seg->update_map = 1;
1174 seg->update_data = 1;
1177 vp9_compute_qdelta(rc, rc->avg_q, rc->avg_q * 0.875, cm->bit_depth);
1178 vp9_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta - 2);
1179 vp9_set_segdata(seg, 1, SEG_LVL_ALT_LF, -2);
1181 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
1182 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_LF);
1184 // Where relevant assume segment data is delta data
1185 seg->abs_delta = SEGMENT_DELTADATA;
1187 } else if (seg->enabled) {
1188 // All other frames if segmentation has been enabled
1190 // First normal frame in a valid gf or alt ref group
1191 if (rc->frames_since_golden == 0) {
1192 // Set up segment features for normal frames in an arf group
1193 if (rc->source_alt_ref_active) {
1194 seg->update_map = 0;
1195 seg->update_data = 1;
1196 seg->abs_delta = SEGMENT_DELTADATA;
1199 vp9_compute_qdelta(rc, rc->avg_q, rc->avg_q * 1.125, cm->bit_depth);
1200 vp9_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta + 2);
1201 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
1203 vp9_set_segdata(seg, 1, SEG_LVL_ALT_LF, -2);
1204 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_LF);
1206 // Segment coding disabled for compred testing
1207 if (high_q || (cpi->static_mb_pct == 100)) {
1208 vp9_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME);
1209 vp9_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME);
1210 vp9_enable_segfeature(seg, 1, SEG_LVL_SKIP);
1213 // Disable segmentation and clear down features if alt ref
1214 // is not active for this group
1216 vp9_disable_segmentation(seg);
1218 memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
1220 seg->update_map = 0;
1221 seg->update_data = 0;
1223 vp9_clearall_segfeatures(seg);
1225 } else if (rc->is_src_frame_alt_ref) {
1226 // Special case where we are coding over the top of a previous
1228 // Segment coding disabled for compred testing
1230 // Enable ref frame features for segment 0 as well
1231 vp9_enable_segfeature(seg, 0, SEG_LVL_REF_FRAME);
1232 vp9_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME);
1234 // All mbs should use ALTREF_FRAME
1235 vp9_clear_segdata(seg, 0, SEG_LVL_REF_FRAME);
1236 vp9_set_segdata(seg, 0, SEG_LVL_REF_FRAME, ALTREF_FRAME);
1237 vp9_clear_segdata(seg, 1, SEG_LVL_REF_FRAME);
1238 vp9_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME);
1240 // Skip all MBs if high Q (0,0 mv and skip coeffs)
1242 vp9_enable_segfeature(seg, 0, SEG_LVL_SKIP);
1243 vp9_enable_segfeature(seg, 1, SEG_LVL_SKIP);
1245 // Enable data update
1246 seg->update_data = 1;
1248 // All other frames.
1250 // No updates.. leave things as they are.
1251 seg->update_map = 0;
1252 seg->update_data = 0;
1256 #endif // !CONFIG_REALTIME_ONLY
1258 static void update_reference_segmentation_map(VP9_COMP *cpi) {
1259 VP9_COMMON *const cm = &cpi->common;
1260 MODE_INFO **mi_8x8_ptr = cm->mi_grid_visible;
1261 uint8_t *cache_ptr = cm->last_frame_seg_map;
1264 for (row = 0; row < cm->mi_rows; row++) {
1265 MODE_INFO **mi_8x8 = mi_8x8_ptr;
1266 uint8_t *cache = cache_ptr;
1267 for (col = 0; col < cm->mi_cols; col++, mi_8x8++, cache++)
1268 cache[0] = mi_8x8[0]->segment_id;
1269 mi_8x8_ptr += cm->mi_stride;
1270 cache_ptr += cm->mi_cols;
1274 static void alloc_raw_frame_buffers(VP9_COMP *cpi) {
1275 VP9_COMMON *cm = &cpi->common;
1276 const VP9EncoderConfig *oxcf = &cpi->oxcf;
1278 if (!cpi->lookahead)
1279 cpi->lookahead = vp9_lookahead_init(oxcf->width, oxcf->height,
1280 cm->subsampling_x, cm->subsampling_y,
1281 #if CONFIG_VP9_HIGHBITDEPTH
1282 cm->use_highbitdepth,
1284 oxcf->lag_in_frames);
1285 if (!cpi->lookahead)
1286 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1287 "Failed to allocate lag buffers");
1289 // TODO(agrange) Check if ARF is enabled and skip allocation if not.
1290 if (vpx_realloc_frame_buffer(&cpi->alt_ref_buffer, oxcf->width, oxcf->height,
1291 cm->subsampling_x, cm->subsampling_y,
1292 #if CONFIG_VP9_HIGHBITDEPTH
1293 cm->use_highbitdepth,
1295 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1297 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1298 "Failed to allocate altref buffer");
1301 static void alloc_util_frame_buffers(VP9_COMP *cpi) {
1302 VP9_COMMON *const cm = &cpi->common;
1303 if (vpx_realloc_frame_buffer(&cpi->last_frame_uf, cm->width, cm->height,
1304 cm->subsampling_x, cm->subsampling_y,
1305 #if CONFIG_VP9_HIGHBITDEPTH
1306 cm->use_highbitdepth,
1308 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1310 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1311 "Failed to allocate last frame buffer");
1313 if (vpx_realloc_frame_buffer(&cpi->scaled_source, cm->width, cm->height,
1314 cm->subsampling_x, cm->subsampling_y,
1315 #if CONFIG_VP9_HIGHBITDEPTH
1316 cm->use_highbitdepth,
1318 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1320 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1321 "Failed to allocate scaled source buffer");
1323 // For 1 pass cbr: allocate scaled_frame that may be used as an intermediate
1324 // buffer for a 2 stage down-sampling: two stages of 1:2 down-sampling for a
1325 // target of 1/4x1/4. number_spatial_layers must be greater than 2.
1326 if (is_one_pass_cbr_svc(cpi) && !cpi->svc.scaled_temp_is_alloc &&
1327 cpi->svc.number_spatial_layers > 2) {
1328 cpi->svc.scaled_temp_is_alloc = 1;
1329 if (vpx_realloc_frame_buffer(
1330 &cpi->svc.scaled_temp, cm->width >> 1, cm->height >> 1,
1331 cm->subsampling_x, cm->subsampling_y,
1332 #if CONFIG_VP9_HIGHBITDEPTH
1333 cm->use_highbitdepth,
1335 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment, NULL, NULL, NULL))
1336 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1337 "Failed to allocate scaled_frame for svc ");
1340 if (vpx_realloc_frame_buffer(&cpi->scaled_last_source, cm->width, cm->height,
1341 cm->subsampling_x, cm->subsampling_y,
1342 #if CONFIG_VP9_HIGHBITDEPTH
1343 cm->use_highbitdepth,
1345 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1347 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1348 "Failed to allocate scaled last source buffer");
1349 #ifdef ENABLE_KF_DENOISE
1350 if (vpx_realloc_frame_buffer(&cpi->raw_unscaled_source, cm->width, cm->height,
1351 cm->subsampling_x, cm->subsampling_y,
1352 #if CONFIG_VP9_HIGHBITDEPTH
1353 cm->use_highbitdepth,
1355 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1357 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1358 "Failed to allocate unscaled raw source frame buffer");
1360 if (vpx_realloc_frame_buffer(&cpi->raw_scaled_source, cm->width, cm->height,
1361 cm->subsampling_x, cm->subsampling_y,
1362 #if CONFIG_VP9_HIGHBITDEPTH
1363 cm->use_highbitdepth,
1365 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1367 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1368 "Failed to allocate scaled raw source frame buffer");
1372 static int alloc_context_buffers_ext(VP9_COMP *cpi) {
1373 VP9_COMMON *cm = &cpi->common;
1374 int mi_size = cm->mi_cols * cm->mi_rows;
1376 cpi->mbmi_ext_base = vpx_calloc(mi_size, sizeof(*cpi->mbmi_ext_base));
1377 if (!cpi->mbmi_ext_base) return 1;
1382 static void alloc_compressor_data(VP9_COMP *cpi) {
1383 VP9_COMMON *cm = &cpi->common;
1386 vp9_alloc_context_buffers(cm, cm->width, cm->height);
1388 alloc_context_buffers_ext(cpi);
1390 vpx_free(cpi->tile_tok[0][0]);
1393 unsigned int tokens = get_token_alloc(cm->mb_rows, cm->mb_cols);
1394 CHECK_MEM_ERROR(cm, cpi->tile_tok[0][0],
1395 vpx_calloc(tokens, sizeof(*cpi->tile_tok[0][0])));
1398 sb_rows = mi_cols_aligned_to_sb(cm->mi_rows) >> MI_BLOCK_SIZE_LOG2;
1399 vpx_free(cpi->tplist[0][0]);
1401 cm, cpi->tplist[0][0],
1402 vpx_calloc(sb_rows * 4 * (1 << 6), sizeof(*cpi->tplist[0][0])));
1404 vp9_setup_pc_tree(&cpi->common, &cpi->td);
1407 void vp9_new_framerate(VP9_COMP *cpi, double framerate) {
1408 cpi->framerate = framerate < 0.1 ? 30 : framerate;
1409 vp9_rc_update_framerate(cpi);
1412 static void set_tile_limits(VP9_COMP *cpi) {
1413 VP9_COMMON *const cm = &cpi->common;
1415 int min_log2_tile_cols, max_log2_tile_cols;
1416 vp9_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols);
1418 cm->log2_tile_cols =
1419 clamp(cpi->oxcf.tile_columns, min_log2_tile_cols, max_log2_tile_cols);
1420 cm->log2_tile_rows = cpi->oxcf.tile_rows;
1422 if (cpi->oxcf.target_level == LEVEL_AUTO) {
1423 const int level_tile_cols =
1424 log_tile_cols_from_picsize_level(cpi->common.width, cpi->common.height);
1425 if (cm->log2_tile_cols > level_tile_cols) {
1426 cm->log2_tile_cols = VPXMAX(level_tile_cols, min_log2_tile_cols);
1431 static void update_frame_size(VP9_COMP *cpi) {
1432 VP9_COMMON *const cm = &cpi->common;
1433 MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
1435 vp9_set_mb_mi(cm, cm->width, cm->height);
1436 vp9_init_context_buffers(cm);
1437 vp9_init_macroblockd(cm, xd, NULL);
1438 cpi->td.mb.mbmi_ext_base = cpi->mbmi_ext_base;
1439 memset(cpi->mbmi_ext_base, 0,
1440 cm->mi_rows * cm->mi_cols * sizeof(*cpi->mbmi_ext_base));
1442 set_tile_limits(cpi);
1445 static void init_buffer_indices(VP9_COMP *cpi) {
1448 for (ref_frame = 0; ref_frame < REF_FRAMES; ++ref_frame)
1449 cpi->ref_fb_idx[ref_frame] = ref_frame;
1451 cpi->lst_fb_idx = cpi->ref_fb_idx[LAST_FRAME - 1];
1452 cpi->gld_fb_idx = cpi->ref_fb_idx[GOLDEN_FRAME - 1];
1453 cpi->alt_fb_idx = cpi->ref_fb_idx[ALTREF_FRAME - 1];
1456 static void init_level_constraint(LevelConstraint *lc) {
1457 lc->level_index = -1;
1458 lc->max_cpb_size = INT_MAX;
1459 lc->max_frame_size = INT_MAX;
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, const 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 static void init_ref_frame_bufs(VP9_COMMON *cm) {
2164 BufferPool *const pool = cm->buffer_pool;
2165 cm->new_fb_idx = INVALID_IDX;
2166 for (i = 0; i < REF_FRAMES; ++i) {
2167 cm->ref_frame_map[i] = INVALID_IDX;
2169 for (i = 0; i < FRAME_BUFFERS; ++i) {
2170 pool->frame_bufs[i].ref_count = 0;
2174 static void update_initial_width(VP9_COMP *cpi, int use_highbitdepth,
2175 int subsampling_x, int subsampling_y) {
2176 VP9_COMMON *const cm = &cpi->common;
2177 #if !CONFIG_VP9_HIGHBITDEPTH
2178 (void)use_highbitdepth;
2179 assert(use_highbitdepth == 0);
2182 if (!cpi->initial_width ||
2183 #if CONFIG_VP9_HIGHBITDEPTH
2184 cm->use_highbitdepth != use_highbitdepth ||
2186 cm->subsampling_x != subsampling_x ||
2187 cm->subsampling_y != subsampling_y) {
2188 cm->subsampling_x = subsampling_x;
2189 cm->subsampling_y = subsampling_y;
2190 #if CONFIG_VP9_HIGHBITDEPTH
2191 cm->use_highbitdepth = use_highbitdepth;
2194 cpi->initial_width = cm->width;
2195 cpi->initial_height = cm->height;
2196 cpi->initial_mbs = cm->MBs;
2200 // TODO(angiebird): Check whether we can move this function to vpx_image.c
2201 static INLINE void vpx_img_chroma_subsampling(vpx_img_fmt_t fmt,
2202 unsigned int *subsampling_x,
2203 unsigned int *subsampling_y) {
2205 case VPX_IMG_FMT_I420:
2206 case VPX_IMG_FMT_YV12:
2207 case VPX_IMG_FMT_I422:
2208 case VPX_IMG_FMT_I42016:
2209 case VPX_IMG_FMT_I42216: *subsampling_x = 1; break;
2210 default: *subsampling_x = 0; break;
2214 case VPX_IMG_FMT_I420:
2215 case VPX_IMG_FMT_I440:
2216 case VPX_IMG_FMT_YV12:
2217 case VPX_IMG_FMT_I42016:
2218 case VPX_IMG_FMT_I44016: *subsampling_y = 1; break;
2219 default: *subsampling_y = 0; break;
2223 // TODO(angiebird): Check whether we can move this function to vpx_image.c
2224 static INLINE int vpx_img_use_highbitdepth(vpx_img_fmt_t fmt) {
2225 return fmt & VPX_IMG_FMT_HIGHBITDEPTH;
2228 #if CONFIG_VP9_TEMPORAL_DENOISING
2229 static void setup_denoiser_buffer(VP9_COMP *cpi) {
2230 VP9_COMMON *const cm = &cpi->common;
2231 if (cpi->oxcf.noise_sensitivity > 0 &&
2232 !cpi->denoiser.frame_buffer_initialized) {
2233 if (vp9_denoiser_alloc(cm, &cpi->svc, &cpi->denoiser, cpi->use_svc,
2234 cpi->oxcf.noise_sensitivity, cm->width, cm->height,
2235 cm->subsampling_x, cm->subsampling_y,
2236 #if CONFIG_VP9_HIGHBITDEPTH
2237 cm->use_highbitdepth,
2239 VP9_ENC_BORDER_IN_PIXELS))
2240 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
2241 "Failed to allocate denoiser");
2246 void vp9_update_compressor_with_img_fmt(VP9_COMP *cpi, vpx_img_fmt_t img_fmt) {
2247 const VP9EncoderConfig *oxcf = &cpi->oxcf;
2248 unsigned int subsampling_x, subsampling_y;
2249 const int use_highbitdepth = vpx_img_use_highbitdepth(img_fmt);
2250 vpx_img_chroma_subsampling(img_fmt, &subsampling_x, &subsampling_y);
2252 update_initial_width(cpi, use_highbitdepth, subsampling_x, subsampling_y);
2253 #if CONFIG_VP9_TEMPORAL_DENOISING
2254 setup_denoiser_buffer(cpi);
2257 assert(cpi->lookahead == NULL);
2258 cpi->lookahead = vp9_lookahead_init(oxcf->width, oxcf->height, subsampling_x,
2260 #if CONFIG_VP9_HIGHBITDEPTH
2263 oxcf->lag_in_frames);
2264 alloc_raw_frame_buffers(cpi);
2267 VP9_COMP *vp9_create_compressor(const VP9EncoderConfig *oxcf,
2268 BufferPool *const pool) {
2270 VP9_COMP *volatile const cpi = vpx_memalign(32, sizeof(VP9_COMP));
2271 VP9_COMMON *volatile const cm = cpi != NULL ? &cpi->common : NULL;
2273 if (!cm) return NULL;
2277 if (setjmp(cm->error.jmp)) {
2278 cm->error.setjmp = 0;
2279 vp9_remove_compressor(cpi);
2283 cm->error.setjmp = 1;
2284 cm->alloc_mi = vp9_enc_alloc_mi;
2285 cm->free_mi = vp9_enc_free_mi;
2286 cm->setup_mi = vp9_enc_setup_mi;
2288 CHECK_MEM_ERROR(cm, cm->fc, (FRAME_CONTEXT *)vpx_calloc(1, sizeof(*cm->fc)));
2290 cm, cm->frame_contexts,
2291 (FRAME_CONTEXT *)vpx_calloc(FRAME_CONTEXTS, sizeof(*cm->frame_contexts)));
2294 cpi->resize_state = ORIG;
2295 cpi->external_resize = 0;
2296 cpi->resize_avg_qp = 0;
2297 cpi->resize_buffer_underflow = 0;
2298 cpi->use_skin_detection = 0;
2299 cpi->common.buffer_pool = pool;
2300 init_ref_frame_bufs(cm);
2302 cpi->force_update_segmentation = 0;
2304 init_config(cpi, oxcf);
2305 cpi->frame_info = vp9_get_frame_info(oxcf);
2307 vp9_rc_init(&cpi->oxcf, oxcf->pass, &cpi->rc);
2309 cm->current_video_frame = 0;
2310 cpi->partition_search_skippable_frame = 0;
2311 cpi->tile_data = NULL;
2313 realloc_segmentation_maps(cpi);
2317 vpx_calloc(cm->mi_rows * cm->mi_cols, sizeof(cpi->skin_map[0])));
2319 #if !CONFIG_REALTIME_ONLY
2320 CHECK_MEM_ERROR(cm, cpi->alt_ref_aq, vp9_alt_ref_aq_create());
2324 cm, cpi->consec_zero_mv,
2325 vpx_calloc(cm->mi_rows * cm->mi_cols, sizeof(*cpi->consec_zero_mv)));
2327 CHECK_MEM_ERROR(cm, cpi->nmvcosts[0],
2328 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts[0])));
2329 CHECK_MEM_ERROR(cm, cpi->nmvcosts[1],
2330 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts[1])));
2331 CHECK_MEM_ERROR(cm, cpi->nmvcosts_hp[0],
2332 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts_hp[0])));
2333 CHECK_MEM_ERROR(cm, cpi->nmvcosts_hp[1],
2334 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts_hp[1])));
2335 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts[0],
2336 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts[0])));
2337 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts[1],
2338 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts[1])));
2339 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts_hp[0],
2340 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts_hp[0])));
2341 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts_hp[1],
2342 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts_hp[1])));
2344 for (i = 0; i < (sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]));
2347 cm, cpi->mbgraph_stats[i].mb_stats,
2348 vpx_calloc(cm->MBs * sizeof(*cpi->mbgraph_stats[i].mb_stats), 1));
2351 #if CONFIG_FP_MB_STATS
2352 cpi->use_fp_mb_stats = 0;
2353 if (cpi->use_fp_mb_stats) {
2354 // a place holder used to store the first pass mb stats in the first pass
2355 CHECK_MEM_ERROR(cm, cpi->twopass.frame_mb_stats_buf,
2356 vpx_calloc(cm->MBs * sizeof(uint8_t), 1));
2358 cpi->twopass.frame_mb_stats_buf = NULL;
2362 cpi->refresh_alt_ref_frame = 0;
2363 cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS;
2365 init_level_info(&cpi->level_info);
2366 init_level_constraint(&cpi->level_constraint);
2368 #if CONFIG_INTERNAL_STATS
2369 cpi->b_calculate_blockiness = 1;
2370 cpi->b_calculate_consistency = 1;
2371 cpi->total_inconsistency = 0;
2372 cpi->psnr.worst = 100.0;
2373 cpi->worst_ssim = 100.0;
2378 if (cpi->b_calculate_psnr) {
2379 cpi->total_sq_error = 0;
2380 cpi->total_samples = 0;
2382 cpi->totalp_sq_error = 0;
2383 cpi->totalp_samples = 0;
2385 cpi->tot_recode_hits = 0;
2386 cpi->summed_quality = 0;
2387 cpi->summed_weights = 0;
2388 cpi->summedp_quality = 0;
2389 cpi->summedp_weights = 0;
2392 cpi->fastssim.worst = 100.0;
2394 cpi->psnrhvs.worst = 100.0;
2396 if (cpi->b_calculate_blockiness) {
2397 cpi->total_blockiness = 0;
2398 cpi->worst_blockiness = 0.0;
2401 if (cpi->b_calculate_consistency) {
2402 CHECK_MEM_ERROR(cm, cpi->ssim_vars,
2403 vpx_calloc(cpi->common.mi_rows * cpi->common.mi_cols,
2404 sizeof(*cpi->ssim_vars) * 4));
2405 cpi->worst_consistency = 100.0;
2407 cpi->ssim_vars = NULL;
2412 cpi->first_time_stamp_ever = INT64_MAX;
2414 /*********************************************************************
2415 * Warning: Read the comments around 'cal_nmvjointsadcost' and *
2416 * 'cal_nmvsadcosts' before modifying how these tables are computed. *
2417 *********************************************************************/
2418 cal_nmvjointsadcost(cpi->td.mb.nmvjointsadcost);
2419 cpi->td.mb.nmvcost[0] = &cpi->nmvcosts[0][MV_MAX];
2420 cpi->td.mb.nmvcost[1] = &cpi->nmvcosts[1][MV_MAX];
2421 cpi->td.mb.nmvsadcost[0] = &cpi->nmvsadcosts[0][MV_MAX];
2422 cpi->td.mb.nmvsadcost[1] = &cpi->nmvsadcosts[1][MV_MAX];
2423 cal_nmvsadcosts(cpi->td.mb.nmvsadcost);
2425 cpi->td.mb.nmvcost_hp[0] = &cpi->nmvcosts_hp[0][MV_MAX];
2426 cpi->td.mb.nmvcost_hp[1] = &cpi->nmvcosts_hp[1][MV_MAX];
2427 cpi->td.mb.nmvsadcost_hp[0] = &cpi->nmvsadcosts_hp[0][MV_MAX];
2428 cpi->td.mb.nmvsadcost_hp[1] = &cpi->nmvsadcosts_hp[1][MV_MAX];
2429 cal_nmvsadcosts_hp(cpi->td.mb.nmvsadcost_hp);
2431 #if CONFIG_VP9_TEMPORAL_DENOISING
2432 #ifdef OUTPUT_YUV_DENOISED
2433 yuv_denoised_file = fopen("denoised.yuv", "ab");
2436 #ifdef OUTPUT_YUV_SKINMAP
2437 yuv_skinmap_file = fopen("skinmap.yuv", "wb");
2439 #ifdef OUTPUT_YUV_REC
2440 yuv_rec_file = fopen("rec.yuv", "wb");
2442 #ifdef OUTPUT_YUV_SVC_SRC
2443 yuv_svc_src[0] = fopen("svc_src_0.yuv", "wb");
2444 yuv_svc_src[1] = fopen("svc_src_1.yuv", "wb");
2445 yuv_svc_src[2] = fopen("svc_src_2.yuv", "wb");
2449 framepsnr = fopen("framepsnr.stt", "a");
2450 kf_list = fopen("kf_list.stt", "w");
2453 cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED;
2455 #if !CONFIG_REALTIME_ONLY
2456 if (oxcf->pass == 1) {
2457 vp9_init_first_pass(cpi);
2458 } else if (oxcf->pass == 2) {
2459 const size_t packet_sz = sizeof(FIRSTPASS_STATS);
2460 const int packets = (int)(oxcf->two_pass_stats_in.sz / packet_sz);
2462 if (cpi->svc.number_spatial_layers > 1 ||
2463 cpi->svc.number_temporal_layers > 1) {
2464 FIRSTPASS_STATS *const stats = oxcf->two_pass_stats_in.buf;
2465 FIRSTPASS_STATS *stats_copy[VPX_SS_MAX_LAYERS] = { 0 };
2468 for (i = 0; i < oxcf->ss_number_layers; ++i) {
2469 FIRSTPASS_STATS *const last_packet_for_layer =
2470 &stats[packets - oxcf->ss_number_layers + i];
2471 const int layer_id = (int)last_packet_for_layer->spatial_layer_id;
2472 const int packets_in_layer = (int)last_packet_for_layer->count + 1;
2473 if (layer_id >= 0 && layer_id < oxcf->ss_number_layers) {
2475 LAYER_CONTEXT *const lc = &cpi->svc.layer_context[layer_id];
2477 vpx_free(lc->rc_twopass_stats_in.buf);
2479 lc->rc_twopass_stats_in.sz = packets_in_layer * packet_sz;
2480 CHECK_MEM_ERROR(cm, lc->rc_twopass_stats_in.buf,
2481 vpx_malloc(lc->rc_twopass_stats_in.sz));
2482 lc->twopass.stats_in_start = lc->rc_twopass_stats_in.buf;
2483 lc->twopass.stats_in = lc->twopass.stats_in_start;
2484 lc->twopass.stats_in_end =
2485 lc->twopass.stats_in_start + packets_in_layer - 1;
2486 // Note the last packet is cumulative first pass stats.
2487 // So the number of frames is packet number minus one
2488 num_frames = packets_in_layer - 1;
2489 fps_init_first_pass_info(&lc->twopass.first_pass_info,
2490 lc->rc_twopass_stats_in.buf, num_frames);
2491 stats_copy[layer_id] = lc->rc_twopass_stats_in.buf;
2495 for (i = 0; i < packets; ++i) {
2496 const int layer_id = (int)stats[i].spatial_layer_id;
2497 if (layer_id >= 0 && layer_id < oxcf->ss_number_layers &&
2498 stats_copy[layer_id] != NULL) {
2499 *stats_copy[layer_id] = stats[i];
2500 ++stats_copy[layer_id];
2504 vp9_init_second_pass_spatial_svc(cpi);
2507 #if CONFIG_FP_MB_STATS
2508 if (cpi->use_fp_mb_stats) {
2509 const size_t psz = cpi->common.MBs * sizeof(uint8_t);
2510 const int ps = (int)(oxcf->firstpass_mb_stats_in.sz / psz);
2512 cpi->twopass.firstpass_mb_stats.mb_stats_start =
2513 oxcf->firstpass_mb_stats_in.buf;
2514 cpi->twopass.firstpass_mb_stats.mb_stats_end =
2515 cpi->twopass.firstpass_mb_stats.mb_stats_start +
2516 (ps - 1) * cpi->common.MBs * sizeof(uint8_t);
2520 cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf;
2521 cpi->twopass.stats_in = cpi->twopass.stats_in_start;
2522 cpi->twopass.stats_in_end = &cpi->twopass.stats_in[packets - 1];
2523 // Note the last packet is cumulative first pass stats.
2524 // So the number of frames is packet number minus one
2525 num_frames = packets - 1;
2526 fps_init_first_pass_info(&cpi->twopass.first_pass_info,
2527 oxcf->two_pass_stats_in.buf, num_frames);
2529 vp9_init_second_pass(cpi);
2532 #endif // !CONFIG_REALTIME_ONLY
2534 cpi->mb_wiener_var_cols = 0;
2535 cpi->mb_wiener_var_rows = 0;
2536 cpi->mb_wiener_variance = NULL;
2538 vp9_set_speed_features_framesize_independent(cpi, oxcf->speed);
2539 vp9_set_speed_features_framesize_dependent(cpi, oxcf->speed);
2542 const int bsize = BLOCK_16X16;
2543 const int w = num_8x8_blocks_wide_lookup[bsize];
2544 const int h = num_8x8_blocks_high_lookup[bsize];
2545 const int num_cols = (cm->mi_cols + w - 1) / w;
2546 const int num_rows = (cm->mi_rows + h - 1) / h;
2547 CHECK_MEM_ERROR(cm, cpi->mi_ssim_rdmult_scaling_factors,
2548 vpx_calloc(num_rows * num_cols,
2549 sizeof(*cpi->mi_ssim_rdmult_scaling_factors)));
2552 cpi->kmeans_data_arr_alloc = 0;
2553 #if CONFIG_NON_GREEDY_MV
2555 #endif // CONFIG_NON_GREEDY_MV
2556 for (i = 0; i < MAX_ARF_GOP_SIZE; ++i) cpi->tpl_stats[i].tpl_stats_ptr = NULL;
2558 // Allocate memory to store variances for a frame.
2559 CHECK_MEM_ERROR(cm, cpi->source_diff_var, vpx_calloc(cm->MBs, sizeof(diff)));
2560 cpi->source_var_thresh = 0;
2561 cpi->frames_till_next_var_check = 0;
2562 #define BFP(BT, SDF, SDAF, VF, SVF, SVAF, SDX4DF, SDX8F) \
2563 cpi->fn_ptr[BT].sdf = SDF; \
2564 cpi->fn_ptr[BT].sdaf = SDAF; \
2565 cpi->fn_ptr[BT].vf = VF; \
2566 cpi->fn_ptr[BT].svf = SVF; \
2567 cpi->fn_ptr[BT].svaf = SVAF; \
2568 cpi->fn_ptr[BT].sdx4df = SDX4DF; \
2569 cpi->fn_ptr[BT].sdx8f = SDX8F;
2571 // TODO(angiebird): make sdx8f available for every block size
2572 BFP(BLOCK_32X16, vpx_sad32x16, vpx_sad32x16_avg, vpx_variance32x16,
2573 vpx_sub_pixel_variance32x16, vpx_sub_pixel_avg_variance32x16,
2574 vpx_sad32x16x4d, NULL)
2576 BFP(BLOCK_16X32, vpx_sad16x32, vpx_sad16x32_avg, vpx_variance16x32,
2577 vpx_sub_pixel_variance16x32, vpx_sub_pixel_avg_variance16x32,
2578 vpx_sad16x32x4d, NULL)
2580 BFP(BLOCK_64X32, vpx_sad64x32, vpx_sad64x32_avg, vpx_variance64x32,
2581 vpx_sub_pixel_variance64x32, vpx_sub_pixel_avg_variance64x32,
2582 vpx_sad64x32x4d, NULL)
2584 BFP(BLOCK_32X64, vpx_sad32x64, vpx_sad32x64_avg, vpx_variance32x64,
2585 vpx_sub_pixel_variance32x64, vpx_sub_pixel_avg_variance32x64,
2586 vpx_sad32x64x4d, NULL)
2588 BFP(BLOCK_32X32, vpx_sad32x32, vpx_sad32x32_avg, vpx_variance32x32,
2589 vpx_sub_pixel_variance32x32, vpx_sub_pixel_avg_variance32x32,
2590 vpx_sad32x32x4d, vpx_sad32x32x8)
2592 BFP(BLOCK_64X64, vpx_sad64x64, vpx_sad64x64_avg, vpx_variance64x64,
2593 vpx_sub_pixel_variance64x64, vpx_sub_pixel_avg_variance64x64,
2594 vpx_sad64x64x4d, NULL)
2596 BFP(BLOCK_16X16, vpx_sad16x16, vpx_sad16x16_avg, vpx_variance16x16,
2597 vpx_sub_pixel_variance16x16, vpx_sub_pixel_avg_variance16x16,
2598 vpx_sad16x16x4d, vpx_sad16x16x8)
2600 BFP(BLOCK_16X8, vpx_sad16x8, vpx_sad16x8_avg, vpx_variance16x8,
2601 vpx_sub_pixel_variance16x8, vpx_sub_pixel_avg_variance16x8,
2602 vpx_sad16x8x4d, vpx_sad16x8x8)
2604 BFP(BLOCK_8X16, vpx_sad8x16, vpx_sad8x16_avg, vpx_variance8x16,
2605 vpx_sub_pixel_variance8x16, vpx_sub_pixel_avg_variance8x16,
2606 vpx_sad8x16x4d, vpx_sad8x16x8)
2608 BFP(BLOCK_8X8, vpx_sad8x8, vpx_sad8x8_avg, vpx_variance8x8,
2609 vpx_sub_pixel_variance8x8, vpx_sub_pixel_avg_variance8x8, vpx_sad8x8x4d,
2612 BFP(BLOCK_8X4, vpx_sad8x4, vpx_sad8x4_avg, vpx_variance8x4,
2613 vpx_sub_pixel_variance8x4, vpx_sub_pixel_avg_variance8x4, vpx_sad8x4x4d,
2616 BFP(BLOCK_4X8, vpx_sad4x8, vpx_sad4x8_avg, vpx_variance4x8,
2617 vpx_sub_pixel_variance4x8, vpx_sub_pixel_avg_variance4x8, vpx_sad4x8x4d,
2620 BFP(BLOCK_4X4, vpx_sad4x4, vpx_sad4x4_avg, vpx_variance4x4,
2621 vpx_sub_pixel_variance4x4, vpx_sub_pixel_avg_variance4x4, vpx_sad4x4x4d,
2624 #if CONFIG_VP9_HIGHBITDEPTH
2625 highbd_set_var_fns(cpi);
2628 /* vp9_init_quantizer() is first called here. Add check in
2629 * vp9_frame_init_quantizer() so that vp9_init_quantizer is only
2630 * called later when needed. This will avoid unnecessary calls of
2631 * vp9_init_quantizer() for every frame.
2633 vp9_init_quantizer(cpi);
2635 vp9_loop_filter_init(cm);
2637 // Set up the unit scaling factor used during motion search.
2638 #if CONFIG_VP9_HIGHBITDEPTH
2639 vp9_setup_scale_factors_for_frame(&cpi->me_sf, cm->width, cm->height,
2640 cm->width, cm->height,
2641 cm->use_highbitdepth);
2643 vp9_setup_scale_factors_for_frame(&cpi->me_sf, cm->width, cm->height,
2644 cm->width, cm->height);
2645 #endif // CONFIG_VP9_HIGHBITDEPTH
2646 cpi->td.mb.me_sf = &cpi->me_sf;
2648 cm->error.setjmp = 0;
2650 #if CONFIG_RATE_CTRL
2651 encode_command_init(&cpi->encode_command);
2657 #if CONFIG_INTERNAL_STATS
2658 #define SNPRINT(H, T) snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T))
2660 #define SNPRINT2(H, T, V) \
2661 snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T), (V))
2662 #endif // CONFIG_INTERNAL_STATS
2664 static void free_tpl_buffer(VP9_COMP *cpi);
2666 void vp9_remove_compressor(VP9_COMP *cpi) {
2673 #if CONFIG_INTERNAL_STATS
2674 vpx_free(cpi->ssim_vars);
2678 if (cm->current_video_frame > 0) {
2679 #if CONFIG_INTERNAL_STATS
2680 vpx_clear_system_state();
2682 if (cpi->oxcf.pass != 1) {
2683 char headings[512] = { 0 };
2684 char results[512] = { 0 };
2685 FILE *f = fopen("opsnr.stt", "a");
2686 double time_encoded =
2687 (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) /
2689 double total_encode_time =
2690 (cpi->time_receive_data + cpi->time_compress_data) / 1000.000;
2692 (double)cpi->bytes * (double)8 / (double)1000 / time_encoded;
2693 const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1);
2694 const double target_rate = (double)cpi->oxcf.target_bandwidth / 1000;
2695 const double rate_err = ((100.0 * (dr - target_rate)) / target_rate);
2697 if (cpi->b_calculate_psnr) {
2698 const double total_psnr = vpx_sse_to_psnr(
2699 (double)cpi->total_samples, peak, (double)cpi->total_sq_error);
2700 const double totalp_psnr = vpx_sse_to_psnr(
2701 (double)cpi->totalp_samples, peak, (double)cpi->totalp_sq_error);
2702 const double total_ssim =
2703 100 * pow(cpi->summed_quality / cpi->summed_weights, 8.0);
2704 const double totalp_ssim =
2705 100 * pow(cpi->summedp_quality / cpi->summedp_weights, 8.0);
2707 snprintf(headings, sizeof(headings),
2708 "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\t"
2709 "VPXSSIM\tVPSSIMP\tFASTSIM\tPSNRHVS\t"
2710 "WstPsnr\tWstSsim\tWstFast\tWstHVS\t"
2711 "AVPsnrY\tAPsnrCb\tAPsnrCr");
2712 snprintf(results, sizeof(results),
2713 "%7.2f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2714 "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2715 "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2716 "%7.3f\t%7.3f\t%7.3f",
2717 dr, cpi->psnr.stat[ALL] / cpi->count, total_psnr,
2718 cpi->psnrp.stat[ALL] / cpi->count, totalp_psnr, total_ssim,
2719 totalp_ssim, cpi->fastssim.stat[ALL] / cpi->count,
2720 cpi->psnrhvs.stat[ALL] / cpi->count, cpi->psnr.worst,
2721 cpi->worst_ssim, cpi->fastssim.worst, cpi->psnrhvs.worst,
2722 cpi->psnr.stat[Y] / cpi->count, cpi->psnr.stat[U] / cpi->count,
2723 cpi->psnr.stat[V] / cpi->count);
2725 if (cpi->b_calculate_blockiness) {
2726 SNPRINT(headings, "\t Block\tWstBlck");
2727 SNPRINT2(results, "\t%7.3f", cpi->total_blockiness / cpi->count);
2728 SNPRINT2(results, "\t%7.3f", cpi->worst_blockiness);
2731 if (cpi->b_calculate_consistency) {
2732 double consistency =
2733 vpx_sse_to_psnr((double)cpi->totalp_samples, peak,
2734 (double)cpi->total_inconsistency);
2736 SNPRINT(headings, "\tConsist\tWstCons");
2737 SNPRINT2(results, "\t%7.3f", consistency);
2738 SNPRINT2(results, "\t%7.3f", cpi->worst_consistency);
2741 SNPRINT(headings, "\t Time\tRcErr\tAbsErr");
2742 SNPRINT2(results, "\t%8.0f", total_encode_time);
2743 SNPRINT2(results, "\t%7.2f", rate_err);
2744 SNPRINT2(results, "\t%7.2f", fabs(rate_err));
2746 fprintf(f, "%s\tAPsnr611\n", headings);
2748 f, "%s\t%7.3f\n", results,
2749 (6 * cpi->psnr.stat[Y] + cpi->psnr.stat[U] + cpi->psnr.stat[V]) /
2759 printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000);
2760 printf("\n_frames recive_data encod_mb_row compress_frame Total\n");
2761 printf("%6d %10ld %10ld %10ld %10ld\n", cpi->common.current_video_frame,
2762 cpi->time_receive_data / 1000, cpi->time_encode_sb_row / 1000,
2763 cpi->time_compress_data / 1000,
2764 (cpi->time_receive_data + cpi->time_compress_data) / 1000);
2769 #if CONFIG_VP9_TEMPORAL_DENOISING
2770 vp9_denoiser_free(&(cpi->denoiser));
2773 if (cpi->kmeans_data_arr_alloc) {
2774 #if CONFIG_MULTITHREAD
2775 pthread_mutex_destroy(&cpi->kmeans_mutex);
2777 vpx_free(cpi->kmeans_data_arr);
2780 free_tpl_buffer(cpi);
2782 for (t = 0; t < cpi->num_workers; ++t) {
2783 VPxWorker *const worker = &cpi->workers[t];
2784 EncWorkerData *const thread_data = &cpi->tile_thr_data[t];
2786 // Deallocate allocated threads.
2787 vpx_get_worker_interface()->end(worker);
2789 // Deallocate allocated thread data.
2790 if (t < cpi->num_workers - 1) {
2791 vpx_free(thread_data->td->counts);
2792 vp9_free_pc_tree(thread_data->td);
2793 vpx_free(thread_data->td);
2796 vpx_free(cpi->tile_thr_data);
2797 vpx_free(cpi->workers);
2798 vp9_row_mt_mem_dealloc(cpi);
2800 if (cpi->num_workers > 1) {
2801 vp9_loop_filter_dealloc(&cpi->lf_row_sync);
2802 vp9_bitstream_encode_tiles_buffer_dealloc(cpi);
2805 #if !CONFIG_REALTIME_ONLY
2806 vp9_alt_ref_aq_destroy(cpi->alt_ref_aq);
2809 dealloc_compressor_data(cpi);
2811 for (i = 0; i < sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]);
2813 vpx_free(cpi->mbgraph_stats[i].mb_stats);
2816 #if CONFIG_FP_MB_STATS
2817 if (cpi->use_fp_mb_stats) {
2818 vpx_free(cpi->twopass.frame_mb_stats_buf);
2819 cpi->twopass.frame_mb_stats_buf = NULL;
2823 vp9_remove_common(cm);
2824 vp9_free_ref_frame_buffers(cm->buffer_pool);
2825 #if CONFIG_VP9_POSTPROC
2826 vp9_free_postproc_buffers(cm);
2830 #if CONFIG_VP9_TEMPORAL_DENOISING
2831 #ifdef OUTPUT_YUV_DENOISED
2832 fclose(yuv_denoised_file);
2835 #ifdef OUTPUT_YUV_SKINMAP
2836 fclose(yuv_skinmap_file);
2838 #ifdef OUTPUT_YUV_REC
2839 fclose(yuv_rec_file);
2841 #ifdef OUTPUT_YUV_SVC_SRC
2842 fclose(yuv_svc_src[0]);
2843 fclose(yuv_svc_src[1]);
2844 fclose(yuv_svc_src[2]);
2861 int vp9_get_psnr(const VP9_COMP *cpi, PSNR_STATS *psnr) {
2862 if (is_psnr_calc_enabled(cpi)) {
2863 #if CONFIG_VP9_HIGHBITDEPTH
2864 vpx_calc_highbd_psnr(cpi->raw_source_frame, cpi->common.frame_to_show, psnr,
2865 cpi->td.mb.e_mbd.bd, cpi->oxcf.input_bit_depth);
2867 vpx_calc_psnr(cpi->raw_source_frame, cpi->common.frame_to_show, psnr);
2876 int vp9_use_as_reference(VP9_COMP *cpi, int ref_frame_flags) {
2877 if (ref_frame_flags > 7) return -1;
2879 cpi->ref_frame_flags = ref_frame_flags;
2883 void vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags) {
2884 cpi->ext_refresh_golden_frame = (ref_frame_flags & VP9_GOLD_FLAG) != 0;
2885 cpi->ext_refresh_alt_ref_frame = (ref_frame_flags & VP9_ALT_FLAG) != 0;
2886 cpi->ext_refresh_last_frame = (ref_frame_flags & VP9_LAST_FLAG) != 0;
2887 cpi->ext_refresh_frame_flags_pending = 1;
2890 static YV12_BUFFER_CONFIG *get_vp9_ref_frame_buffer(
2891 VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag) {
2892 MV_REFERENCE_FRAME ref_frame = NONE;
2893 if (ref_frame_flag == VP9_LAST_FLAG)
2894 ref_frame = LAST_FRAME;
2895 else if (ref_frame_flag == VP9_GOLD_FLAG)
2896 ref_frame = GOLDEN_FRAME;
2897 else if (ref_frame_flag == VP9_ALT_FLAG)
2898 ref_frame = ALTREF_FRAME;
2900 return ref_frame == NONE ? NULL : get_ref_frame_buffer(cpi, ref_frame);
2903 int vp9_copy_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
2904 YV12_BUFFER_CONFIG *sd) {
2905 YV12_BUFFER_CONFIG *cfg = get_vp9_ref_frame_buffer(cpi, ref_frame_flag);
2907 vpx_yv12_copy_frame(cfg, sd);
2914 int vp9_set_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
2915 YV12_BUFFER_CONFIG *sd) {
2916 YV12_BUFFER_CONFIG *cfg = get_vp9_ref_frame_buffer(cpi, ref_frame_flag);
2918 vpx_yv12_copy_frame(sd, cfg);
2925 int vp9_update_entropy(VP9_COMP *cpi, int update) {
2926 cpi->ext_refresh_frame_context = update;
2927 cpi->ext_refresh_frame_context_pending = 1;
2931 #ifdef OUTPUT_YUV_REC
2932 void vp9_write_yuv_rec_frame(VP9_COMMON *cm) {
2933 YV12_BUFFER_CONFIG *s = cm->frame_to_show;
2934 uint8_t *src = s->y_buffer;
2937 #if CONFIG_VP9_HIGHBITDEPTH
2938 if (s->flags & YV12_FLAG_HIGHBITDEPTH) {
2939 uint16_t *src16 = CONVERT_TO_SHORTPTR(s->y_buffer);
2942 fwrite(src16, s->y_width, 2, yuv_rec_file);
2943 src16 += s->y_stride;
2946 src16 = CONVERT_TO_SHORTPTR(s->u_buffer);
2950 fwrite(src16, s->uv_width, 2, yuv_rec_file);
2951 src16 += s->uv_stride;
2954 src16 = CONVERT_TO_SHORTPTR(s->v_buffer);
2958 fwrite(src16, s->uv_width, 2, yuv_rec_file);
2959 src16 += s->uv_stride;
2962 fflush(yuv_rec_file);
2965 #endif // CONFIG_VP9_HIGHBITDEPTH
2968 fwrite(src, s->y_width, 1, yuv_rec_file);
2976 fwrite(src, s->uv_width, 1, yuv_rec_file);
2977 src += s->uv_stride;
2984 fwrite(src, s->uv_width, 1, yuv_rec_file);
2985 src += s->uv_stride;
2988 fflush(yuv_rec_file);
2992 #if CONFIG_VP9_HIGHBITDEPTH
2993 static void scale_and_extend_frame_nonnormative(const YV12_BUFFER_CONFIG *src,
2994 YV12_BUFFER_CONFIG *dst,
2997 static void scale_and_extend_frame_nonnormative(const YV12_BUFFER_CONFIG *src,
2998 YV12_BUFFER_CONFIG *dst) {
2999 #endif // CONFIG_VP9_HIGHBITDEPTH
3000 // TODO(dkovalev): replace YV12_BUFFER_CONFIG with vpx_image_t
3002 const uint8_t *const srcs[3] = { src->y_buffer, src->u_buffer,
3004 const int src_strides[3] = { src->y_stride, src->uv_stride, src->uv_stride };
3005 const int src_widths[3] = { src->y_crop_width, src->uv_crop_width,
3006 src->uv_crop_width };
3007 const int src_heights[3] = { src->y_crop_height, src->uv_crop_height,
3008 src->uv_crop_height };
3009 uint8_t *const dsts[3] = { dst->y_buffer, dst->u_buffer, dst->v_buffer };
3010 const int dst_strides[3] = { dst->y_stride, dst->uv_stride, dst->uv_stride };
3011 const int dst_widths[3] = { dst->y_crop_width, dst->uv_crop_width,
3012 dst->uv_crop_width };
3013 const int dst_heights[3] = { dst->y_crop_height, dst->uv_crop_height,
3014 dst->uv_crop_height };
3016 for (i = 0; i < MAX_MB_PLANE; ++i) {
3017 #if CONFIG_VP9_HIGHBITDEPTH
3018 if (src->flags & YV12_FLAG_HIGHBITDEPTH) {
3019 vp9_highbd_resize_plane(srcs[i], src_heights[i], src_widths[i],
3020 src_strides[i], dsts[i], dst_heights[i],
3021 dst_widths[i], dst_strides[i], bd);
3023 vp9_resize_plane(srcs[i], src_heights[i], src_widths[i], src_strides[i],
3024 dsts[i], dst_heights[i], dst_widths[i], dst_strides[i]);
3027 vp9_resize_plane(srcs[i], src_heights[i], src_widths[i], src_strides[i],
3028 dsts[i], dst_heights[i], dst_widths[i], dst_strides[i]);
3029 #endif // CONFIG_VP9_HIGHBITDEPTH
3031 vpx_extend_frame_borders(dst);
3034 #if CONFIG_VP9_HIGHBITDEPTH
3035 static void scale_and_extend_frame(const YV12_BUFFER_CONFIG *src,
3036 YV12_BUFFER_CONFIG *dst, int bd,
3037 INTERP_FILTER filter_type,
3039 const int src_w = src->y_crop_width;
3040 const int src_h = src->y_crop_height;
3041 const int dst_w = dst->y_crop_width;
3042 const int dst_h = dst->y_crop_height;
3043 const uint8_t *const srcs[3] = { src->y_buffer, src->u_buffer,
3045 const int src_strides[3] = { src->y_stride, src->uv_stride, src->uv_stride };
3046 uint8_t *const dsts[3] = { dst->y_buffer, dst->u_buffer, dst->v_buffer };
3047 const int dst_strides[3] = { dst->y_stride, dst->uv_stride, dst->uv_stride };
3048 const InterpKernel *const kernel = vp9_filter_kernels[filter_type];
3051 for (i = 0; i < MAX_MB_PLANE; ++i) {
3052 const int factor = (i == 0 || i == 3 ? 1 : 2);
3053 const int src_stride = src_strides[i];
3054 const int dst_stride = dst_strides[i];
3055 for (y = 0; y < dst_h; y += 16) {
3056 const int y_q4 = y * (16 / factor) * src_h / dst_h + phase_scaler;
3057 for (x = 0; x < dst_w; x += 16) {
3058 const int x_q4 = x * (16 / factor) * src_w / dst_w + phase_scaler;
3059 const uint8_t *src_ptr = srcs[i] +
3060 (y / factor) * src_h / dst_h * src_stride +
3061 (x / factor) * src_w / dst_w;
3062 uint8_t *dst_ptr = dsts[i] + (y / factor) * dst_stride + (x / factor);
3064 if (src->flags & YV12_FLAG_HIGHBITDEPTH) {
3065 vpx_highbd_convolve8(CONVERT_TO_SHORTPTR(src_ptr), src_stride,
3066 CONVERT_TO_SHORTPTR(dst_ptr), dst_stride, kernel,
3067 x_q4 & 0xf, 16 * src_w / dst_w, y_q4 & 0xf,
3068 16 * src_h / dst_h, 16 / factor, 16 / factor,
3071 vpx_scaled_2d(src_ptr, src_stride, dst_ptr, dst_stride, kernel,
3072 x_q4 & 0xf, 16 * src_w / dst_w, y_q4 & 0xf,
3073 16 * src_h / dst_h, 16 / factor, 16 / factor);
3079 vpx_extend_frame_borders(dst);
3081 #endif // CONFIG_VP9_HIGHBITDEPTH
3083 #if !CONFIG_REALTIME_ONLY
3084 static int scale_down(VP9_COMP *cpi, int q) {
3085 RATE_CONTROL *const rc = &cpi->rc;
3086 GF_GROUP *const gf_group = &cpi->twopass.gf_group;
3088 assert(frame_is_kf_gf_arf(cpi));
3090 if (rc->frame_size_selector == UNSCALED &&
3091 q >= rc->rf_level_maxq[gf_group->rf_level[gf_group->index]]) {
3092 const int max_size_thresh =
3093 (int)(rate_thresh_mult[SCALE_STEP1] *
3094 VPXMAX(rc->this_frame_target, rc->avg_frame_bandwidth));
3095 scale = rc->projected_frame_size > max_size_thresh ? 1 : 0;
3100 static int big_rate_miss_high_threshold(VP9_COMP *cpi) {
3101 const RATE_CONTROL *const rc = &cpi->rc;
3104 if (frame_is_kf_gf_arf(cpi))
3105 big_miss_high = rc->this_frame_target * 3 / 2;
3107 big_miss_high = rc->this_frame_target * 2;
3109 return big_miss_high;
3112 static int big_rate_miss(VP9_COMP *cpi) {
3113 const RATE_CONTROL *const rc = &cpi->rc;
3117 // Ignore for overlay frames
3118 if (rc->is_src_frame_alt_ref) {
3121 big_miss_low = (rc->this_frame_target / 2);
3122 big_miss_high = big_rate_miss_high_threshold(cpi);
3124 return (rc->projected_frame_size > big_miss_high) ||
3125 (rc->projected_frame_size < big_miss_low);
3129 // test in two pass for the first
3130 static int two_pass_first_group_inter(VP9_COMP *cpi) {
3131 if (cpi->oxcf.pass == 2) {
3132 TWO_PASS *const twopass = &cpi->twopass;
3133 GF_GROUP *const gf_group = &twopass->gf_group;
3134 const int gfg_index = gf_group->index;
3136 if (gfg_index == 0) return gf_group->update_type[gfg_index] == LF_UPDATE;
3137 return gf_group->update_type[gfg_index - 1] != LF_UPDATE &&
3138 gf_group->update_type[gfg_index] == LF_UPDATE;
3144 // Function to test for conditions that indicate we should loop
3145 // back and recode a frame.
3146 static int recode_loop_test(VP9_COMP *cpi, int high_limit, int low_limit, int q,
3147 int maxq, int minq) {
3148 const RATE_CONTROL *const rc = &cpi->rc;
3149 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
3150 const int frame_is_kfgfarf = frame_is_kf_gf_arf(cpi);
3151 int force_recode = 0;
3153 if ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
3154 big_rate_miss(cpi) || (cpi->sf.recode_loop == ALLOW_RECODE) ||
3155 (two_pass_first_group_inter(cpi) &&
3156 (cpi->sf.recode_loop == ALLOW_RECODE_FIRST)) ||
3157 (frame_is_kfgfarf && (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF))) {
3158 if (frame_is_kfgfarf && (oxcf->resize_mode == RESIZE_DYNAMIC) &&
3159 scale_down(cpi, q)) {
3160 // Code this group at a lower resolution.
3161 cpi->resize_pending = 1;
3165 // Force recode for extreme overshoot.
3166 if ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
3167 (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF &&
3168 rc->projected_frame_size >= big_rate_miss_high_threshold(cpi))) {
3172 // TODO(agrange) high_limit could be greater than the scale-down threshold.
3173 if ((rc->projected_frame_size > high_limit && q < maxq) ||
3174 (rc->projected_frame_size < low_limit && q > minq)) {
3176 } else if (cpi->oxcf.rc_mode == VPX_CQ) {
3177 // Deal with frame undershoot and whether or not we are
3178 // below the automatically set cq level.
3179 if (q > oxcf->cq_level &&
3180 rc->projected_frame_size < ((rc->this_frame_target * 7) >> 3)) {
3185 return force_recode;
3187 #endif // !CONFIG_REALTIME_ONLY
3189 static void update_ref_frames(VP9_COMP *cpi) {
3190 VP9_COMMON *const cm = &cpi->common;
3191 BufferPool *const pool = cm->buffer_pool;
3192 GF_GROUP *const gf_group = &cpi->twopass.gf_group;
3194 if (cpi->rc.show_arf_as_gld) {
3195 int tmp = cpi->alt_fb_idx;
3196 cpi->alt_fb_idx = cpi->gld_fb_idx;
3197 cpi->gld_fb_idx = tmp;
3198 } else if (cm->show_existing_frame) {
3200 cpi->lst_fb_idx = cpi->alt_fb_idx;
3202 stack_pop(gf_group->arf_index_stack, gf_group->stack_size);
3203 --gf_group->stack_size;
3206 // At this point the new frame has been encoded.
3207 // If any buffer copy / swapping is signaled it should be done here.
3208 if (cm->frame_type == KEY_FRAME) {
3209 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
3211 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->alt_fb_idx],
3213 } else if (vp9_preserve_existing_gf(cpi)) {
3214 // We have decided to preserve the previously existing golden frame as our
3215 // new ARF frame. However, in the short term in function
3216 // vp9_get_refresh_mask() we left it in the GF slot and, if
3217 // we're updating the GF with the current decoded frame, we save it to the
3218 // ARF slot instead.
3219 // We now have to update the ARF with the current frame and swap gld_fb_idx
3220 // and alt_fb_idx so that, overall, we've stored the old GF in the new ARF
3221 // slot and, if we're updating the GF, the current frame becomes the new GF.
3224 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->alt_fb_idx],
3227 tmp = cpi->alt_fb_idx;
3228 cpi->alt_fb_idx = cpi->gld_fb_idx;
3229 cpi->gld_fb_idx = tmp;
3230 } else { /* For non key/golden frames */
3231 if (cpi->refresh_alt_ref_frame) {
3232 int arf_idx = gf_group->top_arf_idx;
3234 // Push new ARF into stack.
3235 stack_push(gf_group->arf_index_stack, cpi->alt_fb_idx,
3236 gf_group->stack_size);
3237 ++gf_group->stack_size;
3239 assert(arf_idx < REF_FRAMES);
3241 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[arf_idx], cm->new_fb_idx);
3242 memcpy(cpi->interp_filter_selected[ALTREF_FRAME],
3243 cpi->interp_filter_selected[0],
3244 sizeof(cpi->interp_filter_selected[0]));
3246 cpi->alt_fb_idx = arf_idx;
3249 if (cpi->refresh_golden_frame) {
3250 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
3252 if (!cpi->rc.is_src_frame_alt_ref)
3253 memcpy(cpi->interp_filter_selected[GOLDEN_FRAME],
3254 cpi->interp_filter_selected[0],
3255 sizeof(cpi->interp_filter_selected[0]));
3257 memcpy(cpi->interp_filter_selected[GOLDEN_FRAME],
3258 cpi->interp_filter_selected[ALTREF_FRAME],
3259 sizeof(cpi->interp_filter_selected[ALTREF_FRAME]));
3263 if (cpi->refresh_last_frame) {
3264 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->lst_fb_idx],
3266 if (!cpi->rc.is_src_frame_alt_ref)
3267 memcpy(cpi->interp_filter_selected[LAST_FRAME],
3268 cpi->interp_filter_selected[0],
3269 sizeof(cpi->interp_filter_selected[0]));
3272 if (gf_group->update_type[gf_group->index] == MID_OVERLAY_UPDATE) {
3274 stack_pop(gf_group->arf_index_stack, gf_group->stack_size);
3275 --gf_group->stack_size;
3279 void vp9_update_reference_frames(VP9_COMP *cpi) {
3280 update_ref_frames(cpi);
3282 #if CONFIG_VP9_TEMPORAL_DENOISING
3283 vp9_denoiser_update_ref_frame(cpi);
3286 if (is_one_pass_cbr_svc(cpi)) vp9_svc_update_ref_frame(cpi);
3289 static void loopfilter_frame(VP9_COMP *cpi, VP9_COMMON *cm) {
3290 MACROBLOCKD *xd = &cpi->td.mb.e_mbd;
3291 struct loopfilter *lf = &cm->lf;
3292 int is_reference_frame =
3293 (cm->frame_type == KEY_FRAME || cpi->refresh_last_frame ||
3294 cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame);
3296 cpi->svc.temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS)
3297 is_reference_frame = !cpi->svc.non_reference_frame;
3299 // Skip loop filter in show_existing_frame mode.
3300 if (cm->show_existing_frame) {
3301 lf->filter_level = 0;
3306 lf->filter_level = 0;
3307 lf->last_filt_level = 0;
3309 struct vpx_usec_timer timer;
3311 vpx_clear_system_state();
3313 vpx_usec_timer_start(&timer);
3315 if (!cpi->rc.is_src_frame_alt_ref) {
3316 if ((cpi->common.frame_type == KEY_FRAME) &&
3317 (!cpi->rc.this_key_frame_forced)) {
3318 lf->last_filt_level = 0;
3320 vp9_pick_filter_level(cpi->Source, cpi, cpi->sf.lpf_pick);
3321 lf->last_filt_level = lf->filter_level;
3323 lf->filter_level = 0;
3326 vpx_usec_timer_mark(&timer);
3327 cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
3330 if (lf->filter_level > 0 && is_reference_frame) {
3331 vp9_build_mask_frame(cm, lf->filter_level, 0);
3333 if (cpi->num_workers > 1)
3334 vp9_loop_filter_frame_mt(cm->frame_to_show, cm, xd->plane,
3335 lf->filter_level, 0, 0, cpi->workers,
3336 cpi->num_workers, &cpi->lf_row_sync);
3338 vp9_loop_filter_frame(cm->frame_to_show, cm, xd, lf->filter_level, 0, 0);
3341 vpx_extend_frame_inner_borders(cm->frame_to_show);
3344 static INLINE void alloc_frame_mvs(VP9_COMMON *const cm, int buffer_idx) {
3345 RefCntBuffer *const new_fb_ptr = &cm->buffer_pool->frame_bufs[buffer_idx];
3346 if (new_fb_ptr->mvs == NULL || new_fb_ptr->mi_rows < cm->mi_rows ||
3347 new_fb_ptr->mi_cols < cm->mi_cols) {
3348 vpx_free(new_fb_ptr->mvs);
3349 CHECK_MEM_ERROR(cm, new_fb_ptr->mvs,
3350 (MV_REF *)vpx_calloc(cm->mi_rows * cm->mi_cols,
3351 sizeof(*new_fb_ptr->mvs)));
3352 new_fb_ptr->mi_rows = cm->mi_rows;
3353 new_fb_ptr->mi_cols = cm->mi_cols;
3357 void vp9_scale_references(VP9_COMP *cpi) {
3358 VP9_COMMON *cm = &cpi->common;
3359 MV_REFERENCE_FRAME ref_frame;
3360 const VP9_REFFRAME ref_mask[3] = { VP9_LAST_FLAG, VP9_GOLD_FLAG,
3363 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3364 // Need to convert from VP9_REFFRAME to index into ref_mask (subtract 1).
3365 if (cpi->ref_frame_flags & ref_mask[ref_frame - 1]) {
3366 BufferPool *const pool = cm->buffer_pool;
3367 const YV12_BUFFER_CONFIG *const ref =
3368 get_ref_frame_buffer(cpi, ref_frame);
3371 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3375 #if CONFIG_VP9_HIGHBITDEPTH
3376 if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) {
3377 RefCntBuffer *new_fb_ptr = NULL;
3378 int force_scaling = 0;
3379 int new_fb = cpi->scaled_ref_idx[ref_frame - 1];
3380 if (new_fb == INVALID_IDX) {
3381 new_fb = get_free_fb(cm);
3384 if (new_fb == INVALID_IDX) return;
3385 new_fb_ptr = &pool->frame_bufs[new_fb];
3386 if (force_scaling || new_fb_ptr->buf.y_crop_width != cm->width ||
3387 new_fb_ptr->buf.y_crop_height != cm->height) {
3388 if (vpx_realloc_frame_buffer(&new_fb_ptr->buf, cm->width, cm->height,
3389 cm->subsampling_x, cm->subsampling_y,
3390 cm->use_highbitdepth,
3391 VP9_ENC_BORDER_IN_PIXELS,
3392 cm->byte_alignment, NULL, NULL, NULL))
3393 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3394 "Failed to allocate frame buffer");
3395 scale_and_extend_frame(ref, &new_fb_ptr->buf, (int)cm->bit_depth,
3397 cpi->scaled_ref_idx[ref_frame - 1] = new_fb;
3398 alloc_frame_mvs(cm, new_fb);
3401 if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) {
3402 RefCntBuffer *new_fb_ptr = NULL;
3403 int force_scaling = 0;
3404 int new_fb = cpi->scaled_ref_idx[ref_frame - 1];
3405 if (new_fb == INVALID_IDX) {
3406 new_fb = get_free_fb(cm);
3409 if (new_fb == INVALID_IDX) return;
3410 new_fb_ptr = &pool->frame_bufs[new_fb];
3411 if (force_scaling || new_fb_ptr->buf.y_crop_width != cm->width ||
3412 new_fb_ptr->buf.y_crop_height != cm->height) {
3413 if (vpx_realloc_frame_buffer(&new_fb_ptr->buf, cm->width, cm->height,
3414 cm->subsampling_x, cm->subsampling_y,
3415 VP9_ENC_BORDER_IN_PIXELS,
3416 cm->byte_alignment, NULL, NULL, NULL))
3417 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3418 "Failed to allocate frame buffer");
3419 vp9_scale_and_extend_frame(ref, &new_fb_ptr->buf, EIGHTTAP, 0);
3420 cpi->scaled_ref_idx[ref_frame - 1] = new_fb;
3421 alloc_frame_mvs(cm, new_fb);
3423 #endif // CONFIG_VP9_HIGHBITDEPTH
3426 RefCntBuffer *buf = NULL;
3427 if (cpi->oxcf.pass == 0 && !cpi->use_svc) {
3428 // Check for release of scaled reference.
3429 buf_idx = cpi->scaled_ref_idx[ref_frame - 1];
3430 if (buf_idx != INVALID_IDX) {
3431 buf = &pool->frame_bufs[buf_idx];
3433 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3436 buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
3437 buf = &pool->frame_bufs[buf_idx];
3438 buf->buf.y_crop_width = ref->y_crop_width;
3439 buf->buf.y_crop_height = ref->y_crop_height;
3440 cpi->scaled_ref_idx[ref_frame - 1] = buf_idx;
3444 if (cpi->oxcf.pass != 0 || cpi->use_svc)
3445 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3450 static void release_scaled_references(VP9_COMP *cpi) {
3451 VP9_COMMON *cm = &cpi->common;
3453 if (cpi->oxcf.pass == 0 && !cpi->use_svc) {
3454 // Only release scaled references under certain conditions:
3455 // if reference will be updated, or if scaled reference has same resolution.
3457 refresh[0] = (cpi->refresh_last_frame) ? 1 : 0;
3458 refresh[1] = (cpi->refresh_golden_frame) ? 1 : 0;
3459 refresh[2] = (cpi->refresh_alt_ref_frame) ? 1 : 0;
3460 for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
3461 const int idx = cpi->scaled_ref_idx[i - 1];
3462 if (idx != INVALID_IDX) {
3463 RefCntBuffer *const buf = &cm->buffer_pool->frame_bufs[idx];
3464 const YV12_BUFFER_CONFIG *const ref = get_ref_frame_buffer(cpi, i);
3465 if (refresh[i - 1] || (buf->buf.y_crop_width == ref->y_crop_width &&
3466 buf->buf.y_crop_height == ref->y_crop_height)) {
3468 cpi->scaled_ref_idx[i - 1] = INVALID_IDX;
3473 for (i = 0; i < REFS_PER_FRAME; ++i) {
3474 const int idx = cpi->scaled_ref_idx[i];
3475 if (idx != INVALID_IDX) {
3476 RefCntBuffer *const buf = &cm->buffer_pool->frame_bufs[idx];
3478 cpi->scaled_ref_idx[i] = INVALID_IDX;
3484 static void full_to_model_count(unsigned int *model_count,
3485 unsigned int *full_count) {
3487 model_count[ZERO_TOKEN] = full_count[ZERO_TOKEN];
3488 model_count[ONE_TOKEN] = full_count[ONE_TOKEN];
3489 model_count[TWO_TOKEN] = full_count[TWO_TOKEN];
3490 for (n = THREE_TOKEN; n < EOB_TOKEN; ++n)
3491 model_count[TWO_TOKEN] += full_count[n];
3492 model_count[EOB_MODEL_TOKEN] = full_count[EOB_TOKEN];
3495 static void full_to_model_counts(vp9_coeff_count_model *model_count,
3496 vp9_coeff_count *full_count) {
3499 for (i = 0; i < PLANE_TYPES; ++i)
3500 for (j = 0; j < REF_TYPES; ++j)
3501 for (k = 0; k < COEF_BANDS; ++k)
3502 for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l)
3503 full_to_model_count(model_count[i][j][k][l], full_count[i][j][k][l]);
3506 #if 0 && CONFIG_INTERNAL_STATS
3507 static void output_frame_level_debug_stats(VP9_COMP *cpi) {
3508 VP9_COMMON *const cm = &cpi->common;
3509 FILE *const f = fopen("tmp.stt", cm->current_video_frame ? "a" : "w");
3512 vpx_clear_system_state();
3514 #if CONFIG_VP9_HIGHBITDEPTH
3515 if (cm->use_highbitdepth) {
3516 recon_err = vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3518 recon_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3521 recon_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3522 #endif // CONFIG_VP9_HIGHBITDEPTH
3525 if (cpi->twopass.total_left_stats.coded_error != 0.0) {
3526 double dc_quant_devisor;
3527 #if CONFIG_VP9_HIGHBITDEPTH
3528 switch (cm->bit_depth) {
3530 dc_quant_devisor = 4.0;
3533 dc_quant_devisor = 16.0;
3536 assert(cm->bit_depth == VPX_BITS_12);
3537 dc_quant_devisor = 64.0;
3541 dc_quant_devisor = 4.0;
3544 if (!cm->current_video_frame) {
3545 fprintf(f, "frame, width, height, last ts, last end ts, "
3546 "source_alt_ref_pending, source_alt_ref_active, "
3547 "this_frame_target, projected_frame_size, "
3548 "projected_frame_size / MBs, "
3549 "projected_frame_size - this_frame_target, "
3550 "vbr_bits_off_target, vbr_bits_off_target_fast, "
3551 "twopass.extend_minq, twopass.extend_minq_fast, "
3552 "total_target_vs_actual, "
3553 "starting_buffer_level - bits_off_target, "
3554 "total_actual_bits, base_qindex, q for base_qindex, "
3555 "dc quant, q for active_worst_quality, avg_q, q for oxcf.cq_level, "
3556 "refresh_last_frame, refresh_golden_frame, refresh_alt_ref_frame, "
3557 "frame_type, gfu_boost, "
3558 "twopass.bits_left, "
3559 "twopass.total_left_stats.coded_error, "
3560 "twopass.bits_left / (1 + twopass.total_left_stats.coded_error), "
3561 "tot_recode_hits, recon_err, kf_boost, "
3562 "twopass.kf_zeromotion_pct, twopass.fr_content_type, "
3563 "filter_level, seg.aq_av_offset\n");
3566 fprintf(f, "%10u, %d, %d, %10"PRId64", %10"PRId64", %d, %d, %10d, %10d, "
3567 "%10d, %10d, %10"PRId64", %10"PRId64", %5d, %5d, %10"PRId64", "
3568 "%10"PRId64", %10"PRId64", %10d, %7.2lf, %7.2lf, %7.2lf, %7.2lf, "
3569 "%7.2lf, %6d, %6d, %5d, %5d, %5d, %10"PRId64", %10.3lf, %10lf, %8u, "
3570 "%10"PRId64", %10d, %10d, %10d, %10d, %10d\n",
3571 cpi->common.current_video_frame,
3572 cm->width, cm->height,
3573 cpi->last_time_stamp_seen,
3574 cpi->last_end_time_stamp_seen,
3575 cpi->rc.source_alt_ref_pending,
3576 cpi->rc.source_alt_ref_active,
3577 cpi->rc.this_frame_target,
3578 cpi->rc.projected_frame_size,
3579 cpi->rc.projected_frame_size / cpi->common.MBs,
3580 (cpi->rc.projected_frame_size - cpi->rc.this_frame_target),
3581 cpi->rc.vbr_bits_off_target,
3582 cpi->rc.vbr_bits_off_target_fast,
3583 cpi->twopass.extend_minq,
3584 cpi->twopass.extend_minq_fast,
3585 cpi->rc.total_target_vs_actual,
3586 (cpi->rc.starting_buffer_level - cpi->rc.bits_off_target),
3587 cpi->rc.total_actual_bits, cm->base_qindex,
3588 vp9_convert_qindex_to_q(cm->base_qindex, cm->bit_depth),
3589 (double)vp9_dc_quant(cm->base_qindex, 0, cm->bit_depth) /
3591 vp9_convert_qindex_to_q(cpi->twopass.active_worst_quality,
3594 vp9_convert_qindex_to_q(cpi->oxcf.cq_level, cm->bit_depth),
3595 cpi->refresh_last_frame, cpi->refresh_golden_frame,
3596 cpi->refresh_alt_ref_frame, cm->frame_type, cpi->rc.gfu_boost,
3597 cpi->twopass.bits_left,
3598 cpi->twopass.total_left_stats.coded_error,
3599 cpi->twopass.bits_left /
3600 (1 + cpi->twopass.total_left_stats.coded_error),
3601 cpi->tot_recode_hits, recon_err, cpi->rc.kf_boost,
3602 cpi->twopass.kf_zeromotion_pct,
3603 cpi->twopass.fr_content_type,
3604 cm->lf.filter_level,
3605 cm->seg.aq_av_offset);
3610 FILE *const fmodes = fopen("Modes.stt", "a");
3613 fprintf(fmodes, "%6d:%1d:%1d:%1d ", cpi->common.current_video_frame,
3614 cm->frame_type, cpi->refresh_golden_frame,
3615 cpi->refresh_alt_ref_frame);
3617 for (i = 0; i < MAX_MODES; ++i)
3618 fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
3620 fprintf(fmodes, "\n");
3627 static void set_mv_search_params(VP9_COMP *cpi) {
3628 const VP9_COMMON *const cm = &cpi->common;
3629 const unsigned int max_mv_def = VPXMIN(cm->width, cm->height);
3631 // Default based on max resolution.
3632 cpi->mv_step_param = vp9_init_search_range(max_mv_def);
3634 if (cpi->sf.mv.auto_mv_step_size) {
3635 if (frame_is_intra_only(cm)) {
3636 // Initialize max_mv_magnitude for use in the first INTER frame
3637 // after a key/intra-only frame.
3638 cpi->max_mv_magnitude = max_mv_def;
3640 if (cm->show_frame) {
3641 // Allow mv_steps to correspond to twice the max mv magnitude found
3642 // in the previous frame, capped by the default max_mv_magnitude based
3644 cpi->mv_step_param = vp9_init_search_range(
3645 VPXMIN(max_mv_def, 2 * cpi->max_mv_magnitude));
3647 cpi->max_mv_magnitude = 0;
3652 static void set_size_independent_vars(VP9_COMP *cpi) {
3653 vp9_set_speed_features_framesize_independent(cpi, cpi->oxcf.speed);
3654 vp9_set_rd_speed_thresholds(cpi);
3655 vp9_set_rd_speed_thresholds_sub8x8(cpi);
3656 cpi->common.interp_filter = cpi->sf.default_interp_filter;
3659 static void set_size_dependent_vars(VP9_COMP *cpi, int *q, int *bottom_index,
3661 VP9_COMMON *const cm = &cpi->common;
3663 // Setup variables that depend on the dimensions of the frame.
3664 vp9_set_speed_features_framesize_dependent(cpi, cpi->oxcf.speed);
3666 // Decide q and q bounds.
3667 *q = vp9_rc_pick_q_and_bounds(cpi, bottom_index, top_index);
3669 if (cpi->oxcf.rc_mode == VPX_CBR && cpi->rc.force_max_q) {
3670 *q = cpi->rc.worst_quality;
3671 cpi->rc.force_max_q = 0;
3674 if (!frame_is_intra_only(cm)) {
3675 vp9_set_high_precision_mv(cpi, (*q) < HIGH_PRECISION_MV_QTHRESH);
3678 #if !CONFIG_REALTIME_ONLY
3679 // Configure experimental use of segmentation for enhanced coding of
3680 // static regions if indicated.
3681 // Only allowed in the second pass of a two pass encode, as it requires
3682 // lagged coding, and if the relevant speed feature flag is set.
3683 if (cpi->oxcf.pass == 2 && cpi->sf.static_segmentation)
3684 configure_static_seg_features(cpi);
3685 #endif // !CONFIG_REALTIME_ONLY
3687 #if CONFIG_VP9_POSTPROC && !(CONFIG_VP9_TEMPORAL_DENOISING)
3688 if (cpi->oxcf.noise_sensitivity > 0) {
3690 switch (cpi->oxcf.noise_sensitivity) {
3691 case 1: l = 20; break;
3692 case 2: l = 40; break;
3693 case 3: l = 60; break;
3695 case 5: l = 100; break;
3696 case 6: l = 150; break;
3698 if (!cpi->common.postproc_state.limits) {
3699 cpi->common.postproc_state.limits =
3700 vpx_calloc(cpi->un_scaled_source->y_width,
3701 sizeof(*cpi->common.postproc_state.limits));
3703 vp9_denoise(&cpi->common, cpi->Source, cpi->Source, l,
3704 cpi->common.postproc_state.limits);
3706 #endif // CONFIG_VP9_POSTPROC
3709 static void init_motion_estimation(VP9_COMP *cpi) {
3710 int y_stride = cpi->scaled_source.y_stride;
3712 if (cpi->sf.mv.search_method == NSTEP) {
3713 vp9_init3smotion_compensation(&cpi->ss_cfg, y_stride);
3714 } else if (cpi->sf.mv.search_method == DIAMOND) {
3715 vp9_init_dsmotion_compensation(&cpi->ss_cfg, y_stride);
3719 static void set_frame_size(VP9_COMP *cpi) {
3721 VP9_COMMON *const cm = &cpi->common;
3722 VP9EncoderConfig *const oxcf = &cpi->oxcf;
3723 MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
3725 #if !CONFIG_REALTIME_ONLY
3726 if (oxcf->pass == 2 && oxcf->rc_mode == VPX_VBR &&
3727 ((oxcf->resize_mode == RESIZE_FIXED && cm->current_video_frame == 0) ||
3728 (oxcf->resize_mode == RESIZE_DYNAMIC && cpi->resize_pending))) {
3729 calculate_coded_size(cpi, &oxcf->scaled_frame_width,
3730 &oxcf->scaled_frame_height);
3732 // There has been a change in frame size.
3733 vp9_set_size_literal(cpi, oxcf->scaled_frame_width,
3734 oxcf->scaled_frame_height);
3736 #endif // !CONFIG_REALTIME_ONLY
3738 if (oxcf->pass == 0 && oxcf->rc_mode == VPX_CBR && !cpi->use_svc &&
3739 oxcf->resize_mode == RESIZE_DYNAMIC && cpi->resize_pending != 0) {
3740 oxcf->scaled_frame_width =
3741 (oxcf->width * cpi->resize_scale_num) / cpi->resize_scale_den;
3742 oxcf->scaled_frame_height =
3743 (oxcf->height * cpi->resize_scale_num) / cpi->resize_scale_den;
3744 // There has been a change in frame size.
3745 vp9_set_size_literal(cpi, oxcf->scaled_frame_width,
3746 oxcf->scaled_frame_height);
3748 // TODO(agrange) Scale cpi->max_mv_magnitude if frame-size has changed.
3749 set_mv_search_params(cpi);
3751 vp9_noise_estimate_init(&cpi->noise_estimate, cm->width, cm->height);
3752 #if CONFIG_VP9_TEMPORAL_DENOISING
3753 // Reset the denoiser on the resized frame.
3754 if (cpi->oxcf.noise_sensitivity > 0) {
3755 vp9_denoiser_free(&(cpi->denoiser));
3756 setup_denoiser_buffer(cpi);
3757 // Dynamic resize is only triggered for non-SVC, so we can force
3758 // golden frame update here as temporary fix to denoiser.
3759 cpi->refresh_golden_frame = 1;
3764 if ((oxcf->pass == 2) && !cpi->use_svc) {
3765 vp9_set_target_rate(cpi);
3768 alloc_frame_mvs(cm, cm->new_fb_idx);
3770 // Reset the frame pointers to the current frame size.
3771 if (vpx_realloc_frame_buffer(get_frame_new_buffer(cm), cm->width, cm->height,
3772 cm->subsampling_x, cm->subsampling_y,
3773 #if CONFIG_VP9_HIGHBITDEPTH
3774 cm->use_highbitdepth,
3776 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
3778 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3779 "Failed to allocate frame buffer");
3781 alloc_util_frame_buffers(cpi);
3782 init_motion_estimation(cpi);
3784 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3785 RefBuffer *const ref_buf = &cm->frame_refs[ref_frame - 1];
3786 const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
3788 ref_buf->idx = buf_idx;
3790 if (buf_idx != INVALID_IDX) {
3791 YV12_BUFFER_CONFIG *const buf = &cm->buffer_pool->frame_bufs[buf_idx].buf;
3793 #if CONFIG_VP9_HIGHBITDEPTH
3794 vp9_setup_scale_factors_for_frame(
3795 &ref_buf->sf, buf->y_crop_width, buf->y_crop_height, cm->width,
3796 cm->height, (buf->flags & YV12_FLAG_HIGHBITDEPTH) ? 1 : 0);
3798 vp9_setup_scale_factors_for_frame(&ref_buf->sf, buf->y_crop_width,
3799 buf->y_crop_height, cm->width,
3801 #endif // CONFIG_VP9_HIGHBITDEPTH
3802 if (vp9_is_scaled(&ref_buf->sf)) vpx_extend_frame_borders(buf);
3804 ref_buf->buf = NULL;
3808 set_ref_ptrs(cm, xd, LAST_FRAME, LAST_FRAME);
3811 #if CONFIG_CONSISTENT_RECODE
3812 static void save_encode_params(VP9_COMP *cpi) {
3813 VP9_COMMON *const cm = &cpi->common;
3814 const int tile_cols = 1 << cm->log2_tile_cols;
3815 const int tile_rows = 1 << cm->log2_tile_rows;
3816 int tile_col, tile_row;
3818 RD_OPT *rd_opt = &cpi->rd;
3819 for (i = 0; i < MAX_REF_FRAMES; i++) {
3820 for (j = 0; j < REFERENCE_MODES; j++)
3821 rd_opt->prediction_type_threshes_prev[i][j] =
3822 rd_opt->prediction_type_threshes[i][j];
3824 for (j = 0; j < SWITCHABLE_FILTER_CONTEXTS; j++)
3825 rd_opt->filter_threshes_prev[i][j] = rd_opt->filter_threshes[i][j];
3828 if (cpi->tile_data != NULL) {
3829 for (tile_row = 0; tile_row < tile_rows; ++tile_row)
3830 for (tile_col = 0; tile_col < tile_cols; ++tile_col) {
3831 TileDataEnc *tile_data =
3832 &cpi->tile_data[tile_row * tile_cols + tile_col];
3833 for (i = 0; i < BLOCK_SIZES; ++i) {
3834 for (j = 0; j < MAX_MODES; ++j) {
3835 tile_data->thresh_freq_fact_prev[i][j] =
3836 tile_data->thresh_freq_fact[i][j];
3844 static INLINE void set_raw_source_frame(VP9_COMP *cpi) {
3845 #ifdef ENABLE_KF_DENOISE
3846 if (is_spatial_denoise_enabled(cpi)) {
3847 cpi->raw_source_frame = vp9_scale_if_required(
3848 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
3849 (oxcf->pass == 0), EIGHTTAP, 0);
3851 cpi->raw_source_frame = cpi->Source;
3854 cpi->raw_source_frame = cpi->Source;
3858 static int encode_without_recode_loop(VP9_COMP *cpi, size_t *size,
3860 VP9_COMMON *const cm = &cpi->common;
3861 SVC *const svc = &cpi->svc;
3862 int q = 0, bottom_index = 0, top_index = 0;
3863 int no_drop_scene_change = 0;
3864 const INTERP_FILTER filter_scaler =
3865 (is_one_pass_cbr_svc(cpi))
3866 ? svc->downsample_filter_type[svc->spatial_layer_id]
3868 const int phase_scaler =
3869 (is_one_pass_cbr_svc(cpi))
3870 ? svc->downsample_filter_phase[svc->spatial_layer_id]
3873 if (cm->show_existing_frame) {
3874 cpi->rc.this_frame_target = 0;
3875 if (is_psnr_calc_enabled(cpi)) set_raw_source_frame(cpi);
3879 svc->time_stamp_prev[svc->spatial_layer_id] = svc->time_stamp_superframe;
3881 // Flag to check if its valid to compute the source sad (used for
3882 // scene detection and for superblock content state in CBR mode).
3883 // The flag may get reset below based on SVC or resizing state.
3884 cpi->compute_source_sad_onepass = cpi->oxcf.mode == REALTIME;
3886 vpx_clear_system_state();
3888 set_frame_size(cpi);
3890 if (is_one_pass_cbr_svc(cpi) &&
3891 cpi->un_scaled_source->y_width == cm->width << 2 &&
3892 cpi->un_scaled_source->y_height == cm->height << 2 &&
3893 svc->scaled_temp.y_width == cm->width << 1 &&
3894 svc->scaled_temp.y_height == cm->height << 1) {
3895 // For svc, if it is a 1/4x1/4 downscaling, do a two-stage scaling to take
3896 // advantage of the 1:2 optimized scaler. In the process, the 1/2x1/2
3897 // result will be saved in scaled_temp and might be used later.
3898 const INTERP_FILTER filter_scaler2 = svc->downsample_filter_type[1];
3899 const int phase_scaler2 = svc->downsample_filter_phase[1];
3900 cpi->Source = vp9_svc_twostage_scale(
3901 cm, cpi->un_scaled_source, &cpi->scaled_source, &svc->scaled_temp,
3902 filter_scaler, phase_scaler, filter_scaler2, phase_scaler2);
3903 svc->scaled_one_half = 1;
3904 } else if (is_one_pass_cbr_svc(cpi) &&
3905 cpi->un_scaled_source->y_width == cm->width << 1 &&
3906 cpi->un_scaled_source->y_height == cm->height << 1 &&
3907 svc->scaled_one_half) {
3908 // If the spatial layer is 1/2x1/2 and the scaling is already done in the
3909 // two-stage scaling, use the result directly.
3910 cpi->Source = &svc->scaled_temp;
3911 svc->scaled_one_half = 0;
3913 cpi->Source = vp9_scale_if_required(
3914 cm, cpi->un_scaled_source, &cpi->scaled_source, (cpi->oxcf.pass == 0),
3915 filter_scaler, phase_scaler);
3917 #ifdef OUTPUT_YUV_SVC_SRC
3918 // Write out at most 3 spatial layers.
3919 if (is_one_pass_cbr_svc(cpi) && svc->spatial_layer_id < 3) {
3920 vpx_write_yuv_frame(yuv_svc_src[svc->spatial_layer_id], cpi->Source);
3923 // Unfiltered raw source used in metrics calculation if the source
3924 // has been filtered.
3925 if (is_psnr_calc_enabled(cpi)) {
3926 #ifdef ENABLE_KF_DENOISE
3927 if (is_spatial_denoise_enabled(cpi)) {
3928 cpi->raw_source_frame = vp9_scale_if_required(
3929 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
3930 (cpi->oxcf.pass == 0), EIGHTTAP, phase_scaler);
3932 cpi->raw_source_frame = cpi->Source;
3935 cpi->raw_source_frame = cpi->Source;
3939 if ((cpi->use_svc &&
3940 (svc->spatial_layer_id < svc->number_spatial_layers - 1 ||
3941 svc->temporal_layer_id < svc->number_temporal_layers - 1 ||
3942 svc->current_superframe < 1)) ||
3943 cpi->resize_pending || cpi->resize_state || cpi->external_resize ||
3944 cpi->resize_state != ORIG) {
3945 cpi->compute_source_sad_onepass = 0;
3946 if (cpi->content_state_sb_fd != NULL)
3947 memset(cpi->content_state_sb_fd, 0,
3948 (cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1) *
3949 sizeof(*cpi->content_state_sb_fd));
3952 // Avoid scaling last_source unless its needed.
3953 // Last source is needed if avg_source_sad() is used, or if
3954 // partition_search_type == SOURCE_VAR_BASED_PARTITION, or if noise
3955 // estimation is enabled.
3956 if (cpi->unscaled_last_source != NULL &&
3957 (cpi->oxcf.content == VP9E_CONTENT_SCREEN ||
3958 (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == VPX_VBR &&
3959 cpi->oxcf.mode == REALTIME && cpi->oxcf.speed >= 5) ||
3960 cpi->sf.partition_search_type == SOURCE_VAR_BASED_PARTITION ||
3961 (cpi->noise_estimate.enabled && !cpi->oxcf.noise_sensitivity) ||
3962 cpi->compute_source_sad_onepass))
3963 cpi->Last_Source = vp9_scale_if_required(
3964 cm, cpi->unscaled_last_source, &cpi->scaled_last_source,
3965 (cpi->oxcf.pass == 0), EIGHTTAP, 0);
3967 if (cpi->Last_Source == NULL ||
3968 cpi->Last_Source->y_width != cpi->Source->y_width ||
3969 cpi->Last_Source->y_height != cpi->Source->y_height)
3970 cpi->compute_source_sad_onepass = 0;
3972 if (frame_is_intra_only(cm) || cpi->resize_pending != 0) {
3973 memset(cpi->consec_zero_mv, 0,
3974 cm->mi_rows * cm->mi_cols * sizeof(*cpi->consec_zero_mv));
3977 #if CONFIG_VP9_TEMPORAL_DENOISING
3978 if (cpi->oxcf.noise_sensitivity > 0 && cpi->use_svc)
3979 vp9_denoiser_reset_on_first_frame(cpi);
3982 // Scene detection is always used for VBR mode or screen-content case.
3983 // For other cases (e.g., CBR mode) use it for 5 <= speed < 8 for now
3984 // (need to check encoding time cost for doing this for speed 8).
3985 cpi->rc.high_source_sad = 0;
3986 cpi->rc.hybrid_intra_scene_change = 0;
3987 cpi->rc.re_encode_maxq_scene_change = 0;
3988 if (cm->show_frame && cpi->oxcf.mode == REALTIME &&
3989 (cpi->oxcf.rc_mode == VPX_VBR ||
3990 cpi->oxcf.content == VP9E_CONTENT_SCREEN ||
3991 (cpi->oxcf.speed >= 5 && cpi->oxcf.speed < 8)))
3992 vp9_scene_detection_onepass(cpi);
3994 if (svc->spatial_layer_id == svc->first_spatial_layer_to_encode) {
3995 svc->high_source_sad_superframe = cpi->rc.high_source_sad;
3996 svc->high_num_blocks_with_motion = cpi->rc.high_num_blocks_with_motion;
3997 // On scene change reset temporal layer pattern to TL0.
3998 // Note that if the base/lower spatial layers are skipped: instead of
3999 // inserting base layer here, we force max-q for the next superframe
4000 // with lower spatial layers: this is done in vp9_encodedframe_overshoot()
4001 // when max-q is decided for the current layer.
4002 // Only do this reset for bypass/flexible mode.
4003 if (svc->high_source_sad_superframe && svc->temporal_layer_id > 0 &&
4004 svc->temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS) {
4005 // rc->high_source_sad will get reset so copy it to restore it.
4006 int tmp_high_source_sad = cpi->rc.high_source_sad;
4007 vp9_svc_reset_temporal_layers(cpi, cm->frame_type == KEY_FRAME);
4008 cpi->rc.high_source_sad = tmp_high_source_sad;
4012 vp9_update_noise_estimate(cpi);
4014 // For 1 pass CBR, check if we are dropping this frame.
4015 // Never drop on key frame, if base layer is key for svc,
4016 // on scene change, or if superframe has layer sync.
4017 if ((cpi->rc.high_source_sad || svc->high_source_sad_superframe) &&
4018 !(cpi->rc.use_post_encode_drop && svc->last_layer_dropped[0]))
4019 no_drop_scene_change = 1;
4020 if (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == VPX_CBR &&
4021 !frame_is_intra_only(cm) && !no_drop_scene_change &&
4022 !svc->superframe_has_layer_sync &&
4024 !svc->layer_context[svc->temporal_layer_id].is_key_frame)) {
4025 if (vp9_rc_drop_frame(cpi)) return 0;
4028 // For 1 pass CBR SVC, only ZEROMV is allowed for spatial reference frame
4029 // when svc->force_zero_mode_spatial_ref = 1. Under those conditions we can
4030 // avoid this frame-level upsampling (for non intra_only frames).
4031 if (frame_is_intra_only(cm) == 0 &&
4032 !(is_one_pass_cbr_svc(cpi) && svc->force_zero_mode_spatial_ref)) {
4033 vp9_scale_references(cpi);
4036 set_size_independent_vars(cpi);
4037 set_size_dependent_vars(cpi, &q, &bottom_index, &top_index);
4039 // search method and step parameter might be changed in speed settings.
4040 init_motion_estimation(cpi);
4042 if (cpi->sf.copy_partition_flag) alloc_copy_partition_data(cpi);
4044 if (cpi->sf.svc_use_lowres_part &&
4045 svc->spatial_layer_id == svc->number_spatial_layers - 2) {
4046 if (svc->prev_partition_svc == NULL) {
4048 cm, svc->prev_partition_svc,
4049 (BLOCK_SIZE *)vpx_calloc(cm->mi_stride * cm->mi_rows,
4050 sizeof(*svc->prev_partition_svc)));
4054 // TODO(jianj): Look into issue of skin detection with high bitdepth.
4055 if (cm->bit_depth == 8 && cpi->oxcf.speed >= 5 && cpi->oxcf.pass == 0 &&
4056 cpi->oxcf.rc_mode == VPX_CBR &&
4057 cpi->oxcf.content != VP9E_CONTENT_SCREEN &&
4058 cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
4059 cpi->use_skin_detection = 1;
4062 // Enable post encode frame dropping for CBR on non key frame, when
4063 // ext_use_post_encode_drop is specified by user.
4064 cpi->rc.use_post_encode_drop = cpi->rc.ext_use_post_encode_drop &&
4065 cpi->oxcf.rc_mode == VPX_CBR &&
4066 cm->frame_type != KEY_FRAME;
4068 vp9_set_quantizer(cm, q);
4069 vp9_set_variance_partition_thresholds(cpi, q, 0);
4073 suppress_active_map(cpi);
4076 // On non-zero spatial layer, check for disabling inter-layer
4078 if (svc->spatial_layer_id > 0) vp9_svc_constrain_inter_layer_pred(cpi);
4079 vp9_svc_assert_constraints_pattern(cpi);
4082 if (cpi->rc.last_post_encode_dropped_scene_change) {
4083 cpi->rc.high_source_sad = 1;
4084 svc->high_source_sad_superframe = 1;
4085 // For now disable use_source_sad since Last_Source will not be the previous
4086 // encoded but the dropped one.
4087 cpi->sf.use_source_sad = 0;
4088 cpi->rc.last_post_encode_dropped_scene_change = 0;
4090 // Check if this high_source_sad (scene/slide change) frame should be
4091 // encoded at high/max QP, and if so, set the q and adjust some rate
4092 // control parameters.
4093 if (cpi->sf.overshoot_detection_cbr_rt == FAST_DETECTION_MAXQ &&
4094 (cpi->rc.high_source_sad ||
4095 (cpi->use_svc && svc->high_source_sad_superframe))) {
4096 if (vp9_encodedframe_overshoot(cpi, -1, &q)) {
4097 vp9_set_quantizer(cm, q);
4098 vp9_set_variance_partition_thresholds(cpi, q, 0);
4102 #if !CONFIG_REALTIME_ONLY
4103 // Variance adaptive and in frame q adjustment experiments are mutually
4105 if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
4106 vp9_vaq_frame_setup(cpi);
4107 } else if (cpi->oxcf.aq_mode == EQUATOR360_AQ) {
4108 vp9_360aq_frame_setup(cpi);
4109 } else if (cpi->oxcf.aq_mode == COMPLEXITY_AQ) {
4110 vp9_setup_in_frame_q_adj(cpi);
4111 } else if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ) {
4112 // it may be pretty bad for rate-control,
4113 // and I should handle it somehow
4114 vp9_alt_ref_aq_setup_map(cpi->alt_ref_aq, cpi);
4117 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
4118 vp9_cyclic_refresh_setup(cpi);
4119 } else if (cpi->roi.enabled && !frame_is_intra_only(cm)) {
4122 #if !CONFIG_REALTIME_ONLY
4126 apply_active_map(cpi);
4128 vp9_encode_frame(cpi);
4130 // Check if we should re-encode this frame at high Q because of high
4131 // overshoot based on the encoded frame size. Only for frames where
4132 // high temporal-source SAD is detected.
4133 // For SVC: all spatial layers are checked for re-encoding.
4134 if (cpi->sf.overshoot_detection_cbr_rt == RE_ENCODE_MAXQ &&
4135 (cpi->rc.high_source_sad ||
4136 (cpi->use_svc && svc->high_source_sad_superframe))) {
4138 // Get an estimate of the encoded frame size.
4139 save_coding_context(cpi);
4140 vp9_pack_bitstream(cpi, dest, size);
4141 restore_coding_context(cpi);
4142 frame_size = (int)(*size) << 3;
4143 // Check if encoded frame will overshoot too much, and if so, set the q and
4144 // adjust some rate control parameters, and return to re-encode the frame.
4145 if (vp9_encodedframe_overshoot(cpi, frame_size, &q)) {
4146 vpx_clear_system_state();
4147 vp9_set_quantizer(cm, q);
4148 vp9_set_variance_partition_thresholds(cpi, q, 0);
4149 suppress_active_map(cpi);
4150 // Turn-off cyclic refresh for re-encoded frame.
4151 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
4152 CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
4153 unsigned char *const seg_map = cpi->segmentation_map;
4154 memset(seg_map, 0, cm->mi_rows * cm->mi_cols);
4155 memset(cr->last_coded_q_map, MAXQ,
4156 cm->mi_rows * cm->mi_cols * sizeof(*cr->last_coded_q_map));
4158 vp9_disable_segmentation(&cm->seg);
4160 apply_active_map(cpi);
4161 vp9_encode_frame(cpi);
4165 // Update some stats from cyclic refresh, and check for golden frame update.
4166 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && cm->seg.enabled &&
4167 !frame_is_intra_only(cm))
4168 vp9_cyclic_refresh_postencode(cpi);
4170 // Update the skip mb flag probabilities based on the distribution
4171 // seen in the last encoder iteration.
4172 // update_base_skip_probs(cpi);
4173 vpx_clear_system_state();
4177 #if !CONFIG_REALTIME_ONLY
4178 #define MAX_QSTEP_ADJ 4
4179 static int get_qstep_adj(int rate_excess, int rate_limit) {
4181 rate_limit ? ((rate_excess + rate_limit / 2) / rate_limit) : INT_MAX;
4182 return VPXMIN(qstep, MAX_QSTEP_ADJ);
4185 static void encode_with_recode_loop(VP9_COMP *cpi, size_t *size,
4187 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
4188 VP9_COMMON *const cm = &cpi->common;
4189 RATE_CONTROL *const rc = &cpi->rc;
4190 int bottom_index, top_index;
4192 int loop_at_this_size = 0;
4194 int overshoot_seen = 0;
4195 int undershoot_seen = 0;
4196 int frame_over_shoot_limit;
4197 int frame_under_shoot_limit;
4198 int q = 0, q_low = 0, q_high = 0;
4200 #ifdef AGGRESSIVE_VBR
4204 if (cm->show_existing_frame) {
4205 rc->this_frame_target = 0;
4206 if (is_psnr_calc_enabled(cpi)) set_raw_source_frame(cpi);
4210 set_size_independent_vars(cpi);
4212 enable_acl = cpi->sf.allow_acl ? (cm->frame_type == KEY_FRAME) ||
4213 (cpi->twopass.gf_group.index == 1)
4217 vpx_clear_system_state();
4219 set_frame_size(cpi);
4221 if (loop_count == 0 || cpi->resize_pending != 0) {
4222 set_size_dependent_vars(cpi, &q, &bottom_index, &top_index);
4224 #ifdef AGGRESSIVE_VBR
4225 if (two_pass_first_group_inter(cpi)) {
4226 // Adjustment limits for min and max q
4227 qrange_adj = VPXMAX(1, (top_index - bottom_index) / 2);
4230 VPXMAX(bottom_index - qrange_adj / 2, oxcf->best_allowed_q);
4231 top_index = VPXMIN(oxcf->worst_allowed_q, top_index + qrange_adj / 2);
4234 // TODO(agrange) Scale cpi->max_mv_magnitude if frame-size has changed.
4235 set_mv_search_params(cpi);
4237 // Reset the loop state for new frame size.
4239 undershoot_seen = 0;
4241 // Reconfiguration for change in frame size has concluded.
4242 cpi->resize_pending = 0;
4244 q_low = bottom_index;
4247 loop_at_this_size = 0;
4250 // Decide frame size bounds first time through.
4251 if (loop_count == 0) {
4252 vp9_rc_compute_frame_size_bounds(cpi, rc->this_frame_target,
4253 &frame_under_shoot_limit,
4254 &frame_over_shoot_limit);
4258 vp9_scale_if_required(cm, cpi->un_scaled_source, &cpi->scaled_source,
4259 (oxcf->pass == 0), EIGHTTAP, 0);
4261 // Unfiltered raw source used in metrics calculation if the source
4262 // has been filtered.
4263 if (is_psnr_calc_enabled(cpi)) {
4264 #ifdef ENABLE_KF_DENOISE
4265 if (is_spatial_denoise_enabled(cpi)) {
4266 cpi->raw_source_frame = vp9_scale_if_required(
4267 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
4268 (oxcf->pass == 0), EIGHTTAP, 0);
4270 cpi->raw_source_frame = cpi->Source;
4273 cpi->raw_source_frame = cpi->Source;
4277 if (cpi->unscaled_last_source != NULL)
4278 cpi->Last_Source = vp9_scale_if_required(cm, cpi->unscaled_last_source,
4279 &cpi->scaled_last_source,
4280 (oxcf->pass == 0), EIGHTTAP, 0);
4282 if (frame_is_intra_only(cm) == 0) {
4283 if (loop_count > 0) {
4284 release_scaled_references(cpi);
4286 vp9_scale_references(cpi);
4289 #if CONFIG_RATE_CTRL
4290 // TODO(angiebird): This is a hack for making sure the encoder use the
4291 // external_quantize_index exactly. Avoid this kind of hack later.
4292 if (cpi->encode_command.use_external_quantize_index) {
4293 q = cpi->encode_command.external_quantize_index;
4297 vp9_set_quantizer(cm, q);
4299 if (loop_count == 0) setup_frame(cpi);
4301 // Variance adaptive and in frame q adjustment experiments are mutually
4303 if (oxcf->aq_mode == VARIANCE_AQ) {
4304 vp9_vaq_frame_setup(cpi);
4305 } else if (oxcf->aq_mode == EQUATOR360_AQ) {
4306 vp9_360aq_frame_setup(cpi);
4307 } else if (oxcf->aq_mode == COMPLEXITY_AQ) {
4308 vp9_setup_in_frame_q_adj(cpi);
4309 } else if (oxcf->aq_mode == LOOKAHEAD_AQ) {
4310 vp9_alt_ref_aq_setup_map(cpi->alt_ref_aq, cpi);
4311 } else if (oxcf->aq_mode == PSNR_AQ) {
4312 vp9_psnr_aq_mode_setup(&cm->seg);
4315 vp9_encode_frame(cpi);
4317 // Update the skip mb flag probabilities based on the distribution
4318 // seen in the last encoder iteration.
4319 // update_base_skip_probs(cpi);
4321 vpx_clear_system_state();
4323 // Dummy pack of the bitstream using up to date stats to get an
4324 // accurate estimate of output frame size to determine if we need
4326 if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF) {
4327 save_coding_context(cpi);
4328 if (!cpi->sf.use_nonrd_pick_mode) vp9_pack_bitstream(cpi, dest, size);
4330 rc->projected_frame_size = (int)(*size) << 3;
4332 if (frame_over_shoot_limit == 0) frame_over_shoot_limit = 1;
4335 #if CONFIG_RATE_CTRL
4336 // This part needs to be after save_coding_context() because
4337 // restore_coding_context may be called in the end of this function.
4338 // TODO(angiebird): This is a hack for making sure the encoder use the
4339 // external_quantize_index exactly. Avoid this kind of hack later.
4340 if (cpi->encode_command.use_external_quantize_index) {
4345 if (oxcf->rc_mode == VPX_Q) {
4348 if ((cm->frame_type == KEY_FRAME) && rc->this_key_frame_forced &&
4349 (rc->projected_frame_size < rc->max_frame_bandwidth)) {
4353 int64_t high_err_target = cpi->ambient_err;
4354 int64_t low_err_target = cpi->ambient_err >> 1;
4356 #if CONFIG_VP9_HIGHBITDEPTH
4357 if (cm->use_highbitdepth) {
4358 kf_err = vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4360 kf_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4363 kf_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4364 #endif // CONFIG_VP9_HIGHBITDEPTH
4366 // Prevent possible divide by zero error below for perfect KF
4369 // The key frame is not good enough or we can afford
4370 // to make it better without undue risk of popping.
4371 if ((kf_err > high_err_target &&
4372 rc->projected_frame_size <= frame_over_shoot_limit) ||
4373 (kf_err > low_err_target &&
4374 rc->projected_frame_size <= frame_under_shoot_limit)) {
4376 q_high = q > q_low ? q - 1 : q_low;
4379 q = (int)((q * high_err_target) / kf_err);
4380 q = VPXMIN(q, (q_high + q_low) >> 1);
4381 } else if (kf_err < low_err_target &&
4382 rc->projected_frame_size >= frame_under_shoot_limit) {
4383 // The key frame is much better than the previous frame
4385 q_low = q < q_high ? q + 1 : q_high;
4388 q = (int)((q * low_err_target) / kf_err);
4389 q = VPXMIN(q, (q_high + q_low + 1) >> 1);
4392 // Clamp Q to upper and lower limits:
4393 q = clamp(q, q_low, q_high);
4396 } else if (recode_loop_test(cpi, frame_over_shoot_limit,
4397 frame_under_shoot_limit, q,
4398 VPXMAX(q_high, top_index), bottom_index)) {
4399 // Is the projected frame size out of range and are we allowed
4400 // to attempt to recode.
4405 if (cpi->resize_pending == 1) {
4406 // Change in frame size so go back around the recode loop.
4407 cpi->rc.frame_size_selector =
4408 SCALE_STEP1 - cpi->rc.frame_size_selector;
4409 cpi->rc.next_frame_size_selector = cpi->rc.frame_size_selector;
4411 #if CONFIG_INTERNAL_STATS
4412 ++cpi->tot_recode_hits;
4419 // Frame size out of permitted range:
4420 // Update correction factor & compute new Q to try...
4422 // Frame is too large
4423 if (rc->projected_frame_size > rc->this_frame_target) {
4424 // Special case if the projected size is > the max allowed.
4425 if ((q == q_high) &&
4426 ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
4427 (!rc->is_src_frame_alt_ref &&
4428 (rc->projected_frame_size >=
4429 big_rate_miss_high_threshold(cpi))))) {
4430 int max_rate = VPXMAX(1, VPXMIN(rc->max_frame_bandwidth,
4431 big_rate_miss_high_threshold(cpi)));
4433 q_val_high = vp9_convert_qindex_to_q(q_high, cm->bit_depth);
4435 q_val_high * ((double)rc->projected_frame_size / max_rate);
4436 q_high = vp9_convert_q_to_qindex(q_val_high, cm->bit_depth);
4437 q_high = clamp(q_high, rc->best_quality, rc->worst_quality);
4440 // Raise Qlow as to at least the current value
4442 get_qstep_adj(rc->projected_frame_size, rc->this_frame_target);
4443 q_low = VPXMIN(q + qstep, q_high);
4445 if (undershoot_seen || loop_at_this_size > 1) {
4446 // Update rate_correction_factor unless
4447 vp9_rc_update_rate_correction_factors(cpi);
4449 q = (q_high + q_low + 1) / 2;
4451 // Update rate_correction_factor unless
4452 vp9_rc_update_rate_correction_factors(cpi);
4454 q = vp9_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4455 VPXMAX(q_high, top_index));
4457 while (q < q_low && retries < 10) {
4458 vp9_rc_update_rate_correction_factors(cpi);
4459 q = vp9_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4460 VPXMAX(q_high, top_index));
4467 // Frame is too small
4469 get_qstep_adj(rc->this_frame_target, rc->projected_frame_size);
4470 q_high = VPXMAX(q - qstep, q_low);
4472 if (overshoot_seen || loop_at_this_size > 1) {
4473 vp9_rc_update_rate_correction_factors(cpi);
4474 q = (q_high + q_low) / 2;
4476 vp9_rc_update_rate_correction_factors(cpi);
4477 q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
4478 VPXMIN(q_low, bottom_index), top_index);
4479 // Special case reset for qlow for constrained quality.
4480 // This should only trigger where there is very substantial
4481 // undershoot on a frame and the auto cq level is above
4482 // the user passsed in value.
4483 if (oxcf->rc_mode == VPX_CQ && q < q_low) {
4487 while (q > q_high && retries < 10) {
4488 vp9_rc_update_rate_correction_factors(cpi);
4489 q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
4490 VPXMIN(q_low, bottom_index), top_index);
4494 undershoot_seen = 1;
4497 // Clamp Q to upper and lower limits:
4498 q = clamp(q, q_low, q_high);
4500 loop = (q != last_q);
4506 // Special case for overlay frame.
4507 if (rc->is_src_frame_alt_ref &&
4508 rc->projected_frame_size < rc->max_frame_bandwidth)
4513 ++loop_at_this_size;
4515 #if CONFIG_INTERNAL_STATS
4516 ++cpi->tot_recode_hits;
4520 if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF)
4521 if (loop || !enable_acl) restore_coding_context(cpi);
4524 #ifdef AGGRESSIVE_VBR
4525 if (two_pass_first_group_inter(cpi)) {
4526 cpi->twopass.active_worst_quality =
4527 VPXMIN(q + qrange_adj, oxcf->worst_allowed_q);
4528 } else if (!frame_is_kf_gf_arf(cpi)) {
4530 if (!frame_is_kf_gf_arf(cpi)) {
4532 // Have we been forced to adapt Q outside the expected range by an extreme
4533 // rate miss. If so adjust the active maxQ for the subsequent frames.
4534 if (!rc->is_src_frame_alt_ref && (q > cpi->twopass.active_worst_quality)) {
4535 cpi->twopass.active_worst_quality = q;
4536 } else if (oxcf->vbr_corpus_complexity && q == q_low &&
4537 rc->projected_frame_size < rc->this_frame_target) {
4538 cpi->twopass.active_worst_quality =
4539 VPXMAX(q, cpi->twopass.active_worst_quality - 1);
4544 // Skip recoding, if model diff is below threshold
4545 const int thresh = compute_context_model_thresh(cpi);
4546 const int diff = compute_context_model_diff(cm);
4547 if (diff < thresh) {
4548 vpx_clear_system_state();
4549 restore_coding_context(cpi);
4553 vp9_encode_frame(cpi);
4554 vpx_clear_system_state();
4555 restore_coding_context(cpi);
4558 #endif // !CONFIG_REALTIME_ONLY
4560 static int get_ref_frame_flags(const VP9_COMP *cpi) {
4561 const int *const map = cpi->common.ref_frame_map;
4562 const int gold_is_last = map[cpi->gld_fb_idx] == map[cpi->lst_fb_idx];
4563 const int alt_is_last = map[cpi->alt_fb_idx] == map[cpi->lst_fb_idx];
4564 const int gold_is_alt = map[cpi->gld_fb_idx] == map[cpi->alt_fb_idx];
4565 int flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;
4567 if (gold_is_last) flags &= ~VP9_GOLD_FLAG;
4569 if (cpi->rc.frames_till_gf_update_due == INT_MAX &&
4570 (cpi->svc.number_temporal_layers == 1 &&
4571 cpi->svc.number_spatial_layers == 1))
4572 flags &= ~VP9_GOLD_FLAG;
4574 if (alt_is_last) flags &= ~VP9_ALT_FLAG;
4576 if (gold_is_alt) flags &= ~VP9_ALT_FLAG;
4581 static void set_ext_overrides(VP9_COMP *cpi) {
4582 // Overrides the defaults with the externally supplied values with
4583 // vp9_update_reference() and vp9_update_entropy() calls
4584 // Note: The overrides are valid only for the next frame passed
4585 // to encode_frame_to_data_rate() function
4586 if (cpi->ext_refresh_frame_context_pending) {
4587 cpi->common.refresh_frame_context = cpi->ext_refresh_frame_context;
4588 cpi->ext_refresh_frame_context_pending = 0;
4590 if (cpi->ext_refresh_frame_flags_pending) {
4591 cpi->refresh_last_frame = cpi->ext_refresh_last_frame;
4592 cpi->refresh_golden_frame = cpi->ext_refresh_golden_frame;
4593 cpi->refresh_alt_ref_frame = cpi->ext_refresh_alt_ref_frame;
4597 YV12_BUFFER_CONFIG *vp9_svc_twostage_scale(
4598 VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled,
4599 YV12_BUFFER_CONFIG *scaled_temp, INTERP_FILTER filter_type,
4600 int phase_scaler, INTERP_FILTER filter_type2, int phase_scaler2) {
4601 if (cm->mi_cols * MI_SIZE != unscaled->y_width ||
4602 cm->mi_rows * MI_SIZE != unscaled->y_height) {
4603 #if CONFIG_VP9_HIGHBITDEPTH
4604 if (cm->bit_depth == VPX_BITS_8) {
4605 vp9_scale_and_extend_frame(unscaled, scaled_temp, filter_type2,
4607 vp9_scale_and_extend_frame(scaled_temp, scaled, filter_type,
4610 scale_and_extend_frame(unscaled, scaled_temp, (int)cm->bit_depth,
4611 filter_type2, phase_scaler2);
4612 scale_and_extend_frame(scaled_temp, scaled, (int)cm->bit_depth,
4613 filter_type, phase_scaler);
4616 vp9_scale_and_extend_frame(unscaled, scaled_temp, filter_type2,
4618 vp9_scale_and_extend_frame(scaled_temp, scaled, filter_type, phase_scaler);
4619 #endif // CONFIG_VP9_HIGHBITDEPTH
4626 YV12_BUFFER_CONFIG *vp9_scale_if_required(
4627 VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled,
4628 int use_normative_scaler, INTERP_FILTER filter_type, int phase_scaler) {
4629 if (cm->mi_cols * MI_SIZE != unscaled->y_width ||
4630 cm->mi_rows * MI_SIZE != unscaled->y_height) {
4631 #if CONFIG_VP9_HIGHBITDEPTH
4632 if (use_normative_scaler && unscaled->y_width <= (scaled->y_width << 1) &&
4633 unscaled->y_height <= (scaled->y_height << 1))
4634 if (cm->bit_depth == VPX_BITS_8)
4635 vp9_scale_and_extend_frame(unscaled, scaled, filter_type, phase_scaler);
4637 scale_and_extend_frame(unscaled, scaled, (int)cm->bit_depth,
4638 filter_type, phase_scaler);
4640 scale_and_extend_frame_nonnormative(unscaled, scaled, (int)cm->bit_depth);
4642 if (use_normative_scaler && unscaled->y_width <= (scaled->y_width << 1) &&
4643 unscaled->y_height <= (scaled->y_height << 1))
4644 vp9_scale_and_extend_frame(unscaled, scaled, filter_type, phase_scaler);
4646 scale_and_extend_frame_nonnormative(unscaled, scaled);
4647 #endif // CONFIG_VP9_HIGHBITDEPTH
4654 static void set_ref_sign_bias(VP9_COMP *cpi) {
4655 VP9_COMMON *const cm = &cpi->common;
4656 RefCntBuffer *const ref_buffer = get_ref_cnt_buffer(cm, cm->new_fb_idx);
4657 const int cur_frame_index = ref_buffer->frame_index;
4658 MV_REFERENCE_FRAME ref_frame;
4660 for (ref_frame = LAST_FRAME; ref_frame < MAX_REF_FRAMES; ++ref_frame) {
4661 const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
4662 const RefCntBuffer *const ref_cnt_buf =
4663 get_ref_cnt_buffer(&cpi->common, buf_idx);
4665 cm->ref_frame_sign_bias[ref_frame] =
4666 cur_frame_index < ref_cnt_buf->frame_index;
4671 static int setup_interp_filter_search_mask(VP9_COMP *cpi) {
4672 INTERP_FILTER ifilter;
4673 int ref_total[MAX_REF_FRAMES] = { 0 };
4674 MV_REFERENCE_FRAME ref;
4676 if (cpi->common.last_frame_type == KEY_FRAME || cpi->refresh_alt_ref_frame)
4678 for (ref = LAST_FRAME; ref <= ALTREF_FRAME; ++ref)
4679 for (ifilter = EIGHTTAP; ifilter <= EIGHTTAP_SHARP; ++ifilter)
4680 ref_total[ref] += cpi->interp_filter_selected[ref][ifilter];
4682 for (ifilter = EIGHTTAP; ifilter <= EIGHTTAP_SHARP; ++ifilter) {
4683 if ((ref_total[LAST_FRAME] &&
4684 cpi->interp_filter_selected[LAST_FRAME][ifilter] == 0) &&
4685 (ref_total[GOLDEN_FRAME] == 0 ||
4686 cpi->interp_filter_selected[GOLDEN_FRAME][ifilter] * 50 <
4687 ref_total[GOLDEN_FRAME]) &&
4688 (ref_total[ALTREF_FRAME] == 0 ||
4689 cpi->interp_filter_selected[ALTREF_FRAME][ifilter] * 50 <
4690 ref_total[ALTREF_FRAME]))
4691 mask |= 1 << ifilter;
4696 #ifdef ENABLE_KF_DENOISE
4697 // Baseline Kernal weights for denoise
4698 static uint8_t dn_kernal_3[9] = { 1, 2, 1, 2, 4, 2, 1, 2, 1 };
4699 static uint8_t dn_kernal_5[25] = { 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 4,
4700 2, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1 };
4702 static INLINE void add_denoise_point(int centre_val, int data_val, int thresh,
4703 uint8_t point_weight, int *sum_val,
4705 if (abs(centre_val - data_val) <= thresh) {
4706 *sum_weight += point_weight;
4707 *sum_val += (int)data_val * (int)point_weight;
4711 static void spatial_denoise_point(uint8_t *src_ptr, const int stride,
4712 const int strength) {
4715 int thresh = strength;
4716 int kernal_size = 5;
4717 int half_k_size = 2;
4721 uint8_t *kernal_ptr;
4723 // Find the maximum deviation from the source point in the locale.
4724 tmp_ptr = src_ptr - (stride * (half_k_size + 1)) - (half_k_size + 1);
4725 for (i = 0; i < kernal_size + 2; ++i) {
4726 for (j = 0; j < kernal_size + 2; ++j) {
4727 max_diff = VPXMAX(max_diff, abs((int)*src_ptr - (int)tmp_ptr[j]));
4732 // Select the kernal size.
4733 if (max_diff > (strength + (strength >> 1))) {
4736 thresh = thresh >> 1;
4738 kernal_ptr = (kernal_size == 3) ? dn_kernal_3 : dn_kernal_5;
4741 tmp_ptr = src_ptr - (stride * half_k_size) - half_k_size;
4742 for (i = 0; i < kernal_size; ++i) {
4743 for (j = 0; j < kernal_size; ++j) {
4744 add_denoise_point((int)*src_ptr, (int)tmp_ptr[j], thresh, *kernal_ptr,
4745 &sum_val, &sum_weight);
4751 // Update the source value with the new filtered value
4752 *src_ptr = (uint8_t)((sum_val + (sum_weight >> 1)) / sum_weight);
4755 #if CONFIG_VP9_HIGHBITDEPTH
4756 static void highbd_spatial_denoise_point(uint16_t *src_ptr, const int stride,
4757 const int strength) {
4760 int thresh = strength;
4761 int kernal_size = 5;
4762 int half_k_size = 2;
4766 uint8_t *kernal_ptr;
4768 // Find the maximum deviation from the source point in the locale.
4769 tmp_ptr = src_ptr - (stride * (half_k_size + 1)) - (half_k_size + 1);
4770 for (i = 0; i < kernal_size + 2; ++i) {
4771 for (j = 0; j < kernal_size + 2; ++j) {
4772 max_diff = VPXMAX(max_diff, abs((int)src_ptr - (int)tmp_ptr[j]));
4777 // Select the kernal size.
4778 if (max_diff > (strength + (strength >> 1))) {
4781 thresh = thresh >> 1;
4783 kernal_ptr = (kernal_size == 3) ? dn_kernal_3 : dn_kernal_5;
4786 tmp_ptr = src_ptr - (stride * half_k_size) - half_k_size;
4787 for (i = 0; i < kernal_size; ++i) {
4788 for (j = 0; j < kernal_size; ++j) {
4789 add_denoise_point((int)*src_ptr, (int)tmp_ptr[j], thresh, *kernal_ptr,
4790 &sum_val, &sum_weight);
4796 // Update the source value with the new filtered value
4797 *src_ptr = (uint16_t)((sum_val + (sum_weight >> 1)) / sum_weight);
4799 #endif // CONFIG_VP9_HIGHBITDEPTH
4801 // Apply thresholded spatial noise supression to a given buffer.
4802 static void spatial_denoise_buffer(VP9_COMP *cpi, uint8_t *buffer,
4803 const int stride, const int width,
4804 const int height, const int strength) {
4805 VP9_COMMON *const cm = &cpi->common;
4806 uint8_t *src_ptr = buffer;
4810 for (row = 0; row < height; ++row) {
4811 for (col = 0; col < width; ++col) {
4812 #if CONFIG_VP9_HIGHBITDEPTH
4813 if (cm->use_highbitdepth)
4814 highbd_spatial_denoise_point(CONVERT_TO_SHORTPTR(&src_ptr[col]), stride,
4817 spatial_denoise_point(&src_ptr[col], stride, strength);
4819 spatial_denoise_point(&src_ptr[col], stride, strength);
4820 #endif // CONFIG_VP9_HIGHBITDEPTH
4826 // Apply thresholded spatial noise supression to source.
4827 static void spatial_denoise_frame(VP9_COMP *cpi) {
4828 YV12_BUFFER_CONFIG *src = cpi->Source;
4829 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
4830 TWO_PASS *const twopass = &cpi->twopass;
4831 VP9_COMMON *const cm = &cpi->common;
4833 // Base the filter strength on the current active max Q.
4834 const int q = (int)(vp9_convert_qindex_to_q(twopass->active_worst_quality,
4837 VPXMAX(oxcf->arnr_strength >> 2, VPXMIN(oxcf->arnr_strength, (q >> 4)));
4839 // Denoise each of Y,U and V buffers.
4840 spatial_denoise_buffer(cpi, src->y_buffer, src->y_stride, src->y_width,
4841 src->y_height, strength);
4843 strength += (strength >> 1);
4844 spatial_denoise_buffer(cpi, src->u_buffer, src->uv_stride, src->uv_width,
4845 src->uv_height, strength << 1);
4847 spatial_denoise_buffer(cpi, src->v_buffer, src->uv_stride, src->uv_width,
4848 src->uv_height, strength << 1);
4850 #endif // ENABLE_KF_DENOISE
4852 #if !CONFIG_REALTIME_ONLY
4853 static void vp9_try_disable_lookahead_aq(VP9_COMP *cpi, size_t *size,
4855 if (cpi->common.seg.enabled)
4856 if (ALT_REF_AQ_PROTECT_GAIN) {
4857 size_t nsize = *size;
4860 // TODO(yuryg): optimize this, as
4861 // we don't really need to repack
4863 save_coding_context(cpi);
4864 vp9_disable_segmentation(&cpi->common.seg);
4865 vp9_pack_bitstream(cpi, dest, &nsize);
4866 restore_coding_context(cpi);
4868 overhead = (int)*size - (int)nsize;
4870 if (vp9_alt_ref_aq_disable_if(cpi->alt_ref_aq, overhead, (int)*size))
4871 vp9_encode_frame(cpi);
4873 vp9_enable_segmentation(&cpi->common.seg);
4878 static void set_frame_index(VP9_COMP *cpi, VP9_COMMON *cm) {
4879 RefCntBuffer *const ref_buffer = get_ref_cnt_buffer(cm, cm->new_fb_idx);
4882 const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
4883 ref_buffer->frame_index =
4884 cm->current_video_frame + gf_group->arf_src_offset[gf_group->index];
4888 static void set_mb_ssim_rdmult_scaling(VP9_COMP *cpi) {
4889 VP9_COMMON *cm = &cpi->common;
4890 ThreadData *td = &cpi->td;
4891 MACROBLOCK *x = &td->mb;
4892 MACROBLOCKD *xd = &x->e_mbd;
4893 uint8_t *y_buffer = cpi->Source->y_buffer;
4894 const int y_stride = cpi->Source->y_stride;
4895 const int block_size = BLOCK_16X16;
4897 const int num_8x8_w = num_8x8_blocks_wide_lookup[block_size];
4898 const int num_8x8_h = num_8x8_blocks_high_lookup[block_size];
4899 const int num_cols = (cm->mi_cols + num_8x8_w - 1) / num_8x8_w;
4900 const int num_rows = (cm->mi_rows + num_8x8_h - 1) / num_8x8_h;
4901 double log_sum = 0.0;
4904 // Loop through each 64x64 block.
4905 for (row = 0; row < num_rows; ++row) {
4906 for (col = 0; col < num_cols; ++col) {
4908 double var = 0.0, num_of_var = 0.0;
4909 const int index = row * num_cols + col;
4911 for (mi_row = row * num_8x8_h;
4912 mi_row < cm->mi_rows && mi_row < (row + 1) * num_8x8_h; ++mi_row) {
4913 for (mi_col = col * num_8x8_w;
4914 mi_col < cm->mi_cols && mi_col < (col + 1) * num_8x8_w; ++mi_col) {
4916 const int row_offset_y = mi_row << 3;
4917 const int col_offset_y = mi_col << 3;
4919 buf.buf = y_buffer + row_offset_y * y_stride + col_offset_y;
4920 buf.stride = y_stride;
4922 // In order to make SSIM_VAR_SCALE in a same scale for both 8 bit
4923 // and high bit videos, the variance needs to be divided by 2.0 or
4925 // TODO(sdeng): need to tune for 12bit videos.
4926 #if CONFIG_VP9_HIGHBITDEPTH
4927 if (cpi->Source->flags & YV12_FLAG_HIGHBITDEPTH)
4928 var += vp9_high_get_sby_variance(cpi, &buf, BLOCK_8X8, xd->bd);
4931 var += vp9_get_sby_variance(cpi, &buf, BLOCK_8X8);
4936 var = var / num_of_var / 64.0;
4938 // Curve fitting with an exponential model on all 16x16 blocks from the
4940 var = 67.035434 * (1 - exp(-0.0021489 * var)) + 17.492222;
4941 cpi->mi_ssim_rdmult_scaling_factors[index] = var;
4942 log_sum += log(var);
4945 log_sum = exp(log_sum / (double)(num_rows * num_cols));
4947 for (row = 0; row < num_rows; ++row) {
4948 for (col = 0; col < num_cols; ++col) {
4949 const int index = row * num_cols + col;
4950 cpi->mi_ssim_rdmult_scaling_factors[index] /= log_sum;
4957 // Process the wiener variance in 16x16 block basis.
4958 static int qsort_comp(const void *elem1, const void *elem2) {
4959 int a = *((const int *)elem1);
4960 int b = *((const int *)elem2);
4961 if (a > b) return 1;
4962 if (a < b) return -1;
4966 static void init_mb_wiener_var_buffer(VP9_COMP *cpi) {
4967 VP9_COMMON *cm = &cpi->common;
4969 if (cpi->mb_wiener_variance && cpi->mb_wiener_var_rows >= cm->mb_rows &&
4970 cpi->mb_wiener_var_cols >= cm->mb_cols)
4973 vpx_free(cpi->mb_wiener_variance);
4974 cpi->mb_wiener_variance = NULL;
4977 cm, cpi->mb_wiener_variance,
4978 vpx_calloc(cm->mb_rows * cm->mb_cols, sizeof(*cpi->mb_wiener_variance)));
4979 cpi->mb_wiener_var_rows = cm->mb_rows;
4980 cpi->mb_wiener_var_cols = cm->mb_cols;
4983 static void set_mb_wiener_variance(VP9_COMP *cpi) {
4984 VP9_COMMON *cm = &cpi->common;
4985 uint8_t *buffer = cpi->Source->y_buffer;
4986 int buf_stride = cpi->Source->y_stride;
4988 #if CONFIG_VP9_HIGHBITDEPTH
4989 ThreadData *td = &cpi->td;
4990 MACROBLOCK *x = &td->mb;
4991 MACROBLOCKD *xd = &x->e_mbd;
4992 DECLARE_ALIGNED(16, uint16_t, zero_pred16[32 * 32]);
4993 DECLARE_ALIGNED(16, uint8_t, zero_pred8[32 * 32]);
4996 DECLARE_ALIGNED(16, uint8_t, zero_pred[32 * 32]);
4999 DECLARE_ALIGNED(16, int16_t, src_diff[32 * 32]);
5000 DECLARE_ALIGNED(16, tran_low_t, coeff[32 * 32]);
5002 int mb_row, mb_col, count = 0;
5003 // Hard coded operating block size
5004 const int block_size = 16;
5005 const int coeff_count = block_size * block_size;
5006 const TX_SIZE tx_size = TX_16X16;
5008 #if CONFIG_VP9_HIGHBITDEPTH
5009 xd->cur_buf = cpi->Source;
5010 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
5011 zero_pred = CONVERT_TO_BYTEPTR(zero_pred16);
5012 memset(zero_pred16, 0, sizeof(*zero_pred16) * coeff_count);
5014 zero_pred = zero_pred8;
5015 memset(zero_pred8, 0, sizeof(*zero_pred8) * coeff_count);
5018 memset(zero_pred, 0, sizeof(*zero_pred) * coeff_count);
5021 cpi->norm_wiener_variance = 0;
5023 for (mb_row = 0; mb_row < cm->mb_rows; ++mb_row) {
5024 for (mb_col = 0; mb_col < cm->mb_cols; ++mb_col) {
5026 int16_t median_val = 0;
5027 uint8_t *mb_buffer =
5028 buffer + mb_row * block_size * buf_stride + mb_col * block_size;
5029 int64_t wiener_variance = 0;
5031 #if CONFIG_VP9_HIGHBITDEPTH
5032 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
5033 vpx_highbd_subtract_block(block_size, block_size, src_diff, block_size,
5034 mb_buffer, buf_stride, zero_pred, block_size,
5036 highbd_wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
5038 vpx_subtract_block(block_size, block_size, src_diff, block_size,
5039 mb_buffer, buf_stride, zero_pred, block_size);
5040 wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
5043 vpx_subtract_block(block_size, block_size, src_diff, block_size,
5044 mb_buffer, buf_stride, zero_pred, block_size);
5045 wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
5046 #endif // CONFIG_VP9_HIGHBITDEPTH
5049 for (idx = 1; idx < coeff_count; ++idx) coeff[idx] = abs(coeff[idx]);
5051 qsort(coeff, coeff_count - 1, sizeof(*coeff), qsort_comp);
5053 // Noise level estimation
5054 median_val = coeff[coeff_count / 2];
5057 for (idx = 1; idx < coeff_count; ++idx) {
5058 int64_t sqr_coeff = (int64_t)coeff[idx] * coeff[idx];
5059 int64_t tmp_coeff = (int64_t)coeff[idx];
5061 tmp_coeff = (sqr_coeff * coeff[idx]) /
5062 (sqr_coeff + (int64_t)median_val * median_val);
5064 wiener_variance += tmp_coeff * tmp_coeff;
5066 cpi->mb_wiener_variance[mb_row * cm->mb_cols + mb_col] =
5067 wiener_variance / coeff_count;
5068 cpi->norm_wiener_variance +=
5069 cpi->mb_wiener_variance[mb_row * cm->mb_cols + mb_col];
5074 if (count) cpi->norm_wiener_variance /= count;
5075 cpi->norm_wiener_variance = VPXMAX(1, cpi->norm_wiener_variance);
5078 static void encode_frame_to_data_rate(VP9_COMP *cpi, size_t *size,
5080 unsigned int *frame_flags) {
5081 VP9_COMMON *const cm = &cpi->common;
5082 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
5083 struct segmentation *const seg = &cm->seg;
5086 // SVC: skip encoding of enhancement layer if the layer target bandwidth = 0.
5087 // No need to set svc.skip_enhancement_layer if whole superframe will be
5089 if (cpi->use_svc && cpi->svc.spatial_layer_id > 0 &&
5090 cpi->oxcf.target_bandwidth == 0 &&
5091 !(cpi->svc.framedrop_mode != LAYER_DROP &&
5092 (cpi->svc.framedrop_mode != CONSTRAINED_FROM_ABOVE_DROP ||
5094 .force_drop_constrained_from_above[cpi->svc.number_spatial_layers -
5096 cpi->svc.drop_spatial_layer[0])) {
5097 cpi->svc.skip_enhancement_layer = 1;
5098 vp9_rc_postencode_update_drop_frame(cpi);
5099 cpi->ext_refresh_frame_flags_pending = 0;
5100 cpi->last_frame_dropped = 1;
5101 cpi->svc.last_layer_dropped[cpi->svc.spatial_layer_id] = 1;
5102 cpi->svc.drop_spatial_layer[cpi->svc.spatial_layer_id] = 1;
5103 vp9_inc_frame_in_layer(cpi);
5107 set_ext_overrides(cpi);
5108 vpx_clear_system_state();
5110 #ifdef ENABLE_KF_DENOISE
5111 // Spatial denoise of key frame.
5112 if (is_spatial_denoise_enabled(cpi)) spatial_denoise_frame(cpi);
5115 if (cm->show_existing_frame == 0) {
5116 // Update frame index
5117 set_frame_index(cpi, cm);
5119 // Set the arf sign bias for this frame.
5120 set_ref_sign_bias(cpi);
5123 // Set default state for segment based loop filter update flags.
5124 cm->lf.mode_ref_delta_update = 0;
5126 if (cpi->oxcf.pass == 2 && cpi->sf.adaptive_interp_filter_search)
5127 cpi->sf.interp_filter_search_mask = setup_interp_filter_search_mask(cpi);
5129 // Set various flags etc to special state if it is a key frame.
5130 if (frame_is_intra_only(cm)) {
5131 // Reset the loop filter deltas and segmentation map.
5132 vp9_reset_segment_features(&cm->seg);
5134 // If segmentation is enabled force a map update for key frames.
5136 seg->update_map = 1;
5137 seg->update_data = 1;
5140 // The alternate reference frame cannot be active for a key frame.
5141 cpi->rc.source_alt_ref_active = 0;
5143 cm->error_resilient_mode = oxcf->error_resilient_mode;
5144 cm->frame_parallel_decoding_mode = oxcf->frame_parallel_decoding_mode;
5146 // By default, encoder assumes decoder can use prev_mi.
5147 if (cm->error_resilient_mode) {
5148 cm->frame_parallel_decoding_mode = 1;
5149 cm->reset_frame_context = 0;
5150 cm->refresh_frame_context = 0;
5151 } else if (cm->intra_only) {
5152 // Only reset the current context.
5153 cm->reset_frame_context = 2;
5157 if (oxcf->tuning == VP8_TUNE_SSIM) set_mb_ssim_rdmult_scaling(cpi);
5159 if (oxcf->aq_mode == PERCEPTUAL_AQ) {
5160 init_mb_wiener_var_buffer(cpi);
5161 set_mb_wiener_variance(cpi);
5164 vpx_clear_system_state();
5166 #if CONFIG_INTERNAL_STATS
5167 memset(cpi->mode_chosen_counts, 0,
5168 MAX_MODES * sizeof(*cpi->mode_chosen_counts));
5170 #if CONFIG_CONSISTENT_RECODE
5171 // Backup to ensure consistency between recodes
5172 save_encode_params(cpi);
5175 if (cpi->sf.recode_loop == DISALLOW_RECODE) {
5176 if (!encode_without_recode_loop(cpi, size, dest)) return;
5178 #if !CONFIG_REALTIME_ONLY
5179 encode_with_recode_loop(cpi, size, dest);
5183 // TODO(jingning): When using show existing frame mode, we assume that the
5184 // current ARF will be directly used as the final reconstructed frame. This is
5185 // an encoder control scheme. One could in principle explore other
5186 // possibilities to arrange the reference frame buffer and their coding order.
5187 if (cm->show_existing_frame) {
5188 ref_cnt_fb(cm->buffer_pool->frame_bufs, &cm->new_fb_idx,
5189 cm->ref_frame_map[cpi->alt_fb_idx]);
5192 #if !CONFIG_REALTIME_ONLY
5193 // Disable segmentation if it decrease rate/distortion ratio
5194 if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ)
5195 vp9_try_disable_lookahead_aq(cpi, size, dest);
5198 #if CONFIG_VP9_TEMPORAL_DENOISING
5199 #ifdef OUTPUT_YUV_DENOISED
5200 if (oxcf->noise_sensitivity > 0 && denoise_svc(cpi)) {
5201 vpx_write_yuv_frame(yuv_denoised_file,
5202 &cpi->denoiser.running_avg_y[INTRA_FRAME]);
5206 #ifdef OUTPUT_YUV_SKINMAP
5207 if (cpi->common.current_video_frame > 1) {
5208 vp9_output_skin_map(cpi, yuv_skinmap_file);
5212 // Special case code to reduce pulsing when key frames are forced at a
5213 // fixed interval. Note the reconstruction error if it is the frame before
5214 // the force key frame
5215 if (cpi->rc.next_key_frame_forced && cpi->rc.frames_to_key == 1) {
5216 #if CONFIG_VP9_HIGHBITDEPTH
5217 if (cm->use_highbitdepth) {
5219 vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5221 cpi->ambient_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5224 cpi->ambient_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5225 #endif // CONFIG_VP9_HIGHBITDEPTH
5228 // If the encoder forced a KEY_FRAME decision
5229 if (cm->frame_type == KEY_FRAME) cpi->refresh_last_frame = 1;
5231 cm->frame_to_show = get_frame_new_buffer(cm);
5232 cm->frame_to_show->color_space = cm->color_space;
5233 cm->frame_to_show->color_range = cm->color_range;
5234 cm->frame_to_show->render_width = cm->render_width;
5235 cm->frame_to_show->render_height = cm->render_height;
5237 // Pick the loop filter level for the frame.
5238 loopfilter_frame(cpi, cm);
5240 if (cpi->rc.use_post_encode_drop) save_coding_context(cpi);
5242 // build the bitstream
5243 vp9_pack_bitstream(cpi, dest, size);
5245 if (cpi->rc.use_post_encode_drop && cm->base_qindex < cpi->rc.worst_quality &&
5246 cpi->svc.spatial_layer_id == 0 && post_encode_drop_cbr(cpi, size)) {
5247 restore_coding_context(cpi);
5251 cpi->last_frame_dropped = 0;
5252 cpi->svc.last_layer_dropped[cpi->svc.spatial_layer_id] = 0;
5253 if (cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1)
5254 cpi->svc.num_encoded_top_layer++;
5256 // Keep track of the frame buffer index updated/refreshed for the
5257 // current encoded TL0 superframe.
5258 if (cpi->svc.temporal_layer_id == 0) {
5259 if (cpi->refresh_last_frame)
5260 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->lst_fb_idx;
5261 else if (cpi->refresh_golden_frame)
5262 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->gld_fb_idx;
5263 else if (cpi->refresh_alt_ref_frame)
5264 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->alt_fb_idx;
5267 if (cm->seg.update_map) update_reference_segmentation_map(cpi);
5269 if (frame_is_intra_only(cm) == 0) {
5270 release_scaled_references(cpi);
5272 vp9_update_reference_frames(cpi);
5274 if (!cm->show_existing_frame) {
5275 for (t = TX_4X4; t <= TX_32X32; ++t) {
5276 full_to_model_counts(cpi->td.counts->coef[t],
5277 cpi->td.rd_counts.coef_counts[t]);
5280 if (!cm->error_resilient_mode && !cm->frame_parallel_decoding_mode) {
5281 if (!frame_is_intra_only(cm)) {
5282 vp9_adapt_mode_probs(cm);
5283 vp9_adapt_mv_probs(cm, cm->allow_high_precision_mv);
5285 vp9_adapt_coef_probs(cm);
5289 cpi->ext_refresh_frame_flags_pending = 0;
5291 if (cpi->refresh_golden_frame == 1)
5292 cpi->frame_flags |= FRAMEFLAGS_GOLDEN;
5294 cpi->frame_flags &= ~FRAMEFLAGS_GOLDEN;
5296 if (cpi->refresh_alt_ref_frame == 1)
5297 cpi->frame_flags |= FRAMEFLAGS_ALTREF;
5299 cpi->frame_flags &= ~FRAMEFLAGS_ALTREF;
5301 cpi->ref_frame_flags = get_ref_frame_flags(cpi);
5303 cm->last_frame_type = cm->frame_type;
5305 vp9_rc_postencode_update(cpi, *size);
5307 *size = VPXMAX(1, *size);
5310 output_frame_level_debug_stats(cpi);
5313 if (cm->frame_type == KEY_FRAME) {
5314 // Tell the caller that the frame was coded as a key frame
5315 *frame_flags = cpi->frame_flags | FRAMEFLAGS_KEY;
5317 *frame_flags = cpi->frame_flags & ~FRAMEFLAGS_KEY;
5320 // Clear the one shot update flags for segmentation map and mode/ref loop
5322 cm->seg.update_map = 0;
5323 cm->seg.update_data = 0;
5324 cm->lf.mode_ref_delta_update = 0;
5326 // keep track of the last coded dimensions
5327 cm->last_width = cm->width;
5328 cm->last_height = cm->height;
5330 // reset to normal state now that we are done.
5331 if (!cm->show_existing_frame) {
5332 cm->last_show_frame = cm->show_frame;
5333 cm->prev_frame = cm->cur_frame;
5336 if (cm->show_frame) {
5337 vp9_swap_mi_and_prev_mi(cm);
5338 // Don't increment frame counters if this was an altref buffer
5339 // update not a real frame
5340 ++cm->current_video_frame;
5341 if (cpi->use_svc) vp9_inc_frame_in_layer(cpi);
5346 .layer_context[cpi->svc.spatial_layer_id *
5347 cpi->svc.number_temporal_layers +
5348 cpi->svc.temporal_layer_id]
5349 .last_frame_type = cm->frame_type;
5350 // Reset layer_sync back to 0 for next frame.
5351 cpi->svc.spatial_layer_sync[cpi->svc.spatial_layer_id] = 0;
5354 cpi->force_update_segmentation = 0;
5356 #if !CONFIG_REALTIME_ONLY
5357 if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ)
5358 vp9_alt_ref_aq_unset_all(cpi->alt_ref_aq, cpi);
5361 cpi->svc.previous_frame_is_intra_only = cm->intra_only;
5362 cpi->svc.set_intra_only_frame = 0;
5365 static void SvcEncode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5366 unsigned int *frame_flags) {
5367 vp9_rc_get_svc_params(cpi);
5368 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5371 static void Pass0Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5372 unsigned int *frame_flags) {
5373 if (cpi->oxcf.rc_mode == VPX_CBR) {
5374 vp9_rc_get_one_pass_cbr_params(cpi);
5376 vp9_rc_get_one_pass_vbr_params(cpi);
5378 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5381 #if !CONFIG_REALTIME_ONLY
5382 static void Pass2Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5383 unsigned int *frame_flags) {
5384 cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED;
5385 #if CONFIG_MISMATCH_DEBUG
5386 mismatch_move_frame_idx_w();
5388 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5390 #endif // !CONFIG_REALTIME_ONLY
5392 int vp9_receive_raw_frame(VP9_COMP *cpi, vpx_enc_frame_flags_t frame_flags,
5393 YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
5395 VP9_COMMON *const cm = &cpi->common;
5396 struct vpx_usec_timer timer;
5398 const int subsampling_x = sd->subsampling_x;
5399 const int subsampling_y = sd->subsampling_y;
5400 #if CONFIG_VP9_HIGHBITDEPTH
5401 const int use_highbitdepth = (sd->flags & YV12_FLAG_HIGHBITDEPTH) != 0;
5403 const int use_highbitdepth = 0;
5406 update_initial_width(cpi, use_highbitdepth, subsampling_x, subsampling_y);
5407 #if CONFIG_VP9_TEMPORAL_DENOISING
5408 setup_denoiser_buffer(cpi);
5411 alloc_raw_frame_buffers(cpi);
5413 vpx_usec_timer_start(&timer);
5415 if (vp9_lookahead_push(cpi->lookahead, sd, time_stamp, end_time,
5416 use_highbitdepth, frame_flags))
5418 vpx_usec_timer_mark(&timer);
5419 cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
5421 if ((cm->profile == PROFILE_0 || cm->profile == PROFILE_2) &&
5422 (subsampling_x != 1 || subsampling_y != 1)) {
5423 vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM,
5424 "Non-4:2:0 color format requires profile 1 or 3");
5427 if ((cm->profile == PROFILE_1 || cm->profile == PROFILE_3) &&
5428 (subsampling_x == 1 && subsampling_y == 1)) {
5429 vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM,
5430 "4:2:0 color format requires profile 0 or 2");
5437 static int frame_is_reference(const VP9_COMP *cpi) {
5438 const VP9_COMMON *cm = &cpi->common;
5440 return cm->frame_type == KEY_FRAME || cpi->refresh_last_frame ||
5441 cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame ||
5442 cm->refresh_frame_context || cm->lf.mode_ref_delta_update ||
5443 cm->seg.update_map || cm->seg.update_data;
5446 static void adjust_frame_rate(VP9_COMP *cpi,
5447 const struct lookahead_entry *source) {
5448 int64_t this_duration;
5451 if (source->ts_start == cpi->first_time_stamp_ever) {
5452 this_duration = source->ts_end - source->ts_start;
5455 int64_t last_duration =
5456 cpi->last_end_time_stamp_seen - cpi->last_time_stamp_seen;
5458 this_duration = source->ts_end - cpi->last_end_time_stamp_seen;
5460 // do a step update if the duration changes by 10%
5462 step = (int)((this_duration - last_duration) * 10 / last_duration);
5465 if (this_duration) {
5467 vp9_new_framerate(cpi, 10000000.0 / this_duration);
5469 // Average this frame's rate into the last second's average
5470 // frame rate. If we haven't seen 1 second yet, then average
5471 // over the whole interval seen.
5472 const double interval = VPXMIN(
5473 (double)(source->ts_end - cpi->first_time_stamp_ever), 10000000.0);
5474 double avg_duration = 10000000.0 / cpi->framerate;
5475 avg_duration *= (interval - avg_duration + this_duration);
5476 avg_duration /= interval;
5478 vp9_new_framerate(cpi, 10000000.0 / avg_duration);
5481 cpi->last_time_stamp_seen = source->ts_start;
5482 cpi->last_end_time_stamp_seen = source->ts_end;
5485 // Returns 0 if this is not an alt ref else the offset of the source frame
5486 // used as the arf midpoint.
5487 static int get_arf_src_index(VP9_COMP *cpi) {
5488 RATE_CONTROL *const rc = &cpi->rc;
5489 int arf_src_index = 0;
5490 if (is_altref_enabled(cpi)) {
5491 if (cpi->oxcf.pass == 2) {
5492 const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
5493 if (gf_group->update_type[gf_group->index] == ARF_UPDATE) {
5494 arf_src_index = gf_group->arf_src_offset[gf_group->index];
5496 } else if (rc->source_alt_ref_pending) {
5497 arf_src_index = rc->frames_till_gf_update_due;
5500 return arf_src_index;
5503 static void check_src_altref(VP9_COMP *cpi,
5504 const struct lookahead_entry *source) {
5505 RATE_CONTROL *const rc = &cpi->rc;
5507 if (cpi->oxcf.pass == 2) {
5508 const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
5509 rc->is_src_frame_alt_ref =
5510 (gf_group->update_type[gf_group->index] == OVERLAY_UPDATE);
5512 rc->is_src_frame_alt_ref =
5513 cpi->alt_ref_source && (source == cpi->alt_ref_source);
5516 if (rc->is_src_frame_alt_ref) {
5517 // Current frame is an ARF overlay frame.
5518 cpi->alt_ref_source = NULL;
5520 // Don't refresh the last buffer for an ARF overlay frame. It will
5521 // become the GF so preserve last as an alternative prediction option.
5522 cpi->refresh_last_frame = 0;
5526 #if CONFIG_INTERNAL_STATS
5527 static void adjust_image_stat(double y, double u, double v, double all,
5532 s->stat[ALL] += all;
5533 s->worst = VPXMIN(s->worst, all);
5535 #endif // CONFIG_INTERNAL_STATS
5537 // Adjust the maximum allowable frame size for the target level.
5538 static void level_rc_framerate(VP9_COMP *cpi, int arf_src_index) {
5539 RATE_CONTROL *const rc = &cpi->rc;
5540 LevelConstraint *const ls = &cpi->level_constraint;
5541 VP9_COMMON *const cm = &cpi->common;
5542 const double max_cpb_size = ls->max_cpb_size;
5543 vpx_clear_system_state();
5544 rc->max_frame_bandwidth = VPXMIN(rc->max_frame_bandwidth, ls->max_frame_size);
5545 if (frame_is_intra_only(cm)) {
5546 rc->max_frame_bandwidth =
5547 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.5));
5548 } else if (arf_src_index > 0) {
5549 rc->max_frame_bandwidth =
5550 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.4));
5552 rc->max_frame_bandwidth =
5553 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.2));
5557 static void update_level_info(VP9_COMP *cpi, size_t *size, int arf_src_index) {
5558 VP9_COMMON *const cm = &cpi->common;
5559 Vp9LevelInfo *const level_info = &cpi->level_info;
5560 Vp9LevelSpec *const level_spec = &level_info->level_spec;
5561 Vp9LevelStats *const level_stats = &level_info->level_stats;
5563 uint64_t luma_samples, dur_end;
5564 const uint32_t luma_pic_size = cm->width * cm->height;
5565 const uint32_t luma_pic_breadth = VPXMAX(cm->width, cm->height);
5566 LevelConstraint *const level_constraint = &cpi->level_constraint;
5567 const int8_t level_index = level_constraint->level_index;
5568 double cpb_data_size;
5570 vpx_clear_system_state();
5572 // update level_stats
5573 level_stats->total_compressed_size += *size;
5574 if (cm->show_frame) {
5575 level_stats->total_uncompressed_size +=
5577 2 * (luma_pic_size >> (cm->subsampling_x + cm->subsampling_y));
5578 level_stats->time_encoded =
5579 (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) /
5580 (double)TICKS_PER_SEC;
5583 if (arf_src_index > 0) {
5584 if (!level_stats->seen_first_altref) {
5585 level_stats->seen_first_altref = 1;
5586 } else if (level_stats->frames_since_last_altref <
5587 level_spec->min_altref_distance) {
5588 level_spec->min_altref_distance = level_stats->frames_since_last_altref;
5590 level_stats->frames_since_last_altref = 0;
5592 ++level_stats->frames_since_last_altref;
5595 if (level_stats->frame_window_buffer.len < FRAME_WINDOW_SIZE - 1) {
5596 idx = (level_stats->frame_window_buffer.start +
5597 level_stats->frame_window_buffer.len++) %
5600 idx = level_stats->frame_window_buffer.start;
5601 level_stats->frame_window_buffer.start = (idx + 1) % FRAME_WINDOW_SIZE;
5603 level_stats->frame_window_buffer.buf[idx].ts = cpi->last_time_stamp_seen;
5604 level_stats->frame_window_buffer.buf[idx].size = (uint32_t)(*size);
5605 level_stats->frame_window_buffer.buf[idx].luma_samples = luma_pic_size;
5607 if (cm->frame_type == KEY_FRAME) {
5608 level_stats->ref_refresh_map = 0;
5611 level_stats->ref_refresh_map |= vp9_get_refresh_mask(cpi);
5612 // Also need to consider the case where the encoder refers to a buffer
5613 // that has been implicitly refreshed after encoding a keyframe.
5614 if (!cm->intra_only) {
5615 level_stats->ref_refresh_map |= (1 << cpi->lst_fb_idx);
5616 level_stats->ref_refresh_map |= (1 << cpi->gld_fb_idx);
5617 level_stats->ref_refresh_map |= (1 << cpi->alt_fb_idx);
5619 for (i = 0; i < REF_FRAMES; ++i) {
5620 count += (level_stats->ref_refresh_map >> i) & 1;
5622 if (count > level_spec->max_ref_frame_buffers) {
5623 level_spec->max_ref_frame_buffers = count;
5627 // update average_bitrate
5628 level_spec->average_bitrate = (double)level_stats->total_compressed_size /
5629 125.0 / level_stats->time_encoded;
5631 // update max_luma_sample_rate
5633 for (i = 0; i < level_stats->frame_window_buffer.len; ++i) {
5634 idx = (level_stats->frame_window_buffer.start +
5635 level_stats->frame_window_buffer.len - 1 - i) %
5638 dur_end = level_stats->frame_window_buffer.buf[idx].ts;
5640 if (dur_end - level_stats->frame_window_buffer.buf[idx].ts >=
5644 luma_samples += level_stats->frame_window_buffer.buf[idx].luma_samples;
5646 if (luma_samples > level_spec->max_luma_sample_rate) {
5647 level_spec->max_luma_sample_rate = luma_samples;
5650 // update max_cpb_size
5652 for (i = 0; i < CPB_WINDOW_SIZE; ++i) {
5653 if (i >= level_stats->frame_window_buffer.len) break;
5654 idx = (level_stats->frame_window_buffer.start +
5655 level_stats->frame_window_buffer.len - 1 - i) %
5657 cpb_data_size += level_stats->frame_window_buffer.buf[idx].size;
5659 cpb_data_size = cpb_data_size / 125.0;
5660 if (cpb_data_size > level_spec->max_cpb_size) {
5661 level_spec->max_cpb_size = cpb_data_size;
5664 // update max_luma_picture_size
5665 if (luma_pic_size > level_spec->max_luma_picture_size) {
5666 level_spec->max_luma_picture_size = luma_pic_size;
5669 // update max_luma_picture_breadth
5670 if (luma_pic_breadth > level_spec->max_luma_picture_breadth) {
5671 level_spec->max_luma_picture_breadth = luma_pic_breadth;
5674 // update compression_ratio
5675 level_spec->compression_ratio = (double)level_stats->total_uncompressed_size *
5677 level_stats->total_compressed_size / 8.0;
5679 // update max_col_tiles
5680 if (level_spec->max_col_tiles < (1 << cm->log2_tile_cols)) {
5681 level_spec->max_col_tiles = (1 << cm->log2_tile_cols);
5684 if (level_index >= 0 && level_constraint->fail_flag == 0) {
5685 if (level_spec->max_luma_picture_size >
5686 vp9_level_defs[level_index].max_luma_picture_size) {
5687 level_constraint->fail_flag |= (1 << LUMA_PIC_SIZE_TOO_LARGE);
5688 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5689 "Failed to encode to the target level %d. %s",
5690 vp9_level_defs[level_index].level,
5691 level_fail_messages[LUMA_PIC_SIZE_TOO_LARGE]);
5694 if (level_spec->max_luma_picture_breadth >
5695 vp9_level_defs[level_index].max_luma_picture_breadth) {
5696 level_constraint->fail_flag |= (1 << LUMA_PIC_BREADTH_TOO_LARGE);
5697 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5698 "Failed to encode to the target level %d. %s",
5699 vp9_level_defs[level_index].level,
5700 level_fail_messages[LUMA_PIC_BREADTH_TOO_LARGE]);
5703 if ((double)level_spec->max_luma_sample_rate >
5704 (double)vp9_level_defs[level_index].max_luma_sample_rate *
5705 (1 + SAMPLE_RATE_GRACE_P)) {
5706 level_constraint->fail_flag |= (1 << LUMA_SAMPLE_RATE_TOO_LARGE);
5707 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5708 "Failed to encode to the target level %d. %s",
5709 vp9_level_defs[level_index].level,
5710 level_fail_messages[LUMA_SAMPLE_RATE_TOO_LARGE]);
5713 if (level_spec->max_col_tiles > vp9_level_defs[level_index].max_col_tiles) {
5714 level_constraint->fail_flag |= (1 << TOO_MANY_COLUMN_TILE);
5715 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5716 "Failed to encode to the target level %d. %s",
5717 vp9_level_defs[level_index].level,
5718 level_fail_messages[TOO_MANY_COLUMN_TILE]);
5721 if (level_spec->min_altref_distance <
5722 vp9_level_defs[level_index].min_altref_distance) {
5723 level_constraint->fail_flag |= (1 << ALTREF_DIST_TOO_SMALL);
5724 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5725 "Failed to encode to the target level %d. %s",
5726 vp9_level_defs[level_index].level,
5727 level_fail_messages[ALTREF_DIST_TOO_SMALL]);
5730 if (level_spec->max_ref_frame_buffers >
5731 vp9_level_defs[level_index].max_ref_frame_buffers) {
5732 level_constraint->fail_flag |= (1 << TOO_MANY_REF_BUFFER);
5733 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5734 "Failed to encode to the target level %d. %s",
5735 vp9_level_defs[level_index].level,
5736 level_fail_messages[TOO_MANY_REF_BUFFER]);
5739 if (level_spec->max_cpb_size > vp9_level_defs[level_index].max_cpb_size) {
5740 level_constraint->fail_flag |= (1 << CPB_TOO_LARGE);
5741 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5742 "Failed to encode to the target level %d. %s",
5743 vp9_level_defs[level_index].level,
5744 level_fail_messages[CPB_TOO_LARGE]);
5747 // Set an upper bound for the next frame size. It will be used in
5748 // level_rc_framerate() before encoding the next frame.
5750 for (i = 0; i < CPB_WINDOW_SIZE - 1; ++i) {
5751 if (i >= level_stats->frame_window_buffer.len) break;
5752 idx = (level_stats->frame_window_buffer.start +
5753 level_stats->frame_window_buffer.len - 1 - i) %
5755 cpb_data_size += level_stats->frame_window_buffer.buf[idx].size;
5757 cpb_data_size = cpb_data_size / 125.0;
5758 level_constraint->max_frame_size =
5759 (int)((vp9_level_defs[level_index].max_cpb_size - cpb_data_size) *
5761 if (level_stats->frame_window_buffer.len < CPB_WINDOW_SIZE - 1)
5762 level_constraint->max_frame_size >>= 1;
5766 typedef struct GF_PICTURE {
5767 YV12_BUFFER_CONFIG *frame;
5769 FRAME_UPDATE_TYPE update_type;
5772 static void init_gop_frames(VP9_COMP *cpi, GF_PICTURE *gf_picture,
5773 const GF_GROUP *gf_group, int *tpl_group_frames) {
5774 VP9_COMMON *cm = &cpi->common;
5780 int arf_index_stack[MAX_ARF_LAYERS];
5781 int arf_stack_size = 0;
5782 int extend_frame_count = 0;
5783 int pframe_qindex = cpi->tpl_stats[2].base_qindex;
5784 int frame_gop_offset = 0;
5786 RefCntBuffer *frame_bufs = cm->buffer_pool->frame_bufs;
5787 int8_t recon_frame_index[REFS_PER_FRAME + MAX_ARF_LAYERS];
5789 memset(recon_frame_index, -1, sizeof(recon_frame_index));
5790 stack_init(arf_index_stack, MAX_ARF_LAYERS);
5792 // TODO(jingning): To be used later for gf frame type parsing.
5795 for (i = 0; i < FRAME_BUFFERS; ++i) {
5796 if (frame_bufs[i].ref_count == 0) {
5797 alloc_frame_mvs(cm, i);
5798 if (vpx_realloc_frame_buffer(&frame_bufs[i].buf, cm->width, cm->height,
5799 cm->subsampling_x, cm->subsampling_y,
5800 #if CONFIG_VP9_HIGHBITDEPTH
5801 cm->use_highbitdepth,
5803 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
5805 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
5806 "Failed to allocate frame buffer");
5808 recon_frame_index[frame_idx] = i;
5811 if (frame_idx >= REFS_PER_FRAME + cpi->oxcf.enable_auto_arf) break;
5815 for (i = 0; i < REFS_PER_FRAME + 1; ++i) {
5816 assert(recon_frame_index[i] >= 0);
5817 cpi->tpl_recon_frames[i] = &frame_bufs[recon_frame_index[i]].buf;
5820 *tpl_group_frames = 0;
5822 // Initialize Golden reference frame.
5823 gf_picture[0].frame = get_ref_frame_buffer(cpi, GOLDEN_FRAME);
5824 for (i = 0; i < 3; ++i) gf_picture[0].ref_frame[i] = -1;
5825 gf_picture[0].update_type = gf_group->update_type[0];
5827 ++*tpl_group_frames;
5829 // Initialize base layer ARF frame
5830 gf_picture[1].frame = cpi->Source;
5831 gf_picture[1].ref_frame[0] = gld_index;
5832 gf_picture[1].ref_frame[1] = lst_index;
5833 gf_picture[1].ref_frame[2] = alt_index;
5834 gf_picture[1].update_type = gf_group->update_type[1];
5836 ++*tpl_group_frames;
5838 // Initialize P frames
5839 for (frame_idx = 2; frame_idx < MAX_ARF_GOP_SIZE; ++frame_idx) {
5840 struct lookahead_entry *buf;
5841 frame_gop_offset = gf_group->frame_gop_index[frame_idx];
5842 buf = vp9_lookahead_peek(cpi->lookahead, frame_gop_offset - 1);
5844 if (buf == NULL) break;
5846 gf_picture[frame_idx].frame = &buf->img;
5847 gf_picture[frame_idx].ref_frame[0] = gld_index;
5848 gf_picture[frame_idx].ref_frame[1] = lst_index;
5849 gf_picture[frame_idx].ref_frame[2] = alt_index;
5850 gf_picture[frame_idx].update_type = gf_group->update_type[frame_idx];
5852 switch (gf_group->update_type[frame_idx]) {
5854 stack_push(arf_index_stack, alt_index, arf_stack_size);
5856 alt_index = frame_idx;
5858 case LF_UPDATE: lst_index = frame_idx; break;
5859 case OVERLAY_UPDATE:
5860 gld_index = frame_idx;
5861 alt_index = stack_pop(arf_index_stack, arf_stack_size);
5865 lst_index = alt_index;
5866 alt_index = stack_pop(arf_index_stack, arf_stack_size);
5872 ++*tpl_group_frames;
5874 // The length of group of pictures is baseline_gf_interval, plus the
5875 // beginning golden frame from last GOP, plus the last overlay frame in
5877 if (frame_idx == gf_group->gf_group_size) break;
5884 // Extend two frames outside the current gf group.
5885 for (; frame_idx < MAX_LAG_BUFFERS && extend_frame_count < 2; ++frame_idx) {
5886 struct lookahead_entry *buf =
5887 vp9_lookahead_peek(cpi->lookahead, frame_gop_offset - 1);
5889 if (buf == NULL) break;
5891 cpi->tpl_stats[frame_idx].base_qindex = pframe_qindex;
5893 gf_picture[frame_idx].frame = &buf->img;
5894 gf_picture[frame_idx].ref_frame[0] = gld_index;
5895 gf_picture[frame_idx].ref_frame[1] = lst_index;
5896 gf_picture[frame_idx].ref_frame[2] = alt_index;
5897 gf_picture[frame_idx].update_type = LF_UPDATE;
5898 lst_index = frame_idx;
5899 ++*tpl_group_frames;
5900 ++extend_frame_count;
5905 static void init_tpl_stats(VP9_COMP *cpi) {
5907 for (frame_idx = 0; frame_idx < MAX_ARF_GOP_SIZE; ++frame_idx) {
5908 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
5909 memset(tpl_frame->tpl_stats_ptr, 0,
5910 tpl_frame->height * tpl_frame->width *
5911 sizeof(*tpl_frame->tpl_stats_ptr));
5912 tpl_frame->is_valid = 0;
5916 #if CONFIG_NON_GREEDY_MV
5917 static uint32_t full_pixel_motion_search(VP9_COMP *cpi, ThreadData *td,
5918 MotionField *motion_field,
5919 int frame_idx, uint8_t *cur_frame_buf,
5920 uint8_t *ref_frame_buf, int stride,
5921 BLOCK_SIZE bsize, int mi_row,
5922 int mi_col, MV *mv) {
5923 MACROBLOCK *const x = &td->mb;
5924 MACROBLOCKD *const xd = &x->e_mbd;
5925 MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
5927 uint32_t bestsme = UINT_MAX;
5928 const MvLimits tmp_mv_limits = x->mv_limits;
5929 // lambda is used to adjust the importance of motion vector consitency.
5930 // TODO(angiebird): Figure out lambda's proper value.
5931 const int lambda = cpi->tpl_stats[frame_idx].lambda;
5932 int_mv nb_full_mvs[NB_MVS_NUM];
5935 MV best_ref_mv1 = { 0, 0 };
5936 MV best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */
5938 best_ref_mv1_full.col = best_ref_mv1.col >> 3;
5939 best_ref_mv1_full.row = best_ref_mv1.row >> 3;
5941 // Setup frame pointers
5942 x->plane[0].src.buf = cur_frame_buf;
5943 x->plane[0].src.stride = stride;
5944 xd->plane[0].pre[0].buf = ref_frame_buf;
5945 xd->plane[0].pre[0].stride = stride;
5947 step_param = mv_sf->reduce_first_step_size;
5948 step_param = VPXMIN(step_param, MAX_MVSEARCH_STEPS - 2);
5950 vp9_set_mv_search_range(&x->mv_limits, &best_ref_mv1);
5953 vp9_prepare_nb_full_mvs(motion_field, mi_row, mi_col, nb_full_mvs);
5954 vp9_full_pixel_diamond_new(cpi, x, bsize, &best_ref_mv1_full, step_param,
5955 lambda, 1, nb_full_mvs, nb_full_mv_num, mv);
5957 /* restore UMV window */
5958 x->mv_limits = tmp_mv_limits;
5963 static uint32_t sub_pixel_motion_search(VP9_COMP *cpi, ThreadData *td,
5964 uint8_t *cur_frame_buf,
5965 uint8_t *ref_frame_buf, int stride,
5966 BLOCK_SIZE bsize, MV *mv) {
5967 MACROBLOCK *const x = &td->mb;
5968 MACROBLOCKD *const xd = &x->e_mbd;
5969 MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
5970 uint32_t bestsme = UINT_MAX;
5971 uint32_t distortion;
5975 MV best_ref_mv1 = { 0, 0 };
5977 // Setup frame pointers
5978 x->plane[0].src.buf = cur_frame_buf;
5979 x->plane[0].src.stride = stride;
5980 xd->plane[0].pre[0].buf = ref_frame_buf;
5981 xd->plane[0].pre[0].stride = stride;
5983 // TODO(yunqing): may use higher tap interp filter than 2 taps.
5984 // Ignore mv costing by sending NULL pointer instead of cost array
5985 bestsme = cpi->find_fractional_mv_step(
5986 x, mv, &best_ref_mv1, cpi->common.allow_high_precision_mv, x->errorperbit,
5987 &cpi->fn_ptr[bsize], 0, mv_sf->subpel_search_level,
5988 cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL, 0, 0,
5994 #else // CONFIG_NON_GREEDY_MV
5995 static uint32_t motion_compensated_prediction(VP9_COMP *cpi, ThreadData *td,
5996 uint8_t *cur_frame_buf,
5997 uint8_t *ref_frame_buf,
5998 int stride, BLOCK_SIZE bsize,
6000 MACROBLOCK *const x = &td->mb;
6001 MACROBLOCKD *const xd = &x->e_mbd;
6002 MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
6003 const SEARCH_METHODS search_method = NSTEP;
6005 int sadpb = x->sadperbit16;
6006 uint32_t bestsme = UINT_MAX;
6007 uint32_t distortion;
6010 const MvLimits tmp_mv_limits = x->mv_limits;
6012 MV best_ref_mv1 = { 0, 0 };
6013 MV best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */
6015 best_ref_mv1_full.col = best_ref_mv1.col >> 3;
6016 best_ref_mv1_full.row = best_ref_mv1.row >> 3;
6018 // Setup frame pointers
6019 x->plane[0].src.buf = cur_frame_buf;
6020 x->plane[0].src.stride = stride;
6021 xd->plane[0].pre[0].buf = ref_frame_buf;
6022 xd->plane[0].pre[0].stride = stride;
6024 step_param = mv_sf->reduce_first_step_size;
6025 step_param = VPXMIN(step_param, MAX_MVSEARCH_STEPS - 2);
6027 vp9_set_mv_search_range(&x->mv_limits, &best_ref_mv1);
6029 vp9_full_pixel_search(cpi, x, bsize, &best_ref_mv1_full, step_param,
6030 search_method, sadpb, cond_cost_list(cpi, cost_list),
6031 &best_ref_mv1, mv, 0, 0);
6033 /* restore UMV window */
6034 x->mv_limits = tmp_mv_limits;
6036 // TODO(yunqing): may use higher tap interp filter than 2 taps.
6037 // Ignore mv costing by sending NULL pointer instead of cost array
6038 bestsme = cpi->find_fractional_mv_step(
6039 x, mv, &best_ref_mv1, cpi->common.allow_high_precision_mv, x->errorperbit,
6040 &cpi->fn_ptr[bsize], 0, mv_sf->subpel_search_level,
6041 cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL, 0, 0,
6048 static int get_overlap_area(int grid_pos_row, int grid_pos_col, int ref_pos_row,
6049 int ref_pos_col, int block, BLOCK_SIZE bsize) {
6050 int width = 0, height = 0;
6051 int bw = 4 << b_width_log2_lookup[bsize];
6052 int bh = 4 << b_height_log2_lookup[bsize];
6056 width = grid_pos_col + bw - ref_pos_col;
6057 height = grid_pos_row + bh - ref_pos_row;
6060 width = ref_pos_col + bw - grid_pos_col;
6061 height = grid_pos_row + bh - ref_pos_row;
6064 width = grid_pos_col + bw - ref_pos_col;
6065 height = ref_pos_row + bh - grid_pos_row;
6068 width = ref_pos_col + bw - grid_pos_col;
6069 height = ref_pos_row + bh - grid_pos_row;
6074 return width * height;
6077 static int round_floor(int ref_pos, int bsize_pix) {
6080 round = -(1 + (-ref_pos - 1) / bsize_pix);
6082 round = ref_pos / bsize_pix;
6087 static void tpl_model_store(TplDepStats *tpl_stats, int mi_row, int mi_col,
6088 BLOCK_SIZE bsize, int stride) {
6089 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6090 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6091 const TplDepStats *src_stats = &tpl_stats[mi_row * stride + mi_col];
6094 for (idy = 0; idy < mi_height; ++idy) {
6095 for (idx = 0; idx < mi_width; ++idx) {
6096 TplDepStats *tpl_ptr = &tpl_stats[(mi_row + idy) * stride + mi_col + idx];
6097 const int64_t mc_flow = tpl_ptr->mc_flow;
6098 const int64_t mc_ref_cost = tpl_ptr->mc_ref_cost;
6099 *tpl_ptr = *src_stats;
6100 tpl_ptr->mc_flow = mc_flow;
6101 tpl_ptr->mc_ref_cost = mc_ref_cost;
6102 tpl_ptr->mc_dep_cost = tpl_ptr->intra_cost + tpl_ptr->mc_flow;
6107 static void tpl_model_update_b(TplDepFrame *tpl_frame, TplDepStats *tpl_stats,
6108 int mi_row, int mi_col, const BLOCK_SIZE bsize) {
6109 TplDepFrame *ref_tpl_frame = &tpl_frame[tpl_stats->ref_frame_index];
6110 TplDepStats *ref_stats = ref_tpl_frame->tpl_stats_ptr;
6111 MV mv = tpl_stats->mv.as_mv;
6112 int mv_row = mv.row >> 3;
6113 int mv_col = mv.col >> 3;
6115 int ref_pos_row = mi_row * MI_SIZE + mv_row;
6116 int ref_pos_col = mi_col * MI_SIZE + mv_col;
6118 const int bw = 4 << b_width_log2_lookup[bsize];
6119 const int bh = 4 << b_height_log2_lookup[bsize];
6120 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6121 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6122 const int pix_num = bw * bh;
6124 // top-left on grid block location in pixel
6125 int grid_pos_row_base = round_floor(ref_pos_row, bh) * bh;
6126 int grid_pos_col_base = round_floor(ref_pos_col, bw) * bw;
6129 for (block = 0; block < 4; ++block) {
6130 int grid_pos_row = grid_pos_row_base + bh * (block >> 1);
6131 int grid_pos_col = grid_pos_col_base + bw * (block & 0x01);
6133 if (grid_pos_row >= 0 && grid_pos_row < ref_tpl_frame->mi_rows * MI_SIZE &&
6134 grid_pos_col >= 0 && grid_pos_col < ref_tpl_frame->mi_cols * MI_SIZE) {
6135 int overlap_area = get_overlap_area(
6136 grid_pos_row, grid_pos_col, ref_pos_row, ref_pos_col, block, bsize);
6137 int ref_mi_row = round_floor(grid_pos_row, bh) * mi_height;
6138 int ref_mi_col = round_floor(grid_pos_col, bw) * mi_width;
6140 int64_t mc_flow = tpl_stats->mc_dep_cost -
6141 (tpl_stats->mc_dep_cost * tpl_stats->inter_cost) /
6142 tpl_stats->intra_cost;
6146 for (idy = 0; idy < mi_height; ++idy) {
6147 for (idx = 0; idx < mi_width; ++idx) {
6148 TplDepStats *des_stats =
6149 &ref_stats[(ref_mi_row + idy) * ref_tpl_frame->stride +
6150 (ref_mi_col + idx)];
6152 des_stats->mc_flow += (mc_flow * overlap_area) / pix_num;
6153 des_stats->mc_ref_cost +=
6154 ((tpl_stats->intra_cost - tpl_stats->inter_cost) * overlap_area) /
6156 assert(overlap_area >= 0);
6163 static void tpl_model_update(TplDepFrame *tpl_frame, TplDepStats *tpl_stats,
6164 int mi_row, int mi_col, const BLOCK_SIZE bsize) {
6166 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6167 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6169 for (idy = 0; idy < mi_height; ++idy) {
6170 for (idx = 0; idx < mi_width; ++idx) {
6171 TplDepStats *tpl_ptr =
6172 &tpl_stats[(mi_row + idy) * tpl_frame->stride + (mi_col + idx)];
6173 tpl_model_update_b(tpl_frame, tpl_ptr, mi_row + idy, mi_col + idx,
6179 static void get_quantize_error(MACROBLOCK *x, int plane, tran_low_t *coeff,
6180 tran_low_t *qcoeff, tran_low_t *dqcoeff,
6181 TX_SIZE tx_size, int64_t *recon_error,
6183 MACROBLOCKD *const xd = &x->e_mbd;
6184 const struct macroblock_plane *const p = &x->plane[plane];
6185 const struct macroblockd_plane *const pd = &xd->plane[plane];
6186 const scan_order *const scan_order = &vp9_default_scan_orders[tx_size];
6188 int pix_num = 1 << num_pels_log2_lookup[txsize_to_bsize[tx_size]];
6189 const int shift = tx_size == TX_32X32 ? 0 : 2;
6191 #if CONFIG_VP9_HIGHBITDEPTH
6192 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6193 vp9_highbd_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp,
6194 p->quant_fp, qcoeff, dqcoeff, pd->dequant,
6195 &eob, scan_order->scan, scan_order->iscan);
6197 vp9_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp,
6198 p->quant_fp, qcoeff, dqcoeff, pd->dequant, &eob,
6199 scan_order->scan, scan_order->iscan);
6202 vp9_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp, p->quant_fp,
6203 qcoeff, dqcoeff, pd->dequant, &eob, scan_order->scan,
6205 #endif // CONFIG_VP9_HIGHBITDEPTH
6207 *recon_error = vp9_block_error(coeff, dqcoeff, pix_num, sse) >> shift;
6208 *recon_error = VPXMAX(*recon_error, 1);
6210 *sse = (*sse) >> shift;
6211 *sse = VPXMAX(*sse, 1);
6214 #if CONFIG_VP9_HIGHBITDEPTH
6215 void highbd_wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
6217 // TODO(sdeng): Implement SIMD based high bit-depth Hadamard transforms.
6219 case TX_8X8: vpx_highbd_hadamard_8x8(src_diff, bw, coeff); break;
6220 case TX_16X16: vpx_highbd_hadamard_16x16(src_diff, bw, coeff); break;
6221 case TX_32X32: vpx_highbd_hadamard_32x32(src_diff, bw, coeff); break;
6225 #endif // CONFIG_VP9_HIGHBITDEPTH
6227 void wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
6230 case TX_8X8: vpx_hadamard_8x8(src_diff, bw, coeff); break;
6231 case TX_16X16: vpx_hadamard_16x16(src_diff, bw, coeff); break;
6232 case TX_32X32: vpx_hadamard_32x32(src_diff, bw, coeff); break;
6237 static void set_mv_limits(const VP9_COMMON *cm, MACROBLOCK *x, int mi_row,
6239 x->mv_limits.row_min = -((mi_row * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND));
6240 x->mv_limits.row_max =
6241 (cm->mi_rows - 1 - mi_row) * MI_SIZE + (17 - 2 * VP9_INTERP_EXTEND);
6242 x->mv_limits.col_min = -((mi_col * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND));
6243 x->mv_limits.col_max =
6244 ((cm->mi_cols - 1 - mi_col) * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND);
6247 static void mode_estimation(VP9_COMP *cpi, MACROBLOCK *x, MACROBLOCKD *xd,
6248 struct scale_factors *sf, GF_PICTURE *gf_picture,
6249 int frame_idx, TplDepFrame *tpl_frame,
6250 int16_t *src_diff, tran_low_t *coeff,
6251 tran_low_t *qcoeff, tran_low_t *dqcoeff, int mi_row,
6252 int mi_col, BLOCK_SIZE bsize, TX_SIZE tx_size,
6253 YV12_BUFFER_CONFIG *ref_frame[], uint8_t *predictor,
6254 int64_t *recon_error, int64_t *sse) {
6255 VP9_COMMON *cm = &cpi->common;
6256 ThreadData *td = &cpi->td;
6258 const int bw = 4 << b_width_log2_lookup[bsize];
6259 const int bh = 4 << b_height_log2_lookup[bsize];
6260 const int pix_num = bw * bh;
6261 int best_rf_idx = -1;
6263 int64_t best_inter_cost = INT64_MAX;
6266 const InterpKernel *const kernel = vp9_filter_kernels[EIGHTTAP];
6268 int64_t best_intra_cost = INT64_MAX;
6270 PREDICTION_MODE mode;
6271 int mb_y_offset = mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6272 MODE_INFO mi_above, mi_left;
6273 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6274 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6275 TplDepStats *tpl_stats =
6276 &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
6278 xd->mb_to_top_edge = -((mi_row * MI_SIZE) * 8);
6279 xd->mb_to_bottom_edge = ((cm->mi_rows - 1 - mi_row) * MI_SIZE) * 8;
6280 xd->mb_to_left_edge = -((mi_col * MI_SIZE) * 8);
6281 xd->mb_to_right_edge = ((cm->mi_cols - 1 - mi_col) * MI_SIZE) * 8;
6282 xd->above_mi = (mi_row > 0) ? &mi_above : NULL;
6283 xd->left_mi = (mi_col > 0) ? &mi_left : NULL;
6285 // Intra prediction search
6286 for (mode = DC_PRED; mode <= TM_PRED; ++mode) {
6288 int src_stride, dst_stride;
6290 src = xd->cur_buf->y_buffer + mb_y_offset;
6291 src_stride = xd->cur_buf->y_stride;
6293 dst = &predictor[0];
6296 xd->mi[0]->sb_type = bsize;
6297 xd->mi[0]->ref_frame[0] = INTRA_FRAME;
6299 vp9_predict_intra_block(xd, b_width_log2_lookup[bsize], tx_size, mode, src,
6300 src_stride, dst, dst_stride, 0, 0, 0);
6302 #if CONFIG_VP9_HIGHBITDEPTH
6303 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6304 vpx_highbd_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst,
6305 dst_stride, xd->bd);
6306 highbd_wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6307 intra_cost = vpx_highbd_satd(coeff, pix_num);
6309 vpx_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst,
6311 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6312 intra_cost = vpx_satd(coeff, pix_num);
6315 vpx_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst, dst_stride);
6316 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6317 intra_cost = vpx_satd(coeff, pix_num);
6318 #endif // CONFIG_VP9_HIGHBITDEPTH
6320 if (intra_cost < best_intra_cost) best_intra_cost = intra_cost;
6323 // Motion compensated prediction
6326 set_mv_limits(cm, x, mi_row, mi_col);
6328 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6330 #if CONFIG_NON_GREEDY_MV
6331 MotionField *motion_field;
6333 if (ref_frame[rf_idx] == NULL) continue;
6335 #if CONFIG_NON_GREEDY_MV
6337 motion_field = vp9_motion_field_info_get_motion_field(
6338 &cpi->motion_field_info, frame_idx, rf_idx, bsize);
6339 mv = vp9_motion_field_mi_get_mv(motion_field, mi_row, mi_col);
6341 motion_compensated_prediction(cpi, td, xd->cur_buf->y_buffer + mb_y_offset,
6342 ref_frame[rf_idx]->y_buffer + mb_y_offset,
6343 xd->cur_buf->y_stride, bsize, &mv.as_mv);
6346 #if CONFIG_VP9_HIGHBITDEPTH
6347 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6348 vp9_highbd_build_inter_predictor(
6349 CONVERT_TO_SHORTPTR(ref_frame[rf_idx]->y_buffer + mb_y_offset),
6350 ref_frame[rf_idx]->y_stride, CONVERT_TO_SHORTPTR(&predictor[0]), bw,
6351 &mv.as_mv, sf, bw, bh, 0, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE,
6352 mi_row * MI_SIZE, xd->bd);
6353 vpx_highbd_subtract_block(
6354 bh, bw, src_diff, bw, xd->cur_buf->y_buffer + mb_y_offset,
6355 xd->cur_buf->y_stride, &predictor[0], bw, xd->bd);
6356 highbd_wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6357 inter_cost = vpx_highbd_satd(coeff, pix_num);
6359 vp9_build_inter_predictor(
6360 ref_frame[rf_idx]->y_buffer + mb_y_offset,
6361 ref_frame[rf_idx]->y_stride, &predictor[0], bw, &mv.as_mv, sf, bw, bh,
6362 0, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE, mi_row * MI_SIZE);
6363 vpx_subtract_block(bh, bw, src_diff, bw,
6364 xd->cur_buf->y_buffer + mb_y_offset,
6365 xd->cur_buf->y_stride, &predictor[0], bw);
6366 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6367 inter_cost = vpx_satd(coeff, pix_num);
6370 vp9_build_inter_predictor(ref_frame[rf_idx]->y_buffer + mb_y_offset,
6371 ref_frame[rf_idx]->y_stride, &predictor[0], bw,
6372 &mv.as_mv, sf, bw, bh, 0, kernel, MV_PRECISION_Q3,
6373 mi_col * MI_SIZE, mi_row * MI_SIZE);
6374 vpx_subtract_block(bh, bw, src_diff, bw,
6375 xd->cur_buf->y_buffer + mb_y_offset,
6376 xd->cur_buf->y_stride, &predictor[0], bw);
6377 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6378 inter_cost = vpx_satd(coeff, pix_num);
6381 if (inter_cost < best_inter_cost) {
6382 best_rf_idx = rf_idx;
6383 best_inter_cost = inter_cost;
6384 best_mv.as_int = mv.as_int;
6385 get_quantize_error(x, 0, coeff, qcoeff, dqcoeff, tx_size, recon_error,
6389 best_intra_cost = VPXMAX(best_intra_cost, 1);
6390 best_inter_cost = VPXMIN(best_intra_cost, best_inter_cost);
6391 tpl_stats->inter_cost = VPXMAX(
6392 1, (best_inter_cost << TPL_DEP_COST_SCALE_LOG2) / (mi_height * mi_width));
6393 tpl_stats->intra_cost = VPXMAX(
6394 1, (best_intra_cost << TPL_DEP_COST_SCALE_LOG2) / (mi_height * mi_width));
6395 tpl_stats->ref_frame_index = gf_picture[frame_idx].ref_frame[best_rf_idx];
6396 tpl_stats->mv.as_int = best_mv.as_int;
6399 #if CONFIG_NON_GREEDY_MV
6400 static int get_block_src_pred_buf(MACROBLOCKD *xd, GF_PICTURE *gf_picture,
6401 int frame_idx, int rf_idx, int mi_row,
6402 int mi_col, struct buf_2d *src,
6403 struct buf_2d *pre) {
6404 const int mb_y_offset =
6405 mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6406 YV12_BUFFER_CONFIG *ref_frame = NULL;
6407 int ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
6408 if (ref_frame_idx != -1) {
6409 ref_frame = gf_picture[ref_frame_idx].frame;
6410 src->buf = xd->cur_buf->y_buffer + mb_y_offset;
6411 src->stride = xd->cur_buf->y_stride;
6412 pre->buf = ref_frame->y_buffer + mb_y_offset;
6413 pre->stride = ref_frame->y_stride;
6414 assert(src->stride == pre->stride);
6417 printf("invalid ref_frame_idx");
6418 assert(ref_frame_idx != -1);
6423 #define kMvPreCheckLines 5
6424 #define kMvPreCheckSize 15
6426 #define MV_REF_POS_NUM 3
6427 POSITION mv_ref_pos[MV_REF_POS_NUM] = {
6433 static int_mv *get_select_mv(VP9_COMP *cpi, TplDepFrame *tpl_frame, int mi_row,
6435 return &cpi->select_mv_arr[mi_row * tpl_frame->stride + mi_col];
6438 static int_mv find_ref_mv(int mv_mode, VP9_COMP *cpi, TplDepFrame *tpl_frame,
6439 BLOCK_SIZE bsize, int mi_row, int mi_col) {
6441 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6442 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6443 int_mv nearest_mv, near_mv, invalid_mv;
6444 nearest_mv.as_int = INVALID_MV;
6445 near_mv.as_int = INVALID_MV;
6446 invalid_mv.as_int = INVALID_MV;
6447 for (i = 0; i < MV_REF_POS_NUM; ++i) {
6448 int nb_row = mi_row + mv_ref_pos[i].row * mi_height;
6449 int nb_col = mi_col + mv_ref_pos[i].col * mi_width;
6450 assert(mv_ref_pos[i].row <= 0);
6451 assert(mv_ref_pos[i].col <= 0);
6452 if (nb_row >= 0 && nb_col >= 0) {
6453 if (nearest_mv.as_int == INVALID_MV) {
6454 nearest_mv = *get_select_mv(cpi, tpl_frame, nb_row, nb_col);
6456 int_mv mv = *get_select_mv(cpi, tpl_frame, nb_row, nb_col);
6457 if (mv.as_int == nearest_mv.as_int) {
6466 if (nearest_mv.as_int == INVALID_MV) {
6467 nearest_mv.as_mv.row = 0;
6468 nearest_mv.as_mv.col = 0;
6470 if (near_mv.as_int == INVALID_MV) {
6471 near_mv.as_mv.row = 0;
6472 near_mv.as_mv.col = 0;
6474 if (mv_mode == NEAREST_MV_MODE) {
6477 if (mv_mode == NEAR_MV_MODE) {
6484 static int_mv get_mv_from_mv_mode(int mv_mode, VP9_COMP *cpi,
6485 MotionField *motion_field,
6486 TplDepFrame *tpl_frame, BLOCK_SIZE bsize,
6487 int mi_row, int mi_col) {
6495 mv = vp9_motion_field_mi_get_mv(motion_field, mi_row, mi_col);
6497 case NEAREST_MV_MODE:
6498 mv = find_ref_mv(mv_mode, cpi, tpl_frame, bsize, mi_row, mi_col);
6501 mv = find_ref_mv(mv_mode, cpi, tpl_frame, bsize, mi_row, mi_col);
6504 mv.as_int = INVALID_MV;
6511 static double get_mv_dist(int mv_mode, VP9_COMP *cpi, MACROBLOCKD *xd,
6512 GF_PICTURE *gf_picture, MotionField *motion_field,
6513 int frame_idx, TplDepFrame *tpl_frame, int rf_idx,
6514 BLOCK_SIZE bsize, int mi_row, int mi_col,
6520 *mv = get_mv_from_mv_mode(mv_mode, cpi, motion_field, tpl_frame, bsize,
6522 full_mv = get_full_mv(&mv->as_mv);
6523 if (get_block_src_pred_buf(xd, gf_picture, frame_idx, rf_idx, mi_row, mi_col,
6525 // TODO(angiebird): Consider subpixel when computing the sse.
6526 cpi->fn_ptr[bsize].vf(src.buf, src.stride, get_buf_from_mv(&pre, &full_mv),
6528 return (double)(sse << VP9_DIST_SCALE_LOG2);
6535 static int get_mv_mode_cost(int mv_mode) {
6536 // TODO(angiebird): The probabilities are roughly inferred from
6537 // default_inter_mode_probs. Check if there is a better way to set the
6539 const int zero_mv_prob = 16;
6540 const int new_mv_prob = 24 * 1;
6541 const int ref_mv_prob = 256 - zero_mv_prob - new_mv_prob;
6542 assert(zero_mv_prob + new_mv_prob + ref_mv_prob == 256);
6544 case ZERO_MV_MODE: return vp9_prob_cost[zero_mv_prob]; break;
6545 case NEW_MV_MODE: return vp9_prob_cost[new_mv_prob]; break;
6546 case NEAREST_MV_MODE: return vp9_prob_cost[ref_mv_prob]; break;
6547 case NEAR_MV_MODE: return vp9_prob_cost[ref_mv_prob]; break;
6548 default: assert(0); return -1;
6552 static INLINE double get_mv_diff_cost(MV *new_mv, MV *ref_mv) {
6553 double mv_diff_cost = log2(1 + abs(new_mv->row - ref_mv->row)) +
6554 log2(1 + abs(new_mv->col - ref_mv->col));
6555 mv_diff_cost *= (1 << VP9_PROB_COST_SHIFT);
6556 return mv_diff_cost;
6558 static double get_mv_cost(int mv_mode, VP9_COMP *cpi, MotionField *motion_field,
6559 TplDepFrame *tpl_frame, BLOCK_SIZE bsize, int mi_row,
6561 double mv_cost = get_mv_mode_cost(mv_mode);
6562 if (mv_mode == NEW_MV_MODE) {
6563 MV new_mv = get_mv_from_mv_mode(mv_mode, cpi, motion_field, tpl_frame,
6564 bsize, mi_row, mi_col)
6566 MV nearest_mv = get_mv_from_mv_mode(NEAREST_MV_MODE, cpi, motion_field,
6567 tpl_frame, bsize, mi_row, mi_col)
6569 MV near_mv = get_mv_from_mv_mode(NEAR_MV_MODE, cpi, motion_field, tpl_frame,
6570 bsize, mi_row, mi_col)
6572 double nearest_cost = get_mv_diff_cost(&new_mv, &nearest_mv);
6573 double near_cost = get_mv_diff_cost(&new_mv, &near_mv);
6574 mv_cost += nearest_cost < near_cost ? nearest_cost : near_cost;
6579 static double eval_mv_mode(int mv_mode, VP9_COMP *cpi, MACROBLOCK *x,
6580 GF_PICTURE *gf_picture, MotionField *motion_field,
6581 int frame_idx, TplDepFrame *tpl_frame, int rf_idx,
6582 BLOCK_SIZE bsize, int mi_row, int mi_col,
6584 MACROBLOCKD *xd = &x->e_mbd;
6586 get_mv_dist(mv_mode, cpi, xd, gf_picture, motion_field, frame_idx,
6587 tpl_frame, rf_idx, bsize, mi_row, mi_col, mv);
6589 get_mv_cost(mv_mode, cpi, motion_field, tpl_frame, bsize, mi_row, mi_col);
6592 return mv_cost + mult * log2f(1 + mv_dist);
6595 static int find_best_ref_mv_mode(VP9_COMP *cpi, MACROBLOCK *x,
6596 GF_PICTURE *gf_picture,
6597 MotionField *motion_field, int frame_idx,
6598 TplDepFrame *tpl_frame, int rf_idx,
6599 BLOCK_SIZE bsize, int mi_row, int mi_col,
6600 double *rd, int_mv *mv) {
6601 int best_mv_mode = ZERO_MV_MODE;
6605 for (mv_mode = 0; mv_mode < MAX_MV_MODE; ++mv_mode) {
6608 if (mv_mode == NEW_MV_MODE) {
6611 this_rd = eval_mv_mode(mv_mode, cpi, x, gf_picture, motion_field, frame_idx,
6612 tpl_frame, rf_idx, bsize, mi_row, mi_col, &this_mv);
6616 best_mv_mode = mv_mode;
6619 if (this_rd < *rd) {
6622 best_mv_mode = mv_mode;
6626 return best_mv_mode;
6629 static void predict_mv_mode(VP9_COMP *cpi, MACROBLOCK *x,
6630 GF_PICTURE *gf_picture, MotionField *motion_field,
6631 int frame_idx, TplDepFrame *tpl_frame, int rf_idx,
6632 BLOCK_SIZE bsize, int mi_row, int mi_col) {
6633 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6634 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6635 int tmp_mv_mode_arr[kMvPreCheckSize];
6636 int *mv_mode_arr = tpl_frame->mv_mode_arr[rf_idx];
6637 double *rd_diff_arr = tpl_frame->rd_diff_arr[rf_idx];
6638 int_mv *select_mv_arr = cpi->select_mv_arr;
6639 int_mv tmp_select_mv_arr[kMvPreCheckSize];
6640 int stride = tpl_frame->stride;
6641 double new_mv_rd = 0;
6642 double no_new_mv_rd = 0;
6643 double this_new_mv_rd = 0;
6644 double this_no_new_mv_rd = 0;
6647 assert(kMvPreCheckSize == (kMvPreCheckLines * (kMvPreCheckLines + 1)) >> 1);
6650 // diagnal scan order
6652 for (idx = 0; idx < kMvPreCheckLines; ++idx) {
6654 for (r = 0; r <= idx; ++r) {
6656 int nb_row = mi_row + r * mi_height;
6657 int nb_col = mi_col + c * mi_width;
6658 if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6660 int_mv *mv = &select_mv_arr[nb_row * stride + nb_col];
6661 mv_mode_arr[nb_row * stride + nb_col] = find_best_ref_mv_mode(
6662 cpi, x, gf_picture, motion_field, frame_idx, tpl_frame, rf_idx,
6663 bsize, nb_row, nb_col, &this_rd, mv);
6664 if (r == 0 && c == 0) {
6665 this_no_new_mv_rd = this_rd;
6667 no_new_mv_rd += this_rd;
6668 tmp_mv_mode_arr[tmp_idx] = mv_mode_arr[nb_row * stride + nb_col];
6669 tmp_select_mv_arr[tmp_idx] = select_mv_arr[nb_row * stride + nb_col];
6676 mv_mode_arr[mi_row * stride + mi_col] = NEW_MV_MODE;
6677 this_new_mv_rd = eval_mv_mode(
6678 NEW_MV_MODE, cpi, x, gf_picture, motion_field, frame_idx, tpl_frame,
6679 rf_idx, bsize, mi_row, mi_col, &select_mv_arr[mi_row * stride + mi_col]);
6680 new_mv_rd = this_new_mv_rd;
6681 // We start from idx = 1 because idx = 0 is evaluated as NEW_MV_MODE
6683 for (idx = 1; idx < kMvPreCheckLines; ++idx) {
6685 for (r = 0; r <= idx; ++r) {
6687 int nb_row = mi_row + r * mi_height;
6688 int nb_col = mi_col + c * mi_width;
6689 if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6691 int_mv *mv = &select_mv_arr[nb_row * stride + nb_col];
6692 mv_mode_arr[nb_row * stride + nb_col] = find_best_ref_mv_mode(
6693 cpi, x, gf_picture, motion_field, frame_idx, tpl_frame, rf_idx,
6694 bsize, nb_row, nb_col, &this_rd, mv);
6695 new_mv_rd += this_rd;
6700 // update best_mv_mode
6702 if (no_new_mv_rd < new_mv_rd) {
6703 for (idx = 0; idx < kMvPreCheckLines; ++idx) {
6705 for (r = 0; r <= idx; ++r) {
6707 int nb_row = mi_row + r * mi_height;
6708 int nb_col = mi_col + c * mi_width;
6709 if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6710 mv_mode_arr[nb_row * stride + nb_col] = tmp_mv_mode_arr[tmp_idx];
6711 select_mv_arr[nb_row * stride + nb_col] = tmp_select_mv_arr[tmp_idx];
6716 rd_diff_arr[mi_row * stride + mi_col] = 0;
6718 rd_diff_arr[mi_row * stride + mi_col] =
6719 (no_new_mv_rd - this_no_new_mv_rd) - (new_mv_rd - this_new_mv_rd);
6723 static void predict_mv_mode_arr(VP9_COMP *cpi, MACROBLOCK *x,
6724 GF_PICTURE *gf_picture,
6725 MotionField *motion_field, int frame_idx,
6726 TplDepFrame *tpl_frame, int rf_idx,
6728 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6729 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6730 const int unit_rows = tpl_frame->mi_rows / mi_height;
6731 const int unit_cols = tpl_frame->mi_cols / mi_width;
6732 const int max_diagonal_lines = unit_rows + unit_cols - 1;
6734 for (idx = 0; idx < max_diagonal_lines; ++idx) {
6736 for (r = VPXMAX(idx - unit_cols + 1, 0); r <= VPXMIN(idx, unit_rows - 1);
6739 int mi_row = r * mi_height;
6740 int mi_col = c * mi_width;
6741 assert(c >= 0 && c < unit_cols);
6742 assert(mi_row >= 0 && mi_row < tpl_frame->mi_rows);
6743 assert(mi_col >= 0 && mi_col < tpl_frame->mi_cols);
6744 predict_mv_mode(cpi, x, gf_picture, motion_field, frame_idx, tpl_frame,
6745 rf_idx, bsize, mi_row, mi_col);
6750 static void do_motion_search(VP9_COMP *cpi, ThreadData *td,
6751 MotionField *motion_field, int frame_idx,
6752 YV12_BUFFER_CONFIG *ref_frame, BLOCK_SIZE bsize,
6753 int mi_row, int mi_col) {
6754 VP9_COMMON *cm = &cpi->common;
6755 MACROBLOCK *x = &td->mb;
6756 MACROBLOCKD *xd = &x->e_mbd;
6757 const int mb_y_offset =
6758 mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6759 assert(ref_frame != NULL);
6760 set_mv_limits(cm, x, mi_row, mi_col);
6762 int_mv mv = vp9_motion_field_mi_get_mv(motion_field, mi_row, mi_col);
6763 uint8_t *cur_frame_buf = xd->cur_buf->y_buffer + mb_y_offset;
6764 uint8_t *ref_frame_buf = ref_frame->y_buffer + mb_y_offset;
6765 const int stride = xd->cur_buf->y_stride;
6766 full_pixel_motion_search(cpi, td, motion_field, frame_idx, cur_frame_buf,
6767 ref_frame_buf, stride, bsize, mi_row, mi_col,
6769 sub_pixel_motion_search(cpi, td, cur_frame_buf, ref_frame_buf, stride,
6771 vp9_motion_field_mi_set_mv(motion_field, mi_row, mi_col, mv);
6775 static void build_motion_field(
6776 VP9_COMP *cpi, int frame_idx,
6777 YV12_BUFFER_CONFIG *ref_frame[MAX_INTER_REF_FRAMES], BLOCK_SIZE bsize) {
6778 VP9_COMMON *cm = &cpi->common;
6779 ThreadData *td = &cpi->td;
6780 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6781 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6782 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6783 const int pw = num_4x4_blocks_wide_lookup[bsize] << 2;
6784 const int ph = num_4x4_blocks_high_lookup[bsize] << 2;
6788 tpl_frame->lambda = (pw * ph) >> 2;
6789 assert(pw * ph == tpl_frame->lambda << 2);
6791 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6792 MotionField *motion_field = vp9_motion_field_info_get_motion_field(
6793 &cpi->motion_field_info, frame_idx, rf_idx, bsize);
6794 if (ref_frame[rf_idx] == NULL) {
6797 vp9_motion_field_reset_mvs(motion_field);
6798 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6799 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6800 do_motion_search(cpi, td, motion_field, frame_idx, ref_frame[rf_idx],
6801 bsize, mi_row, mi_col);
6806 #endif // CONFIG_NON_GREEDY_MV
6808 static void mc_flow_dispenser(VP9_COMP *cpi, GF_PICTURE *gf_picture,
6809 int frame_idx, BLOCK_SIZE bsize) {
6810 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6811 YV12_BUFFER_CONFIG *this_frame = gf_picture[frame_idx].frame;
6812 YV12_BUFFER_CONFIG *ref_frame[MAX_INTER_REF_FRAMES] = { NULL, NULL, NULL };
6814 VP9_COMMON *cm = &cpi->common;
6815 struct scale_factors sf;
6817 ThreadData *td = &cpi->td;
6818 MACROBLOCK *x = &td->mb;
6819 MACROBLOCKD *xd = &x->e_mbd;
6822 #if CONFIG_VP9_HIGHBITDEPTH
6823 DECLARE_ALIGNED(16, uint16_t, predictor16[32 * 32 * 3]);
6824 DECLARE_ALIGNED(16, uint8_t, predictor8[32 * 32 * 3]);
6827 DECLARE_ALIGNED(16, uint8_t, predictor[32 * 32 * 3]);
6829 DECLARE_ALIGNED(16, int16_t, src_diff[32 * 32]);
6830 DECLARE_ALIGNED(16, tran_low_t, coeff[32 * 32]);
6831 DECLARE_ALIGNED(16, tran_low_t, qcoeff[32 * 32]);
6832 DECLARE_ALIGNED(16, tran_low_t, dqcoeff[32 * 32]);
6834 const TX_SIZE tx_size = max_txsize_lookup[bsize];
6835 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6836 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6837 int64_t recon_error, sse;
6838 #if CONFIG_NON_GREEDY_MV
6839 int square_block_idx;
6843 // Setup scaling factor
6844 #if CONFIG_VP9_HIGHBITDEPTH
6845 vp9_setup_scale_factors_for_frame(
6846 &sf, this_frame->y_crop_width, this_frame->y_crop_height,
6847 this_frame->y_crop_width, this_frame->y_crop_height,
6848 cpi->common.use_highbitdepth);
6850 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH)
6851 predictor = CONVERT_TO_BYTEPTR(predictor16);
6853 predictor = predictor8;
6855 vp9_setup_scale_factors_for_frame(
6856 &sf, this_frame->y_crop_width, this_frame->y_crop_height,
6857 this_frame->y_crop_width, this_frame->y_crop_height);
6858 #endif // CONFIG_VP9_HIGHBITDEPTH
6860 // Prepare reference frame pointers. If any reference frame slot is
6861 // unavailable, the pointer will be set to Null.
6862 for (idx = 0; idx < MAX_INTER_REF_FRAMES; ++idx) {
6863 int rf_idx = gf_picture[frame_idx].ref_frame[idx];
6864 if (rf_idx != -1) ref_frame[idx] = gf_picture[rf_idx].frame;
6867 xd->mi = cm->mi_grid_visible;
6869 xd->cur_buf = this_frame;
6871 // Get rd multiplier set up.
6872 rdmult = vp9_compute_rd_mult_based_on_qindex(cpi, tpl_frame->base_qindex);
6873 set_error_per_bit(&cpi->td.mb, rdmult);
6874 vp9_initialize_me_consts(cpi, &cpi->td.mb, tpl_frame->base_qindex);
6876 tpl_frame->is_valid = 1;
6878 cm->base_qindex = tpl_frame->base_qindex;
6879 vp9_frame_init_quantizer(cpi);
6881 #if CONFIG_NON_GREEDY_MV
6882 for (square_block_idx = 0; square_block_idx < SQUARE_BLOCK_SIZES;
6883 ++square_block_idx) {
6884 BLOCK_SIZE square_bsize = square_block_idx_to_bsize(square_block_idx);
6885 build_motion_field(cpi, frame_idx, ref_frame, square_bsize);
6887 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6888 int ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
6889 if (ref_frame_idx != -1) {
6890 MotionField *motion_field = vp9_motion_field_info_get_motion_field(
6891 &cpi->motion_field_info, frame_idx, rf_idx, bsize);
6892 predict_mv_mode_arr(cpi, x, gf_picture, motion_field, frame_idx,
6893 tpl_frame, rf_idx, bsize);
6898 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6899 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6900 mode_estimation(cpi, x, xd, &sf, gf_picture, frame_idx, tpl_frame,
6901 src_diff, coeff, qcoeff, dqcoeff, mi_row, mi_col, bsize,
6902 tx_size, ref_frame, predictor, &recon_error, &sse);
6903 // Motion flow dependency dispenser.
6904 tpl_model_store(tpl_frame->tpl_stats_ptr, mi_row, mi_col, bsize,
6907 tpl_model_update(cpi->tpl_stats, tpl_frame->tpl_stats_ptr, mi_row, mi_col,
6913 #if CONFIG_NON_GREEDY_MV
6914 #define DUMP_TPL_STATS 0
6916 static void dump_buf(uint8_t *buf, int stride, int row, int col, int h, int w) {
6918 printf("%d %d\n", h, w);
6919 for (i = 0; i < h; ++i) {
6920 for (j = 0; j < w; ++j) {
6921 printf("%d ", buf[(row + i) * stride + col + j]);
6927 static void dump_frame_buf(const YV12_BUFFER_CONFIG *frame_buf) {
6928 dump_buf(frame_buf->y_buffer, frame_buf->y_stride, 0, 0, frame_buf->y_height,
6929 frame_buf->y_width);
6930 dump_buf(frame_buf->u_buffer, frame_buf->uv_stride, 0, 0,
6931 frame_buf->uv_height, frame_buf->uv_width);
6932 dump_buf(frame_buf->v_buffer, frame_buf->uv_stride, 0, 0,
6933 frame_buf->uv_height, frame_buf->uv_width);
6936 static void dump_tpl_stats(const VP9_COMP *cpi, int tpl_group_frames,
6937 const GF_GROUP *gf_group,
6938 const GF_PICTURE *gf_picture, BLOCK_SIZE bsize) {
6940 const VP9_COMMON *cm = &cpi->common;
6942 for (frame_idx = 1; frame_idx < tpl_group_frames; ++frame_idx) {
6943 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6944 const TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6947 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6948 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6949 ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
6950 if (ref_frame_idx != -1) {
6951 YV12_BUFFER_CONFIG *ref_frame_buf = gf_picture[ref_frame_idx].frame;
6952 const int gf_frame_offset = gf_group->frame_gop_index[frame_idx];
6953 const int ref_gf_frame_offset =
6954 gf_group->frame_gop_index[ref_frame_idx];
6957 "frame_idx %d mi_rows %d mi_cols %d bsize %d ref_frame_idx %d "
6958 "rf_idx %d gf_frame_offset %d ref_gf_frame_offset %d\n",
6959 frame_idx, cm->mi_rows, cm->mi_cols, mi_width * MI_SIZE,
6960 ref_frame_idx, rf_idx, gf_frame_offset, ref_gf_frame_offset);
6961 for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row) {
6962 for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) {
6963 if ((mi_row % mi_height) == 0 && (mi_col % mi_width) == 0) {
6964 int_mv mv = vp9_motion_field_info_get_mv(&cpi->motion_field_info,
6965 frame_idx, rf_idx, bsize,
6967 printf("%d %d %d %d\n", mi_row, mi_col, mv.as_mv.row,
6972 for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row) {
6973 for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) {
6974 if ((mi_row % mi_height) == 0 && (mi_col % mi_width) == 0) {
6975 const TplDepStats *tpl_ptr =
6977 ->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
6978 printf("%f ", tpl_ptr->feature_score);
6984 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6985 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6988 ->mv_mode_arr[rf_idx][mi_row * tpl_frame->stride + mi_col];
6989 printf("%d ", mv_mode);
6994 dump_frame_buf(gf_picture[frame_idx].frame);
6995 dump_frame_buf(ref_frame_buf);
7000 #endif // DUMP_TPL_STATS
7001 #endif // CONFIG_NON_GREEDY_MV
7003 static void init_tpl_buffer(VP9_COMP *cpi) {
7004 VP9_COMMON *cm = &cpi->common;
7007 const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
7008 const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
7009 #if CONFIG_NON_GREEDY_MV
7012 vpx_free(cpi->select_mv_arr);
7014 cm, cpi->select_mv_arr,
7015 vpx_calloc(mi_rows * mi_cols * 4, sizeof(*cpi->select_mv_arr)));
7018 // TODO(jingning): Reduce the actual memory use for tpl model build up.
7019 for (frame = 0; frame < MAX_ARF_GOP_SIZE; ++frame) {
7020 if (cpi->tpl_stats[frame].width >= mi_cols &&
7021 cpi->tpl_stats[frame].height >= mi_rows &&
7022 cpi->tpl_stats[frame].tpl_stats_ptr)
7025 #if CONFIG_NON_GREEDY_MV
7026 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
7027 vpx_free(cpi->tpl_stats[frame].mv_mode_arr[rf_idx]);
7029 cm, cpi->tpl_stats[frame].mv_mode_arr[rf_idx],
7030 vpx_calloc(mi_rows * mi_cols * 4,
7031 sizeof(*cpi->tpl_stats[frame].mv_mode_arr[rf_idx])));
7032 vpx_free(cpi->tpl_stats[frame].rd_diff_arr[rf_idx]);
7034 cm, cpi->tpl_stats[frame].rd_diff_arr[rf_idx],
7035 vpx_calloc(mi_rows * mi_cols * 4,
7036 sizeof(*cpi->tpl_stats[frame].rd_diff_arr[rf_idx])));
7039 vpx_free(cpi->tpl_stats[frame].tpl_stats_ptr);
7040 CHECK_MEM_ERROR(cm, cpi->tpl_stats[frame].tpl_stats_ptr,
7041 vpx_calloc(mi_rows * mi_cols,
7042 sizeof(*cpi->tpl_stats[frame].tpl_stats_ptr)));
7043 cpi->tpl_stats[frame].is_valid = 0;
7044 cpi->tpl_stats[frame].width = mi_cols;
7045 cpi->tpl_stats[frame].height = mi_rows;
7046 cpi->tpl_stats[frame].stride = mi_cols;
7047 cpi->tpl_stats[frame].mi_rows = cm->mi_rows;
7048 cpi->tpl_stats[frame].mi_cols = cm->mi_cols;
7051 for (frame = 0; frame < REF_FRAMES; ++frame) {
7052 cpi->enc_frame_buf[frame].mem_valid = 0;
7053 cpi->enc_frame_buf[frame].released = 1;
7057 static void free_tpl_buffer(VP9_COMP *cpi) {
7059 #if CONFIG_NON_GREEDY_MV
7060 vp9_free_motion_field_info(&cpi->motion_field_info);
7061 vpx_free(cpi->select_mv_arr);
7063 for (frame = 0; frame < MAX_ARF_GOP_SIZE; ++frame) {
7064 #if CONFIG_NON_GREEDY_MV
7066 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
7067 vpx_free(cpi->tpl_stats[frame].mv_mode_arr[rf_idx]);
7068 vpx_free(cpi->tpl_stats[frame].rd_diff_arr[rf_idx]);
7071 vpx_free(cpi->tpl_stats[frame].tpl_stats_ptr);
7072 cpi->tpl_stats[frame].is_valid = 0;
7076 static void setup_tpl_stats(VP9_COMP *cpi) {
7077 GF_PICTURE gf_picture[MAX_ARF_GOP_SIZE];
7078 const GF_GROUP *gf_group = &cpi->twopass.gf_group;
7079 int tpl_group_frames = 0;
7081 cpi->tpl_bsize = BLOCK_32X32;
7083 init_gop_frames(cpi, gf_picture, gf_group, &tpl_group_frames);
7085 init_tpl_stats(cpi);
7087 // Backward propagation from tpl_group_frames to 1.
7088 for (frame_idx = tpl_group_frames - 1; frame_idx > 0; --frame_idx) {
7089 if (gf_picture[frame_idx].update_type == USE_BUF_FRAME) continue;
7090 mc_flow_dispenser(cpi, gf_picture, frame_idx, cpi->tpl_bsize);
7092 #if CONFIG_NON_GREEDY_MV
7095 dump_tpl_stats(cpi, tpl_group_frames, gf_group, gf_picture, cpi->tpl_bsize);
7096 #endif // DUMP_TPL_STATS
7097 #endif // CONFIG_NON_GREEDY_MV
7100 static void init_encode_frame_result(ENCODE_FRAME_RESULT *encode_frame_result) {
7101 encode_frame_result->show_idx = -1; // Actual encoding deosn't happen.
7104 #if !CONFIG_REALTIME_ONLY
7105 static void update_encode_frame_result(ENCODE_FRAME_RESULT *encode_frame_result,
7107 FRAME_UPDATE_TYPE update_type,
7108 const YV12_BUFFER_CONFIG *source_frame,
7109 const YV12_BUFFER_CONFIG *coded_frame,
7110 int quantize_index, uint32_t bit_depth,
7111 uint32_t input_bit_depth) {
7113 #if CONFIG_VP9_HIGHBITDEPTH
7114 vpx_calc_highbd_psnr(source_frame, coded_frame, &psnr, bit_depth,
7118 (void)input_bit_depth;
7119 vpx_calc_psnr(source_frame, coded_frame, &psnr);
7121 encode_frame_result->psnr = psnr.psnr[0];
7122 encode_frame_result->sse = psnr.sse[0];
7123 encode_frame_result->show_idx = show_idx;
7124 encode_frame_result->update_type = update_type;
7125 encode_frame_result->quantize_index = quantize_index;
7127 #endif // !CONFIG_REALTIME_ONLY
7129 int vp9_get_compressed_data(VP9_COMP *cpi, unsigned int *frame_flags,
7130 size_t *size, uint8_t *dest, int64_t *time_stamp,
7131 int64_t *time_end, int flush,
7132 ENCODE_FRAME_RESULT *encode_frame_result) {
7133 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
7134 VP9_COMMON *const cm = &cpi->common;
7135 BufferPool *const pool = cm->buffer_pool;
7136 RATE_CONTROL *const rc = &cpi->rc;
7137 struct vpx_usec_timer cmptimer;
7138 YV12_BUFFER_CONFIG *force_src_buffer = NULL;
7139 struct lookahead_entry *last_source = NULL;
7140 struct lookahead_entry *source = NULL;
7142 const int gf_group_index = cpi->twopass.gf_group.index;
7144 init_encode_frame_result(encode_frame_result);
7146 if (is_one_pass_cbr_svc(cpi)) {
7147 vp9_one_pass_cbr_svc_start_layer(cpi);
7150 vpx_usec_timer_start(&cmptimer);
7152 vp9_set_high_precision_mv(cpi, ALTREF_HIGH_PRECISION_MV);
7154 // Is multi-arf enabled.
7155 // Note that at the moment multi_arf is only configured for 2 pass VBR and
7156 // will not work properly with svc.
7157 // Enable the Jingning's new "multi_layer_arf" code if "enable_auto_arf"
7158 // is greater than or equal to 2.
7159 if ((oxcf->pass == 2) && !cpi->use_svc && (cpi->oxcf.enable_auto_arf >= 2))
7160 cpi->multi_layer_arf = 1;
7162 cpi->multi_layer_arf = 0;
7165 cm->reset_frame_context = 0;
7166 cm->refresh_frame_context = 1;
7167 if (!is_one_pass_cbr_svc(cpi)) {
7168 cpi->refresh_last_frame = 1;
7169 cpi->refresh_golden_frame = 0;
7170 cpi->refresh_alt_ref_frame = 0;
7173 // Should we encode an arf frame.
7174 arf_src_index = get_arf_src_index(cpi);
7176 if (arf_src_index) {
7177 for (i = 0; i <= arf_src_index; ++i) {
7178 struct lookahead_entry *e = vp9_lookahead_peek(cpi->lookahead, i);
7179 // Avoid creating an alt-ref if there's a forced keyframe pending.
7182 } else if (e->flags == VPX_EFLAG_FORCE_KF) {
7190 // Clear arf index stack before group of pictures processing starts.
7191 if (gf_group_index == 1) {
7192 stack_init(cpi->twopass.gf_group.arf_index_stack, MAX_LAG_BUFFERS * 2);
7193 cpi->twopass.gf_group.stack_size = 0;
7196 if (arf_src_index) {
7197 assert(arf_src_index <= rc->frames_to_key);
7198 if ((source = vp9_lookahead_peek(cpi->lookahead, arf_src_index)) != NULL) {
7199 cpi->alt_ref_source = source;
7201 #if !CONFIG_REALTIME_ONLY
7202 if ((oxcf->mode != REALTIME) && (oxcf->arnr_max_frames > 0) &&
7203 (oxcf->arnr_strength > 0)) {
7204 int bitrate = cpi->rc.avg_frame_bandwidth / 40;
7205 int not_low_bitrate = bitrate > ALT_REF_AQ_LOW_BITRATE_BOUNDARY;
7207 int not_last_frame = (cpi->lookahead->sz - arf_src_index > 1);
7208 not_last_frame |= ALT_REF_AQ_APPLY_TO_LAST_FRAME;
7210 // Produce the filtered ARF frame.
7211 vp9_temporal_filter(cpi, arf_src_index);
7212 vpx_extend_frame_borders(&cpi->alt_ref_buffer);
7214 // for small bitrates segmentation overhead usually
7215 // eats all bitrate gain from enabling delta quantizers
7216 if (cpi->oxcf.alt_ref_aq != 0 && not_low_bitrate && not_last_frame)
7217 vp9_alt_ref_aq_setup_mode(cpi->alt_ref_aq, cpi);
7219 force_src_buffer = &cpi->alt_ref_buffer;
7224 cpi->refresh_alt_ref_frame = 1;
7225 cpi->refresh_golden_frame = 0;
7226 cpi->refresh_last_frame = 0;
7227 rc->is_src_frame_alt_ref = 0;
7228 rc->source_alt_ref_pending = 0;
7230 rc->source_alt_ref_pending = 0;
7235 // Get last frame source.
7236 if (cm->current_video_frame > 0) {
7237 if ((last_source = vp9_lookahead_peek(cpi->lookahead, -1)) == NULL)
7241 // Read in the source frame.
7242 if (cpi->use_svc || cpi->svc.set_intra_only_frame)
7243 source = vp9_svc_lookahead_pop(cpi, cpi->lookahead, flush);
7245 source = vp9_lookahead_pop(cpi->lookahead, flush);
7247 if (source != NULL) {
7250 // If the flags indicate intra frame, but if the current picture is for
7251 // spatial layer above first_spatial_layer_to_encode, it should not be an
7253 if ((source->flags & VPX_EFLAG_FORCE_KF) && cpi->use_svc &&
7254 cpi->svc.spatial_layer_id > cpi->svc.first_spatial_layer_to_encode) {
7255 source->flags &= ~(unsigned int)(VPX_EFLAG_FORCE_KF);
7258 // Check to see if the frame should be encoded as an arf overlay.
7259 check_src_altref(cpi, source);
7264 cpi->un_scaled_source = cpi->Source =
7265 force_src_buffer ? force_src_buffer : &source->img;
7267 #ifdef ENABLE_KF_DENOISE
7268 // Copy of raw source for metrics calculation.
7269 if (is_psnr_calc_enabled(cpi))
7270 vp9_copy_and_extend_frame(cpi->Source, &cpi->raw_unscaled_source);
7273 cpi->unscaled_last_source = last_source != NULL ? &last_source->img : NULL;
7275 *time_stamp = source->ts_start;
7276 *time_end = source->ts_end;
7277 *frame_flags = (source->flags & VPX_EFLAG_FORCE_KF) ? FRAMEFLAGS_KEY : 0;
7283 if (source->ts_start < cpi->first_time_stamp_ever) {
7284 cpi->first_time_stamp_ever = source->ts_start;
7285 cpi->last_end_time_stamp_seen = source->ts_start;
7288 // Clear down mmx registers
7289 vpx_clear_system_state();
7291 // adjust frame rates based on timestamps given
7292 if (cm->show_frame) {
7293 if (cpi->use_svc && cpi->svc.use_set_ref_frame_config &&
7294 cpi->svc.duration[cpi->svc.spatial_layer_id] > 0)
7295 vp9_svc_adjust_frame_rate(cpi);
7297 adjust_frame_rate(cpi, source);
7300 if (is_one_pass_cbr_svc(cpi)) {
7301 vp9_update_temporal_layer_framerate(cpi);
7302 vp9_restore_layer_context(cpi);
7305 // Find a free buffer for the new frame, releasing the reference previously
7307 if (cm->new_fb_idx != INVALID_IDX) {
7308 --pool->frame_bufs[cm->new_fb_idx].ref_count;
7310 cm->new_fb_idx = get_free_fb(cm);
7312 if (cm->new_fb_idx == INVALID_IDX) return -1;
7314 cm->cur_frame = &pool->frame_bufs[cm->new_fb_idx];
7316 // Start with a 0 size frame.
7319 cpi->frame_flags = *frame_flags;
7321 #if !CONFIG_REALTIME_ONLY
7322 if ((oxcf->pass == 2) && !cpi->use_svc) {
7323 vp9_rc_get_second_pass_params(cpi);
7324 } else if (oxcf->pass == 1) {
7325 set_frame_size(cpi);
7327 #endif // !CONFIG_REALTIME_ONLY
7329 if (oxcf->pass != 1 && cpi->level_constraint.level_index >= 0 &&
7330 cpi->level_constraint.fail_flag == 0)
7331 level_rc_framerate(cpi, arf_src_index);
7333 if (cpi->oxcf.pass != 0 || cpi->use_svc || frame_is_intra_only(cm) == 1) {
7334 for (i = 0; i < REFS_PER_FRAME; ++i) cpi->scaled_ref_idx[i] = INVALID_IDX;
7337 if (cpi->kmeans_data_arr_alloc == 0) {
7338 const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
7339 const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
7340 #if CONFIG_MULTITHREAD
7341 pthread_mutex_init(&cpi->kmeans_mutex, NULL);
7344 cm, cpi->kmeans_data_arr,
7345 vpx_calloc(mi_rows * mi_cols, sizeof(*cpi->kmeans_data_arr)));
7346 cpi->kmeans_data_stride = mi_cols;
7347 cpi->kmeans_data_arr_alloc = 1;
7350 #if CONFIG_NON_GREEDY_MV
7352 const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
7353 const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
7354 Status status = vp9_alloc_motion_field_info(
7355 &cpi->motion_field_info, MAX_ARF_GOP_SIZE, mi_rows, mi_cols);
7356 if (status == STATUS_FAILED) {
7357 vpx_internal_error(&(cm)->error, VPX_CODEC_MEM_ERROR,
7358 "vp9_alloc_motion_field_info failed");
7361 #endif // CONFIG_NON_GREEDY_MV
7363 if (gf_group_index == 1 &&
7364 cpi->twopass.gf_group.update_type[gf_group_index] == ARF_UPDATE &&
7365 cpi->sf.enable_tpl_model) {
7366 init_tpl_buffer(cpi);
7367 vp9_estimate_qp_gop(cpi);
7368 setup_tpl_stats(cpi);
7371 #if CONFIG_BITSTREAM_DEBUG
7372 assert(cpi->oxcf.max_threads == 0 &&
7373 "bitstream debug tool does not support multithreading");
7374 bitstream_queue_record_write();
7376 #if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
7377 bitstream_queue_set_frame_write(cm->current_video_frame * 2 + cm->show_frame);
7380 cpi->td.mb.fp_src_pred = 0;
7381 #if CONFIG_REALTIME_ONLY
7383 SvcEncode(cpi, size, dest, frame_flags);
7386 Pass0Encode(cpi, size, dest, frame_flags);
7388 #else // !CONFIG_REALTIME_ONLY
7389 if (oxcf->pass == 1 && !cpi->use_svc) {
7390 const int lossless = is_lossless_requested(oxcf);
7391 #if CONFIG_VP9_HIGHBITDEPTH
7392 if (cpi->oxcf.use_highbitdepth)
7393 cpi->td.mb.fwd_txfm4x4 =
7394 lossless ? vp9_highbd_fwht4x4 : vpx_highbd_fdct4x4;
7396 cpi->td.mb.fwd_txfm4x4 = lossless ? vp9_fwht4x4 : vpx_fdct4x4;
7397 cpi->td.mb.highbd_inv_txfm_add =
7398 lossless ? vp9_highbd_iwht4x4_add : vp9_highbd_idct4x4_add;
7400 cpi->td.mb.fwd_txfm4x4 = lossless ? vp9_fwht4x4 : vpx_fdct4x4;
7401 #endif // CONFIG_VP9_HIGHBITDEPTH
7402 cpi->td.mb.inv_txfm_add = lossless ? vp9_iwht4x4_add : vp9_idct4x4_add;
7403 vp9_first_pass(cpi, source);
7404 } else if (oxcf->pass == 2 && !cpi->use_svc) {
7405 Pass2Encode(cpi, size, dest, frame_flags);
7406 // update_encode_frame_result() depends on twopass.gf_group.index and
7407 // cm->new_fb_idx and cpi->Source are updated for current properly and have
7408 // not been updated for the next frame yet.
7409 // The update locations are as follows.
7410 // 1) twopass.gf_group.index is initialized at define_gf_group by vp9_zero()
7411 // for the first frame in the gf_group and is updated for the next frame at
7412 // vp9_twopass_postencode_update().
7413 // 2) cpi->Source is updated at the beginging of this function, i.e.
7414 // vp9_get_compressed_data()
7415 // 3) cm->new_fb_idx is updated at the beginging of this function by
7417 // TODO(angiebird): Improve the codebase to make the update of frame
7418 // dependent variables more robust.
7419 update_encode_frame_result(
7420 encode_frame_result, source->show_idx,
7421 cpi->twopass.gf_group.update_type[cpi->twopass.gf_group.index],
7422 cpi->Source, get_frame_new_buffer(cm), vp9_get_quantizer(cpi),
7423 cpi->oxcf.input_bit_depth, cm->bit_depth);
7424 vp9_twopass_postencode_update(cpi);
7425 } else if (cpi->use_svc) {
7426 SvcEncode(cpi, size, dest, frame_flags);
7429 Pass0Encode(cpi, size, dest, frame_flags);
7431 #endif // CONFIG_REALTIME_ONLY
7433 if (cm->show_frame) cm->cur_show_frame_fb_idx = cm->new_fb_idx;
7435 if (cm->refresh_frame_context)
7436 cm->frame_contexts[cm->frame_context_idx] = *cm->fc;
7438 // No frame encoded, or frame was dropped, release scaled references.
7439 if ((*size == 0) && (frame_is_intra_only(cm) == 0)) {
7440 release_scaled_references(cpi);
7444 cpi->droppable = !frame_is_reference(cpi);
7447 // Save layer specific state.
7448 if (is_one_pass_cbr_svc(cpi) || ((cpi->svc.number_temporal_layers > 1 ||
7449 cpi->svc.number_spatial_layers > 1) &&
7451 vp9_save_layer_context(cpi);
7454 vpx_usec_timer_mark(&cmptimer);
7455 cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
7457 if (cpi->keep_level_stats && oxcf->pass != 1)
7458 update_level_info(cpi, size, arf_src_index);
7460 #if CONFIG_INTERNAL_STATS
7462 if (oxcf->pass != 1) {
7463 double samples = 0.0;
7464 cpi->bytes += (int)(*size);
7466 if (cm->show_frame) {
7467 uint32_t bit_depth = 8;
7468 uint32_t in_bit_depth = 8;
7470 #if CONFIG_VP9_HIGHBITDEPTH
7471 if (cm->use_highbitdepth) {
7472 in_bit_depth = cpi->oxcf.input_bit_depth;
7473 bit_depth = cm->bit_depth;
7477 if (cpi->b_calculate_psnr) {
7478 YV12_BUFFER_CONFIG *orig = cpi->raw_source_frame;
7479 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
7480 YV12_BUFFER_CONFIG *pp = &cm->post_proc_buffer;
7482 #if CONFIG_VP9_HIGHBITDEPTH
7483 vpx_calc_highbd_psnr(orig, recon, &psnr, cpi->td.mb.e_mbd.bd,
7486 vpx_calc_psnr(orig, recon, &psnr);
7487 #endif // CONFIG_VP9_HIGHBITDEPTH
7489 adjust_image_stat(psnr.psnr[1], psnr.psnr[2], psnr.psnr[3],
7490 psnr.psnr[0], &cpi->psnr);
7491 cpi->total_sq_error += psnr.sse[0];
7492 cpi->total_samples += psnr.samples[0];
7493 samples = psnr.samples[0];
7497 double frame_ssim2 = 0, weight = 0;
7498 #if CONFIG_VP9_POSTPROC
7499 if (vpx_alloc_frame_buffer(
7500 pp, recon->y_crop_width, recon->y_crop_height,
7501 cm->subsampling_x, cm->subsampling_y,
7502 #if CONFIG_VP9_HIGHBITDEPTH
7503 cm->use_highbitdepth,
7505 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment) < 0) {
7506 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
7507 "Failed to allocate post processing buffer");
7510 vp9_ppflags_t ppflags;
7511 ppflags.post_proc_flag = VP9D_DEBLOCK;
7512 ppflags.deblocking_level = 0; // not used in vp9_post_proc_frame()
7513 ppflags.noise_level = 0; // not used in vp9_post_proc_frame()
7514 vp9_post_proc_frame(cm, pp, &ppflags,
7515 cpi->un_scaled_source->y_width);
7518 vpx_clear_system_state();
7520 #if CONFIG_VP9_HIGHBITDEPTH
7521 vpx_calc_highbd_psnr(orig, pp, &psnr2, cpi->td.mb.e_mbd.bd,
7522 cpi->oxcf.input_bit_depth);
7524 vpx_calc_psnr(orig, pp, &psnr2);
7525 #endif // CONFIG_VP9_HIGHBITDEPTH
7527 cpi->totalp_sq_error += psnr2.sse[0];
7528 cpi->totalp_samples += psnr2.samples[0];
7529 adjust_image_stat(psnr2.psnr[1], psnr2.psnr[2], psnr2.psnr[3],
7530 psnr2.psnr[0], &cpi->psnrp);
7532 #if CONFIG_VP9_HIGHBITDEPTH
7533 if (cm->use_highbitdepth) {
7534 frame_ssim2 = vpx_highbd_calc_ssim(orig, recon, &weight, bit_depth,
7537 frame_ssim2 = vpx_calc_ssim(orig, recon, &weight);
7540 frame_ssim2 = vpx_calc_ssim(orig, recon, &weight);
7541 #endif // CONFIG_VP9_HIGHBITDEPTH
7543 cpi->worst_ssim = VPXMIN(cpi->worst_ssim, frame_ssim2);
7544 cpi->summed_quality += frame_ssim2 * weight;
7545 cpi->summed_weights += weight;
7547 #if CONFIG_VP9_HIGHBITDEPTH
7548 if (cm->use_highbitdepth) {
7549 frame_ssim2 = vpx_highbd_calc_ssim(orig, pp, &weight, bit_depth,
7552 frame_ssim2 = vpx_calc_ssim(orig, pp, &weight);
7555 frame_ssim2 = vpx_calc_ssim(orig, pp, &weight);
7556 #endif // CONFIG_VP9_HIGHBITDEPTH
7558 cpi->summedp_quality += frame_ssim2 * weight;
7559 cpi->summedp_weights += weight;
7561 if (cm->show_frame) {
7562 FILE *f = fopen("q_used.stt", "a");
7563 fprintf(f, "%5d : Y%f7.3:U%f7.3:V%f7.3:F%f7.3:S%7.3f\n",
7564 cpi->common.current_video_frame, psnr2.psnr[1],
7565 psnr2.psnr[2], psnr2.psnr[3], psnr2.psnr[0], frame_ssim2);
7571 if (cpi->b_calculate_blockiness) {
7572 #if CONFIG_VP9_HIGHBITDEPTH
7573 if (!cm->use_highbitdepth)
7576 double frame_blockiness = vp9_get_blockiness(
7577 cpi->Source->y_buffer, cpi->Source->y_stride,
7578 cm->frame_to_show->y_buffer, cm->frame_to_show->y_stride,
7579 cpi->Source->y_width, cpi->Source->y_height);
7580 cpi->worst_blockiness =
7581 VPXMAX(cpi->worst_blockiness, frame_blockiness);
7582 cpi->total_blockiness += frame_blockiness;
7586 if (cpi->b_calculate_consistency) {
7587 #if CONFIG_VP9_HIGHBITDEPTH
7588 if (!cm->use_highbitdepth)
7591 double this_inconsistency = vpx_get_ssim_metrics(
7592 cpi->Source->y_buffer, cpi->Source->y_stride,
7593 cm->frame_to_show->y_buffer, cm->frame_to_show->y_stride,
7594 cpi->Source->y_width, cpi->Source->y_height, cpi->ssim_vars,
7597 const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1);
7598 double consistency =
7599 vpx_sse_to_psnr(samples, peak, (double)cpi->total_inconsistency);
7600 if (consistency > 0.0)
7601 cpi->worst_consistency =
7602 VPXMIN(cpi->worst_consistency, consistency);
7603 cpi->total_inconsistency += this_inconsistency;
7608 double y, u, v, frame_all;
7609 frame_all = vpx_calc_fastssim(cpi->Source, cm->frame_to_show, &y, &u,
7610 &v, bit_depth, in_bit_depth);
7611 adjust_image_stat(y, u, v, frame_all, &cpi->fastssim);
7614 double y, u, v, frame_all;
7615 frame_all = vpx_psnrhvs(cpi->Source, cm->frame_to_show, &y, &u, &v,
7616 bit_depth, in_bit_depth);
7617 adjust_image_stat(y, u, v, frame_all, &cpi->psnrhvs);
7624 if (is_one_pass_cbr_svc(cpi)) {
7625 if (cm->show_frame) {
7626 ++cpi->svc.spatial_layer_to_encode;
7627 if (cpi->svc.spatial_layer_to_encode >= cpi->svc.number_spatial_layers)
7628 cpi->svc.spatial_layer_to_encode = 0;
7632 vpx_clear_system_state();
7636 int vp9_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest,
7637 vp9_ppflags_t *flags) {
7638 VP9_COMMON *cm = &cpi->common;
7639 #if !CONFIG_VP9_POSTPROC
7643 if (!cm->show_frame) {
7647 #if CONFIG_VP9_POSTPROC
7648 ret = vp9_post_proc_frame(cm, dest, flags, cpi->un_scaled_source->y_width);
7650 if (cm->frame_to_show) {
7651 *dest = *cm->frame_to_show;
7652 dest->y_width = cm->width;
7653 dest->y_height = cm->height;
7654 dest->uv_width = cm->width >> cm->subsampling_x;
7655 dest->uv_height = cm->height >> cm->subsampling_y;
7660 #endif // !CONFIG_VP9_POSTPROC
7661 vpx_clear_system_state();
7666 int vp9_set_internal_size(VP9_COMP *cpi, VPX_SCALING horiz_mode,
7667 VPX_SCALING vert_mode) {
7668 VP9_COMMON *cm = &cpi->common;
7669 int hr = 0, hs = 0, vr = 0, vs = 0;
7671 if (horiz_mode > ONETWO || vert_mode > ONETWO) return -1;
7673 Scale2Ratio(horiz_mode, &hr, &hs);
7674 Scale2Ratio(vert_mode, &vr, &vs);
7676 // always go to the next whole number
7677 cm->width = (hs - 1 + cpi->oxcf.width * hr) / hs;
7678 cm->height = (vs - 1 + cpi->oxcf.height * vr) / vs;
7679 if (cm->current_video_frame) {
7680 assert(cm->width <= cpi->initial_width);
7681 assert(cm->height <= cpi->initial_height);
7684 update_frame_size(cpi);
7689 int vp9_set_size_literal(VP9_COMP *cpi, unsigned int width,
7690 unsigned int height) {
7691 VP9_COMMON *cm = &cpi->common;
7692 #if CONFIG_VP9_HIGHBITDEPTH
7693 update_initial_width(cpi, cm->use_highbitdepth, 1, 1);
7695 update_initial_width(cpi, 0, 1, 1);
7696 #endif // CONFIG_VP9_HIGHBITDEPTH
7698 #if CONFIG_VP9_TEMPORAL_DENOISING
7699 setup_denoiser_buffer(cpi);
7701 alloc_raw_frame_buffers(cpi);
7704 if (cm->width > cpi->initial_width) {
7705 cm->width = cpi->initial_width;
7706 printf("Warning: Desired width too large, changed to %d\n", cm->width);
7711 cm->height = height;
7712 if (cm->height > cpi->initial_height) {
7713 cm->height = cpi->initial_height;
7714 printf("Warning: Desired height too large, changed to %d\n", cm->height);
7717 assert(cm->width <= cpi->initial_width);
7718 assert(cm->height <= cpi->initial_height);
7720 update_frame_size(cpi);
7725 void vp9_set_svc(VP9_COMP *cpi, int use_svc) {
7726 cpi->use_svc = use_svc;
7730 int vp9_get_quantizer(const VP9_COMP *cpi) { return cpi->common.base_qindex; }
7732 void vp9_apply_encoding_flags(VP9_COMP *cpi, vpx_enc_frame_flags_t flags) {
7734 (VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF)) {
7737 if (flags & VP8_EFLAG_NO_REF_LAST) ref ^= VP9_LAST_FLAG;
7739 if (flags & VP8_EFLAG_NO_REF_GF) ref ^= VP9_GOLD_FLAG;
7741 if (flags & VP8_EFLAG_NO_REF_ARF) ref ^= VP9_ALT_FLAG;
7743 vp9_use_as_reference(cpi, ref);
7747 (VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
7748 VP8_EFLAG_FORCE_GF | VP8_EFLAG_FORCE_ARF)) {
7751 if (flags & VP8_EFLAG_NO_UPD_LAST) upd ^= VP9_LAST_FLAG;
7753 if (flags & VP8_EFLAG_NO_UPD_GF) upd ^= VP9_GOLD_FLAG;
7755 if (flags & VP8_EFLAG_NO_UPD_ARF) upd ^= VP9_ALT_FLAG;
7757 vp9_update_reference(cpi, upd);
7760 if (flags & VP8_EFLAG_NO_UPD_ENTROPY) {
7761 vp9_update_entropy(cpi, 0);
7765 void vp9_set_row_mt(VP9_COMP *cpi) {
7766 // Enable row based multi-threading for supported modes of encoding
7768 if (((cpi->oxcf.mode == GOOD || cpi->oxcf.mode == BEST) &&
7769 cpi->oxcf.speed < 5 && cpi->oxcf.pass == 1) &&
7770 cpi->oxcf.row_mt && !cpi->use_svc)
7773 if (cpi->oxcf.mode == GOOD && cpi->oxcf.speed < 5 &&
7774 (cpi->oxcf.pass == 0 || cpi->oxcf.pass == 2) && cpi->oxcf.row_mt &&
7778 // In realtime mode, enable row based multi-threading for all the speed levels
7779 // where non-rd path is used.
7780 if (cpi->oxcf.mode == REALTIME && cpi->oxcf.speed >= 5 && cpi->oxcf.row_mt) {
7785 cpi->row_mt_bit_exact = 1;
7787 cpi->row_mt_bit_exact = 0;