2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
16 #include "./vp9_rtcd.h"
17 #include "./vpx_config.h"
18 #include "./vpx_dsp_rtcd.h"
19 #include "./vpx_scale_rtcd.h"
20 #include "vpx_dsp/psnr.h"
21 #include "vpx_dsp/vpx_dsp_common.h"
22 #include "vpx_dsp/vpx_filter.h"
23 #if CONFIG_INTERNAL_STATS
24 #include "vpx_dsp/ssim.h"
26 #include "vpx_ports/mem.h"
27 #include "vpx_ports/system_state.h"
28 #include "vpx_ports/vpx_timer.h"
29 #if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
30 #include "vpx_util/vpx_debug_util.h"
31 #endif // CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
33 #include "vp9/common/vp9_alloccommon.h"
34 #include "vp9/common/vp9_filter.h"
35 #include "vp9/common/vp9_idct.h"
36 #if CONFIG_NON_GREEDY_MV
37 #include "vp9/common/vp9_mvref_common.h"
39 #if CONFIG_VP9_POSTPROC
40 #include "vp9/common/vp9_postproc.h"
42 #include "vp9/common/vp9_reconinter.h"
43 #include "vp9/common/vp9_reconintra.h"
44 #include "vp9/common/vp9_tile_common.h"
45 #include "vp9/common/vp9_scan.h"
47 #if !CONFIG_REALTIME_ONLY
48 #include "vp9/encoder/vp9_alt_ref_aq.h"
49 #include "vp9/encoder/vp9_aq_360.h"
50 #include "vp9/encoder/vp9_aq_complexity.h"
52 #include "vp9/encoder/vp9_aq_cyclicrefresh.h"
53 #if !CONFIG_REALTIME_ONLY
54 #include "vp9/encoder/vp9_aq_variance.h"
56 #include "vp9/encoder/vp9_bitstream.h"
57 #if CONFIG_INTERNAL_STATS
58 #include "vp9/encoder/vp9_blockiness.h"
60 #include "vp9/encoder/vp9_context_tree.h"
61 #include "vp9/encoder/vp9_encodeframe.h"
62 #include "vp9/encoder/vp9_encodemb.h"
63 #include "vp9/encoder/vp9_encodemv.h"
64 #include "vp9/encoder/vp9_encoder.h"
65 #include "vp9/encoder/vp9_ethread.h"
66 #include "vp9/encoder/vp9_extend.h"
67 #include "vp9/encoder/vp9_firstpass.h"
68 #include "vp9/encoder/vp9_mbgraph.h"
69 #if CONFIG_NON_GREEDY_MV
70 #include "vp9/encoder/vp9_mcomp.h"
72 #include "vp9/encoder/vp9_multi_thread.h"
73 #include "vp9/encoder/vp9_noise_estimate.h"
74 #include "vp9/encoder/vp9_picklpf.h"
75 #include "vp9/encoder/vp9_ratectrl.h"
76 #include "vp9/encoder/vp9_rd.h"
77 #include "vp9/encoder/vp9_resize.h"
78 #include "vp9/encoder/vp9_segmentation.h"
79 #include "vp9/encoder/vp9_skin_detection.h"
80 #include "vp9/encoder/vp9_speed_features.h"
81 #include "vp9/encoder/vp9_svc_layercontext.h"
82 #include "vp9/encoder/vp9_temporal_filter.h"
83 #include "vp9/vp9_cx_iface.h"
85 #define AM_SEGMENT_ID_INACTIVE 7
86 #define AM_SEGMENT_ID_ACTIVE 0
88 // Whether to use high precision mv for altref computation.
89 #define ALTREF_HIGH_PRECISION_MV 1
91 // Q threshold for high precision mv. Choose a very high value for now so that
92 // HIGH_PRECISION is always chosen.
93 #define HIGH_PRECISION_MV_QTHRESH 200
95 #define FRAME_SIZE_FACTOR 128 // empirical params for context model threshold
96 #define FRAME_RATE_FACTOR 8
98 #ifdef OUTPUT_YUV_DENOISED
99 FILE *yuv_denoised_file = NULL;
101 #ifdef OUTPUT_YUV_SKINMAP
102 static FILE *yuv_skinmap_file = NULL;
104 #ifdef OUTPUT_YUV_REC
107 #ifdef OUTPUT_YUV_SVC_SRC
108 FILE *yuv_svc_src[3] = { NULL, NULL, NULL };
117 #ifdef ENABLE_KF_DENOISE
118 // Test condition for spatial denoise of source.
119 static int is_spatial_denoise_enabled(VP9_COMP *cpi) {
120 VP9_COMMON *const cm = &cpi->common;
121 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
123 return (oxcf->pass != 1) && !is_lossless_requested(&cpi->oxcf) &&
124 frame_is_intra_only(cm);
128 #if CONFIG_VP9_HIGHBITDEPTH
129 void highbd_wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
132 void wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
135 #if !CONFIG_REALTIME_ONLY
136 // compute adaptive threshold for skip recoding
137 static int compute_context_model_thresh(const VP9_COMP *const cpi) {
138 const VP9_COMMON *const cm = &cpi->common;
139 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
140 const int frame_size = (cm->width * cm->height) >> 10;
141 const int bitrate = (int)(oxcf->target_bandwidth >> 10);
142 const int qindex_factor = cm->base_qindex + (MAXQ >> 1);
144 // This equation makes the threshold adaptive to frame size.
145 // Coding gain obtained by recoding comes from alternate frames of large
146 // content change. We skip recoding if the difference of previous and current
147 // frame context probability model is less than a certain threshold.
148 // The first component is the most critical part to guarantee adaptivity.
149 // Other parameters are estimated based on normal setting of hd resolution
150 // parameters. e.g frame_size = 1920x1080, bitrate = 8000, qindex_factor < 50
152 ((FRAME_SIZE_FACTOR * frame_size - FRAME_RATE_FACTOR * bitrate) *
159 // compute the total cost difference between current
160 // and previous frame context prob model.
161 static int compute_context_model_diff(const VP9_COMMON *const cm) {
162 const FRAME_CONTEXT *const pre_fc =
163 &cm->frame_contexts[cm->frame_context_idx];
164 const FRAME_CONTEXT *const cur_fc = cm->fc;
165 const FRAME_COUNTS *counts = &cm->counts;
166 vpx_prob pre_last_prob, cur_last_prob;
168 int i, j, k, l, m, n;
171 for (i = 0; i < BLOCK_SIZE_GROUPS; ++i) {
172 for (j = 0; j < INTRA_MODES - 1; ++j) {
173 diff += (int)counts->y_mode[i][j] *
174 (pre_fc->y_mode_prob[i][j] - cur_fc->y_mode_prob[i][j]);
176 pre_last_prob = MAX_PROB - pre_fc->y_mode_prob[i][INTRA_MODES - 2];
177 cur_last_prob = MAX_PROB - cur_fc->y_mode_prob[i][INTRA_MODES - 2];
179 diff += (int)counts->y_mode[i][INTRA_MODES - 1] *
180 (pre_last_prob - cur_last_prob);
184 for (i = 0; i < INTRA_MODES; ++i) {
185 for (j = 0; j < INTRA_MODES - 1; ++j) {
186 diff += (int)counts->uv_mode[i][j] *
187 (pre_fc->uv_mode_prob[i][j] - cur_fc->uv_mode_prob[i][j]);
189 pre_last_prob = MAX_PROB - pre_fc->uv_mode_prob[i][INTRA_MODES - 2];
190 cur_last_prob = MAX_PROB - cur_fc->uv_mode_prob[i][INTRA_MODES - 2];
192 diff += (int)counts->uv_mode[i][INTRA_MODES - 1] *
193 (pre_last_prob - cur_last_prob);
197 for (i = 0; i < PARTITION_CONTEXTS; ++i) {
198 for (j = 0; j < PARTITION_TYPES - 1; ++j) {
199 diff += (int)counts->partition[i][j] *
200 (pre_fc->partition_prob[i][j] - cur_fc->partition_prob[i][j]);
202 pre_last_prob = MAX_PROB - pre_fc->partition_prob[i][PARTITION_TYPES - 2];
203 cur_last_prob = MAX_PROB - cur_fc->partition_prob[i][PARTITION_TYPES - 2];
205 diff += (int)counts->partition[i][PARTITION_TYPES - 1] *
206 (pre_last_prob - cur_last_prob);
210 for (i = 0; i < TX_SIZES; ++i) {
211 for (j = 0; j < PLANE_TYPES; ++j) {
212 for (k = 0; k < REF_TYPES; ++k) {
213 for (l = 0; l < COEF_BANDS; ++l) {
214 for (m = 0; m < BAND_COEFF_CONTEXTS(l); ++m) {
215 for (n = 0; n < UNCONSTRAINED_NODES; ++n) {
216 diff += (int)counts->coef[i][j][k][l][m][n] *
217 (pre_fc->coef_probs[i][j][k][l][m][n] -
218 cur_fc->coef_probs[i][j][k][l][m][n]);
223 pre_fc->coef_probs[i][j][k][l][m][UNCONSTRAINED_NODES - 1];
226 cur_fc->coef_probs[i][j][k][l][m][UNCONSTRAINED_NODES - 1];
228 diff += (int)counts->coef[i][j][k][l][m][UNCONSTRAINED_NODES] *
229 (pre_last_prob - cur_last_prob);
236 // switchable_interp_prob
237 for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i) {
238 for (j = 0; j < SWITCHABLE_FILTERS - 1; ++j) {
239 diff += (int)counts->switchable_interp[i][j] *
240 (pre_fc->switchable_interp_prob[i][j] -
241 cur_fc->switchable_interp_prob[i][j]);
244 MAX_PROB - pre_fc->switchable_interp_prob[i][SWITCHABLE_FILTERS - 2];
246 MAX_PROB - cur_fc->switchable_interp_prob[i][SWITCHABLE_FILTERS - 2];
248 diff += (int)counts->switchable_interp[i][SWITCHABLE_FILTERS - 1] *
249 (pre_last_prob - cur_last_prob);
253 for (i = 0; i < INTER_MODE_CONTEXTS; ++i) {
254 for (j = 0; j < INTER_MODES - 1; ++j) {
255 diff += (int)counts->inter_mode[i][j] *
256 (pre_fc->inter_mode_probs[i][j] - cur_fc->inter_mode_probs[i][j]);
258 pre_last_prob = MAX_PROB - pre_fc->inter_mode_probs[i][INTER_MODES - 2];
259 cur_last_prob = MAX_PROB - cur_fc->inter_mode_probs[i][INTER_MODES - 2];
261 diff += (int)counts->inter_mode[i][INTER_MODES - 1] *
262 (pre_last_prob - cur_last_prob);
266 for (i = 0; i < INTRA_INTER_CONTEXTS; ++i) {
267 diff += (int)counts->intra_inter[i][0] *
268 (pre_fc->intra_inter_prob[i] - cur_fc->intra_inter_prob[i]);
270 pre_last_prob = MAX_PROB - pre_fc->intra_inter_prob[i];
271 cur_last_prob = MAX_PROB - cur_fc->intra_inter_prob[i];
273 diff += (int)counts->intra_inter[i][1] * (pre_last_prob - cur_last_prob);
277 for (i = 0; i < COMP_INTER_CONTEXTS; ++i) {
278 diff += (int)counts->comp_inter[i][0] *
279 (pre_fc->comp_inter_prob[i] - cur_fc->comp_inter_prob[i]);
281 pre_last_prob = MAX_PROB - pre_fc->comp_inter_prob[i];
282 cur_last_prob = MAX_PROB - cur_fc->comp_inter_prob[i];
284 diff += (int)counts->comp_inter[i][1] * (pre_last_prob - cur_last_prob);
288 for (i = 0; i < REF_CONTEXTS; ++i) {
289 for (j = 0; j < 2; ++j) {
290 diff += (int)counts->single_ref[i][j][0] *
291 (pre_fc->single_ref_prob[i][j] - cur_fc->single_ref_prob[i][j]);
293 pre_last_prob = MAX_PROB - pre_fc->single_ref_prob[i][j];
294 cur_last_prob = MAX_PROB - cur_fc->single_ref_prob[i][j];
297 (int)counts->single_ref[i][j][1] * (pre_last_prob - cur_last_prob);
302 for (i = 0; i < REF_CONTEXTS; ++i) {
303 diff += (int)counts->comp_ref[i][0] *
304 (pre_fc->comp_ref_prob[i] - cur_fc->comp_ref_prob[i]);
306 pre_last_prob = MAX_PROB - pre_fc->comp_ref_prob[i];
307 cur_last_prob = MAX_PROB - cur_fc->comp_ref_prob[i];
309 diff += (int)counts->comp_ref[i][1] * (pre_last_prob - cur_last_prob);
313 for (i = 0; i < TX_SIZE_CONTEXTS; ++i) {
315 for (j = 0; j < TX_SIZES - 1; ++j) {
316 diff += (int)counts->tx.p32x32[i][j] *
317 (pre_fc->tx_probs.p32x32[i][j] - cur_fc->tx_probs.p32x32[i][j]);
319 pre_last_prob = MAX_PROB - pre_fc->tx_probs.p32x32[i][TX_SIZES - 2];
320 cur_last_prob = MAX_PROB - cur_fc->tx_probs.p32x32[i][TX_SIZES - 2];
322 diff += (int)counts->tx.p32x32[i][TX_SIZES - 1] *
323 (pre_last_prob - cur_last_prob);
326 for (j = 0; j < TX_SIZES - 2; ++j) {
327 diff += (int)counts->tx.p16x16[i][j] *
328 (pre_fc->tx_probs.p16x16[i][j] - cur_fc->tx_probs.p16x16[i][j]);
330 pre_last_prob = MAX_PROB - pre_fc->tx_probs.p16x16[i][TX_SIZES - 3];
331 cur_last_prob = MAX_PROB - cur_fc->tx_probs.p16x16[i][TX_SIZES - 3];
333 diff += (int)counts->tx.p16x16[i][TX_SIZES - 2] *
334 (pre_last_prob - cur_last_prob);
337 for (j = 0; j < TX_SIZES - 3; ++j) {
338 diff += (int)counts->tx.p8x8[i][j] *
339 (pre_fc->tx_probs.p8x8[i][j] - cur_fc->tx_probs.p8x8[i][j]);
341 pre_last_prob = MAX_PROB - pre_fc->tx_probs.p8x8[i][TX_SIZES - 4];
342 cur_last_prob = MAX_PROB - cur_fc->tx_probs.p8x8[i][TX_SIZES - 4];
345 (int)counts->tx.p8x8[i][TX_SIZES - 3] * (pre_last_prob - cur_last_prob);
349 for (i = 0; i < SKIP_CONTEXTS; ++i) {
350 diff += (int)counts->skip[i][0] *
351 (pre_fc->skip_probs[i] - cur_fc->skip_probs[i]);
353 pre_last_prob = MAX_PROB - pre_fc->skip_probs[i];
354 cur_last_prob = MAX_PROB - cur_fc->skip_probs[i];
356 diff += (int)counts->skip[i][1] * (pre_last_prob - cur_last_prob);
360 for (i = 0; i < MV_JOINTS - 1; ++i) {
361 diff += (int)counts->mv.joints[i] *
362 (pre_fc->nmvc.joints[i] - cur_fc->nmvc.joints[i]);
364 pre_last_prob = MAX_PROB - pre_fc->nmvc.joints[MV_JOINTS - 2];
365 cur_last_prob = MAX_PROB - cur_fc->nmvc.joints[MV_JOINTS - 2];
368 (int)counts->mv.joints[MV_JOINTS - 1] * (pre_last_prob - cur_last_prob);
370 for (i = 0; i < 2; ++i) {
371 const nmv_component_counts *nmv_count = &counts->mv.comps[i];
372 const nmv_component *pre_nmv_prob = &pre_fc->nmvc.comps[i];
373 const nmv_component *cur_nmv_prob = &cur_fc->nmvc.comps[i];
376 diff += (int)nmv_count->sign[0] * (pre_nmv_prob->sign - cur_nmv_prob->sign);
378 pre_last_prob = MAX_PROB - pre_nmv_prob->sign;
379 cur_last_prob = MAX_PROB - cur_nmv_prob->sign;
381 diff += (int)nmv_count->sign[1] * (pre_last_prob - cur_last_prob);
384 for (j = 0; j < MV_CLASSES - 1; ++j) {
385 diff += (int)nmv_count->classes[j] *
386 (pre_nmv_prob->classes[j] - cur_nmv_prob->classes[j]);
388 pre_last_prob = MAX_PROB - pre_nmv_prob->classes[MV_CLASSES - 2];
389 cur_last_prob = MAX_PROB - cur_nmv_prob->classes[MV_CLASSES - 2];
391 diff += (int)nmv_count->classes[MV_CLASSES - 1] *
392 (pre_last_prob - cur_last_prob);
395 for (j = 0; j < CLASS0_SIZE - 1; ++j) {
396 diff += (int)nmv_count->class0[j] *
397 (pre_nmv_prob->class0[j] - cur_nmv_prob->class0[j]);
399 pre_last_prob = MAX_PROB - pre_nmv_prob->class0[CLASS0_SIZE - 2];
400 cur_last_prob = MAX_PROB - cur_nmv_prob->class0[CLASS0_SIZE - 2];
402 diff += (int)nmv_count->class0[CLASS0_SIZE - 1] *
403 (pre_last_prob - cur_last_prob);
406 for (j = 0; j < MV_OFFSET_BITS; ++j) {
407 diff += (int)nmv_count->bits[j][0] *
408 (pre_nmv_prob->bits[j] - cur_nmv_prob->bits[j]);
410 pre_last_prob = MAX_PROB - pre_nmv_prob->bits[j];
411 cur_last_prob = MAX_PROB - cur_nmv_prob->bits[j];
413 diff += (int)nmv_count->bits[j][1] * (pre_last_prob - cur_last_prob);
417 for (j = 0; j < CLASS0_SIZE; ++j) {
418 for (k = 0; k < MV_FP_SIZE - 1; ++k) {
419 diff += (int)nmv_count->class0_fp[j][k] *
420 (pre_nmv_prob->class0_fp[j][k] - cur_nmv_prob->class0_fp[j][k]);
422 pre_last_prob = MAX_PROB - pre_nmv_prob->class0_fp[j][MV_FP_SIZE - 2];
423 cur_last_prob = MAX_PROB - cur_nmv_prob->class0_fp[j][MV_FP_SIZE - 2];
425 diff += (int)nmv_count->class0_fp[j][MV_FP_SIZE - 1] *
426 (pre_last_prob - cur_last_prob);
430 for (j = 0; j < MV_FP_SIZE - 1; ++j) {
432 (int)nmv_count->fp[j] * (pre_nmv_prob->fp[j] - cur_nmv_prob->fp[j]);
434 pre_last_prob = MAX_PROB - pre_nmv_prob->fp[MV_FP_SIZE - 2];
435 cur_last_prob = MAX_PROB - cur_nmv_prob->fp[MV_FP_SIZE - 2];
438 (int)nmv_count->fp[MV_FP_SIZE - 1] * (pre_last_prob - cur_last_prob);
441 diff += (int)nmv_count->class0_hp[0] *
442 (pre_nmv_prob->class0_hp - cur_nmv_prob->class0_hp);
444 pre_last_prob = MAX_PROB - pre_nmv_prob->class0_hp;
445 cur_last_prob = MAX_PROB - cur_nmv_prob->class0_hp;
447 diff += (int)nmv_count->class0_hp[1] * (pre_last_prob - cur_last_prob);
450 diff += (int)nmv_count->hp[0] * (pre_nmv_prob->hp - cur_nmv_prob->hp);
452 pre_last_prob = MAX_PROB - pre_nmv_prob->hp;
453 cur_last_prob = MAX_PROB - cur_nmv_prob->hp;
455 diff += (int)nmv_count->hp[1] * (pre_last_prob - cur_last_prob);
460 #endif // !CONFIG_REALTIME_ONLY
462 // Test for whether to calculate metrics for the frame.
463 static int is_psnr_calc_enabled(const VP9_COMP *cpi) {
464 const VP9_COMMON *const cm = &cpi->common;
465 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
467 return cpi->b_calculate_psnr && (oxcf->pass != 1) && cm->show_frame;
470 /* clang-format off */
471 const Vp9LevelSpec vp9_level_defs[VP9_LEVELS] = {
472 // sample rate size breadth bitrate cpb
473 { LEVEL_1, 829440, 36864, 512, 200, 400, 2, 1, 4, 8 },
474 { LEVEL_1_1, 2764800, 73728, 768, 800, 1000, 2, 1, 4, 8 },
475 { LEVEL_2, 4608000, 122880, 960, 1800, 1500, 2, 1, 4, 8 },
476 { LEVEL_2_1, 9216000, 245760, 1344, 3600, 2800, 2, 2, 4, 8 },
477 { LEVEL_3, 20736000, 552960, 2048, 7200, 6000, 2, 4, 4, 8 },
478 { LEVEL_3_1, 36864000, 983040, 2752, 12000, 10000, 2, 4, 4, 8 },
479 { LEVEL_4, 83558400, 2228224, 4160, 18000, 16000, 4, 4, 4, 8 },
480 { LEVEL_4_1, 160432128, 2228224, 4160, 30000, 18000, 4, 4, 5, 6 },
481 { LEVEL_5, 311951360, 8912896, 8384, 60000, 36000, 6, 8, 6, 4 },
482 { LEVEL_5_1, 588251136, 8912896, 8384, 120000, 46000, 8, 8, 10, 4 },
483 // TODO(huisu): update max_cpb_size for level 5_2 ~ 6_2 when
484 // they are finalized (currently tentative).
485 { LEVEL_5_2, 1176502272, 8912896, 8384, 180000, 90000, 8, 8, 10, 4 },
486 { LEVEL_6, 1176502272, 35651584, 16832, 180000, 90000, 8, 16, 10, 4 },
487 { LEVEL_6_1, 2353004544u, 35651584, 16832, 240000, 180000, 8, 16, 10, 4 },
488 { LEVEL_6_2, 4706009088u, 35651584, 16832, 480000, 360000, 8, 16, 10, 4 },
490 /* clang-format on */
492 static const char *level_fail_messages[TARGET_LEVEL_FAIL_IDS] = {
493 "The average bit-rate is too high.",
494 "The picture size is too large.",
495 "The picture width/height is too large.",
496 "The luma sample rate is too large.",
497 "The CPB size is too large.",
498 "The compression ratio is too small",
499 "Too many column tiles are used.",
500 "The alt-ref distance is too small.",
501 "Too many reference buffers are used."
504 static INLINE void Scale2Ratio(VPX_SCALING mode, int *hr, int *hs) {
519 assert(mode == ONETWO);
526 // Mark all inactive blocks as active. Other segmentation features may be set
527 // so memset cannot be used, instead only inactive blocks should be reset.
528 static void suppress_active_map(VP9_COMP *cpi) {
529 unsigned char *const seg_map = cpi->segmentation_map;
531 if (cpi->active_map.enabled || cpi->active_map.update) {
532 const int rows = cpi->common.mi_rows;
533 const int cols = cpi->common.mi_cols;
536 for (i = 0; i < rows * cols; ++i)
537 if (seg_map[i] == AM_SEGMENT_ID_INACTIVE)
538 seg_map[i] = AM_SEGMENT_ID_ACTIVE;
542 static void apply_active_map(VP9_COMP *cpi) {
543 struct segmentation *const seg = &cpi->common.seg;
544 unsigned char *const seg_map = cpi->segmentation_map;
545 const unsigned char *const active_map = cpi->active_map.map;
548 assert(AM_SEGMENT_ID_ACTIVE == CR_SEGMENT_ID_BASE);
550 if (frame_is_intra_only(&cpi->common)) {
551 cpi->active_map.enabled = 0;
552 cpi->active_map.update = 1;
555 if (cpi->active_map.update) {
556 if (cpi->active_map.enabled) {
557 for (i = 0; i < cpi->common.mi_rows * cpi->common.mi_cols; ++i)
558 if (seg_map[i] == AM_SEGMENT_ID_ACTIVE) seg_map[i] = active_map[i];
559 vp9_enable_segmentation(seg);
560 vp9_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_SKIP);
561 vp9_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF);
562 // Setting the data to -MAX_LOOP_FILTER will result in the computed loop
563 // filter level being zero regardless of the value of seg->abs_delta.
564 vp9_set_segdata(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF,
567 vp9_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_SKIP);
568 vp9_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF);
570 seg->update_data = 1;
574 cpi->active_map.update = 0;
578 static void apply_roi_map(VP9_COMP *cpi) {
579 VP9_COMMON *cm = &cpi->common;
580 struct segmentation *const seg = &cm->seg;
581 vpx_roi_map_t *roi = &cpi->roi;
582 const int *delta_q = roi->delta_q;
583 const int *delta_lf = roi->delta_lf;
584 const int *skip = roi->skip;
586 int internal_delta_q[MAX_SEGMENTS];
588 static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG,
591 // TODO(jianj): Investigate why ROI not working in speed < 5 or in non
593 if (cpi->oxcf.mode != REALTIME || cpi->oxcf.speed < 5) return;
594 if (!roi->enabled) return;
596 memcpy(&ref_frame, roi->ref_frame, sizeof(ref_frame));
598 vp9_enable_segmentation(seg);
599 vp9_clearall_segfeatures(seg);
600 // Select delta coding method;
601 seg->abs_delta = SEGMENT_DELTADATA;
603 memcpy(cpi->segmentation_map, roi->roi_map, (cm->mi_rows * cm->mi_cols));
605 for (i = 0; i < MAX_SEGMENTS; ++i) {
606 // Translate the external delta q values to internal values.
607 internal_delta_q[i] = vp9_quantizer_to_qindex(abs(delta_q[i]));
608 if (delta_q[i] < 0) internal_delta_q[i] = -internal_delta_q[i];
609 vp9_disable_segfeature(seg, i, SEG_LVL_ALT_Q);
610 vp9_disable_segfeature(seg, i, SEG_LVL_ALT_LF);
611 if (internal_delta_q[i] != 0) {
612 vp9_enable_segfeature(seg, i, SEG_LVL_ALT_Q);
613 vp9_set_segdata(seg, i, SEG_LVL_ALT_Q, internal_delta_q[i]);
615 if (delta_lf[i] != 0) {
616 vp9_enable_segfeature(seg, i, SEG_LVL_ALT_LF);
617 vp9_set_segdata(seg, i, SEG_LVL_ALT_LF, delta_lf[i]);
620 vp9_enable_segfeature(seg, i, SEG_LVL_SKIP);
621 vp9_set_segdata(seg, i, SEG_LVL_SKIP, skip[i]);
623 if (ref_frame[i] >= 0) {
625 // ALTREF is not used as reference for nonrd_pickmode with 0 lag.
626 if (ref_frame[i] == ALTREF_FRAME && cpi->sf.use_nonrd_pick_mode)
628 // If GOLDEN is selected, make sure it's set as reference.
629 if (ref_frame[i] == GOLDEN_FRAME &&
630 !(cpi->ref_frame_flags & flag_list[ref_frame[i]])) {
633 // GOLDEN was updated in previous encoded frame, so GOLDEN and LAST are
635 if (ref_frame[i] == GOLDEN_FRAME && cpi->rc.frames_since_golden == 0)
636 ref_frame[i] = LAST_FRAME;
638 vp9_enable_segfeature(seg, i, SEG_LVL_REF_FRAME);
639 vp9_set_segdata(seg, i, SEG_LVL_REF_FRAME, ref_frame[i]);
646 static void init_level_info(Vp9LevelInfo *level_info) {
647 Vp9LevelStats *const level_stats = &level_info->level_stats;
648 Vp9LevelSpec *const level_spec = &level_info->level_spec;
650 memset(level_stats, 0, sizeof(*level_stats));
651 memset(level_spec, 0, sizeof(*level_spec));
652 level_spec->level = LEVEL_UNKNOWN;
653 level_spec->min_altref_distance = INT_MAX;
656 static int check_seg_range(int seg_data[8], int range) {
657 return !(abs(seg_data[0]) > range || abs(seg_data[1]) > range ||
658 abs(seg_data[2]) > range || abs(seg_data[3]) > range ||
659 abs(seg_data[4]) > range || abs(seg_data[5]) > range ||
660 abs(seg_data[6]) > range || abs(seg_data[7]) > range);
663 VP9_LEVEL vp9_get_level(const Vp9LevelSpec *const level_spec) {
665 const Vp9LevelSpec *this_level;
667 vpx_clear_system_state();
669 for (i = 0; i < VP9_LEVELS; ++i) {
670 this_level = &vp9_level_defs[i];
671 if ((double)level_spec->max_luma_sample_rate >
672 (double)this_level->max_luma_sample_rate *
673 (1 + SAMPLE_RATE_GRACE_P) ||
674 level_spec->max_luma_picture_size > this_level->max_luma_picture_size ||
675 level_spec->max_luma_picture_breadth >
676 this_level->max_luma_picture_breadth ||
677 level_spec->average_bitrate > this_level->average_bitrate ||
678 level_spec->max_cpb_size > this_level->max_cpb_size ||
679 level_spec->compression_ratio < this_level->compression_ratio ||
680 level_spec->max_col_tiles > this_level->max_col_tiles ||
681 level_spec->min_altref_distance < this_level->min_altref_distance ||
682 level_spec->max_ref_frame_buffers > this_level->max_ref_frame_buffers)
686 return (i == VP9_LEVELS) ? LEVEL_UNKNOWN : vp9_level_defs[i].level;
689 int vp9_set_roi_map(VP9_COMP *cpi, unsigned char *map, unsigned int rows,
690 unsigned int cols, int delta_q[8], int delta_lf[8],
691 int skip[8], int ref_frame[8]) {
692 VP9_COMMON *cm = &cpi->common;
693 vpx_roi_map_t *roi = &cpi->roi;
694 const int range = 63;
695 const int ref_frame_range = 3; // Alt-ref
696 const int skip_range = 1;
697 const int frame_rows = cpi->common.mi_rows;
698 const int frame_cols = cpi->common.mi_cols;
700 // Check number of rows and columns match
701 if (frame_rows != (int)rows || frame_cols != (int)cols) {
705 if (!check_seg_range(delta_q, range) || !check_seg_range(delta_lf, range) ||
706 !check_seg_range(ref_frame, ref_frame_range) ||
707 !check_seg_range(skip, skip_range))
710 // Also disable segmentation if no deltas are specified.
712 (!(delta_q[0] | delta_q[1] | delta_q[2] | delta_q[3] | delta_q[4] |
713 delta_q[5] | delta_q[6] | delta_q[7] | delta_lf[0] | delta_lf[1] |
714 delta_lf[2] | delta_lf[3] | delta_lf[4] | delta_lf[5] | delta_lf[6] |
715 delta_lf[7] | skip[0] | skip[1] | skip[2] | skip[3] | skip[4] |
716 skip[5] | skip[6] | skip[7]) &&
717 (ref_frame[0] == -1 && ref_frame[1] == -1 && ref_frame[2] == -1 &&
718 ref_frame[3] == -1 && ref_frame[4] == -1 && ref_frame[5] == -1 &&
719 ref_frame[6] == -1 && ref_frame[7] == -1))) {
720 vp9_disable_segmentation(&cm->seg);
721 cpi->roi.enabled = 0;
726 vpx_free(roi->roi_map);
729 CHECK_MEM_ERROR(cm, roi->roi_map, vpx_malloc(rows * cols));
731 // Copy to ROI sturcture in the compressor.
732 memcpy(roi->roi_map, map, rows * cols);
733 memcpy(&roi->delta_q, delta_q, MAX_SEGMENTS * sizeof(delta_q[0]));
734 memcpy(&roi->delta_lf, delta_lf, MAX_SEGMENTS * sizeof(delta_lf[0]));
735 memcpy(&roi->skip, skip, MAX_SEGMENTS * sizeof(skip[0]));
736 memcpy(&roi->ref_frame, ref_frame, MAX_SEGMENTS * sizeof(ref_frame[0]));
744 int vp9_set_active_map(VP9_COMP *cpi, unsigned char *new_map_16x16, int rows,
746 if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols) {
747 unsigned char *const active_map_8x8 = cpi->active_map.map;
748 const int mi_rows = cpi->common.mi_rows;
749 const int mi_cols = cpi->common.mi_cols;
750 cpi->active_map.update = 1;
753 for (r = 0; r < mi_rows; ++r) {
754 for (c = 0; c < mi_cols; ++c) {
755 active_map_8x8[r * mi_cols + c] =
756 new_map_16x16[(r >> 1) * cols + (c >> 1)]
757 ? AM_SEGMENT_ID_ACTIVE
758 : AM_SEGMENT_ID_INACTIVE;
761 cpi->active_map.enabled = 1;
763 cpi->active_map.enabled = 0;
771 int vp9_get_active_map(VP9_COMP *cpi, unsigned char *new_map_16x16, int rows,
773 if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols &&
775 unsigned char *const seg_map_8x8 = cpi->segmentation_map;
776 const int mi_rows = cpi->common.mi_rows;
777 const int mi_cols = cpi->common.mi_cols;
778 memset(new_map_16x16, !cpi->active_map.enabled, rows * cols);
779 if (cpi->active_map.enabled) {
781 for (r = 0; r < mi_rows; ++r) {
782 for (c = 0; c < mi_cols; ++c) {
783 // Cyclic refresh segments are considered active despite not having
784 // AM_SEGMENT_ID_ACTIVE
785 new_map_16x16[(r >> 1) * cols + (c >> 1)] |=
786 seg_map_8x8[r * mi_cols + c] != AM_SEGMENT_ID_INACTIVE;
796 void vp9_set_high_precision_mv(VP9_COMP *cpi, int allow_high_precision_mv) {
797 MACROBLOCK *const mb = &cpi->td.mb;
798 cpi->common.allow_high_precision_mv = allow_high_precision_mv;
799 if (cpi->common.allow_high_precision_mv) {
800 mb->mvcost = mb->nmvcost_hp;
801 mb->mvsadcost = mb->nmvsadcost_hp;
803 mb->mvcost = mb->nmvcost;
804 mb->mvsadcost = mb->nmvsadcost;
808 static void setup_frame(VP9_COMP *cpi) {
809 VP9_COMMON *const cm = &cpi->common;
810 // Set up entropy context depending on frame type. The decoder mandates
811 // the use of the default context, index 0, for keyframes and inter
812 // frames where the error_resilient_mode or intra_only flag is set. For
813 // other inter-frames the encoder currently uses only two contexts;
814 // context 1 for ALTREF frames and context 0 for the others.
815 if (frame_is_intra_only(cm) || cm->error_resilient_mode) {
816 vp9_setup_past_independence(cm);
818 if (!cpi->use_svc) cm->frame_context_idx = cpi->refresh_alt_ref_frame;
821 // TODO(jingning): Overwrite the frame_context_idx index in multi-layer ARF
822 // case. Need some further investigation on if we could apply this to single
823 // layer ARF case as well.
824 if (cpi->multi_layer_arf && !cpi->use_svc) {
825 GF_GROUP *const gf_group = &cpi->twopass.gf_group;
826 const int gf_group_index = gf_group->index;
827 const int boost_frame =
828 !cpi->rc.is_src_frame_alt_ref &&
829 (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame);
831 // frame_context_idx Frame Type
832 // 0 Intra only frame, base layer ARF
833 // 1 ARFs with layer depth = 2,3
834 // 2 ARFs with layer depth > 3
835 // 3 Non-boosted frames
836 if (frame_is_intra_only(cm)) {
837 cm->frame_context_idx = 0;
838 } else if (boost_frame) {
839 if (gf_group->rf_level[gf_group_index] == GF_ARF_STD)
840 cm->frame_context_idx = 0;
841 else if (gf_group->layer_depth[gf_group_index] <= 3)
842 cm->frame_context_idx = 1;
844 cm->frame_context_idx = 2;
846 cm->frame_context_idx = 3;
850 if (cm->frame_type == KEY_FRAME) {
851 cpi->refresh_golden_frame = 1;
852 cpi->refresh_alt_ref_frame = 1;
853 vp9_zero(cpi->interp_filter_selected);
855 *cm->fc = cm->frame_contexts[cm->frame_context_idx];
856 vp9_zero(cpi->interp_filter_selected[0]);
860 static void vp9_enc_setup_mi(VP9_COMMON *cm) {
862 cm->mi = cm->mip + cm->mi_stride + 1;
863 memset(cm->mip, 0, cm->mi_stride * (cm->mi_rows + 1) * sizeof(*cm->mip));
864 cm->prev_mi = cm->prev_mip + cm->mi_stride + 1;
865 // Clear top border row
866 memset(cm->prev_mip, 0, sizeof(*cm->prev_mip) * cm->mi_stride);
867 // Clear left border column
868 for (i = 1; i < cm->mi_rows + 1; ++i)
869 memset(&cm->prev_mip[i * cm->mi_stride], 0, sizeof(*cm->prev_mip));
871 cm->mi_grid_visible = cm->mi_grid_base + cm->mi_stride + 1;
872 cm->prev_mi_grid_visible = cm->prev_mi_grid_base + cm->mi_stride + 1;
874 memset(cm->mi_grid_base, 0,
875 cm->mi_stride * (cm->mi_rows + 1) * sizeof(*cm->mi_grid_base));
878 static int vp9_enc_alloc_mi(VP9_COMMON *cm, int mi_size) {
879 cm->mip = vpx_calloc(mi_size, sizeof(*cm->mip));
880 if (!cm->mip) return 1;
881 cm->prev_mip = vpx_calloc(mi_size, sizeof(*cm->prev_mip));
882 if (!cm->prev_mip) return 1;
883 cm->mi_alloc_size = mi_size;
885 cm->mi_grid_base = (MODE_INFO **)vpx_calloc(mi_size, sizeof(MODE_INFO *));
886 if (!cm->mi_grid_base) return 1;
887 cm->prev_mi_grid_base =
888 (MODE_INFO **)vpx_calloc(mi_size, sizeof(MODE_INFO *));
889 if (!cm->prev_mi_grid_base) return 1;
894 static void vp9_enc_free_mi(VP9_COMMON *cm) {
897 vpx_free(cm->prev_mip);
899 vpx_free(cm->mi_grid_base);
900 cm->mi_grid_base = NULL;
901 vpx_free(cm->prev_mi_grid_base);
902 cm->prev_mi_grid_base = NULL;
903 cm->mi_alloc_size = 0;
906 static void vp9_swap_mi_and_prev_mi(VP9_COMMON *cm) {
907 // Current mip will be the prev_mip for the next frame.
908 MODE_INFO **temp_base = cm->prev_mi_grid_base;
909 MODE_INFO *temp = cm->prev_mip;
911 // Skip update prev_mi frame in show_existing_frame mode.
912 if (cm->show_existing_frame) return;
914 cm->prev_mip = cm->mip;
917 // Update the upper left visible macroblock ptrs.
918 cm->mi = cm->mip + cm->mi_stride + 1;
919 cm->prev_mi = cm->prev_mip + cm->mi_stride + 1;
921 cm->prev_mi_grid_base = cm->mi_grid_base;
922 cm->mi_grid_base = temp_base;
923 cm->mi_grid_visible = cm->mi_grid_base + cm->mi_stride + 1;
924 cm->prev_mi_grid_visible = cm->prev_mi_grid_base + cm->mi_stride + 1;
927 void vp9_initialize_enc(void) {
928 static volatile int init_done = 0;
934 vp9_init_intra_predictors();
936 vp9_rc_init_minq_luts();
937 vp9_entropy_mv_init();
938 #if !CONFIG_REALTIME_ONLY
939 vp9_temporal_filter_init();
945 static void dealloc_compressor_data(VP9_COMP *cpi) {
946 VP9_COMMON *const cm = &cpi->common;
949 vpx_free(cpi->mbmi_ext_base);
950 cpi->mbmi_ext_base = NULL;
952 vpx_free(cpi->tile_data);
953 cpi->tile_data = NULL;
955 vpx_free(cpi->segmentation_map);
956 cpi->segmentation_map = NULL;
957 vpx_free(cpi->coding_context.last_frame_seg_map_copy);
958 cpi->coding_context.last_frame_seg_map_copy = NULL;
960 vpx_free(cpi->nmvcosts[0]);
961 vpx_free(cpi->nmvcosts[1]);
962 cpi->nmvcosts[0] = NULL;
963 cpi->nmvcosts[1] = NULL;
965 vpx_free(cpi->nmvcosts_hp[0]);
966 vpx_free(cpi->nmvcosts_hp[1]);
967 cpi->nmvcosts_hp[0] = NULL;
968 cpi->nmvcosts_hp[1] = NULL;
970 vpx_free(cpi->nmvsadcosts[0]);
971 vpx_free(cpi->nmvsadcosts[1]);
972 cpi->nmvsadcosts[0] = NULL;
973 cpi->nmvsadcosts[1] = NULL;
975 vpx_free(cpi->nmvsadcosts_hp[0]);
976 vpx_free(cpi->nmvsadcosts_hp[1]);
977 cpi->nmvsadcosts_hp[0] = NULL;
978 cpi->nmvsadcosts_hp[1] = NULL;
980 vpx_free(cpi->skin_map);
981 cpi->skin_map = NULL;
983 vpx_free(cpi->prev_partition);
984 cpi->prev_partition = NULL;
986 vpx_free(cpi->svc.prev_partition_svc);
987 cpi->svc.prev_partition_svc = NULL;
989 vpx_free(cpi->prev_segment_id);
990 cpi->prev_segment_id = NULL;
992 vpx_free(cpi->prev_variance_low);
993 cpi->prev_variance_low = NULL;
995 vpx_free(cpi->copied_frame_cnt);
996 cpi->copied_frame_cnt = NULL;
998 vpx_free(cpi->content_state_sb_fd);
999 cpi->content_state_sb_fd = NULL;
1001 vpx_free(cpi->count_arf_frame_usage);
1002 cpi->count_arf_frame_usage = NULL;
1003 vpx_free(cpi->count_lastgolden_frame_usage);
1004 cpi->count_lastgolden_frame_usage = NULL;
1006 vp9_cyclic_refresh_free(cpi->cyclic_refresh);
1007 cpi->cyclic_refresh = NULL;
1009 vpx_free(cpi->active_map.map);
1010 cpi->active_map.map = NULL;
1012 vpx_free(cpi->roi.roi_map);
1013 cpi->roi.roi_map = NULL;
1015 vpx_free(cpi->consec_zero_mv);
1016 cpi->consec_zero_mv = NULL;
1018 vpx_free(cpi->mb_wiener_variance);
1019 cpi->mb_wiener_variance = NULL;
1021 vpx_free(cpi->mi_ssim_rdmult_scaling_factors);
1022 cpi->mi_ssim_rdmult_scaling_factors = NULL;
1024 vp9_free_ref_frame_buffers(cm->buffer_pool);
1025 #if CONFIG_VP9_POSTPROC
1026 vp9_free_postproc_buffers(cm);
1028 vp9_free_context_buffers(cm);
1030 vpx_free_frame_buffer(&cpi->last_frame_uf);
1031 vpx_free_frame_buffer(&cpi->scaled_source);
1032 vpx_free_frame_buffer(&cpi->scaled_last_source);
1033 vpx_free_frame_buffer(&cpi->alt_ref_buffer);
1034 #ifdef ENABLE_KF_DENOISE
1035 vpx_free_frame_buffer(&cpi->raw_unscaled_source);
1036 vpx_free_frame_buffer(&cpi->raw_scaled_source);
1039 vp9_lookahead_destroy(cpi->lookahead);
1041 vpx_free(cpi->tile_tok[0][0]);
1042 cpi->tile_tok[0][0] = 0;
1044 vpx_free(cpi->tplist[0][0]);
1045 cpi->tplist[0][0] = NULL;
1047 vp9_free_pc_tree(&cpi->td);
1049 for (i = 0; i < cpi->svc.number_spatial_layers; ++i) {
1050 LAYER_CONTEXT *const lc = &cpi->svc.layer_context[i];
1051 vpx_free(lc->rc_twopass_stats_in.buf);
1052 lc->rc_twopass_stats_in.buf = NULL;
1053 lc->rc_twopass_stats_in.sz = 0;
1056 if (cpi->source_diff_var != NULL) {
1057 vpx_free(cpi->source_diff_var);
1058 cpi->source_diff_var = NULL;
1061 for (i = 0; i < MAX_LAG_BUFFERS; ++i) {
1062 vpx_free_frame_buffer(&cpi->svc.scaled_frames[i]);
1064 memset(&cpi->svc.scaled_frames[0], 0,
1065 MAX_LAG_BUFFERS * sizeof(cpi->svc.scaled_frames[0]));
1067 vpx_free_frame_buffer(&cpi->svc.scaled_temp);
1068 memset(&cpi->svc.scaled_temp, 0, sizeof(cpi->svc.scaled_temp));
1070 vpx_free_frame_buffer(&cpi->svc.empty_frame.img);
1071 memset(&cpi->svc.empty_frame, 0, sizeof(cpi->svc.empty_frame));
1073 vp9_free_svc_cyclic_refresh(cpi);
1076 static void save_coding_context(VP9_COMP *cpi) {
1077 CODING_CONTEXT *const cc = &cpi->coding_context;
1078 VP9_COMMON *cm = &cpi->common;
1080 // Stores a snapshot of key state variables which can subsequently be
1081 // restored with a call to vp9_restore_coding_context. These functions are
1082 // intended for use in a re-code loop in vp9_compress_frame where the
1083 // quantizer value is adjusted between loop iterations.
1084 vp9_copy(cc->nmvjointcost, cpi->td.mb.nmvjointcost);
1086 memcpy(cc->nmvcosts[0], cpi->nmvcosts[0],
1087 MV_VALS * sizeof(*cpi->nmvcosts[0]));
1088 memcpy(cc->nmvcosts[1], cpi->nmvcosts[1],
1089 MV_VALS * sizeof(*cpi->nmvcosts[1]));
1090 memcpy(cc->nmvcosts_hp[0], cpi->nmvcosts_hp[0],
1091 MV_VALS * sizeof(*cpi->nmvcosts_hp[0]));
1092 memcpy(cc->nmvcosts_hp[1], cpi->nmvcosts_hp[1],
1093 MV_VALS * sizeof(*cpi->nmvcosts_hp[1]));
1095 vp9_copy(cc->segment_pred_probs, cm->seg.pred_probs);
1097 memcpy(cpi->coding_context.last_frame_seg_map_copy, cm->last_frame_seg_map,
1098 (cm->mi_rows * cm->mi_cols));
1100 vp9_copy(cc->last_ref_lf_deltas, cm->lf.last_ref_deltas);
1101 vp9_copy(cc->last_mode_lf_deltas, cm->lf.last_mode_deltas);
1106 static void restore_coding_context(VP9_COMP *cpi) {
1107 CODING_CONTEXT *const cc = &cpi->coding_context;
1108 VP9_COMMON *cm = &cpi->common;
1110 // Restore key state variables to the snapshot state stored in the
1111 // previous call to vp9_save_coding_context.
1112 vp9_copy(cpi->td.mb.nmvjointcost, cc->nmvjointcost);
1114 memcpy(cpi->nmvcosts[0], cc->nmvcosts[0], MV_VALS * sizeof(*cc->nmvcosts[0]));
1115 memcpy(cpi->nmvcosts[1], cc->nmvcosts[1], MV_VALS * sizeof(*cc->nmvcosts[1]));
1116 memcpy(cpi->nmvcosts_hp[0], cc->nmvcosts_hp[0],
1117 MV_VALS * sizeof(*cc->nmvcosts_hp[0]));
1118 memcpy(cpi->nmvcosts_hp[1], cc->nmvcosts_hp[1],
1119 MV_VALS * sizeof(*cc->nmvcosts_hp[1]));
1121 vp9_copy(cm->seg.pred_probs, cc->segment_pred_probs);
1123 memcpy(cm->last_frame_seg_map, cpi->coding_context.last_frame_seg_map_copy,
1124 (cm->mi_rows * cm->mi_cols));
1126 vp9_copy(cm->lf.last_ref_deltas, cc->last_ref_lf_deltas);
1127 vp9_copy(cm->lf.last_mode_deltas, cc->last_mode_lf_deltas);
1132 #if !CONFIG_REALTIME_ONLY
1133 static void configure_static_seg_features(VP9_COMP *cpi) {
1134 VP9_COMMON *const cm = &cpi->common;
1135 const RATE_CONTROL *const rc = &cpi->rc;
1136 struct segmentation *const seg = &cm->seg;
1138 int high_q = (int)(rc->avg_q > 48.0);
1141 // Disable and clear down for KF
1142 if (cm->frame_type == KEY_FRAME) {
1143 // Clear down the global segmentation map
1144 memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
1145 seg->update_map = 0;
1146 seg->update_data = 0;
1147 cpi->static_mb_pct = 0;
1149 // Disable segmentation
1150 vp9_disable_segmentation(seg);
1152 // Clear down the segment features.
1153 vp9_clearall_segfeatures(seg);
1154 } else if (cpi->refresh_alt_ref_frame) {
1155 // If this is an alt ref frame
1156 // Clear down the global segmentation map
1157 memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
1158 seg->update_map = 0;
1159 seg->update_data = 0;
1160 cpi->static_mb_pct = 0;
1162 // Disable segmentation and individual segment features by default
1163 vp9_disable_segmentation(seg);
1164 vp9_clearall_segfeatures(seg);
1166 // Scan frames from current to arf frame.
1167 // This function re-enables segmentation if appropriate.
1168 vp9_update_mbgraph_stats(cpi);
1170 // If segmentation was enabled set those features needed for the
1173 seg->update_map = 1;
1174 seg->update_data = 1;
1177 vp9_compute_qdelta(rc, rc->avg_q, rc->avg_q * 0.875, cm->bit_depth);
1178 vp9_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta - 2);
1179 vp9_set_segdata(seg, 1, SEG_LVL_ALT_LF, -2);
1181 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
1182 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_LF);
1184 // Where relevant assume segment data is delta data
1185 seg->abs_delta = SEGMENT_DELTADATA;
1187 } else if (seg->enabled) {
1188 // All other frames if segmentation has been enabled
1190 // First normal frame in a valid gf or alt ref group
1191 if (rc->frames_since_golden == 0) {
1192 // Set up segment features for normal frames in an arf group
1193 if (rc->source_alt_ref_active) {
1194 seg->update_map = 0;
1195 seg->update_data = 1;
1196 seg->abs_delta = SEGMENT_DELTADATA;
1199 vp9_compute_qdelta(rc, rc->avg_q, rc->avg_q * 1.125, cm->bit_depth);
1200 vp9_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta + 2);
1201 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
1203 vp9_set_segdata(seg, 1, SEG_LVL_ALT_LF, -2);
1204 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_LF);
1206 // Segment coding disabled for compred testing
1207 if (high_q || (cpi->static_mb_pct == 100)) {
1208 vp9_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME);
1209 vp9_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME);
1210 vp9_enable_segfeature(seg, 1, SEG_LVL_SKIP);
1213 // Disable segmentation and clear down features if alt ref
1214 // is not active for this group
1216 vp9_disable_segmentation(seg);
1218 memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
1220 seg->update_map = 0;
1221 seg->update_data = 0;
1223 vp9_clearall_segfeatures(seg);
1225 } else if (rc->is_src_frame_alt_ref) {
1226 // Special case where we are coding over the top of a previous
1228 // Segment coding disabled for compred testing
1230 // Enable ref frame features for segment 0 as well
1231 vp9_enable_segfeature(seg, 0, SEG_LVL_REF_FRAME);
1232 vp9_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME);
1234 // All mbs should use ALTREF_FRAME
1235 vp9_clear_segdata(seg, 0, SEG_LVL_REF_FRAME);
1236 vp9_set_segdata(seg, 0, SEG_LVL_REF_FRAME, ALTREF_FRAME);
1237 vp9_clear_segdata(seg, 1, SEG_LVL_REF_FRAME);
1238 vp9_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME);
1240 // Skip all MBs if high Q (0,0 mv and skip coeffs)
1242 vp9_enable_segfeature(seg, 0, SEG_LVL_SKIP);
1243 vp9_enable_segfeature(seg, 1, SEG_LVL_SKIP);
1245 // Enable data update
1246 seg->update_data = 1;
1248 // All other frames.
1250 // No updates.. leave things as they are.
1251 seg->update_map = 0;
1252 seg->update_data = 0;
1256 #endif // !CONFIG_REALTIME_ONLY
1258 static void update_reference_segmentation_map(VP9_COMP *cpi) {
1259 VP9_COMMON *const cm = &cpi->common;
1260 MODE_INFO **mi_8x8_ptr = cm->mi_grid_visible;
1261 uint8_t *cache_ptr = cm->last_frame_seg_map;
1264 for (row = 0; row < cm->mi_rows; row++) {
1265 MODE_INFO **mi_8x8 = mi_8x8_ptr;
1266 uint8_t *cache = cache_ptr;
1267 for (col = 0; col < cm->mi_cols; col++, mi_8x8++, cache++)
1268 cache[0] = mi_8x8[0]->segment_id;
1269 mi_8x8_ptr += cm->mi_stride;
1270 cache_ptr += cm->mi_cols;
1274 static void alloc_raw_frame_buffers(VP9_COMP *cpi) {
1275 VP9_COMMON *cm = &cpi->common;
1276 const VP9EncoderConfig *oxcf = &cpi->oxcf;
1278 if (!cpi->lookahead)
1279 cpi->lookahead = vp9_lookahead_init(oxcf->width, oxcf->height,
1280 cm->subsampling_x, cm->subsampling_y,
1281 #if CONFIG_VP9_HIGHBITDEPTH
1282 cm->use_highbitdepth,
1284 oxcf->lag_in_frames);
1285 if (!cpi->lookahead)
1286 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1287 "Failed to allocate lag buffers");
1289 // TODO(agrange) Check if ARF is enabled and skip allocation if not.
1290 if (vpx_realloc_frame_buffer(&cpi->alt_ref_buffer, oxcf->width, oxcf->height,
1291 cm->subsampling_x, cm->subsampling_y,
1292 #if CONFIG_VP9_HIGHBITDEPTH
1293 cm->use_highbitdepth,
1295 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1297 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1298 "Failed to allocate altref buffer");
1301 static void alloc_util_frame_buffers(VP9_COMP *cpi) {
1302 VP9_COMMON *const cm = &cpi->common;
1303 if (vpx_realloc_frame_buffer(&cpi->last_frame_uf, cm->width, cm->height,
1304 cm->subsampling_x, cm->subsampling_y,
1305 #if CONFIG_VP9_HIGHBITDEPTH
1306 cm->use_highbitdepth,
1308 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1310 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1311 "Failed to allocate last frame buffer");
1313 if (vpx_realloc_frame_buffer(&cpi->scaled_source, cm->width, cm->height,
1314 cm->subsampling_x, cm->subsampling_y,
1315 #if CONFIG_VP9_HIGHBITDEPTH
1316 cm->use_highbitdepth,
1318 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1320 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1321 "Failed to allocate scaled source buffer");
1323 // For 1 pass cbr: allocate scaled_frame that may be used as an intermediate
1324 // buffer for a 2 stage down-sampling: two stages of 1:2 down-sampling for a
1325 // target of 1/4x1/4. number_spatial_layers must be greater than 2.
1326 if (is_one_pass_cbr_svc(cpi) && !cpi->svc.scaled_temp_is_alloc &&
1327 cpi->svc.number_spatial_layers > 2) {
1328 cpi->svc.scaled_temp_is_alloc = 1;
1329 if (vpx_realloc_frame_buffer(
1330 &cpi->svc.scaled_temp, cm->width >> 1, cm->height >> 1,
1331 cm->subsampling_x, cm->subsampling_y,
1332 #if CONFIG_VP9_HIGHBITDEPTH
1333 cm->use_highbitdepth,
1335 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment, NULL, NULL, NULL))
1336 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1337 "Failed to allocate scaled_frame for svc ");
1340 if (vpx_realloc_frame_buffer(&cpi->scaled_last_source, cm->width, cm->height,
1341 cm->subsampling_x, cm->subsampling_y,
1342 #if CONFIG_VP9_HIGHBITDEPTH
1343 cm->use_highbitdepth,
1345 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1347 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1348 "Failed to allocate scaled last source buffer");
1349 #ifdef ENABLE_KF_DENOISE
1350 if (vpx_realloc_frame_buffer(&cpi->raw_unscaled_source, cm->width, cm->height,
1351 cm->subsampling_x, cm->subsampling_y,
1352 #if CONFIG_VP9_HIGHBITDEPTH
1353 cm->use_highbitdepth,
1355 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1357 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1358 "Failed to allocate unscaled raw source frame buffer");
1360 if (vpx_realloc_frame_buffer(&cpi->raw_scaled_source, cm->width, cm->height,
1361 cm->subsampling_x, cm->subsampling_y,
1362 #if CONFIG_VP9_HIGHBITDEPTH
1363 cm->use_highbitdepth,
1365 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
1367 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
1368 "Failed to allocate scaled raw source frame buffer");
1372 static int alloc_context_buffers_ext(VP9_COMP *cpi) {
1373 VP9_COMMON *cm = &cpi->common;
1374 int mi_size = cm->mi_cols * cm->mi_rows;
1376 cpi->mbmi_ext_base = vpx_calloc(mi_size, sizeof(*cpi->mbmi_ext_base));
1377 if (!cpi->mbmi_ext_base) return 1;
1382 static void alloc_compressor_data(VP9_COMP *cpi) {
1383 VP9_COMMON *cm = &cpi->common;
1386 vp9_alloc_context_buffers(cm, cm->width, cm->height);
1388 alloc_context_buffers_ext(cpi);
1390 vpx_free(cpi->tile_tok[0][0]);
1393 unsigned int tokens = get_token_alloc(cm->mb_rows, cm->mb_cols);
1394 CHECK_MEM_ERROR(cm, cpi->tile_tok[0][0],
1395 vpx_calloc(tokens, sizeof(*cpi->tile_tok[0][0])));
1398 sb_rows = mi_cols_aligned_to_sb(cm->mi_rows) >> MI_BLOCK_SIZE_LOG2;
1399 vpx_free(cpi->tplist[0][0]);
1401 cm, cpi->tplist[0][0],
1402 vpx_calloc(sb_rows * 4 * (1 << 6), sizeof(*cpi->tplist[0][0])));
1404 vp9_setup_pc_tree(&cpi->common, &cpi->td);
1407 void vp9_new_framerate(VP9_COMP *cpi, double framerate) {
1408 cpi->framerate = framerate < 0.1 ? 30 : framerate;
1409 vp9_rc_update_framerate(cpi);
1412 static void set_tile_limits(VP9_COMP *cpi) {
1413 VP9_COMMON *const cm = &cpi->common;
1415 int min_log2_tile_cols, max_log2_tile_cols;
1416 vp9_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols);
1418 cm->log2_tile_cols =
1419 clamp(cpi->oxcf.tile_columns, min_log2_tile_cols, max_log2_tile_cols);
1420 cm->log2_tile_rows = cpi->oxcf.tile_rows;
1422 if (cpi->oxcf.target_level == LEVEL_AUTO) {
1423 const int level_tile_cols =
1424 log_tile_cols_from_picsize_level(cpi->common.width, cpi->common.height);
1425 if (cm->log2_tile_cols > level_tile_cols) {
1426 cm->log2_tile_cols = VPXMAX(level_tile_cols, min_log2_tile_cols);
1431 static void update_frame_size(VP9_COMP *cpi) {
1432 VP9_COMMON *const cm = &cpi->common;
1433 MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
1435 vp9_set_mb_mi(cm, cm->width, cm->height);
1436 vp9_init_context_buffers(cm);
1437 vp9_init_macroblockd(cm, xd, NULL);
1438 cpi->td.mb.mbmi_ext_base = cpi->mbmi_ext_base;
1439 memset(cpi->mbmi_ext_base, 0,
1440 cm->mi_rows * cm->mi_cols * sizeof(*cpi->mbmi_ext_base));
1442 set_tile_limits(cpi);
1445 static void init_buffer_indices(VP9_COMP *cpi) {
1448 for (ref_frame = 0; ref_frame < REF_FRAMES; ++ref_frame)
1449 cpi->ref_fb_idx[ref_frame] = ref_frame;
1451 cpi->lst_fb_idx = cpi->ref_fb_idx[LAST_FRAME - 1];
1452 cpi->gld_fb_idx = cpi->ref_fb_idx[GOLDEN_FRAME - 1];
1453 cpi->alt_fb_idx = cpi->ref_fb_idx[ALTREF_FRAME - 1];
1456 static void init_level_constraint(LevelConstraint *lc) {
1457 lc->level_index = -1;
1458 lc->max_cpb_size = INT_MAX;
1459 lc->max_frame_size = INT_MAX;
1463 static void set_level_constraint(LevelConstraint *ls, int8_t level_index) {
1464 vpx_clear_system_state();
1465 ls->level_index = level_index;
1466 if (level_index >= 0) {
1467 ls->max_cpb_size = vp9_level_defs[level_index].max_cpb_size * (double)1000;
1471 static void init_config(struct VP9_COMP *cpi, const VP9EncoderConfig *oxcf) {
1472 VP9_COMMON *const cm = &cpi->common;
1475 cpi->framerate = oxcf->init_framerate;
1476 cm->profile = oxcf->profile;
1477 cm->bit_depth = oxcf->bit_depth;
1478 #if CONFIG_VP9_HIGHBITDEPTH
1479 cm->use_highbitdepth = oxcf->use_highbitdepth;
1481 cm->color_space = oxcf->color_space;
1482 cm->color_range = oxcf->color_range;
1484 cpi->target_level = oxcf->target_level;
1485 cpi->keep_level_stats = oxcf->target_level != LEVEL_MAX;
1486 set_level_constraint(&cpi->level_constraint,
1487 get_level_index(cpi->target_level));
1489 cm->width = oxcf->width;
1490 cm->height = oxcf->height;
1491 alloc_compressor_data(cpi);
1493 cpi->svc.temporal_layering_mode = oxcf->temporal_layering_mode;
1495 // Single thread case: use counts in common.
1496 cpi->td.counts = &cm->counts;
1498 // Spatial scalability.
1499 cpi->svc.number_spatial_layers = oxcf->ss_number_layers;
1500 // Temporal scalability.
1501 cpi->svc.number_temporal_layers = oxcf->ts_number_layers;
1503 if ((cpi->svc.number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) ||
1504 ((cpi->svc.number_temporal_layers > 1 ||
1505 cpi->svc.number_spatial_layers > 1) &&
1506 cpi->oxcf.pass != 1)) {
1507 vp9_init_layer_context(cpi);
1510 // change includes all joint functionality
1511 vp9_change_config(cpi, oxcf);
1513 cpi->static_mb_pct = 0;
1514 cpi->ref_frame_flags = 0;
1516 init_buffer_indices(cpi);
1518 vp9_noise_estimate_init(&cpi->noise_estimate, cm->width, cm->height);
1521 static void set_rc_buffer_sizes(RATE_CONTROL *rc,
1522 const VP9EncoderConfig *oxcf) {
1523 const int64_t bandwidth = oxcf->target_bandwidth;
1524 const int64_t starting = oxcf->starting_buffer_level_ms;
1525 const int64_t optimal = oxcf->optimal_buffer_level_ms;
1526 const int64_t maximum = oxcf->maximum_buffer_size_ms;
1528 rc->starting_buffer_level = starting * bandwidth / 1000;
1529 rc->optimal_buffer_level =
1530 (optimal == 0) ? bandwidth / 8 : optimal * bandwidth / 1000;
1531 rc->maximum_buffer_size =
1532 (maximum == 0) ? bandwidth / 8 : maximum * bandwidth / 1000;
1535 #if CONFIG_VP9_HIGHBITDEPTH
1536 // TODO(angiebird): make sdx8f available for highbitdepth if needed
1537 #define HIGHBD_BFP(BT, SDF, SDAF, VF, SVF, SVAF, SDX4DF) \
1538 cpi->fn_ptr[BT].sdf = SDF; \
1539 cpi->fn_ptr[BT].sdaf = SDAF; \
1540 cpi->fn_ptr[BT].vf = VF; \
1541 cpi->fn_ptr[BT].svf = SVF; \
1542 cpi->fn_ptr[BT].svaf = SVAF; \
1543 cpi->fn_ptr[BT].sdx4df = SDX4DF; \
1544 cpi->fn_ptr[BT].sdx8f = NULL;
1546 #define MAKE_BFP_SAD_WRAPPER(fnname) \
1547 static unsigned int fnname##_bits8(const uint8_t *src_ptr, \
1548 int source_stride, \
1549 const uint8_t *ref_ptr, int ref_stride) { \
1550 return fnname(src_ptr, source_stride, ref_ptr, ref_stride); \
1552 static unsigned int fnname##_bits10( \
1553 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1555 return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 2; \
1557 static unsigned int fnname##_bits12( \
1558 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1560 return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 4; \
1563 #define MAKE_BFP_SADAVG_WRAPPER(fnname) \
1564 static unsigned int fnname##_bits8( \
1565 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1566 int ref_stride, const uint8_t *second_pred) { \
1567 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred); \
1569 static unsigned int fnname##_bits10( \
1570 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1571 int ref_stride, const uint8_t *second_pred) { \
1572 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred) >> \
1575 static unsigned int fnname##_bits12( \
1576 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
1577 int ref_stride, const uint8_t *second_pred) { \
1578 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred) >> \
1582 #define MAKE_BFP_SAD4D_WRAPPER(fnname) \
1583 static void fnname##_bits8(const uint8_t *src_ptr, int source_stride, \
1584 const uint8_t *const ref_ptr[], int ref_stride, \
1585 unsigned int *sad_array) { \
1586 fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array); \
1588 static void fnname##_bits10(const uint8_t *src_ptr, int source_stride, \
1589 const uint8_t *const ref_ptr[], int ref_stride, \
1590 unsigned int *sad_array) { \
1592 fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array); \
1593 for (i = 0; i < 4; i++) sad_array[i] >>= 2; \
1595 static void fnname##_bits12(const uint8_t *src_ptr, int source_stride, \
1596 const uint8_t *const ref_ptr[], int ref_stride, \
1597 unsigned int *sad_array) { \
1599 fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array); \
1600 for (i = 0; i < 4; i++) sad_array[i] >>= 4; \
1603 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad32x16)
1604 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad32x16_avg)
1605 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad32x16x4d)
1606 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad16x32)
1607 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad16x32_avg)
1608 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad16x32x4d)
1609 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad64x32)
1610 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad64x32_avg)
1611 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad64x32x4d)
1612 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad32x64)
1613 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad32x64_avg)
1614 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad32x64x4d)
1615 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad32x32)
1616 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad32x32_avg)
1617 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad32x32x4d)
1618 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad64x64)
1619 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad64x64_avg)
1620 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad64x64x4d)
1621 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad16x16)
1622 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad16x16_avg)
1623 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad16x16x4d)
1624 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad16x8)
1625 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad16x8_avg)
1626 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad16x8x4d)
1627 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad8x16)
1628 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad8x16_avg)
1629 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad8x16x4d)
1630 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad8x8)
1631 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad8x8_avg)
1632 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad8x8x4d)
1633 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad8x4)
1634 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad8x4_avg)
1635 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad8x4x4d)
1636 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad4x8)
1637 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad4x8_avg)
1638 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad4x8x4d)
1639 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad4x4)
1640 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad4x4_avg)
1641 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad4x4x4d)
1643 static void highbd_set_var_fns(VP9_COMP *const cpi) {
1644 VP9_COMMON *const cm = &cpi->common;
1645 if (cm->use_highbitdepth) {
1646 switch (cm->bit_depth) {
1648 HIGHBD_BFP(BLOCK_32X16, vpx_highbd_sad32x16_bits8,
1649 vpx_highbd_sad32x16_avg_bits8, vpx_highbd_8_variance32x16,
1650 vpx_highbd_8_sub_pixel_variance32x16,
1651 vpx_highbd_8_sub_pixel_avg_variance32x16,
1652 vpx_highbd_sad32x16x4d_bits8)
1654 HIGHBD_BFP(BLOCK_16X32, vpx_highbd_sad16x32_bits8,
1655 vpx_highbd_sad16x32_avg_bits8, vpx_highbd_8_variance16x32,
1656 vpx_highbd_8_sub_pixel_variance16x32,
1657 vpx_highbd_8_sub_pixel_avg_variance16x32,
1658 vpx_highbd_sad16x32x4d_bits8)
1660 HIGHBD_BFP(BLOCK_64X32, vpx_highbd_sad64x32_bits8,
1661 vpx_highbd_sad64x32_avg_bits8, vpx_highbd_8_variance64x32,
1662 vpx_highbd_8_sub_pixel_variance64x32,
1663 vpx_highbd_8_sub_pixel_avg_variance64x32,
1664 vpx_highbd_sad64x32x4d_bits8)
1666 HIGHBD_BFP(BLOCK_32X64, vpx_highbd_sad32x64_bits8,
1667 vpx_highbd_sad32x64_avg_bits8, vpx_highbd_8_variance32x64,
1668 vpx_highbd_8_sub_pixel_variance32x64,
1669 vpx_highbd_8_sub_pixel_avg_variance32x64,
1670 vpx_highbd_sad32x64x4d_bits8)
1672 HIGHBD_BFP(BLOCK_32X32, vpx_highbd_sad32x32_bits8,
1673 vpx_highbd_sad32x32_avg_bits8, vpx_highbd_8_variance32x32,
1674 vpx_highbd_8_sub_pixel_variance32x32,
1675 vpx_highbd_8_sub_pixel_avg_variance32x32,
1676 vpx_highbd_sad32x32x4d_bits8)
1678 HIGHBD_BFP(BLOCK_64X64, vpx_highbd_sad64x64_bits8,
1679 vpx_highbd_sad64x64_avg_bits8, vpx_highbd_8_variance64x64,
1680 vpx_highbd_8_sub_pixel_variance64x64,
1681 vpx_highbd_8_sub_pixel_avg_variance64x64,
1682 vpx_highbd_sad64x64x4d_bits8)
1684 HIGHBD_BFP(BLOCK_16X16, vpx_highbd_sad16x16_bits8,
1685 vpx_highbd_sad16x16_avg_bits8, vpx_highbd_8_variance16x16,
1686 vpx_highbd_8_sub_pixel_variance16x16,
1687 vpx_highbd_8_sub_pixel_avg_variance16x16,
1688 vpx_highbd_sad16x16x4d_bits8)
1690 HIGHBD_BFP(BLOCK_16X8, vpx_highbd_sad16x8_bits8,
1691 vpx_highbd_sad16x8_avg_bits8, vpx_highbd_8_variance16x8,
1692 vpx_highbd_8_sub_pixel_variance16x8,
1693 vpx_highbd_8_sub_pixel_avg_variance16x8,
1694 vpx_highbd_sad16x8x4d_bits8)
1696 HIGHBD_BFP(BLOCK_8X16, vpx_highbd_sad8x16_bits8,
1697 vpx_highbd_sad8x16_avg_bits8, vpx_highbd_8_variance8x16,
1698 vpx_highbd_8_sub_pixel_variance8x16,
1699 vpx_highbd_8_sub_pixel_avg_variance8x16,
1700 vpx_highbd_sad8x16x4d_bits8)
1703 BLOCK_8X8, vpx_highbd_sad8x8_bits8, vpx_highbd_sad8x8_avg_bits8,
1704 vpx_highbd_8_variance8x8, vpx_highbd_8_sub_pixel_variance8x8,
1705 vpx_highbd_8_sub_pixel_avg_variance8x8, vpx_highbd_sad8x8x4d_bits8)
1708 BLOCK_8X4, vpx_highbd_sad8x4_bits8, vpx_highbd_sad8x4_avg_bits8,
1709 vpx_highbd_8_variance8x4, vpx_highbd_8_sub_pixel_variance8x4,
1710 vpx_highbd_8_sub_pixel_avg_variance8x4, vpx_highbd_sad8x4x4d_bits8)
1713 BLOCK_4X8, vpx_highbd_sad4x8_bits8, vpx_highbd_sad4x8_avg_bits8,
1714 vpx_highbd_8_variance4x8, vpx_highbd_8_sub_pixel_variance4x8,
1715 vpx_highbd_8_sub_pixel_avg_variance4x8, vpx_highbd_sad4x8x4d_bits8)
1718 BLOCK_4X4, vpx_highbd_sad4x4_bits8, vpx_highbd_sad4x4_avg_bits8,
1719 vpx_highbd_8_variance4x4, vpx_highbd_8_sub_pixel_variance4x4,
1720 vpx_highbd_8_sub_pixel_avg_variance4x4, vpx_highbd_sad4x4x4d_bits8)
1724 HIGHBD_BFP(BLOCK_32X16, vpx_highbd_sad32x16_bits10,
1725 vpx_highbd_sad32x16_avg_bits10, vpx_highbd_10_variance32x16,
1726 vpx_highbd_10_sub_pixel_variance32x16,
1727 vpx_highbd_10_sub_pixel_avg_variance32x16,
1728 vpx_highbd_sad32x16x4d_bits10)
1730 HIGHBD_BFP(BLOCK_16X32, vpx_highbd_sad16x32_bits10,
1731 vpx_highbd_sad16x32_avg_bits10, vpx_highbd_10_variance16x32,
1732 vpx_highbd_10_sub_pixel_variance16x32,
1733 vpx_highbd_10_sub_pixel_avg_variance16x32,
1734 vpx_highbd_sad16x32x4d_bits10)
1736 HIGHBD_BFP(BLOCK_64X32, vpx_highbd_sad64x32_bits10,
1737 vpx_highbd_sad64x32_avg_bits10, vpx_highbd_10_variance64x32,
1738 vpx_highbd_10_sub_pixel_variance64x32,
1739 vpx_highbd_10_sub_pixel_avg_variance64x32,
1740 vpx_highbd_sad64x32x4d_bits10)
1742 HIGHBD_BFP(BLOCK_32X64, vpx_highbd_sad32x64_bits10,
1743 vpx_highbd_sad32x64_avg_bits10, vpx_highbd_10_variance32x64,
1744 vpx_highbd_10_sub_pixel_variance32x64,
1745 vpx_highbd_10_sub_pixel_avg_variance32x64,
1746 vpx_highbd_sad32x64x4d_bits10)
1748 HIGHBD_BFP(BLOCK_32X32, vpx_highbd_sad32x32_bits10,
1749 vpx_highbd_sad32x32_avg_bits10, vpx_highbd_10_variance32x32,
1750 vpx_highbd_10_sub_pixel_variance32x32,
1751 vpx_highbd_10_sub_pixel_avg_variance32x32,
1752 vpx_highbd_sad32x32x4d_bits10)
1754 HIGHBD_BFP(BLOCK_64X64, vpx_highbd_sad64x64_bits10,
1755 vpx_highbd_sad64x64_avg_bits10, vpx_highbd_10_variance64x64,
1756 vpx_highbd_10_sub_pixel_variance64x64,
1757 vpx_highbd_10_sub_pixel_avg_variance64x64,
1758 vpx_highbd_sad64x64x4d_bits10)
1760 HIGHBD_BFP(BLOCK_16X16, vpx_highbd_sad16x16_bits10,
1761 vpx_highbd_sad16x16_avg_bits10, vpx_highbd_10_variance16x16,
1762 vpx_highbd_10_sub_pixel_variance16x16,
1763 vpx_highbd_10_sub_pixel_avg_variance16x16,
1764 vpx_highbd_sad16x16x4d_bits10)
1766 HIGHBD_BFP(BLOCK_16X8, vpx_highbd_sad16x8_bits10,
1767 vpx_highbd_sad16x8_avg_bits10, vpx_highbd_10_variance16x8,
1768 vpx_highbd_10_sub_pixel_variance16x8,
1769 vpx_highbd_10_sub_pixel_avg_variance16x8,
1770 vpx_highbd_sad16x8x4d_bits10)
1772 HIGHBD_BFP(BLOCK_8X16, vpx_highbd_sad8x16_bits10,
1773 vpx_highbd_sad8x16_avg_bits10, vpx_highbd_10_variance8x16,
1774 vpx_highbd_10_sub_pixel_variance8x16,
1775 vpx_highbd_10_sub_pixel_avg_variance8x16,
1776 vpx_highbd_sad8x16x4d_bits10)
1778 HIGHBD_BFP(BLOCK_8X8, vpx_highbd_sad8x8_bits10,
1779 vpx_highbd_sad8x8_avg_bits10, vpx_highbd_10_variance8x8,
1780 vpx_highbd_10_sub_pixel_variance8x8,
1781 vpx_highbd_10_sub_pixel_avg_variance8x8,
1782 vpx_highbd_sad8x8x4d_bits10)
1784 HIGHBD_BFP(BLOCK_8X4, vpx_highbd_sad8x4_bits10,
1785 vpx_highbd_sad8x4_avg_bits10, vpx_highbd_10_variance8x4,
1786 vpx_highbd_10_sub_pixel_variance8x4,
1787 vpx_highbd_10_sub_pixel_avg_variance8x4,
1788 vpx_highbd_sad8x4x4d_bits10)
1790 HIGHBD_BFP(BLOCK_4X8, vpx_highbd_sad4x8_bits10,
1791 vpx_highbd_sad4x8_avg_bits10, vpx_highbd_10_variance4x8,
1792 vpx_highbd_10_sub_pixel_variance4x8,
1793 vpx_highbd_10_sub_pixel_avg_variance4x8,
1794 vpx_highbd_sad4x8x4d_bits10)
1796 HIGHBD_BFP(BLOCK_4X4, vpx_highbd_sad4x4_bits10,
1797 vpx_highbd_sad4x4_avg_bits10, vpx_highbd_10_variance4x4,
1798 vpx_highbd_10_sub_pixel_variance4x4,
1799 vpx_highbd_10_sub_pixel_avg_variance4x4,
1800 vpx_highbd_sad4x4x4d_bits10)
1804 assert(cm->bit_depth == VPX_BITS_12);
1805 HIGHBD_BFP(BLOCK_32X16, vpx_highbd_sad32x16_bits12,
1806 vpx_highbd_sad32x16_avg_bits12, vpx_highbd_12_variance32x16,
1807 vpx_highbd_12_sub_pixel_variance32x16,
1808 vpx_highbd_12_sub_pixel_avg_variance32x16,
1809 vpx_highbd_sad32x16x4d_bits12)
1811 HIGHBD_BFP(BLOCK_16X32, vpx_highbd_sad16x32_bits12,
1812 vpx_highbd_sad16x32_avg_bits12, vpx_highbd_12_variance16x32,
1813 vpx_highbd_12_sub_pixel_variance16x32,
1814 vpx_highbd_12_sub_pixel_avg_variance16x32,
1815 vpx_highbd_sad16x32x4d_bits12)
1817 HIGHBD_BFP(BLOCK_64X32, vpx_highbd_sad64x32_bits12,
1818 vpx_highbd_sad64x32_avg_bits12, vpx_highbd_12_variance64x32,
1819 vpx_highbd_12_sub_pixel_variance64x32,
1820 vpx_highbd_12_sub_pixel_avg_variance64x32,
1821 vpx_highbd_sad64x32x4d_bits12)
1823 HIGHBD_BFP(BLOCK_32X64, vpx_highbd_sad32x64_bits12,
1824 vpx_highbd_sad32x64_avg_bits12, vpx_highbd_12_variance32x64,
1825 vpx_highbd_12_sub_pixel_variance32x64,
1826 vpx_highbd_12_sub_pixel_avg_variance32x64,
1827 vpx_highbd_sad32x64x4d_bits12)
1829 HIGHBD_BFP(BLOCK_32X32, vpx_highbd_sad32x32_bits12,
1830 vpx_highbd_sad32x32_avg_bits12, vpx_highbd_12_variance32x32,
1831 vpx_highbd_12_sub_pixel_variance32x32,
1832 vpx_highbd_12_sub_pixel_avg_variance32x32,
1833 vpx_highbd_sad32x32x4d_bits12)
1835 HIGHBD_BFP(BLOCK_64X64, vpx_highbd_sad64x64_bits12,
1836 vpx_highbd_sad64x64_avg_bits12, vpx_highbd_12_variance64x64,
1837 vpx_highbd_12_sub_pixel_variance64x64,
1838 vpx_highbd_12_sub_pixel_avg_variance64x64,
1839 vpx_highbd_sad64x64x4d_bits12)
1841 HIGHBD_BFP(BLOCK_16X16, vpx_highbd_sad16x16_bits12,
1842 vpx_highbd_sad16x16_avg_bits12, vpx_highbd_12_variance16x16,
1843 vpx_highbd_12_sub_pixel_variance16x16,
1844 vpx_highbd_12_sub_pixel_avg_variance16x16,
1845 vpx_highbd_sad16x16x4d_bits12)
1847 HIGHBD_BFP(BLOCK_16X8, vpx_highbd_sad16x8_bits12,
1848 vpx_highbd_sad16x8_avg_bits12, vpx_highbd_12_variance16x8,
1849 vpx_highbd_12_sub_pixel_variance16x8,
1850 vpx_highbd_12_sub_pixel_avg_variance16x8,
1851 vpx_highbd_sad16x8x4d_bits12)
1853 HIGHBD_BFP(BLOCK_8X16, vpx_highbd_sad8x16_bits12,
1854 vpx_highbd_sad8x16_avg_bits12, vpx_highbd_12_variance8x16,
1855 vpx_highbd_12_sub_pixel_variance8x16,
1856 vpx_highbd_12_sub_pixel_avg_variance8x16,
1857 vpx_highbd_sad8x16x4d_bits12)
1859 HIGHBD_BFP(BLOCK_8X8, vpx_highbd_sad8x8_bits12,
1860 vpx_highbd_sad8x8_avg_bits12, vpx_highbd_12_variance8x8,
1861 vpx_highbd_12_sub_pixel_variance8x8,
1862 vpx_highbd_12_sub_pixel_avg_variance8x8,
1863 vpx_highbd_sad8x8x4d_bits12)
1865 HIGHBD_BFP(BLOCK_8X4, vpx_highbd_sad8x4_bits12,
1866 vpx_highbd_sad8x4_avg_bits12, vpx_highbd_12_variance8x4,
1867 vpx_highbd_12_sub_pixel_variance8x4,
1868 vpx_highbd_12_sub_pixel_avg_variance8x4,
1869 vpx_highbd_sad8x4x4d_bits12)
1871 HIGHBD_BFP(BLOCK_4X8, vpx_highbd_sad4x8_bits12,
1872 vpx_highbd_sad4x8_avg_bits12, vpx_highbd_12_variance4x8,
1873 vpx_highbd_12_sub_pixel_variance4x8,
1874 vpx_highbd_12_sub_pixel_avg_variance4x8,
1875 vpx_highbd_sad4x8x4d_bits12)
1877 HIGHBD_BFP(BLOCK_4X4, vpx_highbd_sad4x4_bits12,
1878 vpx_highbd_sad4x4_avg_bits12, vpx_highbd_12_variance4x4,
1879 vpx_highbd_12_sub_pixel_variance4x4,
1880 vpx_highbd_12_sub_pixel_avg_variance4x4,
1881 vpx_highbd_sad4x4x4d_bits12)
1886 #endif // CONFIG_VP9_HIGHBITDEPTH
1888 static void realloc_segmentation_maps(VP9_COMP *cpi) {
1889 VP9_COMMON *const cm = &cpi->common;
1891 // Create the encoder segmentation map and set all entries to 0
1892 vpx_free(cpi->segmentation_map);
1893 CHECK_MEM_ERROR(cm, cpi->segmentation_map,
1894 vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1896 // Create a map used for cyclic background refresh.
1897 if (cpi->cyclic_refresh) vp9_cyclic_refresh_free(cpi->cyclic_refresh);
1898 CHECK_MEM_ERROR(cm, cpi->cyclic_refresh,
1899 vp9_cyclic_refresh_alloc(cm->mi_rows, cm->mi_cols));
1901 // Create a map used to mark inactive areas.
1902 vpx_free(cpi->active_map.map);
1903 CHECK_MEM_ERROR(cm, cpi->active_map.map,
1904 vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1906 // And a place holder structure is the coding context
1907 // for use if we want to save and restore it
1908 vpx_free(cpi->coding_context.last_frame_seg_map_copy);
1909 CHECK_MEM_ERROR(cm, cpi->coding_context.last_frame_seg_map_copy,
1910 vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1913 static void alloc_copy_partition_data(VP9_COMP *cpi) {
1914 VP9_COMMON *const cm = &cpi->common;
1915 if (cpi->prev_partition == NULL) {
1916 CHECK_MEM_ERROR(cm, cpi->prev_partition,
1917 (BLOCK_SIZE *)vpx_calloc(cm->mi_stride * cm->mi_rows,
1918 sizeof(*cpi->prev_partition)));
1920 if (cpi->prev_segment_id == NULL) {
1922 cm, cpi->prev_segment_id,
1923 (int8_t *)vpx_calloc((cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1),
1924 sizeof(*cpi->prev_segment_id)));
1926 if (cpi->prev_variance_low == NULL) {
1927 CHECK_MEM_ERROR(cm, cpi->prev_variance_low,
1928 (uint8_t *)vpx_calloc(
1929 (cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1) * 25,
1930 sizeof(*cpi->prev_variance_low)));
1932 if (cpi->copied_frame_cnt == NULL) {
1934 cm, cpi->copied_frame_cnt,
1935 (uint8_t *)vpx_calloc((cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1),
1936 sizeof(*cpi->copied_frame_cnt)));
1940 void vp9_change_config(struct VP9_COMP *cpi, const VP9EncoderConfig *oxcf) {
1941 VP9_COMMON *const cm = &cpi->common;
1942 RATE_CONTROL *const rc = &cpi->rc;
1943 int last_w = cpi->oxcf.width;
1944 int last_h = cpi->oxcf.height;
1946 vp9_init_quantizer(cpi);
1947 if (cm->profile != oxcf->profile) cm->profile = oxcf->profile;
1948 cm->bit_depth = oxcf->bit_depth;
1949 cm->color_space = oxcf->color_space;
1950 cm->color_range = oxcf->color_range;
1952 cpi->target_level = oxcf->target_level;
1953 cpi->keep_level_stats = oxcf->target_level != LEVEL_MAX;
1954 set_level_constraint(&cpi->level_constraint,
1955 get_level_index(cpi->target_level));
1957 if (cm->profile <= PROFILE_1)
1958 assert(cm->bit_depth == VPX_BITS_8);
1960 assert(cm->bit_depth > VPX_BITS_8);
1963 #if CONFIG_VP9_HIGHBITDEPTH
1964 cpi->td.mb.e_mbd.bd = (int)cm->bit_depth;
1965 #endif // CONFIG_VP9_HIGHBITDEPTH
1967 if ((oxcf->pass == 0) && (oxcf->rc_mode == VPX_Q)) {
1968 rc->baseline_gf_interval = FIXED_GF_INTERVAL;
1970 rc->baseline_gf_interval = (MIN_GF_INTERVAL + MAX_GF_INTERVAL) / 2;
1973 cpi->refresh_golden_frame = 0;
1974 cpi->refresh_last_frame = 1;
1975 cm->refresh_frame_context = 1;
1976 cm->reset_frame_context = 0;
1978 vp9_reset_segment_features(&cm->seg);
1979 vp9_set_high_precision_mv(cpi, 0);
1984 for (i = 0; i < MAX_SEGMENTS; i++)
1985 cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout;
1987 cpi->encode_breakout = cpi->oxcf.encode_breakout;
1989 set_rc_buffer_sizes(rc, &cpi->oxcf);
1991 // Under a configuration change, where maximum_buffer_size may change,
1992 // keep buffer level clipped to the maximum allowed buffer size.
1993 rc->bits_off_target = VPXMIN(rc->bits_off_target, rc->maximum_buffer_size);
1994 rc->buffer_level = VPXMIN(rc->buffer_level, rc->maximum_buffer_size);
1996 // Set up frame rate and related parameters rate control values.
1997 vp9_new_framerate(cpi, cpi->framerate);
1999 // Set absolute upper and lower quality limits
2000 rc->worst_quality = cpi->oxcf.worst_allowed_q;
2001 rc->best_quality = cpi->oxcf.best_allowed_q;
2003 cm->interp_filter = cpi->sf.default_interp_filter;
2005 if (cpi->oxcf.render_width > 0 && cpi->oxcf.render_height > 0) {
2006 cm->render_width = cpi->oxcf.render_width;
2007 cm->render_height = cpi->oxcf.render_height;
2009 cm->render_width = cpi->oxcf.width;
2010 cm->render_height = cpi->oxcf.height;
2012 if (last_w != cpi->oxcf.width || last_h != cpi->oxcf.height) {
2013 cm->width = cpi->oxcf.width;
2014 cm->height = cpi->oxcf.height;
2015 cpi->external_resize = 1;
2018 if (cpi->initial_width) {
2019 int new_mi_size = 0;
2020 vp9_set_mb_mi(cm, cm->width, cm->height);
2021 new_mi_size = cm->mi_stride * calc_mi_size(cm->mi_rows);
2022 if (cm->mi_alloc_size < new_mi_size) {
2023 vp9_free_context_buffers(cm);
2024 alloc_compressor_data(cpi);
2025 realloc_segmentation_maps(cpi);
2026 cpi->initial_width = cpi->initial_height = 0;
2027 cpi->external_resize = 0;
2028 } else if (cm->mi_alloc_size == new_mi_size &&
2029 (cpi->oxcf.width > last_w || cpi->oxcf.height > last_h)) {
2030 vp9_alloc_loop_filter(cm);
2034 if (cm->current_video_frame == 0 || last_w != cpi->oxcf.width ||
2035 last_h != cpi->oxcf.height)
2036 update_frame_size(cpi);
2038 if (last_w != cpi->oxcf.width || last_h != cpi->oxcf.height) {
2039 memset(cpi->consec_zero_mv, 0,
2040 cm->mi_rows * cm->mi_cols * sizeof(*cpi->consec_zero_mv));
2041 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ)
2042 vp9_cyclic_refresh_reset_resize(cpi);
2047 if ((cpi->svc.number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) ||
2048 ((cpi->svc.number_temporal_layers > 1 ||
2049 cpi->svc.number_spatial_layers > 1) &&
2050 cpi->oxcf.pass != 1)) {
2051 vp9_update_layer_context_change_config(cpi,
2052 (int)cpi->oxcf.target_bandwidth);
2055 // Check for resetting the rc flags (rc_1_frame, rc_2_frame) if the
2056 // configuration change has a large change in avg_frame_bandwidth.
2057 // For SVC check for resetting based on spatial layer average bandwidth.
2058 // Also reset buffer level to optimal level.
2059 if (cm->current_video_frame > 0) {
2061 vp9_svc_check_reset_layer_rc_flag(cpi);
2063 if (rc->avg_frame_bandwidth > (3 * rc->last_avg_frame_bandwidth >> 1) ||
2064 rc->avg_frame_bandwidth < (rc->last_avg_frame_bandwidth >> 1)) {
2067 rc->bits_off_target = rc->optimal_buffer_level;
2068 rc->buffer_level = rc->optimal_buffer_level;
2073 cpi->alt_ref_source = NULL;
2074 rc->is_src_frame_alt_ref = 0;
2077 // Experimental RD Code
2078 cpi->frame_distortion = 0;
2079 cpi->last_frame_distortion = 0;
2082 set_tile_limits(cpi);
2084 cpi->ext_refresh_frame_flags_pending = 0;
2085 cpi->ext_refresh_frame_context_pending = 0;
2087 #if CONFIG_VP9_HIGHBITDEPTH
2088 highbd_set_var_fns(cpi);
2091 vp9_set_row_mt(cpi);
2095 #define M_LOG2_E 0.693147180559945309417
2097 #define log2f(x) (log(x) / (float)M_LOG2_E)
2099 /***********************************************************************
2100 * Read before modifying 'cal_nmvjointsadcost' or 'cal_nmvsadcosts' *
2101 ***********************************************************************
2102 * The following 2 functions ('cal_nmvjointsadcost' and *
2103 * 'cal_nmvsadcosts') are used to calculate cost lookup tables *
2104 * used by 'vp9_diamond_search_sad'. The C implementation of the *
2105 * function is generic, but the AVX intrinsics optimised version *
2106 * relies on the following properties of the computed tables: *
2107 * For cal_nmvjointsadcost: *
2108 * - mvjointsadcost[1] == mvjointsadcost[2] == mvjointsadcost[3] *
2109 * For cal_nmvsadcosts: *
2110 * - For all i: mvsadcost[0][i] == mvsadcost[1][i] *
2111 * (Equal costs for both components) *
2112 * - For all i: mvsadcost[0][i] == mvsadcost[0][-i] *
2113 * (Cost function is even) *
2114 * If these do not hold, then the AVX optimised version of the *
2115 * 'vp9_diamond_search_sad' function cannot be used as it is, in which *
2116 * case you can revert to using the C function instead. *
2117 ***********************************************************************/
2119 static void cal_nmvjointsadcost(int *mvjointsadcost) {
2120 /*********************************************************************
2121 * Warning: Read the comments above before modifying this function *
2122 *********************************************************************/
2123 mvjointsadcost[0] = 600;
2124 mvjointsadcost[1] = 300;
2125 mvjointsadcost[2] = 300;
2126 mvjointsadcost[3] = 300;
2129 static void cal_nmvsadcosts(int *mvsadcost[2]) {
2130 /*********************************************************************
2131 * Warning: Read the comments above before modifying this function *
2132 *********************************************************************/
2135 mvsadcost[0][0] = 0;
2136 mvsadcost[1][0] = 0;
2139 double z = 256 * (2 * (log2f(8 * i) + .6));
2140 mvsadcost[0][i] = (int)z;
2141 mvsadcost[1][i] = (int)z;
2142 mvsadcost[0][-i] = (int)z;
2143 mvsadcost[1][-i] = (int)z;
2144 } while (++i <= MV_MAX);
2147 static void cal_nmvsadcosts_hp(int *mvsadcost[2]) {
2150 mvsadcost[0][0] = 0;
2151 mvsadcost[1][0] = 0;
2154 double z = 256 * (2 * (log2f(8 * i) + .6));
2155 mvsadcost[0][i] = (int)z;
2156 mvsadcost[1][i] = (int)z;
2157 mvsadcost[0][-i] = (int)z;
2158 mvsadcost[1][-i] = (int)z;
2159 } while (++i <= MV_MAX);
2162 static void init_ref_frame_bufs(VP9_COMMON *cm) {
2164 BufferPool *const pool = cm->buffer_pool;
2165 cm->new_fb_idx = INVALID_IDX;
2166 for (i = 0; i < REF_FRAMES; ++i) {
2167 cm->ref_frame_map[i] = INVALID_IDX;
2169 for (i = 0; i < FRAME_BUFFERS; ++i) {
2170 pool->frame_bufs[i].ref_count = 0;
2174 static void update_initial_width(VP9_COMP *cpi, int use_highbitdepth,
2175 int subsampling_x, int subsampling_y) {
2176 VP9_COMMON *const cm = &cpi->common;
2177 #if !CONFIG_VP9_HIGHBITDEPTH
2178 (void)use_highbitdepth;
2179 assert(use_highbitdepth == 0);
2182 if (!cpi->initial_width ||
2183 #if CONFIG_VP9_HIGHBITDEPTH
2184 cm->use_highbitdepth != use_highbitdepth ||
2186 cm->subsampling_x != subsampling_x ||
2187 cm->subsampling_y != subsampling_y) {
2188 cm->subsampling_x = subsampling_x;
2189 cm->subsampling_y = subsampling_y;
2190 #if CONFIG_VP9_HIGHBITDEPTH
2191 cm->use_highbitdepth = use_highbitdepth;
2194 cpi->initial_width = cm->width;
2195 cpi->initial_height = cm->height;
2196 cpi->initial_mbs = cm->MBs;
2200 // TODO(angiebird): Check whether we can move this function to vpx_image.c
2201 static INLINE void vpx_img_chroma_subsampling(vpx_img_fmt_t fmt,
2202 unsigned int *subsampling_x,
2203 unsigned int *subsampling_y) {
2205 case VPX_IMG_FMT_I420:
2206 case VPX_IMG_FMT_YV12:
2207 case VPX_IMG_FMT_I422:
2208 case VPX_IMG_FMT_I42016:
2209 case VPX_IMG_FMT_I42216: *subsampling_x = 1; break;
2210 default: *subsampling_x = 0; break;
2214 case VPX_IMG_FMT_I420:
2215 case VPX_IMG_FMT_I440:
2216 case VPX_IMG_FMT_YV12:
2217 case VPX_IMG_FMT_I42016:
2218 case VPX_IMG_FMT_I44016: *subsampling_y = 1; break;
2219 default: *subsampling_y = 0; break;
2223 // TODO(angiebird): Check whether we can move this function to vpx_image.c
2224 static INLINE int vpx_img_use_highbitdepth(vpx_img_fmt_t fmt) {
2225 return fmt & VPX_IMG_FMT_HIGHBITDEPTH;
2228 #if CONFIG_VP9_TEMPORAL_DENOISING
2229 static void setup_denoiser_buffer(VP9_COMP *cpi) {
2230 VP9_COMMON *const cm = &cpi->common;
2231 if (cpi->oxcf.noise_sensitivity > 0 &&
2232 !cpi->denoiser.frame_buffer_initialized) {
2233 if (vp9_denoiser_alloc(cm, &cpi->svc, &cpi->denoiser, cpi->use_svc,
2234 cpi->oxcf.noise_sensitivity, cm->width, cm->height,
2235 cm->subsampling_x, cm->subsampling_y,
2236 #if CONFIG_VP9_HIGHBITDEPTH
2237 cm->use_highbitdepth,
2239 VP9_ENC_BORDER_IN_PIXELS))
2240 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
2241 "Failed to allocate denoiser");
2246 void vp9_update_compressor_with_img_fmt(VP9_COMP *cpi, vpx_img_fmt_t img_fmt) {
2247 const VP9EncoderConfig *oxcf = &cpi->oxcf;
2248 unsigned int subsampling_x, subsampling_y;
2249 const int use_highbitdepth = vpx_img_use_highbitdepth(img_fmt);
2250 vpx_img_chroma_subsampling(img_fmt, &subsampling_x, &subsampling_y);
2252 update_initial_width(cpi, use_highbitdepth, subsampling_x, subsampling_y);
2253 #if CONFIG_VP9_TEMPORAL_DENOISING
2254 setup_denoiser_buffer(cpi);
2257 assert(cpi->lookahead == NULL);
2258 cpi->lookahead = vp9_lookahead_init(oxcf->width, oxcf->height, subsampling_x,
2260 #if CONFIG_VP9_HIGHBITDEPTH
2263 oxcf->lag_in_frames);
2264 alloc_raw_frame_buffers(cpi);
2267 VP9_COMP *vp9_create_compressor(const VP9EncoderConfig *oxcf,
2268 BufferPool *const pool) {
2270 VP9_COMP *volatile const cpi = vpx_memalign(32, sizeof(VP9_COMP));
2271 VP9_COMMON *volatile const cm = cpi != NULL ? &cpi->common : NULL;
2273 if (!cm) return NULL;
2277 if (setjmp(cm->error.jmp)) {
2278 cm->error.setjmp = 0;
2279 vp9_remove_compressor(cpi);
2283 cm->error.setjmp = 1;
2284 cm->alloc_mi = vp9_enc_alloc_mi;
2285 cm->free_mi = vp9_enc_free_mi;
2286 cm->setup_mi = vp9_enc_setup_mi;
2288 CHECK_MEM_ERROR(cm, cm->fc, (FRAME_CONTEXT *)vpx_calloc(1, sizeof(*cm->fc)));
2290 cm, cm->frame_contexts,
2291 (FRAME_CONTEXT *)vpx_calloc(FRAME_CONTEXTS, sizeof(*cm->frame_contexts)));
2294 cpi->resize_state = ORIG;
2295 cpi->external_resize = 0;
2296 cpi->resize_avg_qp = 0;
2297 cpi->resize_buffer_underflow = 0;
2298 cpi->use_skin_detection = 0;
2299 cpi->common.buffer_pool = pool;
2300 init_ref_frame_bufs(cm);
2302 cpi->force_update_segmentation = 0;
2304 init_config(cpi, oxcf);
2305 cpi->frame_info = vp9_get_frame_info(oxcf);
2307 vp9_rc_init(&cpi->oxcf, oxcf->pass, &cpi->rc);
2309 cm->current_video_frame = 0;
2310 cpi->partition_search_skippable_frame = 0;
2311 cpi->tile_data = NULL;
2313 realloc_segmentation_maps(cpi);
2317 vpx_calloc(cm->mi_rows * cm->mi_cols, sizeof(cpi->skin_map[0])));
2319 #if !CONFIG_REALTIME_ONLY
2320 CHECK_MEM_ERROR(cm, cpi->alt_ref_aq, vp9_alt_ref_aq_create());
2324 cm, cpi->consec_zero_mv,
2325 vpx_calloc(cm->mi_rows * cm->mi_cols, sizeof(*cpi->consec_zero_mv)));
2327 CHECK_MEM_ERROR(cm, cpi->nmvcosts[0],
2328 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts[0])));
2329 CHECK_MEM_ERROR(cm, cpi->nmvcosts[1],
2330 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts[1])));
2331 CHECK_MEM_ERROR(cm, cpi->nmvcosts_hp[0],
2332 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts_hp[0])));
2333 CHECK_MEM_ERROR(cm, cpi->nmvcosts_hp[1],
2334 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts_hp[1])));
2335 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts[0],
2336 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts[0])));
2337 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts[1],
2338 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts[1])));
2339 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts_hp[0],
2340 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts_hp[0])));
2341 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts_hp[1],
2342 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts_hp[1])));
2344 for (i = 0; i < (sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]));
2347 cm, cpi->mbgraph_stats[i].mb_stats,
2348 vpx_calloc(cm->MBs * sizeof(*cpi->mbgraph_stats[i].mb_stats), 1));
2351 #if CONFIG_FP_MB_STATS
2352 cpi->use_fp_mb_stats = 0;
2353 if (cpi->use_fp_mb_stats) {
2354 // a place holder used to store the first pass mb stats in the first pass
2355 CHECK_MEM_ERROR(cm, cpi->twopass.frame_mb_stats_buf,
2356 vpx_calloc(cm->MBs * sizeof(uint8_t), 1));
2358 cpi->twopass.frame_mb_stats_buf = NULL;
2362 cpi->refresh_alt_ref_frame = 0;
2363 cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS;
2365 init_level_info(&cpi->level_info);
2366 init_level_constraint(&cpi->level_constraint);
2368 #if CONFIG_INTERNAL_STATS
2369 cpi->b_calculate_blockiness = 1;
2370 cpi->b_calculate_consistency = 1;
2371 cpi->total_inconsistency = 0;
2372 cpi->psnr.worst = 100.0;
2373 cpi->worst_ssim = 100.0;
2378 if (cpi->b_calculate_psnr) {
2379 cpi->total_sq_error = 0;
2380 cpi->total_samples = 0;
2382 cpi->totalp_sq_error = 0;
2383 cpi->totalp_samples = 0;
2385 cpi->tot_recode_hits = 0;
2386 cpi->summed_quality = 0;
2387 cpi->summed_weights = 0;
2388 cpi->summedp_quality = 0;
2389 cpi->summedp_weights = 0;
2392 cpi->fastssim.worst = 100.0;
2394 cpi->psnrhvs.worst = 100.0;
2396 if (cpi->b_calculate_blockiness) {
2397 cpi->total_blockiness = 0;
2398 cpi->worst_blockiness = 0.0;
2401 if (cpi->b_calculate_consistency) {
2402 CHECK_MEM_ERROR(cm, cpi->ssim_vars,
2403 vpx_calloc(cpi->common.mi_rows * cpi->common.mi_cols,
2404 sizeof(*cpi->ssim_vars) * 4));
2405 cpi->worst_consistency = 100.0;
2407 cpi->ssim_vars = NULL;
2412 cpi->first_time_stamp_ever = INT64_MAX;
2414 /*********************************************************************
2415 * Warning: Read the comments around 'cal_nmvjointsadcost' and *
2416 * 'cal_nmvsadcosts' before modifying how these tables are computed. *
2417 *********************************************************************/
2418 cal_nmvjointsadcost(cpi->td.mb.nmvjointsadcost);
2419 cpi->td.mb.nmvcost[0] = &cpi->nmvcosts[0][MV_MAX];
2420 cpi->td.mb.nmvcost[1] = &cpi->nmvcosts[1][MV_MAX];
2421 cpi->td.mb.nmvsadcost[0] = &cpi->nmvsadcosts[0][MV_MAX];
2422 cpi->td.mb.nmvsadcost[1] = &cpi->nmvsadcosts[1][MV_MAX];
2423 cal_nmvsadcosts(cpi->td.mb.nmvsadcost);
2425 cpi->td.mb.nmvcost_hp[0] = &cpi->nmvcosts_hp[0][MV_MAX];
2426 cpi->td.mb.nmvcost_hp[1] = &cpi->nmvcosts_hp[1][MV_MAX];
2427 cpi->td.mb.nmvsadcost_hp[0] = &cpi->nmvsadcosts_hp[0][MV_MAX];
2428 cpi->td.mb.nmvsadcost_hp[1] = &cpi->nmvsadcosts_hp[1][MV_MAX];
2429 cal_nmvsadcosts_hp(cpi->td.mb.nmvsadcost_hp);
2431 #if CONFIG_VP9_TEMPORAL_DENOISING
2432 #ifdef OUTPUT_YUV_DENOISED
2433 yuv_denoised_file = fopen("denoised.yuv", "ab");
2436 #ifdef OUTPUT_YUV_SKINMAP
2437 yuv_skinmap_file = fopen("skinmap.yuv", "wb");
2439 #ifdef OUTPUT_YUV_REC
2440 yuv_rec_file = fopen("rec.yuv", "wb");
2442 #ifdef OUTPUT_YUV_SVC_SRC
2443 yuv_svc_src[0] = fopen("svc_src_0.yuv", "wb");
2444 yuv_svc_src[1] = fopen("svc_src_1.yuv", "wb");
2445 yuv_svc_src[2] = fopen("svc_src_2.yuv", "wb");
2449 framepsnr = fopen("framepsnr.stt", "a");
2450 kf_list = fopen("kf_list.stt", "w");
2453 cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED;
2455 #if !CONFIG_REALTIME_ONLY
2456 if (oxcf->pass == 1) {
2457 vp9_init_first_pass(cpi);
2458 } else if (oxcf->pass == 2) {
2459 const size_t packet_sz = sizeof(FIRSTPASS_STATS);
2460 const int packets = (int)(oxcf->two_pass_stats_in.sz / packet_sz);
2462 if (cpi->svc.number_spatial_layers > 1 ||
2463 cpi->svc.number_temporal_layers > 1) {
2464 FIRSTPASS_STATS *const stats = oxcf->two_pass_stats_in.buf;
2465 FIRSTPASS_STATS *stats_copy[VPX_SS_MAX_LAYERS] = { 0 };
2468 for (i = 0; i < oxcf->ss_number_layers; ++i) {
2469 FIRSTPASS_STATS *const last_packet_for_layer =
2470 &stats[packets - oxcf->ss_number_layers + i];
2471 const int layer_id = (int)last_packet_for_layer->spatial_layer_id;
2472 const int packets_in_layer = (int)last_packet_for_layer->count + 1;
2473 if (layer_id >= 0 && layer_id < oxcf->ss_number_layers) {
2475 LAYER_CONTEXT *const lc = &cpi->svc.layer_context[layer_id];
2477 vpx_free(lc->rc_twopass_stats_in.buf);
2479 lc->rc_twopass_stats_in.sz = packets_in_layer * packet_sz;
2480 CHECK_MEM_ERROR(cm, lc->rc_twopass_stats_in.buf,
2481 vpx_malloc(lc->rc_twopass_stats_in.sz));
2482 lc->twopass.stats_in_start = lc->rc_twopass_stats_in.buf;
2483 lc->twopass.stats_in = lc->twopass.stats_in_start;
2484 lc->twopass.stats_in_end =
2485 lc->twopass.stats_in_start + packets_in_layer - 1;
2486 // Note the last packet is cumulative first pass stats.
2487 // So the number of frames is packet number minus one
2488 num_frames = packets_in_layer - 1;
2489 fps_init_first_pass_info(&lc->twopass.first_pass_info,
2490 lc->rc_twopass_stats_in.buf, num_frames);
2491 stats_copy[layer_id] = lc->rc_twopass_stats_in.buf;
2495 for (i = 0; i < packets; ++i) {
2496 const int layer_id = (int)stats[i].spatial_layer_id;
2497 if (layer_id >= 0 && layer_id < oxcf->ss_number_layers &&
2498 stats_copy[layer_id] != NULL) {
2499 *stats_copy[layer_id] = stats[i];
2500 ++stats_copy[layer_id];
2504 vp9_init_second_pass_spatial_svc(cpi);
2507 #if CONFIG_FP_MB_STATS
2508 if (cpi->use_fp_mb_stats) {
2509 const size_t psz = cpi->common.MBs * sizeof(uint8_t);
2510 const int ps = (int)(oxcf->firstpass_mb_stats_in.sz / psz);
2512 cpi->twopass.firstpass_mb_stats.mb_stats_start =
2513 oxcf->firstpass_mb_stats_in.buf;
2514 cpi->twopass.firstpass_mb_stats.mb_stats_end =
2515 cpi->twopass.firstpass_mb_stats.mb_stats_start +
2516 (ps - 1) * cpi->common.MBs * sizeof(uint8_t);
2520 cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf;
2521 cpi->twopass.stats_in = cpi->twopass.stats_in_start;
2522 cpi->twopass.stats_in_end = &cpi->twopass.stats_in[packets - 1];
2523 // Note the last packet is cumulative first pass stats.
2524 // So the number of frames is packet number minus one
2525 num_frames = packets - 1;
2526 fps_init_first_pass_info(&cpi->twopass.first_pass_info,
2527 oxcf->two_pass_stats_in.buf, num_frames);
2529 vp9_init_second_pass(cpi);
2532 #endif // !CONFIG_REALTIME_ONLY
2534 cpi->mb_wiener_var_cols = 0;
2535 cpi->mb_wiener_var_rows = 0;
2536 cpi->mb_wiener_variance = NULL;
2538 vp9_set_speed_features_framesize_independent(cpi, oxcf->speed);
2539 vp9_set_speed_features_framesize_dependent(cpi, oxcf->speed);
2542 const int bsize = BLOCK_16X16;
2543 const int w = num_8x8_blocks_wide_lookup[bsize];
2544 const int h = num_8x8_blocks_high_lookup[bsize];
2545 const int num_cols = (cm->mi_cols + w - 1) / w;
2546 const int num_rows = (cm->mi_rows + h - 1) / h;
2547 CHECK_MEM_ERROR(cm, cpi->mi_ssim_rdmult_scaling_factors,
2548 vpx_calloc(num_rows * num_cols,
2549 sizeof(*cpi->mi_ssim_rdmult_scaling_factors)));
2552 cpi->kmeans_data_arr_alloc = 0;
2553 #if CONFIG_NON_GREEDY_MV
2555 #endif // CONFIG_NON_GREEDY_MV
2556 for (i = 0; i < MAX_ARF_GOP_SIZE; ++i) cpi->tpl_stats[i].tpl_stats_ptr = NULL;
2558 // Allocate memory to store variances for a frame.
2559 CHECK_MEM_ERROR(cm, cpi->source_diff_var, vpx_calloc(cm->MBs, sizeof(diff)));
2560 cpi->source_var_thresh = 0;
2561 cpi->frames_till_next_var_check = 0;
2562 #define BFP(BT, SDF, SDAF, VF, SVF, SVAF, SDX4DF, SDX8F) \
2563 cpi->fn_ptr[BT].sdf = SDF; \
2564 cpi->fn_ptr[BT].sdaf = SDAF; \
2565 cpi->fn_ptr[BT].vf = VF; \
2566 cpi->fn_ptr[BT].svf = SVF; \
2567 cpi->fn_ptr[BT].svaf = SVAF; \
2568 cpi->fn_ptr[BT].sdx4df = SDX4DF; \
2569 cpi->fn_ptr[BT].sdx8f = SDX8F;
2571 // TODO(angiebird): make sdx8f available for every block size
2572 BFP(BLOCK_32X16, vpx_sad32x16, vpx_sad32x16_avg, vpx_variance32x16,
2573 vpx_sub_pixel_variance32x16, vpx_sub_pixel_avg_variance32x16,
2574 vpx_sad32x16x4d, NULL)
2576 BFP(BLOCK_16X32, vpx_sad16x32, vpx_sad16x32_avg, vpx_variance16x32,
2577 vpx_sub_pixel_variance16x32, vpx_sub_pixel_avg_variance16x32,
2578 vpx_sad16x32x4d, NULL)
2580 BFP(BLOCK_64X32, vpx_sad64x32, vpx_sad64x32_avg, vpx_variance64x32,
2581 vpx_sub_pixel_variance64x32, vpx_sub_pixel_avg_variance64x32,
2582 vpx_sad64x32x4d, NULL)
2584 BFP(BLOCK_32X64, vpx_sad32x64, vpx_sad32x64_avg, vpx_variance32x64,
2585 vpx_sub_pixel_variance32x64, vpx_sub_pixel_avg_variance32x64,
2586 vpx_sad32x64x4d, NULL)
2588 BFP(BLOCK_32X32, vpx_sad32x32, vpx_sad32x32_avg, vpx_variance32x32,
2589 vpx_sub_pixel_variance32x32, vpx_sub_pixel_avg_variance32x32,
2590 vpx_sad32x32x4d, vpx_sad32x32x8)
2592 BFP(BLOCK_64X64, vpx_sad64x64, vpx_sad64x64_avg, vpx_variance64x64,
2593 vpx_sub_pixel_variance64x64, vpx_sub_pixel_avg_variance64x64,
2594 vpx_sad64x64x4d, NULL)
2596 BFP(BLOCK_16X16, vpx_sad16x16, vpx_sad16x16_avg, vpx_variance16x16,
2597 vpx_sub_pixel_variance16x16, vpx_sub_pixel_avg_variance16x16,
2598 vpx_sad16x16x4d, vpx_sad16x16x8)
2600 BFP(BLOCK_16X8, vpx_sad16x8, vpx_sad16x8_avg, vpx_variance16x8,
2601 vpx_sub_pixel_variance16x8, vpx_sub_pixel_avg_variance16x8,
2602 vpx_sad16x8x4d, vpx_sad16x8x8)
2604 BFP(BLOCK_8X16, vpx_sad8x16, vpx_sad8x16_avg, vpx_variance8x16,
2605 vpx_sub_pixel_variance8x16, vpx_sub_pixel_avg_variance8x16,
2606 vpx_sad8x16x4d, vpx_sad8x16x8)
2608 BFP(BLOCK_8X8, vpx_sad8x8, vpx_sad8x8_avg, vpx_variance8x8,
2609 vpx_sub_pixel_variance8x8, vpx_sub_pixel_avg_variance8x8, vpx_sad8x8x4d,
2612 BFP(BLOCK_8X4, vpx_sad8x4, vpx_sad8x4_avg, vpx_variance8x4,
2613 vpx_sub_pixel_variance8x4, vpx_sub_pixel_avg_variance8x4, vpx_sad8x4x4d,
2616 BFP(BLOCK_4X8, vpx_sad4x8, vpx_sad4x8_avg, vpx_variance4x8,
2617 vpx_sub_pixel_variance4x8, vpx_sub_pixel_avg_variance4x8, vpx_sad4x8x4d,
2620 BFP(BLOCK_4X4, vpx_sad4x4, vpx_sad4x4_avg, vpx_variance4x4,
2621 vpx_sub_pixel_variance4x4, vpx_sub_pixel_avg_variance4x4, vpx_sad4x4x4d,
2624 #if CONFIG_VP9_HIGHBITDEPTH
2625 highbd_set_var_fns(cpi);
2628 /* vp9_init_quantizer() is first called here. Add check in
2629 * vp9_frame_init_quantizer() so that vp9_init_quantizer is only
2630 * called later when needed. This will avoid unnecessary calls of
2631 * vp9_init_quantizer() for every frame.
2633 vp9_init_quantizer(cpi);
2635 vp9_loop_filter_init(cm);
2637 // Set up the unit scaling factor used during motion search.
2638 #if CONFIG_VP9_HIGHBITDEPTH
2639 vp9_setup_scale_factors_for_frame(&cpi->me_sf, cm->width, cm->height,
2640 cm->width, cm->height,
2641 cm->use_highbitdepth);
2643 vp9_setup_scale_factors_for_frame(&cpi->me_sf, cm->width, cm->height,
2644 cm->width, cm->height);
2645 #endif // CONFIG_VP9_HIGHBITDEPTH
2646 cpi->td.mb.me_sf = &cpi->me_sf;
2648 cm->error.setjmp = 0;
2653 #if CONFIG_INTERNAL_STATS
2654 #define SNPRINT(H, T) snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T))
2656 #define SNPRINT2(H, T, V) \
2657 snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T), (V))
2658 #endif // CONFIG_INTERNAL_STATS
2660 static void free_tpl_buffer(VP9_COMP *cpi);
2662 void vp9_remove_compressor(VP9_COMP *cpi) {
2669 #if CONFIG_INTERNAL_STATS
2670 vpx_free(cpi->ssim_vars);
2674 if (cm->current_video_frame > 0) {
2675 #if CONFIG_INTERNAL_STATS
2676 vpx_clear_system_state();
2678 if (cpi->oxcf.pass != 1) {
2679 char headings[512] = { 0 };
2680 char results[512] = { 0 };
2681 FILE *f = fopen("opsnr.stt", "a");
2682 double time_encoded =
2683 (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) /
2685 double total_encode_time =
2686 (cpi->time_receive_data + cpi->time_compress_data) / 1000.000;
2688 (double)cpi->bytes * (double)8 / (double)1000 / time_encoded;
2689 const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1);
2690 const double target_rate = (double)cpi->oxcf.target_bandwidth / 1000;
2691 const double rate_err = ((100.0 * (dr - target_rate)) / target_rate);
2693 if (cpi->b_calculate_psnr) {
2694 const double total_psnr = vpx_sse_to_psnr(
2695 (double)cpi->total_samples, peak, (double)cpi->total_sq_error);
2696 const double totalp_psnr = vpx_sse_to_psnr(
2697 (double)cpi->totalp_samples, peak, (double)cpi->totalp_sq_error);
2698 const double total_ssim =
2699 100 * pow(cpi->summed_quality / cpi->summed_weights, 8.0);
2700 const double totalp_ssim =
2701 100 * pow(cpi->summedp_quality / cpi->summedp_weights, 8.0);
2703 snprintf(headings, sizeof(headings),
2704 "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\t"
2705 "VPXSSIM\tVPSSIMP\tFASTSIM\tPSNRHVS\t"
2706 "WstPsnr\tWstSsim\tWstFast\tWstHVS\t"
2707 "AVPsnrY\tAPsnrCb\tAPsnrCr");
2708 snprintf(results, sizeof(results),
2709 "%7.2f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2710 "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2711 "%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2712 "%7.3f\t%7.3f\t%7.3f",
2713 dr, cpi->psnr.stat[ALL] / cpi->count, total_psnr,
2714 cpi->psnrp.stat[ALL] / cpi->count, totalp_psnr, total_ssim,
2715 totalp_ssim, cpi->fastssim.stat[ALL] / cpi->count,
2716 cpi->psnrhvs.stat[ALL] / cpi->count, cpi->psnr.worst,
2717 cpi->worst_ssim, cpi->fastssim.worst, cpi->psnrhvs.worst,
2718 cpi->psnr.stat[Y] / cpi->count, cpi->psnr.stat[U] / cpi->count,
2719 cpi->psnr.stat[V] / cpi->count);
2721 if (cpi->b_calculate_blockiness) {
2722 SNPRINT(headings, "\t Block\tWstBlck");
2723 SNPRINT2(results, "\t%7.3f", cpi->total_blockiness / cpi->count);
2724 SNPRINT2(results, "\t%7.3f", cpi->worst_blockiness);
2727 if (cpi->b_calculate_consistency) {
2728 double consistency =
2729 vpx_sse_to_psnr((double)cpi->totalp_samples, peak,
2730 (double)cpi->total_inconsistency);
2732 SNPRINT(headings, "\tConsist\tWstCons");
2733 SNPRINT2(results, "\t%7.3f", consistency);
2734 SNPRINT2(results, "\t%7.3f", cpi->worst_consistency);
2737 SNPRINT(headings, "\t Time\tRcErr\tAbsErr");
2738 SNPRINT2(results, "\t%8.0f", total_encode_time);
2739 SNPRINT2(results, "\t%7.2f", rate_err);
2740 SNPRINT2(results, "\t%7.2f", fabs(rate_err));
2742 fprintf(f, "%s\tAPsnr611\n", headings);
2744 f, "%s\t%7.3f\n", results,
2745 (6 * cpi->psnr.stat[Y] + cpi->psnr.stat[U] + cpi->psnr.stat[V]) /
2755 printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000);
2756 printf("\n_frames recive_data encod_mb_row compress_frame Total\n");
2757 printf("%6d %10ld %10ld %10ld %10ld\n", cpi->common.current_video_frame,
2758 cpi->time_receive_data / 1000, cpi->time_encode_sb_row / 1000,
2759 cpi->time_compress_data / 1000,
2760 (cpi->time_receive_data + cpi->time_compress_data) / 1000);
2765 #if CONFIG_VP9_TEMPORAL_DENOISING
2766 vp9_denoiser_free(&(cpi->denoiser));
2769 if (cpi->kmeans_data_arr_alloc) {
2770 #if CONFIG_MULTITHREAD
2771 pthread_mutex_destroy(&cpi->kmeans_mutex);
2773 vpx_free(cpi->kmeans_data_arr);
2776 free_tpl_buffer(cpi);
2778 for (t = 0; t < cpi->num_workers; ++t) {
2779 VPxWorker *const worker = &cpi->workers[t];
2780 EncWorkerData *const thread_data = &cpi->tile_thr_data[t];
2782 // Deallocate allocated threads.
2783 vpx_get_worker_interface()->end(worker);
2785 // Deallocate allocated thread data.
2786 if (t < cpi->num_workers - 1) {
2787 vpx_free(thread_data->td->counts);
2788 vp9_free_pc_tree(thread_data->td);
2789 vpx_free(thread_data->td);
2792 vpx_free(cpi->tile_thr_data);
2793 vpx_free(cpi->workers);
2794 vp9_row_mt_mem_dealloc(cpi);
2796 if (cpi->num_workers > 1) {
2797 vp9_loop_filter_dealloc(&cpi->lf_row_sync);
2798 vp9_bitstream_encode_tiles_buffer_dealloc(cpi);
2801 #if !CONFIG_REALTIME_ONLY
2802 vp9_alt_ref_aq_destroy(cpi->alt_ref_aq);
2805 dealloc_compressor_data(cpi);
2807 for (i = 0; i < sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]);
2809 vpx_free(cpi->mbgraph_stats[i].mb_stats);
2812 #if CONFIG_FP_MB_STATS
2813 if (cpi->use_fp_mb_stats) {
2814 vpx_free(cpi->twopass.frame_mb_stats_buf);
2815 cpi->twopass.frame_mb_stats_buf = NULL;
2819 vp9_remove_common(cm);
2820 vp9_free_ref_frame_buffers(cm->buffer_pool);
2821 #if CONFIG_VP9_POSTPROC
2822 vp9_free_postproc_buffers(cm);
2826 #if CONFIG_VP9_TEMPORAL_DENOISING
2827 #ifdef OUTPUT_YUV_DENOISED
2828 fclose(yuv_denoised_file);
2831 #ifdef OUTPUT_YUV_SKINMAP
2832 fclose(yuv_skinmap_file);
2834 #ifdef OUTPUT_YUV_REC
2835 fclose(yuv_rec_file);
2837 #ifdef OUTPUT_YUV_SVC_SRC
2838 fclose(yuv_svc_src[0]);
2839 fclose(yuv_svc_src[1]);
2840 fclose(yuv_svc_src[2]);
2857 int vp9_get_psnr(const VP9_COMP *cpi, PSNR_STATS *psnr) {
2858 if (is_psnr_calc_enabled(cpi)) {
2859 #if CONFIG_VP9_HIGHBITDEPTH
2860 vpx_calc_highbd_psnr(cpi->raw_source_frame, cpi->common.frame_to_show, psnr,
2861 cpi->td.mb.e_mbd.bd, cpi->oxcf.input_bit_depth);
2863 vpx_calc_psnr(cpi->raw_source_frame, cpi->common.frame_to_show, psnr);
2872 int vp9_use_as_reference(VP9_COMP *cpi, int ref_frame_flags) {
2873 if (ref_frame_flags > 7) return -1;
2875 cpi->ref_frame_flags = ref_frame_flags;
2879 void vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags) {
2880 cpi->ext_refresh_golden_frame = (ref_frame_flags & VP9_GOLD_FLAG) != 0;
2881 cpi->ext_refresh_alt_ref_frame = (ref_frame_flags & VP9_ALT_FLAG) != 0;
2882 cpi->ext_refresh_last_frame = (ref_frame_flags & VP9_LAST_FLAG) != 0;
2883 cpi->ext_refresh_frame_flags_pending = 1;
2886 static YV12_BUFFER_CONFIG *get_vp9_ref_frame_buffer(
2887 VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag) {
2888 MV_REFERENCE_FRAME ref_frame = NONE;
2889 if (ref_frame_flag == VP9_LAST_FLAG)
2890 ref_frame = LAST_FRAME;
2891 else if (ref_frame_flag == VP9_GOLD_FLAG)
2892 ref_frame = GOLDEN_FRAME;
2893 else if (ref_frame_flag == VP9_ALT_FLAG)
2894 ref_frame = ALTREF_FRAME;
2896 return ref_frame == NONE ? NULL : get_ref_frame_buffer(cpi, ref_frame);
2899 int vp9_copy_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
2900 YV12_BUFFER_CONFIG *sd) {
2901 YV12_BUFFER_CONFIG *cfg = get_vp9_ref_frame_buffer(cpi, ref_frame_flag);
2903 vpx_yv12_copy_frame(cfg, sd);
2910 int vp9_set_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
2911 YV12_BUFFER_CONFIG *sd) {
2912 YV12_BUFFER_CONFIG *cfg = get_vp9_ref_frame_buffer(cpi, ref_frame_flag);
2914 vpx_yv12_copy_frame(sd, cfg);
2921 int vp9_update_entropy(VP9_COMP *cpi, int update) {
2922 cpi->ext_refresh_frame_context = update;
2923 cpi->ext_refresh_frame_context_pending = 1;
2927 #ifdef OUTPUT_YUV_REC
2928 void vp9_write_yuv_rec_frame(VP9_COMMON *cm) {
2929 YV12_BUFFER_CONFIG *s = cm->frame_to_show;
2930 uint8_t *src = s->y_buffer;
2933 #if CONFIG_VP9_HIGHBITDEPTH
2934 if (s->flags & YV12_FLAG_HIGHBITDEPTH) {
2935 uint16_t *src16 = CONVERT_TO_SHORTPTR(s->y_buffer);
2938 fwrite(src16, s->y_width, 2, yuv_rec_file);
2939 src16 += s->y_stride;
2942 src16 = CONVERT_TO_SHORTPTR(s->u_buffer);
2946 fwrite(src16, s->uv_width, 2, yuv_rec_file);
2947 src16 += s->uv_stride;
2950 src16 = CONVERT_TO_SHORTPTR(s->v_buffer);
2954 fwrite(src16, s->uv_width, 2, yuv_rec_file);
2955 src16 += s->uv_stride;
2958 fflush(yuv_rec_file);
2961 #endif // CONFIG_VP9_HIGHBITDEPTH
2964 fwrite(src, s->y_width, 1, yuv_rec_file);
2972 fwrite(src, s->uv_width, 1, yuv_rec_file);
2973 src += s->uv_stride;
2980 fwrite(src, s->uv_width, 1, yuv_rec_file);
2981 src += s->uv_stride;
2984 fflush(yuv_rec_file);
2988 #if CONFIG_VP9_HIGHBITDEPTH
2989 static void scale_and_extend_frame_nonnormative(const YV12_BUFFER_CONFIG *src,
2990 YV12_BUFFER_CONFIG *dst,
2993 static void scale_and_extend_frame_nonnormative(const YV12_BUFFER_CONFIG *src,
2994 YV12_BUFFER_CONFIG *dst) {
2995 #endif // CONFIG_VP9_HIGHBITDEPTH
2996 // TODO(dkovalev): replace YV12_BUFFER_CONFIG with vpx_image_t
2998 const uint8_t *const srcs[3] = { src->y_buffer, src->u_buffer,
3000 const int src_strides[3] = { src->y_stride, src->uv_stride, src->uv_stride };
3001 const int src_widths[3] = { src->y_crop_width, src->uv_crop_width,
3002 src->uv_crop_width };
3003 const int src_heights[3] = { src->y_crop_height, src->uv_crop_height,
3004 src->uv_crop_height };
3005 uint8_t *const dsts[3] = { dst->y_buffer, dst->u_buffer, dst->v_buffer };
3006 const int dst_strides[3] = { dst->y_stride, dst->uv_stride, dst->uv_stride };
3007 const int dst_widths[3] = { dst->y_crop_width, dst->uv_crop_width,
3008 dst->uv_crop_width };
3009 const int dst_heights[3] = { dst->y_crop_height, dst->uv_crop_height,
3010 dst->uv_crop_height };
3012 for (i = 0; i < MAX_MB_PLANE; ++i) {
3013 #if CONFIG_VP9_HIGHBITDEPTH
3014 if (src->flags & YV12_FLAG_HIGHBITDEPTH) {
3015 vp9_highbd_resize_plane(srcs[i], src_heights[i], src_widths[i],
3016 src_strides[i], dsts[i], dst_heights[i],
3017 dst_widths[i], dst_strides[i], bd);
3019 vp9_resize_plane(srcs[i], src_heights[i], src_widths[i], src_strides[i],
3020 dsts[i], dst_heights[i], dst_widths[i], dst_strides[i]);
3023 vp9_resize_plane(srcs[i], src_heights[i], src_widths[i], src_strides[i],
3024 dsts[i], dst_heights[i], dst_widths[i], dst_strides[i]);
3025 #endif // CONFIG_VP9_HIGHBITDEPTH
3027 vpx_extend_frame_borders(dst);
3030 #if CONFIG_VP9_HIGHBITDEPTH
3031 static void scale_and_extend_frame(const YV12_BUFFER_CONFIG *src,
3032 YV12_BUFFER_CONFIG *dst, int bd,
3033 INTERP_FILTER filter_type,
3035 const int src_w = src->y_crop_width;
3036 const int src_h = src->y_crop_height;
3037 const int dst_w = dst->y_crop_width;
3038 const int dst_h = dst->y_crop_height;
3039 const uint8_t *const srcs[3] = { src->y_buffer, src->u_buffer,
3041 const int src_strides[3] = { src->y_stride, src->uv_stride, src->uv_stride };
3042 uint8_t *const dsts[3] = { dst->y_buffer, dst->u_buffer, dst->v_buffer };
3043 const int dst_strides[3] = { dst->y_stride, dst->uv_stride, dst->uv_stride };
3044 const InterpKernel *const kernel = vp9_filter_kernels[filter_type];
3047 for (i = 0; i < MAX_MB_PLANE; ++i) {
3048 const int factor = (i == 0 || i == 3 ? 1 : 2);
3049 const int src_stride = src_strides[i];
3050 const int dst_stride = dst_strides[i];
3051 for (y = 0; y < dst_h; y += 16) {
3052 const int y_q4 = y * (16 / factor) * src_h / dst_h + phase_scaler;
3053 for (x = 0; x < dst_w; x += 16) {
3054 const int x_q4 = x * (16 / factor) * src_w / dst_w + phase_scaler;
3055 const uint8_t *src_ptr = srcs[i] +
3056 (y / factor) * src_h / dst_h * src_stride +
3057 (x / factor) * src_w / dst_w;
3058 uint8_t *dst_ptr = dsts[i] + (y / factor) * dst_stride + (x / factor);
3060 if (src->flags & YV12_FLAG_HIGHBITDEPTH) {
3061 vpx_highbd_convolve8(CONVERT_TO_SHORTPTR(src_ptr), src_stride,
3062 CONVERT_TO_SHORTPTR(dst_ptr), dst_stride, kernel,
3063 x_q4 & 0xf, 16 * src_w / dst_w, y_q4 & 0xf,
3064 16 * src_h / dst_h, 16 / factor, 16 / factor,
3067 vpx_scaled_2d(src_ptr, src_stride, dst_ptr, dst_stride, kernel,
3068 x_q4 & 0xf, 16 * src_w / dst_w, y_q4 & 0xf,
3069 16 * src_h / dst_h, 16 / factor, 16 / factor);
3075 vpx_extend_frame_borders(dst);
3077 #endif // CONFIG_VP9_HIGHBITDEPTH
3079 #if !CONFIG_REALTIME_ONLY
3080 static int scale_down(VP9_COMP *cpi, int q) {
3081 RATE_CONTROL *const rc = &cpi->rc;
3082 GF_GROUP *const gf_group = &cpi->twopass.gf_group;
3084 assert(frame_is_kf_gf_arf(cpi));
3086 if (rc->frame_size_selector == UNSCALED &&
3087 q >= rc->rf_level_maxq[gf_group->rf_level[gf_group->index]]) {
3088 const int max_size_thresh =
3089 (int)(rate_thresh_mult[SCALE_STEP1] *
3090 VPXMAX(rc->this_frame_target, rc->avg_frame_bandwidth));
3091 scale = rc->projected_frame_size > max_size_thresh ? 1 : 0;
3096 static int big_rate_miss_high_threshold(VP9_COMP *cpi) {
3097 const RATE_CONTROL *const rc = &cpi->rc;
3100 if (frame_is_kf_gf_arf(cpi))
3101 big_miss_high = rc->this_frame_target * 3 / 2;
3103 big_miss_high = rc->this_frame_target * 2;
3105 return big_miss_high;
3108 static int big_rate_miss(VP9_COMP *cpi) {
3109 const RATE_CONTROL *const rc = &cpi->rc;
3113 // Ignore for overlay frames
3114 if (rc->is_src_frame_alt_ref) {
3117 big_miss_low = (rc->this_frame_target / 2);
3118 big_miss_high = big_rate_miss_high_threshold(cpi);
3120 return (rc->projected_frame_size > big_miss_high) ||
3121 (rc->projected_frame_size < big_miss_low);
3125 // test in two pass for the first
3126 static int two_pass_first_group_inter(VP9_COMP *cpi) {
3127 if (cpi->oxcf.pass == 2) {
3128 TWO_PASS *const twopass = &cpi->twopass;
3129 GF_GROUP *const gf_group = &twopass->gf_group;
3130 const int gfg_index = gf_group->index;
3132 if (gfg_index == 0) return gf_group->update_type[gfg_index] == LF_UPDATE;
3133 return gf_group->update_type[gfg_index - 1] != LF_UPDATE &&
3134 gf_group->update_type[gfg_index] == LF_UPDATE;
3140 // Function to test for conditions that indicate we should loop
3141 // back and recode a frame.
3142 static int recode_loop_test(VP9_COMP *cpi, int high_limit, int low_limit, int q,
3143 int maxq, int minq) {
3144 const RATE_CONTROL *const rc = &cpi->rc;
3145 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
3146 const int frame_is_kfgfarf = frame_is_kf_gf_arf(cpi);
3147 int force_recode = 0;
3149 if ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
3150 big_rate_miss(cpi) || (cpi->sf.recode_loop == ALLOW_RECODE) ||
3151 (two_pass_first_group_inter(cpi) &&
3152 (cpi->sf.recode_loop == ALLOW_RECODE_FIRST)) ||
3153 (frame_is_kfgfarf && (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF))) {
3154 if (frame_is_kfgfarf && (oxcf->resize_mode == RESIZE_DYNAMIC) &&
3155 scale_down(cpi, q)) {
3156 // Code this group at a lower resolution.
3157 cpi->resize_pending = 1;
3161 // Force recode for extreme overshoot.
3162 if ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
3163 (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF &&
3164 rc->projected_frame_size >= big_rate_miss_high_threshold(cpi))) {
3168 // TODO(agrange) high_limit could be greater than the scale-down threshold.
3169 if ((rc->projected_frame_size > high_limit && q < maxq) ||
3170 (rc->projected_frame_size < low_limit && q > minq)) {
3172 } else if (cpi->oxcf.rc_mode == VPX_CQ) {
3173 // Deal with frame undershoot and whether or not we are
3174 // below the automatically set cq level.
3175 if (q > oxcf->cq_level &&
3176 rc->projected_frame_size < ((rc->this_frame_target * 7) >> 3)) {
3181 return force_recode;
3183 #endif // !CONFIG_REALTIME_ONLY
3185 static void update_ref_frames(VP9_COMP *cpi) {
3186 VP9_COMMON *const cm = &cpi->common;
3187 BufferPool *const pool = cm->buffer_pool;
3188 GF_GROUP *const gf_group = &cpi->twopass.gf_group;
3190 if (cpi->rc.show_arf_as_gld) {
3191 int tmp = cpi->alt_fb_idx;
3192 cpi->alt_fb_idx = cpi->gld_fb_idx;
3193 cpi->gld_fb_idx = tmp;
3194 } else if (cm->show_existing_frame) {
3196 cpi->lst_fb_idx = cpi->alt_fb_idx;
3198 stack_pop(gf_group->arf_index_stack, gf_group->stack_size);
3199 --gf_group->stack_size;
3202 // At this point the new frame has been encoded.
3203 // If any buffer copy / swapping is signaled it should be done here.
3204 if (cm->frame_type == KEY_FRAME) {
3205 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
3207 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->alt_fb_idx],
3209 } else if (vp9_preserve_existing_gf(cpi)) {
3210 // We have decided to preserve the previously existing golden frame as our
3211 // new ARF frame. However, in the short term in function
3212 // vp9_get_refresh_mask() we left it in the GF slot and, if
3213 // we're updating the GF with the current decoded frame, we save it to the
3214 // ARF slot instead.
3215 // We now have to update the ARF with the current frame and swap gld_fb_idx
3216 // and alt_fb_idx so that, overall, we've stored the old GF in the new ARF
3217 // slot and, if we're updating the GF, the current frame becomes the new GF.
3220 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->alt_fb_idx],
3223 tmp = cpi->alt_fb_idx;
3224 cpi->alt_fb_idx = cpi->gld_fb_idx;
3225 cpi->gld_fb_idx = tmp;
3226 } else { /* For non key/golden frames */
3227 if (cpi->refresh_alt_ref_frame) {
3228 int arf_idx = gf_group->top_arf_idx;
3230 // Push new ARF into stack.
3231 stack_push(gf_group->arf_index_stack, cpi->alt_fb_idx,
3232 gf_group->stack_size);
3233 ++gf_group->stack_size;
3235 assert(arf_idx < REF_FRAMES);
3237 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[arf_idx], cm->new_fb_idx);
3238 memcpy(cpi->interp_filter_selected[ALTREF_FRAME],
3239 cpi->interp_filter_selected[0],
3240 sizeof(cpi->interp_filter_selected[0]));
3242 cpi->alt_fb_idx = arf_idx;
3245 if (cpi->refresh_golden_frame) {
3246 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
3248 if (!cpi->rc.is_src_frame_alt_ref)
3249 memcpy(cpi->interp_filter_selected[GOLDEN_FRAME],
3250 cpi->interp_filter_selected[0],
3251 sizeof(cpi->interp_filter_selected[0]));
3253 memcpy(cpi->interp_filter_selected[GOLDEN_FRAME],
3254 cpi->interp_filter_selected[ALTREF_FRAME],
3255 sizeof(cpi->interp_filter_selected[ALTREF_FRAME]));
3259 if (cpi->refresh_last_frame) {
3260 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->lst_fb_idx],
3262 if (!cpi->rc.is_src_frame_alt_ref)
3263 memcpy(cpi->interp_filter_selected[LAST_FRAME],
3264 cpi->interp_filter_selected[0],
3265 sizeof(cpi->interp_filter_selected[0]));
3268 if (gf_group->update_type[gf_group->index] == MID_OVERLAY_UPDATE) {
3270 stack_pop(gf_group->arf_index_stack, gf_group->stack_size);
3271 --gf_group->stack_size;
3275 void vp9_update_reference_frames(VP9_COMP *cpi) {
3276 update_ref_frames(cpi);
3278 #if CONFIG_VP9_TEMPORAL_DENOISING
3279 vp9_denoiser_update_ref_frame(cpi);
3282 if (is_one_pass_cbr_svc(cpi)) vp9_svc_update_ref_frame(cpi);
3285 static void loopfilter_frame(VP9_COMP *cpi, VP9_COMMON *cm) {
3286 MACROBLOCKD *xd = &cpi->td.mb.e_mbd;
3287 struct loopfilter *lf = &cm->lf;
3288 int is_reference_frame =
3289 (cm->frame_type == KEY_FRAME || cpi->refresh_last_frame ||
3290 cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame);
3292 cpi->svc.temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS)
3293 is_reference_frame = !cpi->svc.non_reference_frame;
3295 // Skip loop filter in show_existing_frame mode.
3296 if (cm->show_existing_frame) {
3297 lf->filter_level = 0;
3302 lf->filter_level = 0;
3303 lf->last_filt_level = 0;
3305 struct vpx_usec_timer timer;
3307 vpx_clear_system_state();
3309 vpx_usec_timer_start(&timer);
3311 if (!cpi->rc.is_src_frame_alt_ref) {
3312 if ((cpi->common.frame_type == KEY_FRAME) &&
3313 (!cpi->rc.this_key_frame_forced)) {
3314 lf->last_filt_level = 0;
3316 vp9_pick_filter_level(cpi->Source, cpi, cpi->sf.lpf_pick);
3317 lf->last_filt_level = lf->filter_level;
3319 lf->filter_level = 0;
3322 vpx_usec_timer_mark(&timer);
3323 cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
3326 if (lf->filter_level > 0 && is_reference_frame) {
3327 vp9_build_mask_frame(cm, lf->filter_level, 0);
3329 if (cpi->num_workers > 1)
3330 vp9_loop_filter_frame_mt(cm->frame_to_show, cm, xd->plane,
3331 lf->filter_level, 0, 0, cpi->workers,
3332 cpi->num_workers, &cpi->lf_row_sync);
3334 vp9_loop_filter_frame(cm->frame_to_show, cm, xd, lf->filter_level, 0, 0);
3337 vpx_extend_frame_inner_borders(cm->frame_to_show);
3340 static INLINE void alloc_frame_mvs(VP9_COMMON *const cm, int buffer_idx) {
3341 RefCntBuffer *const new_fb_ptr = &cm->buffer_pool->frame_bufs[buffer_idx];
3342 if (new_fb_ptr->mvs == NULL || new_fb_ptr->mi_rows < cm->mi_rows ||
3343 new_fb_ptr->mi_cols < cm->mi_cols) {
3344 vpx_free(new_fb_ptr->mvs);
3345 CHECK_MEM_ERROR(cm, new_fb_ptr->mvs,
3346 (MV_REF *)vpx_calloc(cm->mi_rows * cm->mi_cols,
3347 sizeof(*new_fb_ptr->mvs)));
3348 new_fb_ptr->mi_rows = cm->mi_rows;
3349 new_fb_ptr->mi_cols = cm->mi_cols;
3353 void vp9_scale_references(VP9_COMP *cpi) {
3354 VP9_COMMON *cm = &cpi->common;
3355 MV_REFERENCE_FRAME ref_frame;
3356 const VP9_REFFRAME ref_mask[3] = { VP9_LAST_FLAG, VP9_GOLD_FLAG,
3359 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3360 // Need to convert from VP9_REFFRAME to index into ref_mask (subtract 1).
3361 if (cpi->ref_frame_flags & ref_mask[ref_frame - 1]) {
3362 BufferPool *const pool = cm->buffer_pool;
3363 const YV12_BUFFER_CONFIG *const ref =
3364 get_ref_frame_buffer(cpi, ref_frame);
3367 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3371 #if CONFIG_VP9_HIGHBITDEPTH
3372 if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) {
3373 RefCntBuffer *new_fb_ptr = NULL;
3374 int force_scaling = 0;
3375 int new_fb = cpi->scaled_ref_idx[ref_frame - 1];
3376 if (new_fb == INVALID_IDX) {
3377 new_fb = get_free_fb(cm);
3380 if (new_fb == INVALID_IDX) return;
3381 new_fb_ptr = &pool->frame_bufs[new_fb];
3382 if (force_scaling || new_fb_ptr->buf.y_crop_width != cm->width ||
3383 new_fb_ptr->buf.y_crop_height != cm->height) {
3384 if (vpx_realloc_frame_buffer(&new_fb_ptr->buf, cm->width, cm->height,
3385 cm->subsampling_x, cm->subsampling_y,
3386 cm->use_highbitdepth,
3387 VP9_ENC_BORDER_IN_PIXELS,
3388 cm->byte_alignment, NULL, NULL, NULL))
3389 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3390 "Failed to allocate frame buffer");
3391 scale_and_extend_frame(ref, &new_fb_ptr->buf, (int)cm->bit_depth,
3393 cpi->scaled_ref_idx[ref_frame - 1] = new_fb;
3394 alloc_frame_mvs(cm, new_fb);
3397 if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) {
3398 RefCntBuffer *new_fb_ptr = NULL;
3399 int force_scaling = 0;
3400 int new_fb = cpi->scaled_ref_idx[ref_frame - 1];
3401 if (new_fb == INVALID_IDX) {
3402 new_fb = get_free_fb(cm);
3405 if (new_fb == INVALID_IDX) return;
3406 new_fb_ptr = &pool->frame_bufs[new_fb];
3407 if (force_scaling || new_fb_ptr->buf.y_crop_width != cm->width ||
3408 new_fb_ptr->buf.y_crop_height != cm->height) {
3409 if (vpx_realloc_frame_buffer(&new_fb_ptr->buf, cm->width, cm->height,
3410 cm->subsampling_x, cm->subsampling_y,
3411 VP9_ENC_BORDER_IN_PIXELS,
3412 cm->byte_alignment, NULL, NULL, NULL))
3413 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3414 "Failed to allocate frame buffer");
3415 vp9_scale_and_extend_frame(ref, &new_fb_ptr->buf, EIGHTTAP, 0);
3416 cpi->scaled_ref_idx[ref_frame - 1] = new_fb;
3417 alloc_frame_mvs(cm, new_fb);
3419 #endif // CONFIG_VP9_HIGHBITDEPTH
3422 RefCntBuffer *buf = NULL;
3423 if (cpi->oxcf.pass == 0 && !cpi->use_svc) {
3424 // Check for release of scaled reference.
3425 buf_idx = cpi->scaled_ref_idx[ref_frame - 1];
3426 if (buf_idx != INVALID_IDX) {
3427 buf = &pool->frame_bufs[buf_idx];
3429 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3432 buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
3433 buf = &pool->frame_bufs[buf_idx];
3434 buf->buf.y_crop_width = ref->y_crop_width;
3435 buf->buf.y_crop_height = ref->y_crop_height;
3436 cpi->scaled_ref_idx[ref_frame - 1] = buf_idx;
3440 if (cpi->oxcf.pass != 0 || cpi->use_svc)
3441 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX;
3446 static void release_scaled_references(VP9_COMP *cpi) {
3447 VP9_COMMON *cm = &cpi->common;
3449 if (cpi->oxcf.pass == 0 && !cpi->use_svc) {
3450 // Only release scaled references under certain conditions:
3451 // if reference will be updated, or if scaled reference has same resolution.
3453 refresh[0] = (cpi->refresh_last_frame) ? 1 : 0;
3454 refresh[1] = (cpi->refresh_golden_frame) ? 1 : 0;
3455 refresh[2] = (cpi->refresh_alt_ref_frame) ? 1 : 0;
3456 for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
3457 const int idx = cpi->scaled_ref_idx[i - 1];
3458 if (idx != INVALID_IDX) {
3459 RefCntBuffer *const buf = &cm->buffer_pool->frame_bufs[idx];
3460 const YV12_BUFFER_CONFIG *const ref = get_ref_frame_buffer(cpi, i);
3461 if (refresh[i - 1] || (buf->buf.y_crop_width == ref->y_crop_width &&
3462 buf->buf.y_crop_height == ref->y_crop_height)) {
3464 cpi->scaled_ref_idx[i - 1] = INVALID_IDX;
3469 for (i = 0; i < REFS_PER_FRAME; ++i) {
3470 const int idx = cpi->scaled_ref_idx[i];
3471 if (idx != INVALID_IDX) {
3472 RefCntBuffer *const buf = &cm->buffer_pool->frame_bufs[idx];
3474 cpi->scaled_ref_idx[i] = INVALID_IDX;
3480 static void full_to_model_count(unsigned int *model_count,
3481 unsigned int *full_count) {
3483 model_count[ZERO_TOKEN] = full_count[ZERO_TOKEN];
3484 model_count[ONE_TOKEN] = full_count[ONE_TOKEN];
3485 model_count[TWO_TOKEN] = full_count[TWO_TOKEN];
3486 for (n = THREE_TOKEN; n < EOB_TOKEN; ++n)
3487 model_count[TWO_TOKEN] += full_count[n];
3488 model_count[EOB_MODEL_TOKEN] = full_count[EOB_TOKEN];
3491 static void full_to_model_counts(vp9_coeff_count_model *model_count,
3492 vp9_coeff_count *full_count) {
3495 for (i = 0; i < PLANE_TYPES; ++i)
3496 for (j = 0; j < REF_TYPES; ++j)
3497 for (k = 0; k < COEF_BANDS; ++k)
3498 for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l)
3499 full_to_model_count(model_count[i][j][k][l], full_count[i][j][k][l]);
3502 #if 0 && CONFIG_INTERNAL_STATS
3503 static void output_frame_level_debug_stats(VP9_COMP *cpi) {
3504 VP9_COMMON *const cm = &cpi->common;
3505 FILE *const f = fopen("tmp.stt", cm->current_video_frame ? "a" : "w");
3508 vpx_clear_system_state();
3510 #if CONFIG_VP9_HIGHBITDEPTH
3511 if (cm->use_highbitdepth) {
3512 recon_err = vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3514 recon_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3517 recon_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
3518 #endif // CONFIG_VP9_HIGHBITDEPTH
3521 if (cpi->twopass.total_left_stats.coded_error != 0.0) {
3522 double dc_quant_devisor;
3523 #if CONFIG_VP9_HIGHBITDEPTH
3524 switch (cm->bit_depth) {
3526 dc_quant_devisor = 4.0;
3529 dc_quant_devisor = 16.0;
3532 assert(cm->bit_depth == VPX_BITS_12);
3533 dc_quant_devisor = 64.0;
3537 dc_quant_devisor = 4.0;
3540 if (!cm->current_video_frame) {
3541 fprintf(f, "frame, width, height, last ts, last end ts, "
3542 "source_alt_ref_pending, source_alt_ref_active, "
3543 "this_frame_target, projected_frame_size, "
3544 "projected_frame_size / MBs, "
3545 "projected_frame_size - this_frame_target, "
3546 "vbr_bits_off_target, vbr_bits_off_target_fast, "
3547 "twopass.extend_minq, twopass.extend_minq_fast, "
3548 "total_target_vs_actual, "
3549 "starting_buffer_level - bits_off_target, "
3550 "total_actual_bits, base_qindex, q for base_qindex, "
3551 "dc quant, q for active_worst_quality, avg_q, q for oxcf.cq_level, "
3552 "refresh_last_frame, refresh_golden_frame, refresh_alt_ref_frame, "
3553 "frame_type, gfu_boost, "
3554 "twopass.bits_left, "
3555 "twopass.total_left_stats.coded_error, "
3556 "twopass.bits_left / (1 + twopass.total_left_stats.coded_error), "
3557 "tot_recode_hits, recon_err, kf_boost, "
3558 "twopass.kf_zeromotion_pct, twopass.fr_content_type, "
3559 "filter_level, seg.aq_av_offset\n");
3562 fprintf(f, "%10u, %d, %d, %10"PRId64", %10"PRId64", %d, %d, %10d, %10d, "
3563 "%10d, %10d, %10"PRId64", %10"PRId64", %5d, %5d, %10"PRId64", "
3564 "%10"PRId64", %10"PRId64", %10d, %7.2lf, %7.2lf, %7.2lf, %7.2lf, "
3565 "%7.2lf, %6d, %6d, %5d, %5d, %5d, %10"PRId64", %10.3lf, %10lf, %8u, "
3566 "%10"PRId64", %10d, %10d, %10d, %10d, %10d\n",
3567 cpi->common.current_video_frame,
3568 cm->width, cm->height,
3569 cpi->last_time_stamp_seen,
3570 cpi->last_end_time_stamp_seen,
3571 cpi->rc.source_alt_ref_pending,
3572 cpi->rc.source_alt_ref_active,
3573 cpi->rc.this_frame_target,
3574 cpi->rc.projected_frame_size,
3575 cpi->rc.projected_frame_size / cpi->common.MBs,
3576 (cpi->rc.projected_frame_size - cpi->rc.this_frame_target),
3577 cpi->rc.vbr_bits_off_target,
3578 cpi->rc.vbr_bits_off_target_fast,
3579 cpi->twopass.extend_minq,
3580 cpi->twopass.extend_minq_fast,
3581 cpi->rc.total_target_vs_actual,
3582 (cpi->rc.starting_buffer_level - cpi->rc.bits_off_target),
3583 cpi->rc.total_actual_bits, cm->base_qindex,
3584 vp9_convert_qindex_to_q(cm->base_qindex, cm->bit_depth),
3585 (double)vp9_dc_quant(cm->base_qindex, 0, cm->bit_depth) /
3587 vp9_convert_qindex_to_q(cpi->twopass.active_worst_quality,
3590 vp9_convert_qindex_to_q(cpi->oxcf.cq_level, cm->bit_depth),
3591 cpi->refresh_last_frame, cpi->refresh_golden_frame,
3592 cpi->refresh_alt_ref_frame, cm->frame_type, cpi->rc.gfu_boost,
3593 cpi->twopass.bits_left,
3594 cpi->twopass.total_left_stats.coded_error,
3595 cpi->twopass.bits_left /
3596 (1 + cpi->twopass.total_left_stats.coded_error),
3597 cpi->tot_recode_hits, recon_err, cpi->rc.kf_boost,
3598 cpi->twopass.kf_zeromotion_pct,
3599 cpi->twopass.fr_content_type,
3600 cm->lf.filter_level,
3601 cm->seg.aq_av_offset);
3606 FILE *const fmodes = fopen("Modes.stt", "a");
3609 fprintf(fmodes, "%6d:%1d:%1d:%1d ", cpi->common.current_video_frame,
3610 cm->frame_type, cpi->refresh_golden_frame,
3611 cpi->refresh_alt_ref_frame);
3613 for (i = 0; i < MAX_MODES; ++i)
3614 fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
3616 fprintf(fmodes, "\n");
3623 static void set_mv_search_params(VP9_COMP *cpi) {
3624 const VP9_COMMON *const cm = &cpi->common;
3625 const unsigned int max_mv_def = VPXMIN(cm->width, cm->height);
3627 // Default based on max resolution.
3628 cpi->mv_step_param = vp9_init_search_range(max_mv_def);
3630 if (cpi->sf.mv.auto_mv_step_size) {
3631 if (frame_is_intra_only(cm)) {
3632 // Initialize max_mv_magnitude for use in the first INTER frame
3633 // after a key/intra-only frame.
3634 cpi->max_mv_magnitude = max_mv_def;
3636 if (cm->show_frame) {
3637 // Allow mv_steps to correspond to twice the max mv magnitude found
3638 // in the previous frame, capped by the default max_mv_magnitude based
3640 cpi->mv_step_param = vp9_init_search_range(
3641 VPXMIN(max_mv_def, 2 * cpi->max_mv_magnitude));
3643 cpi->max_mv_magnitude = 0;
3648 static void set_size_independent_vars(VP9_COMP *cpi) {
3649 vp9_set_speed_features_framesize_independent(cpi, cpi->oxcf.speed);
3650 vp9_set_rd_speed_thresholds(cpi);
3651 vp9_set_rd_speed_thresholds_sub8x8(cpi);
3652 cpi->common.interp_filter = cpi->sf.default_interp_filter;
3655 static void set_size_dependent_vars(VP9_COMP *cpi, int *q, int *bottom_index,
3657 VP9_COMMON *const cm = &cpi->common;
3659 // Setup variables that depend on the dimensions of the frame.
3660 vp9_set_speed_features_framesize_dependent(cpi, cpi->oxcf.speed);
3662 // Decide q and q bounds.
3663 *q = vp9_rc_pick_q_and_bounds(cpi, bottom_index, top_index);
3665 if (cpi->oxcf.rc_mode == VPX_CBR && cpi->rc.force_max_q) {
3666 *q = cpi->rc.worst_quality;
3667 cpi->rc.force_max_q = 0;
3670 if (!frame_is_intra_only(cm)) {
3671 vp9_set_high_precision_mv(cpi, (*q) < HIGH_PRECISION_MV_QTHRESH);
3674 #if !CONFIG_REALTIME_ONLY
3675 // Configure experimental use of segmentation for enhanced coding of
3676 // static regions if indicated.
3677 // Only allowed in the second pass of a two pass encode, as it requires
3678 // lagged coding, and if the relevant speed feature flag is set.
3679 if (cpi->oxcf.pass == 2 && cpi->sf.static_segmentation)
3680 configure_static_seg_features(cpi);
3681 #endif // !CONFIG_REALTIME_ONLY
3683 #if CONFIG_VP9_POSTPROC && !(CONFIG_VP9_TEMPORAL_DENOISING)
3684 if (cpi->oxcf.noise_sensitivity > 0) {
3686 switch (cpi->oxcf.noise_sensitivity) {
3687 case 1: l = 20; break;
3688 case 2: l = 40; break;
3689 case 3: l = 60; break;
3691 case 5: l = 100; break;
3692 case 6: l = 150; break;
3694 if (!cpi->common.postproc_state.limits) {
3695 cpi->common.postproc_state.limits =
3696 vpx_calloc(cpi->un_scaled_source->y_width,
3697 sizeof(*cpi->common.postproc_state.limits));
3699 vp9_denoise(&cpi->common, cpi->Source, cpi->Source, l,
3700 cpi->common.postproc_state.limits);
3702 #endif // CONFIG_VP9_POSTPROC
3705 static void init_motion_estimation(VP9_COMP *cpi) {
3706 int y_stride = cpi->scaled_source.y_stride;
3708 if (cpi->sf.mv.search_method == NSTEP) {
3709 vp9_init3smotion_compensation(&cpi->ss_cfg, y_stride);
3710 } else if (cpi->sf.mv.search_method == DIAMOND) {
3711 vp9_init_dsmotion_compensation(&cpi->ss_cfg, y_stride);
3715 static void set_frame_size(VP9_COMP *cpi) {
3717 VP9_COMMON *const cm = &cpi->common;
3718 VP9EncoderConfig *const oxcf = &cpi->oxcf;
3719 MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
3721 #if !CONFIG_REALTIME_ONLY
3722 if (oxcf->pass == 2 && oxcf->rc_mode == VPX_VBR &&
3723 ((oxcf->resize_mode == RESIZE_FIXED && cm->current_video_frame == 0) ||
3724 (oxcf->resize_mode == RESIZE_DYNAMIC && cpi->resize_pending))) {
3725 calculate_coded_size(cpi, &oxcf->scaled_frame_width,
3726 &oxcf->scaled_frame_height);
3728 // There has been a change in frame size.
3729 vp9_set_size_literal(cpi, oxcf->scaled_frame_width,
3730 oxcf->scaled_frame_height);
3732 #endif // !CONFIG_REALTIME_ONLY
3734 if (oxcf->pass == 0 && oxcf->rc_mode == VPX_CBR && !cpi->use_svc &&
3735 oxcf->resize_mode == RESIZE_DYNAMIC && cpi->resize_pending != 0) {
3736 oxcf->scaled_frame_width =
3737 (oxcf->width * cpi->resize_scale_num) / cpi->resize_scale_den;
3738 oxcf->scaled_frame_height =
3739 (oxcf->height * cpi->resize_scale_num) / cpi->resize_scale_den;
3740 // There has been a change in frame size.
3741 vp9_set_size_literal(cpi, oxcf->scaled_frame_width,
3742 oxcf->scaled_frame_height);
3744 // TODO(agrange) Scale cpi->max_mv_magnitude if frame-size has changed.
3745 set_mv_search_params(cpi);
3747 vp9_noise_estimate_init(&cpi->noise_estimate, cm->width, cm->height);
3748 #if CONFIG_VP9_TEMPORAL_DENOISING
3749 // Reset the denoiser on the resized frame.
3750 if (cpi->oxcf.noise_sensitivity > 0) {
3751 vp9_denoiser_free(&(cpi->denoiser));
3752 setup_denoiser_buffer(cpi);
3753 // Dynamic resize is only triggered for non-SVC, so we can force
3754 // golden frame update here as temporary fix to denoiser.
3755 cpi->refresh_golden_frame = 1;
3760 if ((oxcf->pass == 2) && !cpi->use_svc) {
3761 vp9_set_target_rate(cpi);
3764 alloc_frame_mvs(cm, cm->new_fb_idx);
3766 // Reset the frame pointers to the current frame size.
3767 if (vpx_realloc_frame_buffer(get_frame_new_buffer(cm), cm->width, cm->height,
3768 cm->subsampling_x, cm->subsampling_y,
3769 #if CONFIG_VP9_HIGHBITDEPTH
3770 cm->use_highbitdepth,
3772 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
3774 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
3775 "Failed to allocate frame buffer");
3777 alloc_util_frame_buffers(cpi);
3778 init_motion_estimation(cpi);
3780 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
3781 RefBuffer *const ref_buf = &cm->frame_refs[ref_frame - 1];
3782 const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
3784 ref_buf->idx = buf_idx;
3786 if (buf_idx != INVALID_IDX) {
3787 YV12_BUFFER_CONFIG *const buf = &cm->buffer_pool->frame_bufs[buf_idx].buf;
3789 #if CONFIG_VP9_HIGHBITDEPTH
3790 vp9_setup_scale_factors_for_frame(
3791 &ref_buf->sf, buf->y_crop_width, buf->y_crop_height, cm->width,
3792 cm->height, (buf->flags & YV12_FLAG_HIGHBITDEPTH) ? 1 : 0);
3794 vp9_setup_scale_factors_for_frame(&ref_buf->sf, buf->y_crop_width,
3795 buf->y_crop_height, cm->width,
3797 #endif // CONFIG_VP9_HIGHBITDEPTH
3798 if (vp9_is_scaled(&ref_buf->sf)) vpx_extend_frame_borders(buf);
3800 ref_buf->buf = NULL;
3804 set_ref_ptrs(cm, xd, LAST_FRAME, LAST_FRAME);
3807 #if CONFIG_CONSISTENT_RECODE
3808 static void save_encode_params(VP9_COMP *cpi) {
3809 VP9_COMMON *const cm = &cpi->common;
3810 const int tile_cols = 1 << cm->log2_tile_cols;
3811 const int tile_rows = 1 << cm->log2_tile_rows;
3812 int tile_col, tile_row;
3814 RD_OPT *rd_opt = &cpi->rd;
3815 for (i = 0; i < MAX_REF_FRAMES; i++) {
3816 for (j = 0; j < REFERENCE_MODES; j++)
3817 rd_opt->prediction_type_threshes_prev[i][j] =
3818 rd_opt->prediction_type_threshes[i][j];
3820 for (j = 0; j < SWITCHABLE_FILTER_CONTEXTS; j++)
3821 rd_opt->filter_threshes_prev[i][j] = rd_opt->filter_threshes[i][j];
3824 if (cpi->tile_data != NULL) {
3825 for (tile_row = 0; tile_row < tile_rows; ++tile_row)
3826 for (tile_col = 0; tile_col < tile_cols; ++tile_col) {
3827 TileDataEnc *tile_data =
3828 &cpi->tile_data[tile_row * tile_cols + tile_col];
3829 for (i = 0; i < BLOCK_SIZES; ++i) {
3830 for (j = 0; j < MAX_MODES; ++j) {
3831 tile_data->thresh_freq_fact_prev[i][j] =
3832 tile_data->thresh_freq_fact[i][j];
3840 static INLINE void set_raw_source_frame(VP9_COMP *cpi) {
3841 #ifdef ENABLE_KF_DENOISE
3842 if (is_spatial_denoise_enabled(cpi)) {
3843 cpi->raw_source_frame = vp9_scale_if_required(
3844 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
3845 (oxcf->pass == 0), EIGHTTAP, 0);
3847 cpi->raw_source_frame = cpi->Source;
3850 cpi->raw_source_frame = cpi->Source;
3854 static int encode_without_recode_loop(VP9_COMP *cpi, size_t *size,
3856 VP9_COMMON *const cm = &cpi->common;
3857 SVC *const svc = &cpi->svc;
3858 int q = 0, bottom_index = 0, top_index = 0;
3859 int no_drop_scene_change = 0;
3860 const INTERP_FILTER filter_scaler =
3861 (is_one_pass_cbr_svc(cpi))
3862 ? svc->downsample_filter_type[svc->spatial_layer_id]
3864 const int phase_scaler =
3865 (is_one_pass_cbr_svc(cpi))
3866 ? svc->downsample_filter_phase[svc->spatial_layer_id]
3869 if (cm->show_existing_frame) {
3870 cpi->rc.this_frame_target = 0;
3871 if (is_psnr_calc_enabled(cpi)) set_raw_source_frame(cpi);
3875 svc->time_stamp_prev[svc->spatial_layer_id] = svc->time_stamp_superframe;
3877 // Flag to check if its valid to compute the source sad (used for
3878 // scene detection and for superblock content state in CBR mode).
3879 // The flag may get reset below based on SVC or resizing state.
3880 cpi->compute_source_sad_onepass = cpi->oxcf.mode == REALTIME;
3882 vpx_clear_system_state();
3884 set_frame_size(cpi);
3886 if (is_one_pass_cbr_svc(cpi) &&
3887 cpi->un_scaled_source->y_width == cm->width << 2 &&
3888 cpi->un_scaled_source->y_height == cm->height << 2 &&
3889 svc->scaled_temp.y_width == cm->width << 1 &&
3890 svc->scaled_temp.y_height == cm->height << 1) {
3891 // For svc, if it is a 1/4x1/4 downscaling, do a two-stage scaling to take
3892 // advantage of the 1:2 optimized scaler. In the process, the 1/2x1/2
3893 // result will be saved in scaled_temp and might be used later.
3894 const INTERP_FILTER filter_scaler2 = svc->downsample_filter_type[1];
3895 const int phase_scaler2 = svc->downsample_filter_phase[1];
3896 cpi->Source = vp9_svc_twostage_scale(
3897 cm, cpi->un_scaled_source, &cpi->scaled_source, &svc->scaled_temp,
3898 filter_scaler, phase_scaler, filter_scaler2, phase_scaler2);
3899 svc->scaled_one_half = 1;
3900 } else if (is_one_pass_cbr_svc(cpi) &&
3901 cpi->un_scaled_source->y_width == cm->width << 1 &&
3902 cpi->un_scaled_source->y_height == cm->height << 1 &&
3903 svc->scaled_one_half) {
3904 // If the spatial layer is 1/2x1/2 and the scaling is already done in the
3905 // two-stage scaling, use the result directly.
3906 cpi->Source = &svc->scaled_temp;
3907 svc->scaled_one_half = 0;
3909 cpi->Source = vp9_scale_if_required(
3910 cm, cpi->un_scaled_source, &cpi->scaled_source, (cpi->oxcf.pass == 0),
3911 filter_scaler, phase_scaler);
3913 #ifdef OUTPUT_YUV_SVC_SRC
3914 // Write out at most 3 spatial layers.
3915 if (is_one_pass_cbr_svc(cpi) && svc->spatial_layer_id < 3) {
3916 vpx_write_yuv_frame(yuv_svc_src[svc->spatial_layer_id], cpi->Source);
3919 // Unfiltered raw source used in metrics calculation if the source
3920 // has been filtered.
3921 if (is_psnr_calc_enabled(cpi)) {
3922 #ifdef ENABLE_KF_DENOISE
3923 if (is_spatial_denoise_enabled(cpi)) {
3924 cpi->raw_source_frame = vp9_scale_if_required(
3925 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
3926 (cpi->oxcf.pass == 0), EIGHTTAP, phase_scaler);
3928 cpi->raw_source_frame = cpi->Source;
3931 cpi->raw_source_frame = cpi->Source;
3935 if ((cpi->use_svc &&
3936 (svc->spatial_layer_id < svc->number_spatial_layers - 1 ||
3937 svc->temporal_layer_id < svc->number_temporal_layers - 1 ||
3938 svc->current_superframe < 1)) ||
3939 cpi->resize_pending || cpi->resize_state || cpi->external_resize ||
3940 cpi->resize_state != ORIG) {
3941 cpi->compute_source_sad_onepass = 0;
3942 if (cpi->content_state_sb_fd != NULL)
3943 memset(cpi->content_state_sb_fd, 0,
3944 (cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1) *
3945 sizeof(*cpi->content_state_sb_fd));
3948 // Avoid scaling last_source unless its needed.
3949 // Last source is needed if avg_source_sad() is used, or if
3950 // partition_search_type == SOURCE_VAR_BASED_PARTITION, or if noise
3951 // estimation is enabled.
3952 if (cpi->unscaled_last_source != NULL &&
3953 (cpi->oxcf.content == VP9E_CONTENT_SCREEN ||
3954 (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == VPX_VBR &&
3955 cpi->oxcf.mode == REALTIME && cpi->oxcf.speed >= 5) ||
3956 cpi->sf.partition_search_type == SOURCE_VAR_BASED_PARTITION ||
3957 (cpi->noise_estimate.enabled && !cpi->oxcf.noise_sensitivity) ||
3958 cpi->compute_source_sad_onepass))
3959 cpi->Last_Source = vp9_scale_if_required(
3960 cm, cpi->unscaled_last_source, &cpi->scaled_last_source,
3961 (cpi->oxcf.pass == 0), EIGHTTAP, 0);
3963 if (cpi->Last_Source == NULL ||
3964 cpi->Last_Source->y_width != cpi->Source->y_width ||
3965 cpi->Last_Source->y_height != cpi->Source->y_height)
3966 cpi->compute_source_sad_onepass = 0;
3968 if (frame_is_intra_only(cm) || cpi->resize_pending != 0) {
3969 memset(cpi->consec_zero_mv, 0,
3970 cm->mi_rows * cm->mi_cols * sizeof(*cpi->consec_zero_mv));
3973 #if CONFIG_VP9_TEMPORAL_DENOISING
3974 if (cpi->oxcf.noise_sensitivity > 0 && cpi->use_svc)
3975 vp9_denoiser_reset_on_first_frame(cpi);
3978 // Scene detection is always used for VBR mode or screen-content case.
3979 // For other cases (e.g., CBR mode) use it for 5 <= speed < 8 for now
3980 // (need to check encoding time cost for doing this for speed 8).
3981 cpi->rc.high_source_sad = 0;
3982 cpi->rc.hybrid_intra_scene_change = 0;
3983 cpi->rc.re_encode_maxq_scene_change = 0;
3984 if (cm->show_frame && cpi->oxcf.mode == REALTIME &&
3985 (cpi->oxcf.rc_mode == VPX_VBR ||
3986 cpi->oxcf.content == VP9E_CONTENT_SCREEN ||
3987 (cpi->oxcf.speed >= 5 && cpi->oxcf.speed < 8)))
3988 vp9_scene_detection_onepass(cpi);
3990 if (svc->spatial_layer_id == svc->first_spatial_layer_to_encode) {
3991 svc->high_source_sad_superframe = cpi->rc.high_source_sad;
3992 svc->high_num_blocks_with_motion = cpi->rc.high_num_blocks_with_motion;
3993 // On scene change reset temporal layer pattern to TL0.
3994 // Note that if the base/lower spatial layers are skipped: instead of
3995 // inserting base layer here, we force max-q for the next superframe
3996 // with lower spatial layers: this is done in vp9_encodedframe_overshoot()
3997 // when max-q is decided for the current layer.
3998 // Only do this reset for bypass/flexible mode.
3999 if (svc->high_source_sad_superframe && svc->temporal_layer_id > 0 &&
4000 svc->temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS) {
4001 // rc->high_source_sad will get reset so copy it to restore it.
4002 int tmp_high_source_sad = cpi->rc.high_source_sad;
4003 vp9_svc_reset_temporal_layers(cpi, cm->frame_type == KEY_FRAME);
4004 cpi->rc.high_source_sad = tmp_high_source_sad;
4008 vp9_update_noise_estimate(cpi);
4010 // For 1 pass CBR, check if we are dropping this frame.
4011 // Never drop on key frame, if base layer is key for svc,
4012 // on scene change, or if superframe has layer sync.
4013 if ((cpi->rc.high_source_sad || svc->high_source_sad_superframe) &&
4014 !(cpi->rc.use_post_encode_drop && svc->last_layer_dropped[0]))
4015 no_drop_scene_change = 1;
4016 if (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == VPX_CBR &&
4017 !frame_is_intra_only(cm) && !no_drop_scene_change &&
4018 !svc->superframe_has_layer_sync &&
4020 !svc->layer_context[svc->temporal_layer_id].is_key_frame)) {
4021 if (vp9_rc_drop_frame(cpi)) return 0;
4024 // For 1 pass CBR SVC, only ZEROMV is allowed for spatial reference frame
4025 // when svc->force_zero_mode_spatial_ref = 1. Under those conditions we can
4026 // avoid this frame-level upsampling (for non intra_only frames).
4027 if (frame_is_intra_only(cm) == 0 &&
4028 !(is_one_pass_cbr_svc(cpi) && svc->force_zero_mode_spatial_ref)) {
4029 vp9_scale_references(cpi);
4032 set_size_independent_vars(cpi);
4033 set_size_dependent_vars(cpi, &q, &bottom_index, &top_index);
4035 // search method and step parameter might be changed in speed settings.
4036 init_motion_estimation(cpi);
4038 if (cpi->sf.copy_partition_flag) alloc_copy_partition_data(cpi);
4040 if (cpi->sf.svc_use_lowres_part &&
4041 svc->spatial_layer_id == svc->number_spatial_layers - 2) {
4042 if (svc->prev_partition_svc == NULL) {
4044 cm, svc->prev_partition_svc,
4045 (BLOCK_SIZE *)vpx_calloc(cm->mi_stride * cm->mi_rows,
4046 sizeof(*svc->prev_partition_svc)));
4050 // TODO(jianj): Look into issue of skin detection with high bitdepth.
4051 if (cm->bit_depth == 8 && cpi->oxcf.speed >= 5 && cpi->oxcf.pass == 0 &&
4052 cpi->oxcf.rc_mode == VPX_CBR &&
4053 cpi->oxcf.content != VP9E_CONTENT_SCREEN &&
4054 cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
4055 cpi->use_skin_detection = 1;
4058 // Enable post encode frame dropping for CBR on non key frame, when
4059 // ext_use_post_encode_drop is specified by user.
4060 cpi->rc.use_post_encode_drop = cpi->rc.ext_use_post_encode_drop &&
4061 cpi->oxcf.rc_mode == VPX_CBR &&
4062 cm->frame_type != KEY_FRAME;
4064 vp9_set_quantizer(cm, q);
4065 vp9_set_variance_partition_thresholds(cpi, q, 0);
4069 suppress_active_map(cpi);
4072 // On non-zero spatial layer, check for disabling inter-layer
4074 if (svc->spatial_layer_id > 0) vp9_svc_constrain_inter_layer_pred(cpi);
4075 vp9_svc_assert_constraints_pattern(cpi);
4078 if (cpi->rc.last_post_encode_dropped_scene_change) {
4079 cpi->rc.high_source_sad = 1;
4080 svc->high_source_sad_superframe = 1;
4081 // For now disable use_source_sad since Last_Source will not be the previous
4082 // encoded but the dropped one.
4083 cpi->sf.use_source_sad = 0;
4084 cpi->rc.last_post_encode_dropped_scene_change = 0;
4086 // Check if this high_source_sad (scene/slide change) frame should be
4087 // encoded at high/max QP, and if so, set the q and adjust some rate
4088 // control parameters.
4089 if (cpi->sf.overshoot_detection_cbr_rt == FAST_DETECTION_MAXQ &&
4090 (cpi->rc.high_source_sad ||
4091 (cpi->use_svc && svc->high_source_sad_superframe))) {
4092 if (vp9_encodedframe_overshoot(cpi, -1, &q)) {
4093 vp9_set_quantizer(cm, q);
4094 vp9_set_variance_partition_thresholds(cpi, q, 0);
4098 #if !CONFIG_REALTIME_ONLY
4099 // Variance adaptive and in frame q adjustment experiments are mutually
4101 if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
4102 vp9_vaq_frame_setup(cpi);
4103 } else if (cpi->oxcf.aq_mode == EQUATOR360_AQ) {
4104 vp9_360aq_frame_setup(cpi);
4105 } else if (cpi->oxcf.aq_mode == COMPLEXITY_AQ) {
4106 vp9_setup_in_frame_q_adj(cpi);
4107 } else if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ) {
4108 // it may be pretty bad for rate-control,
4109 // and I should handle it somehow
4110 vp9_alt_ref_aq_setup_map(cpi->alt_ref_aq, cpi);
4113 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
4114 vp9_cyclic_refresh_setup(cpi);
4115 } else if (cpi->roi.enabled && !frame_is_intra_only(cm)) {
4118 #if !CONFIG_REALTIME_ONLY
4122 apply_active_map(cpi);
4124 vp9_encode_frame(cpi);
4126 // Check if we should re-encode this frame at high Q because of high
4127 // overshoot based on the encoded frame size. Only for frames where
4128 // high temporal-source SAD is detected.
4129 // For SVC: all spatial layers are checked for re-encoding.
4130 if (cpi->sf.overshoot_detection_cbr_rt == RE_ENCODE_MAXQ &&
4131 (cpi->rc.high_source_sad ||
4132 (cpi->use_svc && svc->high_source_sad_superframe))) {
4134 // Get an estimate of the encoded frame size.
4135 save_coding_context(cpi);
4136 vp9_pack_bitstream(cpi, dest, size);
4137 restore_coding_context(cpi);
4138 frame_size = (int)(*size) << 3;
4139 // Check if encoded frame will overshoot too much, and if so, set the q and
4140 // adjust some rate control parameters, and return to re-encode the frame.
4141 if (vp9_encodedframe_overshoot(cpi, frame_size, &q)) {
4142 vpx_clear_system_state();
4143 vp9_set_quantizer(cm, q);
4144 vp9_set_variance_partition_thresholds(cpi, q, 0);
4145 suppress_active_map(cpi);
4146 // Turn-off cyclic refresh for re-encoded frame.
4147 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
4148 CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
4149 unsigned char *const seg_map = cpi->segmentation_map;
4150 memset(seg_map, 0, cm->mi_rows * cm->mi_cols);
4151 memset(cr->last_coded_q_map, MAXQ,
4152 cm->mi_rows * cm->mi_cols * sizeof(*cr->last_coded_q_map));
4154 vp9_disable_segmentation(&cm->seg);
4156 apply_active_map(cpi);
4157 vp9_encode_frame(cpi);
4161 // Update some stats from cyclic refresh, and check for golden frame update.
4162 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && cm->seg.enabled &&
4163 !frame_is_intra_only(cm))
4164 vp9_cyclic_refresh_postencode(cpi);
4166 // Update the skip mb flag probabilities based on the distribution
4167 // seen in the last encoder iteration.
4168 // update_base_skip_probs(cpi);
4169 vpx_clear_system_state();
4173 #if !CONFIG_REALTIME_ONLY
4174 #define MAX_QSTEP_ADJ 4
4175 static int get_qstep_adj(int rate_excess, int rate_limit) {
4177 rate_limit ? ((rate_excess + rate_limit / 2) / rate_limit) : INT_MAX;
4178 return VPXMIN(qstep, MAX_QSTEP_ADJ);
4181 static void encode_with_recode_loop(VP9_COMP *cpi, size_t *size,
4183 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
4184 VP9_COMMON *const cm = &cpi->common;
4185 RATE_CONTROL *const rc = &cpi->rc;
4186 int bottom_index, top_index;
4188 int loop_at_this_size = 0;
4190 int overshoot_seen = 0;
4191 int undershoot_seen = 0;
4192 int frame_over_shoot_limit;
4193 int frame_under_shoot_limit;
4194 int q = 0, q_low = 0, q_high = 0;
4196 #ifdef AGGRESSIVE_VBR
4200 if (cm->show_existing_frame) {
4201 rc->this_frame_target = 0;
4202 if (is_psnr_calc_enabled(cpi)) set_raw_source_frame(cpi);
4206 set_size_independent_vars(cpi);
4208 enable_acl = cpi->sf.allow_acl ? (cm->frame_type == KEY_FRAME) ||
4209 (cpi->twopass.gf_group.index == 1)
4213 vpx_clear_system_state();
4215 set_frame_size(cpi);
4217 if (loop_count == 0 || cpi->resize_pending != 0) {
4218 set_size_dependent_vars(cpi, &q, &bottom_index, &top_index);
4220 #ifdef AGGRESSIVE_VBR
4221 if (two_pass_first_group_inter(cpi)) {
4222 // Adjustment limits for min and max q
4223 qrange_adj = VPXMAX(1, (top_index - bottom_index) / 2);
4226 VPXMAX(bottom_index - qrange_adj / 2, oxcf->best_allowed_q);
4227 top_index = VPXMIN(oxcf->worst_allowed_q, top_index + qrange_adj / 2);
4230 // TODO(agrange) Scale cpi->max_mv_magnitude if frame-size has changed.
4231 set_mv_search_params(cpi);
4233 // Reset the loop state for new frame size.
4235 undershoot_seen = 0;
4237 // Reconfiguration for change in frame size has concluded.
4238 cpi->resize_pending = 0;
4240 q_low = bottom_index;
4243 loop_at_this_size = 0;
4246 // Decide frame size bounds first time through.
4247 if (loop_count == 0) {
4248 vp9_rc_compute_frame_size_bounds(cpi, rc->this_frame_target,
4249 &frame_under_shoot_limit,
4250 &frame_over_shoot_limit);
4254 vp9_scale_if_required(cm, cpi->un_scaled_source, &cpi->scaled_source,
4255 (oxcf->pass == 0), EIGHTTAP, 0);
4257 // Unfiltered raw source used in metrics calculation if the source
4258 // has been filtered.
4259 if (is_psnr_calc_enabled(cpi)) {
4260 #ifdef ENABLE_KF_DENOISE
4261 if (is_spatial_denoise_enabled(cpi)) {
4262 cpi->raw_source_frame = vp9_scale_if_required(
4263 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source,
4264 (oxcf->pass == 0), EIGHTTAP, 0);
4266 cpi->raw_source_frame = cpi->Source;
4269 cpi->raw_source_frame = cpi->Source;
4273 if (cpi->unscaled_last_source != NULL)
4274 cpi->Last_Source = vp9_scale_if_required(cm, cpi->unscaled_last_source,
4275 &cpi->scaled_last_source,
4276 (oxcf->pass == 0), EIGHTTAP, 0);
4278 if (frame_is_intra_only(cm) == 0) {
4279 if (loop_count > 0) {
4280 release_scaled_references(cpi);
4282 vp9_scale_references(cpi);
4285 vp9_set_quantizer(cm, q);
4287 if (loop_count == 0) setup_frame(cpi);
4289 // Variance adaptive and in frame q adjustment experiments are mutually
4291 if (oxcf->aq_mode == VARIANCE_AQ) {
4292 vp9_vaq_frame_setup(cpi);
4293 } else if (oxcf->aq_mode == EQUATOR360_AQ) {
4294 vp9_360aq_frame_setup(cpi);
4295 } else if (oxcf->aq_mode == COMPLEXITY_AQ) {
4296 vp9_setup_in_frame_q_adj(cpi);
4297 } else if (oxcf->aq_mode == LOOKAHEAD_AQ) {
4298 vp9_alt_ref_aq_setup_map(cpi->alt_ref_aq, cpi);
4299 } else if (oxcf->aq_mode == PSNR_AQ) {
4300 vp9_psnr_aq_mode_setup(&cm->seg);
4303 vp9_encode_frame(cpi);
4305 // Update the skip mb flag probabilities based on the distribution
4306 // seen in the last encoder iteration.
4307 // update_base_skip_probs(cpi);
4309 vpx_clear_system_state();
4311 // Dummy pack of the bitstream using up to date stats to get an
4312 // accurate estimate of output frame size to determine if we need
4314 if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF) {
4315 save_coding_context(cpi);
4316 if (!cpi->sf.use_nonrd_pick_mode) vp9_pack_bitstream(cpi, dest, size);
4318 rc->projected_frame_size = (int)(*size) << 3;
4320 if (frame_over_shoot_limit == 0) frame_over_shoot_limit = 1;
4323 if (oxcf->rc_mode == VPX_Q) {
4326 if ((cm->frame_type == KEY_FRAME) && rc->this_key_frame_forced &&
4327 (rc->projected_frame_size < rc->max_frame_bandwidth)) {
4331 int64_t high_err_target = cpi->ambient_err;
4332 int64_t low_err_target = cpi->ambient_err >> 1;
4334 #if CONFIG_VP9_HIGHBITDEPTH
4335 if (cm->use_highbitdepth) {
4336 kf_err = vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4338 kf_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4341 kf_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
4342 #endif // CONFIG_VP9_HIGHBITDEPTH
4344 // Prevent possible divide by zero error below for perfect KF
4347 // The key frame is not good enough or we can afford
4348 // to make it better without undue risk of popping.
4349 if ((kf_err > high_err_target &&
4350 rc->projected_frame_size <= frame_over_shoot_limit) ||
4351 (kf_err > low_err_target &&
4352 rc->projected_frame_size <= frame_under_shoot_limit)) {
4354 q_high = q > q_low ? q - 1 : q_low;
4357 q = (int)((q * high_err_target) / kf_err);
4358 q = VPXMIN(q, (q_high + q_low) >> 1);
4359 } else if (kf_err < low_err_target &&
4360 rc->projected_frame_size >= frame_under_shoot_limit) {
4361 // The key frame is much better than the previous frame
4363 q_low = q < q_high ? q + 1 : q_high;
4366 q = (int)((q * low_err_target) / kf_err);
4367 q = VPXMIN(q, (q_high + q_low + 1) >> 1);
4370 // Clamp Q to upper and lower limits:
4371 q = clamp(q, q_low, q_high);
4374 } else if (recode_loop_test(cpi, frame_over_shoot_limit,
4375 frame_under_shoot_limit, q,
4376 VPXMAX(q_high, top_index), bottom_index)) {
4377 // Is the projected frame size out of range and are we allowed
4378 // to attempt to recode.
4383 if (cpi->resize_pending == 1) {
4384 // Change in frame size so go back around the recode loop.
4385 cpi->rc.frame_size_selector =
4386 SCALE_STEP1 - cpi->rc.frame_size_selector;
4387 cpi->rc.next_frame_size_selector = cpi->rc.frame_size_selector;
4389 #if CONFIG_INTERNAL_STATS
4390 ++cpi->tot_recode_hits;
4397 // Frame size out of permitted range:
4398 // Update correction factor & compute new Q to try...
4400 // Frame is too large
4401 if (rc->projected_frame_size > rc->this_frame_target) {
4402 // Special case if the projected size is > the max allowed.
4403 if ((q == q_high) &&
4404 ((rc->projected_frame_size >= rc->max_frame_bandwidth) ||
4405 (!rc->is_src_frame_alt_ref &&
4406 (rc->projected_frame_size >=
4407 big_rate_miss_high_threshold(cpi))))) {
4408 int max_rate = VPXMAX(1, VPXMIN(rc->max_frame_bandwidth,
4409 big_rate_miss_high_threshold(cpi)));
4411 q_val_high = vp9_convert_qindex_to_q(q_high, cm->bit_depth);
4413 q_val_high * ((double)rc->projected_frame_size / max_rate);
4414 q_high = vp9_convert_q_to_qindex(q_val_high, cm->bit_depth);
4415 q_high = clamp(q_high, rc->best_quality, rc->worst_quality);
4418 // Raise Qlow as to at least the current value
4420 get_qstep_adj(rc->projected_frame_size, rc->this_frame_target);
4421 q_low = VPXMIN(q + qstep, q_high);
4423 if (undershoot_seen || loop_at_this_size > 1) {
4424 // Update rate_correction_factor unless
4425 vp9_rc_update_rate_correction_factors(cpi);
4427 q = (q_high + q_low + 1) / 2;
4429 // Update rate_correction_factor unless
4430 vp9_rc_update_rate_correction_factors(cpi);
4432 q = vp9_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4433 VPXMAX(q_high, top_index));
4435 while (q < q_low && retries < 10) {
4436 vp9_rc_update_rate_correction_factors(cpi);
4437 q = vp9_rc_regulate_q(cpi, rc->this_frame_target, bottom_index,
4438 VPXMAX(q_high, top_index));
4445 // Frame is too small
4447 get_qstep_adj(rc->this_frame_target, rc->projected_frame_size);
4448 q_high = VPXMAX(q - qstep, q_low);
4450 if (overshoot_seen || loop_at_this_size > 1) {
4451 vp9_rc_update_rate_correction_factors(cpi);
4452 q = (q_high + q_low) / 2;
4454 vp9_rc_update_rate_correction_factors(cpi);
4455 q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
4456 VPXMIN(q_low, bottom_index), top_index);
4457 // Special case reset for qlow for constrained quality.
4458 // This should only trigger where there is very substantial
4459 // undershoot on a frame and the auto cq level is above
4460 // the user passsed in value.
4461 if (oxcf->rc_mode == VPX_CQ && q < q_low) {
4465 while (q > q_high && retries < 10) {
4466 vp9_rc_update_rate_correction_factors(cpi);
4467 q = vp9_rc_regulate_q(cpi, rc->this_frame_target,
4468 VPXMIN(q_low, bottom_index), top_index);
4472 undershoot_seen = 1;
4475 // Clamp Q to upper and lower limits:
4476 q = clamp(q, q_low, q_high);
4478 loop = (q != last_q);
4484 // Special case for overlay frame.
4485 if (rc->is_src_frame_alt_ref &&
4486 rc->projected_frame_size < rc->max_frame_bandwidth)
4491 ++loop_at_this_size;
4493 #if CONFIG_INTERNAL_STATS
4494 ++cpi->tot_recode_hits;
4498 if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF)
4499 if (loop || !enable_acl) restore_coding_context(cpi);
4502 #ifdef AGGRESSIVE_VBR
4503 if (two_pass_first_group_inter(cpi)) {
4504 cpi->twopass.active_worst_quality =
4505 VPXMIN(q + qrange_adj, oxcf->worst_allowed_q);
4506 } else if (!frame_is_kf_gf_arf(cpi)) {
4508 if (!frame_is_kf_gf_arf(cpi)) {
4510 // Have we been forced to adapt Q outside the expected range by an extreme
4511 // rate miss. If so adjust the active maxQ for the subsequent frames.
4512 if (!rc->is_src_frame_alt_ref && (q > cpi->twopass.active_worst_quality)) {
4513 cpi->twopass.active_worst_quality = q;
4514 } else if (oxcf->vbr_corpus_complexity && q == q_low &&
4515 rc->projected_frame_size < rc->this_frame_target) {
4516 cpi->twopass.active_worst_quality =
4517 VPXMAX(q, cpi->twopass.active_worst_quality - 1);
4522 // Skip recoding, if model diff is below threshold
4523 const int thresh = compute_context_model_thresh(cpi);
4524 const int diff = compute_context_model_diff(cm);
4525 if (diff < thresh) {
4526 vpx_clear_system_state();
4527 restore_coding_context(cpi);
4531 vp9_encode_frame(cpi);
4532 vpx_clear_system_state();
4533 restore_coding_context(cpi);
4536 #endif // !CONFIG_REALTIME_ONLY
4538 static int get_ref_frame_flags(const VP9_COMP *cpi) {
4539 const int *const map = cpi->common.ref_frame_map;
4540 const int gold_is_last = map[cpi->gld_fb_idx] == map[cpi->lst_fb_idx];
4541 const int alt_is_last = map[cpi->alt_fb_idx] == map[cpi->lst_fb_idx];
4542 const int gold_is_alt = map[cpi->gld_fb_idx] == map[cpi->alt_fb_idx];
4543 int flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;
4545 if (gold_is_last) flags &= ~VP9_GOLD_FLAG;
4547 if (cpi->rc.frames_till_gf_update_due == INT_MAX &&
4548 (cpi->svc.number_temporal_layers == 1 &&
4549 cpi->svc.number_spatial_layers == 1))
4550 flags &= ~VP9_GOLD_FLAG;
4552 if (alt_is_last) flags &= ~VP9_ALT_FLAG;
4554 if (gold_is_alt) flags &= ~VP9_ALT_FLAG;
4559 static void set_ext_overrides(VP9_COMP *cpi) {
4560 // Overrides the defaults with the externally supplied values with
4561 // vp9_update_reference() and vp9_update_entropy() calls
4562 // Note: The overrides are valid only for the next frame passed
4563 // to encode_frame_to_data_rate() function
4564 if (cpi->ext_refresh_frame_context_pending) {
4565 cpi->common.refresh_frame_context = cpi->ext_refresh_frame_context;
4566 cpi->ext_refresh_frame_context_pending = 0;
4568 if (cpi->ext_refresh_frame_flags_pending) {
4569 cpi->refresh_last_frame = cpi->ext_refresh_last_frame;
4570 cpi->refresh_golden_frame = cpi->ext_refresh_golden_frame;
4571 cpi->refresh_alt_ref_frame = cpi->ext_refresh_alt_ref_frame;
4575 YV12_BUFFER_CONFIG *vp9_svc_twostage_scale(
4576 VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled,
4577 YV12_BUFFER_CONFIG *scaled_temp, INTERP_FILTER filter_type,
4578 int phase_scaler, INTERP_FILTER filter_type2, int phase_scaler2) {
4579 if (cm->mi_cols * MI_SIZE != unscaled->y_width ||
4580 cm->mi_rows * MI_SIZE != unscaled->y_height) {
4581 #if CONFIG_VP9_HIGHBITDEPTH
4582 if (cm->bit_depth == VPX_BITS_8) {
4583 vp9_scale_and_extend_frame(unscaled, scaled_temp, filter_type2,
4585 vp9_scale_and_extend_frame(scaled_temp, scaled, filter_type,
4588 scale_and_extend_frame(unscaled, scaled_temp, (int)cm->bit_depth,
4589 filter_type2, phase_scaler2);
4590 scale_and_extend_frame(scaled_temp, scaled, (int)cm->bit_depth,
4591 filter_type, phase_scaler);
4594 vp9_scale_and_extend_frame(unscaled, scaled_temp, filter_type2,
4596 vp9_scale_and_extend_frame(scaled_temp, scaled, filter_type, phase_scaler);
4597 #endif // CONFIG_VP9_HIGHBITDEPTH
4604 YV12_BUFFER_CONFIG *vp9_scale_if_required(
4605 VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled,
4606 int use_normative_scaler, INTERP_FILTER filter_type, int phase_scaler) {
4607 if (cm->mi_cols * MI_SIZE != unscaled->y_width ||
4608 cm->mi_rows * MI_SIZE != unscaled->y_height) {
4609 #if CONFIG_VP9_HIGHBITDEPTH
4610 if (use_normative_scaler && unscaled->y_width <= (scaled->y_width << 1) &&
4611 unscaled->y_height <= (scaled->y_height << 1))
4612 if (cm->bit_depth == VPX_BITS_8)
4613 vp9_scale_and_extend_frame(unscaled, scaled, filter_type, phase_scaler);
4615 scale_and_extend_frame(unscaled, scaled, (int)cm->bit_depth,
4616 filter_type, phase_scaler);
4618 scale_and_extend_frame_nonnormative(unscaled, scaled, (int)cm->bit_depth);
4620 if (use_normative_scaler && unscaled->y_width <= (scaled->y_width << 1) &&
4621 unscaled->y_height <= (scaled->y_height << 1))
4622 vp9_scale_and_extend_frame(unscaled, scaled, filter_type, phase_scaler);
4624 scale_and_extend_frame_nonnormative(unscaled, scaled);
4625 #endif // CONFIG_VP9_HIGHBITDEPTH
4632 static void set_ref_sign_bias(VP9_COMP *cpi) {
4633 VP9_COMMON *const cm = &cpi->common;
4634 RefCntBuffer *const ref_buffer = get_ref_cnt_buffer(cm, cm->new_fb_idx);
4635 const int cur_frame_index = ref_buffer->frame_index;
4636 MV_REFERENCE_FRAME ref_frame;
4638 for (ref_frame = LAST_FRAME; ref_frame < MAX_REF_FRAMES; ++ref_frame) {
4639 const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
4640 const RefCntBuffer *const ref_cnt_buf =
4641 get_ref_cnt_buffer(&cpi->common, buf_idx);
4643 cm->ref_frame_sign_bias[ref_frame] =
4644 cur_frame_index < ref_cnt_buf->frame_index;
4649 static int setup_interp_filter_search_mask(VP9_COMP *cpi) {
4650 INTERP_FILTER ifilter;
4651 int ref_total[MAX_REF_FRAMES] = { 0 };
4652 MV_REFERENCE_FRAME ref;
4654 if (cpi->common.last_frame_type == KEY_FRAME || cpi->refresh_alt_ref_frame)
4656 for (ref = LAST_FRAME; ref <= ALTREF_FRAME; ++ref)
4657 for (ifilter = EIGHTTAP; ifilter <= EIGHTTAP_SHARP; ++ifilter)
4658 ref_total[ref] += cpi->interp_filter_selected[ref][ifilter];
4660 for (ifilter = EIGHTTAP; ifilter <= EIGHTTAP_SHARP; ++ifilter) {
4661 if ((ref_total[LAST_FRAME] &&
4662 cpi->interp_filter_selected[LAST_FRAME][ifilter] == 0) &&
4663 (ref_total[GOLDEN_FRAME] == 0 ||
4664 cpi->interp_filter_selected[GOLDEN_FRAME][ifilter] * 50 <
4665 ref_total[GOLDEN_FRAME]) &&
4666 (ref_total[ALTREF_FRAME] == 0 ||
4667 cpi->interp_filter_selected[ALTREF_FRAME][ifilter] * 50 <
4668 ref_total[ALTREF_FRAME]))
4669 mask |= 1 << ifilter;
4674 #ifdef ENABLE_KF_DENOISE
4675 // Baseline Kernal weights for denoise
4676 static uint8_t dn_kernal_3[9] = { 1, 2, 1, 2, 4, 2, 1, 2, 1 };
4677 static uint8_t dn_kernal_5[25] = { 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 4,
4678 2, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1 };
4680 static INLINE void add_denoise_point(int centre_val, int data_val, int thresh,
4681 uint8_t point_weight, int *sum_val,
4683 if (abs(centre_val - data_val) <= thresh) {
4684 *sum_weight += point_weight;
4685 *sum_val += (int)data_val * (int)point_weight;
4689 static void spatial_denoise_point(uint8_t *src_ptr, const int stride,
4690 const int strength) {
4693 int thresh = strength;
4694 int kernal_size = 5;
4695 int half_k_size = 2;
4699 uint8_t *kernal_ptr;
4701 // Find the maximum deviation from the source point in the locale.
4702 tmp_ptr = src_ptr - (stride * (half_k_size + 1)) - (half_k_size + 1);
4703 for (i = 0; i < kernal_size + 2; ++i) {
4704 for (j = 0; j < kernal_size + 2; ++j) {
4705 max_diff = VPXMAX(max_diff, abs((int)*src_ptr - (int)tmp_ptr[j]));
4710 // Select the kernal size.
4711 if (max_diff > (strength + (strength >> 1))) {
4714 thresh = thresh >> 1;
4716 kernal_ptr = (kernal_size == 3) ? dn_kernal_3 : dn_kernal_5;
4719 tmp_ptr = src_ptr - (stride * half_k_size) - half_k_size;
4720 for (i = 0; i < kernal_size; ++i) {
4721 for (j = 0; j < kernal_size; ++j) {
4722 add_denoise_point((int)*src_ptr, (int)tmp_ptr[j], thresh, *kernal_ptr,
4723 &sum_val, &sum_weight);
4729 // Update the source value with the new filtered value
4730 *src_ptr = (uint8_t)((sum_val + (sum_weight >> 1)) / sum_weight);
4733 #if CONFIG_VP9_HIGHBITDEPTH
4734 static void highbd_spatial_denoise_point(uint16_t *src_ptr, const int stride,
4735 const int strength) {
4738 int thresh = strength;
4739 int kernal_size = 5;
4740 int half_k_size = 2;
4744 uint8_t *kernal_ptr;
4746 // Find the maximum deviation from the source point in the locale.
4747 tmp_ptr = src_ptr - (stride * (half_k_size + 1)) - (half_k_size + 1);
4748 for (i = 0; i < kernal_size + 2; ++i) {
4749 for (j = 0; j < kernal_size + 2; ++j) {
4750 max_diff = VPXMAX(max_diff, abs((int)src_ptr - (int)tmp_ptr[j]));
4755 // Select the kernal size.
4756 if (max_diff > (strength + (strength >> 1))) {
4759 thresh = thresh >> 1;
4761 kernal_ptr = (kernal_size == 3) ? dn_kernal_3 : dn_kernal_5;
4764 tmp_ptr = src_ptr - (stride * half_k_size) - half_k_size;
4765 for (i = 0; i < kernal_size; ++i) {
4766 for (j = 0; j < kernal_size; ++j) {
4767 add_denoise_point((int)*src_ptr, (int)tmp_ptr[j], thresh, *kernal_ptr,
4768 &sum_val, &sum_weight);
4774 // Update the source value with the new filtered value
4775 *src_ptr = (uint16_t)((sum_val + (sum_weight >> 1)) / sum_weight);
4777 #endif // CONFIG_VP9_HIGHBITDEPTH
4779 // Apply thresholded spatial noise supression to a given buffer.
4780 static void spatial_denoise_buffer(VP9_COMP *cpi, uint8_t *buffer,
4781 const int stride, const int width,
4782 const int height, const int strength) {
4783 VP9_COMMON *const cm = &cpi->common;
4784 uint8_t *src_ptr = buffer;
4788 for (row = 0; row < height; ++row) {
4789 for (col = 0; col < width; ++col) {
4790 #if CONFIG_VP9_HIGHBITDEPTH
4791 if (cm->use_highbitdepth)
4792 highbd_spatial_denoise_point(CONVERT_TO_SHORTPTR(&src_ptr[col]), stride,
4795 spatial_denoise_point(&src_ptr[col], stride, strength);
4797 spatial_denoise_point(&src_ptr[col], stride, strength);
4798 #endif // CONFIG_VP9_HIGHBITDEPTH
4804 // Apply thresholded spatial noise supression to source.
4805 static void spatial_denoise_frame(VP9_COMP *cpi) {
4806 YV12_BUFFER_CONFIG *src = cpi->Source;
4807 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
4808 TWO_PASS *const twopass = &cpi->twopass;
4809 VP9_COMMON *const cm = &cpi->common;
4811 // Base the filter strength on the current active max Q.
4812 const int q = (int)(vp9_convert_qindex_to_q(twopass->active_worst_quality,
4815 VPXMAX(oxcf->arnr_strength >> 2, VPXMIN(oxcf->arnr_strength, (q >> 4)));
4817 // Denoise each of Y,U and V buffers.
4818 spatial_denoise_buffer(cpi, src->y_buffer, src->y_stride, src->y_width,
4819 src->y_height, strength);
4821 strength += (strength >> 1);
4822 spatial_denoise_buffer(cpi, src->u_buffer, src->uv_stride, src->uv_width,
4823 src->uv_height, strength << 1);
4825 spatial_denoise_buffer(cpi, src->v_buffer, src->uv_stride, src->uv_width,
4826 src->uv_height, strength << 1);
4828 #endif // ENABLE_KF_DENOISE
4830 #if !CONFIG_REALTIME_ONLY
4831 static void vp9_try_disable_lookahead_aq(VP9_COMP *cpi, size_t *size,
4833 if (cpi->common.seg.enabled)
4834 if (ALT_REF_AQ_PROTECT_GAIN) {
4835 size_t nsize = *size;
4838 // TODO(yuryg): optimize this, as
4839 // we don't really need to repack
4841 save_coding_context(cpi);
4842 vp9_disable_segmentation(&cpi->common.seg);
4843 vp9_pack_bitstream(cpi, dest, &nsize);
4844 restore_coding_context(cpi);
4846 overhead = (int)*size - (int)nsize;
4848 if (vp9_alt_ref_aq_disable_if(cpi->alt_ref_aq, overhead, (int)*size))
4849 vp9_encode_frame(cpi);
4851 vp9_enable_segmentation(&cpi->common.seg);
4856 static void set_frame_index(VP9_COMP *cpi, VP9_COMMON *cm) {
4857 RefCntBuffer *const ref_buffer = get_ref_cnt_buffer(cm, cm->new_fb_idx);
4860 const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
4861 ref_buffer->frame_index =
4862 cm->current_video_frame + gf_group->arf_src_offset[gf_group->index];
4866 // Implementation and modifications of C. Yeo, H. L. Tan, and Y. H. Tan, "On
4867 // rate distortion optimization using SSIM," Circuits and Systems for Video
4868 // Technology, IEEE Transactions on, vol. 23, no. 7, pp. 1170-1181, 2013.
4869 // SSIM_VAR_SCALE defines the strength of the bias towards SSIM in RDO.
4870 // Some sample values are:
4871 // (for midres test set)
4872 // SSIM_VAR_SCALE avg_psnr ssim ms_ssim
4873 // 8.0 9.421 -5.537 -6.898
4874 // 16.0 4.703 -5.378 -6.238
4875 // 32.0 1.929 -4.308 -4.807
4876 #define SSIM_VAR_SCALE 16.0
4877 static void set_mb_ssim_rdmult_scaling(VP9_COMP *cpi) {
4878 VP9_COMMON *cm = &cpi->common;
4879 ThreadData *td = &cpi->td;
4880 MACROBLOCK *x = &td->mb;
4881 MACROBLOCKD *xd = &x->e_mbd;
4882 uint8_t *y_buffer = cpi->Source->y_buffer;
4883 const int y_stride = cpi->Source->y_stride;
4884 const int block_size = BLOCK_16X16;
4886 const int num_8x8_w = num_8x8_blocks_wide_lookup[block_size];
4887 const int num_8x8_h = num_8x8_blocks_high_lookup[block_size];
4888 const int num_cols = (cm->mi_cols + num_8x8_w - 1) / num_8x8_w;
4889 const int num_rows = (cm->mi_rows + num_8x8_h - 1) / num_8x8_h;
4890 double log_sum = 0.0;
4893 const double c2 = 58.5225 * SSIM_VAR_SCALE; // 58.5225 = (.03*255)^2
4895 // Loop through each 64x64 block.
4896 for (row = 0; row < num_rows; ++row) {
4897 for (col = 0; col < num_cols; ++col) {
4899 double var = 0.0, num_of_var = 0.0;
4900 const int index = row * num_cols + col;
4902 for (mi_row = row * num_8x8_h;
4903 mi_row < cm->mi_rows && mi_row < (row + 1) * num_8x8_h; ++mi_row) {
4904 for (mi_col = col * num_8x8_w;
4905 mi_col < cm->mi_cols && mi_col < (col + 1) * num_8x8_w; ++mi_col) {
4907 const int row_offset_y = mi_row << 3;
4908 const int col_offset_y = mi_col << 3;
4910 buf.buf = y_buffer + row_offset_y * y_stride + col_offset_y;
4911 buf.stride = y_stride;
4913 // In order to make SSIM_VAR_SCALE in a same scale for both 8 bit
4914 // and high bit videos, the variance needs to be divided by 2.0 or
4916 // TODO(sdeng): need to tune for 12bit videos.
4917 #if CONFIG_VP9_HIGHBITDEPTH
4918 if (cpi->Source->flags & YV12_FLAG_HIGHBITDEPTH)
4919 var += vp9_high_get_sby_variance(cpi, &buf, BLOCK_8X8, xd->bd);
4922 var += vp9_get_sby_variance(cpi, &buf, BLOCK_8X8);
4927 var = var / num_of_var / 64.0;
4928 var = 2.0 * var + c2;
4929 cpi->mi_ssim_rdmult_scaling_factors[index] = var;
4930 log_sum += log(var);
4933 log_sum = exp(log_sum / (double)(num_rows * num_cols));
4935 for (row = 0; row < num_rows; ++row) {
4936 for (col = 0; col < num_cols; ++col) {
4937 const int index = row * num_cols + col;
4938 cpi->mi_ssim_rdmult_scaling_factors[index] /= log_sum;
4945 // Process the wiener variance in 16x16 block basis.
4946 static int qsort_comp(const void *elem1, const void *elem2) {
4947 int a = *((const int *)elem1);
4948 int b = *((const int *)elem2);
4949 if (a > b) return 1;
4950 if (a < b) return -1;
4954 static void init_mb_wiener_var_buffer(VP9_COMP *cpi) {
4955 VP9_COMMON *cm = &cpi->common;
4957 if (cpi->mb_wiener_variance && cpi->mb_wiener_var_rows >= cm->mb_rows &&
4958 cpi->mb_wiener_var_cols >= cm->mb_cols)
4961 vpx_free(cpi->mb_wiener_variance);
4962 cpi->mb_wiener_variance = NULL;
4965 cm, cpi->mb_wiener_variance,
4966 vpx_calloc(cm->mb_rows * cm->mb_cols, sizeof(*cpi->mb_wiener_variance)));
4967 cpi->mb_wiener_var_rows = cm->mb_rows;
4968 cpi->mb_wiener_var_cols = cm->mb_cols;
4971 static void set_mb_wiener_variance(VP9_COMP *cpi) {
4972 VP9_COMMON *cm = &cpi->common;
4973 uint8_t *buffer = cpi->Source->y_buffer;
4974 int buf_stride = cpi->Source->y_stride;
4976 #if CONFIG_VP9_HIGHBITDEPTH
4977 ThreadData *td = &cpi->td;
4978 MACROBLOCK *x = &td->mb;
4979 MACROBLOCKD *xd = &x->e_mbd;
4980 DECLARE_ALIGNED(16, uint16_t, zero_pred16[32 * 32]);
4981 DECLARE_ALIGNED(16, uint8_t, zero_pred8[32 * 32]);
4984 DECLARE_ALIGNED(16, uint8_t, zero_pred[32 * 32]);
4987 DECLARE_ALIGNED(16, int16_t, src_diff[32 * 32]);
4988 DECLARE_ALIGNED(16, tran_low_t, coeff[32 * 32]);
4990 int mb_row, mb_col, count = 0;
4991 // Hard coded operating block size
4992 const int block_size = 16;
4993 const int coeff_count = block_size * block_size;
4994 const TX_SIZE tx_size = TX_16X16;
4996 #if CONFIG_VP9_HIGHBITDEPTH
4997 xd->cur_buf = cpi->Source;
4998 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
4999 zero_pred = CONVERT_TO_BYTEPTR(zero_pred16);
5000 memset(zero_pred16, 0, sizeof(*zero_pred16) * coeff_count);
5002 zero_pred = zero_pred8;
5003 memset(zero_pred8, 0, sizeof(*zero_pred8) * coeff_count);
5006 memset(zero_pred, 0, sizeof(*zero_pred) * coeff_count);
5009 cpi->norm_wiener_variance = 0;
5011 for (mb_row = 0; mb_row < cm->mb_rows; ++mb_row) {
5012 for (mb_col = 0; mb_col < cm->mb_cols; ++mb_col) {
5014 int16_t median_val = 0;
5015 uint8_t *mb_buffer =
5016 buffer + mb_row * block_size * buf_stride + mb_col * block_size;
5017 int64_t wiener_variance = 0;
5019 #if CONFIG_VP9_HIGHBITDEPTH
5020 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
5021 vpx_highbd_subtract_block(block_size, block_size, src_diff, block_size,
5022 mb_buffer, buf_stride, zero_pred, block_size,
5024 highbd_wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
5026 vpx_subtract_block(block_size, block_size, src_diff, block_size,
5027 mb_buffer, buf_stride, zero_pred, block_size);
5028 wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
5031 vpx_subtract_block(block_size, block_size, src_diff, block_size,
5032 mb_buffer, buf_stride, zero_pred, block_size);
5033 wht_fwd_txfm(src_diff, block_size, coeff, tx_size);
5034 #endif // CONFIG_VP9_HIGHBITDEPTH
5037 for (idx = 1; idx < coeff_count; ++idx) coeff[idx] = abs(coeff[idx]);
5039 qsort(coeff, coeff_count - 1, sizeof(*coeff), qsort_comp);
5041 // Noise level estimation
5042 median_val = coeff[coeff_count / 2];
5045 for (idx = 1; idx < coeff_count; ++idx) {
5046 int64_t sqr_coeff = (int64_t)coeff[idx] * coeff[idx];
5047 int64_t tmp_coeff = (int64_t)coeff[idx];
5049 tmp_coeff = (sqr_coeff * coeff[idx]) /
5050 (sqr_coeff + (int64_t)median_val * median_val);
5052 wiener_variance += tmp_coeff * tmp_coeff;
5054 cpi->mb_wiener_variance[mb_row * cm->mb_cols + mb_col] =
5055 wiener_variance / coeff_count;
5056 cpi->norm_wiener_variance +=
5057 cpi->mb_wiener_variance[mb_row * cm->mb_cols + mb_col];
5062 if (count) cpi->norm_wiener_variance /= count;
5063 cpi->norm_wiener_variance = VPXMAX(1, cpi->norm_wiener_variance);
5066 static void encode_frame_to_data_rate(VP9_COMP *cpi, size_t *size,
5068 unsigned int *frame_flags) {
5069 VP9_COMMON *const cm = &cpi->common;
5070 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
5071 struct segmentation *const seg = &cm->seg;
5074 // SVC: skip encoding of enhancement layer if the layer target bandwidth = 0.
5075 // No need to set svc.skip_enhancement_layer if whole superframe will be
5077 if (cpi->use_svc && cpi->svc.spatial_layer_id > 0 &&
5078 cpi->oxcf.target_bandwidth == 0 &&
5079 !(cpi->svc.framedrop_mode != LAYER_DROP &&
5080 (cpi->svc.framedrop_mode != CONSTRAINED_FROM_ABOVE_DROP ||
5082 .force_drop_constrained_from_above[cpi->svc.number_spatial_layers -
5084 cpi->svc.drop_spatial_layer[0])) {
5085 cpi->svc.skip_enhancement_layer = 1;
5086 vp9_rc_postencode_update_drop_frame(cpi);
5087 cpi->ext_refresh_frame_flags_pending = 0;
5088 cpi->last_frame_dropped = 1;
5089 cpi->svc.last_layer_dropped[cpi->svc.spatial_layer_id] = 1;
5090 cpi->svc.drop_spatial_layer[cpi->svc.spatial_layer_id] = 1;
5091 vp9_inc_frame_in_layer(cpi);
5095 set_ext_overrides(cpi);
5096 vpx_clear_system_state();
5098 #ifdef ENABLE_KF_DENOISE
5099 // Spatial denoise of key frame.
5100 if (is_spatial_denoise_enabled(cpi)) spatial_denoise_frame(cpi);
5103 if (cm->show_existing_frame == 0) {
5104 // Update frame index
5105 set_frame_index(cpi, cm);
5107 // Set the arf sign bias for this frame.
5108 set_ref_sign_bias(cpi);
5111 // Set default state for segment based loop filter update flags.
5112 cm->lf.mode_ref_delta_update = 0;
5114 if (cpi->oxcf.pass == 2 && cpi->sf.adaptive_interp_filter_search)
5115 cpi->sf.interp_filter_search_mask = setup_interp_filter_search_mask(cpi);
5117 // Set various flags etc to special state if it is a key frame.
5118 if (frame_is_intra_only(cm)) {
5119 // Reset the loop filter deltas and segmentation map.
5120 vp9_reset_segment_features(&cm->seg);
5122 // If segmentation is enabled force a map update for key frames.
5124 seg->update_map = 1;
5125 seg->update_data = 1;
5128 // The alternate reference frame cannot be active for a key frame.
5129 cpi->rc.source_alt_ref_active = 0;
5131 cm->error_resilient_mode = oxcf->error_resilient_mode;
5132 cm->frame_parallel_decoding_mode = oxcf->frame_parallel_decoding_mode;
5134 // By default, encoder assumes decoder can use prev_mi.
5135 if (cm->error_resilient_mode) {
5136 cm->frame_parallel_decoding_mode = 1;
5137 cm->reset_frame_context = 0;
5138 cm->refresh_frame_context = 0;
5139 } else if (cm->intra_only) {
5140 // Only reset the current context.
5141 cm->reset_frame_context = 2;
5145 if (oxcf->tuning == VP8_TUNE_SSIM) set_mb_ssim_rdmult_scaling(cpi);
5147 if (oxcf->aq_mode == PERCEPTUAL_AQ) {
5148 init_mb_wiener_var_buffer(cpi);
5149 set_mb_wiener_variance(cpi);
5152 vpx_clear_system_state();
5154 #if CONFIG_INTERNAL_STATS
5155 memset(cpi->mode_chosen_counts, 0,
5156 MAX_MODES * sizeof(*cpi->mode_chosen_counts));
5158 #if CONFIG_CONSISTENT_RECODE
5159 // Backup to ensure consistency between recodes
5160 save_encode_params(cpi);
5163 if (cpi->sf.recode_loop == DISALLOW_RECODE) {
5164 if (!encode_without_recode_loop(cpi, size, dest)) return;
5166 #if !CONFIG_REALTIME_ONLY
5167 encode_with_recode_loop(cpi, size, dest);
5171 // TODO(jingning): When using show existing frame mode, we assume that the
5172 // current ARF will be directly used as the final reconstructed frame. This is
5173 // an encoder control scheme. One could in principle explore other
5174 // possibilities to arrange the reference frame buffer and their coding order.
5175 if (cm->show_existing_frame) {
5176 ref_cnt_fb(cm->buffer_pool->frame_bufs, &cm->new_fb_idx,
5177 cm->ref_frame_map[cpi->alt_fb_idx]);
5180 #if !CONFIG_REALTIME_ONLY
5181 // Disable segmentation if it decrease rate/distortion ratio
5182 if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ)
5183 vp9_try_disable_lookahead_aq(cpi, size, dest);
5186 #if CONFIG_VP9_TEMPORAL_DENOISING
5187 #ifdef OUTPUT_YUV_DENOISED
5188 if (oxcf->noise_sensitivity > 0 && denoise_svc(cpi)) {
5189 vpx_write_yuv_frame(yuv_denoised_file,
5190 &cpi->denoiser.running_avg_y[INTRA_FRAME]);
5194 #ifdef OUTPUT_YUV_SKINMAP
5195 if (cpi->common.current_video_frame > 1) {
5196 vp9_output_skin_map(cpi, yuv_skinmap_file);
5200 // Special case code to reduce pulsing when key frames are forced at a
5201 // fixed interval. Note the reconstruction error if it is the frame before
5202 // the force key frame
5203 if (cpi->rc.next_key_frame_forced && cpi->rc.frames_to_key == 1) {
5204 #if CONFIG_VP9_HIGHBITDEPTH
5205 if (cm->use_highbitdepth) {
5207 vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5209 cpi->ambient_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5212 cpi->ambient_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
5213 #endif // CONFIG_VP9_HIGHBITDEPTH
5216 // If the encoder forced a KEY_FRAME decision
5217 if (cm->frame_type == KEY_FRAME) cpi->refresh_last_frame = 1;
5219 cm->frame_to_show = get_frame_new_buffer(cm);
5220 cm->frame_to_show->color_space = cm->color_space;
5221 cm->frame_to_show->color_range = cm->color_range;
5222 cm->frame_to_show->render_width = cm->render_width;
5223 cm->frame_to_show->render_height = cm->render_height;
5225 // Pick the loop filter level for the frame.
5226 loopfilter_frame(cpi, cm);
5228 if (cpi->rc.use_post_encode_drop) save_coding_context(cpi);
5230 // build the bitstream
5231 vp9_pack_bitstream(cpi, dest, size);
5233 if (cpi->rc.use_post_encode_drop && cm->base_qindex < cpi->rc.worst_quality &&
5234 cpi->svc.spatial_layer_id == 0 && post_encode_drop_cbr(cpi, size)) {
5235 restore_coding_context(cpi);
5239 cpi->last_frame_dropped = 0;
5240 cpi->svc.last_layer_dropped[cpi->svc.spatial_layer_id] = 0;
5241 if (cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1)
5242 cpi->svc.num_encoded_top_layer++;
5244 // Keep track of the frame buffer index updated/refreshed for the
5245 // current encoded TL0 superframe.
5246 if (cpi->svc.temporal_layer_id == 0) {
5247 if (cpi->refresh_last_frame)
5248 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->lst_fb_idx;
5249 else if (cpi->refresh_golden_frame)
5250 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->gld_fb_idx;
5251 else if (cpi->refresh_alt_ref_frame)
5252 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->alt_fb_idx;
5255 if (cm->seg.update_map) update_reference_segmentation_map(cpi);
5257 if (frame_is_intra_only(cm) == 0) {
5258 release_scaled_references(cpi);
5260 vp9_update_reference_frames(cpi);
5262 if (!cm->show_existing_frame) {
5263 for (t = TX_4X4; t <= TX_32X32; ++t) {
5264 full_to_model_counts(cpi->td.counts->coef[t],
5265 cpi->td.rd_counts.coef_counts[t]);
5268 if (!cm->error_resilient_mode && !cm->frame_parallel_decoding_mode) {
5269 if (!frame_is_intra_only(cm)) {
5270 vp9_adapt_mode_probs(cm);
5271 vp9_adapt_mv_probs(cm, cm->allow_high_precision_mv);
5273 vp9_adapt_coef_probs(cm);
5277 cpi->ext_refresh_frame_flags_pending = 0;
5279 if (cpi->refresh_golden_frame == 1)
5280 cpi->frame_flags |= FRAMEFLAGS_GOLDEN;
5282 cpi->frame_flags &= ~FRAMEFLAGS_GOLDEN;
5284 if (cpi->refresh_alt_ref_frame == 1)
5285 cpi->frame_flags |= FRAMEFLAGS_ALTREF;
5287 cpi->frame_flags &= ~FRAMEFLAGS_ALTREF;
5289 cpi->ref_frame_flags = get_ref_frame_flags(cpi);
5291 cm->last_frame_type = cm->frame_type;
5293 vp9_rc_postencode_update(cpi, *size);
5295 *size = VPXMAX(1, *size);
5298 output_frame_level_debug_stats(cpi);
5301 if (cm->frame_type == KEY_FRAME) {
5302 // Tell the caller that the frame was coded as a key frame
5303 *frame_flags = cpi->frame_flags | FRAMEFLAGS_KEY;
5305 *frame_flags = cpi->frame_flags & ~FRAMEFLAGS_KEY;
5308 // Clear the one shot update flags for segmentation map and mode/ref loop
5310 cm->seg.update_map = 0;
5311 cm->seg.update_data = 0;
5312 cm->lf.mode_ref_delta_update = 0;
5314 // keep track of the last coded dimensions
5315 cm->last_width = cm->width;
5316 cm->last_height = cm->height;
5318 // reset to normal state now that we are done.
5319 if (!cm->show_existing_frame) {
5320 cm->last_show_frame = cm->show_frame;
5321 cm->prev_frame = cm->cur_frame;
5324 if (cm->show_frame) {
5325 vp9_swap_mi_and_prev_mi(cm);
5326 // Don't increment frame counters if this was an altref buffer
5327 // update not a real frame
5328 ++cm->current_video_frame;
5329 if (cpi->use_svc) vp9_inc_frame_in_layer(cpi);
5334 .layer_context[cpi->svc.spatial_layer_id *
5335 cpi->svc.number_temporal_layers +
5336 cpi->svc.temporal_layer_id]
5337 .last_frame_type = cm->frame_type;
5338 // Reset layer_sync back to 0 for next frame.
5339 cpi->svc.spatial_layer_sync[cpi->svc.spatial_layer_id] = 0;
5342 cpi->force_update_segmentation = 0;
5344 #if !CONFIG_REALTIME_ONLY
5345 if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ)
5346 vp9_alt_ref_aq_unset_all(cpi->alt_ref_aq, cpi);
5349 cpi->svc.previous_frame_is_intra_only = cm->intra_only;
5350 cpi->svc.set_intra_only_frame = 0;
5353 static void SvcEncode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5354 unsigned int *frame_flags) {
5355 vp9_rc_get_svc_params(cpi);
5356 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5359 static void Pass0Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5360 unsigned int *frame_flags) {
5361 if (cpi->oxcf.rc_mode == VPX_CBR) {
5362 vp9_rc_get_one_pass_cbr_params(cpi);
5364 vp9_rc_get_one_pass_vbr_params(cpi);
5366 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5369 #if !CONFIG_REALTIME_ONLY
5370 static void Pass2Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
5371 unsigned int *frame_flags) {
5372 cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED;
5373 #if CONFIG_MISMATCH_DEBUG
5374 mismatch_move_frame_idx_w();
5376 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5378 vp9_twopass_postencode_update(cpi);
5380 #endif // !CONFIG_REALTIME_ONLY
5382 int vp9_receive_raw_frame(VP9_COMP *cpi, vpx_enc_frame_flags_t frame_flags,
5383 YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
5385 VP9_COMMON *const cm = &cpi->common;
5386 struct vpx_usec_timer timer;
5388 const int subsampling_x = sd->subsampling_x;
5389 const int subsampling_y = sd->subsampling_y;
5390 #if CONFIG_VP9_HIGHBITDEPTH
5391 const int use_highbitdepth = (sd->flags & YV12_FLAG_HIGHBITDEPTH) != 0;
5393 const int use_highbitdepth = 0;
5396 update_initial_width(cpi, use_highbitdepth, subsampling_x, subsampling_y);
5397 #if CONFIG_VP9_TEMPORAL_DENOISING
5398 setup_denoiser_buffer(cpi);
5401 alloc_raw_frame_buffers(cpi);
5403 vpx_usec_timer_start(&timer);
5405 if (vp9_lookahead_push(cpi->lookahead, sd, time_stamp, end_time,
5406 use_highbitdepth, frame_flags))
5408 vpx_usec_timer_mark(&timer);
5409 cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
5411 if ((cm->profile == PROFILE_0 || cm->profile == PROFILE_2) &&
5412 (subsampling_x != 1 || subsampling_y != 1)) {
5413 vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM,
5414 "Non-4:2:0 color format requires profile 1 or 3");
5417 if ((cm->profile == PROFILE_1 || cm->profile == PROFILE_3) &&
5418 (subsampling_x == 1 && subsampling_y == 1)) {
5419 vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM,
5420 "4:2:0 color format requires profile 0 or 2");
5427 static int frame_is_reference(const VP9_COMP *cpi) {
5428 const VP9_COMMON *cm = &cpi->common;
5430 return cm->frame_type == KEY_FRAME || cpi->refresh_last_frame ||
5431 cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame ||
5432 cm->refresh_frame_context || cm->lf.mode_ref_delta_update ||
5433 cm->seg.update_map || cm->seg.update_data;
5436 static void adjust_frame_rate(VP9_COMP *cpi,
5437 const struct lookahead_entry *source) {
5438 int64_t this_duration;
5441 if (source->ts_start == cpi->first_time_stamp_ever) {
5442 this_duration = source->ts_end - source->ts_start;
5445 int64_t last_duration =
5446 cpi->last_end_time_stamp_seen - cpi->last_time_stamp_seen;
5448 this_duration = source->ts_end - cpi->last_end_time_stamp_seen;
5450 // do a step update if the duration changes by 10%
5452 step = (int)((this_duration - last_duration) * 10 / last_duration);
5455 if (this_duration) {
5457 vp9_new_framerate(cpi, 10000000.0 / this_duration);
5459 // Average this frame's rate into the last second's average
5460 // frame rate. If we haven't seen 1 second yet, then average
5461 // over the whole interval seen.
5462 const double interval = VPXMIN(
5463 (double)(source->ts_end - cpi->first_time_stamp_ever), 10000000.0);
5464 double avg_duration = 10000000.0 / cpi->framerate;
5465 avg_duration *= (interval - avg_duration + this_duration);
5466 avg_duration /= interval;
5468 vp9_new_framerate(cpi, 10000000.0 / avg_duration);
5471 cpi->last_time_stamp_seen = source->ts_start;
5472 cpi->last_end_time_stamp_seen = source->ts_end;
5475 // Returns 0 if this is not an alt ref else the offset of the source frame
5476 // used as the arf midpoint.
5477 static int get_arf_src_index(VP9_COMP *cpi) {
5478 RATE_CONTROL *const rc = &cpi->rc;
5479 int arf_src_index = 0;
5480 if (is_altref_enabled(cpi)) {
5481 if (cpi->oxcf.pass == 2) {
5482 const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
5483 if (gf_group->update_type[gf_group->index] == ARF_UPDATE) {
5484 arf_src_index = gf_group->arf_src_offset[gf_group->index];
5486 } else if (rc->source_alt_ref_pending) {
5487 arf_src_index = rc->frames_till_gf_update_due;
5490 return arf_src_index;
5493 static void check_src_altref(VP9_COMP *cpi,
5494 const struct lookahead_entry *source) {
5495 RATE_CONTROL *const rc = &cpi->rc;
5497 if (cpi->oxcf.pass == 2) {
5498 const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
5499 rc->is_src_frame_alt_ref =
5500 (gf_group->update_type[gf_group->index] == OVERLAY_UPDATE);
5502 rc->is_src_frame_alt_ref =
5503 cpi->alt_ref_source && (source == cpi->alt_ref_source);
5506 if (rc->is_src_frame_alt_ref) {
5507 // Current frame is an ARF overlay frame.
5508 cpi->alt_ref_source = NULL;
5510 // Don't refresh the last buffer for an ARF overlay frame. It will
5511 // become the GF so preserve last as an alternative prediction option.
5512 cpi->refresh_last_frame = 0;
5516 #if CONFIG_INTERNAL_STATS
5517 static void adjust_image_stat(double y, double u, double v, double all,
5522 s->stat[ALL] += all;
5523 s->worst = VPXMIN(s->worst, all);
5525 #endif // CONFIG_INTERNAL_STATS
5527 // Adjust the maximum allowable frame size for the target level.
5528 static void level_rc_framerate(VP9_COMP *cpi, int arf_src_index) {
5529 RATE_CONTROL *const rc = &cpi->rc;
5530 LevelConstraint *const ls = &cpi->level_constraint;
5531 VP9_COMMON *const cm = &cpi->common;
5532 const double max_cpb_size = ls->max_cpb_size;
5533 vpx_clear_system_state();
5534 rc->max_frame_bandwidth = VPXMIN(rc->max_frame_bandwidth, ls->max_frame_size);
5535 if (frame_is_intra_only(cm)) {
5536 rc->max_frame_bandwidth =
5537 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.5));
5538 } else if (arf_src_index > 0) {
5539 rc->max_frame_bandwidth =
5540 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.4));
5542 rc->max_frame_bandwidth =
5543 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.2));
5547 static void update_level_info(VP9_COMP *cpi, size_t *size, int arf_src_index) {
5548 VP9_COMMON *const cm = &cpi->common;
5549 Vp9LevelInfo *const level_info = &cpi->level_info;
5550 Vp9LevelSpec *const level_spec = &level_info->level_spec;
5551 Vp9LevelStats *const level_stats = &level_info->level_stats;
5553 uint64_t luma_samples, dur_end;
5554 const uint32_t luma_pic_size = cm->width * cm->height;
5555 const uint32_t luma_pic_breadth = VPXMAX(cm->width, cm->height);
5556 LevelConstraint *const level_constraint = &cpi->level_constraint;
5557 const int8_t level_index = level_constraint->level_index;
5558 double cpb_data_size;
5560 vpx_clear_system_state();
5562 // update level_stats
5563 level_stats->total_compressed_size += *size;
5564 if (cm->show_frame) {
5565 level_stats->total_uncompressed_size +=
5567 2 * (luma_pic_size >> (cm->subsampling_x + cm->subsampling_y));
5568 level_stats->time_encoded =
5569 (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) /
5570 (double)TICKS_PER_SEC;
5573 if (arf_src_index > 0) {
5574 if (!level_stats->seen_first_altref) {
5575 level_stats->seen_first_altref = 1;
5576 } else if (level_stats->frames_since_last_altref <
5577 level_spec->min_altref_distance) {
5578 level_spec->min_altref_distance = level_stats->frames_since_last_altref;
5580 level_stats->frames_since_last_altref = 0;
5582 ++level_stats->frames_since_last_altref;
5585 if (level_stats->frame_window_buffer.len < FRAME_WINDOW_SIZE - 1) {
5586 idx = (level_stats->frame_window_buffer.start +
5587 level_stats->frame_window_buffer.len++) %
5590 idx = level_stats->frame_window_buffer.start;
5591 level_stats->frame_window_buffer.start = (idx + 1) % FRAME_WINDOW_SIZE;
5593 level_stats->frame_window_buffer.buf[idx].ts = cpi->last_time_stamp_seen;
5594 level_stats->frame_window_buffer.buf[idx].size = (uint32_t)(*size);
5595 level_stats->frame_window_buffer.buf[idx].luma_samples = luma_pic_size;
5597 if (cm->frame_type == KEY_FRAME) {
5598 level_stats->ref_refresh_map = 0;
5601 level_stats->ref_refresh_map |= vp9_get_refresh_mask(cpi);
5602 // Also need to consider the case where the encoder refers to a buffer
5603 // that has been implicitly refreshed after encoding a keyframe.
5604 if (!cm->intra_only) {
5605 level_stats->ref_refresh_map |= (1 << cpi->lst_fb_idx);
5606 level_stats->ref_refresh_map |= (1 << cpi->gld_fb_idx);
5607 level_stats->ref_refresh_map |= (1 << cpi->alt_fb_idx);
5609 for (i = 0; i < REF_FRAMES; ++i) {
5610 count += (level_stats->ref_refresh_map >> i) & 1;
5612 if (count > level_spec->max_ref_frame_buffers) {
5613 level_spec->max_ref_frame_buffers = count;
5617 // update average_bitrate
5618 level_spec->average_bitrate = (double)level_stats->total_compressed_size /
5619 125.0 / level_stats->time_encoded;
5621 // update max_luma_sample_rate
5623 for (i = 0; i < level_stats->frame_window_buffer.len; ++i) {
5624 idx = (level_stats->frame_window_buffer.start +
5625 level_stats->frame_window_buffer.len - 1 - i) %
5628 dur_end = level_stats->frame_window_buffer.buf[idx].ts;
5630 if (dur_end - level_stats->frame_window_buffer.buf[idx].ts >=
5634 luma_samples += level_stats->frame_window_buffer.buf[idx].luma_samples;
5636 if (luma_samples > level_spec->max_luma_sample_rate) {
5637 level_spec->max_luma_sample_rate = luma_samples;
5640 // update max_cpb_size
5642 for (i = 0; i < CPB_WINDOW_SIZE; ++i) {
5643 if (i >= level_stats->frame_window_buffer.len) break;
5644 idx = (level_stats->frame_window_buffer.start +
5645 level_stats->frame_window_buffer.len - 1 - i) %
5647 cpb_data_size += level_stats->frame_window_buffer.buf[idx].size;
5649 cpb_data_size = cpb_data_size / 125.0;
5650 if (cpb_data_size > level_spec->max_cpb_size) {
5651 level_spec->max_cpb_size = cpb_data_size;
5654 // update max_luma_picture_size
5655 if (luma_pic_size > level_spec->max_luma_picture_size) {
5656 level_spec->max_luma_picture_size = luma_pic_size;
5659 // update max_luma_picture_breadth
5660 if (luma_pic_breadth > level_spec->max_luma_picture_breadth) {
5661 level_spec->max_luma_picture_breadth = luma_pic_breadth;
5664 // update compression_ratio
5665 level_spec->compression_ratio = (double)level_stats->total_uncompressed_size *
5667 level_stats->total_compressed_size / 8.0;
5669 // update max_col_tiles
5670 if (level_spec->max_col_tiles < (1 << cm->log2_tile_cols)) {
5671 level_spec->max_col_tiles = (1 << cm->log2_tile_cols);
5674 if (level_index >= 0 && level_constraint->fail_flag == 0) {
5675 if (level_spec->max_luma_picture_size >
5676 vp9_level_defs[level_index].max_luma_picture_size) {
5677 level_constraint->fail_flag |= (1 << LUMA_PIC_SIZE_TOO_LARGE);
5678 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5679 "Failed to encode to the target level %d. %s",
5680 vp9_level_defs[level_index].level,
5681 level_fail_messages[LUMA_PIC_SIZE_TOO_LARGE]);
5684 if (level_spec->max_luma_picture_breadth >
5685 vp9_level_defs[level_index].max_luma_picture_breadth) {
5686 level_constraint->fail_flag |= (1 << LUMA_PIC_BREADTH_TOO_LARGE);
5687 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5688 "Failed to encode to the target level %d. %s",
5689 vp9_level_defs[level_index].level,
5690 level_fail_messages[LUMA_PIC_BREADTH_TOO_LARGE]);
5693 if ((double)level_spec->max_luma_sample_rate >
5694 (double)vp9_level_defs[level_index].max_luma_sample_rate *
5695 (1 + SAMPLE_RATE_GRACE_P)) {
5696 level_constraint->fail_flag |= (1 << LUMA_SAMPLE_RATE_TOO_LARGE);
5697 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5698 "Failed to encode to the target level %d. %s",
5699 vp9_level_defs[level_index].level,
5700 level_fail_messages[LUMA_SAMPLE_RATE_TOO_LARGE]);
5703 if (level_spec->max_col_tiles > vp9_level_defs[level_index].max_col_tiles) {
5704 level_constraint->fail_flag |= (1 << TOO_MANY_COLUMN_TILE);
5705 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5706 "Failed to encode to the target level %d. %s",
5707 vp9_level_defs[level_index].level,
5708 level_fail_messages[TOO_MANY_COLUMN_TILE]);
5711 if (level_spec->min_altref_distance <
5712 vp9_level_defs[level_index].min_altref_distance) {
5713 level_constraint->fail_flag |= (1 << ALTREF_DIST_TOO_SMALL);
5714 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5715 "Failed to encode to the target level %d. %s",
5716 vp9_level_defs[level_index].level,
5717 level_fail_messages[ALTREF_DIST_TOO_SMALL]);
5720 if (level_spec->max_ref_frame_buffers >
5721 vp9_level_defs[level_index].max_ref_frame_buffers) {
5722 level_constraint->fail_flag |= (1 << TOO_MANY_REF_BUFFER);
5723 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5724 "Failed to encode to the target level %d. %s",
5725 vp9_level_defs[level_index].level,
5726 level_fail_messages[TOO_MANY_REF_BUFFER]);
5729 if (level_spec->max_cpb_size > vp9_level_defs[level_index].max_cpb_size) {
5730 level_constraint->fail_flag |= (1 << CPB_TOO_LARGE);
5731 vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
5732 "Failed to encode to the target level %d. %s",
5733 vp9_level_defs[level_index].level,
5734 level_fail_messages[CPB_TOO_LARGE]);
5737 // Set an upper bound for the next frame size. It will be used in
5738 // level_rc_framerate() before encoding the next frame.
5740 for (i = 0; i < CPB_WINDOW_SIZE - 1; ++i) {
5741 if (i >= level_stats->frame_window_buffer.len) break;
5742 idx = (level_stats->frame_window_buffer.start +
5743 level_stats->frame_window_buffer.len - 1 - i) %
5745 cpb_data_size += level_stats->frame_window_buffer.buf[idx].size;
5747 cpb_data_size = cpb_data_size / 125.0;
5748 level_constraint->max_frame_size =
5749 (int)((vp9_level_defs[level_index].max_cpb_size - cpb_data_size) *
5751 if (level_stats->frame_window_buffer.len < CPB_WINDOW_SIZE - 1)
5752 level_constraint->max_frame_size >>= 1;
5756 typedef struct GF_PICTURE {
5757 YV12_BUFFER_CONFIG *frame;
5759 FRAME_UPDATE_TYPE update_type;
5762 static void init_gop_frames(VP9_COMP *cpi, GF_PICTURE *gf_picture,
5763 const GF_GROUP *gf_group, int *tpl_group_frames) {
5764 VP9_COMMON *cm = &cpi->common;
5770 int arf_index_stack[MAX_ARF_LAYERS];
5771 int arf_stack_size = 0;
5772 int extend_frame_count = 0;
5773 int pframe_qindex = cpi->tpl_stats[2].base_qindex;
5774 int frame_gop_offset = 0;
5776 RefCntBuffer *frame_bufs = cm->buffer_pool->frame_bufs;
5777 int8_t recon_frame_index[REFS_PER_FRAME + MAX_ARF_LAYERS];
5779 memset(recon_frame_index, -1, sizeof(recon_frame_index));
5780 stack_init(arf_index_stack, MAX_ARF_LAYERS);
5782 // TODO(jingning): To be used later for gf frame type parsing.
5785 for (i = 0; i < FRAME_BUFFERS; ++i) {
5786 if (frame_bufs[i].ref_count == 0) {
5787 alloc_frame_mvs(cm, i);
5788 if (vpx_realloc_frame_buffer(&frame_bufs[i].buf, cm->width, cm->height,
5789 cm->subsampling_x, cm->subsampling_y,
5790 #if CONFIG_VP9_HIGHBITDEPTH
5791 cm->use_highbitdepth,
5793 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment,
5795 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
5796 "Failed to allocate frame buffer");
5798 recon_frame_index[frame_idx] = i;
5801 if (frame_idx >= REFS_PER_FRAME + cpi->oxcf.enable_auto_arf) break;
5805 for (i = 0; i < REFS_PER_FRAME + 1; ++i) {
5806 assert(recon_frame_index[i] >= 0);
5807 cpi->tpl_recon_frames[i] = &frame_bufs[recon_frame_index[i]].buf;
5810 *tpl_group_frames = 0;
5812 // Initialize Golden reference frame.
5813 gf_picture[0].frame = get_ref_frame_buffer(cpi, GOLDEN_FRAME);
5814 for (i = 0; i < 3; ++i) gf_picture[0].ref_frame[i] = -1;
5815 gf_picture[0].update_type = gf_group->update_type[0];
5817 ++*tpl_group_frames;
5819 // Initialize base layer ARF frame
5820 gf_picture[1].frame = cpi->Source;
5821 gf_picture[1].ref_frame[0] = gld_index;
5822 gf_picture[1].ref_frame[1] = lst_index;
5823 gf_picture[1].ref_frame[2] = alt_index;
5824 gf_picture[1].update_type = gf_group->update_type[1];
5826 ++*tpl_group_frames;
5828 // Initialize P frames
5829 for (frame_idx = 2; frame_idx < MAX_ARF_GOP_SIZE; ++frame_idx) {
5830 struct lookahead_entry *buf;
5831 frame_gop_offset = gf_group->frame_gop_index[frame_idx];
5832 buf = vp9_lookahead_peek(cpi->lookahead, frame_gop_offset - 1);
5834 if (buf == NULL) break;
5836 gf_picture[frame_idx].frame = &buf->img;
5837 gf_picture[frame_idx].ref_frame[0] = gld_index;
5838 gf_picture[frame_idx].ref_frame[1] = lst_index;
5839 gf_picture[frame_idx].ref_frame[2] = alt_index;
5840 gf_picture[frame_idx].update_type = gf_group->update_type[frame_idx];
5842 switch (gf_group->update_type[frame_idx]) {
5844 stack_push(arf_index_stack, alt_index, arf_stack_size);
5846 alt_index = frame_idx;
5848 case LF_UPDATE: lst_index = frame_idx; break;
5849 case OVERLAY_UPDATE:
5850 gld_index = frame_idx;
5851 alt_index = stack_pop(arf_index_stack, arf_stack_size);
5855 lst_index = alt_index;
5856 alt_index = stack_pop(arf_index_stack, arf_stack_size);
5862 ++*tpl_group_frames;
5864 // The length of group of pictures is baseline_gf_interval, plus the
5865 // beginning golden frame from last GOP, plus the last overlay frame in
5867 if (frame_idx == gf_group->gf_group_size) break;
5874 // Extend two frames outside the current gf group.
5875 for (; frame_idx < MAX_LAG_BUFFERS && extend_frame_count < 2; ++frame_idx) {
5876 struct lookahead_entry *buf =
5877 vp9_lookahead_peek(cpi->lookahead, frame_gop_offset - 1);
5879 if (buf == NULL) break;
5881 cpi->tpl_stats[frame_idx].base_qindex = pframe_qindex;
5883 gf_picture[frame_idx].frame = &buf->img;
5884 gf_picture[frame_idx].ref_frame[0] = gld_index;
5885 gf_picture[frame_idx].ref_frame[1] = lst_index;
5886 gf_picture[frame_idx].ref_frame[2] = alt_index;
5887 gf_picture[frame_idx].update_type = LF_UPDATE;
5888 lst_index = frame_idx;
5889 ++*tpl_group_frames;
5890 ++extend_frame_count;
5895 static void init_tpl_stats(VP9_COMP *cpi) {
5897 for (frame_idx = 0; frame_idx < MAX_ARF_GOP_SIZE; ++frame_idx) {
5898 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
5899 memset(tpl_frame->tpl_stats_ptr, 0,
5900 tpl_frame->height * tpl_frame->width *
5901 sizeof(*tpl_frame->tpl_stats_ptr));
5902 tpl_frame->is_valid = 0;
5906 #if CONFIG_NON_GREEDY_MV
5907 static uint32_t full_pixel_motion_search(VP9_COMP *cpi, ThreadData *td,
5908 MotionField *motion_field,
5909 int frame_idx, uint8_t *cur_frame_buf,
5910 uint8_t *ref_frame_buf, int stride,
5911 BLOCK_SIZE bsize, int mi_row,
5912 int mi_col, MV *mv) {
5913 MACROBLOCK *const x = &td->mb;
5914 MACROBLOCKD *const xd = &x->e_mbd;
5915 MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
5917 uint32_t bestsme = UINT_MAX;
5918 const MvLimits tmp_mv_limits = x->mv_limits;
5919 // lambda is used to adjust the importance of motion vector consitency.
5920 // TODO(angiebird): Figure out lambda's proper value.
5921 const int lambda = cpi->tpl_stats[frame_idx].lambda;
5922 int_mv nb_full_mvs[NB_MVS_NUM];
5925 MV best_ref_mv1 = { 0, 0 };
5926 MV best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */
5928 best_ref_mv1_full.col = best_ref_mv1.col >> 3;
5929 best_ref_mv1_full.row = best_ref_mv1.row >> 3;
5931 // Setup frame pointers
5932 x->plane[0].src.buf = cur_frame_buf;
5933 x->plane[0].src.stride = stride;
5934 xd->plane[0].pre[0].buf = ref_frame_buf;
5935 xd->plane[0].pre[0].stride = stride;
5937 step_param = mv_sf->reduce_first_step_size;
5938 step_param = VPXMIN(step_param, MAX_MVSEARCH_STEPS - 2);
5940 vp9_set_mv_search_range(&x->mv_limits, &best_ref_mv1);
5943 vp9_prepare_nb_full_mvs(motion_field, mi_row, mi_col, nb_full_mvs);
5944 vp9_full_pixel_diamond_new(cpi, x, bsize, &best_ref_mv1_full, step_param,
5945 lambda, 1, nb_full_mvs, nb_full_mv_num, mv);
5947 /* restore UMV window */
5948 x->mv_limits = tmp_mv_limits;
5953 static uint32_t sub_pixel_motion_search(VP9_COMP *cpi, ThreadData *td,
5954 uint8_t *cur_frame_buf,
5955 uint8_t *ref_frame_buf, int stride,
5956 BLOCK_SIZE bsize, MV *mv) {
5957 MACROBLOCK *const x = &td->mb;
5958 MACROBLOCKD *const xd = &x->e_mbd;
5959 MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
5960 uint32_t bestsme = UINT_MAX;
5961 uint32_t distortion;
5965 MV best_ref_mv1 = { 0, 0 };
5967 // Setup frame pointers
5968 x->plane[0].src.buf = cur_frame_buf;
5969 x->plane[0].src.stride = stride;
5970 xd->plane[0].pre[0].buf = ref_frame_buf;
5971 xd->plane[0].pre[0].stride = stride;
5973 // TODO(yunqing): may use higher tap interp filter than 2 taps.
5974 // Ignore mv costing by sending NULL pointer instead of cost array
5975 bestsme = cpi->find_fractional_mv_step(
5976 x, mv, &best_ref_mv1, cpi->common.allow_high_precision_mv, x->errorperbit,
5977 &cpi->fn_ptr[bsize], 0, mv_sf->subpel_search_level,
5978 cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL, 0, 0,
5984 #else // CONFIG_NON_GREEDY_MV
5985 static uint32_t motion_compensated_prediction(VP9_COMP *cpi, ThreadData *td,
5986 uint8_t *cur_frame_buf,
5987 uint8_t *ref_frame_buf,
5988 int stride, BLOCK_SIZE bsize,
5990 MACROBLOCK *const x = &td->mb;
5991 MACROBLOCKD *const xd = &x->e_mbd;
5992 MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
5993 const SEARCH_METHODS search_method = NSTEP;
5995 int sadpb = x->sadperbit16;
5996 uint32_t bestsme = UINT_MAX;
5997 uint32_t distortion;
6000 const MvLimits tmp_mv_limits = x->mv_limits;
6002 MV best_ref_mv1 = { 0, 0 };
6003 MV best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */
6005 best_ref_mv1_full.col = best_ref_mv1.col >> 3;
6006 best_ref_mv1_full.row = best_ref_mv1.row >> 3;
6008 // Setup frame pointers
6009 x->plane[0].src.buf = cur_frame_buf;
6010 x->plane[0].src.stride = stride;
6011 xd->plane[0].pre[0].buf = ref_frame_buf;
6012 xd->plane[0].pre[0].stride = stride;
6014 step_param = mv_sf->reduce_first_step_size;
6015 step_param = VPXMIN(step_param, MAX_MVSEARCH_STEPS - 2);
6017 vp9_set_mv_search_range(&x->mv_limits, &best_ref_mv1);
6019 vp9_full_pixel_search(cpi, x, bsize, &best_ref_mv1_full, step_param,
6020 search_method, sadpb, cond_cost_list(cpi, cost_list),
6021 &best_ref_mv1, mv, 0, 0);
6023 /* restore UMV window */
6024 x->mv_limits = tmp_mv_limits;
6026 // TODO(yunqing): may use higher tap interp filter than 2 taps.
6027 // Ignore mv costing by sending NULL pointer instead of cost array
6028 bestsme = cpi->find_fractional_mv_step(
6029 x, mv, &best_ref_mv1, cpi->common.allow_high_precision_mv, x->errorperbit,
6030 &cpi->fn_ptr[bsize], 0, mv_sf->subpel_search_level,
6031 cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL, 0, 0,
6038 static int get_overlap_area(int grid_pos_row, int grid_pos_col, int ref_pos_row,
6039 int ref_pos_col, int block, BLOCK_SIZE bsize) {
6040 int width = 0, height = 0;
6041 int bw = 4 << b_width_log2_lookup[bsize];
6042 int bh = 4 << b_height_log2_lookup[bsize];
6046 width = grid_pos_col + bw - ref_pos_col;
6047 height = grid_pos_row + bh - ref_pos_row;
6050 width = ref_pos_col + bw - grid_pos_col;
6051 height = grid_pos_row + bh - ref_pos_row;
6054 width = grid_pos_col + bw - ref_pos_col;
6055 height = ref_pos_row + bh - grid_pos_row;
6058 width = ref_pos_col + bw - grid_pos_col;
6059 height = ref_pos_row + bh - grid_pos_row;
6064 return width * height;
6067 static int round_floor(int ref_pos, int bsize_pix) {
6070 round = -(1 + (-ref_pos - 1) / bsize_pix);
6072 round = ref_pos / bsize_pix;
6077 static void tpl_model_store(TplDepStats *tpl_stats, int mi_row, int mi_col,
6078 BLOCK_SIZE bsize, int stride) {
6079 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6080 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6081 const TplDepStats *src_stats = &tpl_stats[mi_row * stride + mi_col];
6084 for (idy = 0; idy < mi_height; ++idy) {
6085 for (idx = 0; idx < mi_width; ++idx) {
6086 TplDepStats *tpl_ptr = &tpl_stats[(mi_row + idy) * stride + mi_col + idx];
6087 const int64_t mc_flow = tpl_ptr->mc_flow;
6088 const int64_t mc_ref_cost = tpl_ptr->mc_ref_cost;
6089 *tpl_ptr = *src_stats;
6090 tpl_ptr->mc_flow = mc_flow;
6091 tpl_ptr->mc_ref_cost = mc_ref_cost;
6092 tpl_ptr->mc_dep_cost = tpl_ptr->intra_cost + tpl_ptr->mc_flow;
6097 static void tpl_model_update_b(TplDepFrame *tpl_frame, TplDepStats *tpl_stats,
6098 int mi_row, int mi_col, const BLOCK_SIZE bsize) {
6099 TplDepFrame *ref_tpl_frame = &tpl_frame[tpl_stats->ref_frame_index];
6100 TplDepStats *ref_stats = ref_tpl_frame->tpl_stats_ptr;
6101 MV mv = tpl_stats->mv.as_mv;
6102 int mv_row = mv.row >> 3;
6103 int mv_col = mv.col >> 3;
6105 int ref_pos_row = mi_row * MI_SIZE + mv_row;
6106 int ref_pos_col = mi_col * MI_SIZE + mv_col;
6108 const int bw = 4 << b_width_log2_lookup[bsize];
6109 const int bh = 4 << b_height_log2_lookup[bsize];
6110 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6111 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6112 const int pix_num = bw * bh;
6114 // top-left on grid block location in pixel
6115 int grid_pos_row_base = round_floor(ref_pos_row, bh) * bh;
6116 int grid_pos_col_base = round_floor(ref_pos_col, bw) * bw;
6119 for (block = 0; block < 4; ++block) {
6120 int grid_pos_row = grid_pos_row_base + bh * (block >> 1);
6121 int grid_pos_col = grid_pos_col_base + bw * (block & 0x01);
6123 if (grid_pos_row >= 0 && grid_pos_row < ref_tpl_frame->mi_rows * MI_SIZE &&
6124 grid_pos_col >= 0 && grid_pos_col < ref_tpl_frame->mi_cols * MI_SIZE) {
6125 int overlap_area = get_overlap_area(
6126 grid_pos_row, grid_pos_col, ref_pos_row, ref_pos_col, block, bsize);
6127 int ref_mi_row = round_floor(grid_pos_row, bh) * mi_height;
6128 int ref_mi_col = round_floor(grid_pos_col, bw) * mi_width;
6130 int64_t mc_flow = tpl_stats->mc_dep_cost -
6131 (tpl_stats->mc_dep_cost * tpl_stats->inter_cost) /
6132 tpl_stats->intra_cost;
6136 for (idy = 0; idy < mi_height; ++idy) {
6137 for (idx = 0; idx < mi_width; ++idx) {
6138 TplDepStats *des_stats =
6139 &ref_stats[(ref_mi_row + idy) * ref_tpl_frame->stride +
6140 (ref_mi_col + idx)];
6142 des_stats->mc_flow += (mc_flow * overlap_area) / pix_num;
6143 des_stats->mc_ref_cost +=
6144 ((tpl_stats->intra_cost - tpl_stats->inter_cost) * overlap_area) /
6146 assert(overlap_area >= 0);
6153 static void tpl_model_update(TplDepFrame *tpl_frame, TplDepStats *tpl_stats,
6154 int mi_row, int mi_col, const BLOCK_SIZE bsize) {
6156 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6157 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6159 for (idy = 0; idy < mi_height; ++idy) {
6160 for (idx = 0; idx < mi_width; ++idx) {
6161 TplDepStats *tpl_ptr =
6162 &tpl_stats[(mi_row + idy) * tpl_frame->stride + (mi_col + idx)];
6163 tpl_model_update_b(tpl_frame, tpl_ptr, mi_row + idy, mi_col + idx,
6169 static void get_quantize_error(MACROBLOCK *x, int plane, tran_low_t *coeff,
6170 tran_low_t *qcoeff, tran_low_t *dqcoeff,
6171 TX_SIZE tx_size, int64_t *recon_error,
6173 MACROBLOCKD *const xd = &x->e_mbd;
6174 const struct macroblock_plane *const p = &x->plane[plane];
6175 const struct macroblockd_plane *const pd = &xd->plane[plane];
6176 const scan_order *const scan_order = &vp9_default_scan_orders[tx_size];
6178 int pix_num = 1 << num_pels_log2_lookup[txsize_to_bsize[tx_size]];
6179 const int shift = tx_size == TX_32X32 ? 0 : 2;
6181 #if CONFIG_VP9_HIGHBITDEPTH
6182 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6183 vp9_highbd_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp,
6184 p->quant_fp, qcoeff, dqcoeff, pd->dequant,
6185 &eob, scan_order->scan, scan_order->iscan);
6187 vp9_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp,
6188 p->quant_fp, qcoeff, dqcoeff, pd->dequant, &eob,
6189 scan_order->scan, scan_order->iscan);
6192 vp9_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp, p->quant_fp,
6193 qcoeff, dqcoeff, pd->dequant, &eob, scan_order->scan,
6195 #endif // CONFIG_VP9_HIGHBITDEPTH
6197 *recon_error = vp9_block_error(coeff, dqcoeff, pix_num, sse) >> shift;
6198 *recon_error = VPXMAX(*recon_error, 1);
6200 *sse = (*sse) >> shift;
6201 *sse = VPXMAX(*sse, 1);
6204 #if CONFIG_VP9_HIGHBITDEPTH
6205 void highbd_wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
6207 // TODO(sdeng): Implement SIMD based high bit-depth Hadamard transforms.
6209 case TX_8X8: vpx_highbd_hadamard_8x8(src_diff, bw, coeff); break;
6210 case TX_16X16: vpx_highbd_hadamard_16x16(src_diff, bw, coeff); break;
6211 case TX_32X32: vpx_highbd_hadamard_32x32(src_diff, bw, coeff); break;
6215 #endif // CONFIG_VP9_HIGHBITDEPTH
6217 void wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff,
6220 case TX_8X8: vpx_hadamard_8x8(src_diff, bw, coeff); break;
6221 case TX_16X16: vpx_hadamard_16x16(src_diff, bw, coeff); break;
6222 case TX_32X32: vpx_hadamard_32x32(src_diff, bw, coeff); break;
6227 static void set_mv_limits(const VP9_COMMON *cm, MACROBLOCK *x, int mi_row,
6229 x->mv_limits.row_min = -((mi_row * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND));
6230 x->mv_limits.row_max =
6231 (cm->mi_rows - 1 - mi_row) * MI_SIZE + (17 - 2 * VP9_INTERP_EXTEND);
6232 x->mv_limits.col_min = -((mi_col * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND));
6233 x->mv_limits.col_max =
6234 ((cm->mi_cols - 1 - mi_col) * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND);
6237 static void mode_estimation(VP9_COMP *cpi, MACROBLOCK *x, MACROBLOCKD *xd,
6238 struct scale_factors *sf, GF_PICTURE *gf_picture,
6239 int frame_idx, TplDepFrame *tpl_frame,
6240 int16_t *src_diff, tran_low_t *coeff,
6241 tran_low_t *qcoeff, tran_low_t *dqcoeff, int mi_row,
6242 int mi_col, BLOCK_SIZE bsize, TX_SIZE tx_size,
6243 YV12_BUFFER_CONFIG *ref_frame[], uint8_t *predictor,
6244 int64_t *recon_error, int64_t *sse) {
6245 VP9_COMMON *cm = &cpi->common;
6246 ThreadData *td = &cpi->td;
6248 const int bw = 4 << b_width_log2_lookup[bsize];
6249 const int bh = 4 << b_height_log2_lookup[bsize];
6250 const int pix_num = bw * bh;
6251 int best_rf_idx = -1;
6253 int64_t best_inter_cost = INT64_MAX;
6256 const InterpKernel *const kernel = vp9_filter_kernels[EIGHTTAP];
6258 int64_t best_intra_cost = INT64_MAX;
6260 PREDICTION_MODE mode;
6261 int mb_y_offset = mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6262 MODE_INFO mi_above, mi_left;
6263 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6264 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6265 TplDepStats *tpl_stats =
6266 &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
6268 xd->mb_to_top_edge = -((mi_row * MI_SIZE) * 8);
6269 xd->mb_to_bottom_edge = ((cm->mi_rows - 1 - mi_row) * MI_SIZE) * 8;
6270 xd->mb_to_left_edge = -((mi_col * MI_SIZE) * 8);
6271 xd->mb_to_right_edge = ((cm->mi_cols - 1 - mi_col) * MI_SIZE) * 8;
6272 xd->above_mi = (mi_row > 0) ? &mi_above : NULL;
6273 xd->left_mi = (mi_col > 0) ? &mi_left : NULL;
6275 // Intra prediction search
6276 for (mode = DC_PRED; mode <= TM_PRED; ++mode) {
6278 int src_stride, dst_stride;
6280 src = xd->cur_buf->y_buffer + mb_y_offset;
6281 src_stride = xd->cur_buf->y_stride;
6283 dst = &predictor[0];
6286 xd->mi[0]->sb_type = bsize;
6287 xd->mi[0]->ref_frame[0] = INTRA_FRAME;
6289 vp9_predict_intra_block(xd, b_width_log2_lookup[bsize], tx_size, mode, src,
6290 src_stride, dst, dst_stride, 0, 0, 0);
6292 #if CONFIG_VP9_HIGHBITDEPTH
6293 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6294 vpx_highbd_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst,
6295 dst_stride, xd->bd);
6296 highbd_wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6297 intra_cost = vpx_highbd_satd(coeff, pix_num);
6299 vpx_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst,
6301 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6302 intra_cost = vpx_satd(coeff, pix_num);
6305 vpx_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst, dst_stride);
6306 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6307 intra_cost = vpx_satd(coeff, pix_num);
6308 #endif // CONFIG_VP9_HIGHBITDEPTH
6310 if (intra_cost < best_intra_cost) best_intra_cost = intra_cost;
6313 // Motion compensated prediction
6316 set_mv_limits(cm, x, mi_row, mi_col);
6318 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6320 #if CONFIG_NON_GREEDY_MV
6321 MotionField *motion_field;
6323 if (ref_frame[rf_idx] == NULL) continue;
6325 #if CONFIG_NON_GREEDY_MV
6327 motion_field = vp9_motion_field_info_get_motion_field(
6328 &cpi->motion_field_info, frame_idx, rf_idx, bsize);
6329 mv = vp9_motion_field_mi_get_mv(motion_field, mi_row, mi_col);
6331 motion_compensated_prediction(cpi, td, xd->cur_buf->y_buffer + mb_y_offset,
6332 ref_frame[rf_idx]->y_buffer + mb_y_offset,
6333 xd->cur_buf->y_stride, bsize, &mv.as_mv);
6336 #if CONFIG_VP9_HIGHBITDEPTH
6337 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
6338 vp9_highbd_build_inter_predictor(
6339 CONVERT_TO_SHORTPTR(ref_frame[rf_idx]->y_buffer + mb_y_offset),
6340 ref_frame[rf_idx]->y_stride, CONVERT_TO_SHORTPTR(&predictor[0]), bw,
6341 &mv.as_mv, sf, bw, bh, 0, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE,
6342 mi_row * MI_SIZE, xd->bd);
6343 vpx_highbd_subtract_block(
6344 bh, bw, src_diff, bw, xd->cur_buf->y_buffer + mb_y_offset,
6345 xd->cur_buf->y_stride, &predictor[0], bw, xd->bd);
6346 highbd_wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6347 inter_cost = vpx_highbd_satd(coeff, pix_num);
6349 vp9_build_inter_predictor(
6350 ref_frame[rf_idx]->y_buffer + mb_y_offset,
6351 ref_frame[rf_idx]->y_stride, &predictor[0], bw, &mv.as_mv, sf, bw, bh,
6352 0, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE, mi_row * MI_SIZE);
6353 vpx_subtract_block(bh, bw, src_diff, bw,
6354 xd->cur_buf->y_buffer + mb_y_offset,
6355 xd->cur_buf->y_stride, &predictor[0], bw);
6356 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6357 inter_cost = vpx_satd(coeff, pix_num);
6360 vp9_build_inter_predictor(ref_frame[rf_idx]->y_buffer + mb_y_offset,
6361 ref_frame[rf_idx]->y_stride, &predictor[0], bw,
6362 &mv.as_mv, sf, bw, bh, 0, kernel, MV_PRECISION_Q3,
6363 mi_col * MI_SIZE, mi_row * MI_SIZE);
6364 vpx_subtract_block(bh, bw, src_diff, bw,
6365 xd->cur_buf->y_buffer + mb_y_offset,
6366 xd->cur_buf->y_stride, &predictor[0], bw);
6367 wht_fwd_txfm(src_diff, bw, coeff, tx_size);
6368 inter_cost = vpx_satd(coeff, pix_num);
6371 if (inter_cost < best_inter_cost) {
6372 best_rf_idx = rf_idx;
6373 best_inter_cost = inter_cost;
6374 best_mv.as_int = mv.as_int;
6375 get_quantize_error(x, 0, coeff, qcoeff, dqcoeff, tx_size, recon_error,
6379 best_intra_cost = VPXMAX(best_intra_cost, 1);
6380 best_inter_cost = VPXMIN(best_intra_cost, best_inter_cost);
6381 tpl_stats->inter_cost = VPXMAX(
6382 1, (best_inter_cost << TPL_DEP_COST_SCALE_LOG2) / (mi_height * mi_width));
6383 tpl_stats->intra_cost = VPXMAX(
6384 1, (best_intra_cost << TPL_DEP_COST_SCALE_LOG2) / (mi_height * mi_width));
6385 tpl_stats->ref_frame_index = gf_picture[frame_idx].ref_frame[best_rf_idx];
6386 tpl_stats->mv.as_int = best_mv.as_int;
6389 #if CONFIG_NON_GREEDY_MV
6390 static int get_block_src_pred_buf(MACROBLOCKD *xd, GF_PICTURE *gf_picture,
6391 int frame_idx, int rf_idx, int mi_row,
6392 int mi_col, struct buf_2d *src,
6393 struct buf_2d *pre) {
6394 const int mb_y_offset =
6395 mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6396 YV12_BUFFER_CONFIG *ref_frame = NULL;
6397 int ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
6398 if (ref_frame_idx != -1) {
6399 ref_frame = gf_picture[ref_frame_idx].frame;
6400 src->buf = xd->cur_buf->y_buffer + mb_y_offset;
6401 src->stride = xd->cur_buf->y_stride;
6402 pre->buf = ref_frame->y_buffer + mb_y_offset;
6403 pre->stride = ref_frame->y_stride;
6404 assert(src->stride == pre->stride);
6407 printf("invalid ref_frame_idx");
6408 assert(ref_frame_idx != -1);
6413 #define kMvPreCheckLines 5
6414 #define kMvPreCheckSize 15
6416 #define MV_REF_POS_NUM 3
6417 POSITION mv_ref_pos[MV_REF_POS_NUM] = {
6423 static int_mv *get_select_mv(VP9_COMP *cpi, TplDepFrame *tpl_frame, int mi_row,
6425 return &cpi->select_mv_arr[mi_row * tpl_frame->stride + mi_col];
6428 static int_mv find_ref_mv(int mv_mode, VP9_COMP *cpi, TplDepFrame *tpl_frame,
6429 BLOCK_SIZE bsize, int mi_row, int mi_col) {
6431 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6432 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6433 int_mv nearest_mv, near_mv, invalid_mv;
6434 nearest_mv.as_int = INVALID_MV;
6435 near_mv.as_int = INVALID_MV;
6436 invalid_mv.as_int = INVALID_MV;
6437 for (i = 0; i < MV_REF_POS_NUM; ++i) {
6438 int nb_row = mi_row + mv_ref_pos[i].row * mi_height;
6439 int nb_col = mi_col + mv_ref_pos[i].col * mi_width;
6440 assert(mv_ref_pos[i].row <= 0);
6441 assert(mv_ref_pos[i].col <= 0);
6442 if (nb_row >= 0 && nb_col >= 0) {
6443 if (nearest_mv.as_int == INVALID_MV) {
6444 nearest_mv = *get_select_mv(cpi, tpl_frame, nb_row, nb_col);
6446 int_mv mv = *get_select_mv(cpi, tpl_frame, nb_row, nb_col);
6447 if (mv.as_int == nearest_mv.as_int) {
6456 if (nearest_mv.as_int == INVALID_MV) {
6457 nearest_mv.as_mv.row = 0;
6458 nearest_mv.as_mv.col = 0;
6460 if (near_mv.as_int == INVALID_MV) {
6461 near_mv.as_mv.row = 0;
6462 near_mv.as_mv.col = 0;
6464 if (mv_mode == NEAREST_MV_MODE) {
6467 if (mv_mode == NEAR_MV_MODE) {
6474 static int_mv get_mv_from_mv_mode(int mv_mode, VP9_COMP *cpi,
6475 MotionField *motion_field,
6476 TplDepFrame *tpl_frame, BLOCK_SIZE bsize,
6477 int mi_row, int mi_col) {
6485 mv = vp9_motion_field_mi_get_mv(motion_field, mi_row, mi_col);
6487 case NEAREST_MV_MODE:
6488 mv = find_ref_mv(mv_mode, cpi, tpl_frame, bsize, mi_row, mi_col);
6491 mv = find_ref_mv(mv_mode, cpi, tpl_frame, bsize, mi_row, mi_col);
6494 mv.as_int = INVALID_MV;
6501 static double get_mv_dist(int mv_mode, VP9_COMP *cpi, MACROBLOCKD *xd,
6502 GF_PICTURE *gf_picture, MotionField *motion_field,
6503 int frame_idx, TplDepFrame *tpl_frame, int rf_idx,
6504 BLOCK_SIZE bsize, int mi_row, int mi_col,
6510 *mv = get_mv_from_mv_mode(mv_mode, cpi, motion_field, tpl_frame, bsize,
6512 full_mv = get_full_mv(&mv->as_mv);
6513 if (get_block_src_pred_buf(xd, gf_picture, frame_idx, rf_idx, mi_row, mi_col,
6515 // TODO(angiebird): Consider subpixel when computing the sse.
6516 cpi->fn_ptr[bsize].vf(src.buf, src.stride, get_buf_from_mv(&pre, &full_mv),
6518 return (double)(sse << VP9_DIST_SCALE_LOG2);
6525 static int get_mv_mode_cost(int mv_mode) {
6526 // TODO(angiebird): The probabilities are roughly inferred from
6527 // default_inter_mode_probs. Check if there is a better way to set the
6529 const int zero_mv_prob = 16;
6530 const int new_mv_prob = 24 * 1;
6531 const int ref_mv_prob = 256 - zero_mv_prob - new_mv_prob;
6532 assert(zero_mv_prob + new_mv_prob + ref_mv_prob == 256);
6534 case ZERO_MV_MODE: return vp9_prob_cost[zero_mv_prob]; break;
6535 case NEW_MV_MODE: return vp9_prob_cost[new_mv_prob]; break;
6536 case NEAREST_MV_MODE: return vp9_prob_cost[ref_mv_prob]; break;
6537 case NEAR_MV_MODE: return vp9_prob_cost[ref_mv_prob]; break;
6538 default: assert(0); return -1;
6542 static INLINE double get_mv_diff_cost(MV *new_mv, MV *ref_mv) {
6543 double mv_diff_cost = log2(1 + abs(new_mv->row - ref_mv->row)) +
6544 log2(1 + abs(new_mv->col - ref_mv->col));
6545 mv_diff_cost *= (1 << VP9_PROB_COST_SHIFT);
6546 return mv_diff_cost;
6548 static double get_mv_cost(int mv_mode, VP9_COMP *cpi, MotionField *motion_field,
6549 TplDepFrame *tpl_frame, BLOCK_SIZE bsize, int mi_row,
6551 double mv_cost = get_mv_mode_cost(mv_mode);
6552 if (mv_mode == NEW_MV_MODE) {
6553 MV new_mv = get_mv_from_mv_mode(mv_mode, cpi, motion_field, tpl_frame,
6554 bsize, mi_row, mi_col)
6556 MV nearest_mv = get_mv_from_mv_mode(NEAREST_MV_MODE, cpi, motion_field,
6557 tpl_frame, bsize, mi_row, mi_col)
6559 MV near_mv = get_mv_from_mv_mode(NEAR_MV_MODE, cpi, motion_field, tpl_frame,
6560 bsize, mi_row, mi_col)
6562 double nearest_cost = get_mv_diff_cost(&new_mv, &nearest_mv);
6563 double near_cost = get_mv_diff_cost(&new_mv, &near_mv);
6564 mv_cost += nearest_cost < near_cost ? nearest_cost : near_cost;
6569 static double eval_mv_mode(int mv_mode, VP9_COMP *cpi, MACROBLOCK *x,
6570 GF_PICTURE *gf_picture, MotionField *motion_field,
6571 int frame_idx, TplDepFrame *tpl_frame, int rf_idx,
6572 BLOCK_SIZE bsize, int mi_row, int mi_col,
6574 MACROBLOCKD *xd = &x->e_mbd;
6576 get_mv_dist(mv_mode, cpi, xd, gf_picture, motion_field, frame_idx,
6577 tpl_frame, rf_idx, bsize, mi_row, mi_col, mv);
6579 get_mv_cost(mv_mode, cpi, motion_field, tpl_frame, bsize, mi_row, mi_col);
6582 return mv_cost + mult * log2f(1 + mv_dist);
6585 static int find_best_ref_mv_mode(VP9_COMP *cpi, MACROBLOCK *x,
6586 GF_PICTURE *gf_picture,
6587 MotionField *motion_field, int frame_idx,
6588 TplDepFrame *tpl_frame, int rf_idx,
6589 BLOCK_SIZE bsize, int mi_row, int mi_col,
6590 double *rd, int_mv *mv) {
6591 int best_mv_mode = ZERO_MV_MODE;
6595 for (mv_mode = 0; mv_mode < MAX_MV_MODE; ++mv_mode) {
6598 if (mv_mode == NEW_MV_MODE) {
6601 this_rd = eval_mv_mode(mv_mode, cpi, x, gf_picture, motion_field, frame_idx,
6602 tpl_frame, rf_idx, bsize, mi_row, mi_col, &this_mv);
6606 best_mv_mode = mv_mode;
6609 if (this_rd < *rd) {
6612 best_mv_mode = mv_mode;
6616 return best_mv_mode;
6619 static void predict_mv_mode(VP9_COMP *cpi, MACROBLOCK *x,
6620 GF_PICTURE *gf_picture, MotionField *motion_field,
6621 int frame_idx, TplDepFrame *tpl_frame, int rf_idx,
6622 BLOCK_SIZE bsize, int mi_row, int mi_col) {
6623 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6624 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6625 int tmp_mv_mode_arr[kMvPreCheckSize];
6626 int *mv_mode_arr = tpl_frame->mv_mode_arr[rf_idx];
6627 double *rd_diff_arr = tpl_frame->rd_diff_arr[rf_idx];
6628 int_mv *select_mv_arr = cpi->select_mv_arr;
6629 int_mv tmp_select_mv_arr[kMvPreCheckSize];
6630 int stride = tpl_frame->stride;
6631 double new_mv_rd = 0;
6632 double no_new_mv_rd = 0;
6633 double this_new_mv_rd = 0;
6634 double this_no_new_mv_rd = 0;
6637 assert(kMvPreCheckSize == (kMvPreCheckLines * (kMvPreCheckLines + 1)) >> 1);
6640 // diagnal scan order
6642 for (idx = 0; idx < kMvPreCheckLines; ++idx) {
6644 for (r = 0; r <= idx; ++r) {
6646 int nb_row = mi_row + r * mi_height;
6647 int nb_col = mi_col + c * mi_width;
6648 if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6650 int_mv *mv = &select_mv_arr[nb_row * stride + nb_col];
6651 mv_mode_arr[nb_row * stride + nb_col] = find_best_ref_mv_mode(
6652 cpi, x, gf_picture, motion_field, frame_idx, tpl_frame, rf_idx,
6653 bsize, nb_row, nb_col, &this_rd, mv);
6654 if (r == 0 && c == 0) {
6655 this_no_new_mv_rd = this_rd;
6657 no_new_mv_rd += this_rd;
6658 tmp_mv_mode_arr[tmp_idx] = mv_mode_arr[nb_row * stride + nb_col];
6659 tmp_select_mv_arr[tmp_idx] = select_mv_arr[nb_row * stride + nb_col];
6666 mv_mode_arr[mi_row * stride + mi_col] = NEW_MV_MODE;
6667 this_new_mv_rd = eval_mv_mode(
6668 NEW_MV_MODE, cpi, x, gf_picture, motion_field, frame_idx, tpl_frame,
6669 rf_idx, bsize, mi_row, mi_col, &select_mv_arr[mi_row * stride + mi_col]);
6670 new_mv_rd = this_new_mv_rd;
6671 // We start from idx = 1 because idx = 0 is evaluated as NEW_MV_MODE
6673 for (idx = 1; idx < kMvPreCheckLines; ++idx) {
6675 for (r = 0; r <= idx; ++r) {
6677 int nb_row = mi_row + r * mi_height;
6678 int nb_col = mi_col + c * mi_width;
6679 if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6681 int_mv *mv = &select_mv_arr[nb_row * stride + nb_col];
6682 mv_mode_arr[nb_row * stride + nb_col] = find_best_ref_mv_mode(
6683 cpi, x, gf_picture, motion_field, frame_idx, tpl_frame, rf_idx,
6684 bsize, nb_row, nb_col, &this_rd, mv);
6685 new_mv_rd += this_rd;
6690 // update best_mv_mode
6692 if (no_new_mv_rd < new_mv_rd) {
6693 for (idx = 0; idx < kMvPreCheckLines; ++idx) {
6695 for (r = 0; r <= idx; ++r) {
6697 int nb_row = mi_row + r * mi_height;
6698 int nb_col = mi_col + c * mi_width;
6699 if (nb_row < tpl_frame->mi_rows && nb_col < tpl_frame->mi_cols) {
6700 mv_mode_arr[nb_row * stride + nb_col] = tmp_mv_mode_arr[tmp_idx];
6701 select_mv_arr[nb_row * stride + nb_col] = tmp_select_mv_arr[tmp_idx];
6706 rd_diff_arr[mi_row * stride + mi_col] = 0;
6708 rd_diff_arr[mi_row * stride + mi_col] =
6709 (no_new_mv_rd - this_no_new_mv_rd) - (new_mv_rd - this_new_mv_rd);
6713 static void predict_mv_mode_arr(VP9_COMP *cpi, MACROBLOCK *x,
6714 GF_PICTURE *gf_picture,
6715 MotionField *motion_field, int frame_idx,
6716 TplDepFrame *tpl_frame, int rf_idx,
6718 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6719 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6720 const int unit_rows = tpl_frame->mi_rows / mi_height;
6721 const int unit_cols = tpl_frame->mi_cols / mi_width;
6722 const int max_diagonal_lines = unit_rows + unit_cols - 1;
6724 for (idx = 0; idx < max_diagonal_lines; ++idx) {
6726 for (r = VPXMAX(idx - unit_cols + 1, 0); r <= VPXMIN(idx, unit_rows - 1);
6729 int mi_row = r * mi_height;
6730 int mi_col = c * mi_width;
6731 assert(c >= 0 && c < unit_cols);
6732 assert(mi_row >= 0 && mi_row < tpl_frame->mi_rows);
6733 assert(mi_col >= 0 && mi_col < tpl_frame->mi_cols);
6734 predict_mv_mode(cpi, x, gf_picture, motion_field, frame_idx, tpl_frame,
6735 rf_idx, bsize, mi_row, mi_col);
6740 static void do_motion_search(VP9_COMP *cpi, ThreadData *td,
6741 MotionField *motion_field, int frame_idx,
6742 YV12_BUFFER_CONFIG *ref_frame, BLOCK_SIZE bsize,
6743 int mi_row, int mi_col) {
6744 VP9_COMMON *cm = &cpi->common;
6745 MACROBLOCK *x = &td->mb;
6746 MACROBLOCKD *xd = &x->e_mbd;
6747 const int mb_y_offset =
6748 mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
6749 assert(ref_frame != NULL);
6750 set_mv_limits(cm, x, mi_row, mi_col);
6752 int_mv mv = vp9_motion_field_mi_get_mv(motion_field, mi_row, mi_col);
6753 uint8_t *cur_frame_buf = xd->cur_buf->y_buffer + mb_y_offset;
6754 uint8_t *ref_frame_buf = ref_frame->y_buffer + mb_y_offset;
6755 const int stride = xd->cur_buf->y_stride;
6756 full_pixel_motion_search(cpi, td, motion_field, frame_idx, cur_frame_buf,
6757 ref_frame_buf, stride, bsize, mi_row, mi_col,
6759 sub_pixel_motion_search(cpi, td, cur_frame_buf, ref_frame_buf, stride,
6761 vp9_motion_field_mi_set_mv(motion_field, mi_row, mi_col, mv);
6765 static void build_motion_field(
6766 VP9_COMP *cpi, int frame_idx,
6767 YV12_BUFFER_CONFIG *ref_frame[MAX_INTER_REF_FRAMES], BLOCK_SIZE bsize) {
6768 VP9_COMMON *cm = &cpi->common;
6769 ThreadData *td = &cpi->td;
6770 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6771 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6772 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6773 const int pw = num_4x4_blocks_wide_lookup[bsize] << 2;
6774 const int ph = num_4x4_blocks_high_lookup[bsize] << 2;
6778 tpl_frame->lambda = (pw * ph) >> 2;
6779 assert(pw * ph == tpl_frame->lambda << 2);
6781 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6782 MotionField *motion_field = vp9_motion_field_info_get_motion_field(
6783 &cpi->motion_field_info, frame_idx, rf_idx, bsize);
6784 if (ref_frame[rf_idx] == NULL) {
6787 vp9_motion_field_reset_mvs(motion_field);
6788 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6789 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6790 do_motion_search(cpi, td, motion_field, frame_idx, ref_frame[rf_idx],
6791 bsize, mi_row, mi_col);
6796 #endif // CONFIG_NON_GREEDY_MV
6798 static void mc_flow_dispenser(VP9_COMP *cpi, GF_PICTURE *gf_picture,
6799 int frame_idx, BLOCK_SIZE bsize) {
6800 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6801 YV12_BUFFER_CONFIG *this_frame = gf_picture[frame_idx].frame;
6802 YV12_BUFFER_CONFIG *ref_frame[MAX_INTER_REF_FRAMES] = { NULL, NULL, NULL };
6804 VP9_COMMON *cm = &cpi->common;
6805 struct scale_factors sf;
6807 ThreadData *td = &cpi->td;
6808 MACROBLOCK *x = &td->mb;
6809 MACROBLOCKD *xd = &x->e_mbd;
6812 #if CONFIG_VP9_HIGHBITDEPTH
6813 DECLARE_ALIGNED(16, uint16_t, predictor16[32 * 32 * 3]);
6814 DECLARE_ALIGNED(16, uint8_t, predictor8[32 * 32 * 3]);
6817 DECLARE_ALIGNED(16, uint8_t, predictor[32 * 32 * 3]);
6819 DECLARE_ALIGNED(16, int16_t, src_diff[32 * 32]);
6820 DECLARE_ALIGNED(16, tran_low_t, coeff[32 * 32]);
6821 DECLARE_ALIGNED(16, tran_low_t, qcoeff[32 * 32]);
6822 DECLARE_ALIGNED(16, tran_low_t, dqcoeff[32 * 32]);
6824 const TX_SIZE tx_size = max_txsize_lookup[bsize];
6825 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6826 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6827 int64_t recon_error, sse;
6828 #if CONFIG_NON_GREEDY_MV
6829 int square_block_idx;
6833 // Setup scaling factor
6834 #if CONFIG_VP9_HIGHBITDEPTH
6835 vp9_setup_scale_factors_for_frame(
6836 &sf, this_frame->y_crop_width, this_frame->y_crop_height,
6837 this_frame->y_crop_width, this_frame->y_crop_height,
6838 cpi->common.use_highbitdepth);
6840 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH)
6841 predictor = CONVERT_TO_BYTEPTR(predictor16);
6843 predictor = predictor8;
6845 vp9_setup_scale_factors_for_frame(
6846 &sf, this_frame->y_crop_width, this_frame->y_crop_height,
6847 this_frame->y_crop_width, this_frame->y_crop_height);
6848 #endif // CONFIG_VP9_HIGHBITDEPTH
6850 // Prepare reference frame pointers. If any reference frame slot is
6851 // unavailable, the pointer will be set to Null.
6852 for (idx = 0; idx < MAX_INTER_REF_FRAMES; ++idx) {
6853 int rf_idx = gf_picture[frame_idx].ref_frame[idx];
6854 if (rf_idx != -1) ref_frame[idx] = gf_picture[rf_idx].frame;
6857 xd->mi = cm->mi_grid_visible;
6859 xd->cur_buf = this_frame;
6861 // Get rd multiplier set up.
6862 rdmult = vp9_compute_rd_mult_based_on_qindex(cpi, tpl_frame->base_qindex);
6863 set_error_per_bit(&cpi->td.mb, rdmult);
6864 vp9_initialize_me_consts(cpi, &cpi->td.mb, tpl_frame->base_qindex);
6866 tpl_frame->is_valid = 1;
6868 cm->base_qindex = tpl_frame->base_qindex;
6869 vp9_frame_init_quantizer(cpi);
6871 #if CONFIG_NON_GREEDY_MV
6872 for (square_block_idx = 0; square_block_idx < SQUARE_BLOCK_SIZES;
6873 ++square_block_idx) {
6874 BLOCK_SIZE square_bsize = square_block_idx_to_bsize(square_block_idx);
6875 build_motion_field(cpi, frame_idx, ref_frame, square_bsize);
6877 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6878 int ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
6879 if (ref_frame_idx != -1) {
6880 MotionField *motion_field = vp9_motion_field_info_get_motion_field(
6881 &cpi->motion_field_info, frame_idx, rf_idx, bsize);
6882 predict_mv_mode_arr(cpi, x, gf_picture, motion_field, frame_idx,
6883 tpl_frame, rf_idx, bsize);
6888 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6889 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6890 mode_estimation(cpi, x, xd, &sf, gf_picture, frame_idx, tpl_frame,
6891 src_diff, coeff, qcoeff, dqcoeff, mi_row, mi_col, bsize,
6892 tx_size, ref_frame, predictor, &recon_error, &sse);
6893 // Motion flow dependency dispenser.
6894 tpl_model_store(tpl_frame->tpl_stats_ptr, mi_row, mi_col, bsize,
6897 tpl_model_update(cpi->tpl_stats, tpl_frame->tpl_stats_ptr, mi_row, mi_col,
6903 #if CONFIG_NON_GREEDY_MV
6904 #define DUMP_TPL_STATS 0
6906 static void dump_buf(uint8_t *buf, int stride, int row, int col, int h, int w) {
6908 printf("%d %d\n", h, w);
6909 for (i = 0; i < h; ++i) {
6910 for (j = 0; j < w; ++j) {
6911 printf("%d ", buf[(row + i) * stride + col + j]);
6917 static void dump_frame_buf(const YV12_BUFFER_CONFIG *frame_buf) {
6918 dump_buf(frame_buf->y_buffer, frame_buf->y_stride, 0, 0, frame_buf->y_height,
6919 frame_buf->y_width);
6920 dump_buf(frame_buf->u_buffer, frame_buf->uv_stride, 0, 0,
6921 frame_buf->uv_height, frame_buf->uv_width);
6922 dump_buf(frame_buf->v_buffer, frame_buf->uv_stride, 0, 0,
6923 frame_buf->uv_height, frame_buf->uv_width);
6926 static void dump_tpl_stats(const VP9_COMP *cpi, int tpl_group_frames,
6927 const GF_GROUP *gf_group,
6928 const GF_PICTURE *gf_picture, BLOCK_SIZE bsize) {
6930 const VP9_COMMON *cm = &cpi->common;
6932 for (frame_idx = 1; frame_idx < tpl_group_frames; ++frame_idx) {
6933 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
6934 const TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx];
6937 const int mi_height = num_8x8_blocks_high_lookup[bsize];
6938 const int mi_width = num_8x8_blocks_wide_lookup[bsize];
6939 ref_frame_idx = gf_picture[frame_idx].ref_frame[rf_idx];
6940 if (ref_frame_idx != -1) {
6941 YV12_BUFFER_CONFIG *ref_frame_buf = gf_picture[ref_frame_idx].frame;
6942 const int gf_frame_offset = gf_group->frame_gop_index[frame_idx];
6943 const int ref_gf_frame_offset =
6944 gf_group->frame_gop_index[ref_frame_idx];
6947 "frame_idx %d mi_rows %d mi_cols %d bsize %d ref_frame_idx %d "
6948 "rf_idx %d gf_frame_offset %d ref_gf_frame_offset %d\n",
6949 frame_idx, cm->mi_rows, cm->mi_cols, mi_width * MI_SIZE,
6950 ref_frame_idx, rf_idx, gf_frame_offset, ref_gf_frame_offset);
6951 for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row) {
6952 for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) {
6953 if ((mi_row % mi_height) == 0 && (mi_col % mi_width) == 0) {
6954 int_mv mv = vp9_motion_field_info_get_mv(&cpi->motion_field_info,
6955 frame_idx, rf_idx, bsize,
6957 printf("%d %d %d %d\n", mi_row, mi_col, mv.as_mv.row,
6962 for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row) {
6963 for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) {
6964 if ((mi_row % mi_height) == 0 && (mi_col % mi_width) == 0) {
6965 const TplDepStats *tpl_ptr =
6967 ->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col];
6968 printf("%f ", tpl_ptr->feature_score);
6974 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) {
6975 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) {
6978 ->mv_mode_arr[rf_idx][mi_row * tpl_frame->stride + mi_col];
6979 printf("%d ", mv_mode);
6984 dump_frame_buf(gf_picture[frame_idx].frame);
6985 dump_frame_buf(ref_frame_buf);
6990 #endif // DUMP_TPL_STATS
6991 #endif // CONFIG_NON_GREEDY_MV
6993 static void init_tpl_buffer(VP9_COMP *cpi) {
6994 VP9_COMMON *cm = &cpi->common;
6997 const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
6998 const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
6999 #if CONFIG_NON_GREEDY_MV
7002 vpx_free(cpi->select_mv_arr);
7004 cm, cpi->select_mv_arr,
7005 vpx_calloc(mi_rows * mi_cols * 4, sizeof(*cpi->select_mv_arr)));
7008 // TODO(jingning): Reduce the actual memory use for tpl model build up.
7009 for (frame = 0; frame < MAX_ARF_GOP_SIZE; ++frame) {
7010 if (cpi->tpl_stats[frame].width >= mi_cols &&
7011 cpi->tpl_stats[frame].height >= mi_rows &&
7012 cpi->tpl_stats[frame].tpl_stats_ptr)
7015 #if CONFIG_NON_GREEDY_MV
7016 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
7017 vpx_free(cpi->tpl_stats[frame].mv_mode_arr[rf_idx]);
7019 cm, cpi->tpl_stats[frame].mv_mode_arr[rf_idx],
7020 vpx_calloc(mi_rows * mi_cols * 4,
7021 sizeof(*cpi->tpl_stats[frame].mv_mode_arr[rf_idx])));
7022 vpx_free(cpi->tpl_stats[frame].rd_diff_arr[rf_idx]);
7024 cm, cpi->tpl_stats[frame].rd_diff_arr[rf_idx],
7025 vpx_calloc(mi_rows * mi_cols * 4,
7026 sizeof(*cpi->tpl_stats[frame].rd_diff_arr[rf_idx])));
7029 vpx_free(cpi->tpl_stats[frame].tpl_stats_ptr);
7030 CHECK_MEM_ERROR(cm, cpi->tpl_stats[frame].tpl_stats_ptr,
7031 vpx_calloc(mi_rows * mi_cols,
7032 sizeof(*cpi->tpl_stats[frame].tpl_stats_ptr)));
7033 cpi->tpl_stats[frame].is_valid = 0;
7034 cpi->tpl_stats[frame].width = mi_cols;
7035 cpi->tpl_stats[frame].height = mi_rows;
7036 cpi->tpl_stats[frame].stride = mi_cols;
7037 cpi->tpl_stats[frame].mi_rows = cm->mi_rows;
7038 cpi->tpl_stats[frame].mi_cols = cm->mi_cols;
7041 for (frame = 0; frame < REF_FRAMES; ++frame) {
7042 cpi->enc_frame_buf[frame].mem_valid = 0;
7043 cpi->enc_frame_buf[frame].released = 1;
7047 static void free_tpl_buffer(VP9_COMP *cpi) {
7049 #if CONFIG_NON_GREEDY_MV
7050 vp9_free_motion_field_info(&cpi->motion_field_info);
7051 vpx_free(cpi->select_mv_arr);
7053 for (frame = 0; frame < MAX_ARF_GOP_SIZE; ++frame) {
7054 #if CONFIG_NON_GREEDY_MV
7056 for (rf_idx = 0; rf_idx < MAX_INTER_REF_FRAMES; ++rf_idx) {
7057 vpx_free(cpi->tpl_stats[frame].mv_mode_arr[rf_idx]);
7058 vpx_free(cpi->tpl_stats[frame].rd_diff_arr[rf_idx]);
7061 vpx_free(cpi->tpl_stats[frame].tpl_stats_ptr);
7062 cpi->tpl_stats[frame].is_valid = 0;
7066 static void setup_tpl_stats(VP9_COMP *cpi) {
7067 GF_PICTURE gf_picture[MAX_ARF_GOP_SIZE];
7068 const GF_GROUP *gf_group = &cpi->twopass.gf_group;
7069 int tpl_group_frames = 0;
7071 cpi->tpl_bsize = BLOCK_32X32;
7073 init_gop_frames(cpi, gf_picture, gf_group, &tpl_group_frames);
7075 init_tpl_stats(cpi);
7077 // Backward propagation from tpl_group_frames to 1.
7078 for (frame_idx = tpl_group_frames - 1; frame_idx > 0; --frame_idx) {
7079 if (gf_picture[frame_idx].update_type == USE_BUF_FRAME) continue;
7080 mc_flow_dispenser(cpi, gf_picture, frame_idx, cpi->tpl_bsize);
7082 #if CONFIG_NON_GREEDY_MV
7085 dump_tpl_stats(cpi, tpl_group_frames, gf_group, gf_picture, cpi->tpl_bsize);
7086 #endif // DUMP_TPL_STATS
7087 #endif // CONFIG_NON_GREEDY_MV
7090 int vp9_get_compressed_data(VP9_COMP *cpi, unsigned int *frame_flags,
7091 size_t *size, uint8_t *dest, int64_t *time_stamp,
7092 int64_t *time_end, int flush) {
7093 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
7094 VP9_COMMON *const cm = &cpi->common;
7095 BufferPool *const pool = cm->buffer_pool;
7096 RATE_CONTROL *const rc = &cpi->rc;
7097 struct vpx_usec_timer cmptimer;
7098 YV12_BUFFER_CONFIG *force_src_buffer = NULL;
7099 struct lookahead_entry *last_source = NULL;
7100 struct lookahead_entry *source = NULL;
7102 const int gf_group_index = cpi->twopass.gf_group.index;
7105 if (is_one_pass_cbr_svc(cpi)) {
7106 vp9_one_pass_cbr_svc_start_layer(cpi);
7109 vpx_usec_timer_start(&cmptimer);
7111 vp9_set_high_precision_mv(cpi, ALTREF_HIGH_PRECISION_MV);
7113 // Is multi-arf enabled.
7114 // Note that at the moment multi_arf is only configured for 2 pass VBR and
7115 // will not work properly with svc.
7116 // Enable the Jingning's new "multi_layer_arf" code if "enable_auto_arf"
7117 // is greater than or equal to 2.
7118 if ((oxcf->pass == 2) && !cpi->use_svc && (cpi->oxcf.enable_auto_arf >= 2))
7119 cpi->multi_layer_arf = 1;
7121 cpi->multi_layer_arf = 0;
7124 cm->reset_frame_context = 0;
7125 cm->refresh_frame_context = 1;
7126 if (!is_one_pass_cbr_svc(cpi)) {
7127 cpi->refresh_last_frame = 1;
7128 cpi->refresh_golden_frame = 0;
7129 cpi->refresh_alt_ref_frame = 0;
7132 // Should we encode an arf frame.
7133 arf_src_index = get_arf_src_index(cpi);
7135 if (arf_src_index) {
7136 for (i = 0; i <= arf_src_index; ++i) {
7137 struct lookahead_entry *e = vp9_lookahead_peek(cpi->lookahead, i);
7138 // Avoid creating an alt-ref if there's a forced keyframe pending.
7141 } else if (e->flags == VPX_EFLAG_FORCE_KF) {
7149 // Clear arf index stack before group of pictures processing starts.
7150 if (gf_group_index == 1) {
7151 stack_init(cpi->twopass.gf_group.arf_index_stack, MAX_LAG_BUFFERS * 2);
7152 cpi->twopass.gf_group.stack_size = 0;
7155 if (arf_src_index) {
7156 assert(arf_src_index <= rc->frames_to_key);
7157 if ((source = vp9_lookahead_peek(cpi->lookahead, arf_src_index)) != NULL) {
7158 cpi->alt_ref_source = source;
7160 #if !CONFIG_REALTIME_ONLY
7161 if ((oxcf->mode != REALTIME) && (oxcf->arnr_max_frames > 0) &&
7162 (oxcf->arnr_strength > 0)) {
7163 int bitrate = cpi->rc.avg_frame_bandwidth / 40;
7164 int not_low_bitrate = bitrate > ALT_REF_AQ_LOW_BITRATE_BOUNDARY;
7166 int not_last_frame = (cpi->lookahead->sz - arf_src_index > 1);
7167 not_last_frame |= ALT_REF_AQ_APPLY_TO_LAST_FRAME;
7169 // Produce the filtered ARF frame.
7170 vp9_temporal_filter(cpi, arf_src_index);
7171 vpx_extend_frame_borders(&cpi->alt_ref_buffer);
7173 // for small bitrates segmentation overhead usually
7174 // eats all bitrate gain from enabling delta quantizers
7175 if (cpi->oxcf.alt_ref_aq != 0 && not_low_bitrate && not_last_frame)
7176 vp9_alt_ref_aq_setup_mode(cpi->alt_ref_aq, cpi);
7178 force_src_buffer = &cpi->alt_ref_buffer;
7183 cpi->refresh_alt_ref_frame = 1;
7184 cpi->refresh_golden_frame = 0;
7185 cpi->refresh_last_frame = 0;
7186 rc->is_src_frame_alt_ref = 0;
7187 rc->source_alt_ref_pending = 0;
7189 rc->source_alt_ref_pending = 0;
7194 // Get last frame source.
7195 if (cm->current_video_frame > 0) {
7196 if ((last_source = vp9_lookahead_peek(cpi->lookahead, -1)) == NULL)
7200 // Read in the source frame.
7201 if (cpi->use_svc || cpi->svc.set_intra_only_frame)
7202 source = vp9_svc_lookahead_pop(cpi, cpi->lookahead, flush);
7204 source = vp9_lookahead_pop(cpi->lookahead, flush);
7206 if (source != NULL) {
7209 // If the flags indicate intra frame, but if the current picture is for
7210 // spatial layer above first_spatial_layer_to_encode, it should not be an
7212 if ((source->flags & VPX_EFLAG_FORCE_KF) && cpi->use_svc &&
7213 cpi->svc.spatial_layer_id > cpi->svc.first_spatial_layer_to_encode) {
7214 source->flags &= ~(unsigned int)(VPX_EFLAG_FORCE_KF);
7217 // Check to see if the frame should be encoded as an arf overlay.
7218 check_src_altref(cpi, source);
7223 cpi->un_scaled_source = cpi->Source =
7224 force_src_buffer ? force_src_buffer : &source->img;
7226 #ifdef ENABLE_KF_DENOISE
7227 // Copy of raw source for metrics calculation.
7228 if (is_psnr_calc_enabled(cpi))
7229 vp9_copy_and_extend_frame(cpi->Source, &cpi->raw_unscaled_source);
7232 cpi->unscaled_last_source = last_source != NULL ? &last_source->img : NULL;
7234 *time_stamp = source->ts_start;
7235 *time_end = source->ts_end;
7236 *frame_flags = (source->flags & VPX_EFLAG_FORCE_KF) ? FRAMEFLAGS_KEY : 0;
7242 if (source->ts_start < cpi->first_time_stamp_ever) {
7243 cpi->first_time_stamp_ever = source->ts_start;
7244 cpi->last_end_time_stamp_seen = source->ts_start;
7247 // Clear down mmx registers
7248 vpx_clear_system_state();
7250 // adjust frame rates based on timestamps given
7251 if (cm->show_frame) {
7252 if (cpi->use_svc && cpi->svc.use_set_ref_frame_config &&
7253 cpi->svc.duration[cpi->svc.spatial_layer_id] > 0)
7254 vp9_svc_adjust_frame_rate(cpi);
7256 adjust_frame_rate(cpi, source);
7259 if (is_one_pass_cbr_svc(cpi)) {
7260 vp9_update_temporal_layer_framerate(cpi);
7261 vp9_restore_layer_context(cpi);
7264 // Find a free buffer for the new frame, releasing the reference previously
7266 if (cm->new_fb_idx != INVALID_IDX) {
7267 --pool->frame_bufs[cm->new_fb_idx].ref_count;
7269 cm->new_fb_idx = get_free_fb(cm);
7271 if (cm->new_fb_idx == INVALID_IDX) return -1;
7273 cm->cur_frame = &pool->frame_bufs[cm->new_fb_idx];
7275 // Start with a 0 size frame.
7278 cpi->frame_flags = *frame_flags;
7280 #if !CONFIG_REALTIME_ONLY
7281 if ((oxcf->pass == 2) && !cpi->use_svc) {
7282 vp9_rc_get_second_pass_params(cpi);
7283 } else if (oxcf->pass == 1) {
7284 set_frame_size(cpi);
7286 #endif // !CONFIG_REALTIME_ONLY
7288 if (oxcf->pass != 1 && cpi->level_constraint.level_index >= 0 &&
7289 cpi->level_constraint.fail_flag == 0)
7290 level_rc_framerate(cpi, arf_src_index);
7292 if (cpi->oxcf.pass != 0 || cpi->use_svc || frame_is_intra_only(cm) == 1) {
7293 for (i = 0; i < REFS_PER_FRAME; ++i) cpi->scaled_ref_idx[i] = INVALID_IDX;
7296 if (cpi->kmeans_data_arr_alloc == 0) {
7297 const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
7298 const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
7299 #if CONFIG_MULTITHREAD
7300 pthread_mutex_init(&cpi->kmeans_mutex, NULL);
7303 cm, cpi->kmeans_data_arr,
7304 vpx_calloc(mi_rows * mi_cols, sizeof(*cpi->kmeans_data_arr)));
7305 cpi->kmeans_data_stride = mi_cols;
7306 cpi->kmeans_data_arr_alloc = 1;
7309 #if CONFIG_NON_GREEDY_MV
7311 const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
7312 const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows);
7313 Status status = vp9_alloc_motion_field_info(
7314 &cpi->motion_field_info, MAX_ARF_GOP_SIZE, mi_rows, mi_cols);
7315 if (status == STATUS_FAILED) {
7316 vpx_internal_error(&(cm)->error, VPX_CODEC_MEM_ERROR,
7317 "vp9_alloc_motion_field_info failed");
7320 #endif // CONFIG_NON_GREEDY_MV
7322 if (gf_group_index == 1 &&
7323 cpi->twopass.gf_group.update_type[gf_group_index] == ARF_UPDATE &&
7324 cpi->sf.enable_tpl_model) {
7325 init_tpl_buffer(cpi);
7326 vp9_estimate_qp_gop(cpi);
7327 setup_tpl_stats(cpi);
7330 #if CONFIG_BITSTREAM_DEBUG
7331 assert(cpi->oxcf.max_threads == 0 &&
7332 "bitstream debug tool does not support multithreading");
7333 bitstream_queue_record_write();
7335 #if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
7336 bitstream_queue_set_frame_write(cm->current_video_frame * 2 + cm->show_frame);
7339 cpi->td.mb.fp_src_pred = 0;
7340 #if CONFIG_REALTIME_ONLY
7342 SvcEncode(cpi, size, dest, frame_flags);
7345 Pass0Encode(cpi, size, dest, frame_flags);
7347 #else // !CONFIG_REALTIME_ONLY
7348 if (oxcf->pass == 1 && !cpi->use_svc) {
7349 const int lossless = is_lossless_requested(oxcf);
7350 #if CONFIG_VP9_HIGHBITDEPTH
7351 if (cpi->oxcf.use_highbitdepth)
7352 cpi->td.mb.fwd_txfm4x4 =
7353 lossless ? vp9_highbd_fwht4x4 : vpx_highbd_fdct4x4;
7355 cpi->td.mb.fwd_txfm4x4 = lossless ? vp9_fwht4x4 : vpx_fdct4x4;
7356 cpi->td.mb.highbd_inv_txfm_add =
7357 lossless ? vp9_highbd_iwht4x4_add : vp9_highbd_idct4x4_add;
7359 cpi->td.mb.fwd_txfm4x4 = lossless ? vp9_fwht4x4 : vpx_fdct4x4;
7360 #endif // CONFIG_VP9_HIGHBITDEPTH
7361 cpi->td.mb.inv_txfm_add = lossless ? vp9_iwht4x4_add : vp9_idct4x4_add;
7362 vp9_first_pass(cpi, source);
7363 } else if (oxcf->pass == 2 && !cpi->use_svc) {
7364 Pass2Encode(cpi, size, dest, frame_flags);
7365 } else if (cpi->use_svc) {
7366 SvcEncode(cpi, size, dest, frame_flags);
7369 Pass0Encode(cpi, size, dest, frame_flags);
7371 #endif // CONFIG_REALTIME_ONLY
7373 if (cm->show_frame) cm->cur_show_frame_fb_idx = cm->new_fb_idx;
7375 if (cm->refresh_frame_context)
7376 cm->frame_contexts[cm->frame_context_idx] = *cm->fc;
7378 // No frame encoded, or frame was dropped, release scaled references.
7379 if ((*size == 0) && (frame_is_intra_only(cm) == 0)) {
7380 release_scaled_references(cpi);
7384 cpi->droppable = !frame_is_reference(cpi);
7387 // Save layer specific state.
7388 if (is_one_pass_cbr_svc(cpi) || ((cpi->svc.number_temporal_layers > 1 ||
7389 cpi->svc.number_spatial_layers > 1) &&
7391 vp9_save_layer_context(cpi);
7394 vpx_usec_timer_mark(&cmptimer);
7395 cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
7397 if (cpi->keep_level_stats && oxcf->pass != 1)
7398 update_level_info(cpi, size, arf_src_index);
7400 #if CONFIG_INTERNAL_STATS
7402 if (oxcf->pass != 1) {
7403 double samples = 0.0;
7404 cpi->bytes += (int)(*size);
7406 if (cm->show_frame) {
7407 uint32_t bit_depth = 8;
7408 uint32_t in_bit_depth = 8;
7410 #if CONFIG_VP9_HIGHBITDEPTH
7411 if (cm->use_highbitdepth) {
7412 in_bit_depth = cpi->oxcf.input_bit_depth;
7413 bit_depth = cm->bit_depth;
7417 if (cpi->b_calculate_psnr) {
7418 YV12_BUFFER_CONFIG *orig = cpi->raw_source_frame;
7419 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
7420 YV12_BUFFER_CONFIG *pp = &cm->post_proc_buffer;
7422 #if CONFIG_VP9_HIGHBITDEPTH
7423 vpx_calc_highbd_psnr(orig, recon, &psnr, cpi->td.mb.e_mbd.bd,
7426 vpx_calc_psnr(orig, recon, &psnr);
7427 #endif // CONFIG_VP9_HIGHBITDEPTH
7429 adjust_image_stat(psnr.psnr[1], psnr.psnr[2], psnr.psnr[3],
7430 psnr.psnr[0], &cpi->psnr);
7431 cpi->total_sq_error += psnr.sse[0];
7432 cpi->total_samples += psnr.samples[0];
7433 samples = psnr.samples[0];
7437 double frame_ssim2 = 0, weight = 0;
7438 #if CONFIG_VP9_POSTPROC
7439 if (vpx_alloc_frame_buffer(
7440 pp, recon->y_crop_width, recon->y_crop_height,
7441 cm->subsampling_x, cm->subsampling_y,
7442 #if CONFIG_VP9_HIGHBITDEPTH
7443 cm->use_highbitdepth,
7445 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment) < 0) {
7446 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
7447 "Failed to allocate post processing buffer");
7450 vp9_ppflags_t ppflags;
7451 ppflags.post_proc_flag = VP9D_DEBLOCK;
7452 ppflags.deblocking_level = 0; // not used in vp9_post_proc_frame()
7453 ppflags.noise_level = 0; // not used in vp9_post_proc_frame()
7454 vp9_post_proc_frame(cm, pp, &ppflags,
7455 cpi->un_scaled_source->y_width);
7458 vpx_clear_system_state();
7460 #if CONFIG_VP9_HIGHBITDEPTH
7461 vpx_calc_highbd_psnr(orig, pp, &psnr2, cpi->td.mb.e_mbd.bd,
7462 cpi->oxcf.input_bit_depth);
7464 vpx_calc_psnr(orig, pp, &psnr2);
7465 #endif // CONFIG_VP9_HIGHBITDEPTH
7467 cpi->totalp_sq_error += psnr2.sse[0];
7468 cpi->totalp_samples += psnr2.samples[0];
7469 adjust_image_stat(psnr2.psnr[1], psnr2.psnr[2], psnr2.psnr[3],
7470 psnr2.psnr[0], &cpi->psnrp);
7472 #if CONFIG_VP9_HIGHBITDEPTH
7473 if (cm->use_highbitdepth) {
7474 frame_ssim2 = vpx_highbd_calc_ssim(orig, recon, &weight, bit_depth,
7477 frame_ssim2 = vpx_calc_ssim(orig, recon, &weight);
7480 frame_ssim2 = vpx_calc_ssim(orig, recon, &weight);
7481 #endif // CONFIG_VP9_HIGHBITDEPTH
7483 cpi->worst_ssim = VPXMIN(cpi->worst_ssim, frame_ssim2);
7484 cpi->summed_quality += frame_ssim2 * weight;
7485 cpi->summed_weights += weight;
7487 #if CONFIG_VP9_HIGHBITDEPTH
7488 if (cm->use_highbitdepth) {
7489 frame_ssim2 = vpx_highbd_calc_ssim(orig, pp, &weight, bit_depth,
7492 frame_ssim2 = vpx_calc_ssim(orig, pp, &weight);
7495 frame_ssim2 = vpx_calc_ssim(orig, pp, &weight);
7496 #endif // CONFIG_VP9_HIGHBITDEPTH
7498 cpi->summedp_quality += frame_ssim2 * weight;
7499 cpi->summedp_weights += weight;
7501 if (cm->show_frame) {
7502 FILE *f = fopen("q_used.stt", "a");
7503 fprintf(f, "%5d : Y%f7.3:U%f7.3:V%f7.3:F%f7.3:S%7.3f\n",
7504 cpi->common.current_video_frame, psnr2.psnr[1],
7505 psnr2.psnr[2], psnr2.psnr[3], psnr2.psnr[0], frame_ssim2);
7511 if (cpi->b_calculate_blockiness) {
7512 #if CONFIG_VP9_HIGHBITDEPTH
7513 if (!cm->use_highbitdepth)
7516 double frame_blockiness = vp9_get_blockiness(
7517 cpi->Source->y_buffer, cpi->Source->y_stride,
7518 cm->frame_to_show->y_buffer, cm->frame_to_show->y_stride,
7519 cpi->Source->y_width, cpi->Source->y_height);
7520 cpi->worst_blockiness =
7521 VPXMAX(cpi->worst_blockiness, frame_blockiness);
7522 cpi->total_blockiness += frame_blockiness;
7526 if (cpi->b_calculate_consistency) {
7527 #if CONFIG_VP9_HIGHBITDEPTH
7528 if (!cm->use_highbitdepth)
7531 double this_inconsistency = vpx_get_ssim_metrics(
7532 cpi->Source->y_buffer, cpi->Source->y_stride,
7533 cm->frame_to_show->y_buffer, cm->frame_to_show->y_stride,
7534 cpi->Source->y_width, cpi->Source->y_height, cpi->ssim_vars,
7537 const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1);
7538 double consistency =
7539 vpx_sse_to_psnr(samples, peak, (double)cpi->total_inconsistency);
7540 if (consistency > 0.0)
7541 cpi->worst_consistency =
7542 VPXMIN(cpi->worst_consistency, consistency);
7543 cpi->total_inconsistency += this_inconsistency;
7548 double y, u, v, frame_all;
7549 frame_all = vpx_calc_fastssim(cpi->Source, cm->frame_to_show, &y, &u,
7550 &v, bit_depth, in_bit_depth);
7551 adjust_image_stat(y, u, v, frame_all, &cpi->fastssim);
7554 double y, u, v, frame_all;
7555 frame_all = vpx_psnrhvs(cpi->Source, cm->frame_to_show, &y, &u, &v,
7556 bit_depth, in_bit_depth);
7557 adjust_image_stat(y, u, v, frame_all, &cpi->psnrhvs);
7564 if (is_one_pass_cbr_svc(cpi)) {
7565 if (cm->show_frame) {
7566 ++cpi->svc.spatial_layer_to_encode;
7567 if (cpi->svc.spatial_layer_to_encode >= cpi->svc.number_spatial_layers)
7568 cpi->svc.spatial_layer_to_encode = 0;
7572 vpx_clear_system_state();
7576 int vp9_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest,
7577 vp9_ppflags_t *flags) {
7578 VP9_COMMON *cm = &cpi->common;
7579 #if !CONFIG_VP9_POSTPROC
7583 if (!cm->show_frame) {
7587 #if CONFIG_VP9_POSTPROC
7588 ret = vp9_post_proc_frame(cm, dest, flags, cpi->un_scaled_source->y_width);
7590 if (cm->frame_to_show) {
7591 *dest = *cm->frame_to_show;
7592 dest->y_width = cm->width;
7593 dest->y_height = cm->height;
7594 dest->uv_width = cm->width >> cm->subsampling_x;
7595 dest->uv_height = cm->height >> cm->subsampling_y;
7600 #endif // !CONFIG_VP9_POSTPROC
7601 vpx_clear_system_state();
7606 int vp9_set_internal_size(VP9_COMP *cpi, VPX_SCALING horiz_mode,
7607 VPX_SCALING vert_mode) {
7608 VP9_COMMON *cm = &cpi->common;
7609 int hr = 0, hs = 0, vr = 0, vs = 0;
7611 if (horiz_mode > ONETWO || vert_mode > ONETWO) return -1;
7613 Scale2Ratio(horiz_mode, &hr, &hs);
7614 Scale2Ratio(vert_mode, &vr, &vs);
7616 // always go to the next whole number
7617 cm->width = (hs - 1 + cpi->oxcf.width * hr) / hs;
7618 cm->height = (vs - 1 + cpi->oxcf.height * vr) / vs;
7619 if (cm->current_video_frame) {
7620 assert(cm->width <= cpi->initial_width);
7621 assert(cm->height <= cpi->initial_height);
7624 update_frame_size(cpi);
7629 int vp9_set_size_literal(VP9_COMP *cpi, unsigned int width,
7630 unsigned int height) {
7631 VP9_COMMON *cm = &cpi->common;
7632 #if CONFIG_VP9_HIGHBITDEPTH
7633 update_initial_width(cpi, cm->use_highbitdepth, 1, 1);
7635 update_initial_width(cpi, 0, 1, 1);
7636 #endif // CONFIG_VP9_HIGHBITDEPTH
7638 #if CONFIG_VP9_TEMPORAL_DENOISING
7639 setup_denoiser_buffer(cpi);
7641 alloc_raw_frame_buffers(cpi);
7644 if (cm->width > cpi->initial_width) {
7645 cm->width = cpi->initial_width;
7646 printf("Warning: Desired width too large, changed to %d\n", cm->width);
7651 cm->height = height;
7652 if (cm->height > cpi->initial_height) {
7653 cm->height = cpi->initial_height;
7654 printf("Warning: Desired height too large, changed to %d\n", cm->height);
7657 assert(cm->width <= cpi->initial_width);
7658 assert(cm->height <= cpi->initial_height);
7660 update_frame_size(cpi);
7665 void vp9_set_svc(VP9_COMP *cpi, int use_svc) {
7666 cpi->use_svc = use_svc;
7670 int vp9_get_quantizer(VP9_COMP *cpi) { return cpi->common.base_qindex; }
7672 void vp9_apply_encoding_flags(VP9_COMP *cpi, vpx_enc_frame_flags_t flags) {
7674 (VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF)) {
7677 if (flags & VP8_EFLAG_NO_REF_LAST) ref ^= VP9_LAST_FLAG;
7679 if (flags & VP8_EFLAG_NO_REF_GF) ref ^= VP9_GOLD_FLAG;
7681 if (flags & VP8_EFLAG_NO_REF_ARF) ref ^= VP9_ALT_FLAG;
7683 vp9_use_as_reference(cpi, ref);
7687 (VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
7688 VP8_EFLAG_FORCE_GF | VP8_EFLAG_FORCE_ARF)) {
7691 if (flags & VP8_EFLAG_NO_UPD_LAST) upd ^= VP9_LAST_FLAG;
7693 if (flags & VP8_EFLAG_NO_UPD_GF) upd ^= VP9_GOLD_FLAG;
7695 if (flags & VP8_EFLAG_NO_UPD_ARF) upd ^= VP9_ALT_FLAG;
7697 vp9_update_reference(cpi, upd);
7700 if (flags & VP8_EFLAG_NO_UPD_ENTROPY) {
7701 vp9_update_entropy(cpi, 0);
7705 void vp9_set_row_mt(VP9_COMP *cpi) {
7706 // Enable row based multi-threading for supported modes of encoding
7708 if (((cpi->oxcf.mode == GOOD || cpi->oxcf.mode == BEST) &&
7709 cpi->oxcf.speed < 5 && cpi->oxcf.pass == 1) &&
7710 cpi->oxcf.row_mt && !cpi->use_svc)
7713 if (cpi->oxcf.mode == GOOD && cpi->oxcf.speed < 5 &&
7714 (cpi->oxcf.pass == 0 || cpi->oxcf.pass == 2) && cpi->oxcf.row_mt &&
7718 // In realtime mode, enable row based multi-threading for all the speed levels
7719 // where non-rd path is used.
7720 if (cpi->oxcf.mode == REALTIME && cpi->oxcf.speed >= 5 && cpi->oxcf.row_mt) {
7725 cpi->row_mt_bit_exact = 1;
7727 cpi->row_mt_bit_exact = 0;