1 /* 2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved. 3 * 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. 9 */ 10 11 #include <math.h> 12 #include <stdio.h> 13 #include <limits.h> 14 15 #include "./vp9_rtcd.h" 16 #include "./vpx_config.h" 17 #include "./vpx_dsp_rtcd.h" 18 #include "./vpx_scale_rtcd.h" 19 #include "vpx_dsp/psnr.h" 20 #include "vpx_dsp/vpx_dsp_common.h" 21 #include "vpx_dsp/vpx_filter.h" 22 #if CONFIG_INTERNAL_STATS 23 #include "vpx_dsp/ssim.h" 24 #endif 25 #include "vpx_ports/mem.h" 26 #include "vpx_ports/system_state.h" 27 #include "vpx_ports/vpx_timer.h" 28 29 #include "vp9/common/vp9_alloccommon.h" 30 #include "vp9/common/vp9_filter.h" 31 #include "vp9/common/vp9_idct.h" 32 #if CONFIG_VP9_POSTPROC 33 #include "vp9/common/vp9_postproc.h" 34 #endif 35 #include "vp9/common/vp9_reconinter.h" 36 #include "vp9/common/vp9_reconintra.h" 37 #include "vp9/common/vp9_tile_common.h" 38 #include "vp9/common/vp9_scan.h" 39 40 #include "vp9/encoder/vp9_alt_ref_aq.h" 41 #include "vp9/encoder/vp9_aq_360.h" 42 #include "vp9/encoder/vp9_aq_complexity.h" 43 #include "vp9/encoder/vp9_aq_cyclicrefresh.h" 44 #include "vp9/encoder/vp9_aq_variance.h" 45 #include "vp9/encoder/vp9_bitstream.h" 46 #if CONFIG_INTERNAL_STATS 47 #include "vp9/encoder/vp9_blockiness.h" 48 #endif 49 #include "vp9/encoder/vp9_context_tree.h" 50 #include "vp9/encoder/vp9_encodeframe.h" 51 #include "vp9/encoder/vp9_encodemb.h" 52 #include "vp9/encoder/vp9_encodemv.h" 53 #include "vp9/encoder/vp9_encoder.h" 54 #include "vp9/encoder/vp9_ethread.h" 55 #include "vp9/encoder/vp9_extend.h" 56 #include "vp9/encoder/vp9_firstpass.h" 57 #include "vp9/encoder/vp9_mbgraph.h" 58 #if CONFIG_NON_GREEDY_MV 59 #include "vp9/encoder/vp9_mcomp.h" 60 #endif 61 #include "vp9/encoder/vp9_multi_thread.h" 62 #include "vp9/encoder/vp9_noise_estimate.h" 63 #include "vp9/encoder/vp9_picklpf.h" 64 #include "vp9/encoder/vp9_ratectrl.h" 65 #include "vp9/encoder/vp9_rd.h" 66 #include "vp9/encoder/vp9_resize.h" 67 #include "vp9/encoder/vp9_segmentation.h" 68 #include "vp9/encoder/vp9_skin_detection.h" 69 #include "vp9/encoder/vp9_speed_features.h" 70 #include "vp9/encoder/vp9_svc_layercontext.h" 71 #include "vp9/encoder/vp9_temporal_filter.h" 72 73 #define AM_SEGMENT_ID_INACTIVE 7 74 #define AM_SEGMENT_ID_ACTIVE 0 75 76 // Whether to use high precision mv for altref computation. 77 #define ALTREF_HIGH_PRECISION_MV 1 78 79 // Q threshold for high precision mv. Choose a very high value for now so that 80 // HIGH_PRECISION is always chosen. 81 #define HIGH_PRECISION_MV_QTHRESH 200 82 83 #define FRAME_SIZE_FACTOR 128 // empirical params for context model threshold 84 #define FRAME_RATE_FACTOR 8 85 86 #ifdef OUTPUT_YUV_DENOISED 87 FILE *yuv_denoised_file = NULL; 88 #endif 89 #ifdef OUTPUT_YUV_SKINMAP 90 static FILE *yuv_skinmap_file = NULL; 91 #endif 92 #ifdef OUTPUT_YUV_REC 93 FILE *yuv_rec_file; 94 #endif 95 #ifdef OUTPUT_YUV_SVC_SRC 96 FILE *yuv_svc_src[3] = { NULL, NULL, NULL }; 97 #endif 98 99 #if 0 100 FILE *framepsnr; 101 FILE *kf_list; 102 FILE *keyfile; 103 #endif 104 105 #ifdef ENABLE_KF_DENOISE 106 // Test condition for spatial denoise of source. 107 static int is_spatial_denoise_enabled(VP9_COMP *cpi) { 108 VP9_COMMON *const cm = &cpi->common; 109 const VP9EncoderConfig *const oxcf = &cpi->oxcf; 110 111 return (oxcf->pass != 1) && !is_lossless_requested(&cpi->oxcf) && 112 frame_is_intra_only(cm); 113 } 114 #endif 115 116 // compute adaptive threshold for skip recoding 117 static int compute_context_model_thresh(const VP9_COMP *const cpi) { 118 const VP9_COMMON *const cm = &cpi->common; 119 const VP9EncoderConfig *const oxcf = &cpi->oxcf; 120 const int frame_size = (cm->width * cm->height) >> 10; 121 const int bitrate = (int)(oxcf->target_bandwidth >> 10); 122 const int qindex_factor = cm->base_qindex + (MAXQ >> 1); 123 124 // This equation makes the threshold adaptive to frame size. 125 // Coding gain obtained by recoding comes from alternate frames of large 126 // content change. We skip recoding if the difference of previous and current 127 // frame context probability model is less than a certain threshold. 128 // The first component is the most critical part to guarantee adaptivity. 129 // Other parameters are estimated based on normal setting of hd resolution 130 // parameters. e.g frame_size = 1920x1080, bitrate = 8000, qindex_factor < 50 131 const int thresh = 132 ((FRAME_SIZE_FACTOR * frame_size - FRAME_RATE_FACTOR * bitrate) * 133 qindex_factor) >> 134 9; 135 136 return thresh; 137 } 138 139 // compute the total cost difference between current 140 // and previous frame context prob model. 141 static int compute_context_model_diff(const VP9_COMMON *const cm) { 142 const FRAME_CONTEXT *const pre_fc = 143 &cm->frame_contexts[cm->frame_context_idx]; 144 const FRAME_CONTEXT *const cur_fc = cm->fc; 145 const FRAME_COUNTS *counts = &cm->counts; 146 vpx_prob pre_last_prob, cur_last_prob; 147 int diff = 0; 148 int i, j, k, l, m, n; 149 150 // y_mode_prob 151 for (i = 0; i < BLOCK_SIZE_GROUPS; ++i) { 152 for (j = 0; j < INTRA_MODES - 1; ++j) { 153 diff += (int)counts->y_mode[i][j] * 154 (pre_fc->y_mode_prob[i][j] - cur_fc->y_mode_prob[i][j]); 155 } 156 pre_last_prob = MAX_PROB - pre_fc->y_mode_prob[i][INTRA_MODES - 2]; 157 cur_last_prob = MAX_PROB - cur_fc->y_mode_prob[i][INTRA_MODES - 2]; 158 159 diff += (int)counts->y_mode[i][INTRA_MODES - 1] * 160 (pre_last_prob - cur_last_prob); 161 } 162 163 // uv_mode_prob 164 for (i = 0; i < INTRA_MODES; ++i) { 165 for (j = 0; j < INTRA_MODES - 1; ++j) { 166 diff += (int)counts->uv_mode[i][j] * 167 (pre_fc->uv_mode_prob[i][j] - cur_fc->uv_mode_prob[i][j]); 168 } 169 pre_last_prob = MAX_PROB - pre_fc->uv_mode_prob[i][INTRA_MODES - 2]; 170 cur_last_prob = MAX_PROB - cur_fc->uv_mode_prob[i][INTRA_MODES - 2]; 171 172 diff += (int)counts->uv_mode[i][INTRA_MODES - 1] * 173 (pre_last_prob - cur_last_prob); 174 } 175 176 // partition_prob 177 for (i = 0; i < PARTITION_CONTEXTS; ++i) { 178 for (j = 0; j < PARTITION_TYPES - 1; ++j) { 179 diff += (int)counts->partition[i][j] * 180 (pre_fc->partition_prob[i][j] - cur_fc->partition_prob[i][j]); 181 } 182 pre_last_prob = MAX_PROB - pre_fc->partition_prob[i][PARTITION_TYPES - 2]; 183 cur_last_prob = MAX_PROB - cur_fc->partition_prob[i][PARTITION_TYPES - 2]; 184 185 diff += (int)counts->partition[i][PARTITION_TYPES - 1] * 186 (pre_last_prob - cur_last_prob); 187 } 188 189 // coef_probs 190 for (i = 0; i < TX_SIZES; ++i) { 191 for (j = 0; j < PLANE_TYPES; ++j) { 192 for (k = 0; k < REF_TYPES; ++k) { 193 for (l = 0; l < COEF_BANDS; ++l) { 194 for (m = 0; m < BAND_COEFF_CONTEXTS(l); ++m) { 195 for (n = 0; n < UNCONSTRAINED_NODES; ++n) { 196 diff += (int)counts->coef[i][j][k][l][m][n] * 197 (pre_fc->coef_probs[i][j][k][l][m][n] - 198 cur_fc->coef_probs[i][j][k][l][m][n]); 199 } 200 201 pre_last_prob = 202 MAX_PROB - 203 pre_fc->coef_probs[i][j][k][l][m][UNCONSTRAINED_NODES - 1]; 204 cur_last_prob = 205 MAX_PROB - 206 cur_fc->coef_probs[i][j][k][l][m][UNCONSTRAINED_NODES - 1]; 207 208 diff += (int)counts->coef[i][j][k][l][m][UNCONSTRAINED_NODES] * 209 (pre_last_prob - cur_last_prob); 210 } 211 } 212 } 213 } 214 } 215 216 // switchable_interp_prob 217 for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i) { 218 for (j = 0; j < SWITCHABLE_FILTERS - 1; ++j) { 219 diff += (int)counts->switchable_interp[i][j] * 220 (pre_fc->switchable_interp_prob[i][j] - 221 cur_fc->switchable_interp_prob[i][j]); 222 } 223 pre_last_prob = 224 MAX_PROB - pre_fc->switchable_interp_prob[i][SWITCHABLE_FILTERS - 2]; 225 cur_last_prob = 226 MAX_PROB - cur_fc->switchable_interp_prob[i][SWITCHABLE_FILTERS - 2]; 227 228 diff += (int)counts->switchable_interp[i][SWITCHABLE_FILTERS - 1] * 229 (pre_last_prob - cur_last_prob); 230 } 231 232 // inter_mode_probs 233 for (i = 0; i < INTER_MODE_CONTEXTS; ++i) { 234 for (j = 0; j < INTER_MODES - 1; ++j) { 235 diff += (int)counts->inter_mode[i][j] * 236 (pre_fc->inter_mode_probs[i][j] - cur_fc->inter_mode_probs[i][j]); 237 } 238 pre_last_prob = MAX_PROB - pre_fc->inter_mode_probs[i][INTER_MODES - 2]; 239 cur_last_prob = MAX_PROB - cur_fc->inter_mode_probs[i][INTER_MODES - 2]; 240 241 diff += (int)counts->inter_mode[i][INTER_MODES - 1] * 242 (pre_last_prob - cur_last_prob); 243 } 244 245 // intra_inter_prob 246 for (i = 0; i < INTRA_INTER_CONTEXTS; ++i) { 247 diff += (int)counts->intra_inter[i][0] * 248 (pre_fc->intra_inter_prob[i] - cur_fc->intra_inter_prob[i]); 249 250 pre_last_prob = MAX_PROB - pre_fc->intra_inter_prob[i]; 251 cur_last_prob = MAX_PROB - cur_fc->intra_inter_prob[i]; 252 253 diff += (int)counts->intra_inter[i][1] * (pre_last_prob - cur_last_prob); 254 } 255 256 // comp_inter_prob 257 for (i = 0; i < COMP_INTER_CONTEXTS; ++i) { 258 diff += (int)counts->comp_inter[i][0] * 259 (pre_fc->comp_inter_prob[i] - cur_fc->comp_inter_prob[i]); 260 261 pre_last_prob = MAX_PROB - pre_fc->comp_inter_prob[i]; 262 cur_last_prob = MAX_PROB - cur_fc->comp_inter_prob[i]; 263 264 diff += (int)counts->comp_inter[i][1] * (pre_last_prob - cur_last_prob); 265 } 266 267 // single_ref_prob 268 for (i = 0; i < REF_CONTEXTS; ++i) { 269 for (j = 0; j < 2; ++j) { 270 diff += (int)counts->single_ref[i][j][0] * 271 (pre_fc->single_ref_prob[i][j] - cur_fc->single_ref_prob[i][j]); 272 273 pre_last_prob = MAX_PROB - pre_fc->single_ref_prob[i][j]; 274 cur_last_prob = MAX_PROB - cur_fc->single_ref_prob[i][j]; 275 276 diff += 277 (int)counts->single_ref[i][j][1] * (pre_last_prob - cur_last_prob); 278 } 279 } 280 281 // comp_ref_prob 282 for (i = 0; i < REF_CONTEXTS; ++i) { 283 diff += (int)counts->comp_ref[i][0] * 284 (pre_fc->comp_ref_prob[i] - cur_fc->comp_ref_prob[i]); 285 286 pre_last_prob = MAX_PROB - pre_fc->comp_ref_prob[i]; 287 cur_last_prob = MAX_PROB - cur_fc->comp_ref_prob[i]; 288 289 diff += (int)counts->comp_ref[i][1] * (pre_last_prob - cur_last_prob); 290 } 291 292 // tx_probs 293 for (i = 0; i < TX_SIZE_CONTEXTS; ++i) { 294 // p32x32 295 for (j = 0; j < TX_SIZES - 1; ++j) { 296 diff += (int)counts->tx.p32x32[i][j] * 297 (pre_fc->tx_probs.p32x32[i][j] - cur_fc->tx_probs.p32x32[i][j]); 298 } 299 pre_last_prob = MAX_PROB - pre_fc->tx_probs.p32x32[i][TX_SIZES - 2]; 300 cur_last_prob = MAX_PROB - cur_fc->tx_probs.p32x32[i][TX_SIZES - 2]; 301 302 diff += (int)counts->tx.p32x32[i][TX_SIZES - 1] * 303 (pre_last_prob - cur_last_prob); 304 305 // p16x16 306 for (j = 0; j < TX_SIZES - 2; ++j) { 307 diff += (int)counts->tx.p16x16[i][j] * 308 (pre_fc->tx_probs.p16x16[i][j] - cur_fc->tx_probs.p16x16[i][j]); 309 } 310 pre_last_prob = MAX_PROB - pre_fc->tx_probs.p16x16[i][TX_SIZES - 3]; 311 cur_last_prob = MAX_PROB - cur_fc->tx_probs.p16x16[i][TX_SIZES - 3]; 312 313 diff += (int)counts->tx.p16x16[i][TX_SIZES - 2] * 314 (pre_last_prob - cur_last_prob); 315 316 // p8x8 317 for (j = 0; j < TX_SIZES - 3; ++j) { 318 diff += (int)counts->tx.p8x8[i][j] * 319 (pre_fc->tx_probs.p8x8[i][j] - cur_fc->tx_probs.p8x8[i][j]); 320 } 321 pre_last_prob = MAX_PROB - pre_fc->tx_probs.p8x8[i][TX_SIZES - 4]; 322 cur_last_prob = MAX_PROB - cur_fc->tx_probs.p8x8[i][TX_SIZES - 4]; 323 324 diff += 325 (int)counts->tx.p8x8[i][TX_SIZES - 3] * (pre_last_prob - cur_last_prob); 326 } 327 328 // skip_probs 329 for (i = 0; i < SKIP_CONTEXTS; ++i) { 330 diff += (int)counts->skip[i][0] * 331 (pre_fc->skip_probs[i] - cur_fc->skip_probs[i]); 332 333 pre_last_prob = MAX_PROB - pre_fc->skip_probs[i]; 334 cur_last_prob = MAX_PROB - cur_fc->skip_probs[i]; 335 336 diff += (int)counts->skip[i][1] * (pre_last_prob - cur_last_prob); 337 } 338 339 // mv 340 for (i = 0; i < MV_JOINTS - 1; ++i) { 341 diff += (int)counts->mv.joints[i] * 342 (pre_fc->nmvc.joints[i] - cur_fc->nmvc.joints[i]); 343 } 344 pre_last_prob = MAX_PROB - pre_fc->nmvc.joints[MV_JOINTS - 2]; 345 cur_last_prob = MAX_PROB - cur_fc->nmvc.joints[MV_JOINTS - 2]; 346 347 diff += 348 (int)counts->mv.joints[MV_JOINTS - 1] * (pre_last_prob - cur_last_prob); 349 350 for (i = 0; i < 2; ++i) { 351 const nmv_component_counts *nmv_count = &counts->mv.comps[i]; 352 const nmv_component *pre_nmv_prob = &pre_fc->nmvc.comps[i]; 353 const nmv_component *cur_nmv_prob = &cur_fc->nmvc.comps[i]; 354 355 // sign 356 diff += (int)nmv_count->sign[0] * (pre_nmv_prob->sign - cur_nmv_prob->sign); 357 358 pre_last_prob = MAX_PROB - pre_nmv_prob->sign; 359 cur_last_prob = MAX_PROB - cur_nmv_prob->sign; 360 361 diff += (int)nmv_count->sign[1] * (pre_last_prob - cur_last_prob); 362 363 // classes 364 for (j = 0; j < MV_CLASSES - 1; ++j) { 365 diff += (int)nmv_count->classes[j] * 366 (pre_nmv_prob->classes[j] - cur_nmv_prob->classes[j]); 367 } 368 pre_last_prob = MAX_PROB - pre_nmv_prob->classes[MV_CLASSES - 2]; 369 cur_last_prob = MAX_PROB - cur_nmv_prob->classes[MV_CLASSES - 2]; 370 371 diff += (int)nmv_count->classes[MV_CLASSES - 1] * 372 (pre_last_prob - cur_last_prob); 373 374 // class0 375 for (j = 0; j < CLASS0_SIZE - 1; ++j) { 376 diff += (int)nmv_count->class0[j] * 377 (pre_nmv_prob->class0[j] - cur_nmv_prob->class0[j]); 378 } 379 pre_last_prob = MAX_PROB - pre_nmv_prob->class0[CLASS0_SIZE - 2]; 380 cur_last_prob = MAX_PROB - cur_nmv_prob->class0[CLASS0_SIZE - 2]; 381 382 diff += (int)nmv_count->class0[CLASS0_SIZE - 1] * 383 (pre_last_prob - cur_last_prob); 384 385 // bits 386 for (j = 0; j < MV_OFFSET_BITS; ++j) { 387 diff += (int)nmv_count->bits[j][0] * 388 (pre_nmv_prob->bits[j] - cur_nmv_prob->bits[j]); 389 390 pre_last_prob = MAX_PROB - pre_nmv_prob->bits[j]; 391 cur_last_prob = MAX_PROB - cur_nmv_prob->bits[j]; 392 393 diff += (int)nmv_count->bits[j][1] * (pre_last_prob - cur_last_prob); 394 } 395 396 // class0_fp 397 for (j = 0; j < CLASS0_SIZE; ++j) { 398 for (k = 0; k < MV_FP_SIZE - 1; ++k) { 399 diff += (int)nmv_count->class0_fp[j][k] * 400 (pre_nmv_prob->class0_fp[j][k] - cur_nmv_prob->class0_fp[j][k]); 401 } 402 pre_last_prob = MAX_PROB - pre_nmv_prob->class0_fp[j][MV_FP_SIZE - 2]; 403 cur_last_prob = MAX_PROB - cur_nmv_prob->class0_fp[j][MV_FP_SIZE - 2]; 404 405 diff += (int)nmv_count->class0_fp[j][MV_FP_SIZE - 1] * 406 (pre_last_prob - cur_last_prob); 407 } 408 409 // fp 410 for (j = 0; j < MV_FP_SIZE - 1; ++j) { 411 diff += 412 (int)nmv_count->fp[j] * (pre_nmv_prob->fp[j] - cur_nmv_prob->fp[j]); 413 } 414 pre_last_prob = MAX_PROB - pre_nmv_prob->fp[MV_FP_SIZE - 2]; 415 cur_last_prob = MAX_PROB - cur_nmv_prob->fp[MV_FP_SIZE - 2]; 416 417 diff += 418 (int)nmv_count->fp[MV_FP_SIZE - 1] * (pre_last_prob - cur_last_prob); 419 420 // class0_hp 421 diff += (int)nmv_count->class0_hp[0] * 422 (pre_nmv_prob->class0_hp - cur_nmv_prob->class0_hp); 423 424 pre_last_prob = MAX_PROB - pre_nmv_prob->class0_hp; 425 cur_last_prob = MAX_PROB - cur_nmv_prob->class0_hp; 426 427 diff += (int)nmv_count->class0_hp[1] * (pre_last_prob - cur_last_prob); 428 429 // hp 430 diff += (int)nmv_count->hp[0] * (pre_nmv_prob->hp - cur_nmv_prob->hp); 431 432 pre_last_prob = MAX_PROB - pre_nmv_prob->hp; 433 cur_last_prob = MAX_PROB - cur_nmv_prob->hp; 434 435 diff += (int)nmv_count->hp[1] * (pre_last_prob - cur_last_prob); 436 } 437 438 return -diff; 439 } 440 441 // Test for whether to calculate metrics for the frame. 442 static int is_psnr_calc_enabled(VP9_COMP *cpi) { 443 VP9_COMMON *const cm = &cpi->common; 444 const VP9EncoderConfig *const oxcf = &cpi->oxcf; 445 446 return cpi->b_calculate_psnr && (oxcf->pass != 1) && cm->show_frame; 447 } 448 449 /* clang-format off */ 450 const Vp9LevelSpec vp9_level_defs[VP9_LEVELS] = { 451 // sample rate size breadth bitrate cpb 452 { LEVEL_1, 829440, 36864, 512, 200, 400, 2, 1, 4, 8 }, 453 { LEVEL_1_1, 2764800, 73728, 768, 800, 1000, 2, 1, 4, 8 }, 454 { LEVEL_2, 4608000, 122880, 960, 1800, 1500, 2, 1, 4, 8 }, 455 { LEVEL_2_1, 9216000, 245760, 1344, 3600, 2800, 2, 2, 4, 8 }, 456 { LEVEL_3, 20736000, 552960, 2048, 7200, 6000, 2, 4, 4, 8 }, 457 { LEVEL_3_1, 36864000, 983040, 2752, 12000, 10000, 2, 4, 4, 8 }, 458 { LEVEL_4, 83558400, 2228224, 4160, 18000, 16000, 4, 4, 4, 8 }, 459 { LEVEL_4_1, 160432128, 2228224, 4160, 30000, 18000, 4, 4, 5, 6 }, 460 { LEVEL_5, 311951360, 8912896, 8384, 60000, 36000, 6, 8, 6, 4 }, 461 { LEVEL_5_1, 588251136, 8912896, 8384, 120000, 46000, 8, 8, 10, 4 }, 462 // TODO(huisu): update max_cpb_size for level 5_2 ~ 6_2 when 463 // they are finalized (currently tentative). 464 { LEVEL_5_2, 1176502272, 8912896, 8384, 180000, 90000, 8, 8, 10, 4 }, 465 { LEVEL_6, 1176502272, 35651584, 16832, 180000, 90000, 8, 16, 10, 4 }, 466 { LEVEL_6_1, 2353004544u, 35651584, 16832, 240000, 180000, 8, 16, 10, 4 }, 467 { LEVEL_6_2, 4706009088u, 35651584, 16832, 480000, 360000, 8, 16, 10, 4 }, 468 }; 469 /* clang-format on */ 470 471 static const char *level_fail_messages[TARGET_LEVEL_FAIL_IDS] = { 472 "The average bit-rate is too high.", 473 "The picture size is too large.", 474 "The picture width/height is too large.", 475 "The luma sample rate is too large.", 476 "The CPB size is too large.", 477 "The compression ratio is too small", 478 "Too many column tiles are used.", 479 "The alt-ref distance is too small.", 480 "Too many reference buffers are used." 481 }; 482 483 static INLINE void Scale2Ratio(VPX_SCALING mode, int *hr, int *hs) { 484 switch (mode) { 485 case NORMAL: 486 *hr = 1; 487 *hs = 1; 488 break; 489 case FOURFIVE: 490 *hr = 4; 491 *hs = 5; 492 break; 493 case THREEFIVE: 494 *hr = 3; 495 *hs = 5; 496 break; 497 default: 498 assert(mode == ONETWO); 499 *hr = 1; 500 *hs = 2; 501 break; 502 } 503 } 504 505 // Mark all inactive blocks as active. Other segmentation features may be set 506 // so memset cannot be used, instead only inactive blocks should be reset. 507 static void suppress_active_map(VP9_COMP *cpi) { 508 unsigned char *const seg_map = cpi->segmentation_map; 509 510 if (cpi->active_map.enabled || cpi->active_map.update) { 511 const int rows = cpi->common.mi_rows; 512 const int cols = cpi->common.mi_cols; 513 int i; 514 515 for (i = 0; i < rows * cols; ++i) 516 if (seg_map[i] == AM_SEGMENT_ID_INACTIVE) 517 seg_map[i] = AM_SEGMENT_ID_ACTIVE; 518 } 519 } 520 521 static void apply_active_map(VP9_COMP *cpi) { 522 struct segmentation *const seg = &cpi->common.seg; 523 unsigned char *const seg_map = cpi->segmentation_map; 524 const unsigned char *const active_map = cpi->active_map.map; 525 int i; 526 527 assert(AM_SEGMENT_ID_ACTIVE == CR_SEGMENT_ID_BASE); 528 529 if (frame_is_intra_only(&cpi->common)) { 530 cpi->active_map.enabled = 0; 531 cpi->active_map.update = 1; 532 } 533 534 if (cpi->active_map.update) { 535 if (cpi->active_map.enabled) { 536 for (i = 0; i < cpi->common.mi_rows * cpi->common.mi_cols; ++i) 537 if (seg_map[i] == AM_SEGMENT_ID_ACTIVE) seg_map[i] = active_map[i]; 538 vp9_enable_segmentation(seg); 539 vp9_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_SKIP); 540 vp9_enable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF); 541 // Setting the data to -MAX_LOOP_FILTER will result in the computed loop 542 // filter level being zero regardless of the value of seg->abs_delta. 543 vp9_set_segdata(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF, 544 -MAX_LOOP_FILTER); 545 } else { 546 vp9_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_SKIP); 547 vp9_disable_segfeature(seg, AM_SEGMENT_ID_INACTIVE, SEG_LVL_ALT_LF); 548 if (seg->enabled) { 549 seg->update_data = 1; 550 seg->update_map = 1; 551 } 552 } 553 cpi->active_map.update = 0; 554 } 555 } 556 557 static void apply_roi_map(VP9_COMP *cpi) { 558 VP9_COMMON *cm = &cpi->common; 559 struct segmentation *const seg = &cm->seg; 560 vpx_roi_map_t *roi = &cpi->roi; 561 const int *delta_q = roi->delta_q; 562 const int *delta_lf = roi->delta_lf; 563 const int *skip = roi->skip; 564 int ref_frame[8]; 565 int internal_delta_q[MAX_SEGMENTS]; 566 int i; 567 static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG, 568 VP9_ALT_FLAG }; 569 570 // TODO(jianj): Investigate why ROI not working in speed < 5 or in non 571 // realtime mode. 572 if (cpi->oxcf.mode != REALTIME || cpi->oxcf.speed < 5) return; 573 if (!roi->enabled) return; 574 575 memcpy(&ref_frame, roi->ref_frame, sizeof(ref_frame)); 576 577 vp9_enable_segmentation(seg); 578 vp9_clearall_segfeatures(seg); 579 // Select delta coding method; 580 seg->abs_delta = SEGMENT_DELTADATA; 581 582 memcpy(cpi->segmentation_map, roi->roi_map, (cm->mi_rows * cm->mi_cols)); 583 584 for (i = 0; i < MAX_SEGMENTS; ++i) { 585 // Translate the external delta q values to internal values. 586 internal_delta_q[i] = vp9_quantizer_to_qindex(abs(delta_q[i])); 587 if (delta_q[i] < 0) internal_delta_q[i] = -internal_delta_q[i]; 588 vp9_disable_segfeature(seg, i, SEG_LVL_ALT_Q); 589 vp9_disable_segfeature(seg, i, SEG_LVL_ALT_LF); 590 if (internal_delta_q[i] != 0) { 591 vp9_enable_segfeature(seg, i, SEG_LVL_ALT_Q); 592 vp9_set_segdata(seg, i, SEG_LVL_ALT_Q, internal_delta_q[i]); 593 } 594 if (delta_lf[i] != 0) { 595 vp9_enable_segfeature(seg, i, SEG_LVL_ALT_LF); 596 vp9_set_segdata(seg, i, SEG_LVL_ALT_LF, delta_lf[i]); 597 } 598 if (skip[i] != 0) { 599 vp9_enable_segfeature(seg, i, SEG_LVL_SKIP); 600 vp9_set_segdata(seg, i, SEG_LVL_SKIP, skip[i]); 601 } 602 if (ref_frame[i] >= 0) { 603 int valid_ref = 1; 604 // ALTREF is not used as reference for nonrd_pickmode with 0 lag. 605 if (ref_frame[i] == ALTREF_FRAME && cpi->sf.use_nonrd_pick_mode) 606 valid_ref = 0; 607 // If GOLDEN is selected, make sure it's set as reference. 608 if (ref_frame[i] == GOLDEN_FRAME && 609 !(cpi->ref_frame_flags & flag_list[ref_frame[i]])) { 610 valid_ref = 0; 611 } 612 // GOLDEN was updated in previous encoded frame, so GOLDEN and LAST are 613 // same reference. 614 if (ref_frame[i] == GOLDEN_FRAME && cpi->rc.frames_since_golden == 0) 615 ref_frame[i] = LAST_FRAME; 616 if (valid_ref) { 617 vp9_enable_segfeature(seg, i, SEG_LVL_REF_FRAME); 618 vp9_set_segdata(seg, i, SEG_LVL_REF_FRAME, ref_frame[i]); 619 } 620 } 621 } 622 roi->enabled = 1; 623 } 624 625 static void init_level_info(Vp9LevelInfo *level_info) { 626 Vp9LevelStats *const level_stats = &level_info->level_stats; 627 Vp9LevelSpec *const level_spec = &level_info->level_spec; 628 629 memset(level_stats, 0, sizeof(*level_stats)); 630 memset(level_spec, 0, sizeof(*level_spec)); 631 level_spec->level = LEVEL_UNKNOWN; 632 level_spec->min_altref_distance = INT_MAX; 633 } 634 635 static int check_seg_range(int seg_data[8], int range) { 636 return !(abs(seg_data[0]) > range || abs(seg_data[1]) > range || 637 abs(seg_data[2]) > range || abs(seg_data[3]) > range || 638 abs(seg_data[4]) > range || abs(seg_data[5]) > range || 639 abs(seg_data[6]) > range || abs(seg_data[7]) > range); 640 } 641 642 VP9_LEVEL vp9_get_level(const Vp9LevelSpec *const level_spec) { 643 int i; 644 const Vp9LevelSpec *this_level; 645 646 vpx_clear_system_state(); 647 648 for (i = 0; i < VP9_LEVELS; ++i) { 649 this_level = &vp9_level_defs[i]; 650 if ((double)level_spec->max_luma_sample_rate > 651 (double)this_level->max_luma_sample_rate * 652 (1 + SAMPLE_RATE_GRACE_P) || 653 level_spec->max_luma_picture_size > this_level->max_luma_picture_size || 654 level_spec->max_luma_picture_breadth > 655 this_level->max_luma_picture_breadth || 656 level_spec->average_bitrate > this_level->average_bitrate || 657 level_spec->max_cpb_size > this_level->max_cpb_size || 658 level_spec->compression_ratio < this_level->compression_ratio || 659 level_spec->max_col_tiles > this_level->max_col_tiles || 660 level_spec->min_altref_distance < this_level->min_altref_distance || 661 level_spec->max_ref_frame_buffers > this_level->max_ref_frame_buffers) 662 continue; 663 break; 664 } 665 return (i == VP9_LEVELS) ? LEVEL_UNKNOWN : vp9_level_defs[i].level; 666 } 667 668 int vp9_set_roi_map(VP9_COMP *cpi, unsigned char *map, unsigned int rows, 669 unsigned int cols, int delta_q[8], int delta_lf[8], 670 int skip[8], int ref_frame[8]) { 671 VP9_COMMON *cm = &cpi->common; 672 vpx_roi_map_t *roi = &cpi->roi; 673 const int range = 63; 674 const int ref_frame_range = 3; // Alt-ref 675 const int skip_range = 1; 676 const int frame_rows = cpi->common.mi_rows; 677 const int frame_cols = cpi->common.mi_cols; 678 679 // Check number of rows and columns match 680 if (frame_rows != (int)rows || frame_cols != (int)cols) { 681 return -1; 682 } 683 684 if (!check_seg_range(delta_q, range) || !check_seg_range(delta_lf, range) || 685 !check_seg_range(ref_frame, ref_frame_range) || 686 !check_seg_range(skip, skip_range)) 687 return -1; 688 689 // Also disable segmentation if no deltas are specified. 690 if (!map || 691 (!(delta_q[0] | delta_q[1] | delta_q[2] | delta_q[3] | delta_q[4] | 692 delta_q[5] | delta_q[6] | delta_q[7] | delta_lf[0] | delta_lf[1] | 693 delta_lf[2] | delta_lf[3] | delta_lf[4] | delta_lf[5] | delta_lf[6] | 694 delta_lf[7] | skip[0] | skip[1] | skip[2] | skip[3] | skip[4] | 695 skip[5] | skip[6] | skip[7]) && 696 (ref_frame[0] == -1 && ref_frame[1] == -1 && ref_frame[2] == -1 && 697 ref_frame[3] == -1 && ref_frame[4] == -1 && ref_frame[5] == -1 && 698 ref_frame[6] == -1 && ref_frame[7] == -1))) { 699 vp9_disable_segmentation(&cm->seg); 700 cpi->roi.enabled = 0; 701 return 0; 702 } 703 704 if (roi->roi_map) { 705 vpx_free(roi->roi_map); 706 roi->roi_map = NULL; 707 } 708 CHECK_MEM_ERROR(cm, roi->roi_map, vpx_malloc(rows * cols)); 709 710 // Copy to ROI sturcture in the compressor. 711 memcpy(roi->roi_map, map, rows * cols); 712 memcpy(&roi->delta_q, delta_q, MAX_SEGMENTS * sizeof(delta_q[0])); 713 memcpy(&roi->delta_lf, delta_lf, MAX_SEGMENTS * sizeof(delta_lf[0])); 714 memcpy(&roi->skip, skip, MAX_SEGMENTS * sizeof(skip[0])); 715 memcpy(&roi->ref_frame, ref_frame, MAX_SEGMENTS * sizeof(ref_frame[0])); 716 roi->enabled = 1; 717 roi->rows = rows; 718 roi->cols = cols; 719 720 return 0; 721 } 722 723 int vp9_set_active_map(VP9_COMP *cpi, unsigned char *new_map_16x16, int rows, 724 int cols) { 725 if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols) { 726 unsigned char *const active_map_8x8 = cpi->active_map.map; 727 const int mi_rows = cpi->common.mi_rows; 728 const int mi_cols = cpi->common.mi_cols; 729 cpi->active_map.update = 1; 730 if (new_map_16x16) { 731 int r, c; 732 for (r = 0; r < mi_rows; ++r) { 733 for (c = 0; c < mi_cols; ++c) { 734 active_map_8x8[r * mi_cols + c] = 735 new_map_16x16[(r >> 1) * cols + (c >> 1)] 736 ? AM_SEGMENT_ID_ACTIVE 737 : AM_SEGMENT_ID_INACTIVE; 738 } 739 } 740 cpi->active_map.enabled = 1; 741 } else { 742 cpi->active_map.enabled = 0; 743 } 744 return 0; 745 } else { 746 return -1; 747 } 748 } 749 750 int vp9_get_active_map(VP9_COMP *cpi, unsigned char *new_map_16x16, int rows, 751 int cols) { 752 if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols && 753 new_map_16x16) { 754 unsigned char *const seg_map_8x8 = cpi->segmentation_map; 755 const int mi_rows = cpi->common.mi_rows; 756 const int mi_cols = cpi->common.mi_cols; 757 memset(new_map_16x16, !cpi->active_map.enabled, rows * cols); 758 if (cpi->active_map.enabled) { 759 int r, c; 760 for (r = 0; r < mi_rows; ++r) { 761 for (c = 0; c < mi_cols; ++c) { 762 // Cyclic refresh segments are considered active despite not having 763 // AM_SEGMENT_ID_ACTIVE 764 new_map_16x16[(r >> 1) * cols + (c >> 1)] |= 765 seg_map_8x8[r * mi_cols + c] != AM_SEGMENT_ID_INACTIVE; 766 } 767 } 768 } 769 return 0; 770 } else { 771 return -1; 772 } 773 } 774 775 void vp9_set_high_precision_mv(VP9_COMP *cpi, int allow_high_precision_mv) { 776 MACROBLOCK *const mb = &cpi->td.mb; 777 cpi->common.allow_high_precision_mv = allow_high_precision_mv; 778 if (cpi->common.allow_high_precision_mv) { 779 mb->mvcost = mb->nmvcost_hp; 780 mb->mvsadcost = mb->nmvsadcost_hp; 781 } else { 782 mb->mvcost = mb->nmvcost; 783 mb->mvsadcost = mb->nmvsadcost; 784 } 785 } 786 787 static void setup_frame(VP9_COMP *cpi) { 788 VP9_COMMON *const cm = &cpi->common; 789 // Set up entropy context depending on frame type. The decoder mandates 790 // the use of the default context, index 0, for keyframes and inter 791 // frames where the error_resilient_mode or intra_only flag is set. For 792 // other inter-frames the encoder currently uses only two contexts; 793 // context 1 for ALTREF frames and context 0 for the others. 794 if (frame_is_intra_only(cm) || cm->error_resilient_mode) { 795 vp9_setup_past_independence(cm); 796 } else { 797 if (!cpi->use_svc) cm->frame_context_idx = cpi->refresh_alt_ref_frame; 798 } 799 800 // TODO(jingning): Overwrite the frame_context_idx index in multi-layer ARF 801 // case. Need some further investigation on if we could apply this to single 802 // layer ARF case as well. 803 if (cpi->multi_layer_arf && !cpi->use_svc) { 804 GF_GROUP *const gf_group = &cpi->twopass.gf_group; 805 cm->frame_context_idx = clamp(gf_group->layer_depth[gf_group->index] - 1, 0, 806 FRAME_CONTEXTS - 1); 807 } 808 809 if (cm->frame_type == KEY_FRAME) { 810 cpi->refresh_golden_frame = 1; 811 cpi->refresh_alt_ref_frame = 1; 812 vp9_zero(cpi->interp_filter_selected); 813 } else { 814 *cm->fc = cm->frame_contexts[cm->frame_context_idx]; 815 vp9_zero(cpi->interp_filter_selected[0]); 816 } 817 } 818 819 static void vp9_enc_setup_mi(VP9_COMMON *cm) { 820 int i; 821 cm->mi = cm->mip + cm->mi_stride + 1; 822 memset(cm->mip, 0, cm->mi_stride * (cm->mi_rows + 1) * sizeof(*cm->mip)); 823 cm->prev_mi = cm->prev_mip + cm->mi_stride + 1; 824 // Clear top border row 825 memset(cm->prev_mip, 0, sizeof(*cm->prev_mip) * cm->mi_stride); 826 // Clear left border column 827 for (i = 1; i < cm->mi_rows + 1; ++i) 828 memset(&cm->prev_mip[i * cm->mi_stride], 0, sizeof(*cm->prev_mip)); 829 830 cm->mi_grid_visible = cm->mi_grid_base + cm->mi_stride + 1; 831 cm->prev_mi_grid_visible = cm->prev_mi_grid_base + cm->mi_stride + 1; 832 833 memset(cm->mi_grid_base, 0, 834 cm->mi_stride * (cm->mi_rows + 1) * sizeof(*cm->mi_grid_base)); 835 } 836 837 static int vp9_enc_alloc_mi(VP9_COMMON *cm, int mi_size) { 838 cm->mip = vpx_calloc(mi_size, sizeof(*cm->mip)); 839 if (!cm->mip) return 1; 840 cm->prev_mip = vpx_calloc(mi_size, sizeof(*cm->prev_mip)); 841 if (!cm->prev_mip) return 1; 842 cm->mi_alloc_size = mi_size; 843 844 cm->mi_grid_base = (MODE_INFO **)vpx_calloc(mi_size, sizeof(MODE_INFO *)); 845 if (!cm->mi_grid_base) return 1; 846 cm->prev_mi_grid_base = 847 (MODE_INFO **)vpx_calloc(mi_size, sizeof(MODE_INFO *)); 848 if (!cm->prev_mi_grid_base) return 1; 849 850 return 0; 851 } 852 853 static void vp9_enc_free_mi(VP9_COMMON *cm) { 854 vpx_free(cm->mip); 855 cm->mip = NULL; 856 vpx_free(cm->prev_mip); 857 cm->prev_mip = NULL; 858 vpx_free(cm->mi_grid_base); 859 cm->mi_grid_base = NULL; 860 vpx_free(cm->prev_mi_grid_base); 861 cm->prev_mi_grid_base = NULL; 862 cm->mi_alloc_size = 0; 863 } 864 865 static void vp9_swap_mi_and_prev_mi(VP9_COMMON *cm) { 866 // Current mip will be the prev_mip for the next frame. 867 MODE_INFO **temp_base = cm->prev_mi_grid_base; 868 MODE_INFO *temp = cm->prev_mip; 869 870 // Skip update prev_mi frame in show_existing_frame mode. 871 if (cm->show_existing_frame) return; 872 873 cm->prev_mip = cm->mip; 874 cm->mip = temp; 875 876 // Update the upper left visible macroblock ptrs. 877 cm->mi = cm->mip + cm->mi_stride + 1; 878 cm->prev_mi = cm->prev_mip + cm->mi_stride + 1; 879 880 cm->prev_mi_grid_base = cm->mi_grid_base; 881 cm->mi_grid_base = temp_base; 882 cm->mi_grid_visible = cm->mi_grid_base + cm->mi_stride + 1; 883 cm->prev_mi_grid_visible = cm->prev_mi_grid_base + cm->mi_stride + 1; 884 } 885 886 void vp9_initialize_enc(void) { 887 static volatile int init_done = 0; 888 889 if (!init_done) { 890 vp9_rtcd(); 891 vpx_dsp_rtcd(); 892 vpx_scale_rtcd(); 893 vp9_init_intra_predictors(); 894 vp9_init_me_luts(); 895 vp9_rc_init_minq_luts(); 896 vp9_entropy_mv_init(); 897 #if !CONFIG_REALTIME_ONLY 898 vp9_temporal_filter_init(); 899 #endif 900 init_done = 1; 901 } 902 } 903 904 static void dealloc_compressor_data(VP9_COMP *cpi) { 905 VP9_COMMON *const cm = &cpi->common; 906 int i; 907 908 vpx_free(cpi->mbmi_ext_base); 909 cpi->mbmi_ext_base = NULL; 910 911 vpx_free(cpi->tile_data); 912 cpi->tile_data = NULL; 913 914 vpx_free(cpi->segmentation_map); 915 cpi->segmentation_map = NULL; 916 vpx_free(cpi->coding_context.last_frame_seg_map_copy); 917 cpi->coding_context.last_frame_seg_map_copy = NULL; 918 919 vpx_free(cpi->nmvcosts[0]); 920 vpx_free(cpi->nmvcosts[1]); 921 cpi->nmvcosts[0] = NULL; 922 cpi->nmvcosts[1] = NULL; 923 924 vpx_free(cpi->nmvcosts_hp[0]); 925 vpx_free(cpi->nmvcosts_hp[1]); 926 cpi->nmvcosts_hp[0] = NULL; 927 cpi->nmvcosts_hp[1] = NULL; 928 929 vpx_free(cpi->nmvsadcosts[0]); 930 vpx_free(cpi->nmvsadcosts[1]); 931 cpi->nmvsadcosts[0] = NULL; 932 cpi->nmvsadcosts[1] = NULL; 933 934 vpx_free(cpi->nmvsadcosts_hp[0]); 935 vpx_free(cpi->nmvsadcosts_hp[1]); 936 cpi->nmvsadcosts_hp[0] = NULL; 937 cpi->nmvsadcosts_hp[1] = NULL; 938 939 vpx_free(cpi->skin_map); 940 cpi->skin_map = NULL; 941 942 vpx_free(cpi->prev_partition); 943 cpi->prev_partition = NULL; 944 945 vpx_free(cpi->svc.prev_partition_svc); 946 cpi->svc.prev_partition_svc = NULL; 947 948 vpx_free(cpi->prev_segment_id); 949 cpi->prev_segment_id = NULL; 950 951 vpx_free(cpi->prev_variance_low); 952 cpi->prev_variance_low = NULL; 953 954 vpx_free(cpi->copied_frame_cnt); 955 cpi->copied_frame_cnt = NULL; 956 957 vpx_free(cpi->content_state_sb_fd); 958 cpi->content_state_sb_fd = NULL; 959 960 vpx_free(cpi->count_arf_frame_usage); 961 cpi->count_arf_frame_usage = NULL; 962 vpx_free(cpi->count_lastgolden_frame_usage); 963 cpi->count_lastgolden_frame_usage = NULL; 964 965 vp9_cyclic_refresh_free(cpi->cyclic_refresh); 966 cpi->cyclic_refresh = NULL; 967 968 vpx_free(cpi->active_map.map); 969 cpi->active_map.map = NULL; 970 971 vpx_free(cpi->roi.roi_map); 972 cpi->roi.roi_map = NULL; 973 974 vpx_free(cpi->consec_zero_mv); 975 cpi->consec_zero_mv = NULL; 976 977 vp9_free_ref_frame_buffers(cm->buffer_pool); 978 #if CONFIG_VP9_POSTPROC 979 vp9_free_postproc_buffers(cm); 980 #endif 981 vp9_free_context_buffers(cm); 982 983 vpx_free_frame_buffer(&cpi->last_frame_uf); 984 vpx_free_frame_buffer(&cpi->scaled_source); 985 vpx_free_frame_buffer(&cpi->scaled_last_source); 986 vpx_free_frame_buffer(&cpi->alt_ref_buffer); 987 #ifdef ENABLE_KF_DENOISE 988 vpx_free_frame_buffer(&cpi->raw_unscaled_source); 989 vpx_free_frame_buffer(&cpi->raw_scaled_source); 990 #endif 991 992 vp9_lookahead_destroy(cpi->lookahead); 993 994 vpx_free(cpi->tile_tok[0][0]); 995 cpi->tile_tok[0][0] = 0; 996 997 vpx_free(cpi->tplist[0][0]); 998 cpi->tplist[0][0] = NULL; 999 1000 vp9_free_pc_tree(&cpi->td); 1001 1002 for (i = 0; i < cpi->svc.number_spatial_layers; ++i) { 1003 LAYER_CONTEXT *const lc = &cpi->svc.layer_context[i]; 1004 vpx_free(lc->rc_twopass_stats_in.buf); 1005 lc->rc_twopass_stats_in.buf = NULL; 1006 lc->rc_twopass_stats_in.sz = 0; 1007 } 1008 1009 if (cpi->source_diff_var != NULL) { 1010 vpx_free(cpi->source_diff_var); 1011 cpi->source_diff_var = NULL; 1012 } 1013 1014 for (i = 0; i < MAX_LAG_BUFFERS; ++i) { 1015 vpx_free_frame_buffer(&cpi->svc.scaled_frames[i]); 1016 } 1017 memset(&cpi->svc.scaled_frames[0], 0, 1018 MAX_LAG_BUFFERS * sizeof(cpi->svc.scaled_frames[0])); 1019 1020 vpx_free_frame_buffer(&cpi->svc.scaled_temp); 1021 memset(&cpi->svc.scaled_temp, 0, sizeof(cpi->svc.scaled_temp)); 1022 1023 vpx_free_frame_buffer(&cpi->svc.empty_frame.img); 1024 memset(&cpi->svc.empty_frame, 0, sizeof(cpi->svc.empty_frame)); 1025 1026 vp9_free_svc_cyclic_refresh(cpi); 1027 } 1028 1029 static void save_coding_context(VP9_COMP *cpi) { 1030 CODING_CONTEXT *const cc = &cpi->coding_context; 1031 VP9_COMMON *cm = &cpi->common; 1032 1033 // Stores a snapshot of key state variables which can subsequently be 1034 // restored with a call to vp9_restore_coding_context. These functions are 1035 // intended for use in a re-code loop in vp9_compress_frame where the 1036 // quantizer value is adjusted between loop iterations. 1037 vp9_copy(cc->nmvjointcost, cpi->td.mb.nmvjointcost); 1038 1039 memcpy(cc->nmvcosts[0], cpi->nmvcosts[0], 1040 MV_VALS * sizeof(*cpi->nmvcosts[0])); 1041 memcpy(cc->nmvcosts[1], cpi->nmvcosts[1], 1042 MV_VALS * sizeof(*cpi->nmvcosts[1])); 1043 memcpy(cc->nmvcosts_hp[0], cpi->nmvcosts_hp[0], 1044 MV_VALS * sizeof(*cpi->nmvcosts_hp[0])); 1045 memcpy(cc->nmvcosts_hp[1], cpi->nmvcosts_hp[1], 1046 MV_VALS * sizeof(*cpi->nmvcosts_hp[1])); 1047 1048 vp9_copy(cc->segment_pred_probs, cm->seg.pred_probs); 1049 1050 memcpy(cpi->coding_context.last_frame_seg_map_copy, cm->last_frame_seg_map, 1051 (cm->mi_rows * cm->mi_cols)); 1052 1053 vp9_copy(cc->last_ref_lf_deltas, cm->lf.last_ref_deltas); 1054 vp9_copy(cc->last_mode_lf_deltas, cm->lf.last_mode_deltas); 1055 1056 cc->fc = *cm->fc; 1057 } 1058 1059 static void restore_coding_context(VP9_COMP *cpi) { 1060 CODING_CONTEXT *const cc = &cpi->coding_context; 1061 VP9_COMMON *cm = &cpi->common; 1062 1063 // Restore key state variables to the snapshot state stored in the 1064 // previous call to vp9_save_coding_context. 1065 vp9_copy(cpi->td.mb.nmvjointcost, cc->nmvjointcost); 1066 1067 memcpy(cpi->nmvcosts[0], cc->nmvcosts[0], MV_VALS * sizeof(*cc->nmvcosts[0])); 1068 memcpy(cpi->nmvcosts[1], cc->nmvcosts[1], MV_VALS * sizeof(*cc->nmvcosts[1])); 1069 memcpy(cpi->nmvcosts_hp[0], cc->nmvcosts_hp[0], 1070 MV_VALS * sizeof(*cc->nmvcosts_hp[0])); 1071 memcpy(cpi->nmvcosts_hp[1], cc->nmvcosts_hp[1], 1072 MV_VALS * sizeof(*cc->nmvcosts_hp[1])); 1073 1074 vp9_copy(cm->seg.pred_probs, cc->segment_pred_probs); 1075 1076 memcpy(cm->last_frame_seg_map, cpi->coding_context.last_frame_seg_map_copy, 1077 (cm->mi_rows * cm->mi_cols)); 1078 1079 vp9_copy(cm->lf.last_ref_deltas, cc->last_ref_lf_deltas); 1080 vp9_copy(cm->lf.last_mode_deltas, cc->last_mode_lf_deltas); 1081 1082 *cm->fc = cc->fc; 1083 } 1084 1085 #if !CONFIG_REALTIME_ONLY 1086 static void configure_static_seg_features(VP9_COMP *cpi) { 1087 VP9_COMMON *const cm = &cpi->common; 1088 const RATE_CONTROL *const rc = &cpi->rc; 1089 struct segmentation *const seg = &cm->seg; 1090 1091 int high_q = (int)(rc->avg_q > 48.0); 1092 int qi_delta; 1093 1094 // Disable and clear down for KF 1095 if (cm->frame_type == KEY_FRAME) { 1096 // Clear down the global segmentation map 1097 memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols); 1098 seg->update_map = 0; 1099 seg->update_data = 0; 1100 cpi->static_mb_pct = 0; 1101 1102 // Disable segmentation 1103 vp9_disable_segmentation(seg); 1104 1105 // Clear down the segment features. 1106 vp9_clearall_segfeatures(seg); 1107 } else if (cpi->refresh_alt_ref_frame) { 1108 // If this is an alt ref frame 1109 // Clear down the global segmentation map 1110 memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols); 1111 seg->update_map = 0; 1112 seg->update_data = 0; 1113 cpi->static_mb_pct = 0; 1114 1115 // Disable segmentation and individual segment features by default 1116 vp9_disable_segmentation(seg); 1117 vp9_clearall_segfeatures(seg); 1118 1119 // Scan frames from current to arf frame. 1120 // This function re-enables segmentation if appropriate. 1121 vp9_update_mbgraph_stats(cpi); 1122 1123 // If segmentation was enabled set those features needed for the 1124 // arf itself. 1125 if (seg->enabled) { 1126 seg->update_map = 1; 1127 seg->update_data = 1; 1128 1129 qi_delta = 1130 vp9_compute_qdelta(rc, rc->avg_q, rc->avg_q * 0.875, cm->bit_depth); 1131 vp9_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta - 2); 1132 vp9_set_segdata(seg, 1, SEG_LVL_ALT_LF, -2); 1133 1134 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_Q); 1135 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_LF); 1136 1137 // Where relevant assume segment data is delta data 1138 seg->abs_delta = SEGMENT_DELTADATA; 1139 } 1140 } else if (seg->enabled) { 1141 // All other frames if segmentation has been enabled 1142 1143 // First normal frame in a valid gf or alt ref group 1144 if (rc->frames_since_golden == 0) { 1145 // Set up segment features for normal frames in an arf group 1146 if (rc->source_alt_ref_active) { 1147 seg->update_map = 0; 1148 seg->update_data = 1; 1149 seg->abs_delta = SEGMENT_DELTADATA; 1150 1151 qi_delta = 1152 vp9_compute_qdelta(rc, rc->avg_q, rc->avg_q * 1.125, cm->bit_depth); 1153 vp9_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta + 2); 1154 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_Q); 1155 1156 vp9_set_segdata(seg, 1, SEG_LVL_ALT_LF, -2); 1157 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_LF); 1158 1159 // Segment coding disabled for compred testing 1160 if (high_q || (cpi->static_mb_pct == 100)) { 1161 vp9_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME); 1162 vp9_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME); 1163 vp9_enable_segfeature(seg, 1, SEG_LVL_SKIP); 1164 } 1165 } else { 1166 // Disable segmentation and clear down features if alt ref 1167 // is not active for this group 1168 1169 vp9_disable_segmentation(seg); 1170 1171 memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols); 1172 1173 seg->update_map = 0; 1174 seg->update_data = 0; 1175 1176 vp9_clearall_segfeatures(seg); 1177 } 1178 } else if (rc->is_src_frame_alt_ref) { 1179 // Special case where we are coding over the top of a previous 1180 // alt ref frame. 1181 // Segment coding disabled for compred testing 1182 1183 // Enable ref frame features for segment 0 as well 1184 vp9_enable_segfeature(seg, 0, SEG_LVL_REF_FRAME); 1185 vp9_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME); 1186 1187 // All mbs should use ALTREF_FRAME 1188 vp9_clear_segdata(seg, 0, SEG_LVL_REF_FRAME); 1189 vp9_set_segdata(seg, 0, SEG_LVL_REF_FRAME, ALTREF_FRAME); 1190 vp9_clear_segdata(seg, 1, SEG_LVL_REF_FRAME); 1191 vp9_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME); 1192 1193 // Skip all MBs if high Q (0,0 mv and skip coeffs) 1194 if (high_q) { 1195 vp9_enable_segfeature(seg, 0, SEG_LVL_SKIP); 1196 vp9_enable_segfeature(seg, 1, SEG_LVL_SKIP); 1197 } 1198 // Enable data update 1199 seg->update_data = 1; 1200 } else { 1201 // All other frames. 1202 1203 // No updates.. leave things as they are. 1204 seg->update_map = 0; 1205 seg->update_data = 0; 1206 } 1207 } 1208 } 1209 #endif // !CONFIG_REALTIME_ONLY 1210 1211 static void update_reference_segmentation_map(VP9_COMP *cpi) { 1212 VP9_COMMON *const cm = &cpi->common; 1213 MODE_INFO **mi_8x8_ptr = cm->mi_grid_visible; 1214 uint8_t *cache_ptr = cm->last_frame_seg_map; 1215 int row, col; 1216 1217 for (row = 0; row < cm->mi_rows; row++) { 1218 MODE_INFO **mi_8x8 = mi_8x8_ptr; 1219 uint8_t *cache = cache_ptr; 1220 for (col = 0; col < cm->mi_cols; col++, mi_8x8++, cache++) 1221 cache[0] = mi_8x8[0]->segment_id; 1222 mi_8x8_ptr += cm->mi_stride; 1223 cache_ptr += cm->mi_cols; 1224 } 1225 } 1226 1227 static void alloc_raw_frame_buffers(VP9_COMP *cpi) { 1228 VP9_COMMON *cm = &cpi->common; 1229 const VP9EncoderConfig *oxcf = &cpi->oxcf; 1230 1231 if (!cpi->lookahead) 1232 cpi->lookahead = vp9_lookahead_init(oxcf->width, oxcf->height, 1233 cm->subsampling_x, cm->subsampling_y, 1234 #if CONFIG_VP9_HIGHBITDEPTH 1235 cm->use_highbitdepth, 1236 #endif 1237 oxcf->lag_in_frames); 1238 if (!cpi->lookahead) 1239 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR, 1240 "Failed to allocate lag buffers"); 1241 1242 // TODO(agrange) Check if ARF is enabled and skip allocation if not. 1243 if (vpx_realloc_frame_buffer(&cpi->alt_ref_buffer, oxcf->width, oxcf->height, 1244 cm->subsampling_x, cm->subsampling_y, 1245 #if CONFIG_VP9_HIGHBITDEPTH 1246 cm->use_highbitdepth, 1247 #endif 1248 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment, 1249 NULL, NULL, NULL)) 1250 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR, 1251 "Failed to allocate altref buffer"); 1252 } 1253 1254 static void alloc_util_frame_buffers(VP9_COMP *cpi) { 1255 VP9_COMMON *const cm = &cpi->common; 1256 if (vpx_realloc_frame_buffer(&cpi->last_frame_uf, cm->width, cm->height, 1257 cm->subsampling_x, cm->subsampling_y, 1258 #if CONFIG_VP9_HIGHBITDEPTH 1259 cm->use_highbitdepth, 1260 #endif 1261 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment, 1262 NULL, NULL, NULL)) 1263 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR, 1264 "Failed to allocate last frame buffer"); 1265 1266 if (vpx_realloc_frame_buffer(&cpi->scaled_source, cm->width, cm->height, 1267 cm->subsampling_x, cm->subsampling_y, 1268 #if CONFIG_VP9_HIGHBITDEPTH 1269 cm->use_highbitdepth, 1270 #endif 1271 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment, 1272 NULL, NULL, NULL)) 1273 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR, 1274 "Failed to allocate scaled source buffer"); 1275 1276 // For 1 pass cbr: allocate scaled_frame that may be used as an intermediate 1277 // buffer for a 2 stage down-sampling: two stages of 1:2 down-sampling for a 1278 // target of 1/4x1/4. number_spatial_layers must be greater than 2. 1279 if (is_one_pass_cbr_svc(cpi) && !cpi->svc.scaled_temp_is_alloc && 1280 cpi->svc.number_spatial_layers > 2) { 1281 cpi->svc.scaled_temp_is_alloc = 1; 1282 if (vpx_realloc_frame_buffer( 1283 &cpi->svc.scaled_temp, cm->width >> 1, cm->height >> 1, 1284 cm->subsampling_x, cm->subsampling_y, 1285 #if CONFIG_VP9_HIGHBITDEPTH 1286 cm->use_highbitdepth, 1287 #endif 1288 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment, NULL, NULL, NULL)) 1289 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR, 1290 "Failed to allocate scaled_frame for svc "); 1291 } 1292 1293 if (vpx_realloc_frame_buffer(&cpi->scaled_last_source, cm->width, cm->height, 1294 cm->subsampling_x, cm->subsampling_y, 1295 #if CONFIG_VP9_HIGHBITDEPTH 1296 cm->use_highbitdepth, 1297 #endif 1298 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment, 1299 NULL, NULL, NULL)) 1300 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR, 1301 "Failed to allocate scaled last source buffer"); 1302 #ifdef ENABLE_KF_DENOISE 1303 if (vpx_realloc_frame_buffer(&cpi->raw_unscaled_source, cm->width, cm->height, 1304 cm->subsampling_x, cm->subsampling_y, 1305 #if CONFIG_VP9_HIGHBITDEPTH 1306 cm->use_highbitdepth, 1307 #endif 1308 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment, 1309 NULL, NULL, NULL)) 1310 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR, 1311 "Failed to allocate unscaled raw source frame buffer"); 1312 1313 if (vpx_realloc_frame_buffer(&cpi->raw_scaled_source, cm->width, cm->height, 1314 cm->subsampling_x, cm->subsampling_y, 1315 #if CONFIG_VP9_HIGHBITDEPTH 1316 cm->use_highbitdepth, 1317 #endif 1318 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment, 1319 NULL, NULL, NULL)) 1320 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR, 1321 "Failed to allocate scaled raw source frame buffer"); 1322 #endif 1323 } 1324 1325 static int alloc_context_buffers_ext(VP9_COMP *cpi) { 1326 VP9_COMMON *cm = &cpi->common; 1327 int mi_size = cm->mi_cols * cm->mi_rows; 1328 1329 cpi->mbmi_ext_base = vpx_calloc(mi_size, sizeof(*cpi->mbmi_ext_base)); 1330 if (!cpi->mbmi_ext_base) return 1; 1331 1332 return 0; 1333 } 1334 1335 static void alloc_compressor_data(VP9_COMP *cpi) { 1336 VP9_COMMON *cm = &cpi->common; 1337 int sb_rows; 1338 1339 vp9_alloc_context_buffers(cm, cm->width, cm->height); 1340 1341 alloc_context_buffers_ext(cpi); 1342 1343 vpx_free(cpi->tile_tok[0][0]); 1344 1345 { 1346 unsigned int tokens = get_token_alloc(cm->mb_rows, cm->mb_cols); 1347 CHECK_MEM_ERROR(cm, cpi->tile_tok[0][0], 1348 vpx_calloc(tokens, sizeof(*cpi->tile_tok[0][0]))); 1349 } 1350 1351 sb_rows = mi_cols_aligned_to_sb(cm->mi_rows) >> MI_BLOCK_SIZE_LOG2; 1352 vpx_free(cpi->tplist[0][0]); 1353 CHECK_MEM_ERROR( 1354 cm, cpi->tplist[0][0], 1355 vpx_calloc(sb_rows * 4 * (1 << 6), sizeof(*cpi->tplist[0][0]))); 1356 1357 vp9_setup_pc_tree(&cpi->common, &cpi->td); 1358 } 1359 1360 void vp9_new_framerate(VP9_COMP *cpi, double framerate) { 1361 cpi->framerate = framerate < 0.1 ? 30 : framerate; 1362 vp9_rc_update_framerate(cpi); 1363 } 1364 1365 static void set_tile_limits(VP9_COMP *cpi) { 1366 VP9_COMMON *const cm = &cpi->common; 1367 1368 int min_log2_tile_cols, max_log2_tile_cols; 1369 vp9_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols); 1370 1371 cm->log2_tile_cols = 1372 clamp(cpi->oxcf.tile_columns, min_log2_tile_cols, max_log2_tile_cols); 1373 cm->log2_tile_rows = cpi->oxcf.tile_rows; 1374 1375 if (cpi->oxcf.target_level == LEVEL_AUTO) { 1376 const int level_tile_cols = 1377 log_tile_cols_from_picsize_level(cpi->common.width, cpi->common.height); 1378 if (cm->log2_tile_cols > level_tile_cols) { 1379 cm->log2_tile_cols = VPXMAX(level_tile_cols, min_log2_tile_cols); 1380 } 1381 } 1382 } 1383 1384 static void update_frame_size(VP9_COMP *cpi) { 1385 VP9_COMMON *const cm = &cpi->common; 1386 MACROBLOCKD *const xd = &cpi->td.mb.e_mbd; 1387 1388 vp9_set_mb_mi(cm, cm->width, cm->height); 1389 vp9_init_context_buffers(cm); 1390 vp9_init_macroblockd(cm, xd, NULL); 1391 cpi->td.mb.mbmi_ext_base = cpi->mbmi_ext_base; 1392 memset(cpi->mbmi_ext_base, 0, 1393 cm->mi_rows * cm->mi_cols * sizeof(*cpi->mbmi_ext_base)); 1394 1395 set_tile_limits(cpi); 1396 } 1397 1398 static void init_buffer_indices(VP9_COMP *cpi) { 1399 int ref_frame; 1400 1401 for (ref_frame = 0; ref_frame < REF_FRAMES; ++ref_frame) 1402 cpi->ref_fb_idx[ref_frame] = ref_frame; 1403 1404 cpi->lst_fb_idx = cpi->ref_fb_idx[LAST_FRAME - 1]; 1405 cpi->gld_fb_idx = cpi->ref_fb_idx[GOLDEN_FRAME - 1]; 1406 cpi->alt_fb_idx = cpi->ref_fb_idx[ALTREF_FRAME - 1]; 1407 } 1408 1409 static void init_level_constraint(LevelConstraint *lc) { 1410 lc->level_index = -1; 1411 lc->max_cpb_size = INT_MAX; 1412 lc->max_frame_size = INT_MAX; 1413 lc->rc_config_updated = 0; 1414 lc->fail_flag = 0; 1415 } 1416 1417 static void set_level_constraint(LevelConstraint *ls, int8_t level_index) { 1418 vpx_clear_system_state(); 1419 ls->level_index = level_index; 1420 if (level_index >= 0) { 1421 ls->max_cpb_size = vp9_level_defs[level_index].max_cpb_size * (double)1000; 1422 } 1423 } 1424 1425 static void init_config(struct VP9_COMP *cpi, VP9EncoderConfig *oxcf) { 1426 VP9_COMMON *const cm = &cpi->common; 1427 1428 cpi->oxcf = *oxcf; 1429 cpi->framerate = oxcf->init_framerate; 1430 cm->profile = oxcf->profile; 1431 cm->bit_depth = oxcf->bit_depth; 1432 #if CONFIG_VP9_HIGHBITDEPTH 1433 cm->use_highbitdepth = oxcf->use_highbitdepth; 1434 #endif 1435 cm->color_space = oxcf->color_space; 1436 cm->color_range = oxcf->color_range; 1437 1438 cpi->target_level = oxcf->target_level; 1439 cpi->keep_level_stats = oxcf->target_level != LEVEL_MAX; 1440 set_level_constraint(&cpi->level_constraint, 1441 get_level_index(cpi->target_level)); 1442 1443 cm->width = oxcf->width; 1444 cm->height = oxcf->height; 1445 alloc_compressor_data(cpi); 1446 1447 cpi->svc.temporal_layering_mode = oxcf->temporal_layering_mode; 1448 1449 // Single thread case: use counts in common. 1450 cpi->td.counts = &cm->counts; 1451 1452 // Spatial scalability. 1453 cpi->svc.number_spatial_layers = oxcf->ss_number_layers; 1454 // Temporal scalability. 1455 cpi->svc.number_temporal_layers = oxcf->ts_number_layers; 1456 1457 if ((cpi->svc.number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) || 1458 ((cpi->svc.number_temporal_layers > 1 || 1459 cpi->svc.number_spatial_layers > 1) && 1460 cpi->oxcf.pass != 1)) { 1461 vp9_init_layer_context(cpi); 1462 } 1463 1464 // change includes all joint functionality 1465 vp9_change_config(cpi, oxcf); 1466 1467 cpi->static_mb_pct = 0; 1468 cpi->ref_frame_flags = 0; 1469 1470 init_buffer_indices(cpi); 1471 1472 vp9_noise_estimate_init(&cpi->noise_estimate, cm->width, cm->height); 1473 } 1474 1475 static void set_rc_buffer_sizes(RATE_CONTROL *rc, 1476 const VP9EncoderConfig *oxcf) { 1477 const int64_t bandwidth = oxcf->target_bandwidth; 1478 const int64_t starting = oxcf->starting_buffer_level_ms; 1479 const int64_t optimal = oxcf->optimal_buffer_level_ms; 1480 const int64_t maximum = oxcf->maximum_buffer_size_ms; 1481 1482 rc->starting_buffer_level = starting * bandwidth / 1000; 1483 rc->optimal_buffer_level = 1484 (optimal == 0) ? bandwidth / 8 : optimal * bandwidth / 1000; 1485 rc->maximum_buffer_size = 1486 (maximum == 0) ? bandwidth / 8 : maximum * bandwidth / 1000; 1487 } 1488 1489 #if CONFIG_VP9_HIGHBITDEPTH 1490 #define HIGHBD_BFP(BT, SDF, SDAF, VF, SVF, SVAF, SDX4DF) \ 1491 cpi->fn_ptr[BT].sdf = SDF; \ 1492 cpi->fn_ptr[BT].sdaf = SDAF; \ 1493 cpi->fn_ptr[BT].vf = VF; \ 1494 cpi->fn_ptr[BT].svf = SVF; \ 1495 cpi->fn_ptr[BT].svaf = SVAF; \ 1496 cpi->fn_ptr[BT].sdx4df = SDX4DF; 1497 1498 #define MAKE_BFP_SAD_WRAPPER(fnname) \ 1499 static unsigned int fnname##_bits8(const uint8_t *src_ptr, \ 1500 int source_stride, \ 1501 const uint8_t *ref_ptr, int ref_stride) { \ 1502 return fnname(src_ptr, source_stride, ref_ptr, ref_stride); \ 1503 } \ 1504 static unsigned int fnname##_bits10( \ 1505 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \ 1506 int ref_stride) { \ 1507 return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 2; \ 1508 } \ 1509 static unsigned int fnname##_bits12( \ 1510 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \ 1511 int ref_stride) { \ 1512 return fnname(src_ptr, source_stride, ref_ptr, ref_stride) >> 4; \ 1513 } 1514 1515 #define MAKE_BFP_SADAVG_WRAPPER(fnname) \ 1516 static unsigned int fnname##_bits8( \ 1517 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \ 1518 int ref_stride, const uint8_t *second_pred) { \ 1519 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred); \ 1520 } \ 1521 static unsigned int fnname##_bits10( \ 1522 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \ 1523 int ref_stride, const uint8_t *second_pred) { \ 1524 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred) >> \ 1525 2; \ 1526 } \ 1527 static unsigned int fnname##_bits12( \ 1528 const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \ 1529 int ref_stride, const uint8_t *second_pred) { \ 1530 return fnname(src_ptr, source_stride, ref_ptr, ref_stride, second_pred) >> \ 1531 4; \ 1532 } 1533 1534 #define MAKE_BFP_SAD4D_WRAPPER(fnname) \ 1535 static void fnname##_bits8(const uint8_t *src_ptr, int source_stride, \ 1536 const uint8_t *const ref_ptr[], int ref_stride, \ 1537 unsigned int *sad_array) { \ 1538 fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array); \ 1539 } \ 1540 static void fnname##_bits10(const uint8_t *src_ptr, int source_stride, \ 1541 const uint8_t *const ref_ptr[], int ref_stride, \ 1542 unsigned int *sad_array) { \ 1543 int i; \ 1544 fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array); \ 1545 for (i = 0; i < 4; i++) sad_array[i] >>= 2; \ 1546 } \ 1547 static void fnname##_bits12(const uint8_t *src_ptr, int source_stride, \ 1548 const uint8_t *const ref_ptr[], int ref_stride, \ 1549 unsigned int *sad_array) { \ 1550 int i; \ 1551 fnname(src_ptr, source_stride, ref_ptr, ref_stride, sad_array); \ 1552 for (i = 0; i < 4; i++) sad_array[i] >>= 4; \ 1553 } 1554 1555 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad32x16) 1556 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad32x16_avg) 1557 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad32x16x4d) 1558 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad16x32) 1559 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad16x32_avg) 1560 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad16x32x4d) 1561 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad64x32) 1562 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad64x32_avg) 1563 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad64x32x4d) 1564 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad32x64) 1565 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad32x64_avg) 1566 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad32x64x4d) 1567 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad32x32) 1568 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad32x32_avg) 1569 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad32x32x4d) 1570 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad64x64) 1571 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad64x64_avg) 1572 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad64x64x4d) 1573 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad16x16) 1574 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad16x16_avg) 1575 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad16x16x4d) 1576 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad16x8) 1577 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad16x8_avg) 1578 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad16x8x4d) 1579 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad8x16) 1580 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad8x16_avg) 1581 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad8x16x4d) 1582 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad8x8) 1583 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad8x8_avg) 1584 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad8x8x4d) 1585 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad8x4) 1586 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad8x4_avg) 1587 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad8x4x4d) 1588 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad4x8) 1589 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad4x8_avg) 1590 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad4x8x4d) 1591 MAKE_BFP_SAD_WRAPPER(vpx_highbd_sad4x4) 1592 MAKE_BFP_SADAVG_WRAPPER(vpx_highbd_sad4x4_avg) 1593 MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad4x4x4d) 1594 1595 static void highbd_set_var_fns(VP9_COMP *const cpi) { 1596 VP9_COMMON *const cm = &cpi->common; 1597 if (cm->use_highbitdepth) { 1598 switch (cm->bit_depth) { 1599 case VPX_BITS_8: 1600 HIGHBD_BFP(BLOCK_32X16, vpx_highbd_sad32x16_bits8, 1601 vpx_highbd_sad32x16_avg_bits8, vpx_highbd_8_variance32x16, 1602 vpx_highbd_8_sub_pixel_variance32x16, 1603 vpx_highbd_8_sub_pixel_avg_variance32x16, 1604 vpx_highbd_sad32x16x4d_bits8) 1605 1606 HIGHBD_BFP(BLOCK_16X32, vpx_highbd_sad16x32_bits8, 1607 vpx_highbd_sad16x32_avg_bits8, vpx_highbd_8_variance16x32, 1608 vpx_highbd_8_sub_pixel_variance16x32, 1609 vpx_highbd_8_sub_pixel_avg_variance16x32, 1610 vpx_highbd_sad16x32x4d_bits8) 1611 1612 HIGHBD_BFP(BLOCK_64X32, vpx_highbd_sad64x32_bits8, 1613 vpx_highbd_sad64x32_avg_bits8, vpx_highbd_8_variance64x32, 1614 vpx_highbd_8_sub_pixel_variance64x32, 1615 vpx_highbd_8_sub_pixel_avg_variance64x32, 1616 vpx_highbd_sad64x32x4d_bits8) 1617 1618 HIGHBD_BFP(BLOCK_32X64, vpx_highbd_sad32x64_bits8, 1619 vpx_highbd_sad32x64_avg_bits8, vpx_highbd_8_variance32x64, 1620 vpx_highbd_8_sub_pixel_variance32x64, 1621 vpx_highbd_8_sub_pixel_avg_variance32x64, 1622 vpx_highbd_sad32x64x4d_bits8) 1623 1624 HIGHBD_BFP(BLOCK_32X32, vpx_highbd_sad32x32_bits8, 1625 vpx_highbd_sad32x32_avg_bits8, vpx_highbd_8_variance32x32, 1626 vpx_highbd_8_sub_pixel_variance32x32, 1627 vpx_highbd_8_sub_pixel_avg_variance32x32, 1628 vpx_highbd_sad32x32x4d_bits8) 1629 1630 HIGHBD_BFP(BLOCK_64X64, vpx_highbd_sad64x64_bits8, 1631 vpx_highbd_sad64x64_avg_bits8, vpx_highbd_8_variance64x64, 1632 vpx_highbd_8_sub_pixel_variance64x64, 1633 vpx_highbd_8_sub_pixel_avg_variance64x64, 1634 vpx_highbd_sad64x64x4d_bits8) 1635 1636 HIGHBD_BFP(BLOCK_16X16, vpx_highbd_sad16x16_bits8, 1637 vpx_highbd_sad16x16_avg_bits8, vpx_highbd_8_variance16x16, 1638 vpx_highbd_8_sub_pixel_variance16x16, 1639 vpx_highbd_8_sub_pixel_avg_variance16x16, 1640 vpx_highbd_sad16x16x4d_bits8) 1641 1642 HIGHBD_BFP(BLOCK_16X8, vpx_highbd_sad16x8_bits8, 1643 vpx_highbd_sad16x8_avg_bits8, vpx_highbd_8_variance16x8, 1644 vpx_highbd_8_sub_pixel_variance16x8, 1645 vpx_highbd_8_sub_pixel_avg_variance16x8, 1646 vpx_highbd_sad16x8x4d_bits8) 1647 1648 HIGHBD_BFP(BLOCK_8X16, vpx_highbd_sad8x16_bits8, 1649 vpx_highbd_sad8x16_avg_bits8, vpx_highbd_8_variance8x16, 1650 vpx_highbd_8_sub_pixel_variance8x16, 1651 vpx_highbd_8_sub_pixel_avg_variance8x16, 1652 vpx_highbd_sad8x16x4d_bits8) 1653 1654 HIGHBD_BFP( 1655 BLOCK_8X8, vpx_highbd_sad8x8_bits8, vpx_highbd_sad8x8_avg_bits8, 1656 vpx_highbd_8_variance8x8, vpx_highbd_8_sub_pixel_variance8x8, 1657 vpx_highbd_8_sub_pixel_avg_variance8x8, vpx_highbd_sad8x8x4d_bits8) 1658 1659 HIGHBD_BFP( 1660 BLOCK_8X4, vpx_highbd_sad8x4_bits8, vpx_highbd_sad8x4_avg_bits8, 1661 vpx_highbd_8_variance8x4, vpx_highbd_8_sub_pixel_variance8x4, 1662 vpx_highbd_8_sub_pixel_avg_variance8x4, vpx_highbd_sad8x4x4d_bits8) 1663 1664 HIGHBD_BFP( 1665 BLOCK_4X8, vpx_highbd_sad4x8_bits8, vpx_highbd_sad4x8_avg_bits8, 1666 vpx_highbd_8_variance4x8, vpx_highbd_8_sub_pixel_variance4x8, 1667 vpx_highbd_8_sub_pixel_avg_variance4x8, vpx_highbd_sad4x8x4d_bits8) 1668 1669 HIGHBD_BFP( 1670 BLOCK_4X4, vpx_highbd_sad4x4_bits8, vpx_highbd_sad4x4_avg_bits8, 1671 vpx_highbd_8_variance4x4, vpx_highbd_8_sub_pixel_variance4x4, 1672 vpx_highbd_8_sub_pixel_avg_variance4x4, vpx_highbd_sad4x4x4d_bits8) 1673 break; 1674 1675 case VPX_BITS_10: 1676 HIGHBD_BFP(BLOCK_32X16, vpx_highbd_sad32x16_bits10, 1677 vpx_highbd_sad32x16_avg_bits10, vpx_highbd_10_variance32x16, 1678 vpx_highbd_10_sub_pixel_variance32x16, 1679 vpx_highbd_10_sub_pixel_avg_variance32x16, 1680 vpx_highbd_sad32x16x4d_bits10) 1681 1682 HIGHBD_BFP(BLOCK_16X32, vpx_highbd_sad16x32_bits10, 1683 vpx_highbd_sad16x32_avg_bits10, vpx_highbd_10_variance16x32, 1684 vpx_highbd_10_sub_pixel_variance16x32, 1685 vpx_highbd_10_sub_pixel_avg_variance16x32, 1686 vpx_highbd_sad16x32x4d_bits10) 1687 1688 HIGHBD_BFP(BLOCK_64X32, vpx_highbd_sad64x32_bits10, 1689 vpx_highbd_sad64x32_avg_bits10, vpx_highbd_10_variance64x32, 1690 vpx_highbd_10_sub_pixel_variance64x32, 1691 vpx_highbd_10_sub_pixel_avg_variance64x32, 1692 vpx_highbd_sad64x32x4d_bits10) 1693 1694 HIGHBD_BFP(BLOCK_32X64, vpx_highbd_sad32x64_bits10, 1695 vpx_highbd_sad32x64_avg_bits10, vpx_highbd_10_variance32x64, 1696 vpx_highbd_10_sub_pixel_variance32x64, 1697 vpx_highbd_10_sub_pixel_avg_variance32x64, 1698 vpx_highbd_sad32x64x4d_bits10) 1699 1700 HIGHBD_BFP(BLOCK_32X32, vpx_highbd_sad32x32_bits10, 1701 vpx_highbd_sad32x32_avg_bits10, vpx_highbd_10_variance32x32, 1702 vpx_highbd_10_sub_pixel_variance32x32, 1703 vpx_highbd_10_sub_pixel_avg_variance32x32, 1704 vpx_highbd_sad32x32x4d_bits10) 1705 1706 HIGHBD_BFP(BLOCK_64X64, vpx_highbd_sad64x64_bits10, 1707 vpx_highbd_sad64x64_avg_bits10, vpx_highbd_10_variance64x64, 1708 vpx_highbd_10_sub_pixel_variance64x64, 1709 vpx_highbd_10_sub_pixel_avg_variance64x64, 1710 vpx_highbd_sad64x64x4d_bits10) 1711 1712 HIGHBD_BFP(BLOCK_16X16, vpx_highbd_sad16x16_bits10, 1713 vpx_highbd_sad16x16_avg_bits10, vpx_highbd_10_variance16x16, 1714 vpx_highbd_10_sub_pixel_variance16x16, 1715 vpx_highbd_10_sub_pixel_avg_variance16x16, 1716 vpx_highbd_sad16x16x4d_bits10) 1717 1718 HIGHBD_BFP(BLOCK_16X8, vpx_highbd_sad16x8_bits10, 1719 vpx_highbd_sad16x8_avg_bits10, vpx_highbd_10_variance16x8, 1720 vpx_highbd_10_sub_pixel_variance16x8, 1721 vpx_highbd_10_sub_pixel_avg_variance16x8, 1722 vpx_highbd_sad16x8x4d_bits10) 1723 1724 HIGHBD_BFP(BLOCK_8X16, vpx_highbd_sad8x16_bits10, 1725 vpx_highbd_sad8x16_avg_bits10, vpx_highbd_10_variance8x16, 1726 vpx_highbd_10_sub_pixel_variance8x16, 1727 vpx_highbd_10_sub_pixel_avg_variance8x16, 1728 vpx_highbd_sad8x16x4d_bits10) 1729 1730 HIGHBD_BFP(BLOCK_8X8, vpx_highbd_sad8x8_bits10, 1731 vpx_highbd_sad8x8_avg_bits10, vpx_highbd_10_variance8x8, 1732 vpx_highbd_10_sub_pixel_variance8x8, 1733 vpx_highbd_10_sub_pixel_avg_variance8x8, 1734 vpx_highbd_sad8x8x4d_bits10) 1735 1736 HIGHBD_BFP(BLOCK_8X4, vpx_highbd_sad8x4_bits10, 1737 vpx_highbd_sad8x4_avg_bits10, vpx_highbd_10_variance8x4, 1738 vpx_highbd_10_sub_pixel_variance8x4, 1739 vpx_highbd_10_sub_pixel_avg_variance8x4, 1740 vpx_highbd_sad8x4x4d_bits10) 1741 1742 HIGHBD_BFP(BLOCK_4X8, vpx_highbd_sad4x8_bits10, 1743 vpx_highbd_sad4x8_avg_bits10, vpx_highbd_10_variance4x8, 1744 vpx_highbd_10_sub_pixel_variance4x8, 1745 vpx_highbd_10_sub_pixel_avg_variance4x8, 1746 vpx_highbd_sad4x8x4d_bits10) 1747 1748 HIGHBD_BFP(BLOCK_4X4, vpx_highbd_sad4x4_bits10, 1749 vpx_highbd_sad4x4_avg_bits10, vpx_highbd_10_variance4x4, 1750 vpx_highbd_10_sub_pixel_variance4x4, 1751 vpx_highbd_10_sub_pixel_avg_variance4x4, 1752 vpx_highbd_sad4x4x4d_bits10) 1753 break; 1754 1755 default: 1756 assert(cm->bit_depth == VPX_BITS_12); 1757 HIGHBD_BFP(BLOCK_32X16, vpx_highbd_sad32x16_bits12, 1758 vpx_highbd_sad32x16_avg_bits12, vpx_highbd_12_variance32x16, 1759 vpx_highbd_12_sub_pixel_variance32x16, 1760 vpx_highbd_12_sub_pixel_avg_variance32x16, 1761 vpx_highbd_sad32x16x4d_bits12) 1762 1763 HIGHBD_BFP(BLOCK_16X32, vpx_highbd_sad16x32_bits12, 1764 vpx_highbd_sad16x32_avg_bits12, vpx_highbd_12_variance16x32, 1765 vpx_highbd_12_sub_pixel_variance16x32, 1766 vpx_highbd_12_sub_pixel_avg_variance16x32, 1767 vpx_highbd_sad16x32x4d_bits12) 1768 1769 HIGHBD_BFP(BLOCK_64X32, vpx_highbd_sad64x32_bits12, 1770 vpx_highbd_sad64x32_avg_bits12, vpx_highbd_12_variance64x32, 1771 vpx_highbd_12_sub_pixel_variance64x32, 1772 vpx_highbd_12_sub_pixel_avg_variance64x32, 1773 vpx_highbd_sad64x32x4d_bits12) 1774 1775 HIGHBD_BFP(BLOCK_32X64, vpx_highbd_sad32x64_bits12, 1776 vpx_highbd_sad32x64_avg_bits12, vpx_highbd_12_variance32x64, 1777 vpx_highbd_12_sub_pixel_variance32x64, 1778 vpx_highbd_12_sub_pixel_avg_variance32x64, 1779 vpx_highbd_sad32x64x4d_bits12) 1780 1781 HIGHBD_BFP(BLOCK_32X32, vpx_highbd_sad32x32_bits12, 1782 vpx_highbd_sad32x32_avg_bits12, vpx_highbd_12_variance32x32, 1783 vpx_highbd_12_sub_pixel_variance32x32, 1784 vpx_highbd_12_sub_pixel_avg_variance32x32, 1785 vpx_highbd_sad32x32x4d_bits12) 1786 1787 HIGHBD_BFP(BLOCK_64X64, vpx_highbd_sad64x64_bits12, 1788 vpx_highbd_sad64x64_avg_bits12, vpx_highbd_12_variance64x64, 1789 vpx_highbd_12_sub_pixel_variance64x64, 1790 vpx_highbd_12_sub_pixel_avg_variance64x64, 1791 vpx_highbd_sad64x64x4d_bits12) 1792 1793 HIGHBD_BFP(BLOCK_16X16, vpx_highbd_sad16x16_bits12, 1794 vpx_highbd_sad16x16_avg_bits12, vpx_highbd_12_variance16x16, 1795 vpx_highbd_12_sub_pixel_variance16x16, 1796 vpx_highbd_12_sub_pixel_avg_variance16x16, 1797 vpx_highbd_sad16x16x4d_bits12) 1798 1799 HIGHBD_BFP(BLOCK_16X8, vpx_highbd_sad16x8_bits12, 1800 vpx_highbd_sad16x8_avg_bits12, vpx_highbd_12_variance16x8, 1801 vpx_highbd_12_sub_pixel_variance16x8, 1802 vpx_highbd_12_sub_pixel_avg_variance16x8, 1803 vpx_highbd_sad16x8x4d_bits12) 1804 1805 HIGHBD_BFP(BLOCK_8X16, vpx_highbd_sad8x16_bits12, 1806 vpx_highbd_sad8x16_avg_bits12, vpx_highbd_12_variance8x16, 1807 vpx_highbd_12_sub_pixel_variance8x16, 1808 vpx_highbd_12_sub_pixel_avg_variance8x16, 1809 vpx_highbd_sad8x16x4d_bits12) 1810 1811 HIGHBD_BFP(BLOCK_8X8, vpx_highbd_sad8x8_bits12, 1812 vpx_highbd_sad8x8_avg_bits12, vpx_highbd_12_variance8x8, 1813 vpx_highbd_12_sub_pixel_variance8x8, 1814 vpx_highbd_12_sub_pixel_avg_variance8x8, 1815 vpx_highbd_sad8x8x4d_bits12) 1816 1817 HIGHBD_BFP(BLOCK_8X4, vpx_highbd_sad8x4_bits12, 1818 vpx_highbd_sad8x4_avg_bits12, vpx_highbd_12_variance8x4, 1819 vpx_highbd_12_sub_pixel_variance8x4, 1820 vpx_highbd_12_sub_pixel_avg_variance8x4, 1821 vpx_highbd_sad8x4x4d_bits12) 1822 1823 HIGHBD_BFP(BLOCK_4X8, vpx_highbd_sad4x8_bits12, 1824 vpx_highbd_sad4x8_avg_bits12, vpx_highbd_12_variance4x8, 1825 vpx_highbd_12_sub_pixel_variance4x8, 1826 vpx_highbd_12_sub_pixel_avg_variance4x8, 1827 vpx_highbd_sad4x8x4d_bits12) 1828 1829 HIGHBD_BFP(BLOCK_4X4, vpx_highbd_sad4x4_bits12, 1830 vpx_highbd_sad4x4_avg_bits12, vpx_highbd_12_variance4x4, 1831 vpx_highbd_12_sub_pixel_variance4x4, 1832 vpx_highbd_12_sub_pixel_avg_variance4x4, 1833 vpx_highbd_sad4x4x4d_bits12) 1834 break; 1835 } 1836 } 1837 } 1838 #endif // CONFIG_VP9_HIGHBITDEPTH 1839 1840 static void realloc_segmentation_maps(VP9_COMP *cpi) { 1841 VP9_COMMON *const cm = &cpi->common; 1842 1843 // Create the encoder segmentation map and set all entries to 0 1844 vpx_free(cpi->segmentation_map); 1845 CHECK_MEM_ERROR(cm, cpi->segmentation_map, 1846 vpx_calloc(cm->mi_rows * cm->mi_cols, 1)); 1847 1848 // Create a map used for cyclic background refresh. 1849 if (cpi->cyclic_refresh) vp9_cyclic_refresh_free(cpi->cyclic_refresh); 1850 CHECK_MEM_ERROR(cm, cpi->cyclic_refresh, 1851 vp9_cyclic_refresh_alloc(cm->mi_rows, cm->mi_cols)); 1852 1853 // Create a map used to mark inactive areas. 1854 vpx_free(cpi->active_map.map); 1855 CHECK_MEM_ERROR(cm, cpi->active_map.map, 1856 vpx_calloc(cm->mi_rows * cm->mi_cols, 1)); 1857 1858 // And a place holder structure is the coding context 1859 // for use if we want to save and restore it 1860 vpx_free(cpi->coding_context.last_frame_seg_map_copy); 1861 CHECK_MEM_ERROR(cm, cpi->coding_context.last_frame_seg_map_copy, 1862 vpx_calloc(cm->mi_rows * cm->mi_cols, 1)); 1863 } 1864 1865 static void alloc_copy_partition_data(VP9_COMP *cpi) { 1866 VP9_COMMON *const cm = &cpi->common; 1867 if (cpi->prev_partition == NULL) { 1868 CHECK_MEM_ERROR(cm, cpi->prev_partition, 1869 (BLOCK_SIZE *)vpx_calloc(cm->mi_stride * cm->mi_rows, 1870 sizeof(*cpi->prev_partition))); 1871 } 1872 if (cpi->prev_segment_id == NULL) { 1873 CHECK_MEM_ERROR( 1874 cm, cpi->prev_segment_id, 1875 (int8_t *)vpx_calloc((cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1), 1876 sizeof(*cpi->prev_segment_id))); 1877 } 1878 if (cpi->prev_variance_low == NULL) { 1879 CHECK_MEM_ERROR(cm, cpi->prev_variance_low, 1880 (uint8_t *)vpx_calloc( 1881 (cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1) * 25, 1882 sizeof(*cpi->prev_variance_low))); 1883 } 1884 if (cpi->copied_frame_cnt == NULL) { 1885 CHECK_MEM_ERROR( 1886 cm, cpi->copied_frame_cnt, 1887 (uint8_t *)vpx_calloc((cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1), 1888 sizeof(*cpi->copied_frame_cnt))); 1889 } 1890 } 1891 1892 void vp9_change_config(struct VP9_COMP *cpi, const VP9EncoderConfig *oxcf) { 1893 VP9_COMMON *const cm = &cpi->common; 1894 RATE_CONTROL *const rc = &cpi->rc; 1895 int last_w = cpi->oxcf.width; 1896 int last_h = cpi->oxcf.height; 1897 1898 vp9_init_quantizer(cpi); 1899 if (cm->profile != oxcf->profile) cm->profile = oxcf->profile; 1900 cm->bit_depth = oxcf->bit_depth; 1901 cm->color_space = oxcf->color_space; 1902 cm->color_range = oxcf->color_range; 1903 1904 cpi->target_level = oxcf->target_level; 1905 cpi->keep_level_stats = oxcf->target_level != LEVEL_MAX; 1906 set_level_constraint(&cpi->level_constraint, 1907 get_level_index(cpi->target_level)); 1908 1909 if (cm->profile <= PROFILE_1) 1910 assert(cm->bit_depth == VPX_BITS_8); 1911 else 1912 assert(cm->bit_depth > VPX_BITS_8); 1913 1914 cpi->oxcf = *oxcf; 1915 #if CONFIG_VP9_HIGHBITDEPTH 1916 cpi->td.mb.e_mbd.bd = (int)cm->bit_depth; 1917 #endif // CONFIG_VP9_HIGHBITDEPTH 1918 1919 if ((oxcf->pass == 0) && (oxcf->rc_mode == VPX_Q)) { 1920 rc->baseline_gf_interval = FIXED_GF_INTERVAL; 1921 } else { 1922 rc->baseline_gf_interval = (MIN_GF_INTERVAL + MAX_GF_INTERVAL) / 2; 1923 } 1924 1925 cpi->refresh_golden_frame = 0; 1926 cpi->refresh_last_frame = 1; 1927 cm->refresh_frame_context = 1; 1928 cm->reset_frame_context = 0; 1929 1930 vp9_reset_segment_features(&cm->seg); 1931 vp9_set_high_precision_mv(cpi, 0); 1932 1933 { 1934 int i; 1935 1936 for (i = 0; i < MAX_SEGMENTS; i++) 1937 cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout; 1938 } 1939 cpi->encode_breakout = cpi->oxcf.encode_breakout; 1940 1941 set_rc_buffer_sizes(rc, &cpi->oxcf); 1942 1943 // Under a configuration change, where maximum_buffer_size may change, 1944 // keep buffer level clipped to the maximum allowed buffer size. 1945 rc->bits_off_target = VPXMIN(rc->bits_off_target, rc->maximum_buffer_size); 1946 rc->buffer_level = VPXMIN(rc->buffer_level, rc->maximum_buffer_size); 1947 1948 // Set up frame rate and related parameters rate control values. 1949 vp9_new_framerate(cpi, cpi->framerate); 1950 1951 // Set absolute upper and lower quality limits 1952 rc->worst_quality = cpi->oxcf.worst_allowed_q; 1953 rc->best_quality = cpi->oxcf.best_allowed_q; 1954 1955 cm->interp_filter = cpi->sf.default_interp_filter; 1956 1957 if (cpi->oxcf.render_width > 0 && cpi->oxcf.render_height > 0) { 1958 cm->render_width = cpi->oxcf.render_width; 1959 cm->render_height = cpi->oxcf.render_height; 1960 } else { 1961 cm->render_width = cpi->oxcf.width; 1962 cm->render_height = cpi->oxcf.height; 1963 } 1964 if (last_w != cpi->oxcf.width || last_h != cpi->oxcf.height) { 1965 cm->width = cpi->oxcf.width; 1966 cm->height = cpi->oxcf.height; 1967 cpi->external_resize = 1; 1968 } 1969 1970 if (cpi->initial_width) { 1971 int new_mi_size = 0; 1972 vp9_set_mb_mi(cm, cm->width, cm->height); 1973 new_mi_size = cm->mi_stride * calc_mi_size(cm->mi_rows); 1974 if (cm->mi_alloc_size < new_mi_size) { 1975 vp9_free_context_buffers(cm); 1976 alloc_compressor_data(cpi); 1977 realloc_segmentation_maps(cpi); 1978 cpi->initial_width = cpi->initial_height = 0; 1979 cpi->external_resize = 0; 1980 } else if (cm->mi_alloc_size == new_mi_size && 1981 (cpi->oxcf.width > last_w || cpi->oxcf.height > last_h)) { 1982 vp9_alloc_loop_filter(cm); 1983 } 1984 } 1985 1986 if (cm->current_video_frame == 0 || last_w != cpi->oxcf.width || 1987 last_h != cpi->oxcf.height) 1988 update_frame_size(cpi); 1989 1990 if (last_w != cpi->oxcf.width || last_h != cpi->oxcf.height) { 1991 memset(cpi->consec_zero_mv, 0, 1992 cm->mi_rows * cm->mi_cols * sizeof(*cpi->consec_zero_mv)); 1993 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) 1994 vp9_cyclic_refresh_reset_resize(cpi); 1995 rc->rc_1_frame = 0; 1996 rc->rc_2_frame = 0; 1997 } 1998 1999 if ((cpi->svc.number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) || 2000 ((cpi->svc.number_temporal_layers > 1 || 2001 cpi->svc.number_spatial_layers > 1) && 2002 cpi->oxcf.pass != 1)) { 2003 vp9_update_layer_context_change_config(cpi, 2004 (int)cpi->oxcf.target_bandwidth); 2005 } 2006 2007 // Check for resetting the rc flags (rc_1_frame, rc_2_frame) if the 2008 // configuration change has a large change in avg_frame_bandwidth. 2009 // For SVC check for resetting based on spatial layer average bandwidth. 2010 // Also reset buffer level to optimal level. 2011 if (cm->current_video_frame > 0) { 2012 if (cpi->use_svc) { 2013 vp9_svc_check_reset_layer_rc_flag(cpi); 2014 } else { 2015 if (rc->avg_frame_bandwidth > (3 * rc->last_avg_frame_bandwidth >> 1) || 2016 rc->avg_frame_bandwidth < (rc->last_avg_frame_bandwidth >> 1)) { 2017 rc->rc_1_frame = 0; 2018 rc->rc_2_frame = 0; 2019 rc->bits_off_target = rc->optimal_buffer_level; 2020 rc->buffer_level = rc->optimal_buffer_level; 2021 } 2022 } 2023 } 2024 2025 cpi->alt_ref_source = NULL; 2026 rc->is_src_frame_alt_ref = 0; 2027 2028 #if 0 2029 // Experimental RD Code 2030 cpi->frame_distortion = 0; 2031 cpi->last_frame_distortion = 0; 2032 #endif 2033 2034 set_tile_limits(cpi); 2035 2036 cpi->ext_refresh_frame_flags_pending = 0; 2037 cpi->ext_refresh_frame_context_pending = 0; 2038 2039 #if CONFIG_VP9_HIGHBITDEPTH 2040 highbd_set_var_fns(cpi); 2041 #endif 2042 2043 vp9_set_row_mt(cpi); 2044 } 2045 2046 #ifndef M_LOG2_E 2047 #define M_LOG2_E 0.693147180559945309417 2048 #endif 2049 #define log2f(x) (log(x) / (float)M_LOG2_E) 2050 2051 /*********************************************************************** 2052 * Read before modifying 'cal_nmvjointsadcost' or 'cal_nmvsadcosts' * 2053 *********************************************************************** 2054 * The following 2 functions ('cal_nmvjointsadcost' and * 2055 * 'cal_nmvsadcosts') are used to calculate cost lookup tables * 2056 * used by 'vp9_diamond_search_sad'. The C implementation of the * 2057 * function is generic, but the AVX intrinsics optimised version * 2058 * relies on the following properties of the computed tables: * 2059 * For cal_nmvjointsadcost: * 2060 * - mvjointsadcost[1] == mvjointsadcost[2] == mvjointsadcost[3] * 2061 * For cal_nmvsadcosts: * 2062 * - For all i: mvsadcost[0][i] == mvsadcost[1][i] * 2063 * (Equal costs for both components) * 2064 * - For all i: mvsadcost[0][i] == mvsadcost[0][-i] * 2065 * (Cost function is even) * 2066 * If these do not hold, then the AVX optimised version of the * 2067 * 'vp9_diamond_search_sad' function cannot be used as it is, in which * 2068 * case you can revert to using the C function instead. * 2069 ***********************************************************************/ 2070 2071 static void cal_nmvjointsadcost(int *mvjointsadcost) { 2072 /********************************************************************* 2073 * Warning: Read the comments above before modifying this function * 2074 *********************************************************************/ 2075 mvjointsadcost[0] = 600; 2076 mvjointsadcost[1] = 300; 2077 mvjointsadcost[2] = 300; 2078 mvjointsadcost[3] = 300; 2079 } 2080 2081 static void cal_nmvsadcosts(int *mvsadcost[2]) { 2082 /********************************************************************* 2083 * Warning: Read the comments above before modifying this function * 2084 *********************************************************************/ 2085 int i = 1; 2086 2087 mvsadcost[0][0] = 0; 2088 mvsadcost[1][0] = 0; 2089 2090 do { 2091 double z = 256 * (2 * (log2f(8 * i) + .6)); 2092 mvsadcost[0][i] = (int)z; 2093 mvsadcost[1][i] = (int)z; 2094 mvsadcost[0][-i] = (int)z; 2095 mvsadcost[1][-i] = (int)z; 2096 } while (++i <= MV_MAX); 2097 } 2098 2099 static void cal_nmvsadcosts_hp(int *mvsadcost[2]) { 2100 int i = 1; 2101 2102 mvsadcost[0][0] = 0; 2103 mvsadcost[1][0] = 0; 2104 2105 do { 2106 double z = 256 * (2 * (log2f(8 * i) + .6)); 2107 mvsadcost[0][i] = (int)z; 2108 mvsadcost[1][i] = (int)z; 2109 mvsadcost[0][-i] = (int)z; 2110 mvsadcost[1][-i] = (int)z; 2111 } while (++i <= MV_MAX); 2112 } 2113 2114 VP9_COMP *vp9_create_compressor(VP9EncoderConfig *oxcf, 2115 BufferPool *const pool) { 2116 unsigned int i; 2117 VP9_COMP *volatile const cpi = vpx_memalign(32, sizeof(VP9_COMP)); 2118 VP9_COMMON *volatile const cm = cpi != NULL ? &cpi->common : NULL; 2119 2120 if (!cm) return NULL; 2121 2122 vp9_zero(*cpi); 2123 2124 if (setjmp(cm->error.jmp)) { 2125 cm->error.setjmp = 0; 2126 vp9_remove_compressor(cpi); 2127 return 0; 2128 } 2129 2130 cm->error.setjmp = 1; 2131 cm->alloc_mi = vp9_enc_alloc_mi; 2132 cm->free_mi = vp9_enc_free_mi; 2133 cm->setup_mi = vp9_enc_setup_mi; 2134 2135 CHECK_MEM_ERROR(cm, cm->fc, (FRAME_CONTEXT *)vpx_calloc(1, sizeof(*cm->fc))); 2136 CHECK_MEM_ERROR( 2137 cm, cm->frame_contexts, 2138 (FRAME_CONTEXT *)vpx_calloc(FRAME_CONTEXTS, sizeof(*cm->frame_contexts))); 2139 2140 cpi->use_svc = 0; 2141 cpi->resize_state = ORIG; 2142 cpi->external_resize = 0; 2143 cpi->resize_avg_qp = 0; 2144 cpi->resize_buffer_underflow = 0; 2145 cpi->use_skin_detection = 0; 2146 cpi->common.buffer_pool = pool; 2147 2148 cpi->force_update_segmentation = 0; 2149 2150 init_config(cpi, oxcf); 2151 vp9_rc_init(&cpi->oxcf, oxcf->pass, &cpi->rc); 2152 2153 cm->current_video_frame = 0; 2154 cpi->partition_search_skippable_frame = 0; 2155 cpi->tile_data = NULL; 2156 2157 realloc_segmentation_maps(cpi); 2158 2159 CHECK_MEM_ERROR( 2160 cm, cpi->skin_map, 2161 vpx_calloc(cm->mi_rows * cm->mi_cols, sizeof(cpi->skin_map[0]))); 2162 2163 CHECK_MEM_ERROR(cm, cpi->alt_ref_aq, vp9_alt_ref_aq_create()); 2164 2165 CHECK_MEM_ERROR( 2166 cm, cpi->consec_zero_mv, 2167 vpx_calloc(cm->mi_rows * cm->mi_cols, sizeof(*cpi->consec_zero_mv))); 2168 2169 CHECK_MEM_ERROR(cm, cpi->nmvcosts[0], 2170 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts[0]))); 2171 CHECK_MEM_ERROR(cm, cpi->nmvcosts[1], 2172 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts[1]))); 2173 CHECK_MEM_ERROR(cm, cpi->nmvcosts_hp[0], 2174 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts_hp[0]))); 2175 CHECK_MEM_ERROR(cm, cpi->nmvcosts_hp[1], 2176 vpx_calloc(MV_VALS, sizeof(*cpi->nmvcosts_hp[1]))); 2177 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts[0], 2178 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts[0]))); 2179 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts[1], 2180 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts[1]))); 2181 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts_hp[0], 2182 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts_hp[0]))); 2183 CHECK_MEM_ERROR(cm, cpi->nmvsadcosts_hp[1], 2184 vpx_calloc(MV_VALS, sizeof(*cpi->nmvsadcosts_hp[1]))); 2185 2186 for (i = 0; i < (sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0])); 2187 i++) { 2188 CHECK_MEM_ERROR( 2189 cm, cpi->mbgraph_stats[i].mb_stats, 2190 vpx_calloc(cm->MBs * sizeof(*cpi->mbgraph_stats[i].mb_stats), 1)); 2191 } 2192 2193 #if CONFIG_FP_MB_STATS 2194 cpi->use_fp_mb_stats = 0; 2195 if (cpi->use_fp_mb_stats) { 2196 // a place holder used to store the first pass mb stats in the first pass 2197 CHECK_MEM_ERROR(cm, cpi->twopass.frame_mb_stats_buf, 2198 vpx_calloc(cm->MBs * sizeof(uint8_t), 1)); 2199 } else { 2200 cpi->twopass.frame_mb_stats_buf = NULL; 2201 } 2202 #endif 2203 2204 cpi->refresh_alt_ref_frame = 0; 2205 cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS; 2206 2207 init_level_info(&cpi->level_info); 2208 init_level_constraint(&cpi->level_constraint); 2209 2210 #if CONFIG_INTERNAL_STATS 2211 cpi->b_calculate_blockiness = 1; 2212 cpi->b_calculate_consistency = 1; 2213 cpi->total_inconsistency = 0; 2214 cpi->psnr.worst = 100.0; 2215 cpi->worst_ssim = 100.0; 2216 2217 cpi->count = 0; 2218 cpi->bytes = 0; 2219 2220 if (cpi->b_calculate_psnr) { 2221 cpi->total_sq_error = 0; 2222 cpi->total_samples = 0; 2223 2224 cpi->totalp_sq_error = 0; 2225 cpi->totalp_samples = 0; 2226 2227 cpi->tot_recode_hits = 0; 2228 cpi->summed_quality = 0; 2229 cpi->summed_weights = 0; 2230 cpi->summedp_quality = 0; 2231 cpi->summedp_weights = 0; 2232 } 2233 2234 cpi->fastssim.worst = 100.0; 2235 2236 cpi->psnrhvs.worst = 100.0; 2237 2238 if (cpi->b_calculate_blockiness) { 2239 cpi->total_blockiness = 0; 2240 cpi->worst_blockiness = 0.0; 2241 } 2242 2243 if (cpi->b_calculate_consistency) { 2244 CHECK_MEM_ERROR(cm, cpi->ssim_vars, 2245 vpx_calloc(cpi->common.mi_rows * cpi->common.mi_cols, 2246 sizeof(*cpi->ssim_vars) * 4)); 2247 cpi->worst_consistency = 100.0; 2248 } else { 2249 cpi->ssim_vars = NULL; 2250 } 2251 2252 #endif 2253 2254 cpi->first_time_stamp_ever = INT64_MAX; 2255 2256 /********************************************************************* 2257 * Warning: Read the comments around 'cal_nmvjointsadcost' and * 2258 * 'cal_nmvsadcosts' before modifying how these tables are computed. * 2259 *********************************************************************/ 2260 cal_nmvjointsadcost(cpi->td.mb.nmvjointsadcost); 2261 cpi->td.mb.nmvcost[0] = &cpi->nmvcosts[0][MV_MAX]; 2262 cpi->td.mb.nmvcost[1] = &cpi->nmvcosts[1][MV_MAX]; 2263 cpi->td.mb.nmvsadcost[0] = &cpi->nmvsadcosts[0][MV_MAX]; 2264 cpi->td.mb.nmvsadcost[1] = &cpi->nmvsadcosts[1][MV_MAX]; 2265 cal_nmvsadcosts(cpi->td.mb.nmvsadcost); 2266 2267 cpi->td.mb.nmvcost_hp[0] = &cpi->nmvcosts_hp[0][MV_MAX]; 2268 cpi->td.mb.nmvcost_hp[1] = &cpi->nmvcosts_hp[1][MV_MAX]; 2269 cpi->td.mb.nmvsadcost_hp[0] = &cpi->nmvsadcosts_hp[0][MV_MAX]; 2270 cpi->td.mb.nmvsadcost_hp[1] = &cpi->nmvsadcosts_hp[1][MV_MAX]; 2271 cal_nmvsadcosts_hp(cpi->td.mb.nmvsadcost_hp); 2272 2273 #if CONFIG_VP9_TEMPORAL_DENOISING 2274 #ifdef OUTPUT_YUV_DENOISED 2275 yuv_denoised_file = fopen("denoised.yuv", "ab"); 2276 #endif 2277 #endif 2278 #ifdef OUTPUT_YUV_SKINMAP 2279 yuv_skinmap_file = fopen("skinmap.yuv", "wb"); 2280 #endif 2281 #ifdef OUTPUT_YUV_REC 2282 yuv_rec_file = fopen("rec.yuv", "wb"); 2283 #endif 2284 #ifdef OUTPUT_YUV_SVC_SRC 2285 yuv_svc_src[0] = fopen("svc_src_0.yuv", "wb"); 2286 yuv_svc_src[1] = fopen("svc_src_1.yuv", "wb"); 2287 yuv_svc_src[2] = fopen("svc_src_2.yuv", "wb"); 2288 #endif 2289 2290 #if 0 2291 framepsnr = fopen("framepsnr.stt", "a"); 2292 kf_list = fopen("kf_list.stt", "w"); 2293 #endif 2294 2295 cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED; 2296 2297 #if !CONFIG_REALTIME_ONLY 2298 if (oxcf->pass == 1) { 2299 vp9_init_first_pass(cpi); 2300 } else if (oxcf->pass == 2) { 2301 const size_t packet_sz = sizeof(FIRSTPASS_STATS); 2302 const int packets = (int)(oxcf->two_pass_stats_in.sz / packet_sz); 2303 2304 if (cpi->svc.number_spatial_layers > 1 || 2305 cpi->svc.number_temporal_layers > 1) { 2306 FIRSTPASS_STATS *const stats = oxcf->two_pass_stats_in.buf; 2307 FIRSTPASS_STATS *stats_copy[VPX_SS_MAX_LAYERS] = { 0 }; 2308 int i; 2309 2310 for (i = 0; i < oxcf->ss_number_layers; ++i) { 2311 FIRSTPASS_STATS *const last_packet_for_layer = 2312 &stats[packets - oxcf->ss_number_layers + i]; 2313 const int layer_id = (int)last_packet_for_layer->spatial_layer_id; 2314 const int packets_in_layer = (int)last_packet_for_layer->count + 1; 2315 if (layer_id >= 0 && layer_id < oxcf->ss_number_layers) { 2316 LAYER_CONTEXT *const lc = &cpi->svc.layer_context[layer_id]; 2317 2318 vpx_free(lc->rc_twopass_stats_in.buf); 2319 2320 lc->rc_twopass_stats_in.sz = packets_in_layer * packet_sz; 2321 CHECK_MEM_ERROR(cm, lc->rc_twopass_stats_in.buf, 2322 vpx_malloc(lc->rc_twopass_stats_in.sz)); 2323 lc->twopass.stats_in_start = lc->rc_twopass_stats_in.buf; 2324 lc->twopass.stats_in = lc->twopass.stats_in_start; 2325 lc->twopass.stats_in_end = 2326 lc->twopass.stats_in_start + packets_in_layer - 1; 2327 stats_copy[layer_id] = lc->rc_twopass_stats_in.buf; 2328 } 2329 } 2330 2331 for (i = 0; i < packets; ++i) { 2332 const int layer_id = (int)stats[i].spatial_layer_id; 2333 if (layer_id >= 0 && layer_id < oxcf->ss_number_layers && 2334 stats_copy[layer_id] != NULL) { 2335 *stats_copy[layer_id] = stats[i]; 2336 ++stats_copy[layer_id]; 2337 } 2338 } 2339 2340 vp9_init_second_pass_spatial_svc(cpi); 2341 } else { 2342 #if CONFIG_FP_MB_STATS 2343 if (cpi->use_fp_mb_stats) { 2344 const size_t psz = cpi->common.MBs * sizeof(uint8_t); 2345 const int ps = (int)(oxcf->firstpass_mb_stats_in.sz / psz); 2346 2347 cpi->twopass.firstpass_mb_stats.mb_stats_start = 2348 oxcf->firstpass_mb_stats_in.buf; 2349 cpi->twopass.firstpass_mb_stats.mb_stats_end = 2350 cpi->twopass.firstpass_mb_stats.mb_stats_start + 2351 (ps - 1) * cpi->common.MBs * sizeof(uint8_t); 2352 } 2353 #endif 2354 2355 cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf; 2356 cpi->twopass.stats_in = cpi->twopass.stats_in_start; 2357 cpi->twopass.stats_in_end = &cpi->twopass.stats_in[packets - 1]; 2358 2359 vp9_init_second_pass(cpi); 2360 } 2361 } 2362 #endif // !CONFIG_REALTIME_ONLY 2363 2364 vp9_set_speed_features_framesize_independent(cpi); 2365 vp9_set_speed_features_framesize_dependent(cpi); 2366 2367 #if CONFIG_NON_GREEDY_MV 2368 cpi->feature_score_loc_alloc = 0; 2369 #endif // CONFIG_NON_GREEDY_MV 2370 for (i = 0; i < MAX_ARF_GOP_SIZE; ++i) cpi->tpl_stats[i].tpl_stats_ptr = NULL; 2371 2372 // Allocate memory to store variances for a frame. 2373 CHECK_MEM_ERROR(cm, cpi->source_diff_var, vpx_calloc(cm->MBs, sizeof(diff))); 2374 cpi->source_var_thresh = 0; 2375 cpi->frames_till_next_var_check = 0; 2376 2377 #define BFP(BT, SDF, SDAF, VF, SVF, SVAF, SDX4DF) \ 2378 cpi->fn_ptr[BT].sdf = SDF; \ 2379 cpi->fn_ptr[BT].sdaf = SDAF; \ 2380 cpi->fn_ptr[BT].vf = VF; \ 2381 cpi->fn_ptr[BT].svf = SVF; \ 2382 cpi->fn_ptr[BT].svaf = SVAF; \ 2383 cpi->fn_ptr[BT].sdx4df = SDX4DF; 2384 2385 BFP(BLOCK_32X16, vpx_sad32x16, vpx_sad32x16_avg, vpx_variance32x16, 2386 vpx_sub_pixel_variance32x16, vpx_sub_pixel_avg_variance32x16, 2387 vpx_sad32x16x4d) 2388 2389 BFP(BLOCK_16X32, vpx_sad16x32, vpx_sad16x32_avg, vpx_variance16x32, 2390 vpx_sub_pixel_variance16x32, vpx_sub_pixel_avg_variance16x32, 2391 vpx_sad16x32x4d) 2392 2393 BFP(BLOCK_64X32, vpx_sad64x32, vpx_sad64x32_avg, vpx_variance64x32, 2394 vpx_sub_pixel_variance64x32, vpx_sub_pixel_avg_variance64x32, 2395 vpx_sad64x32x4d) 2396 2397 BFP(BLOCK_32X64, vpx_sad32x64, vpx_sad32x64_avg, vpx_variance32x64, 2398 vpx_sub_pixel_variance32x64, vpx_sub_pixel_avg_variance32x64, 2399 vpx_sad32x64x4d) 2400 2401 BFP(BLOCK_32X32, vpx_sad32x32, vpx_sad32x32_avg, vpx_variance32x32, 2402 vpx_sub_pixel_variance32x32, vpx_sub_pixel_avg_variance32x32, 2403 vpx_sad32x32x4d) 2404 2405 BFP(BLOCK_64X64, vpx_sad64x64, vpx_sad64x64_avg, vpx_variance64x64, 2406 vpx_sub_pixel_variance64x64, vpx_sub_pixel_avg_variance64x64, 2407 vpx_sad64x64x4d) 2408 2409 BFP(BLOCK_16X16, vpx_sad16x16, vpx_sad16x16_avg, vpx_variance16x16, 2410 vpx_sub_pixel_variance16x16, vpx_sub_pixel_avg_variance16x16, 2411 vpx_sad16x16x4d) 2412 2413 BFP(BLOCK_16X8, vpx_sad16x8, vpx_sad16x8_avg, vpx_variance16x8, 2414 vpx_sub_pixel_variance16x8, vpx_sub_pixel_avg_variance16x8, 2415 vpx_sad16x8x4d) 2416 2417 BFP(BLOCK_8X16, vpx_sad8x16, vpx_sad8x16_avg, vpx_variance8x16, 2418 vpx_sub_pixel_variance8x16, vpx_sub_pixel_avg_variance8x16, 2419 vpx_sad8x16x4d) 2420 2421 BFP(BLOCK_8X8, vpx_sad8x8, vpx_sad8x8_avg, vpx_variance8x8, 2422 vpx_sub_pixel_variance8x8, vpx_sub_pixel_avg_variance8x8, vpx_sad8x8x4d) 2423 2424 BFP(BLOCK_8X4, vpx_sad8x4, vpx_sad8x4_avg, vpx_variance8x4, 2425 vpx_sub_pixel_variance8x4, vpx_sub_pixel_avg_variance8x4, vpx_sad8x4x4d) 2426 2427 BFP(BLOCK_4X8, vpx_sad4x8, vpx_sad4x8_avg, vpx_variance4x8, 2428 vpx_sub_pixel_variance4x8, vpx_sub_pixel_avg_variance4x8, vpx_sad4x8x4d) 2429 2430 BFP(BLOCK_4X4, vpx_sad4x4, vpx_sad4x4_avg, vpx_variance4x4, 2431 vpx_sub_pixel_variance4x4, vpx_sub_pixel_avg_variance4x4, vpx_sad4x4x4d) 2432 2433 #if CONFIG_VP9_HIGHBITDEPTH 2434 highbd_set_var_fns(cpi); 2435 #endif 2436 2437 /* vp9_init_quantizer() is first called here. Add check in 2438 * vp9_frame_init_quantizer() so that vp9_init_quantizer is only 2439 * called later when needed. This will avoid unnecessary calls of 2440 * vp9_init_quantizer() for every frame. 2441 */ 2442 vp9_init_quantizer(cpi); 2443 2444 vp9_loop_filter_init(cm); 2445 2446 // Set up the unit scaling factor used during motion search. 2447 #if CONFIG_VP9_HIGHBITDEPTH 2448 vp9_setup_scale_factors_for_frame(&cpi->me_sf, cm->width, cm->height, 2449 cm->width, cm->height, 2450 cm->use_highbitdepth); 2451 #else 2452 vp9_setup_scale_factors_for_frame(&cpi->me_sf, cm->width, cm->height, 2453 cm->width, cm->height); 2454 #endif // CONFIG_VP9_HIGHBITDEPTH 2455 cpi->td.mb.me_sf = &cpi->me_sf; 2456 2457 cm->error.setjmp = 0; 2458 2459 return cpi; 2460 } 2461 2462 #if CONFIG_INTERNAL_STATS 2463 #define SNPRINT(H, T) snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T)) 2464 2465 #define SNPRINT2(H, T, V) \ 2466 snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T), (V)) 2467 #endif // CONFIG_INTERNAL_STATS 2468 2469 void vp9_remove_compressor(VP9_COMP *cpi) { 2470 VP9_COMMON *cm; 2471 unsigned int i, frame; 2472 int t; 2473 2474 if (!cpi) return; 2475 2476 #if CONFIG_INTERNAL_STATS 2477 vpx_free(cpi->ssim_vars); 2478 #endif 2479 2480 cm = &cpi->common; 2481 if (cm->current_video_frame > 0) { 2482 #if CONFIG_INTERNAL_STATS 2483 vpx_clear_system_state(); 2484 2485 if (cpi->oxcf.pass != 1) { 2486 char headings[512] = { 0 }; 2487 char results[512] = { 0 }; 2488 FILE *f = fopen("opsnr.stt", "a"); 2489 double time_encoded = 2490 (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) / 2491 10000000.000; 2492 double total_encode_time = 2493 (cpi->time_receive_data + cpi->time_compress_data) / 1000.000; 2494 const double dr = 2495 (double)cpi->bytes * (double)8 / (double)1000 / time_encoded; 2496 const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1); 2497 const double target_rate = (double)cpi->oxcf.target_bandwidth / 1000; 2498 const double rate_err = ((100.0 * (dr - target_rate)) / target_rate); 2499 2500 if (cpi->b_calculate_psnr) { 2501 const double total_psnr = vpx_sse_to_psnr( 2502 (double)cpi->total_samples, peak, (double)cpi->total_sq_error); 2503 const double totalp_psnr = vpx_sse_to_psnr( 2504 (double)cpi->totalp_samples, peak, (double)cpi->totalp_sq_error); 2505 const double total_ssim = 2506 100 * pow(cpi->summed_quality / cpi->summed_weights, 8.0); 2507 const double totalp_ssim = 2508 100 * pow(cpi->summedp_quality / cpi->summedp_weights, 8.0); 2509 2510 snprintf(headings, sizeof(headings), 2511 "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\t" 2512 "VPXSSIM\tVPSSIMP\tFASTSIM\tPSNRHVS\t" 2513 "WstPsnr\tWstSsim\tWstFast\tWstHVS\t" 2514 "AVPsnrY\tAPsnrCb\tAPsnrCr"); 2515 snprintf(results, sizeof(results), 2516 "%7.2f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t" 2517 "%7.3f\t%7.3f\t%7.3f\t%7.3f\t" 2518 "%7.3f\t%7.3f\t%7.3f\t%7.3f\t" 2519 "%7.3f\t%7.3f\t%7.3f", 2520 dr, cpi->psnr.stat[ALL] / cpi->count, total_psnr, 2521 cpi->psnrp.stat[ALL] / cpi->count, totalp_psnr, total_ssim, 2522 totalp_ssim, cpi->fastssim.stat[ALL] / cpi->count, 2523 cpi->psnrhvs.stat[ALL] / cpi->count, cpi->psnr.worst, 2524 cpi->worst_ssim, cpi->fastssim.worst, cpi->psnrhvs.worst, 2525 cpi->psnr.stat[Y] / cpi->count, cpi->psnr.stat[U] / cpi->count, 2526 cpi->psnr.stat[V] / cpi->count); 2527 2528 if (cpi->b_calculate_blockiness) { 2529 SNPRINT(headings, "\t Block\tWstBlck"); 2530 SNPRINT2(results, "\t%7.3f", cpi->total_blockiness / cpi->count); 2531 SNPRINT2(results, "\t%7.3f", cpi->worst_blockiness); 2532 } 2533 2534 if (cpi->b_calculate_consistency) { 2535 double consistency = 2536 vpx_sse_to_psnr((double)cpi->totalp_samples, peak, 2537 (double)cpi->total_inconsistency); 2538 2539 SNPRINT(headings, "\tConsist\tWstCons"); 2540 SNPRINT2(results, "\t%7.3f", consistency); 2541 SNPRINT2(results, "\t%7.3f", cpi->worst_consistency); 2542 } 2543 2544 fprintf(f, "%s\t Time\tRcErr\tAbsErr\n", headings); 2545 fprintf(f, "%s\t%8.0f\t%7.2f\t%7.2f\n", results, total_encode_time, 2546 rate_err, fabs(rate_err)); 2547 } 2548 2549 fclose(f); 2550 } 2551 #endif 2552 2553 #if 0 2554 { 2555 printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000); 2556 printf("\n_frames recive_data encod_mb_row compress_frame Total\n"); 2557 printf("%6d %10ld %10ld %10ld %10ld\n", cpi->common.current_video_frame, 2558 cpi->time_receive_data / 1000, cpi->time_encode_sb_row / 1000, 2559 cpi->time_compress_data / 1000, 2560 (cpi->time_receive_data + cpi->time_compress_data) / 1000); 2561 } 2562 #endif 2563 } 2564 2565 #if CONFIG_VP9_TEMPORAL_DENOISING 2566 vp9_denoiser_free(&(cpi->denoiser)); 2567 #endif 2568 2569 #if CONFIG_NON_GREEDY_MV 2570 vpx_free(cpi->feature_score_loc_arr); 2571 vpx_free(cpi->feature_score_loc_sort); 2572 vpx_free(cpi->feature_score_loc_heap); 2573 #endif 2574 for (frame = 0; frame < MAX_ARF_GOP_SIZE; ++frame) { 2575 vpx_free(cpi->tpl_stats[frame].tpl_stats_ptr); 2576 cpi->tpl_stats[frame].is_valid = 0; 2577 } 2578 2579 for (t = 0; t < cpi->num_workers; ++t) { 2580 VPxWorker *const worker = &cpi->workers[t]; 2581 EncWorkerData *const thread_data = &cpi->tile_thr_data[t]; 2582 2583 // Deallocate allocated threads. 2584 vpx_get_worker_interface()->end(worker); 2585 2586 // Deallocate allocated thread data. 2587 if (t < cpi->num_workers - 1) { 2588 vpx_free(thread_data->td->counts); 2589 vp9_free_pc_tree(thread_data->td); 2590 vpx_free(thread_data->td); 2591 } 2592 } 2593 vpx_free(cpi->tile_thr_data); 2594 vpx_free(cpi->workers); 2595 vp9_row_mt_mem_dealloc(cpi); 2596 2597 if (cpi->num_workers > 1) { 2598 vp9_loop_filter_dealloc(&cpi->lf_row_sync); 2599 vp9_bitstream_encode_tiles_buffer_dealloc(cpi); 2600 } 2601 2602 vp9_alt_ref_aq_destroy(cpi->alt_ref_aq); 2603 2604 dealloc_compressor_data(cpi); 2605 2606 for (i = 0; i < sizeof(cpi->mbgraph_stats) / sizeof(cpi->mbgraph_stats[0]); 2607 ++i) { 2608 vpx_free(cpi->mbgraph_stats[i].mb_stats); 2609 } 2610 2611 #if CONFIG_FP_MB_STATS 2612 if (cpi->use_fp_mb_stats) { 2613 vpx_free(cpi->twopass.frame_mb_stats_buf); 2614 cpi->twopass.frame_mb_stats_buf = NULL; 2615 } 2616 #endif 2617 2618 vp9_remove_common(cm); 2619 vp9_free_ref_frame_buffers(cm->buffer_pool); 2620 #if CONFIG_VP9_POSTPROC 2621 vp9_free_postproc_buffers(cm); 2622 #endif 2623 vpx_free(cpi); 2624 2625 #if CONFIG_VP9_TEMPORAL_DENOISING 2626 #ifdef OUTPUT_YUV_DENOISED 2627 fclose(yuv_denoised_file); 2628 #endif 2629 #endif 2630 #ifdef OUTPUT_YUV_SKINMAP 2631 fclose(yuv_skinmap_file); 2632 #endif 2633 #ifdef OUTPUT_YUV_REC 2634 fclose(yuv_rec_file); 2635 #endif 2636 #ifdef OUTPUT_YUV_SVC_SRC 2637 fclose(yuv_svc_src[0]); 2638 fclose(yuv_svc_src[1]); 2639 fclose(yuv_svc_src[2]); 2640 #endif 2641 2642 #if 0 2643 2644 if (keyfile) 2645 fclose(keyfile); 2646 2647 if (framepsnr) 2648 fclose(framepsnr); 2649 2650 if (kf_list) 2651 fclose(kf_list); 2652 2653 #endif 2654 } 2655 2656 static void generate_psnr_packet(VP9_COMP *cpi) { 2657 struct vpx_codec_cx_pkt pkt; 2658 int i; 2659 PSNR_STATS psnr; 2660 #if CONFIG_VP9_HIGHBITDEPTH 2661 vpx_calc_highbd_psnr(cpi->raw_source_frame, cpi->common.frame_to_show, &psnr, 2662 cpi->td.mb.e_mbd.bd, cpi->oxcf.input_bit_depth); 2663 #else 2664 vpx_calc_psnr(cpi->raw_source_frame, cpi->common.frame_to_show, &psnr); 2665 #endif 2666 2667 for (i = 0; i < 4; ++i) { 2668 pkt.data.psnr.samples[i] = psnr.samples[i]; 2669 pkt.data.psnr.sse[i] = psnr.sse[i]; 2670 pkt.data.psnr.psnr[i] = psnr.psnr[i]; 2671 } 2672 pkt.kind = VPX_CODEC_PSNR_PKT; 2673 if (cpi->use_svc) 2674 cpi->svc 2675 .layer_context[cpi->svc.spatial_layer_id * 2676 cpi->svc.number_temporal_layers] 2677 .psnr_pkt = pkt.data.psnr; 2678 else 2679 vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt); 2680 } 2681 2682 int vp9_use_as_reference(VP9_COMP *cpi, int ref_frame_flags) { 2683 if (ref_frame_flags > 7) return -1; 2684 2685 cpi->ref_frame_flags = ref_frame_flags; 2686 return 0; 2687 } 2688 2689 void vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags) { 2690 cpi->ext_refresh_golden_frame = (ref_frame_flags & VP9_GOLD_FLAG) != 0; 2691 cpi->ext_refresh_alt_ref_frame = (ref_frame_flags & VP9_ALT_FLAG) != 0; 2692 cpi->ext_refresh_last_frame = (ref_frame_flags & VP9_LAST_FLAG) != 0; 2693 cpi->ext_refresh_frame_flags_pending = 1; 2694 } 2695 2696 static YV12_BUFFER_CONFIG *get_vp9_ref_frame_buffer( 2697 VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag) { 2698 MV_REFERENCE_FRAME ref_frame = NONE; 2699 if (ref_frame_flag == VP9_LAST_FLAG) 2700 ref_frame = LAST_FRAME; 2701 else if (ref_frame_flag == VP9_GOLD_FLAG) 2702 ref_frame = GOLDEN_FRAME; 2703 else if (ref_frame_flag == VP9_ALT_FLAG) 2704 ref_frame = ALTREF_FRAME; 2705 2706 return ref_frame == NONE ? NULL : get_ref_frame_buffer(cpi, ref_frame); 2707 } 2708 2709 int vp9_copy_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag, 2710 YV12_BUFFER_CONFIG *sd) { 2711 YV12_BUFFER_CONFIG *cfg = get_vp9_ref_frame_buffer(cpi, ref_frame_flag); 2712 if (cfg) { 2713 vpx_yv12_copy_frame(cfg, sd); 2714 return 0; 2715 } else { 2716 return -1; 2717 } 2718 } 2719 2720 int vp9_set_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag, 2721 YV12_BUFFER_CONFIG *sd) { 2722 YV12_BUFFER_CONFIG *cfg = get_vp9_ref_frame_buffer(cpi, ref_frame_flag); 2723 if (cfg) { 2724 vpx_yv12_copy_frame(sd, cfg); 2725 return 0; 2726 } else { 2727 return -1; 2728 } 2729 } 2730 2731 int vp9_update_entropy(VP9_COMP *cpi, int update) { 2732 cpi->ext_refresh_frame_context = update; 2733 cpi->ext_refresh_frame_context_pending = 1; 2734 return 0; 2735 } 2736 2737 #ifdef OUTPUT_YUV_REC 2738 void vp9_write_yuv_rec_frame(VP9_COMMON *cm) { 2739 YV12_BUFFER_CONFIG *s = cm->frame_to_show; 2740 uint8_t *src = s->y_buffer; 2741 int h = cm->height; 2742 2743 #if CONFIG_VP9_HIGHBITDEPTH 2744 if (s->flags & YV12_FLAG_HIGHBITDEPTH) { 2745 uint16_t *src16 = CONVERT_TO_SHORTPTR(s->y_buffer); 2746 2747 do { 2748 fwrite(src16, s->y_width, 2, yuv_rec_file); 2749 src16 += s->y_stride; 2750 } while (--h); 2751 2752 src16 = CONVERT_TO_SHORTPTR(s->u_buffer); 2753 h = s->uv_height; 2754 2755 do { 2756 fwrite(src16, s->uv_width, 2, yuv_rec_file); 2757 src16 += s->uv_stride; 2758 } while (--h); 2759 2760 src16 = CONVERT_TO_SHORTPTR(s->v_buffer); 2761 h = s->uv_height; 2762 2763 do { 2764 fwrite(src16, s->uv_width, 2, yuv_rec_file); 2765 src16 += s->uv_stride; 2766 } while (--h); 2767 2768 fflush(yuv_rec_file); 2769 return; 2770 } 2771 #endif // CONFIG_VP9_HIGHBITDEPTH 2772 2773 do { 2774 fwrite(src, s->y_width, 1, yuv_rec_file); 2775 src += s->y_stride; 2776 } while (--h); 2777 2778 src = s->u_buffer; 2779 h = s->uv_height; 2780 2781 do { 2782 fwrite(src, s->uv_width, 1, yuv_rec_file); 2783 src += s->uv_stride; 2784 } while (--h); 2785 2786 src = s->v_buffer; 2787 h = s->uv_height; 2788 2789 do { 2790 fwrite(src, s->uv_width, 1, yuv_rec_file); 2791 src += s->uv_stride; 2792 } while (--h); 2793 2794 fflush(yuv_rec_file); 2795 } 2796 #endif 2797 2798 #if CONFIG_VP9_HIGHBITDEPTH 2799 static void scale_and_extend_frame_nonnormative(const YV12_BUFFER_CONFIG *src, 2800 YV12_BUFFER_CONFIG *dst, 2801 int bd) { 2802 #else 2803 static void scale_and_extend_frame_nonnormative(const YV12_BUFFER_CONFIG *src, 2804 YV12_BUFFER_CONFIG *dst) { 2805 #endif // CONFIG_VP9_HIGHBITDEPTH 2806 // TODO(dkovalev): replace YV12_BUFFER_CONFIG with vpx_image_t 2807 int i; 2808 const uint8_t *const srcs[3] = { src->y_buffer, src->u_buffer, 2809 src->v_buffer }; 2810 const int src_strides[3] = { src->y_stride, src->uv_stride, src->uv_stride }; 2811 const int src_widths[3] = { src->y_crop_width, src->uv_crop_width, 2812 src->uv_crop_width }; 2813 const int src_heights[3] = { src->y_crop_height, src->uv_crop_height, 2814 src->uv_crop_height }; 2815 uint8_t *const dsts[3] = { dst->y_buffer, dst->u_buffer, dst->v_buffer }; 2816 const int dst_strides[3] = { dst->y_stride, dst->uv_stride, dst->uv_stride }; 2817 const int dst_widths[3] = { dst->y_crop_width, dst->uv_crop_width, 2818 dst->uv_crop_width }; 2819 const int dst_heights[3] = { dst->y_crop_height, dst->uv_crop_height, 2820 dst->uv_crop_height }; 2821 2822 for (i = 0; i < MAX_MB_PLANE; ++i) { 2823 #if CONFIG_VP9_HIGHBITDEPTH 2824 if (src->flags & YV12_FLAG_HIGHBITDEPTH) { 2825 vp9_highbd_resize_plane(srcs[i], src_heights[i], src_widths[i], 2826 src_strides[i], dsts[i], dst_heights[i], 2827 dst_widths[i], dst_strides[i], bd); 2828 } else { 2829 vp9_resize_plane(srcs[i], src_heights[i], src_widths[i], src_strides[i], 2830 dsts[i], dst_heights[i], dst_widths[i], dst_strides[i]); 2831 } 2832 #else 2833 vp9_resize_plane(srcs[i], src_heights[i], src_widths[i], src_strides[i], 2834 dsts[i], dst_heights[i], dst_widths[i], dst_strides[i]); 2835 #endif // CONFIG_VP9_HIGHBITDEPTH 2836 } 2837 vpx_extend_frame_borders(dst); 2838 } 2839 2840 #if CONFIG_VP9_HIGHBITDEPTH 2841 static void scale_and_extend_frame(const YV12_BUFFER_CONFIG *src, 2842 YV12_BUFFER_CONFIG *dst, int bd, 2843 INTERP_FILTER filter_type, 2844 int phase_scaler) { 2845 const int src_w = src->y_crop_width; 2846 const int src_h = src->y_crop_height; 2847 const int dst_w = dst->y_crop_width; 2848 const int dst_h = dst->y_crop_height; 2849 const uint8_t *const srcs[3] = { src->y_buffer, src->u_buffer, 2850 src->v_buffer }; 2851 const int src_strides[3] = { src->y_stride, src->uv_stride, src->uv_stride }; 2852 uint8_t *const dsts[3] = { dst->y_buffer, dst->u_buffer, dst->v_buffer }; 2853 const int dst_strides[3] = { dst->y_stride, dst->uv_stride, dst->uv_stride }; 2854 const InterpKernel *const kernel = vp9_filter_kernels[filter_type]; 2855 int x, y, i; 2856 2857 for (i = 0; i < MAX_MB_PLANE; ++i) { 2858 const int factor = (i == 0 || i == 3 ? 1 : 2); 2859 const int src_stride = src_strides[i]; 2860 const int dst_stride = dst_strides[i]; 2861 for (y = 0; y < dst_h; y += 16) { 2862 const int y_q4 = y * (16 / factor) * src_h / dst_h + phase_scaler; 2863 for (x = 0; x < dst_w; x += 16) { 2864 const int x_q4 = x * (16 / factor) * src_w / dst_w + phase_scaler; 2865 const uint8_t *src_ptr = srcs[i] + 2866 (y / factor) * src_h / dst_h * src_stride + 2867 (x / factor) * src_w / dst_w; 2868 uint8_t *dst_ptr = dsts[i] + (y / factor) * dst_stride + (x / factor); 2869 2870 if (src->flags & YV12_FLAG_HIGHBITDEPTH) { 2871 vpx_highbd_convolve8(CONVERT_TO_SHORTPTR(src_ptr), src_stride, 2872 CONVERT_TO_SHORTPTR(dst_ptr), dst_stride, kernel, 2873 x_q4 & 0xf, 16 * src_w / dst_w, y_q4 & 0xf, 2874 16 * src_h / dst_h, 16 / factor, 16 / factor, 2875 bd); 2876 } else { 2877 vpx_scaled_2d(src_ptr, src_stride, dst_ptr, dst_stride, kernel, 2878 x_q4 & 0xf, 16 * src_w / dst_w, y_q4 & 0xf, 2879 16 * src_h / dst_h, 16 / factor, 16 / factor); 2880 } 2881 } 2882 } 2883 } 2884 2885 vpx_extend_frame_borders(dst); 2886 } 2887 #endif // CONFIG_VP9_HIGHBITDEPTH 2888 2889 static int scale_down(VP9_COMP *cpi, int q) { 2890 RATE_CONTROL *const rc = &cpi->rc; 2891 GF_GROUP *const gf_group = &cpi->twopass.gf_group; 2892 int scale = 0; 2893 assert(frame_is_kf_gf_arf(cpi)); 2894 2895 if (rc->frame_size_selector == UNSCALED && 2896 q >= rc->rf_level_maxq[gf_group->rf_level[gf_group->index]]) { 2897 const int max_size_thresh = 2898 (int)(rate_thresh_mult[SCALE_STEP1] * 2899 VPXMAX(rc->this_frame_target, rc->avg_frame_bandwidth)); 2900 scale = rc->projected_frame_size > max_size_thresh ? 1 : 0; 2901 } 2902 return scale; 2903 } 2904 2905 static int big_rate_miss_high_threshold(VP9_COMP *cpi) { 2906 const RATE_CONTROL *const rc = &cpi->rc; 2907 int big_miss_high; 2908 2909 if (frame_is_kf_gf_arf(cpi)) 2910 big_miss_high = rc->this_frame_target * 3 / 2; 2911 else 2912 big_miss_high = rc->this_frame_target * 2; 2913 2914 return big_miss_high; 2915 } 2916 2917 static int big_rate_miss(VP9_COMP *cpi) { 2918 const RATE_CONTROL *const rc = &cpi->rc; 2919 int big_miss_high; 2920 int big_miss_low; 2921 2922 // Ignore for overlay frames 2923 if (rc->is_src_frame_alt_ref) { 2924 return 0; 2925 } else { 2926 big_miss_low = (rc->this_frame_target / 2); 2927 big_miss_high = big_rate_miss_high_threshold(cpi); 2928 2929 return (rc->projected_frame_size > big_miss_high) || 2930 (rc->projected_frame_size < big_miss_low); 2931 } 2932 } 2933 2934 // test in two pass for the first 2935 static int two_pass_first_group_inter(VP9_COMP *cpi) { 2936 if (cpi->oxcf.pass == 2) { 2937 TWO_PASS *const twopass = &cpi->twopass; 2938 GF_GROUP *const gf_group = &twopass->gf_group; 2939 const int gfg_index = gf_group->index; 2940 2941 if (gfg_index == 0) return gf_group->update_type[gfg_index] == LF_UPDATE; 2942 return gf_group->update_type[gfg_index - 1] != LF_UPDATE && 2943 gf_group->update_type[gfg_index] == LF_UPDATE; 2944 } else { 2945 return 0; 2946 } 2947 } 2948 2949 // Function to test for conditions that indicate we should loop 2950 // back and recode a frame. 2951 static int recode_loop_test(VP9_COMP *cpi, int high_limit, int low_limit, int q, 2952 int maxq, int minq) { 2953 const RATE_CONTROL *const rc = &cpi->rc; 2954 const VP9EncoderConfig *const oxcf = &cpi->oxcf; 2955 const int frame_is_kfgfarf = frame_is_kf_gf_arf(cpi); 2956 int force_recode = 0; 2957 2958 if ((rc->projected_frame_size >= rc->max_frame_bandwidth) || 2959 big_rate_miss(cpi) || (cpi->sf.recode_loop == ALLOW_RECODE) || 2960 (two_pass_first_group_inter(cpi) && 2961 (cpi->sf.recode_loop == ALLOW_RECODE_FIRST)) || 2962 (frame_is_kfgfarf && (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF))) { 2963 if (frame_is_kfgfarf && (oxcf->resize_mode == RESIZE_DYNAMIC) && 2964 scale_down(cpi, q)) { 2965 // Code this group at a lower resolution. 2966 cpi->resize_pending = 1; 2967 return 1; 2968 } 2969 2970 // Force recode for extreme overshoot. 2971 if ((rc->projected_frame_size >= rc->max_frame_bandwidth) || 2972 (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF && 2973 rc->projected_frame_size >= big_rate_miss_high_threshold(cpi))) { 2974 return 1; 2975 } 2976 2977 // TODO(agrange) high_limit could be greater than the scale-down threshold. 2978 if ((rc->projected_frame_size > high_limit && q < maxq) || 2979 (rc->projected_frame_size < low_limit && q > minq)) { 2980 force_recode = 1; 2981 } else if (cpi->oxcf.rc_mode == VPX_CQ) { 2982 // Deal with frame undershoot and whether or not we are 2983 // below the automatically set cq level. 2984 if (q > oxcf->cq_level && 2985 rc->projected_frame_size < ((rc->this_frame_target * 7) >> 3)) { 2986 force_recode = 1; 2987 } 2988 } 2989 } 2990 return force_recode; 2991 } 2992 2993 static void update_ref_frames(VP9_COMP *cpi) { 2994 VP9_COMMON *const cm = &cpi->common; 2995 BufferPool *const pool = cm->buffer_pool; 2996 GF_GROUP *const gf_group = &cpi->twopass.gf_group; 2997 2998 // Pop ARF. 2999 if (cm->show_existing_frame) { 3000 cpi->lst_fb_idx = cpi->alt_fb_idx; 3001 cpi->alt_fb_idx = 3002 stack_pop(gf_group->arf_index_stack, gf_group->stack_size); 3003 --gf_group->stack_size; 3004 } 3005 3006 // At this point the new frame has been encoded. 3007 // If any buffer copy / swapping is signaled it should be done here. 3008 if (cm->frame_type == KEY_FRAME) { 3009 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx], 3010 cm->new_fb_idx); 3011 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->alt_fb_idx], 3012 cm->new_fb_idx); 3013 } else if (vp9_preserve_existing_gf(cpi)) { 3014 // We have decided to preserve the previously existing golden frame as our 3015 // new ARF frame. However, in the short term in function 3016 // vp9_get_refresh_mask() we left it in the GF slot and, if 3017 // we're updating the GF with the current decoded frame, we save it to the 3018 // ARF slot instead. 3019 // We now have to update the ARF with the current frame and swap gld_fb_idx 3020 // and alt_fb_idx so that, overall, we've stored the old GF in the new ARF 3021 // slot and, if we're updating the GF, the current frame becomes the new GF. 3022 int tmp; 3023 3024 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->alt_fb_idx], 3025 cm->new_fb_idx); 3026 3027 tmp = cpi->alt_fb_idx; 3028 cpi->alt_fb_idx = cpi->gld_fb_idx; 3029 cpi->gld_fb_idx = tmp; 3030 } else { /* For non key/golden frames */ 3031 if (cpi->refresh_alt_ref_frame) { 3032 int arf_idx = gf_group->top_arf_idx; 3033 3034 // Push new ARF into stack. 3035 stack_push(gf_group->arf_index_stack, cpi->alt_fb_idx, 3036 gf_group->stack_size); 3037 ++gf_group->stack_size; 3038 3039 assert(arf_idx < REF_FRAMES); 3040 3041 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[arf_idx], cm->new_fb_idx); 3042 memcpy(cpi->interp_filter_selected[ALTREF_FRAME], 3043 cpi->interp_filter_selected[0], 3044 sizeof(cpi->interp_filter_selected[0])); 3045 3046 cpi->alt_fb_idx = arf_idx; 3047 } 3048 3049 if (cpi->refresh_golden_frame) { 3050 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx], 3051 cm->new_fb_idx); 3052 if (!cpi->rc.is_src_frame_alt_ref) 3053 memcpy(cpi->interp_filter_selected[GOLDEN_FRAME], 3054 cpi->interp_filter_selected[0], 3055 sizeof(cpi->interp_filter_selected[0])); 3056 else 3057 memcpy(cpi->interp_filter_selected[GOLDEN_FRAME], 3058 cpi->interp_filter_selected[ALTREF_FRAME], 3059 sizeof(cpi->interp_filter_selected[ALTREF_FRAME])); 3060 } 3061 } 3062 3063 if (cpi->refresh_last_frame) { 3064 ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->lst_fb_idx], 3065 cm->new_fb_idx); 3066 if (!cpi->rc.is_src_frame_alt_ref) 3067 memcpy(cpi->interp_filter_selected[LAST_FRAME], 3068 cpi->interp_filter_selected[0], 3069 sizeof(cpi->interp_filter_selected[0])); 3070 } 3071 3072 if (gf_group->update_type[gf_group->index] == MID_OVERLAY_UPDATE) { 3073 cpi->alt_fb_idx = 3074 stack_pop(gf_group->arf_index_stack, gf_group->stack_size); 3075 --gf_group->stack_size; 3076 } 3077 } 3078 3079 void vp9_update_reference_frames(VP9_COMP *cpi) { 3080 update_ref_frames(cpi); 3081 3082 #if CONFIG_VP9_TEMPORAL_DENOISING 3083 vp9_denoiser_update_ref_frame(cpi); 3084 #endif 3085 3086 if (is_one_pass_cbr_svc(cpi)) vp9_svc_update_ref_frame(cpi); 3087 } 3088 3089 static void loopfilter_frame(VP9_COMP *cpi, VP9_COMMON *cm) { 3090 MACROBLOCKD *xd = &cpi->td.mb.e_mbd; 3091 struct loopfilter *lf = &cm->lf; 3092 int is_reference_frame = 3093 (cm->frame_type == KEY_FRAME || cpi->refresh_last_frame || 3094 cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame); 3095 if (cpi->use_svc && 3096 cpi->svc.temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS) 3097 is_reference_frame = !cpi->svc.non_reference_frame; 3098 3099 // Skip loop filter in show_existing_frame mode. 3100 if (cm->show_existing_frame) { 3101 lf->filter_level = 0; 3102 return; 3103 } 3104 3105 if (xd->lossless) { 3106 lf->filter_level = 0; 3107 lf->last_filt_level = 0; 3108 } else { 3109 struct vpx_usec_timer timer; 3110 3111 vpx_clear_system_state(); 3112 3113 vpx_usec_timer_start(&timer); 3114 3115 if (!cpi->rc.is_src_frame_alt_ref) { 3116 if ((cpi->common.frame_type == KEY_FRAME) && 3117 (!cpi->rc.this_key_frame_forced)) { 3118 lf->last_filt_level = 0; 3119 } 3120 vp9_pick_filter_level(cpi->Source, cpi, cpi->sf.lpf_pick); 3121 lf->last_filt_level = lf->filter_level; 3122 } else { 3123 lf->filter_level = 0; 3124 } 3125 3126 vpx_usec_timer_mark(&timer); 3127 cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer); 3128 } 3129 3130 if (lf->filter_level > 0 && is_reference_frame) { 3131 vp9_build_mask_frame(cm, lf->filter_level, 0); 3132 3133 if (cpi->num_workers > 1) 3134 vp9_loop_filter_frame_mt(cm->frame_to_show, cm, xd->plane, 3135 lf->filter_level, 0, 0, cpi->workers, 3136 cpi->num_workers, &cpi->lf_row_sync); 3137 else 3138 vp9_loop_filter_frame(cm->frame_to_show, cm, xd, lf->filter_level, 0, 0); 3139 } 3140 3141 vpx_extend_frame_inner_borders(cm->frame_to_show); 3142 } 3143 3144 static INLINE void alloc_frame_mvs(VP9_COMMON *const cm, int buffer_idx) { 3145 RefCntBuffer *const new_fb_ptr = &cm->buffer_pool->frame_bufs[buffer_idx]; 3146 if (new_fb_ptr->mvs == NULL || new_fb_ptr->mi_rows < cm->mi_rows || 3147 new_fb_ptr->mi_cols < cm->mi_cols) { 3148 vpx_free(new_fb_ptr->mvs); 3149 CHECK_MEM_ERROR(cm, new_fb_ptr->mvs, 3150 (MV_REF *)vpx_calloc(cm->mi_rows * cm->mi_cols, 3151 sizeof(*new_fb_ptr->mvs))); 3152 new_fb_ptr->mi_rows = cm->mi_rows; 3153 new_fb_ptr->mi_cols = cm->mi_cols; 3154 } 3155 } 3156 3157 void vp9_scale_references(VP9_COMP *cpi) { 3158 VP9_COMMON *cm = &cpi->common; 3159 MV_REFERENCE_FRAME ref_frame; 3160 const VP9_REFFRAME ref_mask[3] = { VP9_LAST_FLAG, VP9_GOLD_FLAG, 3161 VP9_ALT_FLAG }; 3162 3163 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { 3164 // Need to convert from VP9_REFFRAME to index into ref_mask (subtract 1). 3165 if (cpi->ref_frame_flags & ref_mask[ref_frame - 1]) { 3166 BufferPool *const pool = cm->buffer_pool; 3167 const YV12_BUFFER_CONFIG *const ref = 3168 get_ref_frame_buffer(cpi, ref_frame); 3169 3170 if (ref == NULL) { 3171 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX; 3172 continue; 3173 } 3174 3175 #if CONFIG_VP9_HIGHBITDEPTH 3176 if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) { 3177 RefCntBuffer *new_fb_ptr = NULL; 3178 int force_scaling = 0; 3179 int new_fb = cpi->scaled_ref_idx[ref_frame - 1]; 3180 if (new_fb == INVALID_IDX) { 3181 new_fb = get_free_fb(cm); 3182 force_scaling = 1; 3183 } 3184 if (new_fb == INVALID_IDX) return; 3185 new_fb_ptr = &pool->frame_bufs[new_fb]; 3186 if (force_scaling || new_fb_ptr->buf.y_crop_width != cm->width || 3187 new_fb_ptr->buf.y_crop_height != cm->height) { 3188 if (vpx_realloc_frame_buffer(&new_fb_ptr->buf, cm->width, cm->height, 3189 cm->subsampling_x, cm->subsampling_y, 3190 cm->use_highbitdepth, 3191 VP9_ENC_BORDER_IN_PIXELS, 3192 cm->byte_alignment, NULL, NULL, NULL)) 3193 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR, 3194 "Failed to allocate frame buffer"); 3195 scale_and_extend_frame(ref, &new_fb_ptr->buf, (int)cm->bit_depth, 3196 EIGHTTAP, 0); 3197 cpi->scaled_ref_idx[ref_frame - 1] = new_fb; 3198 alloc_frame_mvs(cm, new_fb); 3199 } 3200 #else 3201 if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) { 3202 RefCntBuffer *new_fb_ptr = NULL; 3203 int force_scaling = 0; 3204 int new_fb = cpi->scaled_ref_idx[ref_frame - 1]; 3205 if (new_fb == INVALID_IDX) { 3206 new_fb = get_free_fb(cm); 3207 force_scaling = 1; 3208 } 3209 if (new_fb == INVALID_IDX) return; 3210 new_fb_ptr = &pool->frame_bufs[new_fb]; 3211 if (force_scaling || new_fb_ptr->buf.y_crop_width != cm->width || 3212 new_fb_ptr->buf.y_crop_height != cm->height) { 3213 if (vpx_realloc_frame_buffer(&new_fb_ptr->buf, cm->width, cm->height, 3214 cm->subsampling_x, cm->subsampling_y, 3215 VP9_ENC_BORDER_IN_PIXELS, 3216 cm->byte_alignment, NULL, NULL, NULL)) 3217 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR, 3218 "Failed to allocate frame buffer"); 3219 vp9_scale_and_extend_frame(ref, &new_fb_ptr->buf, EIGHTTAP, 0); 3220 cpi->scaled_ref_idx[ref_frame - 1] = new_fb; 3221 alloc_frame_mvs(cm, new_fb); 3222 } 3223 #endif // CONFIG_VP9_HIGHBITDEPTH 3224 } else { 3225 int buf_idx; 3226 RefCntBuffer *buf = NULL; 3227 if (cpi->oxcf.pass == 0 && !cpi->use_svc) { 3228 // Check for release of scaled reference. 3229 buf_idx = cpi->scaled_ref_idx[ref_frame - 1]; 3230 if (buf_idx != INVALID_IDX) { 3231 buf = &pool->frame_bufs[buf_idx]; 3232 --buf->ref_count; 3233 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX; 3234 } 3235 } 3236 buf_idx = get_ref_frame_buf_idx(cpi, ref_frame); 3237 buf = &pool->frame_bufs[buf_idx]; 3238 buf->buf.y_crop_width = ref->y_crop_width; 3239 buf->buf.y_crop_height = ref->y_crop_height; 3240 cpi->scaled_ref_idx[ref_frame - 1] = buf_idx; 3241 ++buf->ref_count; 3242 } 3243 } else { 3244 if (cpi->oxcf.pass != 0 || cpi->use_svc) 3245 cpi->scaled_ref_idx[ref_frame - 1] = INVALID_IDX; 3246 } 3247 } 3248 } 3249 3250 static void release_scaled_references(VP9_COMP *cpi) { 3251 VP9_COMMON *cm = &cpi->common; 3252 int i; 3253 if (cpi->oxcf.pass == 0 && !cpi->use_svc) { 3254 // Only release scaled references under certain conditions: 3255 // if reference will be updated, or if scaled reference has same resolution. 3256 int refresh[3]; 3257 refresh[0] = (cpi->refresh_last_frame) ? 1 : 0; 3258 refresh[1] = (cpi->refresh_golden_frame) ? 1 : 0; 3259 refresh[2] = (cpi->refresh_alt_ref_frame) ? 1 : 0; 3260 for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) { 3261 const int idx = cpi->scaled_ref_idx[i - 1]; 3262 if (idx != INVALID_IDX) { 3263 RefCntBuffer *const buf = &cm->buffer_pool->frame_bufs[idx]; 3264 const YV12_BUFFER_CONFIG *const ref = get_ref_frame_buffer(cpi, i); 3265 if (refresh[i - 1] || (buf->buf.y_crop_width == ref->y_crop_width && 3266 buf->buf.y_crop_height == ref->y_crop_height)) { 3267 --buf->ref_count; 3268 cpi->scaled_ref_idx[i - 1] = INVALID_IDX; 3269 } 3270 } 3271 } 3272 } else { 3273 for (i = 0; i < REFS_PER_FRAME; ++i) { 3274 const int idx = cpi->scaled_ref_idx[i]; 3275 if (idx != INVALID_IDX) { 3276 RefCntBuffer *const buf = &cm->buffer_pool->frame_bufs[idx]; 3277 --buf->ref_count; 3278 cpi->scaled_ref_idx[i] = INVALID_IDX; 3279 } 3280 } 3281 } 3282 } 3283 3284 static void full_to_model_count(unsigned int *model_count, 3285 unsigned int *full_count) { 3286 int n; 3287 model_count[ZERO_TOKEN] = full_count[ZERO_TOKEN]; 3288 model_count[ONE_TOKEN] = full_count[ONE_TOKEN]; 3289 model_count[TWO_TOKEN] = full_count[TWO_TOKEN]; 3290 for (n = THREE_TOKEN; n < EOB_TOKEN; ++n) 3291 model_count[TWO_TOKEN] += full_count[n]; 3292 model_count[EOB_MODEL_TOKEN] = full_count[EOB_TOKEN]; 3293 } 3294 3295 static void full_to_model_counts(vp9_coeff_count_model *model_count, 3296 vp9_coeff_count *full_count) { 3297 int i, j, k, l; 3298 3299 for (i = 0; i < PLANE_TYPES; ++i) 3300 for (j = 0; j < REF_TYPES; ++j) 3301 for (k = 0; k < COEF_BANDS; ++k) 3302 for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l) 3303 full_to_model_count(model_count[i][j][k][l], full_count[i][j][k][l]); 3304 } 3305 3306 #if 0 && CONFIG_INTERNAL_STATS 3307 static void output_frame_level_debug_stats(VP9_COMP *cpi) { 3308 VP9_COMMON *const cm = &cpi->common; 3309 FILE *const f = fopen("tmp.stt", cm->current_video_frame ? "a" : "w"); 3310 int64_t recon_err; 3311 3312 vpx_clear_system_state(); 3313 3314 #if CONFIG_VP9_HIGHBITDEPTH 3315 if (cm->use_highbitdepth) { 3316 recon_err = vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm)); 3317 } else { 3318 recon_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm)); 3319 } 3320 #else 3321 recon_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm)); 3322 #endif // CONFIG_VP9_HIGHBITDEPTH 3323 3324 3325 if (cpi->twopass.total_left_stats.coded_error != 0.0) { 3326 double dc_quant_devisor; 3327 #if CONFIG_VP9_HIGHBITDEPTH 3328 switch (cm->bit_depth) { 3329 case VPX_BITS_8: 3330 dc_quant_devisor = 4.0; 3331 break; 3332 case VPX_BITS_10: 3333 dc_quant_devisor = 16.0; 3334 break; 3335 default: 3336 assert(cm->bit_depth == VPX_BITS_12); 3337 dc_quant_devisor = 64.0; 3338 break; 3339 } 3340 #else 3341 dc_quant_devisor = 4.0; 3342 #endif 3343 3344 if (!cm->current_video_frame) { 3345 fprintf(f, "frame, width, height, last ts, last end ts, " 3346 "source_alt_ref_pending, source_alt_ref_active, " 3347 "this_frame_target, projected_frame_size, " 3348 "projected_frame_size / MBs, " 3349 "projected_frame_size - this_frame_target, " 3350 "vbr_bits_off_target, vbr_bits_off_target_fast, " 3351 "twopass.extend_minq, twopass.extend_minq_fast, " 3352 "total_target_vs_actual, " 3353 "starting_buffer_level - bits_off_target, " 3354 "total_actual_bits, base_qindex, q for base_qindex, " 3355 "dc quant, q for active_worst_quality, avg_q, q for oxcf.cq_level, " 3356 "refresh_last_frame, refresh_golden_frame, refresh_alt_ref_frame, " 3357 "frame_type, gfu_boost, " 3358 "twopass.bits_left, " 3359 "twopass.total_left_stats.coded_error, " 3360 "twopass.bits_left / (1 + twopass.total_left_stats.coded_error), " 3361 "tot_recode_hits, recon_err, kf_boost, " 3362 "twopass.kf_zeromotion_pct, twopass.fr_content_type, " 3363 "filter_level, seg.aq_av_offset\n"); 3364 } 3365 3366 fprintf(f, "%10u, %d, %d, %10"PRId64", %10"PRId64", %d, %d, %10d, %10d, " 3367 "%10d, %10d, %10"PRId64", %10"PRId64", %5d, %5d, %10"PRId64", " 3368 "%10"PRId64", %10"PRId64", %10d, %7.2lf, %7.2lf, %7.2lf, %7.2lf, " 3369 "%7.2lf, %6d, %6d, %5d, %5d, %5d, %10"PRId64", %10.3lf, %10lf, %8u, " 3370 "%10"PRId64", %10d, %10d, %10d, %10d, %10d\n", 3371 cpi->common.current_video_frame, 3372 cm->width, cm->height, 3373 cpi->last_time_stamp_seen, 3374 cpi->last_end_time_stamp_seen, 3375 cpi->rc.source_alt_ref_pending, 3376 cpi->rc.source_alt_ref_active, 3377 cpi->rc.this_frame_target, 3378 cpi->rc.projected_frame_size, 3379 cpi->rc.projected_frame_size / cpi->common.MBs, 3380 (cpi->rc.projected_frame_size - cpi->rc.this_frame_target), 3381 cpi->rc.vbr_bits_off_target, 3382 cpi->rc.vbr_bits_off_target_fast, 3383 cpi->twopass.extend_minq, 3384 cpi->twopass.extend_minq_fast, 3385 cpi->rc.total_target_vs_actual, 3386 (cpi->rc.starting_buffer_level - cpi->rc.bits_off_target), 3387 cpi->rc.total_actual_bits, cm->base_qindex, 3388 vp9_convert_qindex_to_q(cm->base_qindex, cm->bit_depth), 3389 (double)vp9_dc_quant(cm->base_qindex, 0, cm->bit_depth) / 3390 dc_quant_devisor, 3391 vp9_convert_qindex_to_q(cpi->twopass.active_worst_quality, 3392 cm->bit_depth), 3393 cpi->rc.avg_q, 3394 vp9_convert_qindex_to_q(cpi->oxcf.cq_level, cm->bit_depth), 3395 cpi->refresh_last_frame, cpi->refresh_golden_frame, 3396 cpi->refresh_alt_ref_frame, cm->frame_type, cpi->rc.gfu_boost, 3397 cpi->twopass.bits_left, 3398 cpi->twopass.total_left_stats.coded_error, 3399 cpi->twopass.bits_left / 3400 (1 + cpi->twopass.total_left_stats.coded_error), 3401 cpi->tot_recode_hits, recon_err, cpi->rc.kf_boost, 3402 cpi->twopass.kf_zeromotion_pct, 3403 cpi->twopass.fr_content_type, 3404 cm->lf.filter_level, 3405 cm->seg.aq_av_offset); 3406 } 3407 fclose(f); 3408 3409 if (0) { 3410 FILE *const fmodes = fopen("Modes.stt", "a"); 3411 int i; 3412 3413 fprintf(fmodes, "%6d:%1d:%1d:%1d ", cpi->common.current_video_frame, 3414 cm->frame_type, cpi->refresh_golden_frame, 3415 cpi->refresh_alt_ref_frame); 3416 3417 for (i = 0; i < MAX_MODES; ++i) 3418 fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]); 3419 3420 fprintf(fmodes, "\n"); 3421 3422 fclose(fmodes); 3423 } 3424 } 3425 #endif 3426 3427 static void set_mv_search_params(VP9_COMP *cpi) { 3428 const VP9_COMMON *const cm = &cpi->common; 3429 const unsigned int max_mv_def = VPXMIN(cm->width, cm->height); 3430 3431 // Default based on max resolution. 3432 cpi->mv_step_param = vp9_init_search_range(max_mv_def); 3433 3434 if (cpi->sf.mv.auto_mv_step_size) { 3435 if (frame_is_intra_only(cm)) { 3436 // Initialize max_mv_magnitude for use in the first INTER frame 3437 // after a key/intra-only frame. 3438 cpi->max_mv_magnitude = max_mv_def; 3439 } else { 3440 if (cm->show_frame) { 3441 // Allow mv_steps to correspond to twice the max mv magnitude found 3442 // in the previous frame, capped by the default max_mv_magnitude based 3443 // on resolution. 3444 cpi->mv_step_param = vp9_init_search_range( 3445 VPXMIN(max_mv_def, 2 * cpi->max_mv_magnitude)); 3446 } 3447 cpi->max_mv_magnitude = 0; 3448 } 3449 } 3450 } 3451 3452 static void set_size_independent_vars(VP9_COMP *cpi) { 3453 vp9_set_speed_features_framesize_independent(cpi); 3454 vp9_set_rd_speed_thresholds(cpi); 3455 vp9_set_rd_speed_thresholds_sub8x8(cpi); 3456 cpi->common.interp_filter = cpi->sf.default_interp_filter; 3457 } 3458 3459 static void set_size_dependent_vars(VP9_COMP *cpi, int *q, int *bottom_index, 3460 int *top_index) { 3461 VP9_COMMON *const cm = &cpi->common; 3462 3463 // Setup variables that depend on the dimensions of the frame. 3464 vp9_set_speed_features_framesize_dependent(cpi); 3465 3466 // Decide q and q bounds. 3467 *q = vp9_rc_pick_q_and_bounds(cpi, bottom_index, top_index); 3468 3469 if (cpi->oxcf.rc_mode == VPX_CBR && cpi->rc.force_max_q) { 3470 *q = cpi->rc.worst_quality; 3471 cpi->rc.force_max_q = 0; 3472 } 3473 3474 if (!frame_is_intra_only(cm)) { 3475 vp9_set_high_precision_mv(cpi, (*q) < HIGH_PRECISION_MV_QTHRESH); 3476 } 3477 3478 #if !CONFIG_REALTIME_ONLY 3479 // Configure experimental use of segmentation for enhanced coding of 3480 // static regions if indicated. 3481 // Only allowed in the second pass of a two pass encode, as it requires 3482 // lagged coding, and if the relevant speed feature flag is set. 3483 if (cpi->oxcf.pass == 2 && cpi->sf.static_segmentation) 3484 configure_static_seg_features(cpi); 3485 #endif // !CONFIG_REALTIME_ONLY 3486 3487 #if CONFIG_VP9_POSTPROC && !(CONFIG_VP9_TEMPORAL_DENOISING) 3488 if (cpi->oxcf.noise_sensitivity > 0) { 3489 int l = 0; 3490 switch (cpi->oxcf.noise_sensitivity) { 3491 case 1: l = 20; break; 3492 case 2: l = 40; break; 3493 case 3: l = 60; break; 3494 case 4: 3495 case 5: l = 100; break; 3496 case 6: l = 150; break; 3497 } 3498 if (!cpi->common.postproc_state.limits) { 3499 cpi->common.postproc_state.limits = 3500 vpx_calloc(cpi->un_scaled_source->y_width, 3501 sizeof(*cpi->common.postproc_state.limits)); 3502 } 3503 vp9_denoise(cpi->Source, cpi->Source, l, cpi->common.postproc_state.limits); 3504 } 3505 #endif // CONFIG_VP9_POSTPROC 3506 } 3507 3508 #if CONFIG_VP9_TEMPORAL_DENOISING 3509 static void setup_denoiser_buffer(VP9_COMP *cpi) { 3510 VP9_COMMON *const cm = &cpi->common; 3511 if (cpi->oxcf.noise_sensitivity > 0 && 3512 !cpi->denoiser.frame_buffer_initialized) { 3513 if (vp9_denoiser_alloc(cm, &cpi->svc, &cpi->denoiser, cpi->use_svc, 3514 cpi->oxcf.noise_sensitivity, cm->width, cm->height, 3515 cm->subsampling_x, cm->subsampling_y, 3516 #if CONFIG_VP9_HIGHBITDEPTH 3517 cm->use_highbitdepth, 3518 #endif 3519 VP9_ENC_BORDER_IN_PIXELS)) 3520 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR, 3521 "Failed to allocate denoiser"); 3522 } 3523 } 3524 #endif 3525 3526 static void init_motion_estimation(VP9_COMP *cpi) { 3527 int y_stride = cpi->scaled_source.y_stride; 3528 3529 if (cpi->sf.mv.search_method == NSTEP) { 3530 vp9_init3smotion_compensation(&cpi->ss_cfg, y_stride); 3531 } else if (cpi->sf.mv.search_method == DIAMOND) { 3532 vp9_init_dsmotion_compensation(&cpi->ss_cfg, y_stride); 3533 } 3534 } 3535 3536 static void set_frame_size(VP9_COMP *cpi) { 3537 int ref_frame; 3538 VP9_COMMON *const cm = &cpi->common; 3539 VP9EncoderConfig *const oxcf = &cpi->oxcf; 3540 MACROBLOCKD *const xd = &cpi->td.mb.e_mbd; 3541 3542 #if !CONFIG_REALTIME_ONLY 3543 if (oxcf->pass == 2 && oxcf->rc_mode == VPX_VBR && 3544 ((oxcf->resize_mode == RESIZE_FIXED && cm->current_video_frame == 0) || 3545 (oxcf->resize_mode == RESIZE_DYNAMIC && cpi->resize_pending))) { 3546 calculate_coded_size(cpi, &oxcf->scaled_frame_width, 3547 &oxcf->scaled_frame_height); 3548 3549 // There has been a change in frame size. 3550 vp9_set_size_literal(cpi, oxcf->scaled_frame_width, 3551 oxcf->scaled_frame_height); 3552 } 3553 #endif // !CONFIG_REALTIME_ONLY 3554 3555 if (oxcf->pass == 0 && oxcf->rc_mode == VPX_CBR && !cpi->use_svc && 3556 oxcf->resize_mode == RESIZE_DYNAMIC && cpi->resize_pending != 0) { 3557 oxcf->scaled_frame_width = 3558 (oxcf->width * cpi->resize_scale_num) / cpi->resize_scale_den; 3559 oxcf->scaled_frame_height = 3560 (oxcf->height * cpi->resize_scale_num) / cpi->resize_scale_den; 3561 // There has been a change in frame size. 3562 vp9_set_size_literal(cpi, oxcf->scaled_frame_width, 3563 oxcf->scaled_frame_height); 3564 3565 // TODO(agrange) Scale cpi->max_mv_magnitude if frame-size has changed. 3566 set_mv_search_params(cpi); 3567 3568 vp9_noise_estimate_init(&cpi->noise_estimate, cm->width, cm->height); 3569 #if CONFIG_VP9_TEMPORAL_DENOISING 3570 // Reset the denoiser on the resized frame. 3571 if (cpi->oxcf.noise_sensitivity > 0) { 3572 vp9_denoiser_free(&(cpi->denoiser)); 3573 setup_denoiser_buffer(cpi); 3574 // Dynamic resize is only triggered for non-SVC, so we can force 3575 // golden frame update here as temporary fix to denoiser. 3576 cpi->refresh_golden_frame = 1; 3577 } 3578 #endif 3579 } 3580 3581 if ((oxcf->pass == 2) && !cpi->use_svc) { 3582 vp9_set_target_rate(cpi); 3583 } 3584 3585 alloc_frame_mvs(cm, cm->new_fb_idx); 3586 3587 // Reset the frame pointers to the current frame size. 3588 if (vpx_realloc_frame_buffer(get_frame_new_buffer(cm), cm->width, cm->height, 3589 cm->subsampling_x, cm->subsampling_y, 3590 #if CONFIG_VP9_HIGHBITDEPTH 3591 cm->use_highbitdepth, 3592 #endif 3593 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment, 3594 NULL, NULL, NULL)) 3595 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR, 3596 "Failed to allocate frame buffer"); 3597 3598 alloc_util_frame_buffers(cpi); 3599 init_motion_estimation(cpi); 3600 3601 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { 3602 RefBuffer *const ref_buf = &cm->frame_refs[ref_frame - 1]; 3603 const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame); 3604 3605 ref_buf->idx = buf_idx; 3606 3607 if (buf_idx != INVALID_IDX) { 3608 YV12_BUFFER_CONFIG *const buf = &cm->buffer_pool->frame_bufs[buf_idx].buf; 3609 ref_buf->buf = buf; 3610 #if CONFIG_VP9_HIGHBITDEPTH 3611 vp9_setup_scale_factors_for_frame( 3612 &ref_buf->sf, buf->y_crop_width, buf->y_crop_height, cm->width, 3613 cm->height, (buf->flags & YV12_FLAG_HIGHBITDEPTH) ? 1 : 0); 3614 #else 3615 vp9_setup_scale_factors_for_frame(&ref_buf->sf, buf->y_crop_width, 3616 buf->y_crop_height, cm->width, 3617 cm->height); 3618 #endif // CONFIG_VP9_HIGHBITDEPTH 3619 if (vp9_is_scaled(&ref_buf->sf)) vpx_extend_frame_borders(buf); 3620 } else { 3621 ref_buf->buf = NULL; 3622 } 3623 } 3624 3625 set_ref_ptrs(cm, xd, LAST_FRAME, LAST_FRAME); 3626 } 3627 3628 #if CONFIG_CONSISTENT_RECODE 3629 static void save_encode_params(VP9_COMP *cpi) { 3630 VP9_COMMON *const cm = &cpi->common; 3631 const int tile_cols = 1 << cm->log2_tile_cols; 3632 const int tile_rows = 1 << cm->log2_tile_rows; 3633 int tile_col, tile_row; 3634 int i, j; 3635 RD_OPT *rd_opt = &cpi->rd; 3636 for (i = 0; i < MAX_REF_FRAMES; i++) { 3637 for (j = 0; j < REFERENCE_MODES; j++) 3638 rd_opt->prediction_type_threshes_prev[i][j] = 3639 rd_opt->prediction_type_threshes[i][j]; 3640 3641 for (j = 0; j < SWITCHABLE_FILTER_CONTEXTS; j++) 3642 rd_opt->filter_threshes_prev[i][j] = rd_opt->filter_threshes[i][j]; 3643 } 3644 3645 if (cpi->tile_data != NULL) { 3646 for (tile_row = 0; tile_row < tile_rows; ++tile_row) 3647 for (tile_col = 0; tile_col < tile_cols; ++tile_col) { 3648 TileDataEnc *tile_data = 3649 &cpi->tile_data[tile_row * tile_cols + tile_col]; 3650 for (i = 0; i < BLOCK_SIZES; ++i) { 3651 for (j = 0; j < MAX_MODES; ++j) { 3652 tile_data->thresh_freq_fact_prev[i][j] = 3653 tile_data->thresh_freq_fact[i][j]; 3654 } 3655 } 3656 } 3657 } 3658 } 3659 #endif 3660 3661 static INLINE void set_raw_source_frame(VP9_COMP *cpi) { 3662 #ifdef ENABLE_KF_DENOISE 3663 if (is_spatial_denoise_enabled(cpi)) { 3664 cpi->raw_source_frame = vp9_scale_if_required( 3665 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source, 3666 (oxcf->pass == 0), EIGHTTAP, 0); 3667 } else { 3668 cpi->raw_source_frame = cpi->Source; 3669 } 3670 #else 3671 cpi->raw_source_frame = cpi->Source; 3672 #endif 3673 } 3674 3675 static int encode_without_recode_loop(VP9_COMP *cpi, size_t *size, 3676 uint8_t *dest) { 3677 VP9_COMMON *const cm = &cpi->common; 3678 SVC *const svc = &cpi->svc; 3679 int q = 0, bottom_index = 0, top_index = 0; 3680 int no_drop_scene_change = 0; 3681 const INTERP_FILTER filter_scaler = 3682 (is_one_pass_cbr_svc(cpi)) 3683 ? svc->downsample_filter_type[svc->spatial_layer_id] 3684 : EIGHTTAP; 3685 const int phase_scaler = 3686 (is_one_pass_cbr_svc(cpi)) 3687 ? svc->downsample_filter_phase[svc->spatial_layer_id] 3688 : 0; 3689 3690 if (cm->show_existing_frame) { 3691 if (is_psnr_calc_enabled(cpi)) set_raw_source_frame(cpi); 3692 return 1; 3693 } 3694 3695 svc->time_stamp_prev[svc->spatial_layer_id] = svc->time_stamp_superframe; 3696 3697 // Flag to check if its valid to compute the source sad (used for 3698 // scene detection and for superblock content state in CBR mode). 3699 // The flag may get reset below based on SVC or resizing state. 3700 cpi->compute_source_sad_onepass = cpi->oxcf.mode == REALTIME; 3701 3702 vpx_clear_system_state(); 3703 3704 set_frame_size(cpi); 3705 3706 if (is_one_pass_cbr_svc(cpi) && 3707 cpi->un_scaled_source->y_width == cm->width << 2 && 3708 cpi->un_scaled_source->y_height == cm->height << 2 && 3709 svc->scaled_temp.y_width == cm->width << 1 && 3710 svc->scaled_temp.y_height == cm->height << 1) { 3711 // For svc, if it is a 1/4x1/4 downscaling, do a two-stage scaling to take 3712 // advantage of the 1:2 optimized scaler. In the process, the 1/2x1/2 3713 // result will be saved in scaled_temp and might be used later. 3714 const INTERP_FILTER filter_scaler2 = svc->downsample_filter_type[1]; 3715 const int phase_scaler2 = svc->downsample_filter_phase[1]; 3716 cpi->Source = vp9_svc_twostage_scale( 3717 cm, cpi->un_scaled_source, &cpi->scaled_source, &svc->scaled_temp, 3718 filter_scaler, phase_scaler, filter_scaler2, phase_scaler2); 3719 svc->scaled_one_half = 1; 3720 } else if (is_one_pass_cbr_svc(cpi) && 3721 cpi->un_scaled_source->y_width == cm->width << 1 && 3722 cpi->un_scaled_source->y_height == cm->height << 1 && 3723 svc->scaled_one_half) { 3724 // If the spatial layer is 1/2x1/2 and the scaling is already done in the 3725 // two-stage scaling, use the result directly. 3726 cpi->Source = &svc->scaled_temp; 3727 svc->scaled_one_half = 0; 3728 } else { 3729 cpi->Source = vp9_scale_if_required( 3730 cm, cpi->un_scaled_source, &cpi->scaled_source, (cpi->oxcf.pass == 0), 3731 filter_scaler, phase_scaler); 3732 } 3733 #ifdef OUTPUT_YUV_SVC_SRC 3734 // Write out at most 3 spatial layers. 3735 if (is_one_pass_cbr_svc(cpi) && svc->spatial_layer_id < 3) { 3736 vpx_write_yuv_frame(yuv_svc_src[svc->spatial_layer_id], cpi->Source); 3737 } 3738 #endif 3739 // Unfiltered raw source used in metrics calculation if the source 3740 // has been filtered. 3741 if (is_psnr_calc_enabled(cpi)) { 3742 #ifdef ENABLE_KF_DENOISE 3743 if (is_spatial_denoise_enabled(cpi)) { 3744 cpi->raw_source_frame = vp9_scale_if_required( 3745 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source, 3746 (cpi->oxcf.pass == 0), EIGHTTAP, phase_scaler); 3747 } else { 3748 cpi->raw_source_frame = cpi->Source; 3749 } 3750 #else 3751 cpi->raw_source_frame = cpi->Source; 3752 #endif 3753 } 3754 3755 if ((cpi->use_svc && 3756 (svc->spatial_layer_id < svc->number_spatial_layers - 1 || 3757 svc->temporal_layer_id < svc->number_temporal_layers - 1 || 3758 svc->current_superframe < 1)) || 3759 cpi->resize_pending || cpi->resize_state || cpi->external_resize || 3760 cpi->resize_state != ORIG) { 3761 cpi->compute_source_sad_onepass = 0; 3762 if (cpi->content_state_sb_fd != NULL) 3763 memset(cpi->content_state_sb_fd, 0, 3764 (cm->mi_stride >> 3) * ((cm->mi_rows >> 3) + 1) * 3765 sizeof(*cpi->content_state_sb_fd)); 3766 } 3767 3768 // Avoid scaling last_source unless its needed. 3769 // Last source is needed if avg_source_sad() is used, or if 3770 // partition_search_type == SOURCE_VAR_BASED_PARTITION, or if noise 3771 // estimation is enabled. 3772 if (cpi->unscaled_last_source != NULL && 3773 (cpi->oxcf.content == VP9E_CONTENT_SCREEN || 3774 (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == VPX_VBR && 3775 cpi->oxcf.mode == REALTIME && cpi->oxcf.speed >= 5) || 3776 cpi->sf.partition_search_type == SOURCE_VAR_BASED_PARTITION || 3777 (cpi->noise_estimate.enabled && !cpi->oxcf.noise_sensitivity) || 3778 cpi->compute_source_sad_onepass)) 3779 cpi->Last_Source = vp9_scale_if_required( 3780 cm, cpi->unscaled_last_source, &cpi->scaled_last_source, 3781 (cpi->oxcf.pass == 0), EIGHTTAP, 0); 3782 3783 if (cpi->Last_Source == NULL || 3784 cpi->Last_Source->y_width != cpi->Source->y_width || 3785 cpi->Last_Source->y_height != cpi->Source->y_height) 3786 cpi->compute_source_sad_onepass = 0; 3787 3788 if (frame_is_intra_only(cm) || cpi->resize_pending != 0) { 3789 memset(cpi->consec_zero_mv, 0, 3790 cm->mi_rows * cm->mi_cols * sizeof(*cpi->consec_zero_mv)); 3791 } 3792 3793 #if CONFIG_VP9_TEMPORAL_DENOISING 3794 if (cpi->oxcf.noise_sensitivity > 0 && cpi->use_svc) 3795 vp9_denoiser_reset_on_first_frame(cpi); 3796 #endif 3797 vp9_update_noise_estimate(cpi); 3798 3799 // Scene detection is always used for VBR mode or screen-content case. 3800 // For other cases (e.g., CBR mode) use it for 5 <= speed < 8 for now 3801 // (need to check encoding time cost for doing this for speed 8). 3802 cpi->rc.high_source_sad = 0; 3803 cpi->rc.hybrid_intra_scene_change = 0; 3804 cpi->rc.re_encode_maxq_scene_change = 0; 3805 if (cm->show_frame && cpi->oxcf.mode == REALTIME && 3806 (cpi->oxcf.rc_mode == VPX_VBR || 3807 cpi->oxcf.content == VP9E_CONTENT_SCREEN || 3808 (cpi->oxcf.speed >= 5 && cpi->oxcf.speed < 8))) 3809 vp9_scene_detection_onepass(cpi); 3810 3811 if (svc->spatial_layer_id == svc->first_spatial_layer_to_encode) { 3812 svc->high_source_sad_superframe = cpi->rc.high_source_sad; 3813 svc->high_num_blocks_with_motion = cpi->rc.high_num_blocks_with_motion; 3814 // On scene change reset temporal layer pattern to TL0. 3815 // Note that if the base/lower spatial layers are skipped: instead of 3816 // inserting base layer here, we force max-q for the next superframe 3817 // with lower spatial layers: this is done in vp9_encodedframe_overshoot() 3818 // when max-q is decided for the current layer. 3819 // Only do this reset for bypass/flexible mode. 3820 if (svc->high_source_sad_superframe && svc->temporal_layer_id > 0 && 3821 svc->temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS) { 3822 // rc->high_source_sad will get reset so copy it to restore it. 3823 int tmp_high_source_sad = cpi->rc.high_source_sad; 3824 vp9_svc_reset_temporal_layers(cpi, cm->frame_type == KEY_FRAME); 3825 cpi->rc.high_source_sad = tmp_high_source_sad; 3826 } 3827 } 3828 3829 // For 1 pass CBR, check if we are dropping this frame. 3830 // Never drop on key frame, if base layer is key for svc, 3831 // on scene change, or if superframe has layer sync. 3832 if ((cpi->rc.high_source_sad || svc->high_source_sad_superframe) && 3833 !(cpi->rc.use_post_encode_drop && svc->last_layer_dropped[0])) 3834 no_drop_scene_change = 1; 3835 if (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == VPX_CBR && 3836 !frame_is_intra_only(cm) && !no_drop_scene_change && 3837 !svc->superframe_has_layer_sync && 3838 (!cpi->use_svc || 3839 !svc->layer_context[svc->temporal_layer_id].is_key_frame)) { 3840 if (vp9_rc_drop_frame(cpi)) return 0; 3841 } 3842 3843 // For 1 pass CBR SVC, only ZEROMV is allowed for spatial reference frame 3844 // when svc->force_zero_mode_spatial_ref = 1. Under those conditions we can 3845 // avoid this frame-level upsampling (for non intra_only frames). 3846 if (frame_is_intra_only(cm) == 0 && 3847 !(is_one_pass_cbr_svc(cpi) && svc->force_zero_mode_spatial_ref)) { 3848 vp9_scale_references(cpi); 3849 } 3850 3851 set_size_independent_vars(cpi); 3852 set_size_dependent_vars(cpi, &q, &bottom_index, &top_index); 3853 3854 // search method and step parameter might be changed in speed settings. 3855 init_motion_estimation(cpi); 3856 3857 if (cpi->sf.copy_partition_flag) alloc_copy_partition_data(cpi); 3858 3859 if (cpi->sf.svc_use_lowres_part && 3860 svc->spatial_layer_id == svc->number_spatial_layers - 2) { 3861 if (svc->prev_partition_svc == NULL) { 3862 CHECK_MEM_ERROR( 3863 cm, svc->prev_partition_svc, 3864 (BLOCK_SIZE *)vpx_calloc(cm->mi_stride * cm->mi_rows, 3865 sizeof(*svc->prev_partition_svc))); 3866 } 3867 } 3868 3869 // TODO(jianj): Look into issue of skin detection with high bitdepth. 3870 if (cm->bit_depth == 8 && cpi->oxcf.speed >= 5 && cpi->oxcf.pass == 0 && 3871 cpi->oxcf.rc_mode == VPX_CBR && 3872 cpi->oxcf.content != VP9E_CONTENT_SCREEN && 3873 cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) { 3874 cpi->use_skin_detection = 1; 3875 } 3876 3877 // Enable post encode frame dropping for CBR on non key frame, when 3878 // ext_use_post_encode_drop is specified by user. 3879 cpi->rc.use_post_encode_drop = cpi->rc.ext_use_post_encode_drop && 3880 cpi->oxcf.rc_mode == VPX_CBR && 3881 cm->frame_type != KEY_FRAME; 3882 3883 vp9_set_quantizer(cm, q); 3884 vp9_set_variance_partition_thresholds(cpi, q, 0); 3885 3886 setup_frame(cpi); 3887 3888 suppress_active_map(cpi); 3889 3890 if (cpi->use_svc) { 3891 // On non-zero spatial layer, check for disabling inter-layer 3892 // prediction. 3893 if (svc->spatial_layer_id > 0) vp9_svc_constrain_inter_layer_pred(cpi); 3894 vp9_svc_assert_constraints_pattern(cpi); 3895 } 3896 3897 if (cpi->rc.last_post_encode_dropped_scene_change) { 3898 cpi->rc.high_source_sad = 1; 3899 svc->high_source_sad_superframe = 1; 3900 // For now disable use_source_sad since Last_Source will not be the previous 3901 // encoded but the dropped one. 3902 cpi->sf.use_source_sad = 0; 3903 cpi->rc.last_post_encode_dropped_scene_change = 0; 3904 } 3905 // Check if this high_source_sad (scene/slide change) frame should be 3906 // encoded at high/max QP, and if so, set the q and adjust some rate 3907 // control parameters. 3908 if (cpi->sf.overshoot_detection_cbr_rt == FAST_DETECTION_MAXQ && 3909 (cpi->rc.high_source_sad || 3910 (cpi->use_svc && svc->high_source_sad_superframe))) { 3911 if (vp9_encodedframe_overshoot(cpi, -1, &q)) { 3912 vp9_set_quantizer(cm, q); 3913 vp9_set_variance_partition_thresholds(cpi, q, 0); 3914 } 3915 } 3916 3917 // Variance adaptive and in frame q adjustment experiments are mutually 3918 // exclusive. 3919 if (cpi->oxcf.aq_mode == VARIANCE_AQ) { 3920 vp9_vaq_frame_setup(cpi); 3921 } else if (cpi->oxcf.aq_mode == EQUATOR360_AQ) { 3922 vp9_360aq_frame_setup(cpi); 3923 } else if (cpi->oxcf.aq_mode == COMPLEXITY_AQ) { 3924 vp9_setup_in_frame_q_adj(cpi); 3925 } else if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) { 3926 vp9_cyclic_refresh_setup(cpi); 3927 } else if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ) { 3928 // it may be pretty bad for rate-control, 3929 // and I should handle it somehow 3930 vp9_alt_ref_aq_setup_map(cpi->alt_ref_aq, cpi); 3931 } else if (cpi->roi.enabled && !frame_is_intra_only(cm)) { 3932 apply_roi_map(cpi); 3933 } 3934 3935 apply_active_map(cpi); 3936 3937 vp9_encode_frame(cpi); 3938 3939 // Check if we should re-encode this frame at high Q because of high 3940 // overshoot based on the encoded frame size. Only for frames where 3941 // high temporal-source SAD is detected. 3942 // For SVC: all spatial layers are checked for re-encoding. 3943 if (cpi->sf.overshoot_detection_cbr_rt == RE_ENCODE_MAXQ && 3944 (cpi->rc.high_source_sad || 3945 (cpi->use_svc && svc->high_source_sad_superframe))) { 3946 int frame_size = 0; 3947 // Get an estimate of the encoded frame size. 3948 save_coding_context(cpi); 3949 vp9_pack_bitstream(cpi, dest, size); 3950 restore_coding_context(cpi); 3951 frame_size = (int)(*size) << 3; 3952 // Check if encoded frame will overshoot too much, and if so, set the q and 3953 // adjust some rate control parameters, and return to re-encode the frame. 3954 if (vp9_encodedframe_overshoot(cpi, frame_size, &q)) { 3955 vpx_clear_system_state(); 3956 vp9_set_quantizer(cm, q); 3957 vp9_set_variance_partition_thresholds(cpi, q, 0); 3958 suppress_active_map(cpi); 3959 // Turn-off cyclic refresh for re-encoded frame. 3960 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) { 3961 CYCLIC_REFRESH *const cr = cpi->cyclic_refresh; 3962 unsigned char *const seg_map = cpi->segmentation_map; 3963 memset(seg_map, 0, cm->mi_rows * cm->mi_cols); 3964 memset(cr->last_coded_q_map, MAXQ, 3965 cm->mi_rows * cm->mi_cols * sizeof(*cr->last_coded_q_map)); 3966 cr->sb_index = 0; 3967 vp9_disable_segmentation(&cm->seg); 3968 } 3969 apply_active_map(cpi); 3970 vp9_encode_frame(cpi); 3971 } 3972 } 3973 3974 // Update some stats from cyclic refresh, and check for golden frame update. 3975 if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && cm->seg.enabled && 3976 !frame_is_intra_only(cm)) 3977 vp9_cyclic_refresh_postencode(cpi); 3978 3979 // Update the skip mb flag probabilities based on the distribution 3980 // seen in the last encoder iteration. 3981 // update_base_skip_probs(cpi); 3982 vpx_clear_system_state(); 3983 return 1; 3984 } 3985 3986 #define MAX_QSTEP_ADJ 4 3987 static int get_qstep_adj(int rate_excess, int rate_limit) { 3988 int qstep = 3989 rate_limit ? ((rate_excess + rate_limit / 2) / rate_limit) : INT_MAX; 3990 return VPXMIN(qstep, MAX_QSTEP_ADJ); 3991 } 3992 3993 static void encode_with_recode_loop(VP9_COMP *cpi, size_t *size, 3994 uint8_t *dest) { 3995 const VP9EncoderConfig *const oxcf = &cpi->oxcf; 3996 VP9_COMMON *const cm = &cpi->common; 3997 RATE_CONTROL *const rc = &cpi->rc; 3998 int bottom_index, top_index; 3999 int loop_count = 0; 4000 int loop_at_this_size = 0; 4001 int loop = 0; 4002 int overshoot_seen = 0; 4003 int undershoot_seen = 0; 4004 int frame_over_shoot_limit; 4005 int frame_under_shoot_limit; 4006 int q = 0, q_low = 0, q_high = 0; 4007 int enable_acl; 4008 #ifdef AGGRESSIVE_VBR 4009 int qrange_adj = 1; 4010 #endif 4011 4012 if (cm->show_existing_frame) { 4013 if (is_psnr_calc_enabled(cpi)) set_raw_source_frame(cpi); 4014 return; 4015 } 4016 4017 set_size_independent_vars(cpi); 4018 4019 enable_acl = cpi->sf.allow_acl ? (cm->frame_type == KEY_FRAME) || 4020 (cpi->twopass.gf_group.index == 1) 4021 : 0; 4022 4023 do { 4024 vpx_clear_system_state(); 4025 4026 set_frame_size(cpi); 4027 4028 if (loop_count == 0 || cpi->resize_pending != 0) { 4029 set_size_dependent_vars(cpi, &q, &bottom_index, &top_index); 4030 4031 #ifdef AGGRESSIVE_VBR 4032 if (two_pass_first_group_inter(cpi)) { 4033 // Adjustment limits for min and max q 4034 qrange_adj = VPXMAX(1, (top_index - bottom_index) / 2); 4035 4036 bottom_index = 4037 VPXMAX(bottom_index - qrange_adj / 2, oxcf->best_allowed_q); 4038 top_index = VPXMIN(oxcf->worst_allowed_q, top_index + qrange_adj / 2); 4039 } 4040 #endif 4041 // TODO(agrange) Scale cpi->max_mv_magnitude if frame-size has changed. 4042 set_mv_search_params(cpi); 4043 4044 // Reset the loop state for new frame size. 4045 overshoot_seen = 0; 4046 undershoot_seen = 0; 4047 4048 // Reconfiguration for change in frame size has concluded. 4049 cpi->resize_pending = 0; 4050 4051 q_low = bottom_index; 4052 q_high = top_index; 4053 4054 loop_at_this_size = 0; 4055 } 4056 4057 // Decide frame size bounds first time through. 4058 if (loop_count == 0) { 4059 vp9_rc_compute_frame_size_bounds(cpi, rc->this_frame_target, 4060 &frame_under_shoot_limit, 4061 &frame_over_shoot_limit); 4062 } 4063 4064 cpi->Source = 4065 vp9_scale_if_required(cm, cpi->un_scaled_source, &cpi->scaled_source, 4066 (oxcf->pass == 0), EIGHTTAP, 0); 4067 4068 // Unfiltered raw source used in metrics calculation if the source 4069 // has been filtered. 4070 if (is_psnr_calc_enabled(cpi)) { 4071 #ifdef ENABLE_KF_DENOISE 4072 if (is_spatial_denoise_enabled(cpi)) { 4073 cpi->raw_source_frame = vp9_scale_if_required( 4074 cm, &cpi->raw_unscaled_source, &cpi->raw_scaled_source, 4075 (oxcf->pass == 0), EIGHTTAP, 0); 4076 } else { 4077 cpi->raw_source_frame = cpi->Source; 4078 } 4079 #else 4080 cpi->raw_source_frame = cpi->Source; 4081 #endif 4082 } 4083 4084 if (cpi->unscaled_last_source != NULL) 4085 cpi->Last_Source = vp9_scale_if_required(cm, cpi->unscaled_last_source, 4086 &cpi->scaled_last_source, 4087 (oxcf->pass == 0), EIGHTTAP, 0); 4088 4089 if (frame_is_intra_only(cm) == 0) { 4090 if (loop_count > 0) { 4091 release_scaled_references(cpi); 4092 } 4093 vp9_scale_references(cpi); 4094 } 4095 4096 vp9_set_quantizer(cm, q); 4097 4098 if (loop_count == 0) setup_frame(cpi); 4099 4100 // Variance adaptive and in frame q adjustment experiments are mutually 4101 // exclusive. 4102 if (oxcf->aq_mode == VARIANCE_AQ) { 4103 vp9_vaq_frame_setup(cpi); 4104 } else if (oxcf->aq_mode == EQUATOR360_AQ) { 4105 vp9_360aq_frame_setup(cpi); 4106 } else if (oxcf->aq_mode == COMPLEXITY_AQ) { 4107 vp9_setup_in_frame_q_adj(cpi); 4108 } else if (oxcf->aq_mode == LOOKAHEAD_AQ) { 4109 vp9_alt_ref_aq_setup_map(cpi->alt_ref_aq, cpi); 4110 } else if (oxcf->aq_mode == PSNR_AQ) { 4111 vp9_psnr_aq_mode_setup(&cm->seg); 4112 } 4113 4114 vp9_encode_frame(cpi); 4115 4116 // Update the skip mb flag probabilities based on the distribution 4117 // seen in the last encoder iteration. 4118 // update_base_skip_probs(cpi); 4119 4120 vpx_clear_system_state(); 4121 4122 // Dummy pack of the bitstream using up to date stats to get an 4123 // accurate estimate of output frame size to determine if we need 4124 // to recode. 4125 if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF) { 4126 save_coding_context(cpi); 4127 if (!cpi->sf.use_nonrd_pick_mode) vp9_pack_bitstream(cpi, dest, size); 4128 4129 rc->projected_frame_size = (int)(*size) << 3; 4130 4131 if (frame_over_shoot_limit == 0) frame_over_shoot_limit = 1; 4132 } 4133 4134 if (oxcf->rc_mode == VPX_Q) { 4135 loop = 0; 4136 } else { 4137 if ((cm->frame_type == KEY_FRAME) && rc->this_key_frame_forced && 4138 (rc->projected_frame_size < rc->max_frame_bandwidth)) { 4139 int last_q = q; 4140 int64_t kf_err; 4141 4142 int64_t high_err_target = cpi->ambient_err; 4143 int64_t low_err_target = cpi->ambient_err >> 1; 4144 4145 #if CONFIG_VP9_HIGHBITDEPTH 4146 if (cm->use_highbitdepth) { 4147 kf_err = vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm)); 4148 } else { 4149 kf_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm)); 4150 } 4151 #else 4152 kf_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm)); 4153 #endif // CONFIG_VP9_HIGHBITDEPTH 4154 4155 // Prevent possible divide by zero error below for perfect KF 4156 kf_err += !kf_err; 4157 4158 // The key frame is not good enough or we can afford 4159 // to make it better without undue risk of popping. 4160 if ((kf_err > high_err_target && 4161 rc->projected_frame_size <= frame_over_shoot_limit) || 4162 (kf_err > low_err_target && 4163 rc->projected_frame_size <= frame_under_shoot_limit)) { 4164 // Lower q_high 4165 q_high = q > q_low ? q - 1 : q_low; 4166 4167 // Adjust Q 4168 q = (int)((q * high_err_target) / kf_err); 4169 q = VPXMIN(q, (q_high + q_low) >> 1); 4170 } else if (kf_err < low_err_target && 4171 rc->projected_frame_size >= frame_under_shoot_limit) { 4172 // The key frame is much better than the previous frame 4173 // Raise q_low 4174 q_low = q < q_high ? q + 1 : q_high; 4175 4176 // Adjust Q 4177 q = (int)((q * low_err_target) / kf_err); 4178 q = VPXMIN(q, (q_high + q_low + 1) >> 1); 4179 } 4180 4181 // Clamp Q to upper and lower limits: 4182 q = clamp(q, q_low, q_high); 4183 4184 loop = q != last_q; 4185 } else if (recode_loop_test(cpi, frame_over_shoot_limit, 4186 frame_under_shoot_limit, q, 4187 VPXMAX(q_high, top_index), bottom_index)) { 4188 // Is the projected frame size out of range and are we allowed 4189 // to attempt to recode. 4190 int last_q = q; 4191 int retries = 0; 4192 int qstep; 4193 4194 if (cpi->resize_pending == 1) { 4195 // Change in frame size so go back around the recode loop. 4196 cpi->rc.frame_size_selector = 4197 SCALE_STEP1 - cpi->rc.frame_size_selector; 4198 cpi->rc.next_frame_size_selector = cpi->rc.frame_size_selector; 4199 4200 #if CONFIG_INTERNAL_STATS 4201 ++cpi->tot_recode_hits; 4202 #endif 4203 ++loop_count; 4204 loop = 1; 4205 continue; 4206 } 4207 4208 // Frame size out of permitted range: 4209 // Update correction factor & compute new Q to try... 4210 4211 // Frame is too large 4212 if (rc->projected_frame_size > rc->this_frame_target) { 4213 // Special case if the projected size is > the max allowed. 4214 if ((q == q_high) && 4215 ((rc->projected_frame_size >= rc->max_frame_bandwidth) || 4216 (!rc->is_src_frame_alt_ref && 4217 (rc->projected_frame_size >= 4218 big_rate_miss_high_threshold(cpi))))) { 4219 int max_rate = VPXMAX(1, VPXMIN(rc->max_frame_bandwidth, 4220 big_rate_miss_high_threshold(cpi))); 4221 double q_val_high; 4222 q_val_high = vp9_convert_qindex_to_q(q_high, cm->bit_depth); 4223 q_val_high = 4224 q_val_high * ((double)rc->projected_frame_size / max_rate); 4225 q_high = vp9_convert_q_to_qindex(q_val_high, cm->bit_depth); 4226 q_high = clamp(q_high, rc->best_quality, rc->worst_quality); 4227 } 4228 4229 // Raise Qlow as to at least the current value 4230 qstep = 4231 get_qstep_adj(rc->projected_frame_size, rc->this_frame_target); 4232 q_low = VPXMIN(q + qstep, q_high); 4233 4234 if (undershoot_seen || loop_at_this_size > 1) { 4235 // Update rate_correction_factor unless 4236 vp9_rc_update_rate_correction_factors(cpi); 4237 4238 q = (q_high + q_low + 1) / 2; 4239 } else { 4240 // Update rate_correction_factor unless 4241 vp9_rc_update_rate_correction_factors(cpi); 4242 4243 q = vp9_rc_regulate_q(cpi, rc->this_frame_target, bottom_index, 4244 VPXMAX(q_high, top_index)); 4245 4246 while (q < q_low && retries < 10) { 4247 vp9_rc_update_rate_correction_factors(cpi); 4248 q = vp9_rc_regulate_q(cpi, rc->this_frame_target, bottom_index, 4249 VPXMAX(q_high, top_index)); 4250 retries++; 4251 } 4252 } 4253 4254 overshoot_seen = 1; 4255 } else { 4256 // Frame is too small 4257 qstep = 4258 get_qstep_adj(rc->this_frame_target, rc->projected_frame_size); 4259 q_high = VPXMAX(q - qstep, q_low); 4260 4261 if (overshoot_seen || loop_at_this_size > 1) { 4262 vp9_rc_update_rate_correction_factors(cpi); 4263 q = (q_high + q_low) / 2; 4264 } else { 4265 vp9_rc_update_rate_correction_factors(cpi); 4266 q = vp9_rc_regulate_q(cpi, rc->this_frame_target, 4267 VPXMIN(q_low, bottom_index), top_index); 4268 // Special case reset for qlow for constrained quality. 4269 // This should only trigger where there is very substantial 4270 // undershoot on a frame and the auto cq level is above 4271 // the user passsed in value. 4272 if (oxcf->rc_mode == VPX_CQ && q < q_low) { 4273 q_low = q; 4274 } 4275 4276 while (q > q_high && retries < 10) { 4277 vp9_rc_update_rate_correction_factors(cpi); 4278 q = vp9_rc_regulate_q(cpi, rc->this_frame_target, 4279 VPXMIN(q_low, bottom_index), top_index); 4280 retries++; 4281 } 4282 } 4283 undershoot_seen = 1; 4284 } 4285 4286 // Clamp Q to upper and lower limits: 4287 q = clamp(q, q_low, q_high); 4288 4289 loop = (q != last_q); 4290 } else { 4291 loop = 0; 4292 } 4293 } 4294 4295 // Special case for overlay frame. 4296 if (rc->is_src_frame_alt_ref && 4297 rc->projected_frame_size < rc->max_frame_bandwidth) 4298 loop = 0; 4299 4300 if (loop) { 4301 ++loop_count; 4302 ++loop_at_this_size; 4303 4304 #if CONFIG_INTERNAL_STATS 4305 ++cpi->tot_recode_hits; 4306 #endif 4307 } 4308 4309 if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF) 4310 if (loop || !enable_acl) restore_coding_context(cpi); 4311 } while (loop); 4312 4313 #ifdef AGGRESSIVE_VBR 4314 if (two_pass_first_group_inter(cpi)) { 4315 cpi->twopass.active_worst_quality = 4316 VPXMIN(q + qrange_adj, oxcf->worst_allowed_q); 4317 } else if (!frame_is_kf_gf_arf(cpi)) { 4318 #else 4319 if (!frame_is_kf_gf_arf(cpi)) { 4320 #endif 4321 // Have we been forced to adapt Q outside the expected range by an extreme 4322 // rate miss. If so adjust the active maxQ for the subsequent frames. 4323 if (!rc->is_src_frame_alt_ref && (q > cpi->twopass.active_worst_quality)) { 4324 cpi->twopass.active_worst_quality = q; 4325 } else if (oxcf->vbr_corpus_complexity && q == q_low && 4326 rc->projected_frame_size < rc->this_frame_target) { 4327 cpi->twopass.active_worst_quality = 4328 VPXMAX(q, cpi->twopass.active_worst_quality - 1); 4329 } 4330 } 4331 4332 if (enable_acl) { 4333 // Skip recoding, if model diff is below threshold 4334 const int thresh = compute_context_model_thresh(cpi); 4335 const int diff = compute_context_model_diff(cm); 4336 if (diff < thresh) { 4337 vpx_clear_system_state(); 4338 restore_coding_context(cpi); 4339 return; 4340 } 4341 4342 vp9_encode_frame(cpi); 4343 vpx_clear_system_state(); 4344 restore_coding_context(cpi); 4345 } 4346 } 4347 4348 static int get_ref_frame_flags(const VP9_COMP *cpi) { 4349 const int *const map = cpi->common.ref_frame_map; 4350 const int gold_is_last = map[cpi->gld_fb_idx] == map[cpi->lst_fb_idx]; 4351 const int alt_is_last = map[cpi->alt_fb_idx] == map[cpi->lst_fb_idx]; 4352 const int gold_is_alt = map[cpi->gld_fb_idx] == map[cpi->alt_fb_idx]; 4353 int flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG; 4354 4355 if (gold_is_last) flags &= ~VP9_GOLD_FLAG; 4356 4357 if (cpi->rc.frames_till_gf_update_due == INT_MAX && 4358 (cpi->svc.number_temporal_layers == 1 && 4359 cpi->svc.number_spatial_layers == 1)) 4360 flags &= ~VP9_GOLD_FLAG; 4361 4362 if (alt_is_last) flags &= ~VP9_ALT_FLAG; 4363 4364 if (gold_is_alt) flags &= ~VP9_ALT_FLAG; 4365 4366 return flags; 4367 } 4368 4369 static void set_ext_overrides(VP9_COMP *cpi) { 4370 // Overrides the defaults with the externally supplied values with 4371 // vp9_update_reference() and vp9_update_entropy() calls 4372 // Note: The overrides are valid only for the next frame passed 4373 // to encode_frame_to_data_rate() function 4374 if (cpi->ext_refresh_frame_context_pending) { 4375 cpi->common.refresh_frame_context = cpi->ext_refresh_frame_context; 4376 cpi->ext_refresh_frame_context_pending = 0; 4377 } 4378 if (cpi->ext_refresh_frame_flags_pending) { 4379 cpi->refresh_last_frame = cpi->ext_refresh_last_frame; 4380 cpi->refresh_golden_frame = cpi->ext_refresh_golden_frame; 4381 cpi->refresh_alt_ref_frame = cpi->ext_refresh_alt_ref_frame; 4382 } 4383 } 4384 4385 YV12_BUFFER_CONFIG *vp9_svc_twostage_scale( 4386 VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled, 4387 YV12_BUFFER_CONFIG *scaled_temp, INTERP_FILTER filter_type, 4388 int phase_scaler, INTERP_FILTER filter_type2, int phase_scaler2) { 4389 if (cm->mi_cols * MI_SIZE != unscaled->y_width || 4390 cm->mi_rows * MI_SIZE != unscaled->y_height) { 4391 #if CONFIG_VP9_HIGHBITDEPTH 4392 if (cm->bit_depth == VPX_BITS_8) { 4393 vp9_scale_and_extend_frame(unscaled, scaled_temp, filter_type2, 4394 phase_scaler2); 4395 vp9_scale_and_extend_frame(scaled_temp, scaled, filter_type, 4396 phase_scaler); 4397 } else { 4398 scale_and_extend_frame(unscaled, scaled_temp, (int)cm->bit_depth, 4399 filter_type2, phase_scaler2); 4400 scale_and_extend_frame(scaled_temp, scaled, (int)cm->bit_depth, 4401 filter_type, phase_scaler); 4402 } 4403 #else 4404 vp9_scale_and_extend_frame(unscaled, scaled_temp, filter_type2, 4405 phase_scaler2); 4406 vp9_scale_and_extend_frame(scaled_temp, scaled, filter_type, phase_scaler); 4407 #endif // CONFIG_VP9_HIGHBITDEPTH 4408 return scaled; 4409 } else { 4410 return unscaled; 4411 } 4412 } 4413 4414 YV12_BUFFER_CONFIG *vp9_scale_if_required( 4415 VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled, 4416 int use_normative_scaler, INTERP_FILTER filter_type, int phase_scaler) { 4417 if (cm->mi_cols * MI_SIZE != unscaled->y_width || 4418 cm->mi_rows * MI_SIZE != unscaled->y_height) { 4419 #if CONFIG_VP9_HIGHBITDEPTH 4420 if (use_normative_scaler && unscaled->y_width <= (scaled->y_width << 1) && 4421 unscaled->y_height <= (scaled->y_height << 1)) 4422 if (cm->bit_depth == VPX_BITS_8) 4423 vp9_scale_and_extend_frame(unscaled, scaled, filter_type, phase_scaler); 4424 else 4425 scale_and_extend_frame(unscaled, scaled, (int)cm->bit_depth, 4426 filter_type, phase_scaler); 4427 else 4428 scale_and_extend_frame_nonnormative(unscaled, scaled, (int)cm->bit_depth); 4429 #else 4430 if (use_normative_scaler && unscaled->y_width <= (scaled->y_width << 1) && 4431 unscaled->y_height <= (scaled->y_height << 1)) 4432 vp9_scale_and_extend_frame(unscaled, scaled, filter_type, phase_scaler); 4433 else 4434 scale_and_extend_frame_nonnormative(unscaled, scaled); 4435 #endif // CONFIG_VP9_HIGHBITDEPTH 4436 return scaled; 4437 } else { 4438 return unscaled; 4439 } 4440 } 4441 4442 static void set_ref_sign_bias(VP9_COMP *cpi) { 4443 VP9_COMMON *const cm = &cpi->common; 4444 RefCntBuffer *const ref_buffer = get_ref_cnt_buffer(cm, cm->new_fb_idx); 4445 const int cur_frame_index = ref_buffer->frame_index; 4446 MV_REFERENCE_FRAME ref_frame; 4447 4448 for (ref_frame = LAST_FRAME; ref_frame < MAX_REF_FRAMES; ++ref_frame) { 4449 const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame); 4450 const RefCntBuffer *const ref_cnt_buf = 4451 get_ref_cnt_buffer(&cpi->common, buf_idx); 4452 if (ref_cnt_buf) { 4453 cm->ref_frame_sign_bias[ref_frame] = 4454 cur_frame_index < ref_cnt_buf->frame_index; 4455 } 4456 } 4457 } 4458 4459 static int setup_interp_filter_search_mask(VP9_COMP *cpi) { 4460 INTERP_FILTER ifilter; 4461 int ref_total[MAX_REF_FRAMES] = { 0 }; 4462 MV_REFERENCE_FRAME ref; 4463 int mask = 0; 4464 if (cpi->common.last_frame_type == KEY_FRAME || cpi->refresh_alt_ref_frame) 4465 return mask; 4466 for (ref = LAST_FRAME; ref <= ALTREF_FRAME; ++ref) 4467 for (ifilter = EIGHTTAP; ifilter <= EIGHTTAP_SHARP; ++ifilter) 4468 ref_total[ref] += cpi->interp_filter_selected[ref][ifilter]; 4469 4470 for (ifilter = EIGHTTAP; ifilter <= EIGHTTAP_SHARP; ++ifilter) { 4471 if ((ref_total[LAST_FRAME] && 4472 cpi->interp_filter_selected[LAST_FRAME][ifilter] == 0) && 4473 (ref_total[GOLDEN_FRAME] == 0 || 4474 cpi->interp_filter_selected[GOLDEN_FRAME][ifilter] * 50 < 4475 ref_total[GOLDEN_FRAME]) && 4476 (ref_total[ALTREF_FRAME] == 0 || 4477 cpi->interp_filter_selected[ALTREF_FRAME][ifilter] * 50 < 4478 ref_total[ALTREF_FRAME])) 4479 mask |= 1 << ifilter; 4480 } 4481 return mask; 4482 } 4483 4484 #ifdef ENABLE_KF_DENOISE 4485 // Baseline Kernal weights for denoise 4486 static uint8_t dn_kernal_3[9] = { 1, 2, 1, 2, 4, 2, 1, 2, 1 }; 4487 static uint8_t dn_kernal_5[25] = { 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 4, 4488 2, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1 }; 4489 4490 static INLINE void add_denoise_point(int centre_val, int data_val, int thresh, 4491 uint8_t point_weight, int *sum_val, 4492 int *sum_weight) { 4493 if (abs(centre_val - data_val) <= thresh) { 4494 *sum_weight += point_weight; 4495 *sum_val += (int)data_val * (int)point_weight; 4496 } 4497 } 4498 4499 static void spatial_denoise_point(uint8_t *src_ptr, const int stride, 4500 const int strength) { 4501 int sum_weight = 0; 4502 int sum_val = 0; 4503 int thresh = strength; 4504 int kernal_size = 5; 4505 int half_k_size = 2; 4506 int i, j; 4507 int max_diff = 0; 4508 uint8_t *tmp_ptr; 4509 uint8_t *kernal_ptr; 4510 4511 // Find the maximum deviation from the source point in the locale. 4512 tmp_ptr = src_ptr - (stride * (half_k_size + 1)) - (half_k_size + 1); 4513 for (i = 0; i < kernal_size + 2; ++i) { 4514 for (j = 0; j < kernal_size + 2; ++j) { 4515 max_diff = VPXMAX(max_diff, abs((int)*src_ptr - (int)tmp_ptr[j])); 4516 } 4517 tmp_ptr += stride; 4518 } 4519 4520 // Select the kernal size. 4521 if (max_diff > (strength + (strength >> 1))) { 4522 kernal_size = 3; 4523 half_k_size = 1; 4524 thresh = thresh >> 1; 4525 } 4526 kernal_ptr = (kernal_size == 3) ? dn_kernal_3 : dn_kernal_5; 4527 4528 // Apply the kernal 4529 tmp_ptr = src_ptr - (stride * half_k_size) - half_k_size; 4530 for (i = 0; i < kernal_size; ++i) { 4531 for (j = 0; j < kernal_size; ++j) { 4532 add_denoise_point((int)*src_ptr, (int)tmp_ptr[j], thresh, *kernal_ptr, 4533 &sum_val, &sum_weight); 4534 ++kernal_ptr; 4535 } 4536 tmp_ptr += stride; 4537 } 4538 4539 // Update the source value with the new filtered value 4540 *src_ptr = (uint8_t)((sum_val + (sum_weight >> 1)) / sum_weight); 4541 } 4542 4543 #if CONFIG_VP9_HIGHBITDEPTH 4544 static void highbd_spatial_denoise_point(uint16_t *src_ptr, const int stride, 4545 const int strength) { 4546 int sum_weight = 0; 4547 int sum_val = 0; 4548 int thresh = strength; 4549 int kernal_size = 5; 4550 int half_k_size = 2; 4551 int i, j; 4552 int max_diff = 0; 4553 uint16_t *tmp_ptr; 4554 uint8_t *kernal_ptr; 4555 4556 // Find the maximum deviation from the source point in the locale. 4557 tmp_ptr = src_ptr - (stride * (half_k_size + 1)) - (half_k_size + 1); 4558 for (i = 0; i < kernal_size + 2; ++i) { 4559 for (j = 0; j < kernal_size + 2; ++j) { 4560 max_diff = VPXMAX(max_diff, abs((int)src_ptr - (int)tmp_ptr[j])); 4561 } 4562 tmp_ptr += stride; 4563 } 4564 4565 // Select the kernal size. 4566 if (max_diff > (strength + (strength >> 1))) { 4567 kernal_size = 3; 4568 half_k_size = 1; 4569 thresh = thresh >> 1; 4570 } 4571 kernal_ptr = (kernal_size == 3) ? dn_kernal_3 : dn_kernal_5; 4572 4573 // Apply the kernal 4574 tmp_ptr = src_ptr - (stride * half_k_size) - half_k_size; 4575 for (i = 0; i < kernal_size; ++i) { 4576 for (j = 0; j < kernal_size; ++j) { 4577 add_denoise_point((int)*src_ptr, (int)tmp_ptr[j], thresh, *kernal_ptr, 4578 &sum_val, &sum_weight); 4579 ++kernal_ptr; 4580 } 4581 tmp_ptr += stride; 4582 } 4583 4584 // Update the source value with the new filtered value 4585 *src_ptr = (uint16_t)((sum_val + (sum_weight >> 1)) / sum_weight); 4586 } 4587 #endif // CONFIG_VP9_HIGHBITDEPTH 4588 4589 // Apply thresholded spatial noise supression to a given buffer. 4590 static void spatial_denoise_buffer(VP9_COMP *cpi, uint8_t *buffer, 4591 const int stride, const int width, 4592 const int height, const int strength) { 4593 VP9_COMMON *const cm = &cpi->common; 4594 uint8_t *src_ptr = buffer; 4595 int row; 4596 int col; 4597 4598 for (row = 0; row < height; ++row) { 4599 for (col = 0; col < width; ++col) { 4600 #if CONFIG_VP9_HIGHBITDEPTH 4601 if (cm->use_highbitdepth) 4602 highbd_spatial_denoise_point(CONVERT_TO_SHORTPTR(&src_ptr[col]), stride, 4603 strength); 4604 else 4605 spatial_denoise_point(&src_ptr[col], stride, strength); 4606 #else 4607 spatial_denoise_point(&src_ptr[col], stride, strength); 4608 #endif // CONFIG_VP9_HIGHBITDEPTH 4609 } 4610 src_ptr += stride; 4611 } 4612 } 4613 4614 // Apply thresholded spatial noise supression to source. 4615 static void spatial_denoise_frame(VP9_COMP *cpi) { 4616 YV12_BUFFER_CONFIG *src = cpi->Source; 4617 const VP9EncoderConfig *const oxcf = &cpi->oxcf; 4618 TWO_PASS *const twopass = &cpi->twopass; 4619 VP9_COMMON *const cm = &cpi->common; 4620 4621 // Base the filter strength on the current active max Q. 4622 const int q = (int)(vp9_convert_qindex_to_q(twopass->active_worst_quality, 4623 cm->bit_depth)); 4624 int strength = 4625 VPXMAX(oxcf->arnr_strength >> 2, VPXMIN(oxcf->arnr_strength, (q >> 4))); 4626 4627 // Denoise each of Y,U and V buffers. 4628 spatial_denoise_buffer(cpi, src->y_buffer, src->y_stride, src->y_width, 4629 src->y_height, strength); 4630 4631 strength += (strength >> 1); 4632 spatial_denoise_buffer(cpi, src->u_buffer, src->uv_stride, src->uv_width, 4633 src->uv_height, strength << 1); 4634 4635 spatial_denoise_buffer(cpi, src->v_buffer, src->uv_stride, src->uv_width, 4636 src->uv_height, strength << 1); 4637 } 4638 #endif // ENABLE_KF_DENOISE 4639 4640 static void vp9_try_disable_lookahead_aq(VP9_COMP *cpi, size_t *size, 4641 uint8_t *dest) { 4642 if (cpi->common.seg.enabled) 4643 if (ALT_REF_AQ_PROTECT_GAIN) { 4644 size_t nsize = *size; 4645 int overhead; 4646 4647 // TODO(yuryg): optimize this, as 4648 // we don't really need to repack 4649 4650 save_coding_context(cpi); 4651 vp9_disable_segmentation(&cpi->common.seg); 4652 vp9_pack_bitstream(cpi, dest, &nsize); 4653 restore_coding_context(cpi); 4654 4655 overhead = (int)*size - (int)nsize; 4656 4657 if (vp9_alt_ref_aq_disable_if(cpi->alt_ref_aq, overhead, (int)*size)) 4658 vp9_encode_frame(cpi); 4659 else 4660 vp9_enable_segmentation(&cpi->common.seg); 4661 } 4662 } 4663 4664 static void set_frame_index(VP9_COMP *cpi, VP9_COMMON *cm) { 4665 RefCntBuffer *const ref_buffer = get_ref_cnt_buffer(cm, cm->new_fb_idx); 4666 4667 if (ref_buffer) { 4668 const GF_GROUP *const gf_group = &cpi->twopass.gf_group; 4669 ref_buffer->frame_index = 4670 cm->current_video_frame + gf_group->arf_src_offset[gf_group->index]; 4671 } 4672 } 4673 4674 static void encode_frame_to_data_rate(VP9_COMP *cpi, size_t *size, 4675 uint8_t *dest, 4676 unsigned int *frame_flags) { 4677 VP9_COMMON *const cm = &cpi->common; 4678 const VP9EncoderConfig *const oxcf = &cpi->oxcf; 4679 struct segmentation *const seg = &cm->seg; 4680 TX_SIZE t; 4681 4682 // SVC: skip encoding of enhancement layer if the layer target bandwidth = 0. 4683 // If in constrained layer drop mode (svc.framedrop_mode != LAYER_DROP) and 4684 // base spatial layer was dropped, no need to set svc.skip_enhancement_layer, 4685 // as whole superframe will be dropped. 4686 if (cpi->use_svc && cpi->svc.spatial_layer_id > 0 && 4687 cpi->oxcf.target_bandwidth == 0 && 4688 !(cpi->svc.framedrop_mode != LAYER_DROP && 4689 cpi->svc.drop_spatial_layer[0])) { 4690 cpi->svc.skip_enhancement_layer = 1; 4691 vp9_rc_postencode_update_drop_frame(cpi); 4692 cpi->ext_refresh_frame_flags_pending = 0; 4693 cpi->last_frame_dropped = 1; 4694 cpi->svc.last_layer_dropped[cpi->svc.spatial_layer_id] = 1; 4695 cpi->svc.drop_spatial_layer[cpi->svc.spatial_layer_id] = 1; 4696 if (cpi->svc.framedrop_mode == LAYER_DROP || 4697 cpi->svc.drop_spatial_layer[0] == 0) { 4698 // For the case of constrained drop mode where the base is dropped 4699 // (drop_spatial_layer[0] == 1), which means full superframe dropped, 4700 // we don't increment the svc frame counters. In particular temporal 4701 // layer counter (which is incremented in vp9_inc_frame_in_layer()) 4702 // won't be incremented, so on a dropped frame we try the same 4703 // temporal_layer_id on next incoming frame. This is to avoid an 4704 // issue with temporal alignement with full superframe dropping. 4705 vp9_inc_frame_in_layer(cpi); 4706 } 4707 return; 4708 } 4709 4710 set_ext_overrides(cpi); 4711 vpx_clear_system_state(); 4712 4713 #ifdef ENABLE_KF_DENOISE 4714 // Spatial denoise of key frame. 4715 if (is_spatial_denoise_enabled(cpi)) spatial_denoise_frame(cpi); 4716 #endif 4717 4718 if (cm->show_existing_frame == 0) { 4719 // Update frame index 4720 set_frame_index(cpi, cm); 4721 4722 // Set the arf sign bias for this frame. 4723 set_ref_sign_bias(cpi); 4724 } 4725 4726 // Set default state for segment based loop filter update flags. 4727 cm->lf.mode_ref_delta_update = 0; 4728 4729 if (cpi->oxcf.pass == 2 && cpi->sf.adaptive_interp_filter_search) 4730 cpi->sf.interp_filter_search_mask = setup_interp_filter_search_mask(cpi); 4731 4732 // Set various flags etc to special state if it is a key frame. 4733 if (frame_is_intra_only(cm)) { 4734 // Reset the loop filter deltas and segmentation map. 4735 vp9_reset_segment_features(&cm->seg); 4736 4737 // If segmentation is enabled force a map update for key frames. 4738 if (seg->enabled) { 4739 seg->update_map = 1; 4740 seg->update_data = 1; 4741 } 4742 4743 // The alternate reference frame cannot be active for a key frame. 4744 cpi->rc.source_alt_ref_active = 0; 4745 4746 cm->error_resilient_mode = oxcf->error_resilient_mode; 4747 cm->frame_parallel_decoding_mode = oxcf->frame_parallel_decoding_mode; 4748 4749 // By default, encoder assumes decoder can use prev_mi. 4750 if (cm->error_resilient_mode) { 4751 cm->frame_parallel_decoding_mode = 1; 4752 cm->reset_frame_context = 0; 4753 cm->refresh_frame_context = 0; 4754 } else if (cm->intra_only) { 4755 // Only reset the current context. 4756 cm->reset_frame_context = 2; 4757 } 4758 } 4759 4760 vpx_clear_system_state(); 4761 4762 #if CONFIG_INTERNAL_STATS 4763 memset(cpi->mode_chosen_counts, 0, 4764 MAX_MODES * sizeof(*cpi->mode_chosen_counts)); 4765 #endif 4766 #if CONFIG_CONSISTENT_RECODE 4767 // Backup to ensure consistency between recodes 4768 save_encode_params(cpi); 4769 #endif 4770 4771 if (cpi->sf.recode_loop == DISALLOW_RECODE) { 4772 if (!encode_without_recode_loop(cpi, size, dest)) return; 4773 } else { 4774 encode_with_recode_loop(cpi, size, dest); 4775 } 4776 4777 // TODO(jingning): When using show existing frame mode, we assume that the 4778 // current ARF will be directly used as the final reconstructed frame. This is 4779 // an encoder control scheme. One could in principle explore other 4780 // possibilities to arrange the reference frame buffer and their coding order. 4781 if (cm->show_existing_frame) { 4782 ref_cnt_fb(cm->buffer_pool->frame_bufs, &cm->new_fb_idx, 4783 cm->ref_frame_map[cpi->alt_fb_idx]); 4784 } 4785 4786 // Disable segmentation if it decrease rate/distortion ratio 4787 if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ) 4788 vp9_try_disable_lookahead_aq(cpi, size, dest); 4789 4790 #if CONFIG_VP9_TEMPORAL_DENOISING 4791 #ifdef OUTPUT_YUV_DENOISED 4792 if (oxcf->noise_sensitivity > 0 && denoise_svc(cpi)) { 4793 vpx_write_yuv_frame(yuv_denoised_file, 4794 &cpi->denoiser.running_avg_y[INTRA_FRAME]); 4795 } 4796 #endif 4797 #endif 4798 #ifdef OUTPUT_YUV_SKINMAP 4799 if (cpi->common.current_video_frame > 1) { 4800 vp9_output_skin_map(cpi, yuv_skinmap_file); 4801 } 4802 #endif 4803 4804 // Special case code to reduce pulsing when key frames are forced at a 4805 // fixed interval. Note the reconstruction error if it is the frame before 4806 // the force key frame 4807 if (cpi->rc.next_key_frame_forced && cpi->rc.frames_to_key == 1) { 4808 #if CONFIG_VP9_HIGHBITDEPTH 4809 if (cm->use_highbitdepth) { 4810 cpi->ambient_err = 4811 vpx_highbd_get_y_sse(cpi->Source, get_frame_new_buffer(cm)); 4812 } else { 4813 cpi->ambient_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm)); 4814 } 4815 #else 4816 cpi->ambient_err = vpx_get_y_sse(cpi->Source, get_frame_new_buffer(cm)); 4817 #endif // CONFIG_VP9_HIGHBITDEPTH 4818 } 4819 4820 // If the encoder forced a KEY_FRAME decision 4821 if (cm->frame_type == KEY_FRAME) cpi->refresh_last_frame = 1; 4822 4823 cm->frame_to_show = get_frame_new_buffer(cm); 4824 cm->frame_to_show->color_space = cm->color_space; 4825 cm->frame_to_show->color_range = cm->color_range; 4826 cm->frame_to_show->render_width = cm->render_width; 4827 cm->frame_to_show->render_height = cm->render_height; 4828 4829 // Pick the loop filter level for the frame. 4830 loopfilter_frame(cpi, cm); 4831 4832 if (cpi->rc.use_post_encode_drop) save_coding_context(cpi); 4833 4834 // build the bitstream 4835 vp9_pack_bitstream(cpi, dest, size); 4836 4837 if (cpi->rc.use_post_encode_drop && cm->base_qindex < cpi->rc.worst_quality && 4838 cpi->svc.spatial_layer_id == 0 && post_encode_drop_cbr(cpi, size)) { 4839 restore_coding_context(cpi); 4840 return; 4841 } 4842 4843 cpi->last_frame_dropped = 0; 4844 cpi->svc.last_layer_dropped[cpi->svc.spatial_layer_id] = 0; 4845 if (cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1) 4846 cpi->svc.num_encoded_top_layer++; 4847 4848 // Keep track of the frame buffer index updated/refreshed for the 4849 // current encoded TL0 superframe. 4850 if (cpi->svc.temporal_layer_id == 0) { 4851 if (cpi->refresh_last_frame) 4852 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->lst_fb_idx; 4853 else if (cpi->refresh_golden_frame) 4854 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->gld_fb_idx; 4855 else if (cpi->refresh_alt_ref_frame) 4856 cpi->svc.fb_idx_upd_tl0[cpi->svc.spatial_layer_id] = cpi->alt_fb_idx; 4857 } 4858 4859 if (cm->seg.update_map) update_reference_segmentation_map(cpi); 4860 4861 if (frame_is_intra_only(cm) == 0) { 4862 release_scaled_references(cpi); 4863 } 4864 vp9_update_reference_frames(cpi); 4865 4866 if (!cm->show_existing_frame) { 4867 for (t = TX_4X4; t <= TX_32X32; ++t) { 4868 full_to_model_counts(cpi->td.counts->coef[t], 4869 cpi->td.rd_counts.coef_counts[t]); 4870 } 4871 4872 if (!cm->error_resilient_mode && !cm->frame_parallel_decoding_mode) { 4873 if (!frame_is_intra_only(cm)) { 4874 vp9_adapt_mode_probs(cm); 4875 vp9_adapt_mv_probs(cm, cm->allow_high_precision_mv); 4876 } 4877 vp9_adapt_coef_probs(cm); 4878 } 4879 } 4880 4881 cpi->ext_refresh_frame_flags_pending = 0; 4882 4883 if (cpi->refresh_golden_frame == 1) 4884 cpi->frame_flags |= FRAMEFLAGS_GOLDEN; 4885 else 4886 cpi->frame_flags &= ~FRAMEFLAGS_GOLDEN; 4887 4888 if (cpi->refresh_alt_ref_frame == 1) 4889 cpi->frame_flags |= FRAMEFLAGS_ALTREF; 4890 else 4891 cpi->frame_flags &= ~FRAMEFLAGS_ALTREF; 4892 4893 cpi->ref_frame_flags = get_ref_frame_flags(cpi); 4894 4895 cm->last_frame_type = cm->frame_type; 4896 4897 vp9_rc_postencode_update(cpi, *size); 4898 4899 *size = VPXMAX(1, *size); 4900 4901 #if 0 4902 output_frame_level_debug_stats(cpi); 4903 #endif 4904 4905 if (cm->frame_type == KEY_FRAME) { 4906 // Tell the caller that the frame was coded as a key frame 4907 *frame_flags = cpi->frame_flags | FRAMEFLAGS_KEY; 4908 } else { 4909 *frame_flags = cpi->frame_flags & ~FRAMEFLAGS_KEY; 4910 } 4911 4912 // Clear the one shot update flags for segmentation map and mode/ref loop 4913 // filter deltas. 4914 cm->seg.update_map = 0; 4915 cm->seg.update_data = 0; 4916 cm->lf.mode_ref_delta_update = 0; 4917 4918 // keep track of the last coded dimensions 4919 cm->last_width = cm->width; 4920 cm->last_height = cm->height; 4921 4922 // reset to normal state now that we are done. 4923 if (!cm->show_existing_frame) { 4924 cm->last_show_frame = cm->show_frame; 4925 cm->prev_frame = cm->cur_frame; 4926 } 4927 4928 if (cm->show_frame) { 4929 vp9_swap_mi_and_prev_mi(cm); 4930 // Don't increment frame counters if this was an altref buffer 4931 // update not a real frame 4932 ++cm->current_video_frame; 4933 if (cpi->use_svc) vp9_inc_frame_in_layer(cpi); 4934 } 4935 4936 if (cpi->use_svc) { 4937 cpi->svc 4938 .layer_context[cpi->svc.spatial_layer_id * 4939 cpi->svc.number_temporal_layers + 4940 cpi->svc.temporal_layer_id] 4941 .last_frame_type = cm->frame_type; 4942 // Reset layer_sync back to 0 for next frame. 4943 cpi->svc.spatial_layer_sync[cpi->svc.spatial_layer_id] = 0; 4944 } 4945 4946 cpi->force_update_segmentation = 0; 4947 4948 if (cpi->oxcf.aq_mode == LOOKAHEAD_AQ) 4949 vp9_alt_ref_aq_unset_all(cpi->alt_ref_aq, cpi); 4950 4951 cpi->svc.previous_frame_is_intra_only = cm->intra_only; 4952 cpi->svc.set_intra_only_frame = 0; 4953 } 4954 4955 static void SvcEncode(VP9_COMP *cpi, size_t *size, uint8_t *dest, 4956 unsigned int *frame_flags) { 4957 vp9_rc_get_svc_params(cpi); 4958 encode_frame_to_data_rate(cpi, size, dest, frame_flags); 4959 } 4960 4961 static void Pass0Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest, 4962 unsigned int *frame_flags) { 4963 if (cpi->oxcf.rc_mode == VPX_CBR) { 4964 vp9_rc_get_one_pass_cbr_params(cpi); 4965 } else { 4966 vp9_rc_get_one_pass_vbr_params(cpi); 4967 } 4968 encode_frame_to_data_rate(cpi, size, dest, frame_flags); 4969 } 4970 4971 #if !CONFIG_REALTIME_ONLY 4972 static void Pass2Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest, 4973 unsigned int *frame_flags) { 4974 cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED; 4975 encode_frame_to_data_rate(cpi, size, dest, frame_flags); 4976 4977 vp9_twopass_postencode_update(cpi); 4978 } 4979 #endif // !CONFIG_REALTIME_ONLY 4980 4981 static void init_ref_frame_bufs(VP9_COMMON *cm) { 4982 int i; 4983 BufferPool *const pool = cm->buffer_pool; 4984 cm->new_fb_idx = INVALID_IDX; 4985 for (i = 0; i < REF_FRAMES; ++i) { 4986 cm->ref_frame_map[i] = INVALID_IDX; 4987 } 4988 for (i = 0; i < FRAME_BUFFERS; ++i) { 4989 pool->frame_bufs[i].ref_count = 0; 4990 } 4991 } 4992 4993 static void check_initial_width(VP9_COMP *cpi, 4994 #if CONFIG_VP9_HIGHBITDEPTH 4995 int use_highbitdepth, 4996 #endif 4997 int subsampling_x, int subsampling_y) { 4998 VP9_COMMON *const cm = &cpi->common; 4999 5000 if (!cpi->initial_width || 5001 #if CONFIG_VP9_HIGHBITDEPTH 5002 cm->use_highbitdepth != use_highbitdepth || 5003 #endif 5004 cm->subsampling_x != subsampling_x || 5005 cm->subsampling_y != subsampling_y) { 5006 cm->subsampling_x = subsampling_x; 5007 cm->subsampling_y = subsampling_y; 5008 #if CONFIG_VP9_HIGHBITDEPTH 5009 cm->use_highbitdepth = use_highbitdepth; 5010 #endif 5011 5012 alloc_raw_frame_buffers(cpi); 5013 init_ref_frame_bufs(cm); 5014 alloc_util_frame_buffers(cpi); 5015 5016 init_motion_estimation(cpi); // TODO(agrange) This can be removed. 5017 5018 cpi->initial_width = cm->width; 5019 cpi->initial_height = cm->height; 5020 cpi->initial_mbs = cm->MBs; 5021 } 5022 } 5023 5024 int vp9_receive_raw_frame(VP9_COMP *cpi, vpx_enc_frame_flags_t frame_flags, 5025 YV12_BUFFER_CONFIG *sd, int64_t time_stamp, 5026 int64_t end_time) { 5027 VP9_COMMON *const cm = &cpi->common; 5028 struct vpx_usec_timer timer; 5029 int res = 0; 5030 const int subsampling_x = sd->subsampling_x; 5031 const int subsampling_y = sd->subsampling_y; 5032 #if CONFIG_VP9_HIGHBITDEPTH 5033 const int use_highbitdepth = (sd->flags & YV12_FLAG_HIGHBITDEPTH) != 0; 5034 #endif 5035 5036 #if CONFIG_VP9_HIGHBITDEPTH 5037 check_initial_width(cpi, use_highbitdepth, subsampling_x, subsampling_y); 5038 #else 5039 check_initial_width(cpi, subsampling_x, subsampling_y); 5040 #endif // CONFIG_VP9_HIGHBITDEPTH 5041 5042 #if CONFIG_VP9_HIGHBITDEPTH 5043 // Disable denoiser for high bitdepth since vp9_denoiser_filter only works for 5044 // 8 bits. 5045 if (cm->bit_depth > 8) cpi->oxcf.noise_sensitivity = 0; 5046 #endif 5047 5048 #if CONFIG_VP9_TEMPORAL_DENOISING 5049 setup_denoiser_buffer(cpi); 5050 #endif 5051 vpx_usec_timer_start(&timer); 5052 5053 if (vp9_lookahead_push(cpi->lookahead, sd, time_stamp, end_time, 5054 #if CONFIG_VP9_HIGHBITDEPTH 5055 use_highbitdepth, 5056 #endif // CONFIG_VP9_HIGHBITDEPTH 5057 frame_flags)) 5058 res = -1; 5059 vpx_usec_timer_mark(&timer); 5060 cpi->time_receive_data += vpx_usec_timer_elapsed(&timer); 5061 5062 if ((cm->profile == PROFILE_0 || cm->profile == PROFILE_2) && 5063 (subsampling_x != 1 || subsampling_y != 1)) { 5064 vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM, 5065 "Non-4:2:0 color format requires profile 1 or 3"); 5066 res = -1; 5067 } 5068 if ((cm->profile == PROFILE_1 || cm->profile == PROFILE_3) && 5069 (subsampling_x == 1 && subsampling_y == 1)) { 5070 vpx_internal_error(&cm->error, VPX_CODEC_INVALID_PARAM, 5071 "4:2:0 color format requires profile 0 or 2"); 5072 res = -1; 5073 } 5074 5075 return res; 5076 } 5077 5078 static int frame_is_reference(const VP9_COMP *cpi) { 5079 const VP9_COMMON *cm = &cpi->common; 5080 5081 return cm->frame_type == KEY_FRAME || cpi->refresh_last_frame || 5082 cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame || 5083 cm->refresh_frame_context || cm->lf.mode_ref_delta_update || 5084 cm->seg.update_map || cm->seg.update_data; 5085 } 5086 5087 static void adjust_frame_rate(VP9_COMP *cpi, 5088 const struct lookahead_entry *source) { 5089 int64_t this_duration; 5090 int step = 0; 5091 5092 if (source->ts_start == cpi->first_time_stamp_ever) { 5093 this_duration = source->ts_end - source->ts_start; 5094 step = 1; 5095 } else { 5096 int64_t last_duration = 5097 cpi->last_end_time_stamp_seen - cpi->last_time_stamp_seen; 5098 5099 this_duration = source->ts_end - cpi->last_end_time_stamp_seen; 5100 5101 // do a step update if the duration changes by 10% 5102 if (last_duration) 5103 step = (int)((this_duration - last_duration) * 10 / last_duration); 5104 } 5105 5106 if (this_duration) { 5107 if (step) { 5108 vp9_new_framerate(cpi, 10000000.0 / this_duration); 5109 } else { 5110 // Average this frame's rate into the last second's average 5111 // frame rate. If we haven't seen 1 second yet, then average 5112 // over the whole interval seen. 5113 const double interval = VPXMIN( 5114 (double)(source->ts_end - cpi->first_time_stamp_ever), 10000000.0); 5115 double avg_duration = 10000000.0 / cpi->framerate; 5116 avg_duration *= (interval - avg_duration + this_duration); 5117 avg_duration /= interval; 5118 5119 vp9_new_framerate(cpi, 10000000.0 / avg_duration); 5120 } 5121 } 5122 cpi->last_time_stamp_seen = source->ts_start; 5123 cpi->last_end_time_stamp_seen = source->ts_end; 5124 } 5125 5126 // Returns 0 if this is not an alt ref else the offset of the source frame 5127 // used as the arf midpoint. 5128 static int get_arf_src_index(VP9_COMP *cpi) { 5129 RATE_CONTROL *const rc = &cpi->rc; 5130 int arf_src_index = 0; 5131 if (is_altref_enabled(cpi)) { 5132 if (cpi->oxcf.pass == 2) { 5133 const GF_GROUP *const gf_group = &cpi->twopass.gf_group; 5134 if (gf_group->update_type[gf_group->index] == ARF_UPDATE) { 5135 arf_src_index = gf_group->arf_src_offset[gf_group->index]; 5136 } 5137 } else if (rc->source_alt_ref_pending) { 5138 arf_src_index = rc->frames_till_gf_update_due; 5139 } 5140 } 5141 return arf_src_index; 5142 } 5143 5144 static void check_src_altref(VP9_COMP *cpi, 5145 const struct lookahead_entry *source) { 5146 RATE_CONTROL *const rc = &cpi->rc; 5147 5148 if (cpi->oxcf.pass == 2) { 5149 const GF_GROUP *const gf_group = &cpi->twopass.gf_group; 5150 rc->is_src_frame_alt_ref = 5151 (gf_group->update_type[gf_group->index] == OVERLAY_UPDATE); 5152 } else { 5153 rc->is_src_frame_alt_ref = 5154 cpi->alt_ref_source && (source == cpi->alt_ref_source); 5155 } 5156 5157 if (rc->is_src_frame_alt_ref) { 5158 // Current frame is an ARF overlay frame. 5159 cpi->alt_ref_source = NULL; 5160 5161 // Don't refresh the last buffer for an ARF overlay frame. It will 5162 // become the GF so preserve last as an alternative prediction option. 5163 cpi->refresh_last_frame = 0; 5164 } 5165 } 5166 5167 #if CONFIG_INTERNAL_STATS 5168 static void adjust_image_stat(double y, double u, double v, double all, 5169 ImageStat *s) { 5170 s->stat[Y] += y; 5171 s->stat[U] += u; 5172 s->stat[V] += v; 5173 s->stat[ALL] += all; 5174 s->worst = VPXMIN(s->worst, all); 5175 } 5176 #endif // CONFIG_INTERNAL_STATS 5177 5178 // Adjust the maximum allowable frame size for the target level. 5179 static void level_rc_framerate(VP9_COMP *cpi, int arf_src_index) { 5180 RATE_CONTROL *const rc = &cpi->rc; 5181 LevelConstraint *const ls = &cpi->level_constraint; 5182 VP9_COMMON *const cm = &cpi->common; 5183 const double max_cpb_size = ls->max_cpb_size; 5184 vpx_clear_system_state(); 5185 rc->max_frame_bandwidth = VPXMIN(rc->max_frame_bandwidth, ls->max_frame_size); 5186 if (frame_is_intra_only(cm)) { 5187 rc->max_frame_bandwidth = 5188 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.5)); 5189 } else if (arf_src_index > 0) { 5190 rc->max_frame_bandwidth = 5191 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.4)); 5192 } else { 5193 rc->max_frame_bandwidth = 5194 VPXMIN(rc->max_frame_bandwidth, (int)(max_cpb_size * 0.2)); 5195 } 5196 } 5197 5198 static void update_level_info(VP9_COMP *cpi, size_t *size, int arf_src_index) { 5199 VP9_COMMON *const cm = &cpi->common; 5200 Vp9LevelInfo *const level_info = &cpi->level_info; 5201 Vp9LevelSpec *const level_spec = &level_info->level_spec; 5202 Vp9LevelStats *const level_stats = &level_info->level_stats; 5203 int i, idx; 5204 uint64_t luma_samples, dur_end; 5205 const uint32_t luma_pic_size = cm->width * cm->height; 5206 const uint32_t luma_pic_breadth = VPXMAX(cm->width, cm->height); 5207 LevelConstraint *const level_constraint = &cpi->level_constraint; 5208 const int8_t level_index = level_constraint->level_index; 5209 double cpb_data_size; 5210 5211 vpx_clear_system_state(); 5212 5213 // update level_stats 5214 level_stats->total_compressed_size += *size; 5215 if (cm->show_frame) { 5216 level_stats->total_uncompressed_size += 5217 luma_pic_size + 5218 2 * (luma_pic_size >> (cm->subsampling_x + cm->subsampling_y)); 5219 level_stats->time_encoded = 5220 (cpi->last_end_time_stamp_seen - cpi->first_time_stamp_ever) / 5221 (double)TICKS_PER_SEC; 5222 } 5223 5224 if (arf_src_index > 0) { 5225 if (!level_stats->seen_first_altref) { 5226 level_stats->seen_first_altref = 1; 5227 } else if (level_stats->frames_since_last_altref < 5228 level_spec->min_altref_distance) { 5229 level_spec->min_altref_distance = level_stats->frames_since_last_altref; 5230 } 5231 level_stats->frames_since_last_altref = 0; 5232 } else { 5233 ++level_stats->frames_since_last_altref; 5234 } 5235 5236 if (level_stats->frame_window_buffer.len < FRAME_WINDOW_SIZE - 1) { 5237 idx = (level_stats->frame_window_buffer.start + 5238 level_stats->frame_window_buffer.len++) % 5239 FRAME_WINDOW_SIZE; 5240 } else { 5241 idx = level_stats->frame_window_buffer.start; 5242 level_stats->frame_window_buffer.start = (idx + 1) % FRAME_WINDOW_SIZE; 5243 } 5244 level_stats->frame_window_buffer.buf[idx].ts = cpi->last_time_stamp_seen; 5245 level_stats->frame_window_buffer.buf[idx].size = (uint32_t)(*size); 5246 level_stats->frame_window_buffer.buf[idx].luma_samples = luma_pic_size; 5247 5248 if (cm->frame_type == KEY_FRAME) { 5249 level_stats->ref_refresh_map = 0; 5250 } else { 5251 int count = 0; 5252 level_stats->ref_refresh_map |= vp9_get_refresh_mask(cpi); 5253 // Also need to consider the case where the encoder refers to a buffer 5254 // that has been implicitly refreshed after encoding a keyframe. 5255 if (!cm->intra_only) { 5256 level_stats->ref_refresh_map |= (1 << cpi->lst_fb_idx); 5257 level_stats->ref_refresh_map |= (1 << cpi->gld_fb_idx); 5258 level_stats->ref_refresh_map |= (1 << cpi->alt_fb_idx); 5259 } 5260 for (i = 0; i < REF_FRAMES; ++i) { 5261 count += (level_stats->ref_refresh_map >> i) & 1; 5262 } 5263 if (count > level_spec->max_ref_frame_buffers) { 5264 level_spec->max_ref_frame_buffers = count; 5265 } 5266 } 5267 5268 // update average_bitrate 5269 level_spec->average_bitrate = (double)level_stats->total_compressed_size / 5270 125.0 / level_stats->time_encoded; 5271 5272 // update max_luma_sample_rate 5273 luma_samples = 0; 5274 for (i = 0; i < level_stats->frame_window_buffer.len; ++i) { 5275 idx = (level_stats->frame_window_buffer.start + 5276 level_stats->frame_window_buffer.len - 1 - i) % 5277 FRAME_WINDOW_SIZE; 5278 if (i == 0) { 5279 dur_end = level_stats->frame_window_buffer.buf[idx].ts; 5280 } 5281 if (dur_end - level_stats->frame_window_buffer.buf[idx].ts >= 5282 TICKS_PER_SEC) { 5283 break; 5284 } 5285 luma_samples += level_stats->frame_window_buffer.buf[idx].luma_samples; 5286 } 5287 if (luma_samples > level_spec->max_luma_sample_rate) { 5288 level_spec->max_luma_sample_rate = luma_samples; 5289 } 5290 5291 // update max_cpb_size 5292 cpb_data_size = 0; 5293 for (i = 0; i < CPB_WINDOW_SIZE; ++i) { 5294 if (i >= level_stats->frame_window_buffer.len) break; 5295 idx = (level_stats->frame_window_buffer.start + 5296 level_stats->frame_window_buffer.len - 1 - i) % 5297 FRAME_WINDOW_SIZE; 5298 cpb_data_size += level_stats->frame_window_buffer.buf[idx].size; 5299 } 5300 cpb_data_size = cpb_data_size / 125.0; 5301 if (cpb_data_size > level_spec->max_cpb_size) { 5302 level_spec->max_cpb_size = cpb_data_size; 5303 } 5304 5305 // update max_luma_picture_size 5306 if (luma_pic_size > level_spec->max_luma_picture_size) { 5307 level_spec->max_luma_picture_size = luma_pic_size; 5308 } 5309 5310 // update max_luma_picture_breadth 5311 if (luma_pic_breadth > level_spec->max_luma_picture_breadth) { 5312 level_spec->max_luma_picture_breadth = luma_pic_breadth; 5313 } 5314 5315 // update compression_ratio 5316 level_spec->compression_ratio = (double)level_stats->total_uncompressed_size * 5317 cm->bit_depth / 5318 level_stats->total_compressed_size / 8.0; 5319 5320 // update max_col_tiles 5321 if (level_spec->max_col_tiles < (1 << cm->log2_tile_cols)) { 5322 level_spec->max_col_tiles = (1 << cm->log2_tile_cols); 5323 } 5324 5325 if (level_index >= 0 && level_constraint->fail_flag == 0) { 5326 if (level_spec->max_luma_picture_size > 5327 vp9_level_defs[level_index].max_luma_picture_size) { 5328 level_constraint->fail_flag |= (1 << LUMA_PIC_SIZE_TOO_LARGE); 5329 vpx_internal_error(&cm->error, VPX_CODEC_ERROR, 5330 "Failed to encode to the target level %d. %s", 5331 vp9_level_defs[level_index].level, 5332 level_fail_messages[LUMA_PIC_SIZE_TOO_LARGE]); 5333 } 5334 5335 if (level_spec->max_luma_picture_breadth > 5336 vp9_level_defs[level_index].max_luma_picture_breadth) { 5337 level_constraint->fail_flag |= (1 << LUMA_PIC_BREADTH_TOO_LARGE); 5338 vpx_internal_error(&cm->error, VPX_CODEC_ERROR, 5339 "Failed to encode to the target level %d. %s", 5340 vp9_level_defs[level_index].level, 5341 level_fail_messages[LUMA_PIC_BREADTH_TOO_LARGE]); 5342 } 5343 5344 if ((double)level_spec->max_luma_sample_rate > 5345 (double)vp9_level_defs[level_index].max_luma_sample_rate * 5346 (1 + SAMPLE_RATE_GRACE_P)) { 5347 level_constraint->fail_flag |= (1 << LUMA_SAMPLE_RATE_TOO_LARGE); 5348 vpx_internal_error(&cm->error, VPX_CODEC_ERROR, 5349 "Failed to encode to the target level %d. %s", 5350 vp9_level_defs[level_index].level, 5351 level_fail_messages[LUMA_SAMPLE_RATE_TOO_LARGE]); 5352 } 5353 5354 if (level_spec->max_col_tiles > vp9_level_defs[level_index].max_col_tiles) { 5355 level_constraint->fail_flag |= (1 << TOO_MANY_COLUMN_TILE); 5356 vpx_internal_error(&cm->error, VPX_CODEC_ERROR, 5357 "Failed to encode to the target level %d. %s", 5358 vp9_level_defs[level_index].level, 5359 level_fail_messages[TOO_MANY_COLUMN_TILE]); 5360 } 5361 5362 if (level_spec->min_altref_distance < 5363 vp9_level_defs[level_index].min_altref_distance) { 5364 level_constraint->fail_flag |= (1 << ALTREF_DIST_TOO_SMALL); 5365 vpx_internal_error(&cm->error, VPX_CODEC_ERROR, 5366 "Failed to encode to the target level %d. %s", 5367 vp9_level_defs[level_index].level, 5368 level_fail_messages[ALTREF_DIST_TOO_SMALL]); 5369 } 5370 5371 if (level_spec->max_ref_frame_buffers > 5372 vp9_level_defs[level_index].max_ref_frame_buffers) { 5373 level_constraint->fail_flag |= (1 << TOO_MANY_REF_BUFFER); 5374 vpx_internal_error(&cm->error, VPX_CODEC_ERROR, 5375 "Failed to encode to the target level %d. %s", 5376 vp9_level_defs[level_index].level, 5377 level_fail_messages[TOO_MANY_REF_BUFFER]); 5378 } 5379 5380 if (level_spec->max_cpb_size > vp9_level_defs[level_index].max_cpb_size) { 5381 level_constraint->fail_flag |= (1 << CPB_TOO_LARGE); 5382 vpx_internal_error(&cm->error, VPX_CODEC_ERROR, 5383 "Failed to encode to the target level %d. %s", 5384 vp9_level_defs[level_index].level, 5385 level_fail_messages[CPB_TOO_LARGE]); 5386 } 5387 5388 // Set an upper bound for the next frame size. It will be used in 5389 // level_rc_framerate() before encoding the next frame. 5390 cpb_data_size = 0; 5391 for (i = 0; i < CPB_WINDOW_SIZE - 1; ++i) { 5392 if (i >= level_stats->frame_window_buffer.len) break; 5393 idx = (level_stats->frame_window_buffer.start + 5394 level_stats->frame_window_buffer.len - 1 - i) % 5395 FRAME_WINDOW_SIZE; 5396 cpb_data_size += level_stats->frame_window_buffer.buf[idx].size; 5397 } 5398 cpb_data_size = cpb_data_size / 125.0; 5399 level_constraint->max_frame_size = 5400 (int)((vp9_level_defs[level_index].max_cpb_size - cpb_data_size) * 5401 1000.0); 5402 if (level_stats->frame_window_buffer.len < CPB_WINDOW_SIZE - 1) 5403 level_constraint->max_frame_size >>= 1; 5404 } 5405 } 5406 5407 typedef struct GF_PICTURE { 5408 YV12_BUFFER_CONFIG *frame; 5409 int ref_frame[3]; 5410 FRAME_UPDATE_TYPE update_type; 5411 } GF_PICTURE; 5412 5413 static void init_gop_frames(VP9_COMP *cpi, GF_PICTURE *gf_picture, 5414 const GF_GROUP *gf_group, int *tpl_group_frames) { 5415 VP9_COMMON *cm = &cpi->common; 5416 int frame_idx = 0; 5417 int i; 5418 int gld_index = -1; 5419 int alt_index = -1; 5420 int lst_index = -1; 5421 int arf_index_stack[MAX_ARF_LAYERS]; 5422 int arf_stack_size = 0; 5423 int extend_frame_count = 0; 5424 int pframe_qindex = cpi->tpl_stats[2].base_qindex; 5425 int frame_gop_offset = 0; 5426 5427 RefCntBuffer *frame_bufs = cm->buffer_pool->frame_bufs; 5428 int8_t recon_frame_index[REFS_PER_FRAME + MAX_ARF_LAYERS]; 5429 5430 memset(recon_frame_index, -1, sizeof(recon_frame_index)); 5431 stack_init(arf_index_stack, MAX_ARF_LAYERS); 5432 5433 // TODO(jingning): To be used later for gf frame type parsing. 5434 (void)gf_group; 5435 5436 for (i = 0; i < FRAME_BUFFERS; ++i) { 5437 if (frame_bufs[i].ref_count == 0) { 5438 alloc_frame_mvs(cm, i); 5439 if (vpx_realloc_frame_buffer(&frame_bufs[i].buf, cm->width, cm->height, 5440 cm->subsampling_x, cm->subsampling_y, 5441 #if CONFIG_VP9_HIGHBITDEPTH 5442 cm->use_highbitdepth, 5443 #endif 5444 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment, 5445 NULL, NULL, NULL)) 5446 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR, 5447 "Failed to allocate frame buffer"); 5448 5449 recon_frame_index[frame_idx] = i; 5450 ++frame_idx; 5451 5452 if (frame_idx >= REFS_PER_FRAME + cpi->oxcf.enable_auto_arf) break; 5453 } 5454 } 5455 5456 for (i = 0; i < REFS_PER_FRAME + 1; ++i) { 5457 assert(recon_frame_index[i] >= 0); 5458 cpi->tpl_recon_frames[i] = &frame_bufs[recon_frame_index[i]].buf; 5459 } 5460 5461 *tpl_group_frames = 0; 5462 5463 // Initialize Golden reference frame. 5464 gf_picture[0].frame = get_ref_frame_buffer(cpi, GOLDEN_FRAME); 5465 for (i = 0; i < 3; ++i) gf_picture[0].ref_frame[i] = -1; 5466 gf_picture[0].update_type = gf_group->update_type[0]; 5467 gld_index = 0; 5468 ++*tpl_group_frames; 5469 5470 // Initialize base layer ARF frame 5471 gf_picture[1].frame = cpi->Source; 5472 gf_picture[1].ref_frame[0] = gld_index; 5473 gf_picture[1].ref_frame[1] = lst_index; 5474 gf_picture[1].ref_frame[2] = alt_index; 5475 gf_picture[1].update_type = gf_group->update_type[1]; 5476 alt_index = 1; 5477 ++*tpl_group_frames; 5478 5479 // Initialize P frames 5480 for (frame_idx = 2; frame_idx < MAX_ARF_GOP_SIZE; ++frame_idx) { 5481 struct lookahead_entry *buf; 5482 frame_gop_offset = gf_group->frame_gop_index[frame_idx]; 5483 buf = vp9_lookahead_peek(cpi->lookahead, frame_gop_offset - 1); 5484 5485 if (buf == NULL) break; 5486 5487 gf_picture[frame_idx].frame = &buf->img; 5488 gf_picture[frame_idx].ref_frame[0] = gld_index; 5489 gf_picture[frame_idx].ref_frame[1] = lst_index; 5490 gf_picture[frame_idx].ref_frame[2] = alt_index; 5491 gf_picture[frame_idx].update_type = gf_group->update_type[frame_idx]; 5492 5493 switch (gf_group->update_type[frame_idx]) { 5494 case ARF_UPDATE: 5495 stack_push(arf_index_stack, alt_index, arf_stack_size); 5496 ++arf_stack_size; 5497 alt_index = frame_idx; 5498 break; 5499 case LF_UPDATE: lst_index = frame_idx; break; 5500 case OVERLAY_UPDATE: 5501 gld_index = frame_idx; 5502 alt_index = stack_pop(arf_index_stack, arf_stack_size); 5503 --arf_stack_size; 5504 break; 5505 case USE_BUF_FRAME: 5506 lst_index = alt_index; 5507 alt_index = stack_pop(arf_index_stack, arf_stack_size); 5508 --arf_stack_size; 5509 break; 5510 default: break; 5511 } 5512 5513 ++*tpl_group_frames; 5514 5515 // The length of group of pictures is baseline_gf_interval, plus the 5516 // beginning golden frame from last GOP, plus the last overlay frame in 5517 // the same GOP. 5518 if (frame_idx == gf_group->gf_group_size) break; 5519 } 5520 5521 alt_index = -1; 5522 ++frame_idx; 5523 ++frame_gop_offset; 5524 5525 // Extend two frames outside the current gf group. 5526 for (; frame_idx < MAX_LAG_BUFFERS && extend_frame_count < 2; ++frame_idx) { 5527 struct lookahead_entry *buf = 5528 vp9_lookahead_peek(cpi->lookahead, frame_gop_offset - 1); 5529 5530 if (buf == NULL) break; 5531 5532 cpi->tpl_stats[frame_idx].base_qindex = pframe_qindex; 5533 5534 gf_picture[frame_idx].frame = &buf->img; 5535 gf_picture[frame_idx].ref_frame[0] = gld_index; 5536 gf_picture[frame_idx].ref_frame[1] = lst_index; 5537 gf_picture[frame_idx].ref_frame[2] = alt_index; 5538 gf_picture[frame_idx].update_type = LF_UPDATE; 5539 lst_index = frame_idx; 5540 ++*tpl_group_frames; 5541 ++extend_frame_count; 5542 ++frame_gop_offset; 5543 } 5544 } 5545 5546 static void init_tpl_stats(VP9_COMP *cpi) { 5547 int frame_idx; 5548 for (frame_idx = 0; frame_idx < MAX_ARF_GOP_SIZE; ++frame_idx) { 5549 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx]; 5550 #if CONFIG_NON_GREEDY_MV 5551 int rf_idx; 5552 for (rf_idx = 0; rf_idx < 3; ++rf_idx) { 5553 tpl_frame->mv_dist_sum[rf_idx] = 0; 5554 tpl_frame->mv_cost_sum[rf_idx] = 0; 5555 } 5556 #endif 5557 memset(tpl_frame->tpl_stats_ptr, 0, 5558 tpl_frame->height * tpl_frame->width * 5559 sizeof(*tpl_frame->tpl_stats_ptr)); 5560 tpl_frame->is_valid = 0; 5561 } 5562 } 5563 5564 #if CONFIG_NON_GREEDY_MV 5565 static uint32_t motion_compensated_prediction( 5566 VP9_COMP *cpi, ThreadData *td, int frame_idx, uint8_t *cur_frame_buf, 5567 uint8_t *ref_frame_buf, int stride, BLOCK_SIZE bsize, int mi_row, 5568 int mi_col, MV *mv, int rf_idx, double *mv_dist, double *mv_cost) { 5569 #else // CONFIG_NON_GREEDY_MV 5570 static uint32_t motion_compensated_prediction(VP9_COMP *cpi, ThreadData *td, 5571 int frame_idx, 5572 uint8_t *cur_frame_buf, 5573 uint8_t *ref_frame_buf, 5574 int stride, BLOCK_SIZE bsize, 5575 int mi_row, int mi_col, MV *mv) { 5576 #endif // CONFIG_NON_GREEDY_MV 5577 MACROBLOCK *const x = &td->mb; 5578 MACROBLOCKD *const xd = &x->e_mbd; 5579 MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv; 5580 const SEARCH_METHODS search_method = NSTEP; 5581 int step_param; 5582 int sadpb = x->sadperbit16; 5583 uint32_t bestsme = UINT_MAX; 5584 uint32_t distortion; 5585 uint32_t sse; 5586 int cost_list[5]; 5587 const MvLimits tmp_mv_limits = x->mv_limits; 5588 #if CONFIG_NON_GREEDY_MV 5589 // lambda is used to adjust the importance of motion vector consitency. 5590 // TODO(angiebird): Figure out lambda's proper value. 5591 double lambda = cpi->tpl_stats[frame_idx].lambda; 5592 int_mv nb_full_mvs[NB_MVS_NUM]; 5593 #endif 5594 5595 MV best_ref_mv1 = { 0, 0 }; 5596 MV best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */ 5597 5598 best_ref_mv1_full.col = best_ref_mv1.col >> 3; 5599 best_ref_mv1_full.row = best_ref_mv1.row >> 3; 5600 5601 // Setup frame pointers 5602 x->plane[0].src.buf = cur_frame_buf; 5603 x->plane[0].src.stride = stride; 5604 xd->plane[0].pre[0].buf = ref_frame_buf; 5605 xd->plane[0].pre[0].stride = stride; 5606 5607 step_param = mv_sf->reduce_first_step_size; 5608 step_param = VPXMIN(step_param, MAX_MVSEARCH_STEPS - 2); 5609 5610 vp9_set_mv_search_range(&x->mv_limits, &best_ref_mv1); 5611 5612 #if CONFIG_NON_GREEDY_MV 5613 (void)search_method; 5614 (void)sadpb; 5615 vp9_prepare_nb_full_mvs(&cpi->tpl_stats[frame_idx], mi_row, mi_col, rf_idx, 5616 bsize, nb_full_mvs); 5617 vp9_full_pixel_diamond_new(cpi, x, &best_ref_mv1_full, step_param, lambda, 1, 5618 &cpi->fn_ptr[bsize], nb_full_mvs, NB_MVS_NUM, mv, 5619 mv_dist, mv_cost); 5620 #else 5621 (void)frame_idx; 5622 (void)mi_row; 5623 (void)mi_col; 5624 vp9_full_pixel_search(cpi, x, bsize, &best_ref_mv1_full, step_param, 5625 search_method, sadpb, cond_cost_list(cpi, cost_list), 5626 &best_ref_mv1, mv, 0, 0); 5627 #endif 5628 5629 /* restore UMV window */ 5630 x->mv_limits = tmp_mv_limits; 5631 5632 // TODO(yunqing): may use higher tap interp filter than 2 taps. 5633 // Ignore mv costing by sending NULL pointer instead of cost array 5634 bestsme = cpi->find_fractional_mv_step( 5635 x, mv, &best_ref_mv1, cpi->common.allow_high_precision_mv, x->errorperbit, 5636 &cpi->fn_ptr[bsize], 0, mv_sf->subpel_search_level, 5637 cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL, 0, 0, 5638 USE_2_TAPS); 5639 5640 return bestsme; 5641 } 5642 5643 static int get_overlap_area(int grid_pos_row, int grid_pos_col, int ref_pos_row, 5644 int ref_pos_col, int block, BLOCK_SIZE bsize) { 5645 int width = 0, height = 0; 5646 int bw = 4 << b_width_log2_lookup[bsize]; 5647 int bh = 4 << b_height_log2_lookup[bsize]; 5648 5649 switch (block) { 5650 case 0: 5651 width = grid_pos_col + bw - ref_pos_col; 5652 height = grid_pos_row + bh - ref_pos_row; 5653 break; 5654 case 1: 5655 width = ref_pos_col + bw - grid_pos_col; 5656 height = grid_pos_row + bh - ref_pos_row; 5657 break; 5658 case 2: 5659 width = grid_pos_col + bw - ref_pos_col; 5660 height = ref_pos_row + bh - grid_pos_row; 5661 break; 5662 case 3: 5663 width = ref_pos_col + bw - grid_pos_col; 5664 height = ref_pos_row + bh - grid_pos_row; 5665 break; 5666 default: assert(0); 5667 } 5668 5669 return width * height; 5670 } 5671 5672 static int round_floor(int ref_pos, int bsize_pix) { 5673 int round; 5674 if (ref_pos < 0) 5675 round = -(1 + (-ref_pos - 1) / bsize_pix); 5676 else 5677 round = ref_pos / bsize_pix; 5678 5679 return round; 5680 } 5681 5682 static void tpl_model_store(TplDepStats *tpl_stats, int mi_row, int mi_col, 5683 BLOCK_SIZE bsize, int stride) { 5684 const int mi_height = num_8x8_blocks_high_lookup[bsize]; 5685 const int mi_width = num_8x8_blocks_wide_lookup[bsize]; 5686 const TplDepStats *src_stats = &tpl_stats[mi_row * stride + mi_col]; 5687 int idx, idy; 5688 5689 for (idy = 0; idy < mi_height; ++idy) { 5690 for (idx = 0; idx < mi_width; ++idx) { 5691 TplDepStats *tpl_ptr = &tpl_stats[(mi_row + idy) * stride + mi_col + idx]; 5692 const int64_t mc_flow = tpl_ptr->mc_flow; 5693 const int64_t mc_ref_cost = tpl_ptr->mc_ref_cost; 5694 *tpl_ptr = *src_stats; 5695 tpl_ptr->mc_flow = mc_flow; 5696 tpl_ptr->mc_ref_cost = mc_ref_cost; 5697 tpl_ptr->mc_dep_cost = tpl_ptr->intra_cost + tpl_ptr->mc_flow; 5698 } 5699 } 5700 } 5701 5702 static void tpl_model_update_b(TplDepFrame *tpl_frame, TplDepStats *tpl_stats, 5703 int mi_row, int mi_col, const BLOCK_SIZE bsize) { 5704 TplDepFrame *ref_tpl_frame = &tpl_frame[tpl_stats->ref_frame_index]; 5705 TplDepStats *ref_stats = ref_tpl_frame->tpl_stats_ptr; 5706 MV mv = tpl_stats->mv.as_mv; 5707 int mv_row = mv.row >> 3; 5708 int mv_col = mv.col >> 3; 5709 5710 int ref_pos_row = mi_row * MI_SIZE + mv_row; 5711 int ref_pos_col = mi_col * MI_SIZE + mv_col; 5712 5713 const int bw = 4 << b_width_log2_lookup[bsize]; 5714 const int bh = 4 << b_height_log2_lookup[bsize]; 5715 const int mi_height = num_8x8_blocks_high_lookup[bsize]; 5716 const int mi_width = num_8x8_blocks_wide_lookup[bsize]; 5717 const int pix_num = bw * bh; 5718 5719 // top-left on grid block location in pixel 5720 int grid_pos_row_base = round_floor(ref_pos_row, bh) * bh; 5721 int grid_pos_col_base = round_floor(ref_pos_col, bw) * bw; 5722 int block; 5723 5724 for (block = 0; block < 4; ++block) { 5725 int grid_pos_row = grid_pos_row_base + bh * (block >> 1); 5726 int grid_pos_col = grid_pos_col_base + bw * (block & 0x01); 5727 5728 if (grid_pos_row >= 0 && grid_pos_row < ref_tpl_frame->mi_rows * MI_SIZE && 5729 grid_pos_col >= 0 && grid_pos_col < ref_tpl_frame->mi_cols * MI_SIZE) { 5730 int overlap_area = get_overlap_area( 5731 grid_pos_row, grid_pos_col, ref_pos_row, ref_pos_col, block, bsize); 5732 int ref_mi_row = round_floor(grid_pos_row, bh) * mi_height; 5733 int ref_mi_col = round_floor(grid_pos_col, bw) * mi_width; 5734 5735 int64_t mc_flow = tpl_stats->mc_dep_cost - 5736 (tpl_stats->mc_dep_cost * tpl_stats->inter_cost) / 5737 tpl_stats->intra_cost; 5738 5739 int idx, idy; 5740 5741 for (idy = 0; idy < mi_height; ++idy) { 5742 for (idx = 0; idx < mi_width; ++idx) { 5743 TplDepStats *des_stats = 5744 &ref_stats[(ref_mi_row + idy) * ref_tpl_frame->stride + 5745 (ref_mi_col + idx)]; 5746 5747 des_stats->mc_flow += (mc_flow * overlap_area) / pix_num; 5748 des_stats->mc_ref_cost += 5749 ((tpl_stats->intra_cost - tpl_stats->inter_cost) * overlap_area) / 5750 pix_num; 5751 assert(overlap_area >= 0); 5752 } 5753 } 5754 } 5755 } 5756 } 5757 5758 static void tpl_model_update(TplDepFrame *tpl_frame, TplDepStats *tpl_stats, 5759 int mi_row, int mi_col, const BLOCK_SIZE bsize) { 5760 int idx, idy; 5761 const int mi_height = num_8x8_blocks_high_lookup[bsize]; 5762 const int mi_width = num_8x8_blocks_wide_lookup[bsize]; 5763 5764 for (idy = 0; idy < mi_height; ++idy) { 5765 for (idx = 0; idx < mi_width; ++idx) { 5766 TplDepStats *tpl_ptr = 5767 &tpl_stats[(mi_row + idy) * tpl_frame->stride + (mi_col + idx)]; 5768 tpl_model_update_b(tpl_frame, tpl_ptr, mi_row + idy, mi_col + idx, 5769 BLOCK_8X8); 5770 } 5771 } 5772 } 5773 5774 static void get_quantize_error(MACROBLOCK *x, int plane, tran_low_t *coeff, 5775 tran_low_t *qcoeff, tran_low_t *dqcoeff, 5776 TX_SIZE tx_size, int64_t *recon_error, 5777 int64_t *sse) { 5778 MACROBLOCKD *const xd = &x->e_mbd; 5779 const struct macroblock_plane *const p = &x->plane[plane]; 5780 const struct macroblockd_plane *const pd = &xd->plane[plane]; 5781 const scan_order *const scan_order = &vp9_default_scan_orders[tx_size]; 5782 uint16_t eob; 5783 int pix_num = 1 << num_pels_log2_lookup[txsize_to_bsize[tx_size]]; 5784 const int shift = tx_size == TX_32X32 ? 0 : 2; 5785 5786 #if CONFIG_VP9_HIGHBITDEPTH 5787 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { 5788 vp9_highbd_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp, 5789 p->quant_fp, qcoeff, dqcoeff, pd->dequant, 5790 &eob, scan_order->scan, scan_order->iscan); 5791 } else { 5792 vp9_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp, 5793 p->quant_fp, qcoeff, dqcoeff, pd->dequant, &eob, 5794 scan_order->scan, scan_order->iscan); 5795 } 5796 #else 5797 vp9_quantize_fp_32x32(coeff, pix_num, x->skip_block, p->round_fp, p->quant_fp, 5798 qcoeff, dqcoeff, pd->dequant, &eob, scan_order->scan, 5799 scan_order->iscan); 5800 #endif // CONFIG_VP9_HIGHBITDEPTH 5801 5802 *recon_error = vp9_block_error(coeff, dqcoeff, pix_num, sse) >> shift; 5803 *recon_error = VPXMAX(*recon_error, 1); 5804 5805 *sse = (*sse) >> shift; 5806 *sse = VPXMAX(*sse, 1); 5807 } 5808 5809 #if CONFIG_VP9_HIGHBITDEPTH 5810 static void highbd_wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff, 5811 TX_SIZE tx_size) { 5812 // TODO(sdeng): Implement SIMD based high bit-depth Hadamard transforms. 5813 switch (tx_size) { 5814 case TX_8X8: vpx_highbd_hadamard_8x8(src_diff, bw, coeff); break; 5815 case TX_16X16: vpx_highbd_hadamard_16x16(src_diff, bw, coeff); break; 5816 case TX_32X32: vpx_highbd_hadamard_32x32(src_diff, bw, coeff); break; 5817 default: assert(0); 5818 } 5819 } 5820 #endif // CONFIG_VP9_HIGHBITDEPTH 5821 5822 static void wht_fwd_txfm(int16_t *src_diff, int bw, tran_low_t *coeff, 5823 TX_SIZE tx_size) { 5824 switch (tx_size) { 5825 case TX_8X8: vpx_hadamard_8x8(src_diff, bw, coeff); break; 5826 case TX_16X16: vpx_hadamard_16x16(src_diff, bw, coeff); break; 5827 case TX_32X32: vpx_hadamard_32x32(src_diff, bw, coeff); break; 5828 default: assert(0); 5829 } 5830 } 5831 5832 #if CONFIG_NON_GREEDY_MV 5833 double get_feature_score(uint8_t *buf, ptrdiff_t stride, int rows, int cols) { 5834 double IxIx = 0; 5835 double IxIy = 0; 5836 double IyIy = 0; 5837 double score; 5838 int r, c; 5839 vpx_clear_system_state(); 5840 for (r = 0; r + 1 < rows; ++r) { 5841 for (c = 0; c + 1 < cols; ++c) { 5842 int diff_x = buf[r * stride + c] - buf[r * stride + c + 1]; 5843 int diff_y = buf[r * stride + c] - buf[(r + 1) * stride + c]; 5844 IxIx += diff_x * diff_x; 5845 IxIy += diff_x * diff_y; 5846 IyIy += diff_y * diff_y; 5847 } 5848 } 5849 IxIx /= (rows - 1) * (cols - 1); 5850 IxIy /= (rows - 1) * (cols - 1); 5851 IyIy /= (rows - 1) * (cols - 1); 5852 score = (IxIx * IyIy - IxIy * IxIy + 0.0001) / (IxIx + IyIy + 0.0001); 5853 return score; 5854 } 5855 #endif 5856 5857 static void set_mv_limits(const VP9_COMMON *cm, MACROBLOCK *x, int mi_row, 5858 int mi_col) { 5859 x->mv_limits.row_min = -((mi_row * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND)); 5860 x->mv_limits.row_max = 5861 (cm->mi_rows - 1 - mi_row) * MI_SIZE + (17 - 2 * VP9_INTERP_EXTEND); 5862 x->mv_limits.col_min = -((mi_col * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND)); 5863 x->mv_limits.col_max = 5864 ((cm->mi_cols - 1 - mi_col) * MI_SIZE) + (17 - 2 * VP9_INTERP_EXTEND); 5865 } 5866 5867 static void mode_estimation(VP9_COMP *cpi, MACROBLOCK *x, MACROBLOCKD *xd, 5868 struct scale_factors *sf, GF_PICTURE *gf_picture, 5869 int frame_idx, TplDepFrame *tpl_frame, 5870 int16_t *src_diff, tran_low_t *coeff, 5871 tran_low_t *qcoeff, tran_low_t *dqcoeff, int mi_row, 5872 int mi_col, BLOCK_SIZE bsize, TX_SIZE tx_size, 5873 YV12_BUFFER_CONFIG *ref_frame[], uint8_t *predictor, 5874 int64_t *recon_error, int64_t *sse) { 5875 VP9_COMMON *cm = &cpi->common; 5876 ThreadData *td = &cpi->td; 5877 5878 const int bw = 4 << b_width_log2_lookup[bsize]; 5879 const int bh = 4 << b_height_log2_lookup[bsize]; 5880 const int pix_num = bw * bh; 5881 int best_rf_idx = -1; 5882 int_mv best_mv; 5883 int64_t best_inter_cost = INT64_MAX; 5884 int64_t inter_cost; 5885 int rf_idx; 5886 const InterpKernel *const kernel = vp9_filter_kernels[EIGHTTAP]; 5887 5888 int64_t best_intra_cost = INT64_MAX; 5889 int64_t intra_cost; 5890 PREDICTION_MODE mode; 5891 int mb_y_offset = mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE; 5892 MODE_INFO mi_above, mi_left; 5893 const int mi_height = num_8x8_blocks_high_lookup[bsize]; 5894 const int mi_width = num_8x8_blocks_wide_lookup[bsize]; 5895 TplDepStats *tpl_stats = 5896 &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col]; 5897 5898 xd->mb_to_top_edge = -((mi_row * MI_SIZE) * 8); 5899 xd->mb_to_bottom_edge = ((cm->mi_rows - 1 - mi_row) * MI_SIZE) * 8; 5900 xd->mb_to_left_edge = -((mi_col * MI_SIZE) * 8); 5901 xd->mb_to_right_edge = ((cm->mi_cols - 1 - mi_col) * MI_SIZE) * 8; 5902 xd->above_mi = (mi_row > 0) ? &mi_above : NULL; 5903 xd->left_mi = (mi_col > 0) ? &mi_left : NULL; 5904 5905 // Intra prediction search 5906 for (mode = DC_PRED; mode <= TM_PRED; ++mode) { 5907 uint8_t *src, *dst; 5908 int src_stride, dst_stride; 5909 5910 src = xd->cur_buf->y_buffer + mb_y_offset; 5911 src_stride = xd->cur_buf->y_stride; 5912 5913 dst = &predictor[0]; 5914 dst_stride = bw; 5915 5916 xd->mi[0]->sb_type = bsize; 5917 xd->mi[0]->ref_frame[0] = INTRA_FRAME; 5918 5919 vp9_predict_intra_block(xd, b_width_log2_lookup[bsize], tx_size, mode, src, 5920 src_stride, dst, dst_stride, 0, 0, 0); 5921 5922 #if CONFIG_VP9_HIGHBITDEPTH 5923 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { 5924 vpx_highbd_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst, 5925 dst_stride, xd->bd); 5926 highbd_wht_fwd_txfm(src_diff, bw, coeff, tx_size); 5927 intra_cost = vpx_highbd_satd(coeff, pix_num); 5928 } else { 5929 vpx_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst, 5930 dst_stride); 5931 wht_fwd_txfm(src_diff, bw, coeff, tx_size); 5932 intra_cost = vpx_satd(coeff, pix_num); 5933 } 5934 #else 5935 vpx_subtract_block(bh, bw, src_diff, bw, src, src_stride, dst, dst_stride); 5936 wht_fwd_txfm(src_diff, bw, coeff, tx_size); 5937 intra_cost = vpx_satd(coeff, pix_num); 5938 #endif // CONFIG_VP9_HIGHBITDEPTH 5939 5940 if (intra_cost < best_intra_cost) best_intra_cost = intra_cost; 5941 } 5942 5943 // Motion compensated prediction 5944 best_mv.as_int = 0; 5945 5946 set_mv_limits(cm, x, mi_row, mi_col); 5947 5948 for (rf_idx = 0; rf_idx < 3; ++rf_idx) { 5949 int_mv mv; 5950 if (ref_frame[rf_idx] == NULL) continue; 5951 5952 #if CONFIG_NON_GREEDY_MV 5953 (void)td; 5954 mv.as_int = 5955 get_pyramid_mv(tpl_frame, rf_idx, bsize, mi_row, mi_col)->as_int; 5956 #else 5957 motion_compensated_prediction( 5958 cpi, td, frame_idx, xd->cur_buf->y_buffer + mb_y_offset, 5959 ref_frame[rf_idx]->y_buffer + mb_y_offset, xd->cur_buf->y_stride, bsize, 5960 mi_row, mi_col, &mv.as_mv); 5961 #endif 5962 5963 #if CONFIG_VP9_HIGHBITDEPTH 5964 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { 5965 vp9_highbd_build_inter_predictor( 5966 CONVERT_TO_SHORTPTR(ref_frame[rf_idx]->y_buffer + mb_y_offset), 5967 ref_frame[rf_idx]->y_stride, CONVERT_TO_SHORTPTR(&predictor[0]), bw, 5968 &mv.as_mv, sf, bw, bh, 0, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE, 5969 mi_row * MI_SIZE, xd->bd); 5970 vpx_highbd_subtract_block( 5971 bh, bw, src_diff, bw, xd->cur_buf->y_buffer + mb_y_offset, 5972 xd->cur_buf->y_stride, &predictor[0], bw, xd->bd); 5973 highbd_wht_fwd_txfm(src_diff, bw, coeff, tx_size); 5974 inter_cost = vpx_highbd_satd(coeff, pix_num); 5975 } else { 5976 vp9_build_inter_predictor( 5977 ref_frame[rf_idx]->y_buffer + mb_y_offset, 5978 ref_frame[rf_idx]->y_stride, &predictor[0], bw, &mv.as_mv, sf, bw, bh, 5979 0, kernel, MV_PRECISION_Q3, mi_col * MI_SIZE, mi_row * MI_SIZE); 5980 vpx_subtract_block(bh, bw, src_diff, bw, 5981 xd->cur_buf->y_buffer + mb_y_offset, 5982 xd->cur_buf->y_stride, &predictor[0], bw); 5983 wht_fwd_txfm(src_diff, bw, coeff, tx_size); 5984 inter_cost = vpx_satd(coeff, pix_num); 5985 } 5986 #else 5987 vp9_build_inter_predictor(ref_frame[rf_idx]->y_buffer + mb_y_offset, 5988 ref_frame[rf_idx]->y_stride, &predictor[0], bw, 5989 &mv.as_mv, sf, bw, bh, 0, kernel, MV_PRECISION_Q3, 5990 mi_col * MI_SIZE, mi_row * MI_SIZE); 5991 vpx_subtract_block(bh, bw, src_diff, bw, 5992 xd->cur_buf->y_buffer + mb_y_offset, 5993 xd->cur_buf->y_stride, &predictor[0], bw); 5994 wht_fwd_txfm(src_diff, bw, coeff, tx_size); 5995 inter_cost = vpx_satd(coeff, pix_num); 5996 #endif 5997 5998 #if CONFIG_NON_GREEDY_MV 5999 tpl_stats->inter_cost_arr[rf_idx] = inter_cost; 6000 get_quantize_error(x, 0, coeff, qcoeff, dqcoeff, tx_size, 6001 &tpl_stats->recon_error_arr[rf_idx], 6002 &tpl_stats->sse_arr[rf_idx]); 6003 #endif 6004 6005 if (inter_cost < best_inter_cost) { 6006 best_rf_idx = rf_idx; 6007 best_inter_cost = inter_cost; 6008 best_mv.as_int = mv.as_int; 6009 #if CONFIG_NON_GREEDY_MV 6010 *recon_error = tpl_stats->recon_error_arr[rf_idx]; 6011 *sse = tpl_stats->sse_arr[rf_idx]; 6012 #else 6013 get_quantize_error(x, 0, coeff, qcoeff, dqcoeff, tx_size, recon_error, 6014 sse); 6015 #endif 6016 } 6017 } 6018 best_intra_cost = VPXMAX(best_intra_cost, 1); 6019 best_inter_cost = VPXMIN(best_intra_cost, best_inter_cost); 6020 tpl_stats->inter_cost = VPXMAX( 6021 1, (best_inter_cost << TPL_DEP_COST_SCALE_LOG2) / (mi_height * mi_width)); 6022 tpl_stats->intra_cost = VPXMAX( 6023 1, (best_intra_cost << TPL_DEP_COST_SCALE_LOG2) / (mi_height * mi_width)); 6024 tpl_stats->ref_frame_index = gf_picture[frame_idx].ref_frame[best_rf_idx]; 6025 tpl_stats->mv.as_int = best_mv.as_int; 6026 } 6027 6028 #if CONFIG_NON_GREEDY_MV 6029 static int compare_feature_score(const void *a, const void *b) { 6030 const FEATURE_SCORE_LOC *aa = *(FEATURE_SCORE_LOC *const *)a; 6031 const FEATURE_SCORE_LOC *bb = *(FEATURE_SCORE_LOC *const *)b; 6032 if (aa->feature_score < bb->feature_score) { 6033 return 1; 6034 } else if (aa->feature_score > bb->feature_score) { 6035 return -1; 6036 } else { 6037 return 0; 6038 } 6039 } 6040 6041 static void do_motion_search(VP9_COMP *cpi, ThreadData *td, int frame_idx, 6042 YV12_BUFFER_CONFIG **ref_frame, BLOCK_SIZE bsize, 6043 int mi_row, int mi_col) { 6044 VP9_COMMON *cm = &cpi->common; 6045 MACROBLOCK *x = &td->mb; 6046 MACROBLOCKD *xd = &x->e_mbd; 6047 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx]; 6048 TplDepStats *tpl_stats = 6049 &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col]; 6050 const int mb_y_offset = 6051 mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE; 6052 int rf_idx; 6053 6054 set_mv_limits(cm, x, mi_row, mi_col); 6055 6056 for (rf_idx = 0; rf_idx < 3; ++rf_idx) { 6057 int_mv *mv = get_pyramid_mv(tpl_frame, rf_idx, bsize, mi_row, mi_col); 6058 if (ref_frame[rf_idx] == NULL) { 6059 tpl_stats->ready[rf_idx] = 0; 6060 continue; 6061 } else { 6062 tpl_stats->ready[rf_idx] = 1; 6063 } 6064 motion_compensated_prediction( 6065 cpi, td, frame_idx, xd->cur_buf->y_buffer + mb_y_offset, 6066 ref_frame[rf_idx]->y_buffer + mb_y_offset, xd->cur_buf->y_stride, bsize, 6067 mi_row, mi_col, &mv->as_mv, rf_idx, &tpl_stats->mv_dist[rf_idx], 6068 &tpl_stats->mv_cost[rf_idx]); 6069 } 6070 } 6071 6072 #define CHANGE_MV_SEARCH_ORDER 1 6073 #define USE_PQSORT 1 6074 #define RE_COMPUTE_MV_INCONSISTENCY 1 6075 6076 #if CHANGE_MV_SEARCH_ORDER 6077 #if USE_PQSORT 6078 static void max_heap_pop(FEATURE_SCORE_LOC **heap, int *size, 6079 FEATURE_SCORE_LOC **output) { 6080 if (*size > 0) { 6081 *output = heap[0]; 6082 --*size; 6083 if (*size > 0) { 6084 int p, l, r; 6085 heap[0] = heap[*size]; 6086 p = 0; 6087 l = 2 * p + 1; 6088 r = 2 * p + 2; 6089 while (l < *size) { 6090 FEATURE_SCORE_LOC *tmp; 6091 int c = l; 6092 if (r < *size && heap[r]->feature_score > heap[l]->feature_score) { 6093 c = r; 6094 } 6095 if (heap[p]->feature_score >= heap[c]->feature_score) { 6096 break; 6097 } 6098 tmp = heap[p]; 6099 heap[p] = heap[c]; 6100 heap[c] = tmp; 6101 p = c; 6102 l = 2 * p + 1; 6103 r = 2 * p + 2; 6104 } 6105 } 6106 } else { 6107 assert(0); 6108 } 6109 } 6110 6111 static void max_heap_push(FEATURE_SCORE_LOC **heap, int *size, 6112 FEATURE_SCORE_LOC *input) { 6113 int c, p; 6114 FEATURE_SCORE_LOC *tmp; 6115 heap[*size] = input; 6116 ++*size; 6117 c = *size - 1; 6118 p = c >> 1; 6119 while (c > 0 && heap[c]->feature_score > heap[p]->feature_score) { 6120 tmp = heap[p]; 6121 heap[p] = heap[c]; 6122 heap[c] = tmp; 6123 c = p; 6124 p >>= 1; 6125 } 6126 } 6127 6128 static void add_nb_blocks_to_heap(VP9_COMP *cpi, const TplDepFrame *tpl_frame, 6129 BLOCK_SIZE bsize, int mi_row, int mi_col, 6130 int *heap_size) { 6131 const int mi_unit = num_8x8_blocks_wide_lookup[bsize]; 6132 const int dirs[NB_MVS_NUM][2] = { { -1, 0 }, { 0, -1 }, { 1, 0 }, { 0, 1 } }; 6133 int i; 6134 for (i = 0; i < NB_MVS_NUM; ++i) { 6135 int r = dirs[i][0] * mi_unit; 6136 int c = dirs[i][1] * mi_unit; 6137 if (mi_row + r >= 0 && mi_row + r < tpl_frame->mi_rows && mi_col + c >= 0 && 6138 mi_col + c < tpl_frame->mi_cols) { 6139 FEATURE_SCORE_LOC *fs_loc = 6140 &cpi->feature_score_loc_arr[(mi_row + r) * tpl_frame->stride + 6141 (mi_col + c)]; 6142 if (fs_loc->visited == 0) { 6143 max_heap_push(cpi->feature_score_loc_heap, heap_size, fs_loc); 6144 } 6145 } 6146 } 6147 } 6148 #endif // USE_PQSORT 6149 #endif // CHANGE_MV_SEARCH_ORDER 6150 6151 static void build_motion_field(VP9_COMP *cpi, MACROBLOCKD *xd, int frame_idx, 6152 YV12_BUFFER_CONFIG *ref_frame[3], 6153 BLOCK_SIZE bsize) { 6154 VP9_COMMON *cm = &cpi->common; 6155 ThreadData *td = &cpi->td; 6156 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx]; 6157 const int mi_height = num_8x8_blocks_high_lookup[bsize]; 6158 const int mi_width = num_8x8_blocks_wide_lookup[bsize]; 6159 int fs_loc_sort_size; 6160 int fs_loc_heap_size; 6161 int mi_row, mi_col; 6162 6163 tpl_frame->lambda = 250; 6164 6165 fs_loc_sort_size = 0; 6166 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) { 6167 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) { 6168 const int mb_y_offset = 6169 mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE; 6170 const int bw = 4 << b_width_log2_lookup[bsize]; 6171 const int bh = 4 << b_height_log2_lookup[bsize]; 6172 TplDepStats *tpl_stats = 6173 &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col]; 6174 FEATURE_SCORE_LOC *fs_loc = 6175 &cpi->feature_score_loc_arr[mi_row * tpl_frame->stride + mi_col]; 6176 tpl_stats->feature_score = get_feature_score( 6177 xd->cur_buf->y_buffer + mb_y_offset, xd->cur_buf->y_stride, bw, bh); 6178 fs_loc->visited = 0; 6179 fs_loc->feature_score = tpl_stats->feature_score; 6180 fs_loc->mi_row = mi_row; 6181 fs_loc->mi_col = mi_col; 6182 cpi->feature_score_loc_sort[fs_loc_sort_size] = fs_loc; 6183 ++fs_loc_sort_size; 6184 } 6185 } 6186 6187 qsort(cpi->feature_score_loc_sort, fs_loc_sort_size, 6188 sizeof(*cpi->feature_score_loc_sort), compare_feature_score); 6189 6190 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) { 6191 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) { 6192 int rf_idx; 6193 for (rf_idx = 0; rf_idx < 3; ++rf_idx) { 6194 TplDepStats *tpl_stats = 6195 &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col]; 6196 tpl_stats->ready[rf_idx] = 0; 6197 } 6198 } 6199 } 6200 6201 #if CHANGE_MV_SEARCH_ORDER 6202 #if !USE_PQSORT 6203 for (i = 0; i < fs_loc_sort_size; ++i) { 6204 FEATURE_SCORE_LOC *fs_loc = cpi->feature_score_loc_sort[i]; 6205 do_motion_search(cpi, td, frame_idx, ref_frame, bsize, fs_loc->mi_row, 6206 fs_loc->mi_col); 6207 } 6208 #else // !USE_PQSORT 6209 fs_loc_heap_size = 0; 6210 max_heap_push(cpi->feature_score_loc_heap, &fs_loc_heap_size, 6211 cpi->feature_score_loc_sort[0]); 6212 6213 while (fs_loc_heap_size > 0) { 6214 FEATURE_SCORE_LOC *fs_loc; 6215 max_heap_pop(cpi->feature_score_loc_heap, &fs_loc_heap_size, &fs_loc); 6216 6217 fs_loc->visited = 1; 6218 6219 do_motion_search(cpi, td, frame_idx, ref_frame, bsize, fs_loc->mi_row, 6220 fs_loc->mi_col); 6221 6222 add_nb_blocks_to_heap(cpi, tpl_frame, bsize, fs_loc->mi_row, fs_loc->mi_col, 6223 &fs_loc_heap_size); 6224 } 6225 #endif // !USE_PQSORT 6226 #else // CHANGE_MV_SEARCH_ORDER 6227 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) { 6228 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) { 6229 do_motion_search(cpi, td, frame_idx, ref_frame, bsize, mi_row, mi_col); 6230 } 6231 } 6232 #endif // CHANGE_MV_SEARCH_ORDER 6233 } 6234 #endif // CONFIG_NON_GREEDY_MV 6235 6236 static void mc_flow_dispenser(VP9_COMP *cpi, GF_PICTURE *gf_picture, 6237 int frame_idx, BLOCK_SIZE bsize) { 6238 TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx]; 6239 YV12_BUFFER_CONFIG *this_frame = gf_picture[frame_idx].frame; 6240 YV12_BUFFER_CONFIG *ref_frame[3] = { NULL, NULL, NULL }; 6241 6242 VP9_COMMON *cm = &cpi->common; 6243 struct scale_factors sf; 6244 int rdmult, idx; 6245 ThreadData *td = &cpi->td; 6246 MACROBLOCK *x = &td->mb; 6247 MACROBLOCKD *xd = &x->e_mbd; 6248 int mi_row, mi_col; 6249 6250 #if CONFIG_VP9_HIGHBITDEPTH 6251 DECLARE_ALIGNED(16, uint16_t, predictor16[32 * 32 * 3]); 6252 DECLARE_ALIGNED(16, uint8_t, predictor8[32 * 32 * 3]); 6253 uint8_t *predictor; 6254 #else 6255 DECLARE_ALIGNED(16, uint8_t, predictor[32 * 32 * 3]); 6256 #endif 6257 DECLARE_ALIGNED(16, int16_t, src_diff[32 * 32]); 6258 DECLARE_ALIGNED(16, tran_low_t, coeff[32 * 32]); 6259 DECLARE_ALIGNED(16, tran_low_t, qcoeff[32 * 32]); 6260 DECLARE_ALIGNED(16, tran_low_t, dqcoeff[32 * 32]); 6261 6262 const TX_SIZE tx_size = max_txsize_lookup[bsize]; 6263 const int mi_height = num_8x8_blocks_high_lookup[bsize]; 6264 const int mi_width = num_8x8_blocks_wide_lookup[bsize]; 6265 int64_t recon_error, sse; 6266 #if CONFIG_NON_GREEDY_MV 6267 int square_block_idx; 6268 #endif 6269 6270 // Setup scaling factor 6271 #if CONFIG_VP9_HIGHBITDEPTH 6272 vp9_setup_scale_factors_for_frame( 6273 &sf, this_frame->y_crop_width, this_frame->y_crop_height, 6274 this_frame->y_crop_width, this_frame->y_crop_height, 6275 cpi->common.use_highbitdepth); 6276 6277 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) 6278 predictor = CONVERT_TO_BYTEPTR(predictor16); 6279 else 6280 predictor = predictor8; 6281 #else 6282 vp9_setup_scale_factors_for_frame( 6283 &sf, this_frame->y_crop_width, this_frame->y_crop_height, 6284 this_frame->y_crop_width, this_frame->y_crop_height); 6285 #endif // CONFIG_VP9_HIGHBITDEPTH 6286 6287 // Prepare reference frame pointers. If any reference frame slot is 6288 // unavailable, the pointer will be set to Null. 6289 for (idx = 0; idx < 3; ++idx) { 6290 int rf_idx = gf_picture[frame_idx].ref_frame[idx]; 6291 if (rf_idx != -1) ref_frame[idx] = gf_picture[rf_idx].frame; 6292 } 6293 6294 xd->mi = cm->mi_grid_visible; 6295 xd->mi[0] = cm->mi; 6296 xd->cur_buf = this_frame; 6297 6298 // Get rd multiplier set up. 6299 rdmult = vp9_compute_rd_mult_based_on_qindex(cpi, tpl_frame->base_qindex); 6300 set_error_per_bit(&cpi->td.mb, rdmult); 6301 vp9_initialize_me_consts(cpi, &cpi->td.mb, tpl_frame->base_qindex); 6302 6303 tpl_frame->is_valid = 1; 6304 6305 cm->base_qindex = tpl_frame->base_qindex; 6306 vp9_frame_init_quantizer(cpi); 6307 6308 #if CONFIG_NON_GREEDY_MV 6309 for (square_block_idx = 0; square_block_idx < SQUARE_BLOCK_SIZES; 6310 ++square_block_idx) { 6311 BLOCK_SIZE square_bsize = square_block_idx_to_bsize(square_block_idx); 6312 build_motion_field(cpi, xd, frame_idx, ref_frame, square_bsize); 6313 } 6314 #endif 6315 6316 for (mi_row = 0; mi_row < cm->mi_rows; mi_row += mi_height) { 6317 for (mi_col = 0; mi_col < cm->mi_cols; mi_col += mi_width) { 6318 mode_estimation(cpi, x, xd, &sf, gf_picture, frame_idx, tpl_frame, 6319 src_diff, coeff, qcoeff, dqcoeff, mi_row, mi_col, bsize, 6320 tx_size, ref_frame, predictor, &recon_error, &sse); 6321 // Motion flow dependency dispenser. 6322 tpl_model_store(tpl_frame->tpl_stats_ptr, mi_row, mi_col, bsize, 6323 tpl_frame->stride); 6324 6325 tpl_model_update(cpi->tpl_stats, tpl_frame->tpl_stats_ptr, mi_row, mi_col, 6326 bsize); 6327 #if CONFIG_NON_GREEDY_MV 6328 { 6329 int rf_idx; 6330 TplDepStats *this_tpl_stats = 6331 &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col]; 6332 for (rf_idx = 0; rf_idx < 3; ++rf_idx) { 6333 #if RE_COMPUTE_MV_INCONSISTENCY 6334 MV this_mv = 6335 get_pyramid_mv(tpl_frame, rf_idx, bsize, mi_row, mi_col)->as_mv; 6336 MV full_mv; 6337 int_mv nb_full_mvs[NB_MVS_NUM]; 6338 vp9_prepare_nb_full_mvs(tpl_frame, mi_row, mi_col, rf_idx, bsize, 6339 nb_full_mvs); 6340 full_mv.row = this_mv.row >> 3; 6341 full_mv.col = this_mv.col >> 3; 6342 this_tpl_stats->mv_cost[rf_idx] = 6343 vp9_nb_mvs_inconsistency(&full_mv, nb_full_mvs, NB_MVS_NUM); 6344 #endif // RE_COMPUTE_MV_INCONSISTENCY 6345 tpl_frame->mv_dist_sum[rf_idx] += this_tpl_stats->mv_dist[rf_idx]; 6346 tpl_frame->mv_cost_sum[rf_idx] += this_tpl_stats->mv_cost[rf_idx]; 6347 } 6348 } 6349 #endif // CONFIG_NON_GREEDY_MV 6350 } 6351 } 6352 } 6353 6354 #if CONFIG_NON_GREEDY_MV 6355 #define DUMP_TPL_STATS 0 6356 #if DUMP_TPL_STATS 6357 static void dump_buf(uint8_t *buf, int stride, int row, int col, int h, int w) { 6358 printf("%d %d\n", h, w); 6359 for (int i = 0; i < h; ++i) { 6360 for (int j = 0; j < w; ++j) { 6361 printf("%d ", buf[(row + i) * stride + col + j]); 6362 } 6363 } 6364 printf("\n"); 6365 } 6366 6367 static void dump_frame_buf(const YV12_BUFFER_CONFIG *frame_buf) { 6368 dump_buf(frame_buf->y_buffer, frame_buf->y_stride, 0, 0, frame_buf->y_height, 6369 frame_buf->y_width); 6370 dump_buf(frame_buf->u_buffer, frame_buf->uv_stride, 0, 0, 6371 frame_buf->uv_height, frame_buf->uv_width); 6372 dump_buf(frame_buf->v_buffer, frame_buf->uv_stride, 0, 0, 6373 frame_buf->uv_height, frame_buf->uv_width); 6374 } 6375 6376 static void dump_tpl_stats(const VP9_COMP *cpi, int tpl_group_frames, 6377 const GF_PICTURE *gf_picture, BLOCK_SIZE bsize) { 6378 int frame_idx; 6379 const VP9_COMMON *cm = &cpi->common; 6380 for (frame_idx = 1; frame_idx < tpl_group_frames; ++frame_idx) { 6381 const TplDepFrame *tpl_frame = &cpi->tpl_stats[frame_idx]; 6382 int idx = 0; 6383 int mi_row, mi_col; 6384 int rf_idx; 6385 const int mi_height = num_8x8_blocks_high_lookup[bsize]; 6386 const int mi_width = num_8x8_blocks_wide_lookup[bsize]; 6387 printf("=\n"); 6388 printf("frame_idx %d mi_rows %d mi_cols %d bsize %d\n", frame_idx, 6389 cm->mi_rows, cm->mi_cols, mi_width * MI_SIZE); 6390 for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row) { 6391 for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) { 6392 if ((mi_row % mi_height) == 0 && (mi_col % mi_width) == 0) { 6393 const TplDepStats *tpl_ptr = 6394 &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col]; 6395 int_mv mv = *get_pyramid_mv(tpl_frame, idx, bsize, mi_row, mi_col); 6396 printf("%d %d %d %d\n", mi_row, mi_col, mv.as_mv.row, mv.as_mv.col); 6397 } 6398 } 6399 } 6400 6401 dump_frame_buf(gf_picture[frame_idx].frame); 6402 6403 for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row) { 6404 for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) { 6405 if ((mi_row % mi_height) == 0 && (mi_col % mi_width) == 0) { 6406 const TplDepStats *tpl_ptr = 6407 &tpl_frame->tpl_stats_ptr[mi_row * tpl_frame->stride + mi_col]; 6408 printf("%f ", tpl_ptr->feature_score); 6409 } 6410 } 6411 } 6412 printf("\n"); 6413 6414 rf_idx = gf_picture[frame_idx].ref_frame[idx]; 6415 printf("has_ref %d\n", rf_idx != -1); 6416 if (rf_idx != -1) { 6417 YV12_BUFFER_CONFIG *ref_frame_buf = gf_picture[rf_idx].frame; 6418 dump_frame_buf(ref_frame_buf); 6419 } 6420 } 6421 } 6422 #endif // DUMP_TPL_STATS 6423 #endif // CONFIG_NON_GREEDY_MV 6424 6425 static void init_tpl_buffer(VP9_COMP *cpi) { 6426 VP9_COMMON *cm = &cpi->common; 6427 int frame; 6428 6429 const int mi_cols = mi_cols_aligned_to_sb(cm->mi_cols); 6430 const int mi_rows = mi_cols_aligned_to_sb(cm->mi_rows); 6431 #if CONFIG_NON_GREEDY_MV 6432 int sqr_bsize; 6433 int rf_idx; 6434 6435 // TODO(angiebird): This probably needs further modifications to support 6436 // frame scaling later on. 6437 if (cpi->feature_score_loc_alloc == 0) { 6438 // The smallest block size of motion field is 4x4, but the mi_unit is 8x8, 6439 // therefore the number of units is "mi_rows * mi_cols * 4" here. 6440 CHECK_MEM_ERROR( 6441 cm, cpi->feature_score_loc_arr, 6442 vpx_calloc(mi_rows * mi_cols * 4, sizeof(*cpi->feature_score_loc_arr))); 6443 CHECK_MEM_ERROR(cm, cpi->feature_score_loc_sort, 6444 vpx_calloc(mi_rows * mi_cols * 4, 6445 sizeof(*cpi->feature_score_loc_sort))); 6446 CHECK_MEM_ERROR(cm, cpi->feature_score_loc_heap, 6447 vpx_calloc(mi_rows * mi_cols * 4, 6448 sizeof(*cpi->feature_score_loc_heap))); 6449 6450 cpi->feature_score_loc_alloc = 1; 6451 } 6452 #endif 6453 6454 // TODO(jingning): Reduce the actual memory use for tpl model build up. 6455 for (frame = 0; frame < MAX_ARF_GOP_SIZE; ++frame) { 6456 if (cpi->tpl_stats[frame].width >= mi_cols && 6457 cpi->tpl_stats[frame].height >= mi_rows && 6458 cpi->tpl_stats[frame].tpl_stats_ptr) 6459 continue; 6460 6461 #if CONFIG_NON_GREEDY_MV 6462 vpx_free(cpi->tpl_stats[frame].pyramid_mv_arr); 6463 for (rf_idx = 0; rf_idx < 3; ++rf_idx) { 6464 for (sqr_bsize = 0; sqr_bsize < SQUARE_BLOCK_SIZES; ++sqr_bsize) { 6465 CHECK_MEM_ERROR( 6466 cm, cpi->tpl_stats[frame].pyramid_mv_arr[rf_idx][sqr_bsize], 6467 vpx_calloc( 6468 mi_rows * mi_cols, 6469 sizeof( 6470 *cpi->tpl_stats[frame].pyramid_mv_arr[rf_idx][sqr_bsize]))); 6471 } 6472 } 6473 #endif 6474 vpx_free(cpi->tpl_stats[frame].tpl_stats_ptr); 6475 CHECK_MEM_ERROR(cm, cpi->tpl_stats[frame].tpl_stats_ptr, 6476 vpx_calloc(mi_rows * mi_cols, 6477 sizeof(*cpi->tpl_stats[frame].tpl_stats_ptr))); 6478 cpi->tpl_stats[frame].is_valid = 0; 6479 cpi->tpl_stats[frame].width = mi_cols; 6480 cpi->tpl_stats[frame].height = mi_rows; 6481 cpi->tpl_stats[frame].stride = mi_cols; 6482 cpi->tpl_stats[frame].mi_rows = cm->mi_rows; 6483 cpi->tpl_stats[frame].mi_cols = cm->mi_cols; 6484 } 6485 6486 for (frame = 0; frame < REF_FRAMES; ++frame) { 6487 cpi->enc_frame_buf[frame].mem_valid = 0; 6488 cpi->enc_frame_buf[frame].released = 1; 6489 } 6490 } 6491 6492 static void setup_tpl_stats(VP9_COMP *cpi) { 6493 GF_PICTURE gf_picture[MAX_ARF_GOP_SIZE]; 6494 const GF_GROUP *gf_group = &cpi->twopass.gf_group; 6495 int tpl_group_frames = 0; 6496 int frame_idx; 6497 const BLOCK_SIZE bsize = BLOCK_32X32; 6498 6499 init_gop_frames(cpi, gf_picture, gf_group, &tpl_group_frames); 6500 6501 init_tpl_stats(cpi); 6502 6503 // Backward propagation from tpl_group_frames to 1. 6504 for (frame_idx = tpl_group_frames - 1; frame_idx > 0; --frame_idx) { 6505 if (gf_picture[frame_idx].update_type == USE_BUF_FRAME) continue; 6506 mc_flow_dispenser(cpi, gf_picture, frame_idx, bsize); 6507 } 6508 #if CONFIG_NON_GREEDY_MV 6509 #if DUMP_TPL_STATS 6510 dump_tpl_stats(cpi, tpl_group_frames, gf_picture, bsize); 6511 #endif // DUMP_TPL_STATS 6512 #endif // CONFIG_NON_GREEDY_MV 6513 } 6514 6515 int vp9_get_compressed_data(VP9_COMP *cpi, unsigned int *frame_flags, 6516 size_t *size, uint8_t *dest, int64_t *time_stamp, 6517 int64_t *time_end, int flush) { 6518 const VP9EncoderConfig *const oxcf = &cpi->oxcf; 6519 VP9_COMMON *const cm = &cpi->common; 6520 BufferPool *const pool = cm->buffer_pool; 6521 RATE_CONTROL *const rc = &cpi->rc; 6522 struct vpx_usec_timer cmptimer; 6523 YV12_BUFFER_CONFIG *force_src_buffer = NULL; 6524 struct lookahead_entry *last_source = NULL; 6525 struct lookahead_entry *source = NULL; 6526 int arf_src_index; 6527 const int gf_group_index = cpi->twopass.gf_group.index; 6528 int i; 6529 6530 if (is_one_pass_cbr_svc(cpi)) { 6531 vp9_one_pass_cbr_svc_start_layer(cpi); 6532 } 6533 6534 vpx_usec_timer_start(&cmptimer); 6535 6536 vp9_set_high_precision_mv(cpi, ALTREF_HIGH_PRECISION_MV); 6537 6538 // Is multi-arf enabled. 6539 // Note that at the moment multi_arf is only configured for 2 pass VBR and 6540 // will not work properly with svc. 6541 // Enable the Jingning's new "multi_layer_arf" code if "enable_auto_arf" 6542 // is greater than or equal to 2. 6543 if ((oxcf->pass == 2) && !cpi->use_svc && (cpi->oxcf.enable_auto_arf >= 2)) 6544 cpi->multi_layer_arf = 1; 6545 else 6546 cpi->multi_layer_arf = 0; 6547 6548 // Normal defaults 6549 cm->reset_frame_context = 0; 6550 cm->refresh_frame_context = 1; 6551 if (!is_one_pass_cbr_svc(cpi)) { 6552 cpi->refresh_last_frame = 1; 6553 cpi->refresh_golden_frame = 0; 6554 cpi->refresh_alt_ref_frame = 0; 6555 } 6556 6557 // Should we encode an arf frame. 6558 arf_src_index = get_arf_src_index(cpi); 6559 6560 if (arf_src_index) { 6561 for (i = 0; i <= arf_src_index; ++i) { 6562 struct lookahead_entry *e = vp9_lookahead_peek(cpi->lookahead, i); 6563 // Avoid creating an alt-ref if there's a forced keyframe pending. 6564 if (e == NULL) { 6565 break; 6566 } else if (e->flags == VPX_EFLAG_FORCE_KF) { 6567 arf_src_index = 0; 6568 flush = 1; 6569 break; 6570 } 6571 } 6572 } 6573 6574 // Clear arf index stack before group of pictures processing starts. 6575 if (gf_group_index == 1) { 6576 stack_init(cpi->twopass.gf_group.arf_index_stack, MAX_LAG_BUFFERS * 2); 6577 cpi->twopass.gf_group.stack_size = 0; 6578 } 6579 6580 if (arf_src_index) { 6581 assert(arf_src_index <= rc->frames_to_key); 6582 if ((source = vp9_lookahead_peek(cpi->lookahead, arf_src_index)) != NULL) { 6583 cpi->alt_ref_source = source; 6584 6585 #if !CONFIG_REALTIME_ONLY 6586 if ((oxcf->mode != REALTIME) && (oxcf->arnr_max_frames > 0) && 6587 (oxcf->arnr_strength > 0)) { 6588 int bitrate = cpi->rc.avg_frame_bandwidth / 40; 6589 int not_low_bitrate = bitrate > ALT_REF_AQ_LOW_BITRATE_BOUNDARY; 6590 6591 int not_last_frame = (cpi->lookahead->sz - arf_src_index > 1); 6592 not_last_frame |= ALT_REF_AQ_APPLY_TO_LAST_FRAME; 6593 6594 // Produce the filtered ARF frame. 6595 vp9_temporal_filter(cpi, arf_src_index); 6596 vpx_extend_frame_borders(&cpi->alt_ref_buffer); 6597 6598 // for small bitrates segmentation overhead usually 6599 // eats all bitrate gain from enabling delta quantizers 6600 if (cpi->oxcf.alt_ref_aq != 0 && not_low_bitrate && not_last_frame) 6601 vp9_alt_ref_aq_setup_mode(cpi->alt_ref_aq, cpi); 6602 6603 force_src_buffer = &cpi->alt_ref_buffer; 6604 } 6605 #endif 6606 cm->show_frame = 0; 6607 cm->intra_only = 0; 6608 cpi->refresh_alt_ref_frame = 1; 6609 cpi->refresh_golden_frame = 0; 6610 cpi->refresh_last_frame = 0; 6611 rc->is_src_frame_alt_ref = 0; 6612 rc->source_alt_ref_pending = 0; 6613 } else { 6614 rc->source_alt_ref_pending = 0; 6615 } 6616 } 6617 6618 if (!source) { 6619 // Get last frame source. 6620 if (cm->current_video_frame > 0) { 6621 if ((last_source = vp9_lookahead_peek(cpi->lookahead, -1)) == NULL) 6622 return -1; 6623 } 6624 6625 // Read in the source frame. 6626 if (cpi->use_svc || cpi->svc.set_intra_only_frame) 6627 source = vp9_svc_lookahead_pop(cpi, cpi->lookahead, flush); 6628 else 6629 source = vp9_lookahead_pop(cpi->lookahead, flush); 6630 6631 if (source != NULL) { 6632 cm->show_frame = 1; 6633 cm->intra_only = 0; 6634 // if the flags indicate intra frame, but if the current picture is for 6635 // non-zero spatial layer, it should not be an intra picture. 6636 if ((source->flags & VPX_EFLAG_FORCE_KF) && cpi->use_svc && 6637 cpi->svc.spatial_layer_id > 0) { 6638 source->flags &= ~(unsigned int)(VPX_EFLAG_FORCE_KF); 6639 } 6640 6641 // Check to see if the frame should be encoded as an arf overlay. 6642 check_src_altref(cpi, source); 6643 } 6644 } 6645 6646 if (source) { 6647 cpi->un_scaled_source = cpi->Source = 6648 force_src_buffer ? force_src_buffer : &source->img; 6649 6650 #ifdef ENABLE_KF_DENOISE 6651 // Copy of raw source for metrics calculation. 6652 if (is_psnr_calc_enabled(cpi)) 6653 vp9_copy_and_extend_frame(cpi->Source, &cpi->raw_unscaled_source); 6654 #endif 6655 6656 cpi->unscaled_last_source = last_source != NULL ? &last_source->img : NULL; 6657 6658 *time_stamp = source->ts_start; 6659 *time_end = source->ts_end; 6660 *frame_flags = (source->flags & VPX_EFLAG_FORCE_KF) ? FRAMEFLAGS_KEY : 0; 6661 } else { 6662 *size = 0; 6663 #if !CONFIG_REALTIME_ONLY 6664 if (flush && oxcf->pass == 1 && !cpi->twopass.first_pass_done) { 6665 vp9_end_first_pass(cpi); /* get last stats packet */ 6666 cpi->twopass.first_pass_done = 1; 6667 } 6668 #endif // !CONFIG_REALTIME_ONLY 6669 return -1; 6670 } 6671 6672 if (source->ts_start < cpi->first_time_stamp_ever) { 6673 cpi->first_time_stamp_ever = source->ts_start; 6674 cpi->last_end_time_stamp_seen = source->ts_start; 6675 } 6676 6677 // Clear down mmx registers 6678 vpx_clear_system_state(); 6679 6680 // adjust frame rates based on timestamps given 6681 if (cm->show_frame) { 6682 if (cpi->use_svc && cpi->svc.use_set_ref_frame_config && 6683 cpi->svc.duration[cpi->svc.spatial_layer_id] > 0) 6684 vp9_svc_adjust_frame_rate(cpi); 6685 else 6686 adjust_frame_rate(cpi, source); 6687 } 6688 6689 if (is_one_pass_cbr_svc(cpi)) { 6690 vp9_update_temporal_layer_framerate(cpi); 6691 vp9_restore_layer_context(cpi); 6692 } 6693 6694 // Find a free buffer for the new frame, releasing the reference previously 6695 // held. 6696 if (cm->new_fb_idx != INVALID_IDX) { 6697 --pool->frame_bufs[cm->new_fb_idx].ref_count; 6698 } 6699 cm->new_fb_idx = get_free_fb(cm); 6700 6701 if (cm->new_fb_idx == INVALID_IDX) return -1; 6702 6703 cm->cur_frame = &pool->frame_bufs[cm->new_fb_idx]; 6704 6705 // Start with a 0 size frame. 6706 *size = 0; 6707 6708 cpi->frame_flags = *frame_flags; 6709 6710 #if !CONFIG_REALTIME_ONLY 6711 if ((oxcf->pass == 2) && !cpi->use_svc) { 6712 vp9_rc_get_second_pass_params(cpi); 6713 } else if (oxcf->pass == 1) { 6714 set_frame_size(cpi); 6715 } 6716 #endif // !CONFIG_REALTIME_ONLY 6717 6718 if (oxcf->pass != 1 && cpi->level_constraint.level_index >= 0 && 6719 cpi->level_constraint.fail_flag == 0) 6720 level_rc_framerate(cpi, arf_src_index); 6721 6722 if (cpi->oxcf.pass != 0 || cpi->use_svc || frame_is_intra_only(cm) == 1) { 6723 for (i = 0; i < REFS_PER_FRAME; ++i) cpi->scaled_ref_idx[i] = INVALID_IDX; 6724 } 6725 6726 if (gf_group_index == 1 && 6727 cpi->twopass.gf_group.update_type[gf_group_index] == ARF_UPDATE && 6728 cpi->sf.enable_tpl_model) { 6729 init_tpl_buffer(cpi); 6730 vp9_estimate_qp_gop(cpi); 6731 setup_tpl_stats(cpi); 6732 } 6733 6734 cpi->td.mb.fp_src_pred = 0; 6735 #if CONFIG_REALTIME_ONLY 6736 if (cpi->use_svc) { 6737 SvcEncode(cpi, size, dest, frame_flags); 6738 } else { 6739 // One pass encode 6740 Pass0Encode(cpi, size, dest, frame_flags); 6741 } 6742 #else // !CONFIG_REALTIME_ONLY 6743 if (oxcf->pass == 1 && !cpi->use_svc) { 6744 const int lossless = is_lossless_requested(oxcf); 6745 #if CONFIG_VP9_HIGHBITDEPTH 6746 if (cpi->oxcf.use_highbitdepth) 6747 cpi->td.mb.fwd_txfm4x4 = 6748 lossless ? vp9_highbd_fwht4x4 : vpx_highbd_fdct4x4; 6749 else 6750 cpi->td.mb.fwd_txfm4x4 = lossless ? vp9_fwht4x4 : vpx_fdct4x4; 6751 cpi->td.mb.highbd_inv_txfm_add = 6752 lossless ? vp9_highbd_iwht4x4_add : vp9_highbd_idct4x4_add; 6753 #else 6754 cpi->td.mb.fwd_txfm4x4 = lossless ? vp9_fwht4x4 : vpx_fdct4x4; 6755 #endif // CONFIG_VP9_HIGHBITDEPTH 6756 cpi->td.mb.inv_txfm_add = lossless ? vp9_iwht4x4_add : vp9_idct4x4_add; 6757 vp9_first_pass(cpi, source); 6758 } else if (oxcf->pass == 2 && !cpi->use_svc) { 6759 Pass2Encode(cpi, size, dest, frame_flags); 6760 } else if (cpi->use_svc) { 6761 SvcEncode(cpi, size, dest, frame_flags); 6762 } else { 6763 // One pass encode 6764 Pass0Encode(cpi, size, dest, frame_flags); 6765 } 6766 #endif // CONFIG_REALTIME_ONLY 6767 6768 if (cm->show_frame) cm->cur_show_frame_fb_idx = cm->new_fb_idx; 6769 6770 if (cm->refresh_frame_context) 6771 cm->frame_contexts[cm->frame_context_idx] = *cm->fc; 6772 6773 // No frame encoded, or frame was dropped, release scaled references. 6774 if ((*size == 0) && (frame_is_intra_only(cm) == 0)) { 6775 release_scaled_references(cpi); 6776 } 6777 6778 if (*size > 0) { 6779 cpi->droppable = !frame_is_reference(cpi); 6780 } 6781 6782 // Save layer specific state. 6783 if (is_one_pass_cbr_svc(cpi) || ((cpi->svc.number_temporal_layers > 1 || 6784 cpi->svc.number_spatial_layers > 1) && 6785 oxcf->pass == 2)) { 6786 vp9_save_layer_context(cpi); 6787 } 6788 6789 vpx_usec_timer_mark(&cmptimer); 6790 cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer); 6791 6792 // Should we calculate metrics for the frame. 6793 if (is_psnr_calc_enabled(cpi)) generate_psnr_packet(cpi); 6794 6795 if (cpi->keep_level_stats && oxcf->pass != 1) 6796 update_level_info(cpi, size, arf_src_index); 6797 6798 #if CONFIG_INTERNAL_STATS 6799 6800 if (oxcf->pass != 1) { 6801 double samples = 0.0; 6802 cpi->bytes += (int)(*size); 6803 6804 if (cm->show_frame) { 6805 uint32_t bit_depth = 8; 6806 uint32_t in_bit_depth = 8; 6807 cpi->count++; 6808 #if CONFIG_VP9_HIGHBITDEPTH 6809 if (cm->use_highbitdepth) { 6810 in_bit_depth = cpi->oxcf.input_bit_depth; 6811 bit_depth = cm->bit_depth; 6812 } 6813 #endif 6814 6815 if (cpi->b_calculate_psnr) { 6816 YV12_BUFFER_CONFIG *orig = cpi->raw_source_frame; 6817 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show; 6818 YV12_BUFFER_CONFIG *pp = &cm->post_proc_buffer; 6819 PSNR_STATS psnr; 6820 #if CONFIG_VP9_HIGHBITDEPTH 6821 vpx_calc_highbd_psnr(orig, recon, &psnr, cpi->td.mb.e_mbd.bd, 6822 in_bit_depth); 6823 #else 6824 vpx_calc_psnr(orig, recon, &psnr); 6825 #endif // CONFIG_VP9_HIGHBITDEPTH 6826 6827 adjust_image_stat(psnr.psnr[1], psnr.psnr[2], psnr.psnr[3], 6828 psnr.psnr[0], &cpi->psnr); 6829 cpi->total_sq_error += psnr.sse[0]; 6830 cpi->total_samples += psnr.samples[0]; 6831 samples = psnr.samples[0]; 6832 6833 { 6834 PSNR_STATS psnr2; 6835 double frame_ssim2 = 0, weight = 0; 6836 #if CONFIG_VP9_POSTPROC 6837 if (vpx_alloc_frame_buffer( 6838 pp, recon->y_crop_width, recon->y_crop_height, 6839 cm->subsampling_x, cm->subsampling_y, 6840 #if CONFIG_VP9_HIGHBITDEPTH 6841 cm->use_highbitdepth, 6842 #endif 6843 VP9_ENC_BORDER_IN_PIXELS, cm->byte_alignment) < 0) { 6844 vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR, 6845 "Failed to allocate post processing buffer"); 6846 } 6847 { 6848 vp9_ppflags_t ppflags; 6849 ppflags.post_proc_flag = VP9D_DEBLOCK; 6850 ppflags.deblocking_level = 0; // not used in vp9_post_proc_frame() 6851 ppflags.noise_level = 0; // not used in vp9_post_proc_frame() 6852 vp9_post_proc_frame(cm, pp, &ppflags, 6853 cpi->un_scaled_source->y_width); 6854 } 6855 #endif 6856 vpx_clear_system_state(); 6857 6858 #if CONFIG_VP9_HIGHBITDEPTH 6859 vpx_calc_highbd_psnr(orig, pp, &psnr2, cpi->td.mb.e_mbd.bd, 6860 cpi->oxcf.input_bit_depth); 6861 #else 6862 vpx_calc_psnr(orig, pp, &psnr2); 6863 #endif // CONFIG_VP9_HIGHBITDEPTH 6864 6865 cpi->totalp_sq_error += psnr2.sse[0]; 6866 cpi->totalp_samples += psnr2.samples[0]; 6867 adjust_image_stat(psnr2.psnr[1], psnr2.psnr[2], psnr2.psnr[3], 6868 psnr2.psnr[0], &cpi->psnrp); 6869 6870 #if CONFIG_VP9_HIGHBITDEPTH 6871 if (cm->use_highbitdepth) { 6872 frame_ssim2 = vpx_highbd_calc_ssim(orig, recon, &weight, bit_depth, 6873 in_bit_depth); 6874 } else { 6875 frame_ssim2 = vpx_calc_ssim(orig, recon, &weight); 6876 } 6877 #else 6878 frame_ssim2 = vpx_calc_ssim(orig, recon, &weight); 6879 #endif // CONFIG_VP9_HIGHBITDEPTH 6880 6881 cpi->worst_ssim = VPXMIN(cpi->worst_ssim, frame_ssim2); 6882 cpi->summed_quality += frame_ssim2 * weight; 6883 cpi->summed_weights += weight; 6884 6885 #if CONFIG_VP9_HIGHBITDEPTH 6886 if (cm->use_highbitdepth) { 6887 frame_ssim2 = vpx_highbd_calc_ssim(orig, pp, &weight, bit_depth, 6888 in_bit_depth); 6889 } else { 6890 frame_ssim2 = vpx_calc_ssim(orig, pp, &weight); 6891 } 6892 #else 6893 frame_ssim2 = vpx_calc_ssim(orig, pp, &weight); 6894 #endif // CONFIG_VP9_HIGHBITDEPTH 6895 6896 cpi->summedp_quality += frame_ssim2 * weight; 6897 cpi->summedp_weights += weight; 6898 #if 0 6899 if (cm->show_frame) { 6900 FILE *f = fopen("q_used.stt", "a"); 6901 fprintf(f, "%5d : Y%f7.3:U%f7.3:V%f7.3:F%f7.3:S%7.3f\n", 6902 cpi->common.current_video_frame, psnr2.psnr[1], 6903 psnr2.psnr[2], psnr2.psnr[3], psnr2.psnr[0], frame_ssim2); 6904 fclose(f); 6905 } 6906 #endif 6907 } 6908 } 6909 if (cpi->b_calculate_blockiness) { 6910 #if CONFIG_VP9_HIGHBITDEPTH 6911 if (!cm->use_highbitdepth) 6912 #endif 6913 { 6914 double frame_blockiness = vp9_get_blockiness( 6915 cpi->Source->y_buffer, cpi->Source->y_stride, 6916 cm->frame_to_show->y_buffer, cm->frame_to_show->y_stride, 6917 cpi->Source->y_width, cpi->Source->y_height); 6918 cpi->worst_blockiness = 6919 VPXMAX(cpi->worst_blockiness, frame_blockiness); 6920 cpi->total_blockiness += frame_blockiness; 6921 } 6922 } 6923 6924 if (cpi->b_calculate_consistency) { 6925 #if CONFIG_VP9_HIGHBITDEPTH 6926 if (!cm->use_highbitdepth) 6927 #endif 6928 { 6929 double this_inconsistency = vpx_get_ssim_metrics( 6930 cpi->Source->y_buffer, cpi->Source->y_stride, 6931 cm->frame_to_show->y_buffer, cm->frame_to_show->y_stride, 6932 cpi->Source->y_width, cpi->Source->y_height, cpi->ssim_vars, 6933 &cpi->metrics, 1); 6934 6935 const double peak = (double)((1 << cpi->oxcf.input_bit_depth) - 1); 6936 double consistency = 6937 vpx_sse_to_psnr(samples, peak, (double)cpi->total_inconsistency); 6938 if (consistency > 0.0) 6939 cpi->worst_consistency = 6940 VPXMIN(cpi->worst_consistency, consistency); 6941 cpi->total_inconsistency += this_inconsistency; 6942 } 6943 } 6944 6945 { 6946 double y, u, v, frame_all; 6947 frame_all = vpx_calc_fastssim(cpi->Source, cm->frame_to_show, &y, &u, 6948 &v, bit_depth, in_bit_depth); 6949 adjust_image_stat(y, u, v, frame_all, &cpi->fastssim); 6950 } 6951 { 6952 double y, u, v, frame_all; 6953 frame_all = vpx_psnrhvs(cpi->Source, cm->frame_to_show, &y, &u, &v, 6954 bit_depth, in_bit_depth); 6955 adjust_image_stat(y, u, v, frame_all, &cpi->psnrhvs); 6956 } 6957 } 6958 } 6959 6960 #endif 6961 6962 if (is_one_pass_cbr_svc(cpi)) { 6963 if (cm->show_frame) { 6964 ++cpi->svc.spatial_layer_to_encode; 6965 if (cpi->svc.spatial_layer_to_encode >= cpi->svc.number_spatial_layers) 6966 cpi->svc.spatial_layer_to_encode = 0; 6967 } 6968 } 6969 6970 vpx_clear_system_state(); 6971 return 0; 6972 } 6973 6974 int vp9_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest, 6975 vp9_ppflags_t *flags) { 6976 VP9_COMMON *cm = &cpi->common; 6977 #if !CONFIG_VP9_POSTPROC 6978 (void)flags; 6979 #endif 6980 6981 if (!cm->show_frame) { 6982 return -1; 6983 } else { 6984 int ret; 6985 #if CONFIG_VP9_POSTPROC 6986 ret = vp9_post_proc_frame(cm, dest, flags, cpi->un_scaled_source->y_width); 6987 #else 6988 if (cm->frame_to_show) { 6989 *dest = *cm->frame_to_show; 6990 dest->y_width = cm->width; 6991 dest->y_height = cm->height; 6992 dest->uv_width = cm->width >> cm->subsampling_x; 6993 dest->uv_height = cm->height >> cm->subsampling_y; 6994 ret = 0; 6995 } else { 6996 ret = -1; 6997 } 6998 #endif // !CONFIG_VP9_POSTPROC 6999 vpx_clear_system_state(); 7000 return ret; 7001 } 7002 } 7003 7004 int vp9_set_internal_size(VP9_COMP *cpi, VPX_SCALING horiz_mode, 7005 VPX_SCALING vert_mode) { 7006 VP9_COMMON *cm = &cpi->common; 7007 int hr = 0, hs = 0, vr = 0, vs = 0; 7008 7009 if (horiz_mode > ONETWO || vert_mode > ONETWO) return -1; 7010 7011 Scale2Ratio(horiz_mode, &hr, &hs); 7012 Scale2Ratio(vert_mode, &vr, &vs); 7013 7014 // always go to the next whole number 7015 cm->width = (hs - 1 + cpi->oxcf.width * hr) / hs; 7016 cm->height = (vs - 1 + cpi->oxcf.height * vr) / vs; 7017 if (cm->current_video_frame) { 7018 assert(cm->width <= cpi->initial_width); 7019 assert(cm->height <= cpi->initial_height); 7020 } 7021 7022 update_frame_size(cpi); 7023 7024 return 0; 7025 } 7026 7027 int vp9_set_size_literal(VP9_COMP *cpi, unsigned int width, 7028 unsigned int height) { 7029 VP9_COMMON *cm = &cpi->common; 7030 #if CONFIG_VP9_HIGHBITDEPTH 7031 check_initial_width(cpi, cm->use_highbitdepth, 1, 1); 7032 #else 7033 check_initial_width(cpi, 1, 1); 7034 #endif // CONFIG_VP9_HIGHBITDEPTH 7035 7036 #if CONFIG_VP9_TEMPORAL_DENOISING 7037 setup_denoiser_buffer(cpi); 7038 #endif 7039 7040 if (width) { 7041 cm->width = width; 7042 if (cm->width > cpi->initial_width) { 7043 cm->width = cpi->initial_width; 7044 printf("Warning: Desired width too large, changed to %d\n", cm->width); 7045 } 7046 } 7047 7048 if (height) { 7049 cm->height = height; 7050 if (cm->height > cpi->initial_height) { 7051 cm->height = cpi->initial_height; 7052 printf("Warning: Desired height too large, changed to %d\n", cm->height); 7053 } 7054 } 7055 assert(cm->width <= cpi->initial_width); 7056 assert(cm->height <= cpi->initial_height); 7057 7058 update_frame_size(cpi); 7059 7060 return 0; 7061 } 7062 7063 void vp9_set_svc(VP9_COMP *cpi, int use_svc) { 7064 cpi->use_svc = use_svc; 7065 return; 7066 } 7067 7068 int vp9_get_quantizer(VP9_COMP *cpi) { return cpi->common.base_qindex; } 7069 7070 void vp9_apply_encoding_flags(VP9_COMP *cpi, vpx_enc_frame_flags_t flags) { 7071 if (flags & 7072 (VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF)) { 7073 int ref = 7; 7074 7075 if (flags & VP8_EFLAG_NO_REF_LAST) ref ^= VP9_LAST_FLAG; 7076 7077 if (flags & VP8_EFLAG_NO_REF_GF) ref ^= VP9_GOLD_FLAG; 7078 7079 if (flags & VP8_EFLAG_NO_REF_ARF) ref ^= VP9_ALT_FLAG; 7080 7081 vp9_use_as_reference(cpi, ref); 7082 } 7083 7084 if (flags & 7085 (VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | 7086 VP8_EFLAG_FORCE_GF | VP8_EFLAG_FORCE_ARF)) { 7087 int upd = 7; 7088 7089 if (flags & VP8_EFLAG_NO_UPD_LAST) upd ^= VP9_LAST_FLAG; 7090 7091 if (flags & VP8_EFLAG_NO_UPD_GF) upd ^= VP9_GOLD_FLAG; 7092 7093 if (flags & VP8_EFLAG_NO_UPD_ARF) upd ^= VP9_ALT_FLAG; 7094 7095 vp9_update_reference(cpi, upd); 7096 } 7097 7098 if (flags & VP8_EFLAG_NO_UPD_ENTROPY) { 7099 vp9_update_entropy(cpi, 0); 7100 } 7101 } 7102 7103 void vp9_set_row_mt(VP9_COMP *cpi) { 7104 // Enable row based multi-threading for supported modes of encoding 7105 cpi->row_mt = 0; 7106 if (((cpi->oxcf.mode == GOOD || cpi->oxcf.mode == BEST) && 7107 cpi->oxcf.speed < 5 && cpi->oxcf.pass == 1) && 7108 cpi->oxcf.row_mt && !cpi->use_svc) 7109 cpi->row_mt = 1; 7110 7111 if (cpi->oxcf.mode == GOOD && cpi->oxcf.speed < 5 && 7112 (cpi->oxcf.pass == 0 || cpi->oxcf.pass == 2) && cpi->oxcf.row_mt && 7113 !cpi->use_svc) 7114 cpi->row_mt = 1; 7115 7116 // In realtime mode, enable row based multi-threading for all the speed levels 7117 // where non-rd path is used. 7118 if (cpi->oxcf.mode == REALTIME && cpi->oxcf.speed >= 5 && cpi->oxcf.row_mt) { 7119 cpi->row_mt = 1; 7120 } 7121 7122 if (cpi->row_mt) 7123 cpi->row_mt_bit_exact = 1; 7124 else 7125 cpi->row_mt_bit_exact = 0; 7126 } 7127
