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