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