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 init_motion_estimation(VP9_COMP *cpi);
2176 static void update_initial_width(VP9_COMP *cpi, int use_highbitdepth,
2177 int subsampling_x, int subsampling_y) {
2178 VP9_COMMON *const cm = &cpi->common;
2179 #if !CONFIG_VP9_HIGHBITDEPTH
2180 (void)use_highbitdepth;
2181 assert(use_highbitdepth == 0);
2184 if (!cpi->initial_width ||
2185 #if CONFIG_VP9_HIGHBITDEPTH
2186 cm->use_highbitdepth != use_highbitdepth ||
2188 cm->subsampling_x != subsampling_x ||
2189 cm->subsampling_y != subsampling_y) {
2190 cm->subsampling_x = subsampling_x;
2191 cm->subsampling_y = subsampling_y;
2192 #if CONFIG_VP9_HIGHBITDEPTH
2193 cm->use_highbitdepth = use_highbitdepth;
2195 alloc_util_frame_buffers(cpi);
2196 init_motion_estimation(cpi);
2197 cpi->initial_width = cm->width;
2198 cpi->initial_height = cm->height;
2199 cpi->initial_mbs = cm->MBs;
2203 // TODO(angiebird): Check whether we can move this function to vpx_image.c
2204 static INLINE void vpx_img_chroma_subsampling(vpx_img_fmt_t fmt,
2205 unsigned int *subsampling_x,
2206 unsigned int *subsampling_y) {
2208 case VPX_IMG_FMT_I420:
2209 case VPX_IMG_FMT_YV12:
2210 case VPX_IMG_FMT_I422:
2211 case VPX_IMG_FMT_I42016:
2212 case VPX_IMG_FMT_I42216: *subsampling_x = 1; break;
2213 default: *subsampling_x = 0; break;
2217 case VPX_IMG_FMT_I420:
2218 case VPX_IMG_FMT_I440:
2219 case VPX_IMG_FMT_YV12:
2220 case VPX_IMG_FMT_I42016:
2221 case VPX_IMG_FMT_I44016: *subsampling_y = 1; break;
2222 default: *subsampling_y = 0; break;
2226 // TODO(angiebird): Check whether we can move this function to vpx_image.c
2227 static INLINE int vpx_img_use_highbitdepth(vpx_img_fmt_t fmt) {
2228 return fmt & VPX_IMG_FMT_HIGHBITDEPTH;
2231 #if CONFIG_VP9_TEMPORAL_DENOISING
2232 static void setup_denoiser_buffer(VP9_COMP *cpi) {
2233 VP9_COMMON *const cm = &cpi->common;
2234 if (cpi->oxcf.noise_sensitivity > 0 &&
2235 !cpi->denoiser.frame_buffer_initialized) {
2236 if (vp9_denoiser_alloc(cm, &cpi->svc, &cpi->denoiser, cpi->use_svc,
2237 cpi->oxcf.noise_sensitivity, cm->width, cm->height,
2238 cm->subsampling_x, cm->subsampling_y,
2239 #if CONFIG_VP9_HIGHBITDEPTH
2240 cm->use_highbitdepth,
2242 VP9_ENC_BORDER_IN_PIXELS))
2243 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
2244 "Failed to allocate denoiser");
2249 void vp9_update_compressor_with_img_fmt(VP9_COMP *cpi, vpx_img_fmt_t img_fmt) {
2250 const VP9EncoderConfig *oxcf = &cpi->oxcf;
2251 unsigned int subsampling_x, subsampling_y;
2252 const int use_highbitdepth = vpx_img_use_highbitdepth(img_fmt);
2253 vpx_img_chroma_subsampling(img_fmt, &subsampling_x, &subsampling_y);
2255 update_initial_width(cpi, use_highbitdepth, subsampling_x, subsampling_y);
2256 #if CONFIG_VP9_TEMPORAL_DENOISING
2257 setup_denoiser_buffer(cpi);
2260 assert(cpi->lookahead == NULL);
2261 cpi->lookahead = vp9_lookahead_init(oxcf->width, oxcf->height, subsampling_x,
2263 #if CONFIG_VP9_HIGHBITDEPTH
2266 oxcf->lag_in_frames);
2267 alloc_raw_frame_buffers(cpi);
2270 VP9_COMP *vp9_create_compressor(const VP9EncoderConfig *oxcf,
2271 BufferPool *const pool) {
2273 VP9_COMP *volatile const cpi = vpx_memalign(32, sizeof(VP9_COMP));
2274 VP9_COMMON *volatile const cm = cpi != NULL ? &cpi->common : NULL;
2276 if (!cm) return NULL;
2280 if (setjmp(cm->error.jmp)) {
2281 cm->error.setjmp = 0;
2282 vp9_remove_compressor(cpi);
2286 cm->error.setjmp = 1;
2287 cm->alloc_mi = vp9_enc_alloc_mi;
2288 cm->free_mi = vp9_enc_free_mi;
2289 cm->setup_mi = vp9_enc_setup_mi;
2291 CHECK_MEM_ERROR(cm, cm->fc, (FRAME_CONTEXT *)vpx_calloc(1, sizeof(*cm->fc)));
2293 cm, cm->frame_contexts,
2294 (FRAME_CONTEXT *)vpx_calloc(FRAME_CONTEXTS, sizeof(*cm->frame_contexts)));
2297 cpi->resize_state = ORIG;
2298 cpi->external_resize = 0;
2299 cpi->resize_avg_qp = 0;
2300 cpi->resize_buffer_underflow = 0;
2301 cpi->use_skin_detection = 0;
2302 cpi->common.buffer_pool = pool;
2303 init_ref_frame_bufs(cm);
2305 cpi->force_update_segmentation = 0;
2307 init_config(cpi, oxcf);
2308 cpi->frame_info = vp9_get_frame_info(oxcf);
2310 vp9_rc_init(&cpi->oxcf, oxcf->pass, &cpi->rc);
2312 cm->current_video_frame = 0;
2313 cpi->partition_search_skippable_frame = 0;
2314 cpi->tile_data = NULL;
2316 realloc_segmentation_maps(cpi);
2320 vpx_calloc(cm->mi_rows * cm->mi_cols, sizeof(cpi->skin_map[0])));
2322 #if !CONFIG_REALTIME_ONLY
2323 CHECK_MEM_ERROR(cm, cpi->alt_ref_aq, vp9_alt_ref_aq_create());
2327 cm, cpi->consec_zero_mv,
2328 vpx_calloc(cm->mi_rows * cm->mi_cols, sizeof(*cpi->consec_zero_mv)));
2330 CHECK_MEM_ERROR(cm, cpi->nmvcosts[0],
2331 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts[0])));
2332 CHECK_MEM_ERROR(cm, cpi->nmvcosts[1],
2333 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts[1])));
2334 CHECK_MEM_ERROR(cm, cpi->nmvcosts_hp[0],
2335 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts_hp[0])));
2336 CHECK_MEM_ERROR(cm, cpi->nmvcosts_hp[1],
2337 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts_hp[1])));
2338 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts[0],
2339 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts[0])));
2340 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts[1],
2341 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts[1])));
2342 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts_hp[0],
2343 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts_hp[0])));
2344 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts_hp[1],
2345 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts_hp[1])));
2347 for (i = 0; i < (sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]));
2350 cm, cpi->mbgraph_stats[i].mb_stats,
2351 vpx_calloc(cm->MBs * sizeof(*cpi->mbgraph_stats[i].mb_stats), 1));
2354 #if CONFIG_FP_MB_STATS
2355 cpi->use_fp_mb_stats = 0;
2356 if (cpi->use_fp_mb_stats) {
2357 // a place holder used to store the first pass mb stats in the first pass
2358 CHECK_MEM_ERROR(cm, cpi->twopass.frame_mb_stats_buf,
2359 vpx_calloc(cm->MBs * sizeof(uint8_t), 1));
2361 cpi->twopass.frame_mb_stats_buf = NULL;
2365 cpi->refresh_alt_ref_frame = 0;
2366 cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS;
2368 init_level_info(&cpi->level_info);
2369 init_level_constraint(&cpi->level_constraint);
2371 #if CONFIG_INTERNAL_STATS
2372 cpi->b_calculate_blockiness = 1;
2373 cpi->b_calculate_consistency = 1;
2374 cpi->total_inconsistency = 0;
2375 cpi->psnr.worst = 100.0;
2376 cpi->worst_ssim = 100.0;
2381 if (cpi->b_calculate_psnr) {
2382 cpi->total_sq_error = 0;
2383 cpi->total_samples = 0;
2385 cpi->totalp_sq_error = 0;
2386 cpi->totalp_samples = 0;
2388 cpi->tot_recode_hits = 0;
2389 cpi->summed_quality = 0;
2390 cpi->summed_weights = 0;
2391 cpi->summedp_quality = 0;
2392 cpi->summedp_weights = 0;
2395 cpi->fastssim.worst = 100.0;
2397 cpi->psnrhvs.worst = 100.0;
2399 if (cpi->b_calculate_blockiness) {
2400 cpi->total_blockiness = 0;
2401 cpi->worst_blockiness = 0.0;
2404 if (cpi->b_calculate_consistency) {
2405 CHECK_MEM_ERROR(cm, cpi->ssim_vars,
2406 vpx_calloc(cpi->common.mi_rows * cpi->common.mi_cols,
2407 sizeof(*cpi->ssim_vars) * 4));
2408 cpi->worst_consistency = 100.0;
2410 cpi->ssim_vars = NULL;
2415 cpi->first_time_stamp_ever = INT64_MAX;
2417 /*********************************************************************
2418 * Warning: Read the comments around 'cal_nmvjointsadcost' and *
2419 * 'cal_nmvsadcosts' before modifying how these tables are computed. *
2420 *********************************************************************/
2421 cal_nmvjointsadcost(cpi->td.mb.nmvjointsadcost);
2422 cpi->td.mb.nmvcost[0] = &cpi->nmvcosts[0][MV_MAX];
2423 cpi->td.mb.nmvcost[1] = &cpi->nmvcosts[1][MV_MAX];
2424 cpi->td.mb.nmvsadcost[0] = &cpi->nmvsadcosts[0][MV_MAX];
2425 cpi->td.mb.nmvsadcost[1] = &cpi->nmvsadcosts[1][MV_MAX];
2426 cal_nmvsadcosts(cpi->td.mb.nmvsadcost);
2428 cpi->td.mb.nmvcost_hp[0] = &cpi->nmvcosts_hp[0][MV_MAX];
2429 cpi->td.mb.nmvcost_hp[1] = &cpi->nmvcosts_hp[1][MV_MAX];
2430 cpi->td.mb.nmvsadcost_hp[0] = &cpi->nmvsadcosts_hp[0][MV_MAX];
2431 cpi->td.mb.nmvsadcost_hp[1] = &cpi->nmvsadcosts_hp[1][MV_MAX];
2432 cal_nmvsadcosts_hp(cpi->td.mb.nmvsadcost_hp);
2434 #if CONFIG_VP9_TEMPORAL_DENOISING
2435 #ifdef OUTPUT_YUV_DENOISED
2436 yuv_denoised_file = fopen("denoised.yuv", "ab");
2439 #ifdef OUTPUT_YUV_SKINMAP
2440 yuv_skinmap_file = fopen("skinmap.yuv", "wb");
2442 #ifdef OUTPUT_YUV_REC
2443 yuv_rec_file = fopen("rec.yuv", "wb");
2445 #ifdef OUTPUT_YUV_SVC_SRC
2446 yuv_svc_src[0] = fopen("svc_src_0.yuv", "wb");
2447 yuv_svc_src[1] = fopen("svc_src_1.yuv", "wb");
2448 yuv_svc_src[2] = fopen("svc_src_2.yuv", "wb");
2452 framepsnr = fopen("framepsnr.stt", "a");
2453 kf_list = fopen("kf_list.stt", "w");
2456 cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED;
2458 #if !CONFIG_REALTIME_ONLY
2459 if (oxcf->pass == 1) {
2460 vp9_init_first_pass(cpi);
2461 } else if (oxcf->pass == 2) {
2462 const size_t packet_sz = sizeof(FIRSTPASS_STATS);
2463 const int packets = (int)(oxcf->two_pass_stats_in.sz / packet_sz);
2465 if (cpi->svc.number_spatial_layers > 1 ||
2466 cpi->svc.number_temporal_layers > 1) {
2467 FIRSTPASS_STATS *const stats = oxcf->two_pass_stats_in.buf;
2468 FIRSTPASS_STATS *stats_copy[VPX_SS_MAX_LAYERS] = { 0 };
2471 for (i = 0; i < oxcf->ss_number_layers; ++i) {
2472 FIRSTPASS_STATS *const last_packet_for_layer =
2473 &stats[packets - oxcf->ss_number_layers + i];
2474 const int layer_id = (int)last_packet_for_layer->spatial_layer_id;
2475 const int packets_in_layer = (int)last_packet_for_layer->count + 1;
2476 if (layer_id >= 0 && layer_id < oxcf->ss_number_layers) {
2478 LAYER_CONTEXT *const lc = &cpi->svc.layer_context[layer_id];
2480 vpx_free(lc->rc_twopass_stats_in.buf);
2482 lc->rc_twopass_stats_in.sz = packets_in_layer * packet_sz;
2483 CHECK_MEM_ERROR(cm, lc->rc_twopass_stats_in.buf,
2484 vpx_malloc(lc->rc_twopass_stats_in.sz));
2485 lc->twopass.stats_in_start = lc->rc_twopass_stats_in.buf;
2486 lc->twopass.stats_in = lc->twopass.stats_in_start;
2487 lc->twopass.stats_in_end =
2488 lc->twopass.stats_in_start + packets_in_layer - 1;
2489 // Note the last packet is cumulative first pass stats.
2490 // So the number of frames is packet number minus one
2491 num_frames = packets_in_layer - 1;
2492 fps_init_first_pass_info(&lc->twopass.first_pass_info,
2493 lc->rc_twopass_stats_in.buf, num_frames);
2494 stats_copy[layer_id] = lc->rc_twopass_stats_in.buf;
2498 for (i = 0; i < packets; ++i) {
2499 const int layer_id = (int)stats[i].spatial_layer_id;
2500 if (layer_id >= 0 && layer_id < oxcf->ss_number_layers &&
2501 stats_copy[layer_id] != NULL) {
2502 *stats_copy[layer_id] = stats[i];
2503 ++stats_copy[layer_id];
2507 vp9_init_second_pass_spatial_svc(cpi);
2510 #if CONFIG_FP_MB_STATS
2511 if (cpi->use_fp_mb_stats) {
2512 const size_t psz = cpi->common.MBs * sizeof(uint8_t);
2513 const int ps = (int)(oxcf->firstpass_mb_stats_in.sz / psz);
2515 cpi->twopass.firstpass_mb_stats.mb_stats_start =
2516 oxcf->firstpass_mb_stats_in.buf;
2517 cpi->twopass.firstpass_mb_stats.mb_stats_end =
2518 cpi->twopass.firstpass_mb_stats.mb_stats_start +
2519 (ps - 1) * cpi->common.MBs * sizeof(uint8_t);
2523 cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf;
2524 cpi->twopass.stats_in = cpi->twopass.stats_in_start;
2525 cpi->twopass.stats_in_end = &cpi->twopass.stats_in[packets - 1];
2526 // Note the last packet is cumulative first pass stats.
2527 // So the number of frames is packet number minus one
2528 num_frames = packets - 1;
2529 fps_init_first_pass_info(&cpi->twopass.first_pass_info,
2530 oxcf->two_pass_stats_in.buf, num_frames);
2532 vp9_init_second_pass(cpi);
2535 #endif // !CONFIG_REALTIME_ONLY
2537 cpi->mb_wiener_var_cols = 0;
2538 cpi->mb_wiener_var_rows = 0;
2539 cpi->mb_wiener_variance = NULL;
2541 vp9_set_speed_features_framesize_independent(cpi, oxcf->speed);
2542 vp9_set_speed_features_framesize_dependent(cpi, oxcf->speed);
2545 const int bsize = BLOCK_16X16;
2546 const int w = num_8x8_blocks_wide_lookup[bsize];
2547 const int h = num_8x8_blocks_high_lookup[bsize];
2548 const int num_cols = (cm->mi_cols + w - 1) / w;
2549 const int num_rows = (cm->mi_rows + h - 1) / h;
2550 CHECK_MEM_ERROR(cm, cpi->mi_ssim_rdmult_scaling_factors,
2551 vpx_calloc(num_rows * num_cols,
2552 sizeof(*cpi->mi_ssim_rdmult_scaling_factors)));
2555 cpi->kmeans_data_arr_alloc = 0;
2556 #if CONFIG_NON_GREEDY_MV
2558 #endif // CONFIG_NON_GREEDY_MV
2559 for (i = 0; i < MAX_ARF_GOP_SIZE; ++i) cpi->tpl_stats[i].tpl_stats_ptr = NULL;
2561 // Allocate memory to store variances for a frame.
2562 CHECK_MEM_ERROR(cm, cpi->source_diff_var, vpx_calloc(cm->MBs, sizeof(diff)));
2563 cpi->source_var_thresh = 0;
2564 cpi->frames_till_next_var_check = 0;
2565 #define BFP(BT, SDF, SDAF, VF, SVF, SVAF, SDX4DF, SDX8F) \
2566 cpi->fn_ptr[BT].sdf = SDF; \
2567 cpi->fn_ptr[BT].sdaf = SDAF; \
2568 cpi->fn_ptr[BT].vf = VF; \
2569 cpi->fn_ptr[BT].svf = SVF; \
2570 cpi->fn_ptr[BT].svaf = SVAF; \
2571 cpi->fn_ptr[BT].sdx4df = SDX4DF; \
2572 cpi->fn_ptr[BT].sdx8f = SDX8F;
2574 // TODO(angiebird): make sdx8f available for every block size
2575 BFP(BLOCK_32X16, vpx_sad32x16, vpx_sad32x16_avg, vpx_variance32x16,
2576 vpx_sub_pixel_variance32x16, vpx_sub_pixel_avg_variance32x16,
2577 vpx_sad32x16x4d, NULL)
2579 BFP(BLOCK_16X32, vpx_sad16x32, vpx_sad16x32_avg, vpx_variance16x32,
2580 vpx_sub_pixel_variance16x32, vpx_sub_pixel_avg_variance16x32,
2581 vpx_sad16x32x4d, NULL)
2583 BFP(BLOCK_64X32, vpx_sad64x32, vpx_sad64x32_avg, vpx_variance64x32,
2584 vpx_sub_pixel_variance64x32, vpx_sub_pixel_avg_variance64x32,
2585 vpx_sad64x32x4d, NULL)
2587 BFP(BLOCK_32X64, vpx_sad32x64, vpx_sad32x64_avg, vpx_variance32x64,
2588 vpx_sub_pixel_variance32x64, vpx_sub_pixel_avg_variance32x64,
2589 vpx_sad32x64x4d, NULL)
2591 BFP(BLOCK_32X32, vpx_sad32x32, vpx_sad32x32_avg, vpx_variance32x32,
2592 vpx_sub_pixel_variance32x32, vpx_sub_pixel_avg_variance32x32,
2593 vpx_sad32x32x4d, vpx_sad32x32x8)
2595 BFP(BLOCK_64X64, vpx_sad64x64, vpx_sad64x64_avg, vpx_variance64x64,
2596 vpx_sub_pixel_variance64x64, vpx_sub_pixel_avg_variance64x64,
2597 vpx_sad64x64x4d, NULL)
2599 BFP(BLOCK_16X16, vpx_sad16x16, vpx_sad16x16_avg, vpx_variance16x16,
2600 vpx_sub_pixel_variance16x16, vpx_sub_pixel_avg_variance16x16,
2601 vpx_sad16x16x4d, vpx_sad16x16x8)
2603 BFP(BLOCK_16X8, vpx_sad16x8, vpx_sad16x8_avg, vpx_variance16x8,
2604 vpx_sub_pixel_variance16x8, vpx_sub_pixel_avg_variance16x8,
2605 vpx_sad16x8x4d, vpx_sad16x8x8)
2607 BFP(BLOCK_8X16, vpx_sad8x16, vpx_sad8x16_avg, vpx_variance8x16,
2608 vpx_sub_pixel_variance8x16, vpx_sub_pixel_avg_variance8x16,
2609 vpx_sad8x16x4d, vpx_sad8x16x8)
2611 BFP(BLOCK_8X8, vpx_sad8x8, vpx_sad8x8_avg, vpx_variance8x8,
2612 vpx_sub_pixel_variance8x8, vpx_sub_pixel_avg_variance8x8, vpx_sad8x8x4d,
2615 BFP(BLOCK_8X4, vpx_sad8x4, vpx_sad8x4_avg, vpx_variance8x4,
2616 vpx_sub_pixel_variance8x4, vpx_sub_pixel_avg_variance8x4, vpx_sad8x4x4d,
2619 BFP(BLOCK_4X8, vpx_sad4x8, vpx_sad4x8_avg, vpx_variance4x8,
2620 vpx_sub_pixel_variance4x8, vpx_sub_pixel_avg_variance4x8, vpx_sad4x8x4d,
2623 BFP(BLOCK_4X4, vpx_sad4x4, vpx_sad4x4_avg, vpx_variance4x4,
2624 vpx_sub_pixel_variance4x4, vpx_sub_pixel_avg_variance4x4, vpx_sad4x4x4d,
2627 #if CONFIG_VP9_HIGHBITDEPTH
2628 highbd_set_var_fns(cpi);
2631 /* vp9_init_quantizer() is first called here. Add check in
2632 * vp9_frame_init_quantizer() so that vp9_init_quantizer is only
2633 * called later when needed. This will avoid unnecessary calls of
2634 * vp9_init_quantizer() for every frame.
2636 vp9_init_quantizer(cpi);
2638 vp9_loop_filter_init(cm);
2640 // Set up the unit scaling factor used during motion search.
2641 #if CONFIG_VP9_HIGHBITDEPTH
2642 vp9_setup_scale_factors_for_frame(&cpi->me_sf, cm->width, cm->height,
2643 cm->width, cm->height,
2644 cm->use_highbitdepth);
2646 vp9_setup_scale_factors_for_frame(&cpi->me_sf, cm->width, cm->height,
2647 cm->width, cm->height);
2648 #endif // CONFIG_VP9_HIGHBITDEPTH
2649 cpi->td.mb.me_sf = &cpi->me_sf;
2651 cm->error.setjmp = 0;
2653 #if CONFIG_RATE_CTRL
2654 encode_command_init(&cpi->encode_command);
2660 #if CONFIG_INTERNAL_STATS
2661 #define SNPRINT(H, T) snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T))
2663 #define SNPRINT2(H, T, V) \
2664 snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T), (V))
2665 #endif // CONFIG_INTERNAL_STATS
2667 static void free_tpl_buffer(VP9_COMP *cpi);
2669 void vp9_remove_compressor(VP9_COMP *cpi) {
2676 #if CONFIG_INTERNAL_STATS
2677 vpx_free(cpi->ssim_vars);
2681 if (cm->current_video_frame > 0) {
2682 #if CONFIG_INTERNAL_STATS
2683 vpx_clear_system_state();
2685 if (cpi->oxcf.pass != 1) {
2686 char headings[512] = { 0 };
2687 char results[512] = { 0 };
2688 FILE *f = fopen("opsnr.stt", "a");
2689 double time_encoded =
2690 (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) /
2692 double total_encode_time =
2693 (cpi->time_receive_data + cpi->time_compress_data) / 1000.000;
2695 (double)cpi->bytes * (double)8 / (double)1000 / time_encoded;
2696 const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1);
2697 const double target_rate = (double)cpi->oxcf.target_bandwidth / 1000;
2698 const double rate_err = ((100.0 * (dr - target_rate)) / target_rate);
2700 if (cpi->b_calculate_psnr) {
2701 const double total_psnr = vpx_sse_to_psnr(
2702 (double)cpi->total_samples, peak, (double)cpi->total_sq_error);
2703 const double totalp_psnr = vpx_sse_to_psnr(
2704 (double)cpi->totalp_samples, peak, (double)cpi->totalp_sq_error);
2705 const double total_ssim =
2706 100 * pow(cpi->summed_quality / cpi->summed_weights, 8.0);
2707 const double totalp_ssim =
2708 100 * pow(cpi->summedp_quality / cpi->summedp_weights, 8.0);
2710 snprintf(headings, sizeof(headings),
2711 "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\t"
2712 "VPXSSIM\tVPSSIMP\tFASTSIM\tPSNRHVS\t"
2713 "WstPsnr\tWstSsim\tWstFast\tWstHVS\t"
2714 "AVPsnrY\tAPsnrCb\tAPsnrCr");
2715 snprintf(results, sizeof(results),
2716 "%7.2f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2717 "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2718 "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2719 "%7.3f\t%7.3f\t%7.3f",
2720 dr, cpi->psnr.stat[ALL] / cpi->count, total_psnr,
2721 cpi->psnrp.stat[ALL] / cpi->count, totalp_psnr, total_ssim,
2722 totalp_ssim, cpi->fastssim.stat[ALL] / cpi->count,
2723 cpi->psnrhvs.stat[ALL] / cpi->count, cpi->psnr.worst,
2724 cpi->worst_ssim, cpi->fastssim.worst, cpi->psnrhvs.worst,
2725 cpi->psnr.stat[Y] / cpi->count, cpi->psnr.stat[U] / cpi->count,
2726 cpi->psnr.stat[V] / cpi->count);
2728 if (cpi->b_calculate_blockiness) {
2729 SNPRINT(headings, "\t Block\tWstBlck");
2730 SNPRINT2(results, "\t%7.3f", cpi->total_blockiness / cpi->count);
2731 SNPRINT2(results, "\t%7.3f", cpi->worst_blockiness);
2734 if (cpi->b_calculate_consistency) {
2735 double consistency =
2736 vpx_sse_to_psnr((double)cpi->totalp_samples, peak,
2737 (double)cpi->total_inconsistency);
2739 SNPRINT(headings, "\tConsist\tWstCons");
2740 SNPRINT2(results, "\t%7.3f", consistency);
2741 SNPRINT2(results, "\t%7.3f", cpi->worst_consistency);
2744 SNPRINT(headings, "\t Time\tRcErr\tAbsErr");
2745 SNPRINT2(results, "\t%8.0f", total_encode_time);
2746 SNPRINT2(results, "\t%7.2f", rate_err);
2747 SNPRINT2(results, "\t%7.2f", fabs(rate_err));
2749 fprintf(f, "%s\tAPsnr611\n", headings);
2751 f, "%s\t%7.3f\n", results,
2752 (6 * cpi->psnr.stat[Y] + cpi->psnr.stat[U] + cpi->psnr.stat[V]) /
2762 printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000);
2763 printf("\n_frames recive_data encod_mb_row compress_frame Total\n");
2764 printf("%6d %10ld %10ld %10ld %10ld\n", cpi->common.current_video_frame,
2765 cpi->time_receive_data / 1000, cpi->time_encode_sb_row / 1000,
2766 cpi->time_compress_data / 1000,
2767 (cpi->time_receive_data + cpi->time_compress_data) / 1000);
2772 #if CONFIG_VP9_TEMPORAL_DENOISING
2773 vp9_denoiser_free(&(cpi->denoiser));
2776 if (cpi->kmeans_data_arr_alloc) {
2777 #if CONFIG_MULTITHREAD
2778 pthread_mutex_destroy(&cpi->kmeans_mutex);
2780 vpx_free(cpi->kmeans_data_arr);
2783 free_tpl_buffer(cpi);
2785 for (t = 0; t < cpi->num_workers; ++t) {
2786 VPxWorker *const worker = &cpi->workers[t];
2787 EncWorkerData *const thread_data = &cpi->tile_thr_data[t];
2789 // Deallocate allocated threads.
2790 vpx_get_worker_interface()->end(worker);
2792 // Deallocate allocated thread data.
2793 if (t < cpi->num_workers - 1) {
2794 vpx_free(thread_data->td->counts);
2795 vp9_free_pc_tree(thread_data->td);
2796 vpx_free(thread_data->td);
2799 vpx_free(cpi->tile_thr_data);
2800 vpx_free(cpi->workers);
2801 vp9_row_mt_mem_dealloc(cpi);
2803 if (cpi->num_workers > 1) {
2804 vp9_loop_filter_dealloc(&cpi->lf_row_sync);
2805 vp9_bitstream_encode_tiles_buffer_dealloc(cpi);
2808 #if !CONFIG_REALTIME_ONLY
2809 vp9_alt_ref_aq_destroy(cpi->alt_ref_aq);
2812 dealloc_compressor_data(cpi);
2814 for (i = 0; i < sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]);
2816 vpx_free(cpi->mbgraph_stats[i].mb_stats);
2819 #if CONFIG_FP_MB_STATS
2820 if (cpi->use_fp_mb_stats) {
2821 vpx_free(cpi->twopass.frame_mb_stats_buf);
2822 cpi->twopass.frame_mb_stats_buf = NULL;
2826 vp9_remove_common(cm);
2827 vp9_free_ref_frame_buffers(cm->buffer_pool);
2828 #if CONFIG_VP9_POSTPROC
2829 vp9_free_postproc_buffers(cm);
2833 #if CONFIG_VP9_TEMPORAL_DENOISING
2834 #ifdef OUTPUT_YUV_DENOISED
2835 fclose(yuv_denoised_file);
2838 #ifdef OUTPUT_YUV_SKINMAP
2839 fclose(yuv_skinmap_file);
2841 #ifdef OUTPUT_YUV_REC
2842 fclose(yuv_rec_file);
2844 #ifdef OUTPUT_YUV_SVC_SRC
2845 fclose(yuv_svc_src[0]);
2846 fclose(yuv_svc_src[1]);
2847 fclose(yuv_svc_src[2]);
2864 int vp9_get_psnr(const VP9_COMP *cpi, PSNR_STATS *psnr) {
2865 if (is_psnr_calc_enabled(cpi)) {
2866 #if CONFIG_VP9_HIGHBITDEPTH
2867 vpx_calc_highbd_psnr(cpi->raw_source_frame, cpi->common.frame_to_show, psnr,
2868 cpi->td.mb.e_mbd.bd, cpi->oxcf.input_bit_depth);
2870 vpx_calc_psnr(cpi->raw_source_frame, cpi->common.frame_to_show, psnr);
2879 int vp9_use_as_reference(VP9_COMP *cpi, int ref_frame_flags) {
2880 if (ref_frame_flags > 7) return -1;
2882 cpi->ref_frame_flags = ref_frame_flags;
2886 void vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags) {
2887 cpi->ext_refresh_golden_frame = (ref_frame_flags & VP9_GOLD_FLAG) != 0;
2888 cpi->ext_refresh_alt_ref_frame = (ref_frame_flags & VP9_ALT_FLAG) != 0;
2889 cpi->ext_refresh_last_frame = (ref_frame_flags & VP9_LAST_FLAG) != 0;
2890 cpi->ext_refresh_frame_flags_pending = 1;
2893 static YV12_BUFFER_CONFIG *get_vp9_ref_frame_buffer(
2894 VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag) {
2895 MV_REFERENCE_FRAME ref_frame = NONE;
2896 if (ref_frame_flag == VP9_LAST_FLAG)
2897 ref_frame = LAST_FRAME;
2898 else if (ref_frame_flag == VP9_GOLD_FLAG)
2899 ref_frame = GOLDEN_FRAME;
2900 else if (ref_frame_flag == VP9_ALT_FLAG)
2901 ref_frame = ALTREF_FRAME;
2903 return ref_frame == NONE ? NULL : get_ref_frame_buffer(cpi, ref_frame);
2906 int vp9_copy_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
2907 YV12_BUFFER_CONFIG *sd) {
2908 YV12_BUFFER_CONFIG *cfg = get_vp9_ref_frame_buffer(cpi, ref_frame_flag);
2910 vpx_yv12_copy_frame(cfg, sd);
2917 int vp9_set_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
2918 YV12_BUFFER_CONFIG *sd) {
2919 YV12_BUFFER_CONFIG *cfg = get_vp9_ref_frame_buffer(cpi, ref_frame_flag);
2921 vpx_yv12_copy_frame(sd, cfg);
2928 int vp9_update_entropy(VP9_COMP *cpi, int update) {
2929 cpi->ext_refresh_frame_context = update;
2930 cpi->ext_refresh_frame_context_pending = 1;
2934 #ifdef OUTPUT_YUV_REC
2935 void vp9_write_yuv_rec_frame(VP9_COMMON *cm) {
2936 YV12_BUFFER_CONFIG *s = cm->frame_to_show;
2937 uint8_t *src = s->y_buffer;
2940 #if CONFIG_VP9_HIGHBITDEPTH
2941 if (s->flags & YV12_FLAG_HIGHBITDEPTH) {
2942 uint16_t *src16 = CONVERT_TO_SHORTPTR(s->y_buffer);
2945 fwrite(src16, s->y_width, 2, yuv_rec_file);
2946 src16 += s->y_stride;
2949 src16 = CONVERT_TO_SHORTPTR(s->u_buffer);
2953 fwrite(src16, s->uv_width, 2, yuv_rec_file);
2954 src16 += s->uv_stride;
2957 src16 = CONVERT_TO_SHORTPTR(s->v_buffer);
2961 fwrite(src16, s->uv_width, 2, yuv_rec_file);
2962 src16 += s->uv_stride;
2965 fflush(yuv_rec_file);
2968 #endif // CONFIG_VP9_HIGHBITDEPTH
2971 fwrite(src, s->y_width, 1, yuv_rec_file);
2979 fwrite(src, s->uv_width, 1, yuv_rec_file);
2980 src += s->uv_stride;
2987 fwrite(src, s->uv_width, 1, yuv_rec_file);
2988 src += s->uv_stride;
2991 fflush(yuv_rec_file);
2995 #if CONFIG_VP9_HIGHBITDEPTH
2996 static void scale_and_extend_frame_nonnormative(const YV12_BUFFER_CONFIG *src,
2997 YV12_BUFFER_CONFIG *dst,
3000 static void scale_and_extend_frame_nonnormative(const YV12_BUFFER_CONFIG *src,
3001 YV12_BUFFER_CONFIG *dst) {
3002 #endif // CONFIG_VP9_HIGHBITDEPTH
3003 // TODO(dkovalev): replace YV12_BUFFER_CONFIG with vpx_image_t
3005 const uint8_t *const srcs[3] = { src->y_buffer, src->u_buffer,
3007 const int src_strides[3] = { src->y_stride, src->uv_stride, src->uv_stride };
3008 const int src_widths[3] = { src->y_crop_width, src->uv_crop_width,
3009 src->uv_crop_width };
3010 const int src_heights[3] = { src->y_crop_height, src->uv_crop_height,
3011 src->uv_crop_height };
3012 uint8_t *const dsts[3] = { dst->y_buffer, dst->u_buffer, dst->v_buffer };
3013 const int dst_strides[3] = { dst->y_stride, dst->uv_stride, dst->uv_stride };
3014 const int dst_widths[3] = { dst->y_crop_width, dst->uv_crop_width,
3015 dst->uv_crop_width };
3016 const int dst_heights[3] = { dst->y_crop_height, dst->uv_crop_height,
3017 dst->uv_crop_height };
3019 for (i = 0; i < MAX_MB_PLANE; ++i) {
3020 #if CONFIG_VP9_HIGHBITDEPTH
3021 if (src->flags & YV12_FLAG_HIGHBITDEPTH) {
3022 vp9_highbd_resize_plane(srcs[i], src_heights[i], src_widths[i],
3023 src_strides[i], dsts[i], dst_heights[i],
3024 dst_widths[i], dst_strides[i], bd);
3026 vp9_resize_plane(srcs[i], src_heights[i], src_widths[i], src_strides[i],
3027 dsts[i], dst_heights[i], dst_widths[i], dst_strides[i]);
3030 vp9_resize_plane(srcs[i], src_heights[i], src_widths[i], src_strides[i],
3031 dsts[i], dst_heights[i], dst_widths[i], dst_strides[i]);
3032 #endif // CONFIG_VP9_HIGHBITDEPTH
3034 vpx_extend_frame_borders(dst);
3037 #if CONFIG_VP9_HIGHBITDEPTH
3038 static void scale_and_extend_frame(const YV12_BUFFER_CONFIG *src,
3039 YV12_BUFFER_CONFIG *dst, int bd,
3040 INTERP_FILTER filter_type,
3042 const int src_w = src->y_crop_width;
3043 const int src_h = src->y_crop_height;
3044 const int dst_w = dst->y_crop_width;
3045 const int dst_h = dst->y_crop_height;
3046 const uint8_t *const srcs[3] = { src->y_buffer, src->u_buffer,
3048 const int src_strides[3] = { src->y_stride, src->uv_stride, src->uv_stride };
3049 uint8_t *const dsts[3] = { dst->y_buffer, dst->u_buffer, dst->v_buffer };
3050 const int dst_strides[3] = { dst->y_stride, dst->uv_stride, dst->uv_stride };
3051 const InterpKernel *const kernel = vp9_filter_kernels[filter_type];
3054 for (i = 0; i < MAX_MB_PLANE; ++i) {
3055 const int factor = (i == 0 || i == 3 ? 1 : 2);
3056 const int src_stride = src_strides[i];
3057 const int dst_stride = dst_strides[i];
3058 for (y = 0; y < dst_h; y += 16) {
3059 const int y_q4 = y * (16 / factor) * src_h / dst_h + phase_scaler;
3060 for (x = 0; x < dst_w; x += 16) {
3061 const int x_q4 = x * (16 / factor) * src_w / dst_w + phase_scaler;
3062 const uint8_t *src_ptr = srcs[i] +
3063 (y / factor) * src_h / dst_h * src_stride +
3064 (x / factor) * src_w / dst_w;
3065 uint8_t *dst_ptr = dsts[i] + (y / factor) * dst_stride + (x / factor);
3067 if (src->flags & YV12_FLAG_HIGHBITDEPTH) {
3068 vpx_highbd_convolve8(CONVERT_TO_SHORTPTR(src_ptr), src_stride,
3069 CONVERT_TO_SHORTPTR(dst_ptr), dst_stride, kernel,
3070 x_q4 & 0xf, 16 * src_w / dst_w, y_q4 & 0xf,
3071 16 * src_h / dst_h, 16 / factor, 16 / factor,
3074 vpx_scaled_2d(src_ptr, src_stride, dst_ptr, dst_stride, kernel,
3075 x_q4 & 0xf, 16 * src_w / dst_w, y_q4 & 0xf,
3076 16 * src_h / dst_h, 16 / factor, 16 / factor);
3082 vpx_extend_frame_borders(dst);
3084 #endif // CONFIG_VP9_HIGHBITDEPTH
3086 #if !CONFIG_REALTIME_ONLY
3087 static int scale_down(VP9_COMP *cpi, int q) {
3088 RATE_CONTROL *const rc = &cpi->rc;
3089 GF_GROUP *const gf_group = &cpi->twopass.gf_group;
3091 assert(frame_is_kf_gf_arf(cpi));
3093 if (rc->frame_size_selector == UNSCALED &&
3094 q >= rc->rf_level_maxq[gf_group->rf_level[gf_group->index]]) {
3095 const int max_size_thresh =
3096 (int)(rate_thresh_mult[SCALE_STEP1] *
3097 VPXMAX(rc->this_frame_target, rc->avg_frame_bandwidth));
3098 scale = rc->projected_frame_size > max_size_thresh ? 1 : 0;
3103 static int big_rate_miss_high_threshold(VP9_COMP *cpi) {
3104 const RATE_CONTROL *const rc = &cpi->rc;
3107 if (frame_is_kf_gf_arf(cpi))
3108 big_miss_high = rc->this_frame_target * 3 / 2;
3110 big_miss_high = rc->this_frame_target * 2;
3112 return big_miss_high;
3115 static int big_rate_miss(VP9_COMP *cpi) {
3116 const RATE_CONTROL *const rc = &cpi->rc;
3120 // Ignore for overlay frames
3121 if (rc->is_src_frame_alt_ref) {
3124 big_miss_low = (rc->this_frame_target / 2);
3125 big_miss_high = big_rate_miss_high_threshold(cpi);
3127 return (rc->projected_frame_size > big_miss_high) ||
3128 (rc->projected_frame_size < big_miss_low);
3132 // test in two pass for the first
3133 static int two_pass_first_group_inter(VP9_COMP *cpi) {
3134 if (cpi->oxcf.pass == 2) {
3135 TWO_PASS *const twopass = &cpi->twopass;
3136 GF_GROUP *const gf_group = &twopass->gf_group;
3137 const int gfg_index = gf_group->index;
3139 if (gfg_index == 0) return gf_group->update_type[gfg_index] == LF_UPDATE;
3140 return gf_group->update_type[gfg_index - 1] != LF_UPDATE &&
3141 gf_group->update_type[gfg_index] == LF_UPDATE;
3147 // Function to test for conditions that indicate we should loop
3148 // back and recode a frame.
3149 static int recode_loop_test(VP9_COMP *cpi, int high_limit, int low_limit, int q,
3150 int maxq, int minq) {
3151 const RATE_CONTROL *const rc = &cpi->rc;
3152 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
3153 const int frame_is_kfgfarf = frame_is_kf_gf_arf(cpi);
3154 int force_recode = 0;
3156 if ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
3157 big_rate_miss(cpi) || (cpi->sf.recode_loop == ALLOW_RECODE) ||
3158 (two_pass_first_group_inter(cpi) &&
3159 (cpi->sf.recode_loop == ALLOW_RECODE_FIRST)) ||
3160 (frame_is_kfgfarf && (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF))) {
3161 if (frame_is_kfgfarf && (oxcf->resize_mode == RESIZE_DYNAMIC) &&
3162 scale_down(cpi, q)) {
3163 // Code this group at a lower resolution.
3164 cpi->resize_pending = 1;
3168 // Force recode for extreme overshoot.
3169 if ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
3170 (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF &&
3171 rc->projected_frame_size >= big_rate_miss_high_threshold(cpi))) {
3175 // TODO(agrange) high_limit could be greater than the scale-down threshold.
3176 if ((rc->projected_frame_size > high_limit && q < maxq) ||
3177 (rc->projected_frame_size < low_limit && q > minq)) {
3179 } else if (cpi->oxcf.rc_mode == VPX_CQ) {
3180 // Deal with frame undershoot and whether or not we are
3181 // below the automatically set cq level.
3182 if (q > oxcf->cq_level &&
3183 rc->projected_frame_size < ((rc->this_frame_target * 7) >> 3)) {
3188 return force_recode;
3190 #endif // !CONFIG_REALTIME_ONLY
3192 static void update_ref_frames(VP9_COMP *cpi) {
3193 VP9_COMMON *const cm = &cpi->common;
3194 BufferPool *const pool = cm->buffer_pool;
3195 GF_GROUP *const gf_group = &cpi->twopass.gf_group;
3197 if (cpi->rc.show_arf_as_gld) {
3198 int tmp = cpi->alt_fb_idx;
3199 cpi->alt_fb_idx = cpi->gld_fb_idx;
3200 cpi->gld_fb_idx = tmp;
3201 } else if (cm->show_existing_frame) {
3203 cpi->lst_fb_idx = cpi->alt_fb_idx;
3205 stack_pop(gf_group->arf_index_stack, gf_group->stack_size);
3206 --gf_group->stack_size;
3209 // At this point the new frame has been encoded.
3210 // If any buffer copy / swapping is signaled it should be done here.
3211 if (cm->frame_type == KEY_FRAME) {
3212 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
3214 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->alt_fb_idx],
3216 } else if (vp9_preserve_existing_gf(cpi)) {
3217 // We have decided to preserve the previously existing golden frame as our
3218 // new ARF frame. However, in the short term in function
3219 // vp9_get_refresh_mask() we left it in the GF slot and, if
3220 // we're updating the GF with the current decoded frame, we save it to the
3221 // ARF slot instead.
3222 // We now have to update the ARF with the current frame and swap gld_fb_idx
3223 // and alt_fb_idx so that, overall, we've stored the old GF in the new ARF
3224 // slot and, if we're updating the GF, the current frame becomes the new GF.
3227 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->alt_fb_idx],
3230 tmp = cpi->alt_fb_idx;
3231 cpi->alt_fb_idx = cpi->gld_fb_idx;
3232 cpi->gld_fb_idx = tmp;
3233 } else { /* For non key/golden frames */
3234 if (cpi->refresh_alt_ref_frame) {
3235 int arf_idx = gf_group->top_arf_idx;
3237 // Push new ARF into stack.
3238 stack_push(gf_group->arf_index_stack, cpi->alt_fb_idx,
3239 gf_group->stack_size);
3240 ++gf_group->stack_size;
3242 assert(arf_idx < REF_FRAMES);
3244 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[arf_idx], cm->new_fb_idx);
3245 memcpy(cpi->interp_filter_selected[ALTREF_FRAME],
3246 cpi->interp_filter_selected[0],
3247 sizeof(cpi->interp_filter_selected[0]));
3249 cpi->alt_fb_idx = arf_idx;
3252 if (cpi->refresh_golden_frame) {
3253 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
3255 if (!cpi->rc.is_src_frame_alt_ref)
3256 memcpy(cpi->interp_filter_selected[GOLDEN_FRAME],
3257 cpi->interp_filter_selected[0],
3258 sizeof(cpi->interp_filter_selected[0]));
3260 memcpy(cpi->interp_filter_selected[GOLDEN_FRAME],
3261 cpi->interp_filter_selected[ALTREF_FRAME],
3262 sizeof(cpi->interp_filter_selected[ALTREF_FRAME]));
3266 if (cpi->refresh_last_frame) {
3267 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->lst_fb_idx],
3269 if (!cpi->rc.is_src_frame_alt_ref)
3270 memcpy(cpi->interp_filter_selected[LAST_FRAME],
3271 cpi->interp_filter_selected[0],
3272 sizeof(cpi->interp_filter_selected[0]));
3275 if (gf_group->update_type[gf_group->index] == MID_OVERLAY_UPDATE) {
3277 stack_pop(gf_group->arf_index_stack, gf_group->stack_size);
3278 --gf_group->stack_size;
3282 void vp9_update_reference_frames(VP9_COMP *cpi) {
3283 update_ref_frames(cpi);
3285 #if CONFIG_VP9_TEMPORAL_DENOISING
3286 vp9_denoiser_update_ref_frame(cpi);
3289 if (is_one_pass_cbr_svc(cpi)) vp9_svc_update_ref_frame(cpi);
3292 static void loopfilter_frame(VP9_COMP *cpi, VP9_COMMON *cm) {
3293 MACROBLOCKD *xd = &cpi->td.mb.e_mbd;
3294 struct loopfilter *lf = &cm->lf;
3295 int is_reference_frame =
3296 (cm->frame_type == KEY_FRAME || cpi->refresh_last_frame ||
3297 cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame);
3299 cpi->svc.temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS)
3300 is_reference_frame = !cpi->svc.non_reference_frame;
3302 // Skip loop filter in show_existing_frame mode.
3303 if (cm->show_existing_frame) {
3304 lf->filter_level = 0;
3309 lf->filter_level = 0;
3310 lf->last_filt_level = 0;
3312 struct vpx_usec_timer timer;
3314 vpx_clear_system_state();
3316 vpx_usec_timer_start(&timer);
3318 if (!cpi->rc.is_src_frame_alt_ref) {
3319 if ((cpi->common.frame_type == KEY_FRAME) &&
3320 (!cpi->rc.this_key_frame_forced)) {
3321 lf->last_filt_level = 0;
3323 vp9_pick_filter_level(cpi->Source, cpi, cpi->sf.lpf_pick);
3324 lf->last_filt_level = lf->filter_level;
3326 lf->filter_level = 0;
3329 vpx_usec_timer_mark(&timer);
3330 cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
3333 if (lf->filter_level > 0 && is_reference_frame) {
3334 vp9_build_mask_frame(cm, lf->filter_level, 0);
3336 if (cpi->num_workers > 1)
3337 vp9_loop_filter_frame_mt(cm->frame_to_show, cm, xd->plane,
3338 lf->filter_level, 0, 0, cpi->workers,
3339 cpi->num_workers, &cpi->lf_row_sync);
3341 vp9_loop_filter_frame(cm->frame_to_show, cm, xd, lf->filter_level, 0, 0);
3344 vpx_extend_frame_inner_borders(cm->frame_to_show);
3347 static INLINE void alloc_frame_mvs(VP9_COMMON *const cm, int buffer_idx) {
3348 RefCntBuffer *const new_fb_ptr = &cm->buffer_pool->frame_bufs[buffer_idx];
3349 if (new_fb_ptr->mvs == NULL || new_fb_ptr->mi_rows < cm->mi_rows ||
3350 new_fb_ptr->mi_cols < cm->mi_cols) {
3351 vpx_free(new_fb_ptr->mvs);
3352 CHECK_MEM_ERROR(cm, new_fb_ptr->mvs,
3353 (MV_REF *)vpx_calloc(cm->mi_rows * cm->mi_cols,
3354 sizeof(*new_fb_ptr->mvs)));
3355 new_fb_ptr->mi_rows = cm->mi_rows;
3356 new_fb_ptr->mi_cols = cm->mi_cols;
3360 void vp9_scale_references(VP9_COMP *cpi) {
3361 VP9_COMMON *cm = &cpi->common;
3362 MV_REFERENCE_FRAME ref_frame;
3363 const VP9_REFFRAME ref_mask[3] = { VP9_LAST_FLAG, VP9_GOLD_FLAG,
3366 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3367 // Need to convert from VP9_REFFRAME to index into ref_mask (subtract 1).
3368 if (cpi->ref_frame_flags & ref_mask[ref_frame - 1]) {
3369 BufferPool *const pool = cm->buffer_pool;
3370 const YV12_BUFFER_CONFIG *const ref =
3371 get_ref_frame_buffer(cpi, ref_frame);
3374 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3378 #if CONFIG_VP9_HIGHBITDEPTH
3379 if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) {
3380 RefCntBuffer *new_fb_ptr = NULL;
3381 int force_scaling = 0;
3382 int new_fb = cpi->scaled_ref_idx[ref_frame - 1];
3383 if (new_fb == INVALID_IDX) {
3384 new_fb = get_free_fb(cm);
3387 if (new_fb == INVALID_IDX) return;
3388 new_fb_ptr = &pool->frame_bufs[new_fb];
3389 if (force_scaling || new_fb_ptr->buf.y_crop_width != cm->width ||
3390 new_fb_ptr->buf.y_crop_height != cm->height) {
3391 if (vpx_realloc_frame_buffer(&new_fb_ptr->buf, cm->width, cm->height,
3392 cm->subsampling_x, cm->subsampling_y,
3393 cm->use_highbitdepth,
3394 VP9_ENC_BORDER_IN_PIXELS,
3395 cm->byte_alignment, NULL, NULL, NULL))
3396 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3397 "Failed to allocate frame buffer");
3398 scale_and_extend_frame(ref, &new_fb_ptr->buf, (int)cm->bit_depth,
3400 cpi->scaled_ref_idx[ref_frame - 1] = new_fb;
3401 alloc_frame_mvs(cm, new_fb);
3404 if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) {
3405 RefCntBuffer *new_fb_ptr = NULL;
3406 int force_scaling = 0;
3407 int new_fb = cpi->scaled_ref_idx[ref_frame - 1];
3408 if (new_fb == INVALID_IDX) {
3409 new_fb = get_free_fb(cm);
3412 if (new_fb == INVALID_IDX) return;
3413 new_fb_ptr = &pool->frame_bufs[new_fb];
3414 if (force_scaling || new_fb_ptr->buf.y_crop_width != cm->width ||
3415 new_fb_ptr->buf.y_crop_height != cm->height) {
3416 if (vpx_realloc_frame_buffer(&new_fb_ptr->buf, cm->width, cm->height,
3417 cm->subsampling_x, cm->subsampling_y,
3418 VP9_ENC_BORDER_IN_PIXELS,
3419 cm->byte_alignment, NULL, NULL, NULL))
3420 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3421 "Failed to allocate frame buffer");
3422 vp9_scale_and_extend_frame(ref, &new_fb_ptr->buf, EIGHTTAP, 0);
3423 cpi->scaled_ref_idx[ref_frame - 1] = new_fb;
3424 alloc_frame_mvs(cm, new_fb);
3426 #endif // CONFIG_VP9_HIGHBITDEPTH
3429 RefCntBuffer *buf = NULL;
3430 if (cpi->oxcf.pass == 0 && !cpi->use_svc) {
3431 // Check for release of scaled reference.
3432 buf_idx = cpi->scaled_ref_idx[ref_frame - 1];
3433 if (buf_idx != INVALID_IDX) {
3434 buf = &pool->frame_bufs[buf_idx];
3436 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3439 buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
3440 buf = &pool->frame_bufs[buf_idx];
3441 buf->buf.y_crop_width = ref->y_crop_width;
3442 buf->buf.y_crop_height = ref->y_crop_height;
3443 cpi->scaled_ref_idx[ref_frame - 1] = buf_idx;
3447 if (cpi->oxcf.pass != 0 || cpi->use_svc)
3448 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3453 static void release_scaled_references(VP9_COMP *cpi) {
3454 VP9_COMMON *cm = &cpi->common;
3456 if (cpi->oxcf.pass == 0 && !cpi->use_svc) {
3457 // Only release scaled references under certain conditions:
3458 // if reference will be updated, or if scaled reference has same resolution.
3460 refresh[0] = (cpi->refresh_last_frame) ? 1 : 0;
3461 refresh[1] = (cpi->refresh_golden_frame) ? 1 : 0;
3462 refresh[2] = (cpi->refresh_alt_ref_frame) ? 1 : 0;
3463 for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
3464 const int idx = cpi->scaled_ref_idx[i - 1];
3465 if (idx != INVALID_IDX) {
3466 RefCntBuffer *const buf = &cm->buffer_pool->frame_bufs[idx];
3467 const YV12_BUFFER_CONFIG *const ref = get_ref_frame_buffer(cpi, i);
3468 if (refresh[i - 1] || (buf->buf.y_crop_width == ref->y_crop_width &&
3469 buf->buf.y_crop_height == ref->y_crop_height)) {
3471 cpi->scaled_ref_idx[i - 1] = INVALID_IDX;
3476 for (i = 0; i < REFS_PER_FRAME; ++i) {
3477 const int idx = cpi->scaled_ref_idx[i];
3478 if (idx != INVALID_IDX) {
3479 RefCntBuffer *const buf = &cm->buffer_pool->frame_bufs[idx];
3481 cpi->scaled_ref_idx[i] = INVALID_IDX;
3487 static void full_to_model_count(unsigned int *model_count,
3488 unsigned int *full_count) {
3490 model_count[ZERO_TOKEN] = full_count[ZERO_TOKEN];
3491 model_count[ONE_TOKEN] = full_count[ONE_TOKEN];
3492 model_count[TWO_TOKEN] = full_count[TWO_TOKEN];
3493 for (n = THREE_TOKEN; n < EOB_TOKEN; ++n)
3494 model_count[TWO_TOKEN] += full_count[n];
3495 model_count[EOB_MODEL_TOKEN] = full_count[EOB_TOKEN];
3498 static void full_to_model_counts(vp9_coeff_count_model *model_count,
3499 vp9_coeff_count *full_count) {
3502 for (i = 0; i < PLANE_TYPES; ++i)
3503 for (j = 0; j < REF_TYPES; ++j)
3504 for (k = 0; k < COEF_BANDS; ++k)
3505 for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l)
3506 full_to_model_count(model_count[i][j][k][l], full_count[i][j][k][l]);
3509 #if 0 && CONFIG_INTERNAL_STATS
3510 static void output_frame_level_debug_stats(VP9_COMP *cpi) {
3511 VP9_COMMON *const cm = &cpi->common;
3512 FILE *const f = fopen("tmp.stt", cm->current_video_frame ? "a" : "w");
3515 vpx_clear_system_state();
3517 #if CONFIG_VP9_HIGHBITDEPTH
3518 if (cm->use_highbitdepth) {
3519 recon_err = vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3521 recon_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3524 recon_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3525 #endif // CONFIG_VP9_HIGHBITDEPTH
3528 if (cpi->twopass.total_left_stats.coded_error != 0.0) {
3529 double dc_quant_devisor;
3530 #if CONFIG_VP9_HIGHBITDEPTH
3531 switch (cm->bit_depth) {
3533 dc_quant_devisor = 4.0;
3536 dc_quant_devisor = 16.0;
3539 assert(cm->bit_depth == VPX_BITS_12);
3540 dc_quant_devisor = 64.0;
3544 dc_quant_devisor = 4.0;
3547 if (!cm->current_video_frame) {
3548 fprintf(f, "frame, width, height, last ts, last end ts, "
3549 "source_alt_ref_pending, source_alt_ref_active, "
3550 "this_frame_target, projected_frame_size, "
3551 "projected_frame_size / MBs, "
3552 "projected_frame_size - this_frame_target, "
3553 "vbr_bits_off_target, vbr_bits_off_target_fast, "
3554 "twopass.extend_minq, twopass.extend_minq_fast, "
3555 "total_target_vs_actual, "
3556 "starting_buffer_level - bits_off_target, "
3557 "total_actual_bits, base_qindex, q for base_qindex, "
3558 "dc quant, q for active_worst_quality, avg_q, q for oxcf.cq_level, "
3559 "refresh_last_frame, refresh_golden_frame, refresh_alt_ref_frame, "
3560 "frame_type, gfu_boost, "
3561 "twopass.bits_left, "
3562 "twopass.total_left_stats.coded_error, "
3563 "twopass.bits_left / (1 + twopass.total_left_stats.coded_error), "
3564 "tot_recode_hits, recon_err, kf_boost, "
3565 "twopass.kf_zeromotion_pct, twopass.fr_content_type, "
3566 "filter_level, seg.aq_av_offset\n");
3569 fprintf(f, "%10u, %d, %d, %10"PRId64", %10"PRId64", %d, %d, %10d, %10d, "
3570 "%10d, %10d, %10"PRId64", %10"PRId64", %5d, %5d, %10"PRId64", "
3571 "%10"PRId64", %10"PRId64", %10d, %7.2lf, %7.2lf, %7.2lf, %7.2lf, "
3572 "%7.2lf, %6d, %6d, %5d, %5d, %5d, %10"PRId64", %10.3lf, %10lf, %8u, "
3573 "%10"PRId64", %10d, %10d, %10d, %10d, %10d\n",
3574 cpi->common.current_video_frame,
3575 cm->width, cm->height,
3576 cpi->last_time_stamp_seen,
3577 cpi->last_end_time_stamp_seen,
3578 cpi->rc.source_alt_ref_pending,
3579 cpi->rc.source_alt_ref_active,
3580 cpi->rc.this_frame_target,
3581 cpi->rc.projected_frame_size,
3582 cpi->rc.projected_frame_size / cpi->common.MBs,
3583 (cpi->rc.projected_frame_size - cpi->rc.this_frame_target),
3584 cpi->rc.vbr_bits_off_target,
3585 cpi->rc.vbr_bits_off_target_fast,
3586 cpi->twopass.extend_minq,
3587 cpi->twopass.extend_minq_fast,
3588 cpi->rc.total_target_vs_actual,
3589 (cpi->rc.starting_buffer_level - cpi->rc.bits_off_target),
3590 cpi->rc.total_actual_bits, cm->base_qindex,
3591 vp9_convert_qindex_to_q(cm->base_qindex, cm->bit_depth),
3592 (double)vp9_dc_quant(cm->base_qindex, 0, cm->bit_depth) /
3594 vp9_convert_qindex_to_q(cpi->twopass.active_worst_quality,
3597 vp9_convert_qindex_to_q(cpi->oxcf.cq_level, cm->bit_depth),
3598 cpi->refresh_last_frame, cpi->refresh_golden_frame,
3599 cpi->refresh_alt_ref_frame, cm->frame_type, cpi->rc.gfu_boost,
3600 cpi->twopass.bits_left,
3601 cpi->twopass.total_left_stats.coded_error,
3602 cpi->twopass.bits_left /
3603 (1 + cpi->twopass.total_left_stats.coded_error),
3604 cpi->tot_recode_hits, recon_err, cpi->rc.kf_boost,
3605 cpi->twopass.kf_zeromotion_pct,
3606 cpi->twopass.fr_content_type,
3607 cm->lf.filter_level,
3608 cm->seg.aq_av_offset);
3613 FILE *const fmodes = fopen("Modes.stt", "a");
3616 fprintf(fmodes, "%6d:%1d:%1d:%1d ", cpi->common.current_video_frame,
3617 cm->frame_type, cpi->refresh_golden_frame,
3618 cpi->refresh_alt_ref_frame);
3620 for (i = 0; i < MAX_MODES; ++i)
3621 fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
3623 fprintf(fmodes, "\n");
3630 static void set_mv_search_params(VP9_COMP *cpi) {
3631 const VP9_COMMON *const cm = &cpi->common;
3632 const unsigned int max_mv_def = VPXMIN(cm->width, cm->height);
3634 // Default based on max resolution.
3635 cpi->mv_step_param = vp9_init_search_range(max_mv_def);
3637 if (cpi->sf.mv.auto_mv_step_size) {
3638 if (frame_is_intra_only(cm)) {
3639 // Initialize max_mv_magnitude for use in the first INTER frame
3640 // after a key/intra-only frame.
3641 cpi->max_mv_magnitude = max_mv_def;
3643 if (cm->show_frame) {
3644 // Allow mv_steps to correspond to twice the max mv magnitude found
3645 // in the previous frame, capped by the default max_mv_magnitude based
3647 cpi->mv_step_param = vp9_init_search_range(
3648 VPXMIN(max_mv_def, 2 * cpi->max_mv_magnitude));
3650 cpi->max_mv_magnitude = 0;
3655 static void set_size_independent_vars(VP9_COMP *cpi) {
3656 vp9_set_speed_features_framesize_independent(cpi, cpi->oxcf.speed);
3657 vp9_set_rd_speed_thresholds(cpi);
3658 vp9_set_rd_speed_thresholds_sub8x8(cpi);
3659 cpi->common.interp_filter = cpi->sf.default_interp_filter;
3662 static void set_size_dependent_vars(VP9_COMP *cpi, int *q, int *bottom_index,
3664 VP9_COMMON *const cm = &cpi->common;
3666 // Setup variables that depend on the dimensions of the frame.
3667 vp9_set_speed_features_framesize_dependent(cpi, cpi->oxcf.speed);
3669 // Decide q and q bounds.
3670 *q = vp9_rc_pick_q_and_bounds(cpi, bottom_index, top_index);
3672 if (cpi->oxcf.rc_mode == VPX_CBR && cpi->rc.force_max_q) {
3673 *q = cpi->rc.worst_quality;
3674 cpi->rc.force_max_q = 0;
3677 if (!frame_is_intra_only(cm)) {
3678 vp9_set_high_precision_mv(cpi, (*q) < HIGH_PRECISION_MV_QTHRESH);
3681 #if !CONFIG_REALTIME_ONLY
3682 // Configure experimental use of segmentation for enhanced coding of
3683 // static regions if indicated.
3684 // Only allowed in the second pass of a two pass encode, as it requires
3685 // lagged coding, and if the relevant speed feature flag is set.
3686 if (cpi->oxcf.pass == 2 && cpi->sf.static_segmentation)
3687 configure_static_seg_features(cpi);
3688 #endif // !CONFIG_REALTIME_ONLY
3690 #if CONFIG_VP9_POSTPROC && !(CONFIG_VP9_TEMPORAL_DENOISING)
3691 if (cpi->oxcf.noise_sensitivity > 0) {
3693 switch (cpi->oxcf.noise_sensitivity) {
3694 case 1: l = 20; break;
3695 case 2: l = 40; break;
3696 case 3: l = 60; break;
3698 case 5: l = 100; break;
3699 case 6: l = 150; break;
3701 if (!cpi->common.postproc_state.limits) {
3702 cpi->common.postproc_state.limits =
3703 vpx_calloc(cpi->un_scaled_source->y_width,
3704 sizeof(*cpi->common.postproc_state.limits));
3706 vp9_denoise(&cpi->common, cpi->Source, cpi->Source, l,
3707 cpi->common.postproc_state.limits);
3709 #endif // CONFIG_VP9_POSTPROC
3712 static void init_motion_estimation(VP9_COMP *cpi) {
3713 int y_stride = cpi->scaled_source.y_stride;
3715 if (cpi->sf.mv.search_method == NSTEP) {
3716 vp9_init3smotion_compensation(&cpi->ss_cfg, y_stride);
3717 } else if (cpi->sf.mv.search_method == DIAMOND) {
3718 vp9_init_dsmotion_compensation(&cpi->ss_cfg, y_stride);
3722 static void set_frame_size(VP9_COMP *cpi) {
3724 VP9_COMMON *const cm = &cpi->common;
3725 VP9EncoderConfig *const oxcf = &cpi->oxcf;
3726 MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
3728 #if !CONFIG_REALTIME_ONLY
3729 if (oxcf->pass == 2 && oxcf->rc_mode == VPX_VBR &&
3730 ((oxcf->resize_mode == RESIZE_FIXED && cm->current_video_frame == 0) ||
3731 (oxcf->resize_mode == RESIZE_DYNAMIC && cpi->resize_pending))) {
3732 calculate_coded_size(cpi, &oxcf->scaled_frame_width,
3733 &oxcf->scaled_frame_height);
3735 // There has been a change in frame size.
3736 vp9_set_size_literal(cpi, oxcf->scaled_frame_width,
3737 oxcf->scaled_frame_height);
3739 #endif // !CONFIG_REALTIME_ONLY
3741 if (oxcf->pass == 0 && oxcf->rc_mode == VPX_CBR && !cpi->use_svc &&
3742 oxcf->resize_mode == RESIZE_DYNAMIC && cpi->resize_pending != 0) {
3743 oxcf->scaled_frame_width =
3744 (oxcf->width * cpi->resize_scale_num) / cpi->resize_scale_den;
3745 oxcf->scaled_frame_height =
3746 (oxcf->height * cpi->resize_scale_num) / cpi->resize_scale_den;
3747 // There has been a change in frame size.
3748 vp9_set_size_literal(cpi, oxcf->scaled_frame_width,
3749 oxcf->scaled_frame_height);
3751 // TODO(agrange) Scale cpi->max_mv_magnitude if frame-size has changed.
3752 set_mv_search_params(cpi);
3754 vp9_noise_estimate_init(&cpi->noise_estimate, cm->width, cm->height);
3755 #if CONFIG_VP9_TEMPORAL_DENOISING
3756 // Reset the denoiser on the resized frame.
3757 if (cpi->oxcf.noise_sensitivity > 0) {
3758 vp9_denoiser_free(&(cpi->denoiser));
3759 setup_denoiser_buffer(cpi);
3760 // Dynamic resize is only triggered for non-SVC, so we can force
3761 // golden frame update here as temporary fix to denoiser.
3762 cpi->refresh_golden_frame = 1;
3767 if ((oxcf->pass == 2) && !cpi->use_svc) {
3768 vp9_set_target_rate(cpi);
3771 alloc_frame_mvs(cm, cm->new_fb_idx);
3773 // Reset the frame pointers to the current frame size.
3774 if (vpx_realloc_frame_buffer(get_frame_new_buffer(cm), cm->width, cm->height,
3775 cm->subsampling_x, cm->subsampling_y,
3776 #if CONFIG_VP9_HIGHBITDEPTH
3777 cm->use_highbitdepth,
3779 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
3781 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3782 "Failed to allocate frame buffer");
3784 alloc_util_frame_buffers(cpi);
3785 init_motion_estimation(cpi);
3787 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3788 RefBuffer *const ref_buf = &cm->frame_refs[ref_frame - 1];
3789 const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
3791 ref_buf->idx = buf_idx;
3793 if (buf_idx != INVALID_IDX) {
3794 YV12_BUFFER_CONFIG *const buf = &cm->buffer_pool->frame_bufs[buf_idx].buf;
3796 #if CONFIG_VP9_HIGHBITDEPTH
3797 vp9_setup_scale_factors_for_frame(
3798 &ref_buf->sf, buf->y_crop_width, buf->y_crop_height, cm->width,
3799 cm->height, (buf->flags & YV12_FLAG_HIGHBITDEPTH) ? 1 : 0);
3801 vp9_setup_scale_factors_for_frame(&ref_buf->sf, buf->y_crop_width,
3802 buf->y_crop_height, cm->width,
3804 #endif // CONFIG_VP9_HIGHBITDEPTH
3805 if (vp9_is_scaled(&ref_buf->sf)) vpx_extend_frame_borders(buf);
3807 ref_buf->buf = NULL;
3811 set_ref_ptrs(cm, xd, LAST_FRAME, LAST_FRAME);
3814 #if CONFIG_CONSISTENT_RECODE
3815 static void save_encode_params(VP9_COMP *cpi) {
3816 VP9_COMMON *const cm = &cpi->common;
3817 const int tile_cols = 1 << cm->log2_tile_cols;
3818 const int tile_rows = 1 << cm->log2_tile_rows;
3819 int tile_col, tile_row;
3821 RD_OPT *rd_opt = &cpi->rd;
3822 for (i = 0; i < MAX_REF_FRAMES; i++) {
3823 for (j = 0; j < REFERENCE_MODES; j++)
3824 rd_opt->prediction_type_threshes_prev[i][j] =
3825 rd_opt->prediction_type_threshes[i][j];
3827 for (j = 0; j < SWITCHABLE_FILTER_CONTEXTS; j++)
3828 rd_opt->filter_threshes_prev[i][j] = rd_opt->filter_threshes[i][j];
3831 if (cpi->tile_data != NULL) {
3832 for (tile_row = 0; tile_row < tile_rows; ++tile_row)
3833 for (tile_col = 0; tile_col < tile_cols; ++tile_col) {
3834 TileDataEnc *tile_data =
3835 &cpi->tile_data[tile_row * tile_cols + tile_col];
3836 for (i = 0; i < BLOCK_SIZES; ++i) {
3837 for (j = 0; j < MAX_MODES; ++j) {
3838 tile_data->thresh_freq_fact_prev[i][j] =
3839 tile_data->thresh_freq_fact[i][j];
3847 static INLINE void set_raw_source_frame(VP9_COMP *cpi) {
3848 #ifdef ENABLE_KF_DENOISE
3849 if (is_spatial_denoise_enabled(cpi)) {
3850 cpi->raw_source_frame = vp9_scale_if_required(
3851 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
3852 (oxcf->pass == 0), EIGHTTAP, 0);
3854 cpi->raw_source_frame = cpi->Source;
3857 cpi->raw_source_frame = cpi->Source;
3861 static int encode_without_recode_loop(VP9_COMP *cpi, size_t *size,
3863 VP9_COMMON *const cm = &cpi->common;
3864 SVC *const svc = &cpi->svc;
3865 int q = 0, bottom_index = 0, top_index = 0;
3866 int no_drop_scene_change = 0;
3867 const INTERP_FILTER filter_scaler =
3868 (is_one_pass_cbr_svc(cpi))
3869 ? svc->downsample_filter_type[svc->spatial_layer_id]
3871 const int phase_scaler =
3872 (is_one_pass_cbr_svc(cpi))
3873 ? svc->downsample_filter_phase[svc->spatial_layer_id]
3876 if (cm->show_existing_frame) {
3877 cpi->rc.this_frame_target = 0;
3878 if (is_psnr_calc_enabled(cpi)) set_raw_source_frame(cpi);
3882 svc->time_stamp_prev[svc->spatial_layer_id] = svc->time_stamp_superframe;
3884 // Flag to check if its valid to compute the source sad (used for
3885 // scene detection and for superblock content state in CBR mode).
3886 // The flag may get reset below based on SVC or resizing state.
3887 cpi->compute_source_sad_onepass = cpi->oxcf.mode == REALTIME;
3889 vpx_clear_system_state();
3891 set_frame_size(cpi);
3893 if (is_one_pass_cbr_svc(cpi) &&
3894 cpi->un_scaled_source->y_width == cm->width << 2 &&
3895 cpi->un_scaled_source->y_height == cm->height << 2 &&
3896 svc->scaled_temp.y_width == cm->width << 1 &&
3897 svc->scaled_temp.y_height == cm->height << 1) {
3898 // For svc, if it is a 1/4x1/4 downscaling, do a two-stage scaling to take
3899 // advantage of the 1:2 optimized scaler. In the process, the 1/2x1/2
3900 // result will be saved in scaled_temp and might be used later.
3901 const INTERP_FILTER filter_scaler2 = svc->downsample_filter_type[1];
3902 const int phase_scaler2 = svc->downsample_filter_phase[1];
3903 cpi->Source = vp9_svc_twostage_scale(
3904 cm, cpi->un_scaled_source, &cpi->scaled_source, &svc->scaled_temp,
3905 filter_scaler, phase_scaler, filter_scaler2, phase_scaler2);
3906 svc->scaled_one_half = 1;
3907 } else if (is_one_pass_cbr_svc(cpi) &&
3908 cpi->un_scaled_source->y_width == cm->width << 1 &&
3909 cpi->un_scaled_source->y_height == cm->height << 1 &&
3910 svc->scaled_one_half) {
3911 // If the spatial layer is 1/2x1/2 and the scaling is already done in the
3912 // two-stage scaling, use the result directly.
3913 cpi->Source = &svc->scaled_temp;
3914 svc->scaled_one_half = 0;
3916 cpi->Source = vp9_scale_if_required(
3917 cm, cpi->un_scaled_source, &cpi->scaled_source, (cpi->oxcf.pass == 0),
3918 filter_scaler, phase_scaler);
3920 #ifdef OUTPUT_YUV_SVC_SRC
3921 // Write out at most 3 spatial layers.
3922 if (is_one_pass_cbr_svc(cpi) && svc->spatial_layer_id < 3) {
3923 vpx_write_yuv_frame(yuv_svc_src[svc->spatial_layer_id], cpi->Source);
3926 // Unfiltered raw source used in metrics calculation if the source
3927 // has been filtered.
3928 if (is_psnr_calc_enabled(cpi)) {
3929 #ifdef ENABLE_KF_DENOISE
3930 if (is_spatial_denoise_enabled(cpi)) {
3931 cpi->raw_source_frame = vp9_scale_if_required(
3932 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
3933 (cpi->oxcf.pass == 0), EIGHTTAP, phase_scaler);
3935 cpi->raw_source_frame = cpi->Source;
3938 cpi->raw_source_frame = cpi->Source;
3942 if ((cpi->use_svc &&
3943 (svc->spatial_layer_id < svc->number_spatial_layers - 1 ||
3944 svc->temporal_layer_id < svc->number_temporal_layers - 1 ||
3945 svc->current_superframe < 1)) ||
3946 cpi->resize_pending || cpi->resize_state || cpi->external_resize ||
3947 cpi->resize_state != ORIG) {
3948 cpi->compute_source_sad_onepass = 0;
3949 if (cpi->content_state_sb_fd != NULL)
3950 memset(cpi->content_state_sb_fd, 0,
3951 (cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1) *
3952 sizeof(*cpi->content_state_sb_fd));
3955 // Avoid scaling last_source unless its needed.
3956 // Last source is needed if avg_source_sad() is used, or if
3957 // partition_search_type == SOURCE_VAR_BASED_PARTITION, or if noise
3958 // estimation is enabled.
3959 if (cpi->unscaled_last_source != NULL &&
3960 (cpi->oxcf.content == VP9E_CONTENT_SCREEN ||
3961 (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == VPX_VBR &&
3962 cpi->oxcf.mode == REALTIME && cpi->oxcf.speed >= 5) ||
3963 cpi->sf.partition_search_type == SOURCE_VAR_BASED_PARTITION ||
3964 (cpi->noise_estimate.enabled && !cpi->oxcf.noise_sensitivity) ||
3965 cpi->compute_source_sad_onepass))
3966 cpi->Last_Source = vp9_scale_if_required(
3967 cm, cpi->unscaled_last_source, &cpi->scaled_last_source,
3968 (cpi->oxcf.pass == 0), EIGHTTAP, 0);
3970 if (cpi->Last_Source == NULL ||
3971 cpi->Last_Source->y_width != cpi->Source->y_width ||
3972 cpi->Last_Source->y_height != cpi->Source->y_height)
3973 cpi->compute_source_sad_onepass = 0;
3975 if (frame_is_intra_only(cm) || cpi->resize_pending != 0) {
3976 memset(cpi->consec_zero_mv, 0,
3977 cm->mi_rows * cm->mi_cols * sizeof(*cpi->consec_zero_mv));
3980 #if CONFIG_VP9_TEMPORAL_DENOISING
3981 if (cpi->oxcf.noise_sensitivity > 0 && cpi->use_svc)
3982 vp9_denoiser_reset_on_first_frame(cpi);
3985 // Scene detection is always used for VBR mode or screen-content case.
3986 // For other cases (e.g., CBR mode) use it for 5 <= speed < 8 for now
3987 // (need to check encoding time cost for doing this for speed 8).
3988 cpi->rc.high_source_sad = 0;
3989 cpi->rc.hybrid_intra_scene_change = 0;
3990 cpi->rc.re_encode_maxq_scene_change = 0;
3991 if (cm->show_frame && cpi->oxcf.mode == REALTIME &&
3992 (cpi->oxcf.rc_mode == VPX_VBR ||
3993 cpi->oxcf.content == VP9E_CONTENT_SCREEN ||
3994 (cpi->oxcf.speed >= 5 && cpi->oxcf.speed < 8)))
3995 vp9_scene_detection_onepass(cpi);
3997 if (svc->spatial_layer_id == svc->first_spatial_layer_to_encode) {
3998 svc->high_source_sad_superframe = cpi->rc.high_source_sad;
3999 svc->high_num_blocks_with_motion = cpi->rc.high_num_blocks_with_motion;
4000 // On scene change reset temporal layer pattern to TL0.
4001 // Note that if the base/lower spatial layers are skipped: instead of
4002 // inserting base layer here, we force max-q for the next superframe
4003 // with lower spatial layers: this is done in vp9_encodedframe_overshoot()
4004 // when max-q is decided for the current layer.
4005 // Only do this reset for bypass/flexible mode.
4006 if (svc->high_source_sad_superframe && svc->temporal_layer_id > 0 &&
4007 svc->temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS) {
4008 // rc->high_source_sad will get reset so copy it to restore it.
4009 int tmp_high_source_sad = cpi->rc.high_source_sad;
4010 vp9_svc_reset_temporal_layers(cpi, cm->frame_type == KEY_FRAME);
4011 cpi->rc.high_source_sad = tmp_high_source_sad;
4015 vp9_update_noise_estimate(cpi);
4017 // For 1 pass CBR, check if we are dropping this frame.
4018 // Never drop on key frame, if base layer is key for svc,
4019 // on scene change, or if superframe has layer sync.
4020 if ((cpi->rc.high_source_sad || svc->high_source_sad_superframe) &&
4021 !(cpi->rc.use_post_encode_drop && svc->last_layer_dropped[0]))
4022 no_drop_scene_change = 1;
4023 if (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == VPX_CBR &&
4024 !frame_is_intra_only(cm) && !no_drop_scene_change &&
4025 !svc->superframe_has_layer_sync &&
4027 !svc->layer_context[svc->temporal_layer_id].is_key_frame)) {
4028 if (vp9_rc_drop_frame(cpi)) return 0;
4031 // For 1 pass CBR SVC, only ZEROMV is allowed for spatial reference frame
4032 // when svc->force_zero_mode_spatial_ref = 1. Under those conditions we can
4033 // avoid this frame-level upsampling (for non intra_only frames).
4034 if (frame_is_intra_only(cm) == 0 &&
4035 !(is_one_pass_cbr_svc(cpi) && svc->force_zero_mode_spatial_ref)) {
4036 vp9_scale_references(cpi);
4039 set_size_independent_vars(cpi);
4040 set_size_dependent_vars(cpi, &q, &bottom_index, &top_index);
4042 // search method and step parameter might be changed in speed settings.
4043 init_motion_estimation(cpi);
4045 if (cpi->sf.copy_partition_flag) alloc_copy_partition_data(cpi);
4047 if (cpi->sf.svc_use_lowres_part &&
4048 svc->spatial_layer_id == svc->number_spatial_layers - 2) {
4049 if (svc->prev_partition_svc == NULL) {
4051 cm, svc->prev_partition_svc,
4052 (BLOCK_SIZE *)vpx_calloc(cm->mi_stride * cm->mi_rows,
4053 sizeof(*svc->prev_partition_svc)));
4057 // TODO(jianj): Look into issue of skin detection with high bitdepth.
4058 if (cm->bit_depth == 8 && cpi->oxcf.speed >= 5 && cpi->oxcf.pass == 0 &&
4059 cpi->oxcf.rc_mode == VPX_CBR &&
4060 cpi->oxcf.content != VP9E_CONTENT_SCREEN &&
4061 cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
4062 cpi->use_skin_detection = 1;
4065 // Enable post encode frame dropping for CBR on non key frame, when
4066 // ext_use_post_encode_drop is specified by user.
4067 cpi->rc.use_post_encode_drop = cpi->rc.ext_use_post_encode_drop &&
4068 cpi->oxcf.rc_mode == VPX_CBR &&
4069 cm->frame_type != KEY_FRAME;
4071 vp9_set_quantizer(cm, q);
4072 vp9_set_variance_partition_thresholds(cpi, q, 0);
4076 suppress_active_map(cpi);
4079 // On non-zero spatial layer, check for disabling inter-layer
4081 if (svc->spatial_layer_id > 0) vp9_svc_constrain_inter_layer_pred(cpi);
4082 vp9_svc_assert_constraints_pattern(cpi);
4085 if (cpi->rc.last_post_encode_dropped_scene_change) {
4086 cpi->rc.high_source_sad = 1;
4087 svc->high_source_sad_superframe = 1;
4088 // For now disable use_source_sad since Last_Source will not be the previous
4089 // encoded but the dropped one.
4090 cpi->sf.use_source_sad = 0;
4091 cpi->rc.last_post_encode_dropped_scene_change = 0;
4093 // Check if this high_source_sad (scene/slide change) frame should be
4094 // encoded at high/max QP, and if so, set the q and adjust some rate
4095 // control parameters.
4096 if (cpi->sf.overshoot_detection_cbr_rt == FAST_DETECTION_MAXQ &&
4097 (cpi->rc.high_source_sad ||
4098 (cpi->use_svc && svc->high_source_sad_superframe))) {
4099 if (vp9_encodedframe_overshoot(cpi, -1, &q)) {
4100 vp9_set_quantizer(cm, q);
4101 vp9_set_variance_partition_thresholds(cpi, q, 0);
4105 #if !CONFIG_REALTIME_ONLY
4106 // Variance adaptive and in frame q adjustment experiments are mutually
4108 if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
4109 vp9_vaq_frame_setup(cpi);
4110 } else if (cpi->oxcf.aq_mode == EQUATOR360_AQ) {
4111 vp9_360aq_frame_setup(cpi);
4112 } else if (cpi->oxcf.aq_mode == COMPLEXITY_AQ) {
4113 vp9_setup_in_frame_q_adj(cpi);
4114 } else if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ) {
4115 // it may be pretty bad for rate-control,
4116 // and I should handle it somehow
4117 vp9_alt_ref_aq_setup_map(cpi->alt_ref_aq, cpi);
4120 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
4121 vp9_cyclic_refresh_setup(cpi);
4122 } else if (cpi->roi.enabled && !frame_is_intra_only(cm)) {
4125 #if !CONFIG_REALTIME_ONLY
4129 apply_active_map(cpi);
4131 vp9_encode_frame(cpi);
4133 // Check if we should re-encode this frame at high Q because of high
4134 // overshoot based on the encoded frame size. Only for frames where
4135 // high temporal-source SAD is detected.
4136 // For SVC: all spatial layers are checked for re-encoding.
4137 if (cpi->sf.overshoot_detection_cbr_rt == RE_ENCODE_MAXQ &&
4138 (cpi->rc.high_source_sad ||
4139 (cpi->use_svc && svc->high_source_sad_superframe))) {
4141 // Get an estimate of the encoded frame size.
4142 save_coding_context(cpi);
4143 vp9_pack_bitstream(cpi, dest, size);
4144 restore_coding_context(cpi);
4145 frame_size = (int)(*size) << 3;
4146 // Check if encoded frame will overshoot too much, and if so, set the q and
4147 // adjust some rate control parameters, and return to re-encode the frame.
4148 if (vp9_encodedframe_overshoot(cpi, frame_size, &q)) {
4149 vpx_clear_system_state();
4150 vp9_set_quantizer(cm, q);
4151 vp9_set_variance_partition_thresholds(cpi, q, 0);
4152 suppress_active_map(cpi);
4153 // Turn-off cyclic refresh for re-encoded frame.
4154 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
4155 CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
4156 unsigned char *const seg_map = cpi->segmentation_map;
4157 memset(seg_map, 0, cm->mi_rows * cm->mi_cols);
4158 memset(cr->last_coded_q_map, MAXQ,
4159 cm->mi_rows * cm->mi_cols * sizeof(*cr->last_coded_q_map));
4161 vp9_disable_segmentation(&cm->seg);
4163 apply_active_map(cpi);
4164 vp9_encode_frame(cpi);
4168 // Update some stats from cyclic refresh, and check for golden frame update.
4169 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && cm->seg.enabled &&
4170 !frame_is_intra_only(cm))
4171 vp9_cyclic_refresh_postencode(cpi);
4173 // Update the skip mb flag probabilities based on the distribution
4174 // seen in the last encoder iteration.
4175 // update_base_skip_probs(cpi);
4176 vpx_clear_system_state();
4180 #if !CONFIG_REALTIME_ONLY
4181 #define MAX_QSTEP_ADJ 4
4182 static int get_qstep_adj(int rate_excess, int rate_limit) {
4184 rate_limit ? ((rate_excess + rate_limit / 2) / rate_limit) : INT_MAX;
4185 return VPXMIN(qstep, MAX_QSTEP_ADJ);
4188 static void encode_with_recode_loop(VP9_COMP *cpi, size_t *size,
4190 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
4191 VP9_COMMON *const cm = &cpi->common;
4192 RATE_CONTROL *const rc = &cpi->rc;
4193 int bottom_index, top_index;
4195 int loop_at_this_size = 0;
4197 int overshoot_seen = 0;
4198 int undershoot_seen = 0;
4199 int frame_over_shoot_limit;
4200 int frame_under_shoot_limit;
4201 int q = 0, q_low = 0, q_high = 0;
4203 #ifdef AGGRESSIVE_VBR
4207 if (cm->show_existing_frame) {
4208 rc->this_frame_target = 0;
4209 if (is_psnr_calc_enabled(cpi)) set_raw_source_frame(cpi);
4213 set_size_independent_vars(cpi);
4215 enable_acl = cpi->sf.allow_acl ? (cm->frame_type == KEY_FRAME) ||
4216 (cpi->twopass.gf_group.index == 1)
4220 vpx_clear_system_state();
4222 set_frame_size(cpi);
4224 if (loop_count == 0 || cpi->resize_pending != 0) {
4225 set_size_dependent_vars(cpi, &q, &bottom_index, &top_index);
4227 #ifdef AGGRESSIVE_VBR
4228 if (two_pass_first_group_inter(cpi)) {
4229 // Adjustment limits for min and max q
4230 qrange_adj = VPXMAX(1, (top_index - bottom_index) / 2);
4233 VPXMAX(bottom_index - qrange_adj / 2, oxcf->best_allowed_q);
4234 top_index = VPXMIN(oxcf->worst_allowed_q, top_index + qrange_adj / 2);
4237 // TODO(agrange) Scale cpi->max_mv_magnitude if frame-size has changed.
4238 set_mv_search_params(cpi);
4240 // Reset the loop state for new frame size.
4242 undershoot_seen = 0;
4244 // Reconfiguration for change in frame size has concluded.
4245 cpi->resize_pending = 0;
4247 q_low = bottom_index;
4250 loop_at_this_size = 0;
4253 // Decide frame size bounds first time through.
4254 if (loop_count == 0) {
4255 vp9_rc_compute_frame_size_bounds(cpi, rc->this_frame_target,
4256 &frame_under_shoot_limit,
4257 &frame_over_shoot_limit);
4261 vp9_scale_if_required(cm, cpi->un_scaled_source, &cpi->scaled_source,
4262 (oxcf->pass == 0), EIGHTTAP, 0);
4264 // Unfiltered raw source used in metrics calculation if the source
4265 // has been filtered.
4266 if (is_psnr_calc_enabled(cpi)) {
4267 #ifdef ENABLE_KF_DENOISE
4268 if (is_spatial_denoise_enabled(cpi)) {
4269 cpi->raw_source_frame = vp9_scale_if_required(
4270 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
4271 (oxcf->pass == 0), EIGHTTAP, 0);
4273 cpi->raw_source_frame = cpi->Source;
4276 cpi->raw_source_frame = cpi->Source;
4280 if (cpi->unscaled_last_source != NULL)
4281 cpi->Last_Source = vp9_scale_if_required(cm, cpi->unscaled_last_source,
4282 &cpi->scaled_last_source,
4283 (oxcf->pass == 0), EIGHTTAP, 0);
4285 if (frame_is_intra_only(cm) == 0) {
4286 if (loop_count > 0) {
4287 release_scaled_references(cpi);
4289 vp9_scale_references(cpi);
4292 #if CONFIG_RATE_CTRL
4293 // TODO(angiebird): This is a hack for making sure the encoder use the
4294 // external_quantize_index exactly. Avoid this kind of hack later.
4295 if (cpi->encode_command.use_external_quantize_index) {
4296 q = cpi->encode_command.external_quantize_index;
4300 vp9_set_quantizer(cm, q);
4302 if (loop_count == 0) setup_frame(cpi);
4304 // Variance adaptive and in frame q adjustment experiments are mutually
4306 if (oxcf->aq_mode == VARIANCE_AQ) {
4307 vp9_vaq_frame_setup(cpi);
4308 } else if (oxcf->aq_mode == EQUATOR360_AQ) {
4309 vp9_360aq_frame_setup(cpi);
4310 } else if (oxcf->aq_mode == COMPLEXITY_AQ) {
4311 vp9_setup_in_frame_q_adj(cpi);
4312 } else if (oxcf->aq_mode == LOOKAHEAD_AQ) {
4313 vp9_alt_ref_aq_setup_map(cpi->alt_ref_aq, cpi);
4314 } else if (oxcf->aq_mode == PSNR_AQ) {
4315 vp9_psnr_aq_mode_setup(&cm->seg);
4318 vp9_encode_frame(cpi);
4320 // Update the skip mb flag probabilities based on the distribution
4321 // seen in the last encoder iteration.
4322 // update_base_skip_probs(cpi);
4324 vpx_clear_system_state();
4326 // Dummy pack of the bitstream using up to date stats to get an
4327 // accurate estimate of output frame size to determine if we need
4329 if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF) {
4330 save_coding_context(cpi);
4331 if (!cpi->sf.use_nonrd_pick_mode) vp9_pack_bitstream(cpi, dest, size);
4333 rc->projected_frame_size = (int)(*size) << 3;
4335 if (frame_over_shoot_limit == 0) frame_over_shoot_limit = 1;
4338 #if CONFIG_RATE_CTRL
4339 // This part needs to be after save_coding_context() because
4340 // restore_coding_context may be called in the end of this function.
4341 // TODO(angiebird): This is a hack for making sure the encoder use the
4342 // external_quantize_index exactly. Avoid this kind of hack later.
4343 if (cpi->encode_command.use_external_quantize_index) {
4348 if (oxcf->rc_mode == VPX_Q) {
4351 if ((cm->frame_type == KEY_FRAME) && rc->this_key_frame_forced &&
4352 (rc->projected_frame_size < rc->max_frame_bandwidth)) {
4356 int64_t high_err_target = cpi->ambient_err;
4357 int64_t low_err_target = cpi->ambient_err >> 1;
4359 #if CONFIG_VP9_HIGHBITDEPTH
4360 if (cm->use_highbitdepth) {
4361 kf_err = vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4363 kf_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4366 kf_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4367 #endif // CONFIG_VP9_HIGHBITDEPTH
4369 // Prevent possible divide by zero error below for perfect KF
4372 // The key frame is not good enough or we can afford
4373 // to make it better without undue risk of popping.
4374 if ((kf_err > high_err_target &&
4375 rc->projected_frame_size <= frame_over_shoot_limit) ||
4376 (kf_err > low_err_target &&
4377 rc->projected_frame_size <= frame_under_shoot_limit)) {
4379 q_high = q > q_low ? q - 1 : q_low;
4382 q = (int)((q * high_err_target) / kf_err);
4383 q = VPXMIN(q, (q_high + q_low) >> 1);
4384 } else if (kf_err < low_err_target &&
4385 rc->projected_frame_size >= frame_under_shoot_limit) {
4386 // The key frame is much better than the previous frame
4388 q_low = q < q_high ? q + 1 : q_high;
4391 q = (int)((q * low_err_target) / kf_err);
4392 q = VPXMIN(q, (q_high + q_low + 1) >> 1);
4395 // Clamp Q to upper and lower limits:
4396 q = clamp(q, q_low, q_high);
4399 } else if (recode_loop_test(cpi, frame_over_shoot_limit,
4400 frame_under_shoot_limit, q,
4401 VPXMAX(q_high, top_index), bottom_index)) {
4402 // Is the projected frame size out of range and are we allowed
4403 // to attempt to recode.
4408 if (cpi->resize_pending == 1) {
4409 // Change in frame size so go back around the recode loop.
4410 cpi->rc.frame_size_selector =
4411 SCALE_STEP1 - cpi->rc.frame_size_selector;
4412 cpi->rc.next_frame_size_selector = cpi->rc.frame_size_selector;
4414 #if CONFIG_INTERNAL_STATS
4415 ++cpi->tot_recode_hits;
4422 // Frame size out of permitted range:
4423 // Update correction factor & compute new Q to try...
4425 // Frame is too large
4426 if (rc->projected_frame_size > rc->this_frame_target) {
4427 // Special case if the projected size is > the max allowed.
4428 if ((q == q_high) &&
4429 ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
4430 (!rc->is_src_frame_alt_ref &&
4431 (rc->projected_frame_size >=
4432 big_rate_miss_high_threshold(cpi))))) {
4433 int max_rate = VPXMAX(1, VPXMIN(rc->max_frame_bandwidth,
4434 big_rate_miss_high_threshold(cpi)));
4436 q_val_high = vp9_convert_qindex_to_q(q_high, cm->bit_depth);
4438 q_val_high * ((double)rc->projected_frame_size / max_rate);
4439 q_high = vp9_convert_q_to_qindex(q_val_high, cm->bit_depth);
4440 q_high = clamp(q_high, rc->best_quality, rc->worst_quality);
4443 // Raise Qlow as to at least the current value
4445 get_qstep_adj(rc->projected_frame_size, rc->this_frame_target);
4446 q_low = VPXMIN(q + qstep, q_high);
4448 if (undershoot_seen || loop_at_this_size > 1) {
4449 // Update rate_correction_factor unless
4450 vp9_rc_update_rate_correction_factors(cpi);
4452 q = (q_high + q_low + 1) / 2;
4454 // Update rate_correction_factor unless
4455 vp9_rc_update_rate_correction_factors(cpi);
4457 q = vp9_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4458 VPXMAX(q_high, top_index));
4460 while (q < q_low && retries < 10) {
4461 vp9_rc_update_rate_correction_factors(cpi);
4462 q = vp9_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4463 VPXMAX(q_high, top_index));
4470 // Frame is too small
4472 get_qstep_adj(rc->this_frame_target, rc->projected_frame_size);
4473 q_high = VPXMAX(q - qstep, q_low);
4475 if (overshoot_seen || loop_at_this_size > 1) {
4476 vp9_rc_update_rate_correction_factors(cpi);
4477 q = (q_high + q_low) / 2;
4479 vp9_rc_update_rate_correction_factors(cpi);
4480 q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
4481 VPXMIN(q_low, bottom_index), top_index);
4482 // Special case reset for qlow for constrained quality.
4483 // This should only trigger where there is very substantial
4484 // undershoot on a frame and the auto cq level is above
4485 // the user passsed in value.
4486 if (oxcf->rc_mode == VPX_CQ && q < q_low) {
4490 while (q > q_high && retries < 10) {
4491 vp9_rc_update_rate_correction_factors(cpi);
4492 q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
4493 VPXMIN(q_low, bottom_index), top_index);
4497 undershoot_seen = 1;
4500 // Clamp Q to upper and lower limits:
4501 q = clamp(q, q_low, q_high);
4503 loop = (q != last_q);
4509 // Special case for overlay frame.
4510 if (rc->is_src_frame_alt_ref &&
4511 rc->projected_frame_size < rc->max_frame_bandwidth)
4516 ++loop_at_this_size;
4518 #if CONFIG_INTERNAL_STATS
4519 ++cpi->tot_recode_hits;
4523 if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF)
4524 if (loop || !enable_acl) restore_coding_context(cpi);
4527 #ifdef AGGRESSIVE_VBR
4528 if (two_pass_first_group_inter(cpi)) {
4529 cpi->twopass.active_worst_quality =
4530 VPXMIN(q + qrange_adj, oxcf->worst_allowed_q);
4531 } else if (!frame_is_kf_gf_arf(cpi)) {
4533 if (!frame_is_kf_gf_arf(cpi)) {
4535 // Have we been forced to adapt Q outside the expected range by an extreme
4536 // rate miss. If so adjust the active maxQ for the subsequent frames.
4537 if (!rc->is_src_frame_alt_ref && (q > cpi->twopass.active_worst_quality)) {
4538 cpi->twopass.active_worst_quality = q;
4539 } else if (oxcf->vbr_corpus_complexity && q == q_low &&
4540 rc->projected_frame_size < rc->this_frame_target) {
4541 cpi->twopass.active_worst_quality =
4542 VPXMAX(q, cpi->twopass.active_worst_quality - 1);
4547 // Skip recoding, if model diff is below threshold
4548 const int thresh = compute_context_model_thresh(cpi);
4549 const int diff = compute_context_model_diff(cm);
4550 if (diff < thresh) {
4551 vpx_clear_system_state();
4552 restore_coding_context(cpi);
4556 vp9_encode_frame(cpi);
4557 vpx_clear_system_state();
4558 restore_coding_context(cpi);
4561 #endif // !CONFIG_REALTIME_ONLY
4563 static int get_ref_frame_flags(const VP9_COMP *cpi) {
4564 const int *const map = cpi->common.ref_frame_map;
4565 const int gold_is_last = map[cpi->gld_fb_idx] == map[cpi->lst_fb_idx];
4566 const int alt_is_last = map[cpi->alt_fb_idx] == map[cpi->lst_fb_idx];
4567 const int gold_is_alt = map[cpi->gld_fb_idx] == map[cpi->alt_fb_idx];
4568 int flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;
4570 if (gold_is_last) flags &= ~VP9_GOLD_FLAG;
4572 if (cpi->rc.frames_till_gf_update_due == INT_MAX &&
4573 (cpi->svc.number_temporal_layers == 1 &&
4574 cpi->svc.number_spatial_layers == 1))
4575 flags &= ~VP9_GOLD_FLAG;
4577 if (alt_is_last) flags &= ~VP9_ALT_FLAG;
4579 if (gold_is_alt) flags &= ~VP9_ALT_FLAG;
4584 static void set_ext_overrides(VP9_COMP *cpi) {
4585 // Overrides the defaults with the externally supplied values with
4586 // vp9_update_reference() and vp9_update_entropy() calls
4587 // Note: The overrides are valid only for the next frame passed
4588 // to encode_frame_to_data_rate() function
4589 if (cpi->ext_refresh_frame_context_pending) {
4590 cpi->common.refresh_frame_context = cpi->ext_refresh_frame_context;
4591 cpi->ext_refresh_frame_context_pending = 0;
4593 if (cpi->ext_refresh_frame_flags_pending) {
4594 cpi->refresh_last_frame = cpi->ext_refresh_last_frame;
4595 cpi->refresh_golden_frame = cpi->ext_refresh_golden_frame;
4596 cpi->refresh_alt_ref_frame = cpi->ext_refresh_alt_ref_frame;
4600 YV12_BUFFER_CONFIG *vp9_svc_twostage_scale(
4601 VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled,
4602 YV12_BUFFER_CONFIG *scaled_temp, INTERP_FILTER filter_type,
4603 int phase_scaler, INTERP_FILTER filter_type2, int phase_scaler2) {
4604 if (cm->mi_cols * MI_SIZE != unscaled->y_width ||
4605 cm->mi_rows * MI_SIZE != unscaled->y_height) {
4606 #if CONFIG_VP9_HIGHBITDEPTH
4607 if (cm->bit_depth == VPX_BITS_8) {
4608 vp9_scale_and_extend_frame(unscaled, scaled_temp, filter_type2,
4610 vp9_scale_and_extend_frame(scaled_temp, scaled, filter_type,
4613 scale_and_extend_frame(unscaled, scaled_temp, (int)cm->bit_depth,
4614 filter_type2, phase_scaler2);
4615 scale_and_extend_frame(scaled_temp, scaled, (int)cm->bit_depth,
4616 filter_type, phase_scaler);
4619 vp9_scale_and_extend_frame(unscaled, scaled_temp, filter_type2,
4621 vp9_scale_and_extend_frame(scaled_temp, scaled, filter_type, phase_scaler);
4622 #endif // CONFIG_VP9_HIGHBITDEPTH
4629 YV12_BUFFER_CONFIG *vp9_scale_if_required(
4630 VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled,
4631 int use_normative_scaler, INTERP_FILTER filter_type, int phase_scaler) {
4632 if (cm->mi_cols * MI_SIZE != unscaled->y_width ||
4633 cm->mi_rows * MI_SIZE != unscaled->y_height) {
4634 #if CONFIG_VP9_HIGHBITDEPTH
4635 if (use_normative_scaler && unscaled->y_width <= (scaled->y_width << 1) &&
4636 unscaled->y_height <= (scaled->y_height << 1))
4637 if (cm->bit_depth == VPX_BITS_8)
4638 vp9_scale_and_extend_frame(unscaled, scaled, filter_type, phase_scaler);
4640 scale_and_extend_frame(unscaled, scaled, (int)cm->bit_depth,
4641 filter_type, phase_scaler);
4643 scale_and_extend_frame_nonnormative(unscaled, scaled, (int)cm->bit_depth);
4645 if (use_normative_scaler && unscaled->y_width <= (scaled->y_width << 1) &&
4646 unscaled->y_height <= (scaled->y_height << 1))
4647 vp9_scale_and_extend_frame(unscaled, scaled, filter_type, phase_scaler);
4649 scale_and_extend_frame_nonnormative(unscaled, scaled);
4650 #endif // CONFIG_VP9_HIGHBITDEPTH
4657 static void set_ref_sign_bias(VP9_COMP *cpi) {
4658 VP9_COMMON *const cm = &cpi->common;
4659 RefCntBuffer *const ref_buffer = get_ref_cnt_buffer(cm, cm->new_fb_idx);
4660 const int cur_frame_index = ref_buffer->frame_index;
4661 MV_REFERENCE_FRAME ref_frame;
4663 for (ref_frame = LAST_FRAME; ref_frame < MAX_REF_FRAMES; ++ref_frame) {
4664 const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
4665 const RefCntBuffer *const ref_cnt_buf =
4666 get_ref_cnt_buffer(&cpi->common, buf_idx);
4668 cm->ref_frame_sign_bias[ref_frame] =
4669 cur_frame_index < ref_cnt_buf->frame_index;
4674 static int setup_interp_filter_search_mask(VP9_COMP *cpi) {
4675 INTERP_FILTER ifilter;
4676 int ref_total[MAX_REF_FRAMES] = { 0 };
4677 MV_REFERENCE_FRAME ref;
4679 if (cpi->common.last_frame_type == KEY_FRAME || cpi->refresh_alt_ref_frame)
4681 for (ref = LAST_FRAME; ref <= ALTREF_FRAME; ++ref)
4682 for (ifilter = EIGHTTAP; ifilter <= EIGHTTAP_SHARP; ++ifilter)
4683 ref_total[ref] += cpi->interp_filter_selected[ref][ifilter];
4685 for (ifilter = EIGHTTAP; ifilter <= EIGHTTAP_SHARP; ++ifilter) {
4686 if ((ref_total[LAST_FRAME] &&
4687 cpi->interp_filter_selected[LAST_FRAME][ifilter] == 0) &&
4688 (ref_total[GOLDEN_FRAME] == 0 ||
4689 cpi->interp_filter_selected[GOLDEN_FRAME][ifilter] * 50 <
4690 ref_total[GOLDEN_FRAME]) &&
4691 (ref_total[ALTREF_FRAME] == 0 ||
4692 cpi->interp_filter_selected[ALTREF_FRAME][ifilter] * 50 <
4693 ref_total[ALTREF_FRAME]))
4694 mask |= 1 << ifilter;
4699 #ifdef ENABLE_KF_DENOISE
4700 // Baseline Kernal weights for denoise
4701 static uint8_t dn_kernal_3[9] = { 1, 2, 1, 2, 4, 2, 1, 2, 1 };
4702 static uint8_t dn_kernal_5[25] = { 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 4,
4703 2, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1 };
4705 static INLINE void add_denoise_point(int centre_val, int data_val, int thresh,
4706 uint8_t point_weight, int *sum_val,
4708 if (abs(centre_val - data_val) <= thresh) {
4709 *sum_weight += point_weight;
4710 *sum_val += (int)data_val * (int)point_weight;
4714 static void spatial_denoise_point(uint8_t *src_ptr, const int stride,
4715 const int strength) {
4718 int thresh = strength;
4719 int kernal_size = 5;
4720 int half_k_size = 2;
4724 uint8_t *kernal_ptr;
4726 // Find the maximum deviation from the source point in the locale.
4727 tmp_ptr = src_ptr - (stride * (half_k_size + 1)) - (half_k_size + 1);
4728 for (i = 0; i < kernal_size + 2; ++i) {
4729 for (j = 0; j < kernal_size + 2; ++j) {
4730 max_diff = VPXMAX(max_diff, abs((int)*src_ptr - (int)tmp_ptr[j]));
4735 // Select the kernal size.
4736 if (max_diff > (strength + (strength >> 1))) {
4739 thresh = thresh >> 1;
4741 kernal_ptr = (kernal_size == 3) ? dn_kernal_3 : dn_kernal_5;
4744 tmp_ptr = src_ptr - (stride * half_k_size) - half_k_size;
4745 for (i = 0; i < kernal_size; ++i) {
4746 for (j = 0; j < kernal_size; ++j) {
4747 add_denoise_point((int)*src_ptr, (int)tmp_ptr[j], thresh, *kernal_ptr,
4748 &sum_val, &sum_weight);
4754 // Update the source value with the new filtered value
4755 *src_ptr = (uint8_t)((sum_val + (sum_weight >> 1)) / sum_weight);
4758 #if CONFIG_VP9_HIGHBITDEPTH
4759 static void highbd_spatial_denoise_point(uint16_t *src_ptr, const int stride,
4760 const int strength) {
4763 int thresh = strength;
4764 int kernal_size = 5;
4765 int half_k_size = 2;
4769 uint8_t *kernal_ptr;
4771 // Find the maximum deviation from the source point in the locale.
4772 tmp_ptr = src_ptr - (stride * (half_k_size + 1)) - (half_k_size + 1);
4773 for (i = 0; i < kernal_size + 2; ++i) {
4774 for (j = 0; j < kernal_size + 2; ++j) {
4775 max_diff = VPXMAX(max_diff, abs((int)src_ptr - (int)tmp_ptr[j]));
4780 // Select the kernal size.
4781 if (max_diff > (strength + (strength >> 1))) {
4784 thresh = thresh >> 1;
4786 kernal_ptr = (kernal_size == 3) ? dn_kernal_3 : dn_kernal_5;
4789 tmp_ptr = src_ptr - (stride * half_k_size) - half_k_size;
4790 for (i = 0; i < kernal_size; ++i) {
4791 for (j = 0; j < kernal_size; ++j) {
4792 add_denoise_point((int)*src_ptr, (int)tmp_ptr[j], thresh, *kernal_ptr,
4793 &sum_val, &sum_weight);
4799 // Update the source value with the new filtered value
4800 *src_ptr = (uint16_t)((sum_val + (sum_weight >> 1)) / sum_weight);
4802 #endif // CONFIG_VP9_HIGHBITDEPTH
4804 // Apply thresholded spatial noise supression to a given buffer.
4805 static void spatial_denoise_buffer(VP9_COMP *cpi, uint8_t *buffer,
4806 const int stride, const int width,
4807 const int height, const int strength) {
4808 VP9_COMMON *const cm = &cpi->common;
4809 uint8_t *src_ptr = buffer;
4813 for (row = 0; row < height; ++row) {
4814 for (col = 0; col < width; ++col) {
4815 #if CONFIG_VP9_HIGHBITDEPTH
4816 if (cm->use_highbitdepth)
4817 highbd_spatial_denoise_point(CONVERT_TO_SHORTPTR(&src_ptr[col]), stride,
4820 spatial_denoise_point(&src_ptr[col], stride, strength);
4822 spatial_denoise_point(&src_ptr[col], stride, strength);
4823 #endif // CONFIG_VP9_HIGHBITDEPTH
4829 // Apply thresholded spatial noise supression to source.
4830 static void spatial_denoise_frame(VP9_COMP *cpi) {
4831 YV12_BUFFER_CONFIG *src = cpi->Source;
4832 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
4833 TWO_PASS *const twopass = &cpi->twopass;
4834 VP9_COMMON *const cm = &cpi->common;
4836 // Base the filter strength on the current active max Q.
4837 const int q = (int)(vp9_convert_qindex_to_q(twopass->active_worst_quality,
4840 VPXMAX(oxcf->arnr_strength >> 2, VPXMIN(oxcf->arnr_strength, (q >> 4)));
4842 // Denoise each of Y,U and V buffers.
4843 spatial_denoise_buffer(cpi, src->y_buffer, src->y_stride, src->y_width,
4844 src->y_height, strength);
4846 strength += (strength >> 1);
4847 spatial_denoise_buffer(cpi, src->u_buffer, src->uv_stride, src->uv_width,
4848 src->uv_height, strength << 1);
4850 spatial_denoise_buffer(cpi, src->v_buffer, src->uv_stride, src->uv_width,
4851 src->uv_height, strength << 1);
4853 #endif // ENABLE_KF_DENOISE
4855 #if !CONFIG_REALTIME_ONLY
4856 static void vp9_try_disable_lookahead_aq(VP9_COMP *cpi, size_t *size,
4858 if (cpi->common.seg.enabled)
4859 if (ALT_REF_AQ_PROTECT_GAIN) {
4860 size_t nsize = *size;
4863 // TODO(yuryg): optimize this, as
4864 // we don't really need to repack
4866 save_coding_context(cpi);
4867 vp9_disable_segmentation(&cpi->common.seg);
4868 vp9_pack_bitstream(cpi, dest, &nsize);
4869 restore_coding_context(cpi);
4871 overhead = (int)*size - (int)nsize;
4873 if (vp9_alt_ref_aq_disable_if(cpi->alt_ref_aq, overhead, (int)*size))
4874 vp9_encode_frame(cpi);
4876 vp9_enable_segmentation(&cpi->common.seg);
4881 static void set_frame_index(VP9_COMP *cpi, VP9_COMMON *cm) {
4882 RefCntBuffer *const ref_buffer = get_ref_cnt_buffer(cm, cm->new_fb_idx);
4885 const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
4886 ref_buffer->frame_index =
4887 cm->current_video_frame + gf_group->arf_src_offset[gf_group->index];
4891 static void set_mb_ssim_rdmult_scaling(VP9_COMP *cpi) {
4892 VP9_COMMON *cm = &cpi->common;
4893 ThreadData *td = &cpi->td;
4894 MACROBLOCK *x = &td->mb;
4895 MACROBLOCKD *xd = &x->e_mbd;
4896 uint8_t *y_buffer = cpi->Source->y_buffer;
4897 const int y_stride = cpi->Source->y_stride;
4898 const int block_size = BLOCK_16X16;
4900 const int num_8x8_w = num_8x8_blocks_wide_lookup[block_size];
4901 const int num_8x8_h = num_8x8_blocks_high_lookup[block_size];
4902 const int num_cols = (cm->mi_cols + num_8x8_w - 1) / num_8x8_w;
4903 const int num_rows = (cm->mi_rows + num_8x8_h - 1) / num_8x8_h;
4904 double log_sum = 0.0;
4907 // Loop through each 64x64 block.
4908 for (row = 0; row < num_rows; ++row) {
4909 for (col = 0; col < num_cols; ++col) {
4911 double var = 0.0, num_of_var = 0.0;
4912 const int index = row * num_cols + col;
4914 for (mi_row = row * num_8x8_h;
4915 mi_row < cm->mi_rows && mi_row < (row + 1) * num_8x8_h; ++mi_row) {
4916 for (mi_col = col * num_8x8_w;
4917 mi_col < cm->mi_cols && mi_col < (col + 1) * num_8x8_w; ++mi_col) {
4919 const int row_offset_y = mi_row << 3;
4920 const int col_offset_y = mi_col << 3;
4922 buf.buf = y_buffer + row_offset_y * y_stride + col_offset_y;
4923 buf.stride = y_stride;
4925 // In order to make SSIM_VAR_SCALE in a same scale for both 8 bit
4926 // and high bit videos, the variance needs to be divided by 2.0 or
4928 // TODO(sdeng): need to tune for 12bit videos.
4929 #if CONFIG_VP9_HIGHBITDEPTH
4930 if (cpi->Source->flags & YV12_FLAG_HIGHBITDEPTH)
4931 var += vp9_high_get_sby_variance(cpi, &buf, BLOCK_8X8, xd->bd);
4934 var += vp9_get_sby_variance(cpi, &buf, BLOCK_8X8);
4939 var = var / num_of_var / 64.0;
4941 // Curve fitting with an exponential model on all 16x16 blocks from the
4943 var = 67.035434 * (1 - exp(-0.0021489 * var)) + 17.492222;
4944 cpi->mi_ssim_rdmult_scaling_factors[index] = var;
4945 log_sum += log(var);
4948 log_sum = exp(log_sum / (double)(num_rows * num_cols));
4950 for (row = 0; row < num_rows; ++row) {
4951 for (col = 0; col < num_cols; ++col) {
4952 const int index = row * num_cols + col;
4953 cpi->mi_ssim_rdmult_scaling_factors[index] /= log_sum;
4960 // Process the wiener variance in 16x16 block basis.
4961 static int qsort_comp(const void *elem1, const void *elem2) {
4962 int a = *((const int *)elem1);
4963 int b = *((const int *)elem2);
4964 if (a > b) return 1;
4965 if (a < b) return -1;
4969 static void init_mb_wiener_var_buffer(VP9_COMP *cpi) {
4970 VP9_COMMON *cm = &cpi->common;
4972 if (cpi->mb_wiener_variance && cpi->mb_wiener_var_rows >= cm->mb_rows &&
4973 cpi->mb_wiener_var_cols >= cm->mb_cols)
4976 vpx_free(cpi->mb_wiener_variance);
4977 cpi->mb_wiener_variance = NULL;
4980 cm, cpi->mb_wiener_variance,
4981 vpx_calloc(cm->mb_rows * cm->mb_cols, sizeof(*cpi->mb_wiener_variance)));
4982 cpi->mb_wiener_var_rows = cm->mb_rows;
4983 cpi->mb_wiener_var_cols = cm->mb_cols;
4986 static void set_mb_wiener_variance(VP9_COMP *cpi) {
4987 VP9_COMMON *cm = &cpi->common;
4988 uint8_t *buffer = cpi->Source->y_buffer;
4989 int buf_stride = cpi->Source->y_stride;
4991 #if CONFIG_VP9_HIGHBITDEPTH
4992 ThreadData *td = &cpi->td;
4993 MACROBLOCK *x = &td->mb;
4994 MACROBLOCKD *xd = &x->e_mbd;
4995 DECLARE_ALIGNED(16, uint16_t, zero_pred16[32 * 32]);
4996 DECLARE_ALIGNED(16, uint8_t, zero_pred8[32 * 32]);
4999 DECLARE_ALIGNED(16, uint8_t, zero_pred[32 * 32]);
5002 DECLARE_ALIGNED(16, int16_t, src_diff[32 * 32]);
5003 DECLARE_ALIGNED(16, tran_low_t, coeff[32 * 32]);
5005 int mb_row, mb_col, count = 0;
5006 // Hard coded operating block size
5007 const int block_size = 16;
5008 const int coeff_count = block_size * block_size;
5009 const TX_SIZE tx_size = TX_16X16;
5011 #if CONFIG_VP9_HIGHBITDEPTH
5012 xd->cur_buf = cpi->Source;
5013 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
5014 zero_pred = CONVERT_TO_BYTEPTR(zero_pred16);
5015 memset(zero_pred16, 0, sizeof(*zero_pred16) * coeff_count);
5017 zero_pred = zero_pred8;
5018 memset(zero_pred8, 0, sizeof(*zero_pred8) * coeff_count);
5021 memset(zero_pred, 0, sizeof(*zero_pred) * coeff_count);
5024 cpi->norm_wiener_variance = 0;
5026 for (mb_row = 0; mb_row < cm->mb_rows; ++mb_row) {
5027 for (mb_col = 0; mb_col < cm->mb_cols; ++mb_col) {
5029 int16_t median_val = 0;
5030 uint8_t *mb_buffer =
5031 buffer + mb_row * block_size * buf_stride + mb_col * block_size;
5032 int64_t wiener_variance = 0;
5034 #if CONFIG_VP9_HIGHBITDEPTH
5035 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
5036 vpx_highbd_subtract_block(block_size, block_size, src_diff, block_size,
5037 mb_buffer, buf_stride, zero_pred, block_size,
5039 highbd_wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
5041 vpx_subtract_block(block_size, block_size, src_diff, block_size,
5042 mb_buffer, buf_stride, zero_pred, block_size);
5043 wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
5046 vpx_subtract_block(block_size, block_size, src_diff, block_size,
5047 mb_buffer, buf_stride, zero_pred, block_size);
5048 wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
5049 #endif // CONFIG_VP9_HIGHBITDEPTH
5052 for (idx = 1; idx < coeff_count; ++idx) coeff[idx] = abs(coeff[idx]);
5054 qsort(coeff, coeff_count - 1, sizeof(*coeff), qsort_comp);
5056 // Noise level estimation
5057 median_val = coeff[coeff_count / 2];
5060 for (idx = 1; idx < coeff_count; ++idx) {
5061 int64_t sqr_coeff = (int64_t)coeff[idx] * coeff[idx];
5062 int64_t tmp_coeff = (int64_t)coeff[idx];
5064 tmp_coeff = (sqr_coeff * coeff[idx]) /
5065 (sqr_coeff + (int64_t)median_val * median_val);
5067 wiener_variance += tmp_coeff * tmp_coeff;
5069 cpi->mb_wiener_variance[mb_row * cm->mb_cols + mb_col] =
5070 wiener_variance / coeff_count;
5071 cpi->norm_wiener_variance +=
5072 cpi->mb_wiener_variance[mb_row * cm->mb_cols + mb_col];
5077 if (count) cpi->norm_wiener_variance /= count;
5078 cpi->norm_wiener_variance = VPXMAX(1, cpi->norm_wiener_variance);
5081 static void encode_frame_to_data_rate(VP9_COMP *cpi, size_t *size,
5083 unsigned int *frame_flags) {
5084 VP9_COMMON *const cm = &cpi->common;
5085 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
5086 struct segmentation *const seg = &cm->seg;
5089 // SVC: skip encoding of enhancement layer if the layer target bandwidth = 0.
5090 // No need to set svc.skip_enhancement_layer if whole superframe will be
5092 if (cpi->use_svc && cpi->svc.spatial_layer_id > 0 &&
5093 cpi->oxcf.target_bandwidth == 0 &&
5094 !(cpi->svc.framedrop_mode != LAYER_DROP &&
5095 (cpi->svc.framedrop_mode != CONSTRAINED_FROM_ABOVE_DROP ||
5097 .force_drop_constrained_from_above[cpi->svc.number_spatial_layers -
5099 cpi->svc.drop_spatial_layer[0])) {
5100 cpi->svc.skip_enhancement_layer = 1;
5101 vp9_rc_postencode_update_drop_frame(cpi);
5102 cpi->ext_refresh_frame_flags_pending = 0;
5103 cpi->last_frame_dropped = 1;
5104 cpi->svc.last_layer_dropped[cpi->svc.spatial_layer_id] = 1;
5105 cpi->svc.drop_spatial_layer[cpi->svc.spatial_layer_id] = 1;
5106 vp9_inc_frame_in_layer(cpi);
5110 set_ext_overrides(cpi);
5111 vpx_clear_system_state();
5113 #ifdef ENABLE_KF_DENOISE
5114 // Spatial denoise of key frame.
5115 if (is_spatial_denoise_enabled(cpi)) spatial_denoise_frame(cpi);
5118 if (cm->show_existing_frame == 0) {
5119 // Update frame index
5120 set_frame_index(cpi, cm);
5122 // Set the arf sign bias for this frame.
5123 set_ref_sign_bias(cpi);
5126 // Set default state for segment based loop filter update flags.
5127 cm->lf.mode_ref_delta_update = 0;
5129 if (cpi->oxcf.pass == 2 && cpi->sf.adaptive_interp_filter_search)
5130 cpi->sf.interp_filter_search_mask = setup_interp_filter_search_mask(cpi);
5132 // Set various flags etc to special state if it is a key frame.
5133 if (frame_is_intra_only(cm)) {
5134 // Reset the loop filter deltas and segmentation map.
5135 vp9_reset_segment_features(&cm->seg);
5137 // If segmentation is enabled force a map update for key frames.
5139 seg->update_map = 1;
5140 seg->update_data = 1;
5143 // The alternate reference frame cannot be active for a key frame.
5144 cpi->rc.source_alt_ref_active = 0;
5146 cm->error_resilient_mode = oxcf->error_resilient_mode;
5147 cm->frame_parallel_decoding_mode = oxcf->frame_parallel_decoding_mode;
5149 // By default, encoder assumes decoder can use prev_mi.
5150 if (cm->error_resilient_mode) {
5151 cm->frame_parallel_decoding_mode = 1;
5152 cm->reset_frame_context = 0;
5153 cm->refresh_frame_context = 0;
5154 } else if (cm->intra_only) {
5155 // Only reset the current context.
5156 cm->reset_frame_context = 2;
5160 if (oxcf->tuning == VP8_TUNE_SSIM) set_mb_ssim_rdmult_scaling(cpi);
5162 if (oxcf->aq_mode == PERCEPTUAL_AQ) {
5163 init_mb_wiener_var_buffer(cpi);
5164 set_mb_wiener_variance(cpi);
5167 vpx_clear_system_state();
5169 #if CONFIG_INTERNAL_STATS
5170 memset(cpi->mode_chosen_counts, 0,
5171 MAX_MODES * sizeof(*cpi->mode_chosen_counts));
5173 #if CONFIG_CONSISTENT_RECODE
5174 // Backup to ensure consistency between recodes
5175 save_encode_params(cpi);
5178 if (cpi->sf.recode_loop == DISALLOW_RECODE) {
5179 if (!encode_without_recode_loop(cpi, size, dest)) return;
5181 #if !CONFIG_REALTIME_ONLY
5182 encode_with_recode_loop(cpi, size, dest);
5186 // TODO(jingning): When using show existing frame mode, we assume that the
5187 // current ARF will be directly used as the final reconstructed frame. This is
5188 // an encoder control scheme. One could in principle explore other
5189 // possibilities to arrange the reference frame buffer and their coding order.
5190 if (cm->show_existing_frame) {
5191 ref_cnt_fb(cm->buffer_pool->frame_bufs, &cm->new_fb_idx,
5192 cm->ref_frame_map[cpi->alt_fb_idx]);
5195 #if !CONFIG_REALTIME_ONLY
5196 // Disable segmentation if it decrease rate/distortion ratio
5197 if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ)
5198 vp9_try_disable_lookahead_aq(cpi, size, dest);
5201 #if CONFIG_VP9_TEMPORAL_DENOISING
5202 #ifdef OUTPUT_YUV_DENOISED
5203 if (oxcf->noise_sensitivity > 0 && denoise_svc(cpi)) {
5204 vpx_write_yuv_frame(yuv_denoised_file,
5205 &cpi->denoiser.running_avg_y[INTRA_FRAME]);
5209 #ifdef OUTPUT_YUV_SKINMAP
5210 if (cpi->common.current_video_frame > 1) {
5211 vp9_output_skin_map(cpi, yuv_skinmap_file);
5215 // Special case code to reduce pulsing when key frames are forced at a
5216 // fixed interval. Note the reconstruction error if it is the frame before
5217 // the force key frame
5218 if (cpi->rc.next_key_frame_forced && cpi->rc.frames_to_key == 1) {
5219 #if CONFIG_VP9_HIGHBITDEPTH
5220 if (cm->use_highbitdepth) {
5222 vpx_highbd_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));
5227 cpi->ambient_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5228 #endif // CONFIG_VP9_HIGHBITDEPTH
5231 // If the encoder forced a KEY_FRAME decision
5232 if (cm->frame_type == KEY_FRAME) cpi->refresh_last_frame = 1;
5234 cm->frame_to_show = get_frame_new_buffer(cm);
5235 cm->frame_to_show->color_space = cm->color_space;
5236 cm->frame_to_show->color_range = cm->color_range;
5237 cm->frame_to_show->render_width = cm->render_width;
5238 cm->frame_to_show->render_height = cm->render_height;
5240 // Pick the loop filter level for the frame.
5241 loopfilter_frame(cpi, cm);
5243 if (cpi->rc.use_post_encode_drop) save_coding_context(cpi);
5245 // build the bitstream
5246 vp9_pack_bitstream(cpi, dest, size);
5248 if (cpi->rc.use_post_encode_drop && cm->base_qindex < cpi->rc.worst_quality &&
5249 cpi->svc.spatial_layer_id == 0 && post_encode_drop_cbr(cpi, size)) {
5250 restore_coding_context(cpi);
5254 cpi->last_frame_dropped = 0;
5255 cpi->svc.last_layer_dropped[cpi->svc.spatial_layer_id] = 0;
5256 if (cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1)
5257 cpi->svc.num_encoded_top_layer++;
5259 // Keep track of the frame buffer index updated/refreshed for the
5260 // current encoded TL0 superframe.
5261 if (cpi->svc.temporal_layer_id == 0) {
5262 if (cpi->refresh_last_frame)
5263 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->lst_fb_idx;
5264 else if (cpi->refresh_golden_frame)
5265 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->gld_fb_idx;
5266 else if (cpi->refresh_alt_ref_frame)
5267 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->alt_fb_idx;
5270 if (cm->seg.update_map) update_reference_segmentation_map(cpi);
5272 if (frame_is_intra_only(cm) == 0) {
5273 release_scaled_references(cpi);
5275 vp9_update_reference_frames(cpi);
5277 if (!cm->show_existing_frame) {
5278 for (t = TX_4X4; t <= TX_32X32; ++t) {
5279 full_to_model_counts(cpi->td.counts->coef[t],
5280 cpi->td.rd_counts.coef_counts[t]);
5283 if (!cm->error_resilient_mode && !cm->frame_parallel_decoding_mode) {
5284 if (!frame_is_intra_only(cm)) {
5285 vp9_adapt_mode_probs(cm);
5286 vp9_adapt_mv_probs(cm, cm->allow_high_precision_mv);
5288 vp9_adapt_coef_probs(cm);
5292 cpi->ext_refresh_frame_flags_pending = 0;
5294 if (cpi->refresh_golden_frame == 1)
5295 cpi->frame_flags |= FRAMEFLAGS_GOLDEN;
5297 cpi->frame_flags &= ~FRAMEFLAGS_GOLDEN;
5299 if (cpi->refresh_alt_ref_frame == 1)
5300 cpi->frame_flags |= FRAMEFLAGS_ALTREF;
5302 cpi->frame_flags &= ~FRAMEFLAGS_ALTREF;
5304 cpi->ref_frame_flags = get_ref_frame_flags(cpi);
5306 cm->last_frame_type = cm->frame_type;
5308 vp9_rc_postencode_update(cpi, *size);
5310 *size = VPXMAX(1, *size);
5313 output_frame_level_debug_stats(cpi);
5316 if (cm->frame_type == KEY_FRAME) {
5317 // Tell the caller that the frame was coded as a key frame
5318 *frame_flags = cpi->frame_flags | FRAMEFLAGS_KEY;
5320 *frame_flags = cpi->frame_flags & ~FRAMEFLAGS_KEY;
5323 // Clear the one shot update flags for segmentation map and mode/ref loop
5325 cm->seg.update_map = 0;
5326 cm->seg.update_data = 0;
5327 cm->lf.mode_ref_delta_update = 0;
5329 // keep track of the last coded dimensions
5330 cm->last_width = cm->width;
5331 cm->last_height = cm->height;
5333 // reset to normal state now that we are done.
5334 if (!cm->show_existing_frame) {
5335 cm->last_show_frame = cm->show_frame;
5336 cm->prev_frame = cm->cur_frame;
5339 if (cm->show_frame) {
5340 vp9_swap_mi_and_prev_mi(cm);
5341 // Don't increment frame counters if this was an altref buffer
5342 // update not a real frame
5343 ++cm->current_video_frame;
5344 if (cpi->use_svc) vp9_inc_frame_in_layer(cpi);
5349 .layer_context[cpi->svc.spatial_layer_id *
5350 cpi->svc.number_temporal_layers +
5351 cpi->svc.temporal_layer_id]
5352 .last_frame_type = cm->frame_type;
5353 // Reset layer_sync back to 0 for next frame.
5354 cpi->svc.spatial_layer_sync[cpi->svc.spatial_layer_id] = 0;
5357 cpi->force_update_segmentation = 0;
5359 #if !CONFIG_REALTIME_ONLY
5360 if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ)
5361 vp9_alt_ref_aq_unset_all(cpi->alt_ref_aq, cpi);
5364 cpi->svc.previous_frame_is_intra_only = cm->intra_only;
5365 cpi->svc.set_intra_only_frame = 0;
5368 static void SvcEncode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5369 unsigned int *frame_flags) {
5370 vp9_rc_get_svc_params(cpi);
5371 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5374 static void Pass0Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5375 unsigned int *frame_flags) {
5376 if (cpi->oxcf.rc_mode == VPX_CBR) {
5377 vp9_rc_get_one_pass_cbr_params(cpi);
5379 vp9_rc_get_one_pass_vbr_params(cpi);
5381 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5384 #if !CONFIG_REALTIME_ONLY
5385 static void Pass2Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5386 unsigned int *frame_flags) {
5387 cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED;
5388 #if CONFIG_MISMATCH_DEBUG
5389 mismatch_move_frame_idx_w();
5391 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5393 #endif // !CONFIG_REALTIME_ONLY
5395 int vp9_receive_raw_frame(VP9_COMP *cpi, vpx_enc_frame_flags_t frame_flags,
5396 YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
5398 VP9_COMMON *const cm = &cpi->common;
5399 struct vpx_usec_timer timer;
5401 const int subsampling_x = sd->subsampling_x;
5402 const int subsampling_y = sd->subsampling_y;
5403 #if CONFIG_VP9_HIGHBITDEPTH
5404 const int use_highbitdepth = (sd->flags & YV12_FLAG_HIGHBITDEPTH) != 0;
5406 const int use_highbitdepth = 0;
5409 update_initial_width(cpi, use_highbitdepth, subsampling_x, subsampling_y);
5410 #if CONFIG_VP9_TEMPORAL_DENOISING
5411 setup_denoiser_buffer(cpi);
5414 alloc_raw_frame_buffers(cpi);
5416 vpx_usec_timer_start(&timer);
5418 if (vp9_lookahead_push(cpi->lookahead, sd, time_stamp, end_time,
5419 use_highbitdepth, frame_flags))
5421 vpx_usec_timer_mark(&timer);
5422 cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
5424 if ((cm->profile == PROFILE_0 || cm->profile == PROFILE_2) &&
5425 (subsampling_x != 1 || subsampling_y != 1)) {
5426 vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM,
5427 "Non-4:2:0 color format requires profile 1 or 3");
5430 if ((cm->profile == PROFILE_1 || cm->profile == PROFILE_3) &&
5431 (subsampling_x == 1 && subsampling_y == 1)) {
5432 vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM,
5433 "4:2:0 color format requires profile 0 or 2");
5440 static int frame_is_reference(const VP9_COMP *cpi) {
5441 const VP9_COMMON *cm = &cpi->common;
5443 return cm->frame_type == KEY_FRAME || cpi->refresh_last_frame ||
5444 cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame ||
5445 cm->refresh_frame_context || cm->lf.mode_ref_delta_update ||
5446 cm->seg.update_map || cm->seg.update_data;
5449 static void adjust_frame_rate(VP9_COMP *cpi,
5450 const struct lookahead_entry *source) {
5451 int64_t this_duration;
5454 if (source->ts_start == cpi->first_time_stamp_ever) {
5455 this_duration = source->ts_end - source->ts_start;
5458 int64_t last_duration =
5459 cpi->last_end_time_stamp_seen - cpi->last_time_stamp_seen;
5461 this_duration = source->ts_end - cpi->last_end_time_stamp_seen;
5463 // do a step update if the duration changes by 10%
5465 step = (int)((this_duration - last_duration) * 10 / last_duration);
5468 if (this_duration) {
5470 vp9_new_framerate(cpi, 10000000.0 / this_duration);
5472 // Average this frame's rate into the last second's average
5473 // frame rate. If we haven't seen 1 second yet, then average
5474 // over the whole interval seen.
5475 const double interval = VPXMIN(
5476 (double)(source->ts_end - cpi->first_time_stamp_ever), 10000000.0);
5477 double avg_duration = 10000000.0 / cpi->framerate;
5478 avg_duration *= (interval - avg_duration + this_duration);
5479 avg_duration /= interval;
5481 vp9_new_framerate(cpi, 10000000.0 / avg_duration);
5484 cpi->last_time_stamp_seen = source->ts_start;
5485 cpi->last_end_time_stamp_seen = source->ts_end;
5488 // Returns 0 if this is not an alt ref else the offset of the source frame
5489 // used as the arf midpoint.
5490 static int get_arf_src_index(VP9_COMP *cpi) {
5491 RATE_CONTROL *const rc = &cpi->rc;
5492 int arf_src_index = 0;
5493 if (is_altref_enabled(cpi)) {
5494 if (cpi->oxcf.pass == 2) {
5495 const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
5496 if (gf_group->update_type[gf_group->index] == ARF_UPDATE) {
5497 arf_src_index = gf_group->arf_src_offset[gf_group->index];
5499 } else if (rc->source_alt_ref_pending) {
5500 arf_src_index = rc->frames_till_gf_update_due;
5503 return arf_src_index;
5506 static void check_src_altref(VP9_COMP *cpi,
5507 const struct lookahead_entry *source) {
5508 RATE_CONTROL *const rc = &cpi->rc;
5510 if (cpi->oxcf.pass == 2) {
5511 const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
5512 rc->is_src_frame_alt_ref =
5513 (gf_group->update_type[gf_group->index] == OVERLAY_UPDATE);
5515 rc->is_src_frame_alt_ref =
5516 cpi->alt_ref_source && (source == cpi->alt_ref_source);
5519 if (rc->is_src_frame_alt_ref) {
5520 // Current frame is an ARF overlay frame.
5521 cpi->alt_ref_source = NULL;
5523 // Don't refresh the last buffer for an ARF overlay frame. It will
5524 // become the GF so preserve last as an alternative prediction option.
5525 cpi->refresh_last_frame = 0;
5529 #if CONFIG_INTERNAL_STATS
5530 static void adjust_image_stat(double y, double u, double v, double all,
5535 s->stat[ALL] += all;
5536 s->worst = VPXMIN(s->worst, all);
5538 #endif // CONFIG_INTERNAL_STATS
5540 // Adjust the maximum allowable frame size for the target level.
5541 static void level_rc_framerate(VP9_COMP *cpi, int arf_src_index) {
5542 RATE_CONTROL *const rc = &cpi->rc;
5543 LevelConstraint *const ls = &cpi->level_constraint;
5544 VP9_COMMON *const cm = &cpi->common;
5545 const double max_cpb_size = ls->max_cpb_size;
5546 vpx_clear_system_state();
5547 rc->max_frame_bandwidth = VPXMIN(rc->max_frame_bandwidth, ls->max_frame_size);
5548 if (frame_is_intra_only(cm)) {
5549 rc->max_frame_bandwidth =
5550 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.5));
5551 } else if (arf_src_index > 0) {
5552 rc->max_frame_bandwidth =
5553 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.4));
5555 rc->max_frame_bandwidth =
5556 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.2));
5560 static void update_level_info(VP9_COMP *cpi, size_t *size, int arf_src_index) {
5561 VP9_COMMON *const cm = &cpi->common;
5562 Vp9LevelInfo *const level_info = &cpi->level_info;
5563 Vp9LevelSpec *const level_spec = &level_info->level_spec;
5564 Vp9LevelStats *const level_stats = &level_info->level_stats;
5566 uint64_t luma_samples, dur_end;
5567 const uint32_t luma_pic_size = cm->width * cm->height;
5568 const uint32_t luma_pic_breadth = VPXMAX(cm->width, cm->height);
5569 LevelConstraint *const level_constraint = &cpi->level_constraint;
5570 const int8_t level_index = level_constraint->level_index;
5571 double cpb_data_size;
5573 vpx_clear_system_state();
5575 // update level_stats
5576 level_stats->total_compressed_size += *size;
5577 if (cm->show_frame) {
5578 level_stats->total_uncompressed_size +=
5580 2 * (luma_pic_size >> (cm->subsampling_x + cm->subsampling_y));
5581 level_stats->time_encoded =
5582 (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) /
5583 (double)TICKS_PER_SEC;
5586 if (arf_src_index > 0) {
5587 if (!level_stats->seen_first_altref) {
5588 level_stats->seen_first_altref = 1;
5589 } else if (level_stats->frames_since_last_altref <
5590 level_spec->min_altref_distance) {
5591 level_spec->min_altref_distance = level_stats->frames_since_last_altref;
5593 level_stats->frames_since_last_altref = 0;
5595 ++level_stats->frames_since_last_altref;
5598 if (level_stats->frame_window_buffer.len < FRAME_WINDOW_SIZE - 1) {
5599 idx = (level_stats->frame_window_buffer.start +
5600 level_stats->frame_window_buffer.len++) %
5603 idx = level_stats->frame_window_buffer.start;
5604 level_stats->frame_window_buffer.start = (idx + 1) % FRAME_WINDOW_SIZE;
5606 level_stats->frame_window_buffer.buf[idx].ts = cpi->last_time_stamp_seen;
5607 level_stats->frame_window_buffer.buf[idx].size = (uint32_t)(*size);
5608 level_stats->frame_window_buffer.buf[idx].luma_samples = luma_pic_size;
5610 if (cm->frame_type == KEY_FRAME) {
5611 level_stats->ref_refresh_map = 0;
5614 level_stats->ref_refresh_map |= vp9_get_refresh_mask(cpi);
5615 // Also need to consider the case where the encoder refers to a buffer
5616 // that has been implicitly refreshed after encoding a keyframe.
5617 if (!cm->intra_only) {
5618 level_stats->ref_refresh_map |= (1 << cpi->lst_fb_idx);
5619 level_stats->ref_refresh_map |= (1 << cpi->gld_fb_idx);
5620 level_stats->ref_refresh_map |= (1 << cpi->alt_fb_idx);
5622 for (i = 0; i < REF_FRAMES; ++i) {
5623 count += (level_stats->ref_refresh_map >> i) & 1;
5625 if (count > level_spec->max_ref_frame_buffers) {
5626 level_spec->max_ref_frame_buffers = count;
5630 // update average_bitrate
5631 level_spec->average_bitrate = (double)level_stats->total_compressed_size /
5632 125.0 / level_stats->time_encoded;
5634 // update max_luma_sample_rate
5636 for (i = 0; i < level_stats->frame_window_buffer.len; ++i) {
5637 idx = (level_stats->frame_window_buffer.start +
5638 level_stats->frame_window_buffer.len - 1 - i) %
5641 dur_end = level_stats->frame_window_buffer.buf[idx].ts;
5643 if (dur_end - level_stats->frame_window_buffer.buf[idx].ts >=
5647 luma_samples += level_stats->frame_window_buffer.buf[idx].luma_samples;
5649 if (luma_samples > level_spec->max_luma_sample_rate) {
5650 level_spec->max_luma_sample_rate = luma_samples;
5653 // update max_cpb_size
5655 for (i = 0; i < CPB_WINDOW_SIZE; ++i) {
5656 if (i >= level_stats->frame_window_buffer.len) break;
5657 idx = (level_stats->frame_window_buffer.start +
5658 level_stats->frame_window_buffer.len - 1 - i) %
5660 cpb_data_size += level_stats->frame_window_buffer.buf[idx].size;
5662 cpb_data_size = cpb_data_size / 125.0;
5663 if (cpb_data_size > level_spec->max_cpb_size) {
5664 level_spec->max_cpb_size = cpb_data_size;
5667 // update max_luma_picture_size
5668 if (luma_pic_size > level_spec->max_luma_picture_size) {
5669 level_spec->max_luma_picture_size = luma_pic_size;
5672 // update max_luma_picture_breadth
5673 if (luma_pic_breadth > level_spec->max_luma_picture_breadth) {
5674 level_spec->max_luma_picture_breadth = luma_pic_breadth;
5677 // update compression_ratio
5678 level_spec->compression_ratio = (double)level_stats->total_uncompressed_size *
5680 level_stats->total_compressed_size / 8.0;
5682 // update max_col_tiles
5683 if (level_spec->max_col_tiles < (1 << cm->log2_tile_cols)) {
5684 level_spec->max_col_tiles = (1 << cm->log2_tile_cols);
5687 if (level_index >= 0 && level_constraint->fail_flag == 0) {
5688 if (level_spec->max_luma_picture_size >
5689 vp9_level_defs[level_index].max_luma_picture_size) {
5690 level_constraint->fail_flag |= (1 << LUMA_PIC_SIZE_TOO_LARGE);
5691 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5692 "Failed to encode to the target level %d. %s",
5693 vp9_level_defs[level_index].level,
5694 level_fail_messages[LUMA_PIC_SIZE_TOO_LARGE]);
5697 if (level_spec->max_luma_picture_breadth >
5698 vp9_level_defs[level_index].max_luma_picture_breadth) {
5699 level_constraint->fail_flag |= (1 << LUMA_PIC_BREADTH_TOO_LARGE);
5700 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5701 "Failed to encode to the target level %d. %s",
5702 vp9_level_defs[level_index].level,
5703 level_fail_messages[LUMA_PIC_BREADTH_TOO_LARGE]);
5706 if ((double)level_spec->max_luma_sample_rate >
5707 (double)vp9_level_defs[level_index].max_luma_sample_rate *
5708 (1 + SAMPLE_RATE_GRACE_P)) {
5709 level_constraint->fail_flag |= (1 << LUMA_SAMPLE_RATE_TOO_LARGE);
5710 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5711 "Failed to encode to the target level %d. %s",
5712 vp9_level_defs[level_index].level,
5713 level_fail_messages[LUMA_SAMPLE_RATE_TOO_LARGE]);
5716 if (level_spec->max_col_tiles > vp9_level_defs[level_index].max_col_tiles) {
5717 level_constraint->fail_flag |= (1 << TOO_MANY_COLUMN_TILE);
5718 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5719 "Failed to encode to the target level %d. %s",
5720 vp9_level_defs[level_index].level,
5721 level_fail_messages[TOO_MANY_COLUMN_TILE]);
5724 if (level_spec->min_altref_distance <
5725 vp9_level_defs[level_index].min_altref_distance) {
5726 level_constraint->fail_flag |= (1 << ALTREF_DIST_TOO_SMALL);
5727 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5728 "Failed to encode to the target level %d. %s",
5729 vp9_level_defs[level_index].level,
5730 level_fail_messages[ALTREF_DIST_TOO_SMALL]);
5733 if (level_spec->max_ref_frame_buffers >
5734 vp9_level_defs[level_index].max_ref_frame_buffers) {
5735 level_constraint->fail_flag |= (1 << TOO_MANY_REF_BUFFER);
5736 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5737 "Failed to encode to the target level %d. %s",
5738 vp9_level_defs[level_index].level,
5739 level_fail_messages[TOO_MANY_REF_BUFFER]);
5742 if (level_spec->max_cpb_size > vp9_level_defs[level_index].max_cpb_size) {
5743 level_constraint->fail_flag |= (1 << CPB_TOO_LARGE);
5744 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5745 "Failed to encode to the target level %d. %s",
5746 vp9_level_defs[level_index].level,
5747 level_fail_messages[CPB_TOO_LARGE]);
5750 // Set an upper bound for the next frame size. It will be used in
5751 // level_rc_framerate() before encoding the next frame.
5753 for (i = 0; i < CPB_WINDOW_SIZE - 1; ++i) {
5754 if (i >= level_stats->frame_window_buffer.len) break;
5755 idx = (level_stats->frame_window_buffer.start +
5756 level_stats->frame_window_buffer.len - 1 - i) %
5758 cpb_data_size += level_stats->frame_window_buffer.buf[idx].size;
5760 cpb_data_size = cpb_data_size / 125.0;
5761 level_constraint->max_frame_size =
5762 (int)((vp9_level_defs[level_index].max_cpb_size - cpb_data_size) *
5764 if (level_stats->frame_window_buffer.len < CPB_WINDOW_SIZE - 1)
5765 level_constraint->max_frame_size >>= 1;
5769 typedef struct GF_PICTURE {
5770 YV12_BUFFER_CONFIG *frame;
5772 FRAME_UPDATE_TYPE update_type;
5775 static void init_gop_frames(VP9_COMP *cpi, GF_PICTURE *gf_picture,
5776 const GF_GROUP *gf_group, int *tpl_group_frames) {
5777 VP9_COMMON *cm = &cpi->common;
5783 int arf_index_stack[MAX_ARF_LAYERS];
5784 int arf_stack_size = 0;
5785 int extend_frame_count = 0;
5786 int pframe_qindex = cpi->tpl_stats[2].base_qindex;
5787 int frame_gop_offset = 0;
5789 RefCntBuffer *frame_bufs = cm->buffer_pool->frame_bufs;
5790 int8_t recon_frame_index[REFS_PER_FRAME + MAX_ARF_LAYERS];
5792 memset(recon_frame_index, -1, sizeof(recon_frame_index));
5793 stack_init(arf_index_stack, MAX_ARF_LAYERS);
5795 // TODO(jingning): To be used later for gf frame type parsing.
5798 for (i = 0; i < FRAME_BUFFERS; ++i) {
5799 if (frame_bufs[i].ref_count == 0) {
5800 alloc_frame_mvs(cm, i);
5801 if (vpx_realloc_frame_buffer(&frame_bufs[i].buf, cm->width, cm->height,
5802 cm->subsampling_x, cm->subsampling_y,
5803 #if CONFIG_VP9_HIGHBITDEPTH
5804 cm->use_highbitdepth,
5806 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
5808 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
5809 "Failed to allocate frame buffer");
5811 recon_frame_index[frame_idx] = i;
5814 if (frame_idx >= REFS_PER_FRAME + cpi->oxcf.enable_auto_arf) break;
5818 for (i = 0; i < REFS_PER_FRAME + 1; ++i) {
5819 assert(recon_frame_index[i] >= 0);
5820 cpi->tpl_recon_frames[i] = &frame_bufs[recon_frame_index[i]].buf;
5823 *tpl_group_frames = 0;
5825 // Initialize Golden reference frame.
5826 gf_picture[0].frame = get_ref_frame_buffer(cpi, GOLDEN_FRAME);
5827 for (i = 0; i < 3; ++i) gf_picture[0].ref_frame[i] = -1;
5828 gf_picture[0].update_type = gf_group->update_type[0];
5830 ++*tpl_group_frames;
5832 // Initialize base layer ARF frame
5833 gf_picture[1].frame = cpi->Source;
5834 gf_picture[1].ref_frame[0] = gld_index;
5835 gf_picture[1].ref_frame[1] = lst_index;
5836 gf_picture[1].ref_frame[2] = alt_index;
5837 gf_picture[1].update_type = gf_group->update_type[1];
5839 ++*tpl_group_frames;
5841 // Initialize P frames
5842 for (frame_idx = 2; frame_idx < MAX_ARF_GOP_SIZE; ++frame_idx) {
5843 struct lookahead_entry *buf;
5844 frame_gop_offset = gf_group->frame_gop_index[frame_idx];
5845 buf = vp9_lookahead_peek(cpi->lookahead, frame_gop_offset - 1);
5847 if (buf == NULL) break;
5849 gf_picture[frame_idx].frame = &buf->img;
5850 gf_picture[frame_idx].ref_frame[0] = gld_index;
5851 gf_picture[frame_idx].ref_frame[1] = lst_index;
5852 gf_picture[frame_idx].ref_frame[2] = alt_index;
5853 gf_picture[frame_idx].update_type = gf_group->update_type[frame_idx];
5855 switch (gf_group->update_type[frame_idx]) {
5857 stack_push(arf_index_stack, alt_index, arf_stack_size);
5859 alt_index = frame_idx;
5861 case LF_UPDATE: lst_index = frame_idx; break;
5862 case OVERLAY_UPDATE:
5863 gld_index = frame_idx;
5864 alt_index = stack_pop(arf_index_stack, arf_stack_size);
5868 lst_index = alt_index;
5869 alt_index = stack_pop(arf_index_stack, arf_stack_size);
5875 ++*tpl_group_frames;
5877 // The length of group of pictures is baseline_gf_interval, plus the
5878 // beginning golden frame from last GOP, plus the last overlay frame in
5880 if (frame_idx == gf_group->gf_group_size) break;
5887 // Extend two frames outside the current gf group.
5888 for (; frame_idx < MAX_LAG_BUFFERS && extend_frame_count < 2; ++frame_idx) {
5889 struct lookahead_entry *buf =
5890 vp9_lookahead_peek(cpi->lookahead, frame_gop_offset - 1);
5892 if (buf == NULL) break;
5894 cpi->tpl_stats[frame_idx].base_qindex = pframe_qindex;
5896 gf_picture[frame_idx].frame = &buf->img;
5897 gf_picture[frame_idx].ref_frame[0] = gld_index;
5898 gf_picture[frame_idx].ref_frame[1] = lst_index;
5899 gf_picture[frame_idx].ref_frame[2] = alt_index;
5900 gf_picture[frame_idx].update_type = LF_UPDATE;
5901 lst_index = frame_idx;
5902 ++*tpl_group_frames;
5903 ++extend_frame_count;
5908 static void init_tpl_stats(VP9_COMP *cpi) {
5910 for (frame_idx = 0; frame_idx < MAX_ARF_GOP_SIZE; ++frame_idx) {
5911 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
5912 memset(tpl_frame->tpl_stats_ptr, 0,
5913 tpl_frame->height * tpl_frame->width *
5914 sizeof(*tpl_frame->tpl_stats_ptr));
5915 tpl_frame->is_valid = 0;
5919 #if CONFIG_NON_GREEDY_MV
5920 static uint32_t full_pixel_motion_search(VP9_COMP *cpi, ThreadData *td,
5921 MotionField *motion_field,
5922 int frame_idx, uint8_t *cur_frame_buf,
5923 uint8_t *ref_frame_buf, int stride,
5924 BLOCK_SIZE bsize, int mi_row,
5925 int mi_col, MV *mv) {
5926 MACROBLOCK *const x = &td->mb;
5927 MACROBLOCKD *const xd = &x->e_mbd;
5928 MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
5930 uint32_t bestsme = UINT_MAX;
5931 const MvLimits tmp_mv_limits = x->mv_limits;
5932 // lambda is used to adjust the importance of motion vector consitency.
5933 // TODO(angiebird): Figure out lambda's proper value.
5934 const int lambda = cpi->tpl_stats[frame_idx].lambda;
5935 int_mv nb_full_mvs[NB_MVS_NUM];
5938 MV best_ref_mv1 = { 0, 0 };
5939 MV best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */
5941 best_ref_mv1_full.col = best_ref_mv1.col >> 3;
5942 best_ref_mv1_full.row = best_ref_mv1.row >> 3;
5944 // Setup frame pointers
5945 x->plane[0].src.buf = cur_frame_buf;
5946 x->plane[0].src.stride = stride;
5947 xd->plane[0].pre[0].buf = ref_frame_buf;
5948 xd->plane[0].pre[0].stride = stride;
5950 step_param = mv_sf->reduce_first_step_size;
5951 step_param = VPXMIN(step_param, MAX_MVSEARCH_STEPS - 2);
5953 vp9_set_mv_search_range(&x->mv_limits, &best_ref_mv1);
5956 vp9_prepare_nb_full_mvs(motion_field, mi_row, mi_col, nb_full_mvs);
5957 vp9_full_pixel_diamond_new(cpi, x, bsize, &best_ref_mv1_full, step_param,
5958 lambda, 1, nb_full_mvs, nb_full_mv_num, mv);
5960 /* restore UMV window */
5961 x->mv_limits = tmp_mv_limits;
5966 static uint32_t sub_pixel_motion_search(VP9_COMP *cpi, ThreadData *td,
5967 uint8_t *cur_frame_buf,
5968 uint8_t *ref_frame_buf, int stride,
5969 BLOCK_SIZE bsize, MV *mv) {
5970 MACROBLOCK *const x = &td->mb;
5971 MACROBLOCKD *const xd = &x->e_mbd;
5972 MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
5973 uint32_t bestsme = UINT_MAX;
5974 uint32_t distortion;
5978 MV best_ref_mv1 = { 0, 0 };
5980 // Setup frame pointers
5981 x->plane[0].src.buf = cur_frame_buf;
5982 x->plane[0].src.stride = stride;
5983 xd->plane[0].pre[0].buf = ref_frame_buf;
5984 xd->plane[0].pre[0].stride = stride;
5986 // TODO(yunqing): may use higher tap interp filter than 2 taps.
5987 // Ignore mv costing by sending NULL pointer instead of cost array
5988 bestsme = cpi->find_fractional_mv_step(
5989 x, mv, &best_ref_mv1, cpi->common.allow_high_precision_mv, x->errorperbit,
5990 &cpi->fn_ptr[bsize], 0, mv_sf->subpel_search_level,
5991 cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL, 0, 0,
5997 #else // CONFIG_NON_GREEDY_MV
5998 static uint32_t motion_compensated_prediction(VP9_COMP *cpi, ThreadData *td,
5999 uint8_t *cur_frame_buf,
6000 uint8_t *ref_frame_buf,
6001 int stride, BLOCK_SIZE bsize,
6003 MACROBLOCK *const x = &td->mb;
6004 MACROBLOCKD *const xd = &x->e_mbd;
6005 MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
6006 const SEARCH_METHODS search_method = NSTEP;
6008 int sadpb = x->sadperbit16;
6009 uint32_t bestsme = UINT_MAX;
6010 uint32_t distortion;
6013 const MvLimits tmp_mv_limits = x->mv_limits;
6015 MV best_ref_mv1 = { 0, 0 };
6016 MV best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */
6018 best_ref_mv1_full.col = best_ref_mv1.col >> 3;
6019 best_ref_mv1_full.row = best_ref_mv1.row >> 3;
6021 // Setup frame pointers
6022 x->plane[0].src.buf = cur_frame_buf;
6023 x->plane[0].src.stride = stride;
6024 xd->plane[0].pre[0].buf = ref_frame_buf;
6025 xd->plane[0].pre[0].stride = stride;
6027 step_param = mv_sf->reduce_first_step_size;
6028 step_param = VPXMIN(step_param, MAX_MVSEARCH_STEPS - 2);
6030 vp9_set_mv_search_range(&x->mv_limits, &best_ref_mv1);
6032 vp9_full_pixel_search(cpi, x, bsize, &best_ref_mv1_full, step_param,
6033 search_method, sadpb, cond_cost_list(cpi, cost_list),
6034 &best_ref_mv1, mv, 0, 0);
6036 /* restore UMV window */
6037 x->mv_limits = tmp_mv_limits;
6039 // TODO(yunqing): may use higher tap interp filter than 2 taps.
6040 // Ignore mv costing by sending NULL pointer instead of cost array
6041 bestsme = cpi->find_fractional_mv_step(
6042 x, mv, &best_ref_mv1, cpi->common.allow_high_precision_mv, x->errorperbit,
6043 &cpi->fn_ptr[bsize], 0, mv_sf->subpel_search_level,
6044 cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL, 0, 0,
6051 static int get_overlap_area(int grid_pos_row, int grid_pos_col, int ref_pos_row,
6052 int ref_pos_col, int block, BLOCK_SIZE bsize) {
6053 int width = 0, height = 0;
6054 int bw = 4 << b_width_log2_lookup[bsize];
6055 int bh = 4 << b_height_log2_lookup[bsize];
6059 width = grid_pos_col + bw - ref_pos_col;
6060 height = grid_pos_row + bh - ref_pos_row;
6063 width = ref_pos_col + bw - grid_pos_col;
6064 height = grid_pos_row + bh - ref_pos_row;
6067 width = grid_pos_col + bw - ref_pos_col;
6068 height = ref_pos_row + bh - grid_pos_row;
6071 width = ref_pos_col + bw - grid_pos_col;
6072 height = ref_pos_row + bh - grid_pos_row;
6077 return width * height;
6080 static int round_floor(int ref_pos, int bsize_pix) {
6083 round = -(1 + (-ref_pos - 1) / bsize_pix);
6085 round = ref_pos / bsize_pix;
6090 static void tpl_model_store(TplDepStats *tpl_stats, int mi_row, int mi_col,
6091 BLOCK_SIZE bsize, int stride) {
6092 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6093 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6094 const TplDepStats *src_stats = &tpl_stats[mi_row * stride + mi_col];
6097 for (idy = 0; idy < mi_height; ++idy) {
6098 for (idx = 0; idx < mi_width; ++idx) {
6099 TplDepStats *tpl_ptr = &tpl_stats[(mi_row + idy) * stride + mi_col + idx];
6100 const int64_t mc_flow = tpl_ptr->mc_flow;
6101 const int64_t mc_ref_cost = tpl_ptr->mc_ref_cost;
6102 *tpl_ptr = *src_stats;
6103 tpl_ptr->mc_flow = mc_flow;
6104 tpl_ptr->mc_ref_cost = mc_ref_cost;
6105 tpl_ptr->mc_dep_cost = tpl_ptr->intra_cost + tpl_ptr->mc_flow;
6110 static void tpl_model_update_b(TplDepFrame *tpl_frame, TplDepStats *tpl_stats,
6111 int mi_row, int mi_col, const BLOCK_SIZE bsize) {
6112 TplDepFrame *ref_tpl_frame = &tpl_frame[tpl_stats->ref_frame_index];
6113 TplDepStats *ref_stats = ref_tpl_frame->tpl_stats_ptr;
6114 MV mv = tpl_stats->mv.as_mv;
6115 int mv_row = mv.row >> 3;
6116 int mv_col = mv.col >> 3;
6118 int ref_pos_row = mi_row * MI_SIZE + mv_row;
6119 int ref_pos_col = mi_col * MI_SIZE + mv_col;
6121 const int bw = 4 << b_width_log2_lookup[bsize];
6122 const int bh = 4 << b_height_log2_lookup[bsize];
6123 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6124 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6125 const int pix_num = bw * bh;
6127 // top-left on grid block location in pixel
6128 int grid_pos_row_base = round_floor(ref_pos_row, bh) * bh;
6129 int grid_pos_col_base = round_floor(ref_pos_col, bw) * bw;
6132 for (block = 0; block < 4; ++block) {
6133 int grid_pos_row = grid_pos_row_base + bh * (block >> 1);
6134 int grid_pos_col = grid_pos_col_base + bw * (block & 0x01);
6136 if (grid_pos_row >= 0 && grid_pos_row < ref_tpl_frame->mi_rows * MI_SIZE &&
6137 grid_pos_col >= 0 && grid_pos_col < ref_tpl_frame->mi_cols * MI_SIZE) {
6138 int overlap_area = get_overlap_area(
6139 grid_pos_row, grid_pos_col, ref_pos_row, ref_pos_col, block, bsize);
6140 int ref_mi_row = round_floor(grid_pos_row, bh) * mi_height;
6141 int ref_mi_col = round_floor(grid_pos_col, bw) * mi_width;
6143 int64_t mc_flow = tpl_stats->mc_dep_cost -
6144 (tpl_stats->mc_dep_cost * tpl_stats->inter_cost) /
6145 tpl_stats->intra_cost;
6149 for (idy = 0; idy < mi_height; ++idy) {
6150 for (idx = 0; idx < mi_width; ++idx) {
6151 TplDepStats *des_stats =
6152 &ref_stats[(ref_mi_row + idy) * ref_tpl_frame->stride +
6153 (ref_mi_col + idx)];
6155 des_stats->mc_flow += (mc_flow * overlap_area) / pix_num;
6156 des_stats->mc_ref_cost +=
6157 ((tpl_stats->intra_cost - tpl_stats->inter_cost) * overlap_area) /
6159 assert(overlap_area >= 0);
6166 static void tpl_model_update(TplDepFrame *tpl_frame, TplDepStats *tpl_stats,
6167 int mi_row, int mi_col, const BLOCK_SIZE bsize) {
6169 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6170 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6172 for (idy = 0; idy < mi_height; ++idy) {
6173 for (idx = 0; idx < mi_width; ++idx) {
6174 TplDepStats *tpl_ptr =
6175 &tpl_stats[(mi_row + idy) * tpl_frame->stride + (mi_col + idx)];
6176 tpl_model_update_b(tpl_frame, tpl_ptr, mi_row + idy, mi_col + idx,
6182 static void get_quantize_error(MACROBLOCK *x, int plane, tran_low_t *coeff,
6183 tran_low_t *qcoeff, tran_low_t *dqcoeff,
6184 TX_SIZE tx_size, int64_t *recon_error,
6186 MACROBLOCKD *const xd = &x->e_mbd;
6187 const struct macroblock_plane *const p = &x->plane[plane];
6188 const struct macroblockd_plane *const pd = &xd->plane[plane];
6189 const scan_order *const scan_order = &vp9_default_scan_orders[tx_size];
6191 int pix_num = 1 << num_pels_log2_lookup[txsize_to_bsize[tx_size]];
6192 const int shift = tx_size == TX_32X32 ? 0 : 2;
6194 #if CONFIG_VP9_HIGHBITDEPTH
6195 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6196 vp9_highbd_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp,
6197 p->quant_fp, qcoeff, dqcoeff, pd->dequant,
6198 &eob, scan_order->scan, scan_order->iscan);
6200 vp9_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp,
6201 p->quant_fp, qcoeff, dqcoeff, pd->dequant, &eob,
6202 scan_order->scan, scan_order->iscan);
6205 vp9_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp, p->quant_fp,
6206 qcoeff, dqcoeff, pd->dequant, &eob, scan_order->scan,
6208 #endif // CONFIG_VP9_HIGHBITDEPTH
6210 *recon_error = vp9_block_error(coeff, dqcoeff, pix_num, sse) >> shift;
6211 *recon_error = VPXMAX(*recon_error, 1);
6213 *sse = (*sse) >> shift;
6214 *sse = VPXMAX(*sse, 1);
6217 #if CONFIG_VP9_HIGHBITDEPTH
6218 void highbd_wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
6220 // TODO(sdeng): Implement SIMD based high bit-depth Hadamard transforms.
6222 case TX_8X8: vpx_highbd_hadamard_8x8(src_diff, bw, coeff); break;
6223 case TX_16X16: vpx_highbd_hadamard_16x16(src_diff, bw, coeff); break;
6224 case TX_32X32: vpx_highbd_hadamard_32x32(src_diff, bw, coeff); break;
6228 #endif // CONFIG_VP9_HIGHBITDEPTH
6230 void wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
6233 case TX_8X8: vpx_hadamard_8x8(src_diff, bw, coeff); break;
6234 case TX_16X16: vpx_hadamard_16x16(src_diff, bw, coeff); break;
6235 case TX_32X32: vpx_hadamard_32x32(src_diff, bw, coeff); break;
6240 static void set_mv_limits(const VP9_COMMON *cm, MACROBLOCK *x, int mi_row,
6242 x->mv_limits.row_min = -((mi_row * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND));
6243 x->mv_limits.row_max =
6244 (cm->mi_rows - 1 - mi_row) * MI_SIZE + (17 - 2 * VP9_INTERP_EXTEND);
6245 x->mv_limits.col_min = -((mi_col * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND));
6246 x->mv_limits.col_max =
6247 ((cm->mi_cols - 1 - mi_col) * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND);
6250 static void mode_estimation(VP9_COMP *cpi, MACROBLOCK *x, MACROBLOCKD *xd,
6251 struct scale_factors *sf, GF_PICTURE *gf_picture,
6252 int frame_idx, TplDepFrame *tpl_frame,
6253 int16_t *src_diff, tran_low_t *coeff,
6254 tran_low_t *qcoeff, tran_low_t *dqcoeff, int mi_row,
6255 int mi_col, BLOCK_SIZE bsize, TX_SIZE tx_size,
6256 YV12_BUFFER_CONFIG *ref_frame[], uint8_t *predictor,
6257 int64_t *recon_error, int64_t *sse) {
6258 VP9_COMMON *cm = &cpi->common;
6259 ThreadData *td = &cpi->td;
6261 const int bw = 4 << b_width_log2_lookup[bsize];
6262 const int bh = 4 << b_height_log2_lookup[bsize];
6263 const int pix_num = bw * bh;
6264 int best_rf_idx = -1;
6266 int64_t best_inter_cost = INT64_MAX;
6269 const InterpKernel *const kernel = vp9_filter_kernels[EIGHTTAP];
6271 int64_t best_intra_cost = INT64_MAX;
6273 PREDICTION_MODE mode;
6274 int mb_y_offset = mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6275 MODE_INFO mi_above, mi_left;
6276 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6277 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6278 TplDepStats *tpl_stats =
6279 &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
6281 xd->mb_to_top_edge = -((mi_row * MI_SIZE) * 8);
6282 xd->mb_to_bottom_edge = ((cm->mi_rows - 1 - mi_row) * MI_SIZE) * 8;
6283 xd->mb_to_left_edge = -((mi_col * MI_SIZE) * 8);
6284 xd->mb_to_right_edge = ((cm->mi_cols - 1 - mi_col) * MI_SIZE) * 8;
6285 xd->above_mi = (mi_row > 0) ? &mi_above : NULL;
6286 xd->left_mi = (mi_col > 0) ? &mi_left : NULL;
6288 // Intra prediction search
6289 for (mode = DC_PRED; mode <= TM_PRED; ++mode) {
6291 int src_stride, dst_stride;
6293 src = xd->cur_buf->y_buffer + mb_y_offset;
6294 src_stride = xd->cur_buf->y_stride;
6296 dst = &predictor[0];
6299 xd->mi[0]->sb_type = bsize;
6300 xd->mi[0]->ref_frame[0] = INTRA_FRAME;
6302 vp9_predict_intra_block(xd, b_width_log2_lookup[bsize], tx_size, mode, src,
6303 src_stride, dst, dst_stride, 0, 0, 0);
6305 #if CONFIG_VP9_HIGHBITDEPTH
6306 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6307 vpx_highbd_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst,
6308 dst_stride, xd->bd);
6309 highbd_wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6310 intra_cost = vpx_highbd_satd(coeff, pix_num);
6312 vpx_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst,
6314 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6315 intra_cost = vpx_satd(coeff, pix_num);
6318 vpx_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst, dst_stride);
6319 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6320 intra_cost = vpx_satd(coeff, pix_num);
6321 #endif // CONFIG_VP9_HIGHBITDEPTH
6323 if (intra_cost < best_intra_cost) best_intra_cost = intra_cost;
6326 // Motion compensated prediction
6329 set_mv_limits(cm, x, mi_row, mi_col);
6331 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6333 #if CONFIG_NON_GREEDY_MV
6334 MotionField *motion_field;
6336 if (ref_frame[rf_idx] == NULL) continue;
6338 #if CONFIG_NON_GREEDY_MV
6340 motion_field = vp9_motion_field_info_get_motion_field(
6341 &cpi->motion_field_info, frame_idx, rf_idx, bsize);
6342 mv = vp9_motion_field_mi_get_mv(motion_field, mi_row, mi_col);
6344 motion_compensated_prediction(cpi, td, xd->cur_buf->y_buffer + mb_y_offset,
6345 ref_frame[rf_idx]->y_buffer + mb_y_offset,
6346 xd->cur_buf->y_stride, bsize, &mv.as_mv);
6349 #if CONFIG_VP9_HIGHBITDEPTH
6350 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6351 vp9_highbd_build_inter_predictor(
6352 CONVERT_TO_SHORTPTR(ref_frame[rf_idx]->y_buffer + mb_y_offset),
6353 ref_frame[rf_idx]->y_stride, CONVERT_TO_SHORTPTR(&predictor[0]), bw,
6354 &mv.as_mv, sf, bw, bh, 0, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE,
6355 mi_row * MI_SIZE, xd->bd);
6356 vpx_highbd_subtract_block(
6357 bh, bw, src_diff, bw, xd->cur_buf->y_buffer + mb_y_offset,
6358 xd->cur_buf->y_stride, &predictor[0], bw, xd->bd);
6359 highbd_wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6360 inter_cost = vpx_highbd_satd(coeff, pix_num);
6362 vp9_build_inter_predictor(
6363 ref_frame[rf_idx]->y_buffer + mb_y_offset,
6364 ref_frame[rf_idx]->y_stride, &predictor[0], bw, &mv.as_mv, sf, bw, bh,
6365 0, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE, mi_row * MI_SIZE);
6366 vpx_subtract_block(bh, bw, src_diff, bw,
6367 xd->cur_buf->y_buffer + mb_y_offset,
6368 xd->cur_buf->y_stride, &predictor[0], bw);
6369 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6370 inter_cost = vpx_satd(coeff, pix_num);
6373 vp9_build_inter_predictor(ref_frame[rf_idx]->y_buffer + mb_y_offset,
6374 ref_frame[rf_idx]->y_stride, &predictor[0], bw,
6375 &mv.as_mv, sf, bw, bh, 0, kernel, MV_PRECISION_Q3,
6376 mi_col * MI_SIZE, mi_row * MI_SIZE);
6377 vpx_subtract_block(bh, bw, src_diff, bw,
6378 xd->cur_buf->y_buffer + mb_y_offset,
6379 xd->cur_buf->y_stride, &predictor[0], bw);
6380 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6381 inter_cost = vpx_satd(coeff, pix_num);
6384 if (inter_cost < best_inter_cost) {
6385 best_rf_idx = rf_idx;
6386 best_inter_cost = inter_cost;
6387 best_mv.as_int = mv.as_int;
6388 get_quantize_error(x, 0, coeff, qcoeff, dqcoeff, tx_size, recon_error,
6392 best_intra_cost = VPXMAX(best_intra_cost, 1);
6393 best_inter_cost = VPXMIN(best_intra_cost, best_inter_cost);
6394 tpl_stats->inter_cost = VPXMAX(
6395 1, (best_inter_cost << TPL_DEP_COST_SCALE_LOG2) / (mi_height * mi_width));
6396 tpl_stats->intra_cost = VPXMAX(
6397 1, (best_intra_cost << TPL_DEP_COST_SCALE_LOG2) / (mi_height * mi_width));
6398 tpl_stats->ref_frame_index = gf_picture[frame_idx].ref_frame[best_rf_idx];
6399 tpl_stats->mv.as_int = best_mv.as_int;
6402 #if CONFIG_NON_GREEDY_MV
6403 static int get_block_src_pred_buf(MACROBLOCKD *xd, GF_PICTURE *gf_picture,
6404 int frame_idx, int rf_idx, int mi_row,
6405 int mi_col, struct buf_2d *src,
6406 struct buf_2d *pre) {
6407 const int mb_y_offset =
6408 mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6409 YV12_BUFFER_CONFIG *ref_frame = NULL;
6410 int ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
6411 if (ref_frame_idx != -1) {
6412 ref_frame = gf_picture[ref_frame_idx].frame;
6413 src->buf = xd->cur_buf->y_buffer + mb_y_offset;
6414 src->stride = xd->cur_buf->y_stride;
6415 pre->buf = ref_frame->y_buffer + mb_y_offset;
6416 pre->stride = ref_frame->y_stride;
6417 assert(src->stride == pre->stride);
6420 printf("invalid ref_frame_idx");
6421 assert(ref_frame_idx != -1);
6426 #define kMvPreCheckLines 5
6427 #define kMvPreCheckSize 15
6429 #define MV_REF_POS_NUM 3
6430 POSITION mv_ref_pos[MV_REF_POS_NUM] = {
6436 static int_mv *get_select_mv(VP9_COMP *cpi, TplDepFrame *tpl_frame, int mi_row,
6438 return &cpi->select_mv_arr[mi_row * tpl_frame->stride + mi_col];
6441 static int_mv find_ref_mv(int mv_mode, VP9_COMP *cpi, TplDepFrame *tpl_frame,
6442 BLOCK_SIZE bsize, int mi_row, int mi_col) {
6444 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6445 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6446 int_mv nearest_mv, near_mv, invalid_mv;
6447 nearest_mv.as_int = INVALID_MV;
6448 near_mv.as_int = INVALID_MV;
6449 invalid_mv.as_int = INVALID_MV;
6450 for (i = 0; i < MV_REF_POS_NUM; ++i) {
6451 int nb_row = mi_row + mv_ref_pos[i].row * mi_height;
6452 int nb_col = mi_col + mv_ref_pos[i].col * mi_width;
6453 assert(mv_ref_pos[i].row <= 0);
6454 assert(mv_ref_pos[i].col <= 0);
6455 if (nb_row >= 0 && nb_col >= 0) {
6456 if (nearest_mv.as_int == INVALID_MV) {
6457 nearest_mv = *get_select_mv(cpi, tpl_frame, nb_row, nb_col);
6459 int_mv mv = *get_select_mv(cpi, tpl_frame, nb_row, nb_col);
6460 if (mv.as_int == nearest_mv.as_int) {
6469 if (nearest_mv.as_int == INVALID_MV) {
6470 nearest_mv.as_mv.row = 0;
6471 nearest_mv.as_mv.col = 0;
6473 if (near_mv.as_int == INVALID_MV) {
6474 near_mv.as_mv.row = 0;
6475 near_mv.as_mv.col = 0;
6477 if (mv_mode == NEAREST_MV_MODE) {
6480 if (mv_mode == NEAR_MV_MODE) {
6487 static int_mv get_mv_from_mv_mode(int mv_mode, VP9_COMP *cpi,
6488 MotionField *motion_field,
6489 TplDepFrame *tpl_frame, BLOCK_SIZE bsize,
6490 int mi_row, int mi_col) {
6498 mv = vp9_motion_field_mi_get_mv(motion_field, mi_row, mi_col);
6500 case NEAREST_MV_MODE:
6501 mv = find_ref_mv(mv_mode, cpi, tpl_frame, bsize, mi_row, mi_col);
6504 mv = find_ref_mv(mv_mode, cpi, tpl_frame, bsize, mi_row, mi_col);
6507 mv.as_int = INVALID_MV;
6514 static double get_mv_dist(int mv_mode, VP9_COMP *cpi, MACROBLOCKD *xd,
6515 GF_PICTURE *gf_picture, MotionField *motion_field,
6516 int frame_idx, TplDepFrame *tpl_frame, int rf_idx,
6517 BLOCK_SIZE bsize, int mi_row, int mi_col,
6523 *mv = get_mv_from_mv_mode(mv_mode, cpi, motion_field, tpl_frame, bsize,
6525 full_mv = get_full_mv(&mv->as_mv);
6526 if (get_block_src_pred_buf(xd, gf_picture, frame_idx, rf_idx, mi_row, mi_col,
6528 // TODO(angiebird): Consider subpixel when computing the sse.
6529 cpi->fn_ptr[bsize].vf(src.buf, src.stride, get_buf_from_mv(&pre, &full_mv),
6531 return (double)(sse << VP9_DIST_SCALE_LOG2);
6538 static int get_mv_mode_cost(int mv_mode) {
6539 // TODO(angiebird): The probabilities are roughly inferred from
6540 // default_inter_mode_probs. Check if there is a better way to set the
6542 const int zero_mv_prob = 16;
6543 const int new_mv_prob = 24 * 1;
6544 const int ref_mv_prob = 256 - zero_mv_prob - new_mv_prob;
6545 assert(zero_mv_prob + new_mv_prob + ref_mv_prob == 256);
6547 case ZERO_MV_MODE: return vp9_prob_cost[zero_mv_prob]; break;
6548 case NEW_MV_MODE: return vp9_prob_cost[new_mv_prob]; break;
6549 case NEAREST_MV_MODE: return vp9_prob_cost[ref_mv_prob]; break;
6550 case NEAR_MV_MODE: return vp9_prob_cost[ref_mv_prob]; break;
6551 default: assert(0); return -1;
6555 static INLINE double get_mv_diff_cost(MV *new_mv, MV *ref_mv) {
6556 double mv_diff_cost = log2(1 + abs(new_mv->row - ref_mv->row)) +
6557 log2(1 + abs(new_mv->col - ref_mv->col));
6558 mv_diff_cost *= (1 << VP9_PROB_COST_SHIFT);
6559 return mv_diff_cost;
6561 static double get_mv_cost(int mv_mode, VP9_COMP *cpi, MotionField *motion_field,
6562 TplDepFrame *tpl_frame, BLOCK_SIZE bsize, int mi_row,
6564 double mv_cost = get_mv_mode_cost(mv_mode);
6565 if (mv_mode == NEW_MV_MODE) {
6566 MV new_mv = get_mv_from_mv_mode(mv_mode, cpi, motion_field, tpl_frame,
6567 bsize, mi_row, mi_col)
6569 MV nearest_mv = get_mv_from_mv_mode(NEAREST_MV_MODE, cpi, motion_field,
6570 tpl_frame, bsize, mi_row, mi_col)
6572 MV near_mv = get_mv_from_mv_mode(NEAR_MV_MODE, cpi, motion_field, tpl_frame,
6573 bsize, mi_row, mi_col)
6575 double nearest_cost = get_mv_diff_cost(&new_mv, &nearest_mv);
6576 double near_cost = get_mv_diff_cost(&new_mv, &near_mv);
6577 mv_cost += nearest_cost < near_cost ? nearest_cost : near_cost;
6582 static double eval_mv_mode(int mv_mode, VP9_COMP *cpi, MACROBLOCK *x,
6583 GF_PICTURE *gf_picture, MotionField *motion_field,
6584 int frame_idx, TplDepFrame *tpl_frame, int rf_idx,
6585 BLOCK_SIZE bsize, int mi_row, int mi_col,
6587 MACROBLOCKD *xd = &x->e_mbd;
6589 get_mv_dist(mv_mode, cpi, xd, gf_picture, motion_field, frame_idx,
6590 tpl_frame, rf_idx, bsize, mi_row, mi_col, mv);
6592 get_mv_cost(mv_mode, cpi, motion_field, tpl_frame, bsize, mi_row, mi_col);
6595 return mv_cost + mult * log2f(1 + mv_dist);
6598 static int find_best_ref_mv_mode(VP9_COMP *cpi, MACROBLOCK *x,
6599 GF_PICTURE *gf_picture,
6600 MotionField *motion_field, int frame_idx,
6601 TplDepFrame *tpl_frame, int rf_idx,
6602 BLOCK_SIZE bsize, int mi_row, int mi_col,
6603 double *rd, int_mv *mv) {
6604 int best_mv_mode = ZERO_MV_MODE;
6608 for (mv_mode = 0; mv_mode < MAX_MV_MODE; ++mv_mode) {
6611 if (mv_mode == NEW_MV_MODE) {
6614 this_rd = eval_mv_mode(mv_mode, cpi, x, gf_picture, motion_field, frame_idx,
6615 tpl_frame, rf_idx, bsize, mi_row, mi_col, &this_mv);
6619 best_mv_mode = mv_mode;
6622 if (this_rd < *rd) {
6625 best_mv_mode = mv_mode;
6629 return best_mv_mode;
6632 static void predict_mv_mode(VP9_COMP *cpi, MACROBLOCK *x,
6633 GF_PICTURE *gf_picture, MotionField *motion_field,
6634 int frame_idx, TplDepFrame *tpl_frame, int rf_idx,
6635 BLOCK_SIZE bsize, int mi_row, int mi_col) {
6636 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6637 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6638 int tmp_mv_mode_arr[kMvPreCheckSize];
6639 int *mv_mode_arr = tpl_frame->mv_mode_arr[rf_idx];
6640 double *rd_diff_arr = tpl_frame->rd_diff_arr[rf_idx];
6641 int_mv *select_mv_arr = cpi->select_mv_arr;
6642 int_mv tmp_select_mv_arr[kMvPreCheckSize];
6643 int stride = tpl_frame->stride;
6644 double new_mv_rd = 0;
6645 double no_new_mv_rd = 0;
6646 double this_new_mv_rd = 0;
6647 double this_no_new_mv_rd = 0;
6650 assert(kMvPreCheckSize == (kMvPreCheckLines * (kMvPreCheckLines + 1)) >> 1);
6653 // diagnal scan order
6655 for (idx = 0; idx < kMvPreCheckLines; ++idx) {
6657 for (r = 0; r <= idx; ++r) {
6659 int nb_row = mi_row + r * mi_height;
6660 int nb_col = mi_col + c * mi_width;
6661 if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6663 int_mv *mv = &select_mv_arr[nb_row * stride + nb_col];
6664 mv_mode_arr[nb_row * stride + nb_col] = find_best_ref_mv_mode(
6665 cpi, x, gf_picture, motion_field, frame_idx, tpl_frame, rf_idx,
6666 bsize, nb_row, nb_col, &this_rd, mv);
6667 if (r == 0 && c == 0) {
6668 this_no_new_mv_rd = this_rd;
6670 no_new_mv_rd += this_rd;
6671 tmp_mv_mode_arr[tmp_idx] = mv_mode_arr[nb_row * stride + nb_col];
6672 tmp_select_mv_arr[tmp_idx] = select_mv_arr[nb_row * stride + nb_col];
6679 mv_mode_arr[mi_row * stride + mi_col] = NEW_MV_MODE;
6680 this_new_mv_rd = eval_mv_mode(
6681 NEW_MV_MODE, cpi, x, gf_picture, motion_field, frame_idx, tpl_frame,
6682 rf_idx, bsize, mi_row, mi_col, &select_mv_arr[mi_row * stride + mi_col]);
6683 new_mv_rd = this_new_mv_rd;
6684 // We start from idx = 1 because idx = 0 is evaluated as NEW_MV_MODE
6686 for (idx = 1; idx < kMvPreCheckLines; ++idx) {
6688 for (r = 0; r <= idx; ++r) {
6690 int nb_row = mi_row + r * mi_height;
6691 int nb_col = mi_col + c * mi_width;
6692 if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6694 int_mv *mv = &select_mv_arr[nb_row * stride + nb_col];
6695 mv_mode_arr[nb_row * stride + nb_col] = find_best_ref_mv_mode(
6696 cpi, x, gf_picture, motion_field, frame_idx, tpl_frame, rf_idx,
6697 bsize, nb_row, nb_col, &this_rd, mv);
6698 new_mv_rd += this_rd;
6703 // update best_mv_mode
6705 if (no_new_mv_rd < new_mv_rd) {
6706 for (idx = 0; idx < kMvPreCheckLines; ++idx) {
6708 for (r = 0; r <= idx; ++r) {
6710 int nb_row = mi_row + r * mi_height;
6711 int nb_col = mi_col + c * mi_width;
6712 if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6713 mv_mode_arr[nb_row * stride + nb_col] = tmp_mv_mode_arr[tmp_idx];
6714 select_mv_arr[nb_row * stride + nb_col] = tmp_select_mv_arr[tmp_idx];
6719 rd_diff_arr[mi_row * stride + mi_col] = 0;
6721 rd_diff_arr[mi_row * stride + mi_col] =
6722 (no_new_mv_rd - this_no_new_mv_rd) - (new_mv_rd - this_new_mv_rd);
6726 static void predict_mv_mode_arr(VP9_COMP *cpi, MACROBLOCK *x,
6727 GF_PICTURE *gf_picture,
6728 MotionField *motion_field, int frame_idx,
6729 TplDepFrame *tpl_frame, int rf_idx,
6731 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6732 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6733 const int unit_rows = tpl_frame->mi_rows / mi_height;
6734 const int unit_cols = tpl_frame->mi_cols / mi_width;
6735 const int max_diagonal_lines = unit_rows + unit_cols - 1;
6737 for (idx = 0; idx < max_diagonal_lines; ++idx) {
6739 for (r = VPXMAX(idx - unit_cols + 1, 0); r <= VPXMIN(idx, unit_rows - 1);
6742 int mi_row = r * mi_height;
6743 int mi_col = c * mi_width;
6744 assert(c >= 0 && c < unit_cols);
6745 assert(mi_row >= 0 && mi_row < tpl_frame->mi_rows);
6746 assert(mi_col >= 0 && mi_col < tpl_frame->mi_cols);
6747 predict_mv_mode(cpi, x, gf_picture, motion_field, frame_idx, tpl_frame,
6748 rf_idx, bsize, mi_row, mi_col);
6753 static void do_motion_search(VP9_COMP *cpi, ThreadData *td,
6754 MotionField *motion_field, int frame_idx,
6755 YV12_BUFFER_CONFIG *ref_frame, BLOCK_SIZE bsize,
6756 int mi_row, int mi_col) {
6757 VP9_COMMON *cm = &cpi->common;
6758 MACROBLOCK *x = &td->mb;
6759 MACROBLOCKD *xd = &x->e_mbd;
6760 const int mb_y_offset =
6761 mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6762 assert(ref_frame != NULL);
6763 set_mv_limits(cm, x, mi_row, mi_col);
6765 int_mv mv = vp9_motion_field_mi_get_mv(motion_field, mi_row, mi_col);
6766 uint8_t *cur_frame_buf = xd->cur_buf->y_buffer + mb_y_offset;
6767 uint8_t *ref_frame_buf = ref_frame->y_buffer + mb_y_offset;
6768 const int stride = xd->cur_buf->y_stride;
6769 full_pixel_motion_search(cpi, td, motion_field, frame_idx, cur_frame_buf,
6770 ref_frame_buf, stride, bsize, mi_row, mi_col,
6772 sub_pixel_motion_search(cpi, td, cur_frame_buf, ref_frame_buf, stride,
6774 vp9_motion_field_mi_set_mv(motion_field, mi_row, mi_col, mv);
6778 static void build_motion_field(
6779 VP9_COMP *cpi, int frame_idx,
6780 YV12_BUFFER_CONFIG *ref_frame[MAX_INTER_REF_FRAMES], BLOCK_SIZE bsize) {
6781 VP9_COMMON *cm = &cpi->common;
6782 ThreadData *td = &cpi->td;
6783 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6784 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6785 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6786 const int pw = num_4x4_blocks_wide_lookup[bsize] << 2;
6787 const int ph = num_4x4_blocks_high_lookup[bsize] << 2;
6791 tpl_frame->lambda = (pw * ph) >> 2;
6792 assert(pw * ph == tpl_frame->lambda << 2);
6794 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6795 MotionField *motion_field = vp9_motion_field_info_get_motion_field(
6796 &cpi->motion_field_info, frame_idx, rf_idx, bsize);
6797 if (ref_frame[rf_idx] == NULL) {
6800 vp9_motion_field_reset_mvs(motion_field);
6801 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6802 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6803 do_motion_search(cpi, td, motion_field, frame_idx, ref_frame[rf_idx],
6804 bsize, mi_row, mi_col);
6809 #endif // CONFIG_NON_GREEDY_MV
6811 static void mc_flow_dispenser(VP9_COMP *cpi, GF_PICTURE *gf_picture,
6812 int frame_idx, BLOCK_SIZE bsize) {
6813 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6814 YV12_BUFFER_CONFIG *this_frame = gf_picture[frame_idx].frame;
6815 YV12_BUFFER_CONFIG *ref_frame[MAX_INTER_REF_FRAMES] = { NULL, NULL, NULL };
6817 VP9_COMMON *cm = &cpi->common;
6818 struct scale_factors sf;
6820 ThreadData *td = &cpi->td;
6821 MACROBLOCK *x = &td->mb;
6822 MACROBLOCKD *xd = &x->e_mbd;
6825 #if CONFIG_VP9_HIGHBITDEPTH
6826 DECLARE_ALIGNED(16, uint16_t, predictor16[32 * 32 * 3]);
6827 DECLARE_ALIGNED(16, uint8_t, predictor8[32 * 32 * 3]);
6830 DECLARE_ALIGNED(16, uint8_t, predictor[32 * 32 * 3]);
6832 DECLARE_ALIGNED(16, int16_t, src_diff[32 * 32]);
6833 DECLARE_ALIGNED(16, tran_low_t, coeff[32 * 32]);
6834 DECLARE_ALIGNED(16, tran_low_t, qcoeff[32 * 32]);
6835 DECLARE_ALIGNED(16, tran_low_t, dqcoeff[32 * 32]);
6837 const TX_SIZE tx_size = max_txsize_lookup[bsize];
6838 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6839 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6840 int64_t recon_error, sse;
6841 #if CONFIG_NON_GREEDY_MV
6842 int square_block_idx;
6846 // Setup scaling factor
6847 #if CONFIG_VP9_HIGHBITDEPTH
6848 vp9_setup_scale_factors_for_frame(
6849 &sf, this_frame->y_crop_width, this_frame->y_crop_height,
6850 this_frame->y_crop_width, this_frame->y_crop_height,
6851 cpi->common.use_highbitdepth);
6853 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH)
6854 predictor = CONVERT_TO_BYTEPTR(predictor16);
6856 predictor = predictor8;
6858 vp9_setup_scale_factors_for_frame(
6859 &sf, this_frame->y_crop_width, this_frame->y_crop_height,
6860 this_frame->y_crop_width, this_frame->y_crop_height);
6861 #endif // CONFIG_VP9_HIGHBITDEPTH
6863 // Prepare reference frame pointers. If any reference frame slot is
6864 // unavailable, the pointer will be set to Null.
6865 for (idx = 0; idx < MAX_INTER_REF_FRAMES; ++idx) {
6866 int rf_idx = gf_picture[frame_idx].ref_frame[idx];
6867 if (rf_idx != -1) ref_frame[idx] = gf_picture[rf_idx].frame;
6870 xd->mi = cm->mi_grid_visible;
6872 xd->cur_buf = this_frame;
6874 // Get rd multiplier set up.
6875 rdmult = vp9_compute_rd_mult_based_on_qindex(cpi, tpl_frame->base_qindex);
6876 set_error_per_bit(&cpi->td.mb, rdmult);
6877 vp9_initialize_me_consts(cpi, &cpi->td.mb, tpl_frame->base_qindex);
6879 tpl_frame->is_valid = 1;
6881 cm->base_qindex = tpl_frame->base_qindex;
6882 vp9_frame_init_quantizer(cpi);
6884 #if CONFIG_NON_GREEDY_MV
6885 for (square_block_idx = 0; square_block_idx < SQUARE_BLOCK_SIZES;
6886 ++square_block_idx) {
6887 BLOCK_SIZE square_bsize = square_block_idx_to_bsize(square_block_idx);
6888 build_motion_field(cpi, frame_idx, ref_frame, square_bsize);
6890 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6891 int ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
6892 if (ref_frame_idx != -1) {
6893 MotionField *motion_field = vp9_motion_field_info_get_motion_field(
6894 &cpi->motion_field_info, frame_idx, rf_idx, bsize);
6895 predict_mv_mode_arr(cpi, x, gf_picture, motion_field, frame_idx,
6896 tpl_frame, rf_idx, bsize);
6901 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6902 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6903 mode_estimation(cpi, x, xd, &sf, gf_picture, frame_idx, tpl_frame,
6904 src_diff, coeff, qcoeff, dqcoeff, mi_row, mi_col, bsize,
6905 tx_size, ref_frame, predictor, &recon_error, &sse);
6906 // Motion flow dependency dispenser.
6907 tpl_model_store(tpl_frame->tpl_stats_ptr, mi_row, mi_col, bsize,
6910 tpl_model_update(cpi->tpl_stats, tpl_frame->tpl_stats_ptr, mi_row, mi_col,
6916 #if CONFIG_NON_GREEDY_MV
6917 #define DUMP_TPL_STATS 0
6919 static void dump_buf(uint8_t *buf, int stride, int row, int col, int h, int w) {
6921 printf("%d %d\n", h, w);
6922 for (i = 0; i < h; ++i) {
6923 for (j = 0; j < w; ++j) {
6924 printf("%d ", buf[(row + i) * stride + col + j]);
6930 static void dump_frame_buf(const YV12_BUFFER_CONFIG *frame_buf) {
6931 dump_buf(frame_buf->y_buffer, frame_buf->y_stride, 0, 0, frame_buf->y_height,
6932 frame_buf->y_width);
6933 dump_buf(frame_buf->u_buffer, frame_buf->uv_stride, 0, 0,
6934 frame_buf->uv_height, frame_buf->uv_width);
6935 dump_buf(frame_buf->v_buffer, frame_buf->uv_stride, 0, 0,
6936 frame_buf->uv_height, frame_buf->uv_width);
6939 static void dump_tpl_stats(const VP9_COMP *cpi, int tpl_group_frames,
6940 const GF_GROUP *gf_group,
6941 const GF_PICTURE *gf_picture, BLOCK_SIZE bsize) {
6943 const VP9_COMMON *cm = &cpi->common;
6945 for (frame_idx = 1; frame_idx < tpl_group_frames; ++frame_idx) {
6946 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6947 const TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6950 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6951 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6952 ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
6953 if (ref_frame_idx != -1) {
6954 YV12_BUFFER_CONFIG *ref_frame_buf = gf_picture[ref_frame_idx].frame;
6955 const int gf_frame_offset = gf_group->frame_gop_index[frame_idx];
6956 const int ref_gf_frame_offset =
6957 gf_group->frame_gop_index[ref_frame_idx];
6960 "frame_idx %d mi_rows %d mi_cols %d bsize %d ref_frame_idx %d "
6961 "rf_idx %d gf_frame_offset %d ref_gf_frame_offset %d\n",
6962 frame_idx, cm->mi_rows, cm->mi_cols, mi_width * MI_SIZE,
6963 ref_frame_idx, rf_idx, gf_frame_offset, ref_gf_frame_offset);
6964 for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row) {
6965 for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) {
6966 if ((mi_row % mi_height) == 0 && (mi_col % mi_width) == 0) {
6967 int_mv mv = vp9_motion_field_info_get_mv(&cpi->motion_field_info,
6968 frame_idx, rf_idx, bsize,
6970 printf("%d %d %d %d\n", mi_row, mi_col, mv.as_mv.row,
6975 for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row) {
6976 for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) {
6977 if ((mi_row % mi_height) == 0 && (mi_col % mi_width) == 0) {
6978 const TplDepStats *tpl_ptr =
6980 ->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
6981 printf("%f ", tpl_ptr->feature_score);
6987 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6988 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6991 ->mv_mode_arr[rf_idx][mi_row * tpl_frame->stride + mi_col];
6992 printf("%d ", mv_mode);
6997 dump_frame_buf(gf_picture[frame_idx].frame);
6998 dump_frame_buf(ref_frame_buf);
7003 #endif // DUMP_TPL_STATS
7004 #endif // CONFIG_NON_GREEDY_MV
7006 static void init_tpl_buffer(VP9_COMP *cpi) {
7007 VP9_COMMON *cm = &cpi->common;
7010 const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
7011 const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
7012 #if CONFIG_NON_GREEDY_MV
7015 vpx_free(cpi->select_mv_arr);
7017 cm, cpi->select_mv_arr,
7018 vpx_calloc(mi_rows * mi_cols * 4, sizeof(*cpi->select_mv_arr)));
7021 // TODO(jingning): Reduce the actual memory use for tpl model build up.
7022 for (frame = 0; frame < MAX_ARF_GOP_SIZE; ++frame) {
7023 if (cpi->tpl_stats[frame].width >= mi_cols &&
7024 cpi->tpl_stats[frame].height >= mi_rows &&
7025 cpi->tpl_stats[frame].tpl_stats_ptr)
7028 #if CONFIG_NON_GREEDY_MV
7029 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
7030 vpx_free(cpi->tpl_stats[frame].mv_mode_arr[rf_idx]);
7032 cm, cpi->tpl_stats[frame].mv_mode_arr[rf_idx],
7033 vpx_calloc(mi_rows * mi_cols * 4,
7034 sizeof(*cpi->tpl_stats[frame].mv_mode_arr[rf_idx])));
7035 vpx_free(cpi->tpl_stats[frame].rd_diff_arr[rf_idx]);
7037 cm, cpi->tpl_stats[frame].rd_diff_arr[rf_idx],
7038 vpx_calloc(mi_rows * mi_cols * 4,
7039 sizeof(*cpi->tpl_stats[frame].rd_diff_arr[rf_idx])));
7042 vpx_free(cpi->tpl_stats[frame].tpl_stats_ptr);
7043 CHECK_MEM_ERROR(cm, cpi->tpl_stats[frame].tpl_stats_ptr,
7044 vpx_calloc(mi_rows * mi_cols,
7045 sizeof(*cpi->tpl_stats[frame].tpl_stats_ptr)));
7046 cpi->tpl_stats[frame].is_valid = 0;
7047 cpi->tpl_stats[frame].width = mi_cols;
7048 cpi->tpl_stats[frame].height = mi_rows;
7049 cpi->tpl_stats[frame].stride = mi_cols;
7050 cpi->tpl_stats[frame].mi_rows = cm->mi_rows;
7051 cpi->tpl_stats[frame].mi_cols = cm->mi_cols;
7054 for (frame = 0; frame < REF_FRAMES; ++frame) {
7055 cpi->enc_frame_buf[frame].mem_valid = 0;
7056 cpi->enc_frame_buf[frame].released = 1;
7060 static void free_tpl_buffer(VP9_COMP *cpi) {
7062 #if CONFIG_NON_GREEDY_MV
7063 vp9_free_motion_field_info(&cpi->motion_field_info);
7064 vpx_free(cpi->select_mv_arr);
7066 for (frame = 0; frame < MAX_ARF_GOP_SIZE; ++frame) {
7067 #if CONFIG_NON_GREEDY_MV
7069 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
7070 vpx_free(cpi->tpl_stats[frame].mv_mode_arr[rf_idx]);
7071 vpx_free(cpi->tpl_stats[frame].rd_diff_arr[rf_idx]);
7074 vpx_free(cpi->tpl_stats[frame].tpl_stats_ptr);
7075 cpi->tpl_stats[frame].is_valid = 0;
7079 static void setup_tpl_stats(VP9_COMP *cpi) {
7080 GF_PICTURE gf_picture[MAX_ARF_GOP_SIZE];
7081 const GF_GROUP *gf_group = &cpi->twopass.gf_group;
7082 int tpl_group_frames = 0;
7084 cpi->tpl_bsize = BLOCK_32X32;
7086 init_gop_frames(cpi, gf_picture, gf_group, &tpl_group_frames);
7088 init_tpl_stats(cpi);
7090 // Backward propagation from tpl_group_frames to 1.
7091 for (frame_idx = tpl_group_frames - 1; frame_idx > 0; --frame_idx) {
7092 if (gf_picture[frame_idx].update_type == USE_BUF_FRAME) continue;
7093 mc_flow_dispenser(cpi, gf_picture, frame_idx, cpi->tpl_bsize);
7095 #if CONFIG_NON_GREEDY_MV
7098 dump_tpl_stats(cpi, tpl_group_frames, gf_group, gf_picture, cpi->tpl_bsize);
7099 #endif // DUMP_TPL_STATS
7100 #endif // CONFIG_NON_GREEDY_MV
7103 static void init_encode_frame_result(ENCODE_FRAME_RESULT *encode_frame_result) {
7104 encode_frame_result->show_idx = -1; // Actual encoding deosn't happen.
7107 #if !CONFIG_REALTIME_ONLY
7108 static void update_encode_frame_result(ENCODE_FRAME_RESULT *encode_frame_result,
7110 FRAME_UPDATE_TYPE update_type,
7111 const YV12_BUFFER_CONFIG *source_frame,
7112 const YV12_BUFFER_CONFIG *coded_frame,
7113 int quantize_index, uint32_t bit_depth,
7114 uint32_t input_bit_depth) {
7116 #if CONFIG_VP9_HIGHBITDEPTH
7117 vpx_calc_highbd_psnr(source_frame, coded_frame, &psnr, bit_depth,
7121 (void)input_bit_depth;
7122 vpx_calc_psnr(source_frame, coded_frame, &psnr);
7124 encode_frame_result->psnr = psnr.psnr[0];
7125 encode_frame_result->sse = psnr.sse[0];
7126 encode_frame_result->show_idx = show_idx;
7127 encode_frame_result->update_type = update_type;
7128 encode_frame_result->quantize_index = quantize_index;
7130 #endif // !CONFIG_REALTIME_ONLY
7132 int vp9_get_compressed_data(VP9_COMP *cpi, unsigned int *frame_flags,
7133 size_t *size, uint8_t *dest, int64_t *time_stamp,
7134 int64_t *time_end, int flush,
7135 ENCODE_FRAME_RESULT *encode_frame_result) {
7136 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
7137 VP9_COMMON *const cm = &cpi->common;
7138 BufferPool *const pool = cm->buffer_pool;
7139 RATE_CONTROL *const rc = &cpi->rc;
7140 struct vpx_usec_timer cmptimer;
7141 YV12_BUFFER_CONFIG *force_src_buffer = NULL;
7142 struct lookahead_entry *last_source = NULL;
7143 struct lookahead_entry *source = NULL;
7145 const int gf_group_index = cpi->twopass.gf_group.index;
7147 init_encode_frame_result(encode_frame_result);
7149 if (is_one_pass_cbr_svc(cpi)) {
7150 vp9_one_pass_cbr_svc_start_layer(cpi);
7153 vpx_usec_timer_start(&cmptimer);
7155 vp9_set_high_precision_mv(cpi, ALTREF_HIGH_PRECISION_MV);
7157 // Is multi-arf enabled.
7158 // Note that at the moment multi_arf is only configured for 2 pass VBR and
7159 // will not work properly with svc.
7160 // Enable the Jingning's new "multi_layer_arf" code if "enable_auto_arf"
7161 // is greater than or equal to 2.
7162 if ((oxcf->pass == 2) && !cpi->use_svc && (cpi->oxcf.enable_auto_arf >= 2))
7163 cpi->multi_layer_arf = 1;
7165 cpi->multi_layer_arf = 0;
7168 cm->reset_frame_context = 0;
7169 cm->refresh_frame_context = 1;
7170 if (!is_one_pass_cbr_svc(cpi)) {
7171 cpi->refresh_last_frame = 1;
7172 cpi->refresh_golden_frame = 0;
7173 cpi->refresh_alt_ref_frame = 0;
7176 // Should we encode an arf frame.
7177 arf_src_index = get_arf_src_index(cpi);
7179 if (arf_src_index) {
7180 for (i = 0; i <= arf_src_index; ++i) {
7181 struct lookahead_entry *e = vp9_lookahead_peek(cpi->lookahead, i);
7182 // Avoid creating an alt-ref if there's a forced keyframe pending.
7185 } else if (e->flags == VPX_EFLAG_FORCE_KF) {
7193 // Clear arf index stack before group of pictures processing starts.
7194 if (gf_group_index == 1) {
7195 stack_init(cpi->twopass.gf_group.arf_index_stack, MAX_LAG_BUFFERS * 2);
7196 cpi->twopass.gf_group.stack_size = 0;
7199 if (arf_src_index) {
7200 assert(arf_src_index <= rc->frames_to_key);
7201 if ((source = vp9_lookahead_peek(cpi->lookahead, arf_src_index)) != NULL) {
7202 cpi->alt_ref_source = source;
7204 #if !CONFIG_REALTIME_ONLY
7205 if ((oxcf->mode != REALTIME) && (oxcf->arnr_max_frames > 0) &&
7206 (oxcf->arnr_strength > 0)) {
7207 int bitrate = cpi->rc.avg_frame_bandwidth / 40;
7208 int not_low_bitrate = bitrate > ALT_REF_AQ_LOW_BITRATE_BOUNDARY;
7210 int not_last_frame = (cpi->lookahead->sz - arf_src_index > 1);
7211 not_last_frame |= ALT_REF_AQ_APPLY_TO_LAST_FRAME;
7213 // Produce the filtered ARF frame.
7214 vp9_temporal_filter(cpi, arf_src_index);
7215 vpx_extend_frame_borders(&cpi->alt_ref_buffer);
7217 // for small bitrates segmentation overhead usually
7218 // eats all bitrate gain from enabling delta quantizers
7219 if (cpi->oxcf.alt_ref_aq != 0 && not_low_bitrate && not_last_frame)
7220 vp9_alt_ref_aq_setup_mode(cpi->alt_ref_aq, cpi);
7222 force_src_buffer = &cpi->alt_ref_buffer;
7227 cpi->refresh_alt_ref_frame = 1;
7228 cpi->refresh_golden_frame = 0;
7229 cpi->refresh_last_frame = 0;
7230 rc->is_src_frame_alt_ref = 0;
7231 rc->source_alt_ref_pending = 0;
7233 rc->source_alt_ref_pending = 0;
7238 // Get last frame source.
7239 if (cm->current_video_frame > 0) {
7240 if ((last_source = vp9_lookahead_peek(cpi->lookahead, -1)) == NULL)
7244 // Read in the source frame.
7245 if (cpi->use_svc || cpi->svc.set_intra_only_frame)
7246 source = vp9_svc_lookahead_pop(cpi, cpi->lookahead, flush);
7248 source = vp9_lookahead_pop(cpi->lookahead, flush);
7250 if (source != NULL) {
7253 // If the flags indicate intra frame, but if the current picture is for
7254 // spatial layer above first_spatial_layer_to_encode, it should not be an
7256 if ((source->flags & VPX_EFLAG_FORCE_KF) && cpi->use_svc &&
7257 cpi->svc.spatial_layer_id > cpi->svc.first_spatial_layer_to_encode) {
7258 source->flags &= ~(unsigned int)(VPX_EFLAG_FORCE_KF);
7261 // Check to see if the frame should be encoded as an arf overlay.
7262 check_src_altref(cpi, source);
7267 cpi->un_scaled_source = cpi->Source =
7268 force_src_buffer ? force_src_buffer : &source->img;
7270 #ifdef ENABLE_KF_DENOISE
7271 // Copy of raw source for metrics calculation.
7272 if (is_psnr_calc_enabled(cpi))
7273 vp9_copy_and_extend_frame(cpi->Source, &cpi->raw_unscaled_source);
7276 cpi->unscaled_last_source = last_source != NULL ? &last_source->img : NULL;
7278 *time_stamp = source->ts_start;
7279 *time_end = source->ts_end;
7280 *frame_flags = (source->flags & VPX_EFLAG_FORCE_KF) ? FRAMEFLAGS_KEY : 0;
7286 if (source->ts_start < cpi->first_time_stamp_ever) {
7287 cpi->first_time_stamp_ever = source->ts_start;
7288 cpi->last_end_time_stamp_seen = source->ts_start;
7291 // Clear down mmx registers
7292 vpx_clear_system_state();
7294 // adjust frame rates based on timestamps given
7295 if (cm->show_frame) {
7296 if (cpi->use_svc && cpi->svc.use_set_ref_frame_config &&
7297 cpi->svc.duration[cpi->svc.spatial_layer_id] > 0)
7298 vp9_svc_adjust_frame_rate(cpi);
7300 adjust_frame_rate(cpi, source);
7303 if (is_one_pass_cbr_svc(cpi)) {
7304 vp9_update_temporal_layer_framerate(cpi);
7305 vp9_restore_layer_context(cpi);
7308 // Find a free buffer for the new frame, releasing the reference previously
7310 if (cm->new_fb_idx != INVALID_IDX) {
7311 --pool->frame_bufs[cm->new_fb_idx].ref_count;
7313 cm->new_fb_idx = get_free_fb(cm);
7315 if (cm->new_fb_idx == INVALID_IDX) return -1;
7317 cm->cur_frame = &pool->frame_bufs[cm->new_fb_idx];
7319 // Start with a 0 size frame.
7322 cpi->frame_flags = *frame_flags;
7324 #if !CONFIG_REALTIME_ONLY
7325 if ((oxcf->pass == 2) && !cpi->use_svc) {
7326 vp9_rc_get_second_pass_params(cpi);
7327 } else if (oxcf->pass == 1) {
7328 set_frame_size(cpi);
7330 #endif // !CONFIG_REALTIME_ONLY
7332 if (oxcf->pass != 1 && cpi->level_constraint.level_index >= 0 &&
7333 cpi->level_constraint.fail_flag == 0)
7334 level_rc_framerate(cpi, arf_src_index);
7336 if (cpi->oxcf.pass != 0 || cpi->use_svc || frame_is_intra_only(cm) == 1) {
7337 for (i = 0; i < REFS_PER_FRAME; ++i) cpi->scaled_ref_idx[i] = INVALID_IDX;
7340 if (cpi->kmeans_data_arr_alloc == 0) {
7341 const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
7342 const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
7343 #if CONFIG_MULTITHREAD
7344 pthread_mutex_init(&cpi->kmeans_mutex, NULL);
7347 cm, cpi->kmeans_data_arr,
7348 vpx_calloc(mi_rows * mi_cols, sizeof(*cpi->kmeans_data_arr)));
7349 cpi->kmeans_data_stride = mi_cols;
7350 cpi->kmeans_data_arr_alloc = 1;
7353 #if CONFIG_NON_GREEDY_MV
7355 const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
7356 const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
7357 Status status = vp9_alloc_motion_field_info(
7358 &cpi->motion_field_info, MAX_ARF_GOP_SIZE, mi_rows, mi_cols);
7359 if (status == STATUS_FAILED) {
7360 vpx_internal_error(&(cm)->error, VPX_CODEC_MEM_ERROR,
7361 "vp9_alloc_motion_field_info failed");
7364 #endif // CONFIG_NON_GREEDY_MV
7366 if (gf_group_index == 1 &&
7367 cpi->twopass.gf_group.update_type[gf_group_index] == ARF_UPDATE &&
7368 cpi->sf.enable_tpl_model) {
7369 init_tpl_buffer(cpi);
7370 vp9_estimate_qp_gop(cpi);
7371 setup_tpl_stats(cpi);
7374 #if CONFIG_BITSTREAM_DEBUG
7375 assert(cpi->oxcf.max_threads == 0 &&
7376 "bitstream debug tool does not support multithreading");
7377 bitstream_queue_record_write();
7379 #if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
7380 bitstream_queue_set_frame_write(cm->current_video_frame * 2 + cm->show_frame);
7383 cpi->td.mb.fp_src_pred = 0;
7384 #if CONFIG_REALTIME_ONLY
7386 SvcEncode(cpi, size, dest, frame_flags);
7389 Pass0Encode(cpi, size, dest, frame_flags);
7391 #else // !CONFIG_REALTIME_ONLY
7392 if (oxcf->pass == 1 && !cpi->use_svc) {
7393 const int lossless = is_lossless_requested(oxcf);
7394 #if CONFIG_VP9_HIGHBITDEPTH
7395 if (cpi->oxcf.use_highbitdepth)
7396 cpi->td.mb.fwd_txfm4x4 =
7397 lossless ? vp9_highbd_fwht4x4 : vpx_highbd_fdct4x4;
7399 cpi->td.mb.fwd_txfm4x4 = lossless ? vp9_fwht4x4 : vpx_fdct4x4;
7400 cpi->td.mb.highbd_inv_txfm_add =
7401 lossless ? vp9_highbd_iwht4x4_add : vp9_highbd_idct4x4_add;
7403 cpi->td.mb.fwd_txfm4x4 = lossless ? vp9_fwht4x4 : vpx_fdct4x4;
7404 #endif // CONFIG_VP9_HIGHBITDEPTH
7405 cpi->td.mb.inv_txfm_add = lossless ? vp9_iwht4x4_add : vp9_idct4x4_add;
7406 vp9_first_pass(cpi, source);
7407 } else if (oxcf->pass == 2 && !cpi->use_svc) {
7408 Pass2Encode(cpi, size, dest, frame_flags);
7409 // update_encode_frame_result() depends on twopass.gf_group.index and
7410 // cm->new_fb_idx and cpi->Source are updated for current properly and have
7411 // not been updated for the next frame yet.
7412 // The update locations are as follows.
7413 // 1) twopass.gf_group.index is initialized at define_gf_group by vp9_zero()
7414 // for the first frame in the gf_group and is updated for the next frame at
7415 // vp9_twopass_postencode_update().
7416 // 2) cpi->Source is updated at the beginging of this function, i.e.
7417 // vp9_get_compressed_data()
7418 // 3) cm->new_fb_idx is updated at the beginging of this function by
7420 // TODO(angiebird): Improve the codebase to make the update of frame
7421 // dependent variables more robust.
7422 update_encode_frame_result(
7423 encode_frame_result, source->show_idx,
7424 cpi->twopass.gf_group.update_type[cpi->twopass.gf_group.index],
7425 cpi->Source, get_frame_new_buffer(cm), vp9_get_quantizer(cpi),
7426 cpi->oxcf.input_bit_depth, cm->bit_depth);
7427 vp9_twopass_postencode_update(cpi);
7428 } else if (cpi->use_svc) {
7429 SvcEncode(cpi, size, dest, frame_flags);
7432 Pass0Encode(cpi, size, dest, frame_flags);
7434 #endif // CONFIG_REALTIME_ONLY
7436 if (cm->show_frame) cm->cur_show_frame_fb_idx = cm->new_fb_idx;
7438 if (cm->refresh_frame_context)
7439 cm->frame_contexts[cm->frame_context_idx] = *cm->fc;
7441 // No frame encoded, or frame was dropped, release scaled references.
7442 if ((*size == 0) && (frame_is_intra_only(cm) == 0)) {
7443 release_scaled_references(cpi);
7447 cpi->droppable = !frame_is_reference(cpi);
7450 // Save layer specific state.
7451 if (is_one_pass_cbr_svc(cpi) || ((cpi->svc.number_temporal_layers > 1 ||
7452 cpi->svc.number_spatial_layers > 1) &&
7454 vp9_save_layer_context(cpi);
7457 vpx_usec_timer_mark(&cmptimer);
7458 cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
7460 if (cpi->keep_level_stats && oxcf->pass != 1)
7461 update_level_info(cpi, size, arf_src_index);
7463 #if CONFIG_INTERNAL_STATS
7465 if (oxcf->pass != 1) {
7466 double samples = 0.0;
7467 cpi->bytes += (int)(*size);
7469 if (cm->show_frame) {
7470 uint32_t bit_depth = 8;
7471 uint32_t in_bit_depth = 8;
7473 #if CONFIG_VP9_HIGHBITDEPTH
7474 if (cm->use_highbitdepth) {
7475 in_bit_depth = cpi->oxcf.input_bit_depth;
7476 bit_depth = cm->bit_depth;
7480 if (cpi->b_calculate_psnr) {
7481 YV12_BUFFER_CONFIG *orig = cpi->raw_source_frame;
7482 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
7483 YV12_BUFFER_CONFIG *pp = &cm->post_proc_buffer;
7485 #if CONFIG_VP9_HIGHBITDEPTH
7486 vpx_calc_highbd_psnr(orig, recon, &psnr, cpi->td.mb.e_mbd.bd,
7489 vpx_calc_psnr(orig, recon, &psnr);
7490 #endif // CONFIG_VP9_HIGHBITDEPTH
7492 adjust_image_stat(psnr.psnr[1], psnr.psnr[2], psnr.psnr[3],
7493 psnr.psnr[0], &cpi->psnr);
7494 cpi->total_sq_error += psnr.sse[0];
7495 cpi->total_samples += psnr.samples[0];
7496 samples = psnr.samples[0];
7500 double frame_ssim2 = 0, weight = 0;
7501 #if CONFIG_VP9_POSTPROC
7502 if (vpx_alloc_frame_buffer(
7503 pp, recon->y_crop_width, recon->y_crop_height,
7504 cm->subsampling_x, cm->subsampling_y,
7505 #if CONFIG_VP9_HIGHBITDEPTH
7506 cm->use_highbitdepth,
7508 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment) < 0) {
7509 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
7510 "Failed to allocate post processing buffer");
7513 vp9_ppflags_t ppflags;
7514 ppflags.post_proc_flag = VP9D_DEBLOCK;
7515 ppflags.deblocking_level = 0; // not used in vp9_post_proc_frame()
7516 ppflags.noise_level = 0; // not used in vp9_post_proc_frame()
7517 vp9_post_proc_frame(cm, pp, &ppflags,
7518 cpi->un_scaled_source->y_width);
7521 vpx_clear_system_state();
7523 #if CONFIG_VP9_HIGHBITDEPTH
7524 vpx_calc_highbd_psnr(orig, pp, &psnr2, cpi->td.mb.e_mbd.bd,
7525 cpi->oxcf.input_bit_depth);
7527 vpx_calc_psnr(orig, pp, &psnr2);
7528 #endif // CONFIG_VP9_HIGHBITDEPTH
7530 cpi->totalp_sq_error += psnr2.sse[0];
7531 cpi->totalp_samples += psnr2.samples[0];
7532 adjust_image_stat(psnr2.psnr[1], psnr2.psnr[2], psnr2.psnr[3],
7533 psnr2.psnr[0], &cpi->psnrp);
7535 #if CONFIG_VP9_HIGHBITDEPTH
7536 if (cm->use_highbitdepth) {
7537 frame_ssim2 = vpx_highbd_calc_ssim(orig, recon, &weight, bit_depth,
7540 frame_ssim2 = vpx_calc_ssim(orig, recon, &weight);
7543 frame_ssim2 = vpx_calc_ssim(orig, recon, &weight);
7544 #endif // CONFIG_VP9_HIGHBITDEPTH
7546 cpi->worst_ssim = VPXMIN(cpi->worst_ssim, frame_ssim2);
7547 cpi->summed_quality += frame_ssim2 * weight;
7548 cpi->summed_weights += weight;
7550 #if CONFIG_VP9_HIGHBITDEPTH
7551 if (cm->use_highbitdepth) {
7552 frame_ssim2 = vpx_highbd_calc_ssim(orig, pp, &weight, bit_depth,
7555 frame_ssim2 = vpx_calc_ssim(orig, pp, &weight);
7558 frame_ssim2 = vpx_calc_ssim(orig, pp, &weight);
7559 #endif // CONFIG_VP9_HIGHBITDEPTH
7561 cpi->summedp_quality += frame_ssim2 * weight;
7562 cpi->summedp_weights += weight;
7564 if (cm->show_frame) {
7565 FILE *f = fopen("q_used.stt", "a");
7566 fprintf(f, "%5d : Y%f7.3:U%f7.3:V%f7.3:F%f7.3:S%7.3f\n",
7567 cpi->common.current_video_frame, psnr2.psnr[1],
7568 psnr2.psnr[2], psnr2.psnr[3], psnr2.psnr[0], frame_ssim2);
7574 if (cpi->b_calculate_blockiness) {
7575 #if CONFIG_VP9_HIGHBITDEPTH
7576 if (!cm->use_highbitdepth)
7579 double frame_blockiness = vp9_get_blockiness(
7580 cpi->Source->y_buffer, cpi->Source->y_stride,
7581 cm->frame_to_show->y_buffer, cm->frame_to_show->y_stride,
7582 cpi->Source->y_width, cpi->Source->y_height);
7583 cpi->worst_blockiness =
7584 VPXMAX(cpi->worst_blockiness, frame_blockiness);
7585 cpi->total_blockiness += frame_blockiness;
7589 if (cpi->b_calculate_consistency) {
7590 #if CONFIG_VP9_HIGHBITDEPTH
7591 if (!cm->use_highbitdepth)
7594 double this_inconsistency = vpx_get_ssim_metrics(
7595 cpi->Source->y_buffer, cpi->Source->y_stride,
7596 cm->frame_to_show->y_buffer, cm->frame_to_show->y_stride,
7597 cpi->Source->y_width, cpi->Source->y_height, cpi->ssim_vars,
7600 const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1);
7601 double consistency =
7602 vpx_sse_to_psnr(samples, peak, (double)cpi->total_inconsistency);
7603 if (consistency > 0.0)
7604 cpi->worst_consistency =
7605 VPXMIN(cpi->worst_consistency, consistency);
7606 cpi->total_inconsistency += this_inconsistency;
7611 double y, u, v, frame_all;
7612 frame_all = vpx_calc_fastssim(cpi->Source, cm->frame_to_show, &y, &u,
7613 &v, bit_depth, in_bit_depth);
7614 adjust_image_stat(y, u, v, frame_all, &cpi->fastssim);
7617 double y, u, v, frame_all;
7618 frame_all = vpx_psnrhvs(cpi->Source, cm->frame_to_show, &y, &u, &v,
7619 bit_depth, in_bit_depth);
7620 adjust_image_stat(y, u, v, frame_all, &cpi->psnrhvs);
7627 if (is_one_pass_cbr_svc(cpi)) {
7628 if (cm->show_frame) {
7629 ++cpi->svc.spatial_layer_to_encode;
7630 if (cpi->svc.spatial_layer_to_encode >= cpi->svc.number_spatial_layers)
7631 cpi->svc.spatial_layer_to_encode = 0;
7635 vpx_clear_system_state();
7639 int vp9_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest,
7640 vp9_ppflags_t *flags) {
7641 VP9_COMMON *cm = &cpi->common;
7642 #if !CONFIG_VP9_POSTPROC
7646 if (!cm->show_frame) {
7650 #if CONFIG_VP9_POSTPROC
7651 ret = vp9_post_proc_frame(cm, dest, flags, cpi->un_scaled_source->y_width);
7653 if (cm->frame_to_show) {
7654 *dest = *cm->frame_to_show;
7655 dest->y_width = cm->width;
7656 dest->y_height = cm->height;
7657 dest->uv_width = cm->width >> cm->subsampling_x;
7658 dest->uv_height = cm->height >> cm->subsampling_y;
7663 #endif // !CONFIG_VP9_POSTPROC
7664 vpx_clear_system_state();
7669 int vp9_set_internal_size(VP9_COMP *cpi, VPX_SCALING horiz_mode,
7670 VPX_SCALING vert_mode) {
7671 VP9_COMMON *cm = &cpi->common;
7672 int hr = 0, hs = 0, vr = 0, vs = 0;
7674 if (horiz_mode > ONETWO || vert_mode > ONETWO) return -1;
7676 Scale2Ratio(horiz_mode, &hr, &hs);
7677 Scale2Ratio(vert_mode, &vr, &vs);
7679 // always go to the next whole number
7680 cm->width = (hs - 1 + cpi->oxcf.width * hr) / hs;
7681 cm->height = (vs - 1 + cpi->oxcf.height * vr) / vs;
7682 if (cm->current_video_frame) {
7683 assert(cm->width <= cpi->initial_width);
7684 assert(cm->height <= cpi->initial_height);
7687 update_frame_size(cpi);
7692 int vp9_set_size_literal(VP9_COMP *cpi, unsigned int width,
7693 unsigned int height) {
7694 VP9_COMMON *cm = &cpi->common;
7695 #if CONFIG_VP9_HIGHBITDEPTH
7696 update_initial_width(cpi, cm->use_highbitdepth, 1, 1);
7698 update_initial_width(cpi, 0, 1, 1);
7699 #endif // CONFIG_VP9_HIGHBITDEPTH
7701 #if CONFIG_VP9_TEMPORAL_DENOISING
7702 setup_denoiser_buffer(cpi);
7704 alloc_raw_frame_buffers(cpi);
7707 if (cm->width > cpi->initial_width) {
7708 cm->width = cpi->initial_width;
7709 printf("Warning: Desired width too large, changed to %d\n", cm->width);
7714 cm->height = height;
7715 if (cm->height > cpi->initial_height) {
7716 cm->height = cpi->initial_height;
7717 printf("Warning: Desired height too large, changed to %d\n", cm->height);
7720 assert(cm->width <= cpi->initial_width);
7721 assert(cm->height <= cpi->initial_height);
7723 update_frame_size(cpi);
7728 void vp9_set_svc(VP9_COMP *cpi, int use_svc) {
7729 cpi->use_svc = use_svc;
7733 int vp9_get_quantizer(const VP9_COMP *cpi) { return cpi->common.base_qindex; }
7735 void vp9_apply_encoding_flags(VP9_COMP *cpi, vpx_enc_frame_flags_t flags) {
7737 (VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF)) {
7740 if (flags & VP8_EFLAG_NO_REF_LAST) ref ^= VP9_LAST_FLAG;
7742 if (flags & VP8_EFLAG_NO_REF_GF) ref ^= VP9_GOLD_FLAG;
7744 if (flags & VP8_EFLAG_NO_REF_ARF) ref ^= VP9_ALT_FLAG;
7746 vp9_use_as_reference(cpi, ref);
7750 (VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
7751 VP8_EFLAG_FORCE_GF | VP8_EFLAG_FORCE_ARF)) {
7754 if (flags & VP8_EFLAG_NO_UPD_LAST) upd ^= VP9_LAST_FLAG;
7756 if (flags & VP8_EFLAG_NO_UPD_GF) upd ^= VP9_GOLD_FLAG;
7758 if (flags & VP8_EFLAG_NO_UPD_ARF) upd ^= VP9_ALT_FLAG;
7760 vp9_update_reference(cpi, upd);
7763 if (flags & VP8_EFLAG_NO_UPD_ENTROPY) {
7764 vp9_update_entropy(cpi, 0);
7768 void vp9_set_row_mt(VP9_COMP *cpi) {
7769 // Enable row based multi-threading for supported modes of encoding
7771 if (((cpi->oxcf.mode == GOOD || cpi->oxcf.mode == BEST) &&
7772 cpi->oxcf.speed < 5 && cpi->oxcf.pass == 1) &&
7773 cpi->oxcf.row_mt && !cpi->use_svc)
7776 if (cpi->oxcf.mode == GOOD && cpi->oxcf.speed < 5 &&
7777 (cpi->oxcf.pass == 0 || cpi->oxcf.pass == 2) && cpi->oxcf.row_mt &&
7781 // In realtime mode, enable row based multi-threading for all the speed levels
7782 // where non-rd path is used.
7783 if (cpi->oxcf.mode == REALTIME && cpi->oxcf.speed >= 5 && cpi->oxcf.row_mt) {
7788 cpi->row_mt_bit_exact = 1;
7790 cpi->row_mt_bit_exact = 0;