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 <limits.h>
12 #include <math.h>
13 #include <stdio.h>
14
15 #include "./vpx_scale_rtcd.h"
16
17 #include "vpx_mem/vpx_mem.h"
18 #include "vpx_scale/vpx_scale.h"
19 #include "vpx_scale/yv12config.h"
20
21 #include "vp9/common/vp9_entropymv.h"
22 #include "vp9/common/vp9_quant_common.h"
23 #include "vp9/common/vp9_reconinter.h" // vp9_setup_dst_planes()
24 #include "vp9/common/vp9_systemdependent.h"
25
26 #include "vp9/encoder/vp9_aq_variance.h"
27 #include "vp9/encoder/vp9_block.h"
28 #include "vp9/encoder/vp9_encodeframe.h"
29 #include "vp9/encoder/vp9_encodemb.h"
30 #include "vp9/encoder/vp9_encodemv.h"
31 #include "vp9/encoder/vp9_extend.h"
32 #include "vp9/encoder/vp9_firstpass.h"
33 #include "vp9/encoder/vp9_mcomp.h"
34 #include "vp9/encoder/vp9_onyx_int.h"
35 #include "vp9/encoder/vp9_quantize.h"
36 #include "vp9/encoder/vp9_ratectrl.h"
37 #include "vp9/encoder/vp9_rdopt.h"
38 #include "vp9/encoder/vp9_variance.h"
39
40 #define OUTPUT_FPF 0
41
42 #define IIFACTOR 12.5
43 #define IIKFACTOR1 12.5
44 #define IIKFACTOR2 15.0
45 #define RMAX 512.0
46 #define GF_RMAX 96.0
47 #define ERR_DIVISOR 150.0
48 #define MIN_DECAY_FACTOR 0.1
49
50 #define KF_MB_INTRA_MIN 150
51 #define GF_MB_INTRA_MIN 100
52
53 #define DOUBLE_DIVIDE_CHECK(x) ((x) < 0 ? (x) - 0.000001 : (x) + 0.000001)
54
55 #define MIN_KF_BOOST 300
56
57 #if CONFIG_MULTIPLE_ARF
58 // Set MIN_GF_INTERVAL to 1 for the full decomposition.
59 #define MIN_GF_INTERVAL 2
60 #else
61 #define MIN_GF_INTERVAL 4
62 #endif
63
swap_yv12(YV12_BUFFER_CONFIG * a,YV12_BUFFER_CONFIG * b)64 static void swap_yv12(YV12_BUFFER_CONFIG *a, YV12_BUFFER_CONFIG *b) {
65 YV12_BUFFER_CONFIG temp = *a;
66 *a = *b;
67 *b = temp;
68 }
69
gfboost_qadjust(int qindex)70 static int gfboost_qadjust(int qindex) {
71 const double q = vp9_convert_qindex_to_q(qindex);
72 return (int)((0.00000828 * q * q * q) +
73 (-0.0055 * q * q) +
74 (1.32 * q) + 79.3);
75 }
76
77 // Resets the first pass file to the given position using a relative seek from
78 // the current position.
reset_fpf_position(struct twopass_rc * p,const FIRSTPASS_STATS * position)79 static void reset_fpf_position(struct twopass_rc *p,
80 const FIRSTPASS_STATS *position) {
81 p->stats_in = position;
82 }
83
lookup_next_frame_stats(const struct twopass_rc * p,FIRSTPASS_STATS * next_frame)84 static int lookup_next_frame_stats(const struct twopass_rc *p,
85 FIRSTPASS_STATS *next_frame) {
86 if (p->stats_in >= p->stats_in_end)
87 return EOF;
88
89 *next_frame = *p->stats_in;
90 return 1;
91 }
92
93
94 // Read frame stats at an offset from the current position.
read_frame_stats(const struct twopass_rc * p,FIRSTPASS_STATS * frame_stats,int offset)95 static int read_frame_stats(const struct twopass_rc *p,
96 FIRSTPASS_STATS *frame_stats, int offset) {
97 const FIRSTPASS_STATS *fps_ptr = p->stats_in;
98
99 // Check legality of offset.
100 if (offset >= 0) {
101 if (&fps_ptr[offset] >= p->stats_in_end)
102 return EOF;
103 } else if (offset < 0) {
104 if (&fps_ptr[offset] < p->stats_in_start)
105 return EOF;
106 }
107
108 *frame_stats = fps_ptr[offset];
109 return 1;
110 }
111
input_stats(struct twopass_rc * p,FIRSTPASS_STATS * fps)112 static int input_stats(struct twopass_rc *p, FIRSTPASS_STATS *fps) {
113 if (p->stats_in >= p->stats_in_end)
114 return EOF;
115
116 *fps = *p->stats_in;
117 ++p->stats_in;
118 return 1;
119 }
120
output_stats(FIRSTPASS_STATS * stats,struct vpx_codec_pkt_list * pktlist)121 static void output_stats(FIRSTPASS_STATS *stats,
122 struct vpx_codec_pkt_list *pktlist) {
123 struct vpx_codec_cx_pkt pkt;
124 pkt.kind = VPX_CODEC_STATS_PKT;
125 pkt.data.twopass_stats.buf = stats;
126 pkt.data.twopass_stats.sz = sizeof(FIRSTPASS_STATS);
127 vpx_codec_pkt_list_add(pktlist, &pkt);
128
129 // TEMP debug code
130 #if OUTPUT_FPF
131 {
132 FILE *fpfile;
133 fpfile = fopen("firstpass.stt", "a");
134
135 fprintf(fpfile, "%12.0f %12.0f %12.0f %12.0f %12.0f %12.4f %12.4f"
136 "%12.4f %12.4f %12.4f %12.4f %12.4f %12.4f %12.4f"
137 "%12.0f %12.0f %12.4f %12.0f %12.0f %12.4f\n",
138 stats->frame,
139 stats->intra_error,
140 stats->coded_error,
141 stats->sr_coded_error,
142 stats->ssim_weighted_pred_err,
143 stats->pcnt_inter,
144 stats->pcnt_motion,
145 stats->pcnt_second_ref,
146 stats->pcnt_neutral,
147 stats->MVr,
148 stats->mvr_abs,
149 stats->MVc,
150 stats->mvc_abs,
151 stats->MVrv,
152 stats->MVcv,
153 stats->mv_in_out_count,
154 stats->new_mv_count,
155 stats->count,
156 stats->duration);
157 fclose(fpfile);
158 }
159 #endif
160 }
161
zero_stats(FIRSTPASS_STATS * section)162 static void zero_stats(FIRSTPASS_STATS *section) {
163 section->frame = 0.0;
164 section->intra_error = 0.0;
165 section->coded_error = 0.0;
166 section->sr_coded_error = 0.0;
167 section->ssim_weighted_pred_err = 0.0;
168 section->pcnt_inter = 0.0;
169 section->pcnt_motion = 0.0;
170 section->pcnt_second_ref = 0.0;
171 section->pcnt_neutral = 0.0;
172 section->MVr = 0.0;
173 section->mvr_abs = 0.0;
174 section->MVc = 0.0;
175 section->mvc_abs = 0.0;
176 section->MVrv = 0.0;
177 section->MVcv = 0.0;
178 section->mv_in_out_count = 0.0;
179 section->new_mv_count = 0.0;
180 section->count = 0.0;
181 section->duration = 1.0;
182 section->spatial_layer_id = 0;
183 }
184
accumulate_stats(FIRSTPASS_STATS * section,const FIRSTPASS_STATS * frame)185 static void accumulate_stats(FIRSTPASS_STATS *section,
186 const FIRSTPASS_STATS *frame) {
187 section->frame += frame->frame;
188 section->spatial_layer_id = frame->spatial_layer_id;
189 section->intra_error += frame->intra_error;
190 section->coded_error += frame->coded_error;
191 section->sr_coded_error += frame->sr_coded_error;
192 section->ssim_weighted_pred_err += frame->ssim_weighted_pred_err;
193 section->pcnt_inter += frame->pcnt_inter;
194 section->pcnt_motion += frame->pcnt_motion;
195 section->pcnt_second_ref += frame->pcnt_second_ref;
196 section->pcnt_neutral += frame->pcnt_neutral;
197 section->MVr += frame->MVr;
198 section->mvr_abs += frame->mvr_abs;
199 section->MVc += frame->MVc;
200 section->mvc_abs += frame->mvc_abs;
201 section->MVrv += frame->MVrv;
202 section->MVcv += frame->MVcv;
203 section->mv_in_out_count += frame->mv_in_out_count;
204 section->new_mv_count += frame->new_mv_count;
205 section->count += frame->count;
206 section->duration += frame->duration;
207 }
208
subtract_stats(FIRSTPASS_STATS * section,const FIRSTPASS_STATS * frame)209 static void subtract_stats(FIRSTPASS_STATS *section,
210 const FIRSTPASS_STATS *frame) {
211 section->frame -= frame->frame;
212 section->intra_error -= frame->intra_error;
213 section->coded_error -= frame->coded_error;
214 section->sr_coded_error -= frame->sr_coded_error;
215 section->ssim_weighted_pred_err -= frame->ssim_weighted_pred_err;
216 section->pcnt_inter -= frame->pcnt_inter;
217 section->pcnt_motion -= frame->pcnt_motion;
218 section->pcnt_second_ref -= frame->pcnt_second_ref;
219 section->pcnt_neutral -= frame->pcnt_neutral;
220 section->MVr -= frame->MVr;
221 section->mvr_abs -= frame->mvr_abs;
222 section->MVc -= frame->MVc;
223 section->mvc_abs -= frame->mvc_abs;
224 section->MVrv -= frame->MVrv;
225 section->MVcv -= frame->MVcv;
226 section->mv_in_out_count -= frame->mv_in_out_count;
227 section->new_mv_count -= frame->new_mv_count;
228 section->count -= frame->count;
229 section->duration -= frame->duration;
230 }
231
avg_stats(FIRSTPASS_STATS * section)232 static void avg_stats(FIRSTPASS_STATS *section) {
233 if (section->count < 1.0)
234 return;
235
236 section->intra_error /= section->count;
237 section->coded_error /= section->count;
238 section->sr_coded_error /= section->count;
239 section->ssim_weighted_pred_err /= section->count;
240 section->pcnt_inter /= section->count;
241 section->pcnt_second_ref /= section->count;
242 section->pcnt_neutral /= section->count;
243 section->pcnt_motion /= section->count;
244 section->MVr /= section->count;
245 section->mvr_abs /= section->count;
246 section->MVc /= section->count;
247 section->mvc_abs /= section->count;
248 section->MVrv /= section->count;
249 section->MVcv /= section->count;
250 section->mv_in_out_count /= section->count;
251 section->duration /= section->count;
252 }
253
254 // Calculate a modified Error used in distributing bits between easier and
255 // harder frames.
calculate_modified_err(const VP9_COMP * cpi,const FIRSTPASS_STATS * this_frame)256 static double calculate_modified_err(const VP9_COMP *cpi,
257 const FIRSTPASS_STATS *this_frame) {
258 const struct twopass_rc *twopass = &cpi->twopass;
259 const FIRSTPASS_STATS *stats;
260 double av_err;
261 double modified_error;
262
263 if (cpi->svc.number_spatial_layers > 1 &&
264 cpi->svc.number_temporal_layers == 1) {
265 twopass = &cpi->svc.layer_context[cpi->svc.spatial_layer_id].twopass;
266 }
267
268 stats = &twopass->total_stats;
269 av_err = stats->ssim_weighted_pred_err / stats->count;
270 modified_error = av_err * pow(this_frame->ssim_weighted_pred_err /
271 DOUBLE_DIVIDE_CHECK(av_err),
272 cpi->oxcf.two_pass_vbrbias / 100.0);
273
274 return fclamp(modified_error,
275 twopass->modified_error_min, twopass->modified_error_max);
276 }
277
278 static const double weight_table[256] = {
279 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
280 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
281 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
282 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
283 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.031250, 0.062500,
284 0.093750, 0.125000, 0.156250, 0.187500, 0.218750, 0.250000, 0.281250,
285 0.312500, 0.343750, 0.375000, 0.406250, 0.437500, 0.468750, 0.500000,
286 0.531250, 0.562500, 0.593750, 0.625000, 0.656250, 0.687500, 0.718750,
287 0.750000, 0.781250, 0.812500, 0.843750, 0.875000, 0.906250, 0.937500,
288 0.968750, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
289 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
290 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
291 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
292 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
293 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
294 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
295 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
296 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
297 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
298 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
299 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
300 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
301 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
302 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
303 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
304 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
305 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
306 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
307 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
308 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
309 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
310 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
311 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
312 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
313 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
314 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
315 1.000000, 1.000000, 1.000000, 1.000000
316 };
317
simple_weight(const YV12_BUFFER_CONFIG * buf)318 static double simple_weight(const YV12_BUFFER_CONFIG *buf) {
319 int i, j;
320 double sum = 0.0;
321 const int w = buf->y_crop_width;
322 const int h = buf->y_crop_height;
323 const uint8_t *row = buf->y_buffer;
324
325 for (i = 0; i < h; ++i) {
326 const uint8_t *pixel = row;
327 for (j = 0; j < w; ++j)
328 sum += weight_table[*pixel++];
329 row += buf->y_stride;
330 }
331
332 return MAX(0.1, sum / (w * h));
333 }
334
335 // This function returns the maximum target rate per frame.
frame_max_bits(const VP9_COMP * cpi)336 static int frame_max_bits(const VP9_COMP *cpi) {
337 int64_t max_bits =
338 ((int64_t)cpi->rc.av_per_frame_bandwidth *
339 (int64_t)cpi->oxcf.two_pass_vbrmax_section) / 100;
340
341 if (max_bits < 0)
342 max_bits = 0;
343 else if (max_bits > cpi->rc.max_frame_bandwidth)
344 max_bits = cpi->rc.max_frame_bandwidth;
345
346 return (int)max_bits;
347 }
348
vp9_init_first_pass(VP9_COMP * cpi)349 void vp9_init_first_pass(VP9_COMP *cpi) {
350 zero_stats(&cpi->twopass.total_stats);
351 }
352
vp9_end_first_pass(VP9_COMP * cpi)353 void vp9_end_first_pass(VP9_COMP *cpi) {
354 if (cpi->use_svc && cpi->svc.number_temporal_layers == 1) {
355 int i;
356 for (i = 0; i < cpi->svc.number_spatial_layers; ++i) {
357 output_stats(&cpi->svc.layer_context[i].twopass.total_stats,
358 cpi->output_pkt_list);
359 }
360 } else {
361 output_stats(&cpi->twopass.total_stats, cpi->output_pkt_list);
362 }
363 }
364
get_block_variance_fn(BLOCK_SIZE bsize)365 static vp9_variance_fn_t get_block_variance_fn(BLOCK_SIZE bsize) {
366 switch (bsize) {
367 case BLOCK_8X8:
368 return vp9_mse8x8;
369 case BLOCK_16X8:
370 return vp9_mse16x8;
371 case BLOCK_8X16:
372 return vp9_mse8x16;
373 default:
374 return vp9_mse16x16;
375 }
376 }
377
zz_motion_search(const MACROBLOCK * x)378 static unsigned int zz_motion_search(const MACROBLOCK *x) {
379 const MACROBLOCKD *const xd = &x->e_mbd;
380 const uint8_t *const src = x->plane[0].src.buf;
381 const int src_stride = x->plane[0].src.stride;
382 const uint8_t *const ref = xd->plane[0].pre[0].buf;
383 const int ref_stride = xd->plane[0].pre[0].stride;
384 unsigned int sse;
385 vp9_variance_fn_t fn = get_block_variance_fn(xd->mi[0]->mbmi.sb_type);
386 fn(src, src_stride, ref, ref_stride, &sse);
387 return sse;
388 }
389
first_pass_motion_search(VP9_COMP * cpi,MACROBLOCK * x,const MV * ref_mv,MV * best_mv,int * best_motion_err)390 static void first_pass_motion_search(VP9_COMP *cpi, MACROBLOCK *x,
391 const MV *ref_mv, MV *best_mv,
392 int *best_motion_err) {
393 MACROBLOCKD *const xd = &x->e_mbd;
394 MV tmp_mv = {0, 0};
395 MV ref_mv_full = {ref_mv->row >> 3, ref_mv->col >> 3};
396 int num00, tmp_err, n, sr = 0;
397 int step_param = 3;
398 int further_steps = (MAX_MVSEARCH_STEPS - 1) - step_param;
399 const BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type;
400 vp9_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[bsize];
401 int new_mv_mode_penalty = 256;
402 const int quart_frm = MIN(cpi->common.width, cpi->common.height);
403
404 // Refine the motion search range according to the frame dimension
405 // for first pass test.
406 while ((quart_frm << sr) < MAX_FULL_PEL_VAL)
407 ++sr;
408
409 step_param += sr;
410 further_steps -= sr;
411
412 // Override the default variance function to use MSE.
413 v_fn_ptr.vf = get_block_variance_fn(bsize);
414
415 // Center the initial step/diamond search on best mv.
416 tmp_err = cpi->diamond_search_sad(x, &ref_mv_full, &tmp_mv,
417 step_param,
418 x->sadperbit16, &num00, &v_fn_ptr,
419 x->nmvjointcost,
420 x->mvcost, ref_mv);
421 if (tmp_err < INT_MAX)
422 tmp_err = vp9_get_mvpred_var(x, &tmp_mv, ref_mv, &v_fn_ptr, 1);
423 if (tmp_err < INT_MAX - new_mv_mode_penalty)
424 tmp_err += new_mv_mode_penalty;
425
426 if (tmp_err < *best_motion_err) {
427 *best_motion_err = tmp_err;
428 best_mv->row = tmp_mv.row;
429 best_mv->col = tmp_mv.col;
430 }
431
432 // Carry out further step/diamond searches as necessary.
433 n = num00;
434 num00 = 0;
435
436 while (n < further_steps) {
437 ++n;
438
439 if (num00) {
440 --num00;
441 } else {
442 tmp_err = cpi->diamond_search_sad(x, &ref_mv_full, &tmp_mv,
443 step_param + n, x->sadperbit16,
444 &num00, &v_fn_ptr,
445 x->nmvjointcost,
446 x->mvcost, ref_mv);
447 if (tmp_err < INT_MAX)
448 tmp_err = vp9_get_mvpred_var(x, &tmp_mv, ref_mv, &v_fn_ptr, 1);
449 if (tmp_err < INT_MAX - new_mv_mode_penalty)
450 tmp_err += new_mv_mode_penalty;
451
452 if (tmp_err < *best_motion_err) {
453 *best_motion_err = tmp_err;
454 best_mv->row = tmp_mv.row;
455 best_mv->col = tmp_mv.col;
456 }
457 }
458 }
459 }
460
get_bsize(const VP9_COMMON * cm,int mb_row,int mb_col)461 static BLOCK_SIZE get_bsize(const VP9_COMMON *cm, int mb_row, int mb_col) {
462 if (2 * mb_col + 1 < cm->mi_cols) {
463 return 2 * mb_row + 1 < cm->mi_rows ? BLOCK_16X16
464 : BLOCK_16X8;
465 } else {
466 return 2 * mb_row + 1 < cm->mi_rows ? BLOCK_8X16
467 : BLOCK_8X8;
468 }
469 }
470
vp9_first_pass(VP9_COMP * cpi)471 void vp9_first_pass(VP9_COMP *cpi) {
472 int mb_row, mb_col;
473 MACROBLOCK *const x = &cpi->mb;
474 VP9_COMMON *const cm = &cpi->common;
475 MACROBLOCKD *const xd = &x->e_mbd;
476 TileInfo tile;
477 struct macroblock_plane *const p = x->plane;
478 struct macroblockd_plane *const pd = xd->plane;
479 const PICK_MODE_CONTEXT *ctx = &x->sb64_context;
480 int i;
481
482 int recon_yoffset, recon_uvoffset;
483 YV12_BUFFER_CONFIG *const lst_yv12 = get_ref_frame_buffer(cpi, LAST_FRAME);
484 YV12_BUFFER_CONFIG *gld_yv12 = get_ref_frame_buffer(cpi, GOLDEN_FRAME);
485 YV12_BUFFER_CONFIG *const new_yv12 = get_frame_new_buffer(cm);
486 int recon_y_stride = lst_yv12->y_stride;
487 int recon_uv_stride = lst_yv12->uv_stride;
488 int uv_mb_height = 16 >> (lst_yv12->y_height > lst_yv12->uv_height);
489 int64_t intra_error = 0;
490 int64_t coded_error = 0;
491 int64_t sr_coded_error = 0;
492
493 int sum_mvr = 0, sum_mvc = 0;
494 int sum_mvr_abs = 0, sum_mvc_abs = 0;
495 int64_t sum_mvrs = 0, sum_mvcs = 0;
496 int mvcount = 0;
497 int intercount = 0;
498 int second_ref_count = 0;
499 int intrapenalty = 256;
500 int neutral_count = 0;
501 int new_mv_count = 0;
502 int sum_in_vectors = 0;
503 uint32_t lastmv_as_int = 0;
504 struct twopass_rc *twopass = &cpi->twopass;
505 const MV zero_mv = {0, 0};
506 const YV12_BUFFER_CONFIG *first_ref_buf = lst_yv12;
507
508 vp9_clear_system_state();
509
510 if (cpi->use_svc && cpi->svc.number_temporal_layers == 1) {
511 MV_REFERENCE_FRAME ref_frame = LAST_FRAME;
512 const YV12_BUFFER_CONFIG *scaled_ref_buf = NULL;
513 twopass = &cpi->svc.layer_context[cpi->svc.spatial_layer_id].twopass;
514
515 vp9_scale_references(cpi);
516
517 // Use either last frame or alt frame for motion search.
518 if (cpi->ref_frame_flags & VP9_LAST_FLAG) {
519 scaled_ref_buf = vp9_get_scaled_ref_frame(cpi, LAST_FRAME);
520 ref_frame = LAST_FRAME;
521 } else if (cpi->ref_frame_flags & VP9_ALT_FLAG) {
522 scaled_ref_buf = vp9_get_scaled_ref_frame(cpi, ALTREF_FRAME);
523 ref_frame = ALTREF_FRAME;
524 }
525
526 if (scaled_ref_buf != NULL) {
527 // Update the stride since we are using scaled reference buffer
528 first_ref_buf = scaled_ref_buf;
529 recon_y_stride = first_ref_buf->y_stride;
530 recon_uv_stride = first_ref_buf->uv_stride;
531 uv_mb_height = 16 >> (first_ref_buf->y_height > first_ref_buf->uv_height);
532 }
533
534 // Disable golden frame for svc first pass for now.
535 gld_yv12 = NULL;
536 set_ref_ptrs(cm, xd, ref_frame, NONE);
537 }
538
539 vp9_setup_src_planes(x, cpi->Source, 0, 0);
540 vp9_setup_pre_planes(xd, 0, first_ref_buf, 0, 0, NULL);
541 vp9_setup_dst_planes(xd, new_yv12, 0, 0);
542
543 xd->mi = cm->mi_grid_visible;
544 xd->mi[0] = cm->mi;
545
546 vp9_setup_block_planes(&x->e_mbd, cm->subsampling_x, cm->subsampling_y);
547
548 vp9_frame_init_quantizer(cpi);
549
550 for (i = 0; i < MAX_MB_PLANE; ++i) {
551 p[i].coeff = ctx->coeff_pbuf[i][1];
552 p[i].qcoeff = ctx->qcoeff_pbuf[i][1];
553 pd[i].dqcoeff = ctx->dqcoeff_pbuf[i][1];
554 p[i].eobs = ctx->eobs_pbuf[i][1];
555 }
556 x->skip_recode = 0;
557
558 vp9_init_mv_probs(cm);
559 vp9_initialize_rd_consts(cpi);
560
561 // Tiling is ignored in the first pass.
562 vp9_tile_init(&tile, cm, 0, 0);
563
564 for (mb_row = 0; mb_row < cm->mb_rows; ++mb_row) {
565 int_mv best_ref_mv;
566
567 best_ref_mv.as_int = 0;
568
569 // Reset above block coeffs.
570 xd->up_available = (mb_row != 0);
571 recon_yoffset = (mb_row * recon_y_stride * 16);
572 recon_uvoffset = (mb_row * recon_uv_stride * uv_mb_height);
573
574 // Set up limit values for motion vectors to prevent them extending
575 // outside the UMV borders.
576 x->mv_row_min = -((mb_row * 16) + BORDER_MV_PIXELS_B16);
577 x->mv_row_max = ((cm->mb_rows - 1 - mb_row) * 16)
578 + BORDER_MV_PIXELS_B16;
579
580 for (mb_col = 0; mb_col < cm->mb_cols; ++mb_col) {
581 int this_error;
582 const int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
583 double error_weight = 1.0;
584 const BLOCK_SIZE bsize = get_bsize(cm, mb_row, mb_col);
585
586 vp9_clear_system_state();
587
588 xd->plane[0].dst.buf = new_yv12->y_buffer + recon_yoffset;
589 xd->plane[1].dst.buf = new_yv12->u_buffer + recon_uvoffset;
590 xd->plane[2].dst.buf = new_yv12->v_buffer + recon_uvoffset;
591 xd->left_available = (mb_col != 0);
592 xd->mi[0]->mbmi.sb_type = bsize;
593 xd->mi[0]->mbmi.ref_frame[0] = INTRA_FRAME;
594 set_mi_row_col(xd, &tile,
595 mb_row << 1, num_8x8_blocks_high_lookup[bsize],
596 mb_col << 1, num_8x8_blocks_wide_lookup[bsize],
597 cm->mi_rows, cm->mi_cols);
598
599 if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
600 const int energy = vp9_block_energy(cpi, x, bsize);
601 error_weight = vp9_vaq_inv_q_ratio(energy);
602 }
603
604 // Do intra 16x16 prediction.
605 this_error = vp9_encode_intra(x, use_dc_pred);
606 if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
607 vp9_clear_system_state();
608 this_error = (int)(this_error * error_weight);
609 }
610
611 // Intrapenalty below deals with situations where the intra and inter
612 // error scores are very low (e.g. a plain black frame).
613 // We do not have special cases in first pass for 0,0 and nearest etc so
614 // all inter modes carry an overhead cost estimate for the mv.
615 // When the error score is very low this causes us to pick all or lots of
616 // INTRA modes and throw lots of key frames.
617 // This penalty adds a cost matching that of a 0,0 mv to the intra case.
618 this_error += intrapenalty;
619
620 // Accumulate the intra error.
621 intra_error += (int64_t)this_error;
622
623 // Set up limit values for motion vectors to prevent them extending
624 // outside the UMV borders.
625 x->mv_col_min = -((mb_col * 16) + BORDER_MV_PIXELS_B16);
626 x->mv_col_max = ((cm->mb_cols - 1 - mb_col) * 16) + BORDER_MV_PIXELS_B16;
627
628 // Other than for the first frame do a motion search.
629 if (cm->current_video_frame > 0) {
630 int tmp_err, motion_error;
631 int_mv mv, tmp_mv;
632
633 xd->plane[0].pre[0].buf = first_ref_buf->y_buffer + recon_yoffset;
634 motion_error = zz_motion_search(x);
635 // Assume 0,0 motion with no mv overhead.
636 mv.as_int = tmp_mv.as_int = 0;
637
638 // Test last reference frame using the previous best mv as the
639 // starting point (best reference) for the search.
640 first_pass_motion_search(cpi, x, &best_ref_mv.as_mv, &mv.as_mv,
641 &motion_error);
642 if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
643 vp9_clear_system_state();
644 motion_error = (int)(motion_error * error_weight);
645 }
646
647 // If the current best reference mv is not centered on 0,0 then do a 0,0
648 // based search as well.
649 if (best_ref_mv.as_int) {
650 tmp_err = INT_MAX;
651 first_pass_motion_search(cpi, x, &zero_mv, &tmp_mv.as_mv,
652 &tmp_err);
653 if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
654 vp9_clear_system_state();
655 tmp_err = (int)(tmp_err * error_weight);
656 }
657
658 if (tmp_err < motion_error) {
659 motion_error = tmp_err;
660 mv.as_int = tmp_mv.as_int;
661 }
662 }
663
664 // Search in an older reference frame.
665 if (cm->current_video_frame > 1 && gld_yv12 != NULL) {
666 // Assume 0,0 motion with no mv overhead.
667 int gf_motion_error;
668
669 xd->plane[0].pre[0].buf = gld_yv12->y_buffer + recon_yoffset;
670 gf_motion_error = zz_motion_search(x);
671
672 first_pass_motion_search(cpi, x, &zero_mv, &tmp_mv.as_mv,
673 &gf_motion_error);
674 if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
675 vp9_clear_system_state();
676 gf_motion_error = (int)(gf_motion_error * error_weight);
677 }
678
679 if (gf_motion_error < motion_error && gf_motion_error < this_error)
680 ++second_ref_count;
681
682 // Reset to last frame as reference buffer.
683 xd->plane[0].pre[0].buf = first_ref_buf->y_buffer + recon_yoffset;
684 xd->plane[1].pre[0].buf = first_ref_buf->u_buffer + recon_uvoffset;
685 xd->plane[2].pre[0].buf = first_ref_buf->v_buffer + recon_uvoffset;
686
687 // In accumulating a score for the older reference frame take the
688 // best of the motion predicted score and the intra coded error
689 // (just as will be done for) accumulation of "coded_error" for
690 // the last frame.
691 if (gf_motion_error < this_error)
692 sr_coded_error += gf_motion_error;
693 else
694 sr_coded_error += this_error;
695 } else {
696 sr_coded_error += motion_error;
697 }
698 // Start by assuming that intra mode is best.
699 best_ref_mv.as_int = 0;
700
701 if (motion_error <= this_error) {
702 // Keep a count of cases where the inter and intra were very close
703 // and very low. This helps with scene cut detection for example in
704 // cropped clips with black bars at the sides or top and bottom.
705 if (((this_error - intrapenalty) * 9 <= motion_error * 10) &&
706 this_error < 2 * intrapenalty)
707 ++neutral_count;
708
709 mv.as_mv.row *= 8;
710 mv.as_mv.col *= 8;
711 this_error = motion_error;
712 xd->mi[0]->mbmi.mode = NEWMV;
713 xd->mi[0]->mbmi.mv[0] = mv;
714 xd->mi[0]->mbmi.tx_size = TX_4X4;
715 xd->mi[0]->mbmi.ref_frame[0] = LAST_FRAME;
716 xd->mi[0]->mbmi.ref_frame[1] = NONE;
717 vp9_build_inter_predictors_sby(xd, mb_row << 1, mb_col << 1, bsize);
718 vp9_encode_sby_pass1(x, bsize);
719 sum_mvr += mv.as_mv.row;
720 sum_mvr_abs += abs(mv.as_mv.row);
721 sum_mvc += mv.as_mv.col;
722 sum_mvc_abs += abs(mv.as_mv.col);
723 sum_mvrs += mv.as_mv.row * mv.as_mv.row;
724 sum_mvcs += mv.as_mv.col * mv.as_mv.col;
725 ++intercount;
726
727 best_ref_mv.as_int = mv.as_int;
728
729 if (mv.as_int) {
730 ++mvcount;
731
732 // Non-zero vector, was it different from the last non zero vector?
733 if (mv.as_int != lastmv_as_int)
734 ++new_mv_count;
735 lastmv_as_int = mv.as_int;
736
737 // Does the row vector point inwards or outwards?
738 if (mb_row < cm->mb_rows / 2) {
739 if (mv.as_mv.row > 0)
740 --sum_in_vectors;
741 else if (mv.as_mv.row < 0)
742 ++sum_in_vectors;
743 } else if (mb_row > cm->mb_rows / 2) {
744 if (mv.as_mv.row > 0)
745 ++sum_in_vectors;
746 else if (mv.as_mv.row < 0)
747 --sum_in_vectors;
748 }
749
750 // Does the col vector point inwards or outwards?
751 if (mb_col < cm->mb_cols / 2) {
752 if (mv.as_mv.col > 0)
753 --sum_in_vectors;
754 else if (mv.as_mv.col < 0)
755 ++sum_in_vectors;
756 } else if (mb_col > cm->mb_cols / 2) {
757 if (mv.as_mv.col > 0)
758 ++sum_in_vectors;
759 else if (mv.as_mv.col < 0)
760 --sum_in_vectors;
761 }
762 }
763 }
764 } else {
765 sr_coded_error += (int64_t)this_error;
766 }
767 coded_error += (int64_t)this_error;
768
769 // Adjust to the next column of MBs.
770 x->plane[0].src.buf += 16;
771 x->plane[1].src.buf += uv_mb_height;
772 x->plane[2].src.buf += uv_mb_height;
773
774 recon_yoffset += 16;
775 recon_uvoffset += uv_mb_height;
776 }
777
778 // Adjust to the next row of MBs.
779 x->plane[0].src.buf += 16 * x->plane[0].src.stride - 16 * cm->mb_cols;
780 x->plane[1].src.buf += uv_mb_height * x->plane[1].src.stride -
781 uv_mb_height * cm->mb_cols;
782 x->plane[2].src.buf += uv_mb_height * x->plane[1].src.stride -
783 uv_mb_height * cm->mb_cols;
784
785 vp9_clear_system_state();
786 }
787
788 vp9_clear_system_state();
789 {
790 FIRSTPASS_STATS fps;
791
792 fps.frame = cm->current_video_frame;
793 fps.spatial_layer_id = cpi->svc.spatial_layer_id;
794 fps.intra_error = (double)(intra_error >> 8);
795 fps.coded_error = (double)(coded_error >> 8);
796 fps.sr_coded_error = (double)(sr_coded_error >> 8);
797 fps.ssim_weighted_pred_err = fps.coded_error * simple_weight(cpi->Source);
798 fps.count = 1.0;
799 fps.pcnt_inter = (double)intercount / cm->MBs;
800 fps.pcnt_second_ref = (double)second_ref_count / cm->MBs;
801 fps.pcnt_neutral = (double)neutral_count / cm->MBs;
802
803 if (mvcount > 0) {
804 fps.MVr = (double)sum_mvr / mvcount;
805 fps.mvr_abs = (double)sum_mvr_abs / mvcount;
806 fps.MVc = (double)sum_mvc / mvcount;
807 fps.mvc_abs = (double)sum_mvc_abs / mvcount;
808 fps.MVrv = ((double)sum_mvrs - (fps.MVr * fps.MVr / mvcount)) / mvcount;
809 fps.MVcv = ((double)sum_mvcs - (fps.MVc * fps.MVc / mvcount)) / mvcount;
810 fps.mv_in_out_count = (double)sum_in_vectors / (mvcount * 2);
811 fps.new_mv_count = new_mv_count;
812 fps.pcnt_motion = (double)mvcount / cm->MBs;
813 } else {
814 fps.MVr = 0.0;
815 fps.mvr_abs = 0.0;
816 fps.MVc = 0.0;
817 fps.mvc_abs = 0.0;
818 fps.MVrv = 0.0;
819 fps.MVcv = 0.0;
820 fps.mv_in_out_count = 0.0;
821 fps.new_mv_count = 0.0;
822 fps.pcnt_motion = 0.0;
823 }
824
825 // TODO(paulwilkins): Handle the case when duration is set to 0, or
826 // something less than the full time between subsequent values of
827 // cpi->source_time_stamp.
828 fps.duration = (double)(cpi->source->ts_end - cpi->source->ts_start);
829
830 // Don't want to do output stats with a stack variable!
831 twopass->this_frame_stats = fps;
832 output_stats(&twopass->this_frame_stats, cpi->output_pkt_list);
833 accumulate_stats(&twopass->total_stats, &fps);
834 }
835
836 // Copy the previous Last Frame back into gf and and arf buffers if
837 // the prediction is good enough... but also don't allow it to lag too far.
838 if ((twopass->sr_update_lag > 3) ||
839 ((cm->current_video_frame > 0) &&
840 (twopass->this_frame_stats.pcnt_inter > 0.20) &&
841 ((twopass->this_frame_stats.intra_error /
842 DOUBLE_DIVIDE_CHECK(twopass->this_frame_stats.coded_error)) > 2.0))) {
843 if (gld_yv12 != NULL) {
844 vp8_yv12_copy_frame(lst_yv12, gld_yv12);
845 }
846 twopass->sr_update_lag = 1;
847 } else {
848 ++twopass->sr_update_lag;
849 }
850
851 if (cpi->use_svc && cpi->svc.number_temporal_layers == 1) {
852 vp9_update_reference_frames(cpi);
853 } else {
854 // Swap frame pointers so last frame refers to the frame we just compressed.
855 swap_yv12(lst_yv12, new_yv12);
856 }
857
858 vp9_extend_frame_borders(lst_yv12);
859
860 // Special case for the first frame. Copy into the GF buffer as a second
861 // reference.
862 if (cm->current_video_frame == 0 && gld_yv12 != NULL) {
863 vp8_yv12_copy_frame(lst_yv12, gld_yv12);
864 }
865
866 // Use this to see what the first pass reconstruction looks like.
867 if (0) {
868 char filename[512];
869 FILE *recon_file;
870 snprintf(filename, sizeof(filename), "enc%04d.yuv",
871 (int)cm->current_video_frame);
872
873 if (cm->current_video_frame == 0)
874 recon_file = fopen(filename, "wb");
875 else
876 recon_file = fopen(filename, "ab");
877
878 (void)fwrite(lst_yv12->buffer_alloc, lst_yv12->frame_size, 1, recon_file);
879 fclose(recon_file);
880 }
881
882 ++cm->current_video_frame;
883 }
884
calc_correction_factor(double err_per_mb,double err_divisor,double pt_low,double pt_high,int q)885 static double calc_correction_factor(double err_per_mb,
886 double err_divisor,
887 double pt_low,
888 double pt_high,
889 int q) {
890 const double error_term = err_per_mb / err_divisor;
891
892 // Adjustment based on actual quantizer to power term.
893 const double power_term = MIN(vp9_convert_qindex_to_q(q) * 0.0125 + pt_low,
894 pt_high);
895
896 // Calculate correction factor.
897 if (power_term < 1.0)
898 assert(error_term >= 0.0);
899
900 return fclamp(pow(error_term, power_term), 0.05, 5.0);
901 }
902
vp9_twopass_worst_quality(VP9_COMP * cpi,FIRSTPASS_STATS * fpstats,int section_target_bandwitdh)903 int vp9_twopass_worst_quality(VP9_COMP *cpi, FIRSTPASS_STATS *fpstats,
904 int section_target_bandwitdh) {
905 int q;
906 const int num_mbs = cpi->common.MBs;
907 int target_norm_bits_per_mb;
908 const RATE_CONTROL *const rc = &cpi->rc;
909
910 const double section_err = fpstats->coded_error / fpstats->count;
911 const double err_per_mb = section_err / num_mbs;
912 const double speed_term = 1.0 + ((double)cpi->speed * 0.04);
913
914 if (section_target_bandwitdh <= 0)
915 return rc->worst_quality; // Highest value allowed
916
917 target_norm_bits_per_mb = section_target_bandwitdh < (1 << 20)
918 ? (512 * section_target_bandwitdh) / num_mbs
919 : 512 * (section_target_bandwitdh / num_mbs);
920
921 // Try and pick a max Q that will be high enough to encode the
922 // content at the given rate.
923 for (q = rc->best_quality; q < rc->worst_quality; ++q) {
924 const double err_correction_factor = calc_correction_factor(err_per_mb,
925 ERR_DIVISOR, 0.5, 0.90, q);
926 const int bits_per_mb_at_this_q =
927 vp9_rc_bits_per_mb(INTER_FRAME, q, (err_correction_factor * speed_term));
928 if (bits_per_mb_at_this_q <= target_norm_bits_per_mb)
929 break;
930 }
931
932 // Restriction on active max q for constrained quality mode.
933 if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
934 q = MAX(q, cpi->cq_target_quality);
935
936 return q;
937 }
938
939 extern void vp9_new_framerate(VP9_COMP *cpi, double framerate);
940
vp9_init_second_pass(VP9_COMP * cpi)941 void vp9_init_second_pass(VP9_COMP *cpi) {
942 FIRSTPASS_STATS this_frame;
943 const FIRSTPASS_STATS *start_pos;
944 struct twopass_rc *twopass = &cpi->twopass;
945 const VP9_CONFIG *const oxcf = &cpi->oxcf;
946 const int is_spatial_svc = (cpi->svc.number_spatial_layers > 1) &&
947 (cpi->svc.number_temporal_layers == 1);
948 double frame_rate;
949
950 if (is_spatial_svc) {
951 twopass = &cpi->svc.layer_context[cpi->svc.spatial_layer_id].twopass;
952 }
953
954 zero_stats(&twopass->total_stats);
955 zero_stats(&twopass->total_left_stats);
956
957 if (!twopass->stats_in_end)
958 return;
959
960 twopass->total_stats = *twopass->stats_in_end;
961 twopass->total_left_stats = twopass->total_stats;
962
963 frame_rate = 10000000.0 * twopass->total_stats.count /
964 twopass->total_stats.duration;
965 // Each frame can have a different duration, as the frame rate in the source
966 // isn't guaranteed to be constant. The frame rate prior to the first frame
967 // encoded in the second pass is a guess. However, the sum duration is not.
968 // It is calculated based on the actual durations of all frames from the
969 // first pass.
970
971 if (is_spatial_svc) {
972 vp9_update_spatial_layer_framerate(cpi, frame_rate);
973 twopass->bits_left =
974 (int64_t)(twopass->total_stats.duration *
975 cpi->svc.layer_context[cpi->svc.spatial_layer_id].target_bandwidth /
976 10000000.0);
977 } else {
978 vp9_new_framerate(cpi, frame_rate);
979 twopass->bits_left = (int64_t)(twopass->total_stats.duration *
980 oxcf->target_bandwidth / 10000000.0);
981 }
982
983 cpi->output_framerate = oxcf->framerate;
984
985 // Calculate a minimum intra value to be used in determining the IIratio
986 // scores used in the second pass. We have this minimum to make sure
987 // that clips that are static but "low complexity" in the intra domain
988 // are still boosted appropriately for KF/GF/ARF.
989 if (!is_spatial_svc) {
990 // We don't know the number of MBs for each layer at this point.
991 // So we will do it later.
992 twopass->kf_intra_err_min = KF_MB_INTRA_MIN * cpi->common.MBs;
993 twopass->gf_intra_err_min = GF_MB_INTRA_MIN * cpi->common.MBs;
994 }
995
996 // This variable monitors how far behind the second ref update is lagging.
997 twopass->sr_update_lag = 1;
998
999 // Scan the first pass file and calculate an average Intra / Inter error
1000 // score ratio for the sequence.
1001 {
1002 double sum_iiratio = 0.0;
1003 start_pos = twopass->stats_in;
1004
1005 while (input_stats(twopass, &this_frame) != EOF) {
1006 const double iiratio = this_frame.intra_error /
1007 DOUBLE_DIVIDE_CHECK(this_frame.coded_error);
1008 sum_iiratio += fclamp(iiratio, 1.0, 20.0);
1009 }
1010
1011 twopass->avg_iiratio = sum_iiratio /
1012 DOUBLE_DIVIDE_CHECK((double)twopass->total_stats.count);
1013
1014 reset_fpf_position(twopass, start_pos);
1015 }
1016
1017 // Scan the first pass file and calculate a modified total error based upon
1018 // the bias/power function used to allocate bits.
1019 {
1020 double av_error = twopass->total_stats.ssim_weighted_pred_err /
1021 DOUBLE_DIVIDE_CHECK(twopass->total_stats.count);
1022
1023 start_pos = twopass->stats_in;
1024
1025 twopass->modified_error_total = 0.0;
1026 twopass->modified_error_min =
1027 (av_error * oxcf->two_pass_vbrmin_section) / 100;
1028 twopass->modified_error_max =
1029 (av_error * oxcf->two_pass_vbrmax_section) / 100;
1030
1031 while (input_stats(twopass, &this_frame) != EOF) {
1032 twopass->modified_error_total +=
1033 calculate_modified_err(cpi, &this_frame);
1034 }
1035 twopass->modified_error_left = twopass->modified_error_total;
1036
1037 reset_fpf_position(twopass, start_pos);
1038 }
1039 }
1040
1041 // This function gives an estimate of how badly we believe the prediction
1042 // quality is decaying from frame to frame.
get_prediction_decay_rate(const VP9_COMMON * cm,const FIRSTPASS_STATS * next_frame)1043 static double get_prediction_decay_rate(const VP9_COMMON *cm,
1044 const FIRSTPASS_STATS *next_frame) {
1045 // Look at the observed drop in prediction quality between the last frame
1046 // and the GF buffer (which contains an older frame).
1047 const double mb_sr_err_diff = (next_frame->sr_coded_error -
1048 next_frame->coded_error) / cm->MBs;
1049 const double second_ref_decay = mb_sr_err_diff <= 512.0
1050 ? fclamp(pow(1.0 - (mb_sr_err_diff / 512.0), 0.5), 0.85, 1.0)
1051 : 0.85;
1052
1053 return MIN(second_ref_decay, next_frame->pcnt_inter);
1054 }
1055
1056 // Function to test for a condition where a complex transition is followed
1057 // by a static section. For example in slide shows where there is a fade
1058 // between slides. This is to help with more optimal kf and gf positioning.
detect_transition_to_still(VP9_COMP * cpi,int frame_interval,int still_interval,double loop_decay_rate,double last_decay_rate)1059 static int detect_transition_to_still(VP9_COMP *cpi, int frame_interval,
1060 int still_interval,
1061 double loop_decay_rate,
1062 double last_decay_rate) {
1063 int trans_to_still = 0;
1064
1065 // Break clause to detect very still sections after motion
1066 // For example a static image after a fade or other transition
1067 // instead of a clean scene cut.
1068 if (frame_interval > MIN_GF_INTERVAL &&
1069 loop_decay_rate >= 0.999 &&
1070 last_decay_rate < 0.9) {
1071 int j;
1072 const FIRSTPASS_STATS *position = cpi->twopass.stats_in;
1073 FIRSTPASS_STATS tmp_next_frame;
1074
1075 // Look ahead a few frames to see if static condition persists...
1076 for (j = 0; j < still_interval; ++j) {
1077 if (EOF == input_stats(&cpi->twopass, &tmp_next_frame))
1078 break;
1079
1080 if (tmp_next_frame.pcnt_inter - tmp_next_frame.pcnt_motion < 0.999)
1081 break;
1082 }
1083
1084 reset_fpf_position(&cpi->twopass, position);
1085
1086 // Only if it does do we signal a transition to still.
1087 if (j == still_interval)
1088 trans_to_still = 1;
1089 }
1090
1091 return trans_to_still;
1092 }
1093
1094 // This function detects a flash through the high relative pcnt_second_ref
1095 // score in the frame following a flash frame. The offset passed in should
1096 // reflect this.
detect_flash(const struct twopass_rc * twopass,int offset)1097 static int detect_flash(const struct twopass_rc *twopass, int offset) {
1098 FIRSTPASS_STATS next_frame;
1099
1100 int flash_detected = 0;
1101
1102 // Read the frame data.
1103 // The return is FALSE (no flash detected) if not a valid frame
1104 if (read_frame_stats(twopass, &next_frame, offset) != EOF) {
1105 // What we are looking for here is a situation where there is a
1106 // brief break in prediction (such as a flash) but subsequent frames
1107 // are reasonably well predicted by an earlier (pre flash) frame.
1108 // The recovery after a flash is indicated by a high pcnt_second_ref
1109 // compared to pcnt_inter.
1110 if (next_frame.pcnt_second_ref > next_frame.pcnt_inter &&
1111 next_frame.pcnt_second_ref >= 0.5)
1112 flash_detected = 1;
1113 }
1114
1115 return flash_detected;
1116 }
1117
1118 // Update the motion related elements to the GF arf boost calculation.
accumulate_frame_motion_stats(FIRSTPASS_STATS * this_frame,double * this_frame_mv_in_out,double * mv_in_out_accumulator,double * abs_mv_in_out_accumulator,double * mv_ratio_accumulator)1119 static void accumulate_frame_motion_stats(
1120 FIRSTPASS_STATS *this_frame,
1121 double *this_frame_mv_in_out,
1122 double *mv_in_out_accumulator,
1123 double *abs_mv_in_out_accumulator,
1124 double *mv_ratio_accumulator) {
1125 double motion_pct;
1126
1127 // Accumulate motion stats.
1128 motion_pct = this_frame->pcnt_motion;
1129
1130 // Accumulate Motion In/Out of frame stats.
1131 *this_frame_mv_in_out = this_frame->mv_in_out_count * motion_pct;
1132 *mv_in_out_accumulator += this_frame->mv_in_out_count * motion_pct;
1133 *abs_mv_in_out_accumulator += fabs(this_frame->mv_in_out_count * motion_pct);
1134
1135 // Accumulate a measure of how uniform (or conversely how random)
1136 // the motion field is (a ratio of absmv / mv).
1137 if (motion_pct > 0.05) {
1138 const double this_frame_mvr_ratio = fabs(this_frame->mvr_abs) /
1139 DOUBLE_DIVIDE_CHECK(fabs(this_frame->MVr));
1140
1141 const double this_frame_mvc_ratio = fabs(this_frame->mvc_abs) /
1142 DOUBLE_DIVIDE_CHECK(fabs(this_frame->MVc));
1143
1144 *mv_ratio_accumulator += (this_frame_mvr_ratio < this_frame->mvr_abs)
1145 ? (this_frame_mvr_ratio * motion_pct)
1146 : this_frame->mvr_abs * motion_pct;
1147
1148 *mv_ratio_accumulator += (this_frame_mvc_ratio < this_frame->mvc_abs)
1149 ? (this_frame_mvc_ratio * motion_pct)
1150 : this_frame->mvc_abs * motion_pct;
1151 }
1152 }
1153
1154 // Calculate a baseline boost number for the current frame.
calc_frame_boost(VP9_COMP * cpi,FIRSTPASS_STATS * this_frame,double this_frame_mv_in_out)1155 static double calc_frame_boost(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame,
1156 double this_frame_mv_in_out) {
1157 double frame_boost;
1158
1159 // Underlying boost factor is based on inter intra error ratio.
1160 if (this_frame->intra_error > cpi->twopass.gf_intra_err_min)
1161 frame_boost = (IIFACTOR * this_frame->intra_error /
1162 DOUBLE_DIVIDE_CHECK(this_frame->coded_error));
1163 else
1164 frame_boost = (IIFACTOR * cpi->twopass.gf_intra_err_min /
1165 DOUBLE_DIVIDE_CHECK(this_frame->coded_error));
1166
1167 // Increase boost for frames where new data coming into frame (e.g. zoom out).
1168 // Slightly reduce boost if there is a net balance of motion out of the frame
1169 // (zoom in). The range for this_frame_mv_in_out is -1.0 to +1.0.
1170 if (this_frame_mv_in_out > 0.0)
1171 frame_boost += frame_boost * (this_frame_mv_in_out * 2.0);
1172 // In the extreme case the boost is halved.
1173 else
1174 frame_boost += frame_boost * (this_frame_mv_in_out / 2.0);
1175
1176 return MIN(frame_boost, GF_RMAX);
1177 }
1178
calc_arf_boost(VP9_COMP * cpi,int offset,int f_frames,int b_frames,int * f_boost,int * b_boost)1179 static int calc_arf_boost(VP9_COMP *cpi, int offset,
1180 int f_frames, int b_frames,
1181 int *f_boost, int *b_boost) {
1182 FIRSTPASS_STATS this_frame;
1183 struct twopass_rc *const twopass = &cpi->twopass;
1184 int i;
1185 double boost_score = 0.0;
1186 double mv_ratio_accumulator = 0.0;
1187 double decay_accumulator = 1.0;
1188 double this_frame_mv_in_out = 0.0;
1189 double mv_in_out_accumulator = 0.0;
1190 double abs_mv_in_out_accumulator = 0.0;
1191 int arf_boost;
1192 int flash_detected = 0;
1193
1194 // Search forward from the proposed arf/next gf position.
1195 for (i = 0; i < f_frames; ++i) {
1196 if (read_frame_stats(twopass, &this_frame, (i + offset)) == EOF)
1197 break;
1198
1199 // Update the motion related elements to the boost calculation.
1200 accumulate_frame_motion_stats(&this_frame,
1201 &this_frame_mv_in_out, &mv_in_out_accumulator,
1202 &abs_mv_in_out_accumulator,
1203 &mv_ratio_accumulator);
1204
1205 // We want to discount the flash frame itself and the recovery
1206 // frame that follows as both will have poor scores.
1207 flash_detected = detect_flash(twopass, i + offset) ||
1208 detect_flash(twopass, i + offset + 1);
1209
1210 // Accumulate the effect of prediction quality decay.
1211 if (!flash_detected) {
1212 decay_accumulator *= get_prediction_decay_rate(&cpi->common, &this_frame);
1213 decay_accumulator = decay_accumulator < MIN_DECAY_FACTOR
1214 ? MIN_DECAY_FACTOR : decay_accumulator;
1215 }
1216
1217 boost_score += (decay_accumulator *
1218 calc_frame_boost(cpi, &this_frame, this_frame_mv_in_out));
1219 }
1220
1221 *f_boost = (int)boost_score;
1222
1223 // Reset for backward looking loop.
1224 boost_score = 0.0;
1225 mv_ratio_accumulator = 0.0;
1226 decay_accumulator = 1.0;
1227 this_frame_mv_in_out = 0.0;
1228 mv_in_out_accumulator = 0.0;
1229 abs_mv_in_out_accumulator = 0.0;
1230
1231 // Search backward towards last gf position.
1232 for (i = -1; i >= -b_frames; --i) {
1233 if (read_frame_stats(twopass, &this_frame, (i + offset)) == EOF)
1234 break;
1235
1236 // Update the motion related elements to the boost calculation.
1237 accumulate_frame_motion_stats(&this_frame,
1238 &this_frame_mv_in_out, &mv_in_out_accumulator,
1239 &abs_mv_in_out_accumulator,
1240 &mv_ratio_accumulator);
1241
1242 // We want to discount the the flash frame itself and the recovery
1243 // frame that follows as both will have poor scores.
1244 flash_detected = detect_flash(twopass, i + offset) ||
1245 detect_flash(twopass, i + offset + 1);
1246
1247 // Cumulative effect of prediction quality decay.
1248 if (!flash_detected) {
1249 decay_accumulator *= get_prediction_decay_rate(&cpi->common, &this_frame);
1250 decay_accumulator = decay_accumulator < MIN_DECAY_FACTOR
1251 ? MIN_DECAY_FACTOR : decay_accumulator;
1252 }
1253
1254 boost_score += (decay_accumulator *
1255 calc_frame_boost(cpi, &this_frame, this_frame_mv_in_out));
1256 }
1257 *b_boost = (int)boost_score;
1258
1259 arf_boost = (*f_boost + *b_boost);
1260 if (arf_boost < ((b_frames + f_frames) * 20))
1261 arf_boost = ((b_frames + f_frames) * 20);
1262
1263 return arf_boost;
1264 }
1265
1266 #if CONFIG_MULTIPLE_ARF
1267 // Work out the frame coding order for a GF or an ARF group.
1268 // The current implementation codes frames in their natural order for a
1269 // GF group, and inserts additional ARFs into an ARF group using a
1270 // binary split approach.
1271 // NOTE: this function is currently implemented recursively.
schedule_frames(VP9_COMP * cpi,const int start,const int end,const int arf_idx,const int gf_or_arf_group,const int level)1272 static void schedule_frames(VP9_COMP *cpi, const int start, const int end,
1273 const int arf_idx, const int gf_or_arf_group,
1274 const int level) {
1275 int i, abs_end, half_range;
1276 int *cfo = cpi->frame_coding_order;
1277 int idx = cpi->new_frame_coding_order_period;
1278
1279 // If (end < 0) an ARF should be coded at position (-end).
1280 assert(start >= 0);
1281
1282 // printf("start:%d end:%d\n", start, end);
1283
1284 // GF Group: code frames in logical order.
1285 if (gf_or_arf_group == 0) {
1286 assert(end >= start);
1287 for (i = start; i <= end; ++i) {
1288 cfo[idx] = i;
1289 cpi->arf_buffer_idx[idx] = arf_idx;
1290 cpi->arf_weight[idx] = -1;
1291 ++idx;
1292 }
1293 cpi->new_frame_coding_order_period = idx;
1294 return;
1295 }
1296
1297 // ARF Group: Work out the ARF schedule and mark ARF frames as negative.
1298 if (end < 0) {
1299 // printf("start:%d end:%d\n", -end, -end);
1300 // ARF frame is at the end of the range.
1301 cfo[idx] = end;
1302 // What ARF buffer does this ARF use as predictor.
1303 cpi->arf_buffer_idx[idx] = (arf_idx > 2) ? (arf_idx - 1) : 2;
1304 cpi->arf_weight[idx] = level;
1305 ++idx;
1306 abs_end = -end;
1307 } else {
1308 abs_end = end;
1309 }
1310
1311 half_range = (abs_end - start) >> 1;
1312
1313 // ARFs may not be adjacent, they must be separated by at least
1314 // MIN_GF_INTERVAL non-ARF frames.
1315 if ((start + MIN_GF_INTERVAL) >= (abs_end - MIN_GF_INTERVAL)) {
1316 // printf("start:%d end:%d\n", start, abs_end);
1317 // Update the coding order and active ARF.
1318 for (i = start; i <= abs_end; ++i) {
1319 cfo[idx] = i;
1320 cpi->arf_buffer_idx[idx] = arf_idx;
1321 cpi->arf_weight[idx] = -1;
1322 ++idx;
1323 }
1324 cpi->new_frame_coding_order_period = idx;
1325 } else {
1326 // Place a new ARF at the mid-point of the range.
1327 cpi->new_frame_coding_order_period = idx;
1328 schedule_frames(cpi, start, -(start + half_range), arf_idx + 1,
1329 gf_or_arf_group, level + 1);
1330 schedule_frames(cpi, start + half_range + 1, abs_end, arf_idx,
1331 gf_or_arf_group, level + 1);
1332 }
1333 }
1334
1335 #define FIXED_ARF_GROUP_SIZE 16
1336
define_fixed_arf_period(VP9_COMP * cpi)1337 void define_fixed_arf_period(VP9_COMP *cpi) {
1338 int i;
1339 int max_level = INT_MIN;
1340
1341 assert(cpi->multi_arf_enabled);
1342 assert(cpi->oxcf.lag_in_frames >= FIXED_ARF_GROUP_SIZE);
1343
1344 // Save the weight of the last frame in the sequence before next
1345 // sequence pattern overwrites it.
1346 cpi->this_frame_weight = cpi->arf_weight[cpi->sequence_number];
1347 assert(cpi->this_frame_weight >= 0);
1348
1349 cpi->twopass.gf_zeromotion_pct = 0;
1350
1351 // Initialize frame coding order variables.
1352 cpi->new_frame_coding_order_period = 0;
1353 cpi->next_frame_in_order = 0;
1354 cpi->arf_buffered = 0;
1355 vp9_zero(cpi->frame_coding_order);
1356 vp9_zero(cpi->arf_buffer_idx);
1357 vpx_memset(cpi->arf_weight, -1, sizeof(cpi->arf_weight));
1358
1359 if (cpi->rc.frames_to_key <= (FIXED_ARF_GROUP_SIZE + 8)) {
1360 // Setup a GF group close to the keyframe.
1361 cpi->rc.source_alt_ref_pending = 0;
1362 cpi->rc.baseline_gf_interval = cpi->rc.frames_to_key;
1363 schedule_frames(cpi, 0, (cpi->rc.baseline_gf_interval - 1), 2, 0, 0);
1364 } else {
1365 // Setup a fixed period ARF group.
1366 cpi->rc.source_alt_ref_pending = 1;
1367 cpi->rc.baseline_gf_interval = FIXED_ARF_GROUP_SIZE;
1368 schedule_frames(cpi, 0, -(cpi->rc.baseline_gf_interval - 1), 2, 1, 0);
1369 }
1370
1371 // Replace level indicator of -1 with correct level.
1372 for (i = 0; i < cpi->new_frame_coding_order_period; ++i) {
1373 if (cpi->arf_weight[i] > max_level) {
1374 max_level = cpi->arf_weight[i];
1375 }
1376 }
1377 ++max_level;
1378 for (i = 0; i < cpi->new_frame_coding_order_period; ++i) {
1379 if (cpi->arf_weight[i] == -1) {
1380 cpi->arf_weight[i] = max_level;
1381 }
1382 }
1383 cpi->max_arf_level = max_level;
1384 #if 0
1385 printf("\nSchedule: ");
1386 for (i = 0; i < cpi->new_frame_coding_order_period; ++i) {
1387 printf("%4d ", cpi->frame_coding_order[i]);
1388 }
1389 printf("\n");
1390 printf("ARFref: ");
1391 for (i = 0; i < cpi->new_frame_coding_order_period; ++i) {
1392 printf("%4d ", cpi->arf_buffer_idx[i]);
1393 }
1394 printf("\n");
1395 printf("Weight: ");
1396 for (i = 0; i < cpi->new_frame_coding_order_period; ++i) {
1397 printf("%4d ", cpi->arf_weight[i]);
1398 }
1399 printf("\n");
1400 #endif
1401 }
1402 #endif
1403
1404 // Analyse and define a gf/arf group.
define_gf_group(VP9_COMP * cpi,FIRSTPASS_STATS * this_frame)1405 static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
1406 FIRSTPASS_STATS next_frame = { 0 };
1407 const FIRSTPASS_STATS *start_pos;
1408 struct twopass_rc *const twopass = &cpi->twopass;
1409 int i;
1410 double boost_score = 0.0;
1411 double old_boost_score = 0.0;
1412 double gf_group_err = 0.0;
1413 double gf_first_frame_err = 0.0;
1414 double mod_frame_err = 0.0;
1415
1416 double mv_ratio_accumulator = 0.0;
1417 double decay_accumulator = 1.0;
1418 double zero_motion_accumulator = 1.0;
1419
1420 double loop_decay_rate = 1.00;
1421 double last_loop_decay_rate = 1.00;
1422
1423 double this_frame_mv_in_out = 0.0;
1424 double mv_in_out_accumulator = 0.0;
1425 double abs_mv_in_out_accumulator = 0.0;
1426 double mv_ratio_accumulator_thresh;
1427 const int max_bits = frame_max_bits(cpi); // Max bits for a single frame.
1428
1429 unsigned int allow_alt_ref = cpi->oxcf.play_alternate &&
1430 cpi->oxcf.lag_in_frames;
1431
1432 int f_boost = 0;
1433 int b_boost = 0;
1434 int flash_detected;
1435 int active_max_gf_interval;
1436 RATE_CONTROL *const rc = &cpi->rc;
1437
1438 twopass->gf_group_bits = 0;
1439
1440 vp9_clear_system_state();
1441
1442 start_pos = twopass->stats_in;
1443
1444 // Load stats for the current frame.
1445 mod_frame_err = calculate_modified_err(cpi, this_frame);
1446
1447 // Note the error of the frame at the start of the group. This will be
1448 // the GF frame error if we code a normal gf.
1449 gf_first_frame_err = mod_frame_err;
1450
1451 // If this is a key frame or the overlay from a previous arf then
1452 // the error score / cost of this frame has already been accounted for.
1453 if (cpi->common.frame_type == KEY_FRAME || rc->source_alt_ref_active)
1454 gf_group_err -= gf_first_frame_err;
1455
1456 // Motion breakout threshold for loop below depends on image size.
1457 mv_ratio_accumulator_thresh = (cpi->common.width + cpi->common.height) / 10.0;
1458
1459 // Work out a maximum interval for the GF.
1460 // If the image appears completely static we can extend beyond this.
1461 // The value chosen depends on the active Q range. At low Q we have
1462 // bits to spare and are better with a smaller interval and smaller boost.
1463 // At high Q when there are few bits to spare we are better with a longer
1464 // interval to spread the cost of the GF.
1465 //
1466 active_max_gf_interval =
1467 12 + ((int)vp9_convert_qindex_to_q(rc->last_q[INTER_FRAME]) >> 5);
1468
1469 if (active_max_gf_interval > rc->max_gf_interval)
1470 active_max_gf_interval = rc->max_gf_interval;
1471
1472 i = 0;
1473 while (i < rc->static_scene_max_gf_interval && i < rc->frames_to_key) {
1474 ++i;
1475
1476 // Accumulate error score of frames in this gf group.
1477 mod_frame_err = calculate_modified_err(cpi, this_frame);
1478 gf_group_err += mod_frame_err;
1479
1480 if (EOF == input_stats(twopass, &next_frame))
1481 break;
1482
1483 // Test for the case where there is a brief flash but the prediction
1484 // quality back to an earlier frame is then restored.
1485 flash_detected = detect_flash(twopass, 0);
1486
1487 // Update the motion related elements to the boost calculation.
1488 accumulate_frame_motion_stats(&next_frame,
1489 &this_frame_mv_in_out, &mv_in_out_accumulator,
1490 &abs_mv_in_out_accumulator,
1491 &mv_ratio_accumulator);
1492
1493 // Accumulate the effect of prediction quality decay.
1494 if (!flash_detected) {
1495 last_loop_decay_rate = loop_decay_rate;
1496 loop_decay_rate = get_prediction_decay_rate(&cpi->common, &next_frame);
1497 decay_accumulator = decay_accumulator * loop_decay_rate;
1498
1499 // Monitor for static sections.
1500 if ((next_frame.pcnt_inter - next_frame.pcnt_motion) <
1501 zero_motion_accumulator) {
1502 zero_motion_accumulator = next_frame.pcnt_inter -
1503 next_frame.pcnt_motion;
1504 }
1505
1506 // Break clause to detect very still sections after motion. For example,
1507 // a static image after a fade or other transition.
1508 if (detect_transition_to_still(cpi, i, 5, loop_decay_rate,
1509 last_loop_decay_rate)) {
1510 allow_alt_ref = 0;
1511 break;
1512 }
1513 }
1514
1515 // Calculate a boost number for this frame.
1516 boost_score += (decay_accumulator *
1517 calc_frame_boost(cpi, &next_frame, this_frame_mv_in_out));
1518
1519 // Break out conditions.
1520 if (
1521 // Break at cpi->max_gf_interval unless almost totally static.
1522 (i >= active_max_gf_interval && (zero_motion_accumulator < 0.995)) ||
1523 (
1524 // Don't break out with a very short interval.
1525 (i > MIN_GF_INTERVAL) &&
1526 ((boost_score > 125.0) || (next_frame.pcnt_inter < 0.75)) &&
1527 (!flash_detected) &&
1528 ((mv_ratio_accumulator > mv_ratio_accumulator_thresh) ||
1529 (abs_mv_in_out_accumulator > 3.0) ||
1530 (mv_in_out_accumulator < -2.0) ||
1531 ((boost_score - old_boost_score) < IIFACTOR)))) {
1532 boost_score = old_boost_score;
1533 break;
1534 }
1535
1536 *this_frame = next_frame;
1537
1538 old_boost_score = boost_score;
1539 }
1540
1541 twopass->gf_zeromotion_pct = (int)(zero_motion_accumulator * 1000.0);
1542
1543 // Don't allow a gf too near the next kf.
1544 if ((rc->frames_to_key - i) < MIN_GF_INTERVAL) {
1545 while (i < (rc->frames_to_key + !rc->next_key_frame_forced)) {
1546 ++i;
1547
1548 if (EOF == input_stats(twopass, this_frame))
1549 break;
1550
1551 if (i < rc->frames_to_key) {
1552 mod_frame_err = calculate_modified_err(cpi, this_frame);
1553 gf_group_err += mod_frame_err;
1554 }
1555 }
1556 }
1557
1558 #if CONFIG_MULTIPLE_ARF
1559 if (cpi->multi_arf_enabled) {
1560 // Initialize frame coding order variables.
1561 cpi->new_frame_coding_order_period = 0;
1562 cpi->next_frame_in_order = 0;
1563 cpi->arf_buffered = 0;
1564 vp9_zero(cpi->frame_coding_order);
1565 vp9_zero(cpi->arf_buffer_idx);
1566 vpx_memset(cpi->arf_weight, -1, sizeof(cpi->arf_weight));
1567 }
1568 #endif
1569
1570 // Set the interval until the next gf.
1571 if (cpi->common.frame_type == KEY_FRAME || rc->source_alt_ref_active)
1572 rc->baseline_gf_interval = i - 1;
1573 else
1574 rc->baseline_gf_interval = i;
1575
1576 // Should we use the alternate reference frame.
1577 if (allow_alt_ref &&
1578 (i < cpi->oxcf.lag_in_frames) &&
1579 (i >= MIN_GF_INTERVAL) &&
1580 // For real scene cuts (not forced kfs) don't allow arf very near kf.
1581 (rc->next_key_frame_forced ||
1582 (i <= (rc->frames_to_key - MIN_GF_INTERVAL)))) {
1583 // Calculate the boost for alt ref.
1584 rc->gfu_boost = calc_arf_boost(cpi, 0, (i - 1), (i - 1), &f_boost,
1585 &b_boost);
1586 rc->source_alt_ref_pending = 1;
1587
1588 #if CONFIG_MULTIPLE_ARF
1589 // Set the ARF schedule.
1590 if (cpi->multi_arf_enabled) {
1591 schedule_frames(cpi, 0, -(rc->baseline_gf_interval - 1), 2, 1, 0);
1592 }
1593 #endif
1594 } else {
1595 rc->gfu_boost = (int)boost_score;
1596 rc->source_alt_ref_pending = 0;
1597 #if CONFIG_MULTIPLE_ARF
1598 // Set the GF schedule.
1599 if (cpi->multi_arf_enabled) {
1600 schedule_frames(cpi, 0, rc->baseline_gf_interval - 1, 2, 0, 0);
1601 assert(cpi->new_frame_coding_order_period ==
1602 rc->baseline_gf_interval);
1603 }
1604 #endif
1605 }
1606
1607 #if CONFIG_MULTIPLE_ARF
1608 if (cpi->multi_arf_enabled && (cpi->common.frame_type != KEY_FRAME)) {
1609 int max_level = INT_MIN;
1610 // Replace level indicator of -1 with correct level.
1611 for (i = 0; i < cpi->frame_coding_order_period; ++i) {
1612 if (cpi->arf_weight[i] > max_level) {
1613 max_level = cpi->arf_weight[i];
1614 }
1615 }
1616 ++max_level;
1617 for (i = 0; i < cpi->frame_coding_order_period; ++i) {
1618 if (cpi->arf_weight[i] == -1) {
1619 cpi->arf_weight[i] = max_level;
1620 }
1621 }
1622 cpi->max_arf_level = max_level;
1623 }
1624 #if 0
1625 if (cpi->multi_arf_enabled) {
1626 printf("\nSchedule: ");
1627 for (i = 0; i < cpi->new_frame_coding_order_period; ++i) {
1628 printf("%4d ", cpi->frame_coding_order[i]);
1629 }
1630 printf("\n");
1631 printf("ARFref: ");
1632 for (i = 0; i < cpi->new_frame_coding_order_period; ++i) {
1633 printf("%4d ", cpi->arf_buffer_idx[i]);
1634 }
1635 printf("\n");
1636 printf("Weight: ");
1637 for (i = 0; i < cpi->new_frame_coding_order_period; ++i) {
1638 printf("%4d ", cpi->arf_weight[i]);
1639 }
1640 printf("\n");
1641 }
1642 #endif
1643 #endif
1644
1645 // Calculate the bits to be allocated to the group as a whole.
1646 if (twopass->kf_group_bits > 0 && twopass->kf_group_error_left > 0) {
1647 twopass->gf_group_bits = (int64_t)(twopass->kf_group_bits *
1648 (gf_group_err / twopass->kf_group_error_left));
1649 } else {
1650 twopass->gf_group_bits = 0;
1651 }
1652 twopass->gf_group_bits = (twopass->gf_group_bits < 0) ?
1653 0 : (twopass->gf_group_bits > twopass->kf_group_bits) ?
1654 twopass->kf_group_bits : twopass->gf_group_bits;
1655
1656 // Clip cpi->twopass.gf_group_bits based on user supplied data rate
1657 // variability limit, cpi->oxcf.two_pass_vbrmax_section.
1658 if (twopass->gf_group_bits > (int64_t)max_bits * rc->baseline_gf_interval)
1659 twopass->gf_group_bits = (int64_t)max_bits * rc->baseline_gf_interval;
1660
1661 // Reset the file position.
1662 reset_fpf_position(twopass, start_pos);
1663
1664 // Assign bits to the arf or gf.
1665 for (i = 0; i <= (rc->source_alt_ref_pending &&
1666 cpi->common.frame_type != KEY_FRAME); ++i) {
1667 int allocation_chunks;
1668 int q = rc->last_q[INTER_FRAME];
1669 int gf_bits;
1670
1671 int boost = (rc->gfu_boost * gfboost_qadjust(q)) / 100;
1672
1673 // Set max and minimum boost and hence minimum allocation.
1674 boost = clamp(boost, 125, (rc->baseline_gf_interval + 1) * 200);
1675
1676 if (rc->source_alt_ref_pending && i == 0)
1677 allocation_chunks = ((rc->baseline_gf_interval + 1) * 100) + boost;
1678 else
1679 allocation_chunks = (rc->baseline_gf_interval * 100) + (boost - 100);
1680
1681 // Prevent overflow.
1682 if (boost > 1023) {
1683 int divisor = boost >> 10;
1684 boost /= divisor;
1685 allocation_chunks /= divisor;
1686 }
1687
1688 // Calculate the number of bits to be spent on the gf or arf based on
1689 // the boost number.
1690 gf_bits = (int)((double)boost * (twopass->gf_group_bits /
1691 (double)allocation_chunks));
1692
1693 // If the frame that is to be boosted is simpler than the average for
1694 // the gf/arf group then use an alternative calculation
1695 // based on the error score of the frame itself.
1696 if (rc->baseline_gf_interval < 1 ||
1697 mod_frame_err < gf_group_err / (double)rc->baseline_gf_interval) {
1698 double alt_gf_grp_bits = (double)twopass->kf_group_bits *
1699 (mod_frame_err * (double)rc->baseline_gf_interval) /
1700 DOUBLE_DIVIDE_CHECK(twopass->kf_group_error_left);
1701
1702 int alt_gf_bits = (int)((double)boost * (alt_gf_grp_bits /
1703 (double)allocation_chunks));
1704
1705 if (gf_bits > alt_gf_bits)
1706 gf_bits = alt_gf_bits;
1707 } else {
1708 // If it is harder than other frames in the group make sure it at
1709 // least receives an allocation in keeping with its relative error
1710 // score, otherwise it may be worse off than an "un-boosted" frame.
1711 int alt_gf_bits = (int)((double)twopass->kf_group_bits *
1712 mod_frame_err /
1713 DOUBLE_DIVIDE_CHECK(twopass->kf_group_error_left));
1714
1715 if (alt_gf_bits > gf_bits)
1716 gf_bits = alt_gf_bits;
1717 }
1718
1719 // Don't allow a negative value for gf_bits.
1720 if (gf_bits < 0)
1721 gf_bits = 0;
1722
1723 if (i == 0) {
1724 twopass->gf_bits = gf_bits;
1725 }
1726 if (i == 1 ||
1727 (!rc->source_alt_ref_pending &&
1728 cpi->common.frame_type != KEY_FRAME)) {
1729 // Calculate the per frame bit target for this frame.
1730 vp9_rc_set_frame_target(cpi, gf_bits);
1731 }
1732 }
1733
1734 {
1735 // Adjust KF group bits and error remaining.
1736 twopass->kf_group_error_left -= (int64_t)gf_group_err;
1737
1738 // If this is an arf update we want to remove the score for the overlay
1739 // frame at the end which will usually be very cheap to code.
1740 // The overlay frame has already, in effect, been coded so we want to spread
1741 // the remaining bits among the other frames.
1742 // For normal GFs remove the score for the GF itself unless this is
1743 // also a key frame in which case it has already been accounted for.
1744 if (rc->source_alt_ref_pending) {
1745 twopass->gf_group_error_left = (int64_t)(gf_group_err - mod_frame_err);
1746 } else if (cpi->common.frame_type != KEY_FRAME) {
1747 twopass->gf_group_error_left = (int64_t)(gf_group_err
1748 - gf_first_frame_err);
1749 } else {
1750 twopass->gf_group_error_left = (int64_t)gf_group_err;
1751 }
1752
1753 // This condition could fail if there are two kfs very close together
1754 // despite MIN_GF_INTERVAL and would cause a divide by 0 in the
1755 // calculation of alt_extra_bits.
1756 if (rc->baseline_gf_interval >= 3) {
1757 const int boost = rc->source_alt_ref_pending ? b_boost : rc->gfu_boost;
1758
1759 if (boost >= 150) {
1760 const int pct_extra = MIN(20, (boost - 100) / 50);
1761 const int alt_extra_bits = (int)((
1762 MAX(twopass->gf_group_bits - twopass->gf_bits, 0) *
1763 pct_extra) / 100);
1764 twopass->gf_group_bits -= alt_extra_bits;
1765 }
1766 }
1767 }
1768
1769 if (cpi->common.frame_type != KEY_FRAME) {
1770 FIRSTPASS_STATS sectionstats;
1771
1772 zero_stats(§ionstats);
1773 reset_fpf_position(twopass, start_pos);
1774
1775 for (i = 0; i < rc->baseline_gf_interval; ++i) {
1776 input_stats(twopass, &next_frame);
1777 accumulate_stats(§ionstats, &next_frame);
1778 }
1779
1780 avg_stats(§ionstats);
1781
1782 twopass->section_intra_rating = (int)
1783 (sectionstats.intra_error /
1784 DOUBLE_DIVIDE_CHECK(sectionstats.coded_error));
1785
1786 reset_fpf_position(twopass, start_pos);
1787 }
1788 }
1789
1790 // Allocate bits to a normal frame that is neither a gf an arf or a key frame.
assign_std_frame_bits(VP9_COMP * cpi,FIRSTPASS_STATS * this_frame)1791 static void assign_std_frame_bits(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
1792 int target_frame_size;
1793 double modified_err;
1794 double err_fraction;
1795 const int max_bits = frame_max_bits(cpi); // Max for a single frame.
1796
1797 // Calculate modified prediction error used in bit allocation.
1798 modified_err = calculate_modified_err(cpi, this_frame);
1799
1800 if (cpi->twopass.gf_group_error_left > 0)
1801 // What portion of the remaining GF group error is used by this frame.
1802 err_fraction = modified_err / cpi->twopass.gf_group_error_left;
1803 else
1804 err_fraction = 0.0;
1805
1806 // How many of those bits available for allocation should we give it?
1807 target_frame_size = (int)((double)cpi->twopass.gf_group_bits * err_fraction);
1808
1809 // Clip target size to 0 - max_bits (or cpi->twopass.gf_group_bits) at
1810 // the top end.
1811 target_frame_size = clamp(target_frame_size, 0,
1812 MIN(max_bits, (int)cpi->twopass.gf_group_bits));
1813
1814 // Adjust error and bits remaining.
1815 cpi->twopass.gf_group_error_left -= (int64_t)modified_err;
1816
1817 // Per frame bit target for this frame.
1818 vp9_rc_set_frame_target(cpi, target_frame_size);
1819 }
1820
test_candidate_kf(VP9_COMP * cpi,const FIRSTPASS_STATS * last_frame,const FIRSTPASS_STATS * this_frame,const FIRSTPASS_STATS * next_frame)1821 static int test_candidate_kf(VP9_COMP *cpi,
1822 const FIRSTPASS_STATS *last_frame,
1823 const FIRSTPASS_STATS *this_frame,
1824 const FIRSTPASS_STATS *next_frame) {
1825 int is_viable_kf = 0;
1826
1827 // Does the frame satisfy the primary criteria of a key frame?
1828 // If so, then examine how well it predicts subsequent frames.
1829 if ((this_frame->pcnt_second_ref < 0.10) &&
1830 (next_frame->pcnt_second_ref < 0.10) &&
1831 ((this_frame->pcnt_inter < 0.05) ||
1832 (((this_frame->pcnt_inter - this_frame->pcnt_neutral) < 0.35) &&
1833 ((this_frame->intra_error /
1834 DOUBLE_DIVIDE_CHECK(this_frame->coded_error)) < 2.5) &&
1835 ((fabs(last_frame->coded_error - this_frame->coded_error) /
1836 DOUBLE_DIVIDE_CHECK(this_frame->coded_error) > 0.40) ||
1837 (fabs(last_frame->intra_error - this_frame->intra_error) /
1838 DOUBLE_DIVIDE_CHECK(this_frame->intra_error) > 0.40) ||
1839 ((next_frame->intra_error /
1840 DOUBLE_DIVIDE_CHECK(next_frame->coded_error)) > 3.5))))) {
1841 int i;
1842 const FIRSTPASS_STATS *start_pos = cpi->twopass.stats_in;
1843 FIRSTPASS_STATS local_next_frame = *next_frame;
1844 double boost_score = 0.0;
1845 double old_boost_score = 0.0;
1846 double decay_accumulator = 1.0;
1847
1848 // Examine how well the key frame predicts subsequent frames.
1849 for (i = 0; i < 16; ++i) {
1850 double next_iiratio = (IIKFACTOR1 * local_next_frame.intra_error /
1851 DOUBLE_DIVIDE_CHECK(local_next_frame.coded_error));
1852
1853 if (next_iiratio > RMAX)
1854 next_iiratio = RMAX;
1855
1856 // Cumulative effect of decay in prediction quality.
1857 if (local_next_frame.pcnt_inter > 0.85)
1858 decay_accumulator *= local_next_frame.pcnt_inter;
1859 else
1860 decay_accumulator *= (0.85 + local_next_frame.pcnt_inter) / 2.0;
1861
1862 // Keep a running total.
1863 boost_score += (decay_accumulator * next_iiratio);
1864
1865 // Test various breakout clauses.
1866 if ((local_next_frame.pcnt_inter < 0.05) ||
1867 (next_iiratio < 1.5) ||
1868 (((local_next_frame.pcnt_inter -
1869 local_next_frame.pcnt_neutral) < 0.20) &&
1870 (next_iiratio < 3.0)) ||
1871 ((boost_score - old_boost_score) < 3.0) ||
1872 (local_next_frame.intra_error < 200)) {
1873 break;
1874 }
1875
1876 old_boost_score = boost_score;
1877
1878 // Get the next frame details
1879 if (EOF == input_stats(&cpi->twopass, &local_next_frame))
1880 break;
1881 }
1882
1883 // If there is tolerable prediction for at least the next 3 frames then
1884 // break out else discard this potential key frame and move on
1885 if (boost_score > 30.0 && (i > 3)) {
1886 is_viable_kf = 1;
1887 } else {
1888 // Reset the file position
1889 reset_fpf_position(&cpi->twopass, start_pos);
1890
1891 is_viable_kf = 0;
1892 }
1893 }
1894
1895 return is_viable_kf;
1896 }
1897
find_next_key_frame(VP9_COMP * cpi,FIRSTPASS_STATS * this_frame)1898 static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
1899 int i, j;
1900 RATE_CONTROL *const rc = &cpi->rc;
1901 struct twopass_rc *const twopass = &cpi->twopass;
1902 FIRSTPASS_STATS last_frame;
1903 const FIRSTPASS_STATS first_frame = *this_frame;
1904 FIRSTPASS_STATS next_frame;
1905 const FIRSTPASS_STATS *start_position = twopass->stats_in;
1906
1907 double decay_accumulator = 1.0;
1908 double zero_motion_accumulator = 1.0;
1909 double boost_score = 0;
1910 double loop_decay_rate;
1911
1912 double kf_mod_err = 0.0;
1913 double kf_group_err = 0.0;
1914 double recent_loop_decay[8] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
1915
1916 vp9_zero(next_frame);
1917
1918 cpi->common.frame_type = KEY_FRAME;
1919
1920 // Is this a forced key frame by interval.
1921 rc->this_key_frame_forced = rc->next_key_frame_forced;
1922
1923 // Clear the alt ref active flag as this can never be active on a key frame.
1924 rc->source_alt_ref_active = 0;
1925
1926 // KF is always a GF so clear frames till next gf counter.
1927 rc->frames_till_gf_update_due = 0;
1928
1929 rc->frames_to_key = 1;
1930
1931 twopass->kf_group_bits = 0; // Total bits available to kf group
1932 twopass->kf_group_error_left = 0; // Group modified error score.
1933
1934 kf_mod_err = calculate_modified_err(cpi, this_frame);
1935
1936 // Find the next keyframe.
1937 i = 0;
1938 while (twopass->stats_in < twopass->stats_in_end) {
1939 // Accumulate kf group error.
1940 kf_group_err += calculate_modified_err(cpi, this_frame);
1941
1942 // Load the next frame's stats.
1943 last_frame = *this_frame;
1944 input_stats(twopass, this_frame);
1945
1946 // Provided that we are not at the end of the file...
1947 if (cpi->oxcf.auto_key &&
1948 lookup_next_frame_stats(twopass, &next_frame) != EOF) {
1949 // Check for a scene cut.
1950 if (test_candidate_kf(cpi, &last_frame, this_frame, &next_frame))
1951 break;
1952
1953 // How fast is the prediction quality decaying?
1954 loop_decay_rate = get_prediction_decay_rate(&cpi->common, &next_frame);
1955
1956 // We want to know something about the recent past... rather than
1957 // as used elsewhere where we are concerned with decay in prediction
1958 // quality since the last GF or KF.
1959 recent_loop_decay[i % 8] = loop_decay_rate;
1960 decay_accumulator = 1.0;
1961 for (j = 0; j < 8; ++j)
1962 decay_accumulator *= recent_loop_decay[j];
1963
1964 // Special check for transition or high motion followed by a
1965 // static scene.
1966 if (detect_transition_to_still(cpi, i, cpi->key_frame_frequency - i,
1967 loop_decay_rate, decay_accumulator))
1968 break;
1969
1970 // Step on to the next frame.
1971 ++rc->frames_to_key;
1972
1973 // If we don't have a real key frame within the next two
1974 // key_frame_frequency intervals then break out of the loop.
1975 if (rc->frames_to_key >= 2 * (int)cpi->key_frame_frequency)
1976 break;
1977 } else {
1978 ++rc->frames_to_key;
1979 }
1980 ++i;
1981 }
1982
1983 // If there is a max kf interval set by the user we must obey it.
1984 // We already breakout of the loop above at 2x max.
1985 // This code centers the extra kf if the actual natural interval
1986 // is between 1x and 2x.
1987 if (cpi->oxcf.auto_key &&
1988 rc->frames_to_key > (int)cpi->key_frame_frequency) {
1989 FIRSTPASS_STATS tmp_frame = first_frame;
1990
1991 rc->frames_to_key /= 2;
1992
1993 // Reset to the start of the group.
1994 reset_fpf_position(twopass, start_position);
1995
1996 kf_group_err = 0;
1997
1998 // Rescan to get the correct error data for the forced kf group.
1999 for (i = 0; i < rc->frames_to_key; ++i) {
2000 kf_group_err += calculate_modified_err(cpi, &tmp_frame);
2001 input_stats(twopass, &tmp_frame);
2002 }
2003 rc->next_key_frame_forced = 1;
2004 } else if (twopass->stats_in == twopass->stats_in_end) {
2005 rc->next_key_frame_forced = 1;
2006 } else {
2007 rc->next_key_frame_forced = 0;
2008 }
2009
2010 // Special case for the last key frame of the file.
2011 if (twopass->stats_in >= twopass->stats_in_end) {
2012 // Accumulate kf group error.
2013 kf_group_err += calculate_modified_err(cpi, this_frame);
2014 }
2015
2016 // Calculate the number of bits that should be assigned to the kf group.
2017 if (twopass->bits_left > 0 && twopass->modified_error_left > 0.0) {
2018 // Maximum number of bits for a single normal frame (not key frame).
2019 const int max_bits = frame_max_bits(cpi);
2020
2021 // Maximum number of bits allocated to the key frame group.
2022 int64_t max_grp_bits;
2023
2024 // Default allocation based on bits left and relative
2025 // complexity of the section.
2026 twopass->kf_group_bits = (int64_t)(twopass->bits_left *
2027 (kf_group_err / twopass->modified_error_left));
2028
2029 // Clip based on maximum per frame rate defined by the user.
2030 max_grp_bits = (int64_t)max_bits * (int64_t)rc->frames_to_key;
2031 if (twopass->kf_group_bits > max_grp_bits)
2032 twopass->kf_group_bits = max_grp_bits;
2033 } else {
2034 twopass->kf_group_bits = 0;
2035 }
2036 // Reset the first pass file position.
2037 reset_fpf_position(twopass, start_position);
2038
2039 // Determine how big to make this keyframe based on how well the subsequent
2040 // frames use inter blocks.
2041 decay_accumulator = 1.0;
2042 boost_score = 0.0;
2043
2044 // Scan through the kf group collating various stats.
2045 for (i = 0; i < rc->frames_to_key; ++i) {
2046 if (EOF == input_stats(twopass, &next_frame))
2047 break;
2048
2049 // Monitor for static sections.
2050 if ((next_frame.pcnt_inter - next_frame.pcnt_motion) <
2051 zero_motion_accumulator) {
2052 zero_motion_accumulator = (next_frame.pcnt_inter -
2053 next_frame.pcnt_motion);
2054 }
2055
2056 // For the first few frames collect data to decide kf boost.
2057 if (i <= (rc->max_gf_interval * 2)) {
2058 double r;
2059 if (next_frame.intra_error > twopass->kf_intra_err_min)
2060 r = (IIKFACTOR2 * next_frame.intra_error /
2061 DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
2062 else
2063 r = (IIKFACTOR2 * twopass->kf_intra_err_min /
2064 DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
2065
2066 if (r > RMAX)
2067 r = RMAX;
2068
2069 // How fast is prediction quality decaying.
2070 if (!detect_flash(twopass, 0)) {
2071 loop_decay_rate = get_prediction_decay_rate(&cpi->common, &next_frame);
2072 decay_accumulator *= loop_decay_rate;
2073 decay_accumulator = decay_accumulator < MIN_DECAY_FACTOR
2074 ? MIN_DECAY_FACTOR : decay_accumulator;
2075 }
2076
2077 boost_score += (decay_accumulator * r);
2078 }
2079 }
2080
2081 {
2082 FIRSTPASS_STATS sectionstats;
2083
2084 zero_stats(§ionstats);
2085 reset_fpf_position(twopass, start_position);
2086
2087 for (i = 0; i < rc->frames_to_key; ++i) {
2088 input_stats(twopass, &next_frame);
2089 accumulate_stats(§ionstats, &next_frame);
2090 }
2091
2092 avg_stats(§ionstats);
2093
2094 twopass->section_intra_rating = (int) (sectionstats.intra_error /
2095 DOUBLE_DIVIDE_CHECK(sectionstats.coded_error));
2096 }
2097
2098 // Reset the first pass file position.
2099 reset_fpf_position(twopass, start_position);
2100
2101 // Work out how many bits to allocate for the key frame itself.
2102 if (1) {
2103 int kf_boost = (int)boost_score;
2104 int allocation_chunks;
2105 int alt_kf_bits;
2106
2107 if (kf_boost < (rc->frames_to_key * 3))
2108 kf_boost = (rc->frames_to_key * 3);
2109
2110 if (kf_boost < MIN_KF_BOOST)
2111 kf_boost = MIN_KF_BOOST;
2112
2113 // Make a note of baseline boost and the zero motion
2114 // accumulator value for use elsewhere.
2115 rc->kf_boost = kf_boost;
2116 twopass->kf_zeromotion_pct = (int)(zero_motion_accumulator * 100.0);
2117
2118 // Key frame size depends on:
2119 // (1) the error score for the whole key frame group,
2120 // (2) the key frames' own error if this is smaller than the
2121 // average for the group (optional),
2122 // (3) insuring that the frame receives at least the allocation it would
2123 // have received based on its own error score vs the error score
2124 // remaining.
2125 // Special case:
2126 // If the sequence appears almost totally static we want to spend almost
2127 // all of the bits on the key frame.
2128 //
2129 // We use (cpi->rc.frames_to_key - 1) below because the key frame itself is
2130 // taken care of by kf_boost.
2131 if (zero_motion_accumulator >= 0.99) {
2132 allocation_chunks = ((rc->frames_to_key - 1) * 10) + kf_boost;
2133 } else {
2134 allocation_chunks = ((rc->frames_to_key - 1) * 100) + kf_boost;
2135 }
2136
2137 // Prevent overflow.
2138 if (kf_boost > 1028) {
2139 int divisor = kf_boost >> 10;
2140 kf_boost /= divisor;
2141 allocation_chunks /= divisor;
2142 }
2143
2144 twopass->kf_group_bits = (twopass->kf_group_bits < 0) ? 0
2145 : twopass->kf_group_bits;
2146
2147 // Calculate the number of bits to be spent on the key frame.
2148 twopass->kf_bits = (int)((double)kf_boost *
2149 ((double)twopass->kf_group_bits / allocation_chunks));
2150
2151 // If the key frame is actually easier than the average for the
2152 // kf group (which does sometimes happen, e.g. a blank intro frame)
2153 // then use an alternate calculation based on the kf error score
2154 // which should give a smaller key frame.
2155 if (kf_mod_err < kf_group_err / rc->frames_to_key) {
2156 double alt_kf_grp_bits = ((double)twopass->bits_left *
2157 (kf_mod_err * (double)rc->frames_to_key) /
2158 DOUBLE_DIVIDE_CHECK(twopass->modified_error_left));
2159
2160 alt_kf_bits = (int)((double)kf_boost *
2161 (alt_kf_grp_bits / (double)allocation_chunks));
2162
2163 if (twopass->kf_bits > alt_kf_bits)
2164 twopass->kf_bits = alt_kf_bits;
2165 } else {
2166 // Else if it is much harder than other frames in the group make sure
2167 // it at least receives an allocation in keeping with its relative
2168 // error score.
2169 alt_kf_bits = (int)((double)twopass->bits_left * (kf_mod_err /
2170 DOUBLE_DIVIDE_CHECK(twopass->modified_error_left)));
2171
2172 if (alt_kf_bits > twopass->kf_bits) {
2173 twopass->kf_bits = alt_kf_bits;
2174 }
2175 }
2176 twopass->kf_group_bits -= twopass->kf_bits;
2177 // Per frame bit target for this frame.
2178 vp9_rc_set_frame_target(cpi, twopass->kf_bits);
2179 }
2180
2181 // Note the total error score of the kf group minus the key frame itself.
2182 twopass->kf_group_error_left = (int)(kf_group_err - kf_mod_err);
2183
2184 // Adjust the count of total modified error left.
2185 // The count of bits left is adjusted elsewhere based on real coded frame
2186 // sizes.
2187 twopass->modified_error_left -= kf_group_err;
2188 }
2189
vp9_rc_get_first_pass_params(VP9_COMP * cpi)2190 void vp9_rc_get_first_pass_params(VP9_COMP *cpi) {
2191 VP9_COMMON *const cm = &cpi->common;
2192 if (!cpi->refresh_alt_ref_frame &&
2193 (cm->current_video_frame == 0 ||
2194 (cm->frame_flags & FRAMEFLAGS_KEY))) {
2195 cm->frame_type = KEY_FRAME;
2196 } else {
2197 cm->frame_type = INTER_FRAME;
2198 }
2199 // Do not use periodic key frames.
2200 cpi->rc.frames_to_key = INT_MAX;
2201 }
2202
vp9_rc_get_second_pass_params(VP9_COMP * cpi)2203 void vp9_rc_get_second_pass_params(VP9_COMP *cpi) {
2204 VP9_COMMON *const cm = &cpi->common;
2205 RATE_CONTROL *const rc = &cpi->rc;
2206 struct twopass_rc *const twopass = &cpi->twopass;
2207 int frames_left;
2208 FIRSTPASS_STATS this_frame;
2209 FIRSTPASS_STATS this_frame_copy;
2210
2211 double this_frame_intra_error;
2212 double this_frame_coded_error;
2213 int target;
2214 LAYER_CONTEXT *lc = NULL;
2215 int is_spatial_svc = (cpi->use_svc && cpi->svc.number_temporal_layers == 1);
2216
2217 if (is_spatial_svc) {
2218 lc = &cpi->svc.layer_context[cpi->svc.spatial_layer_id];
2219 frames_left = (int)(twopass->total_stats.count -
2220 lc->current_video_frame_in_layer);
2221 } else {
2222 frames_left = (int)(twopass->total_stats.count -
2223 cm->current_video_frame);
2224 }
2225
2226 if (!twopass->stats_in)
2227 return;
2228
2229 if (cpi->refresh_alt_ref_frame) {
2230 cm->frame_type = INTER_FRAME;
2231 vp9_rc_set_frame_target(cpi, twopass->gf_bits);
2232 return;
2233 }
2234
2235 vp9_clear_system_state();
2236
2237 if (is_spatial_svc && twopass->kf_intra_err_min == 0) {
2238 twopass->kf_intra_err_min = KF_MB_INTRA_MIN * cpi->common.MBs;
2239 twopass->gf_intra_err_min = GF_MB_INTRA_MIN * cpi->common.MBs;
2240 }
2241
2242 if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
2243 twopass->active_worst_quality = cpi->oxcf.cq_level;
2244 } else if (cm->current_video_frame == 0 ||
2245 (is_spatial_svc && lc->current_video_frame_in_layer == 0)) {
2246 // Special case code for first frame.
2247 const int section_target_bandwidth = (int)(twopass->bits_left /
2248 frames_left);
2249 const int tmp_q = vp9_twopass_worst_quality(cpi, &twopass->total_left_stats,
2250 section_target_bandwidth);
2251 twopass->active_worst_quality = tmp_q;
2252 rc->ni_av_qi = tmp_q;
2253 rc->avg_q = vp9_convert_qindex_to_q(tmp_q);
2254 }
2255 vp9_zero(this_frame);
2256 if (EOF == input_stats(twopass, &this_frame))
2257 return;
2258
2259 this_frame_intra_error = this_frame.intra_error;
2260 this_frame_coded_error = this_frame.coded_error;
2261
2262 // Keyframe and section processing.
2263 if (rc->frames_to_key == 0 ||
2264 (cm->frame_flags & FRAMEFLAGS_KEY)) {
2265 // Define next KF group and assign bits to it.
2266 this_frame_copy = this_frame;
2267 find_next_key_frame(cpi, &this_frame_copy);
2268 // Don't place key frame in any enhancement layers in spatial svc
2269 if (cpi->use_svc && cpi->svc.number_temporal_layers == 1 &&
2270 cpi->svc.spatial_layer_id > 0) {
2271 cm->frame_type = INTER_FRAME;
2272 }
2273 } else {
2274 cm->frame_type = INTER_FRAME;
2275 }
2276
2277 // Is this frame a GF / ARF? (Note: a key frame is always also a GF).
2278 if (rc->frames_till_gf_update_due == 0) {
2279 // Define next gf group and assign bits to it.
2280 this_frame_copy = this_frame;
2281
2282 #if CONFIG_MULTIPLE_ARF
2283 if (cpi->multi_arf_enabled) {
2284 define_fixed_arf_period(cpi);
2285 } else {
2286 #endif
2287 define_gf_group(cpi, &this_frame_copy);
2288 #if CONFIG_MULTIPLE_ARF
2289 }
2290 #endif
2291
2292 if (twopass->gf_zeromotion_pct > 995) {
2293 // As long as max_thresh for encode breakout is small enough, it is ok
2294 // to enable it for show frame, i.e. set allow_encode_breakout to
2295 // ENCODE_BREAKOUT_LIMITED.
2296 if (!cm->show_frame)
2297 cpi->allow_encode_breakout = ENCODE_BREAKOUT_DISABLED;
2298 else
2299 cpi->allow_encode_breakout = ENCODE_BREAKOUT_LIMITED;
2300 }
2301
2302 rc->frames_till_gf_update_due = rc->baseline_gf_interval;
2303 cpi->refresh_golden_frame = 1;
2304 } else {
2305 // Otherwise this is an ordinary frame.
2306 // Assign bits from those allocated to the GF group.
2307 this_frame_copy = this_frame;
2308 assign_std_frame_bits(cpi, &this_frame_copy);
2309 }
2310
2311 // Keep a globally available copy of this and the next frame's iiratio.
2312 twopass->this_iiratio = (int)(this_frame_intra_error /
2313 DOUBLE_DIVIDE_CHECK(this_frame_coded_error));
2314 {
2315 FIRSTPASS_STATS next_frame;
2316 if (lookup_next_frame_stats(twopass, &next_frame) != EOF) {
2317 twopass->next_iiratio = (int)(next_frame.intra_error /
2318 DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
2319 }
2320 }
2321
2322 if (cpi->common.frame_type == KEY_FRAME)
2323 target = vp9_rc_clamp_iframe_target_size(cpi, rc->this_frame_target);
2324 else
2325 target = vp9_rc_clamp_pframe_target_size(cpi, rc->this_frame_target);
2326 vp9_rc_set_frame_target(cpi, target);
2327
2328 // Update the total stats remaining structure.
2329 subtract_stats(&twopass->total_left_stats, &this_frame);
2330 }
2331
vp9_twopass_postencode_update(VP9_COMP * cpi)2332 void vp9_twopass_postencode_update(VP9_COMP *cpi) {
2333 const uint64_t bits_used = cpi->rc.projected_frame_size;
2334 cpi->twopass.bits_left -= bits_used;
2335 cpi->twopass.bits_left = MAX(cpi->twopass.bits_left, 0);
2336 // Update bits left to the kf and gf groups to account for overshoot or
2337 // undershoot on these frames.
2338 if (cpi->common.frame_type == KEY_FRAME) {
2339 // For key frames kf_group_bits already had the target bits subtracted out.
2340 // So now update to the correct value based on the actual bits used.
2341 cpi->twopass.kf_group_bits += cpi->rc.this_frame_target - bits_used;
2342 } else {
2343 cpi->twopass.kf_group_bits -= bits_used;
2344 cpi->twopass.gf_group_bits -= bits_used;
2345 cpi->twopass.gf_group_bits = MAX(cpi->twopass.gf_group_bits, 0);
2346 }
2347 cpi->twopass.kf_group_bits = MAX(cpi->twopass.kf_group_bits, 0);
2348 }
2349