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_dsp_rtcd.h"
16 #include "./vpx_scale_rtcd.h"
17 
18 #include "vpx_dsp/vpx_dsp_common.h"
19 #include "vpx_mem/vpx_mem.h"
20 #include "vpx_ports/mem.h"
21 #include "vpx_ports/system_state.h"
22 #include "vpx_scale/vpx_scale.h"
23 #include "vpx_scale/yv12config.h"
24 
25 #include "vp9/common/vp9_entropymv.h"
26 #include "vp9/common/vp9_quant_common.h"
27 #include "vp9/common/vp9_reconinter.h"  // vp9_setup_dst_planes()
28 #include "vp9/encoder/vp9_aq_variance.h"
29 #include "vp9/encoder/vp9_block.h"
30 #include "vp9/encoder/vp9_encodeframe.h"
31 #include "vp9/encoder/vp9_encodemb.h"
32 #include "vp9/encoder/vp9_encodemv.h"
33 #include "vp9/encoder/vp9_encoder.h"
34 #include "vp9/encoder/vp9_extend.h"
35 #include "vp9/encoder/vp9_firstpass.h"
36 #include "vp9/encoder/vp9_mcomp.h"
37 #include "vp9/encoder/vp9_quantize.h"
38 #include "vp9/encoder/vp9_rd.h"
39 #include "vpx_dsp/variance.h"
40 
41 #define OUTPUT_FPF          0
42 #define ARF_STATS_OUTPUT    0
43 
44 #define GROUP_ADAPTIVE_MAXQ 1
45 
46 #define BOOST_BREAKOUT      12.5
47 #define BOOST_FACTOR        12.5
48 #define ERR_DIVISOR         128.0
49 #define FACTOR_PT_LOW       0.70
50 #define FACTOR_PT_HIGH      0.90
51 #define FIRST_PASS_Q        10.0
52 #define GF_MAX_BOOST        96.0
53 #define INTRA_MODE_PENALTY  1024
54 #define KF_MAX_BOOST        128.0
55 #define MIN_ARF_GF_BOOST    240
56 #define MIN_DECAY_FACTOR    0.01
57 #define MIN_KF_BOOST        300
58 #define NEW_MV_MODE_PENALTY 32
59 #define SVC_FACTOR_PT_LOW   0.45
60 #define DARK_THRESH         64
61 #define DEFAULT_GRP_WEIGHT  1.0
62 #define RC_FACTOR_MIN       0.75
63 #define RC_FACTOR_MAX       1.75
64 
65 
66 #define NCOUNT_INTRA_THRESH 8192
67 #define NCOUNT_INTRA_FACTOR 3
68 #define NCOUNT_FRAME_II_THRESH 5.0
69 
70 #define DOUBLE_DIVIDE_CHECK(x) ((x) < 0 ? (x) - 0.000001 : (x) + 0.000001)
71 
72 #if ARF_STATS_OUTPUT
73 unsigned int arf_count = 0;
74 #endif
75 
76 // Resets the first pass file to the given position using a relative seek from
77 // the current position.
reset_fpf_position(TWO_PASS * p,const FIRSTPASS_STATS * position)78 static void reset_fpf_position(TWO_PASS *p,
79                                const FIRSTPASS_STATS *position) {
80   p->stats_in = position;
81 }
82 
83 // Read frame stats at an offset from the current position.
read_frame_stats(const TWO_PASS * p,int offset)84 static const FIRSTPASS_STATS *read_frame_stats(const TWO_PASS *p, int offset) {
85   if ((offset >= 0 && p->stats_in + offset >= p->stats_in_end) ||
86       (offset < 0 && p->stats_in + offset < p->stats_in_start)) {
87     return NULL;
88   }
89 
90   return &p->stats_in[offset];
91 }
92 
input_stats(TWO_PASS * p,FIRSTPASS_STATS * fps)93 static int input_stats(TWO_PASS *p, FIRSTPASS_STATS *fps) {
94   if (p->stats_in >= p->stats_in_end)
95     return EOF;
96 
97   *fps = *p->stats_in;
98   ++p->stats_in;
99   return 1;
100 }
101 
output_stats(FIRSTPASS_STATS * stats,struct vpx_codec_pkt_list * pktlist)102 static void output_stats(FIRSTPASS_STATS *stats,
103                          struct vpx_codec_pkt_list *pktlist) {
104   struct vpx_codec_cx_pkt pkt;
105   pkt.kind = VPX_CODEC_STATS_PKT;
106   pkt.data.twopass_stats.buf = stats;
107   pkt.data.twopass_stats.sz = sizeof(FIRSTPASS_STATS);
108   vpx_codec_pkt_list_add(pktlist, &pkt);
109 
110 // TEMP debug code
111 #if OUTPUT_FPF
112   {
113     FILE *fpfile;
114     fpfile = fopen("firstpass.stt", "a");
115 
116     fprintf(fpfile, "%12.0lf %12.4lf %12.0lf %12.0lf %12.0lf %12.4lf %12.4lf"
117             "%12.4lf %12.4lf %12.4lf %12.4lf %12.4lf %12.4lf %12.4lf %12.4lf"
118             "%12.4lf %12.4lf %12.0lf %12.0lf %12.0lf %12.4lf\n",
119             stats->frame,
120             stats->weight,
121             stats->intra_error,
122             stats->coded_error,
123             stats->sr_coded_error,
124             stats->pcnt_inter,
125             stats->pcnt_motion,
126             stats->pcnt_second_ref,
127             stats->pcnt_neutral,
128             stats->intra_skip_pct,
129             stats->inactive_zone_rows,
130             stats->inactive_zone_cols,
131             stats->MVr,
132             stats->mvr_abs,
133             stats->MVc,
134             stats->mvc_abs,
135             stats->MVrv,
136             stats->MVcv,
137             stats->mv_in_out_count,
138             stats->new_mv_count,
139             stats->count,
140             stats->duration);
141     fclose(fpfile);
142   }
143 #endif
144 }
145 
146 #if CONFIG_FP_MB_STATS
output_fpmb_stats(uint8_t * this_frame_mb_stats,VP9_COMMON * cm,struct vpx_codec_pkt_list * pktlist)147 static void output_fpmb_stats(uint8_t *this_frame_mb_stats, VP9_COMMON *cm,
148                          struct vpx_codec_pkt_list *pktlist) {
149   struct vpx_codec_cx_pkt pkt;
150   pkt.kind = VPX_CODEC_FPMB_STATS_PKT;
151   pkt.data.firstpass_mb_stats.buf = this_frame_mb_stats;
152   pkt.data.firstpass_mb_stats.sz = cm->initial_mbs * sizeof(uint8_t);
153   vpx_codec_pkt_list_add(pktlist, &pkt);
154 }
155 #endif
156 
zero_stats(FIRSTPASS_STATS * section)157 static void zero_stats(FIRSTPASS_STATS *section) {
158   section->frame = 0.0;
159   section->weight = 0.0;
160   section->intra_error = 0.0;
161   section->coded_error = 0.0;
162   section->sr_coded_error = 0.0;
163   section->pcnt_inter  = 0.0;
164   section->pcnt_motion  = 0.0;
165   section->pcnt_second_ref = 0.0;
166   section->pcnt_neutral = 0.0;
167   section->intra_skip_pct = 0.0;
168   section->inactive_zone_rows = 0.0;
169   section->inactive_zone_cols = 0.0;
170   section->MVr = 0.0;
171   section->mvr_abs     = 0.0;
172   section->MVc        = 0.0;
173   section->mvc_abs     = 0.0;
174   section->MVrv       = 0.0;
175   section->MVcv       = 0.0;
176   section->mv_in_out_count  = 0.0;
177   section->new_mv_count = 0.0;
178   section->count      = 0.0;
179   section->duration   = 1.0;
180   section->spatial_layer_id = 0;
181 }
182 
accumulate_stats(FIRSTPASS_STATS * section,const FIRSTPASS_STATS * frame)183 static void accumulate_stats(FIRSTPASS_STATS *section,
184                              const FIRSTPASS_STATS *frame) {
185   section->frame += frame->frame;
186   section->weight += frame->weight;
187   section->spatial_layer_id = frame->spatial_layer_id;
188   section->intra_error += frame->intra_error;
189   section->coded_error += frame->coded_error;
190   section->sr_coded_error += frame->sr_coded_error;
191   section->pcnt_inter  += frame->pcnt_inter;
192   section->pcnt_motion += frame->pcnt_motion;
193   section->pcnt_second_ref += frame->pcnt_second_ref;
194   section->pcnt_neutral += frame->pcnt_neutral;
195   section->intra_skip_pct += frame->intra_skip_pct;
196   section->inactive_zone_rows += frame->inactive_zone_rows;
197   section->inactive_zone_cols += frame->inactive_zone_cols;
198   section->MVr += frame->MVr;
199   section->mvr_abs     += frame->mvr_abs;
200   section->MVc        += frame->MVc;
201   section->mvc_abs     += frame->mvc_abs;
202   section->MVrv       += frame->MVrv;
203   section->MVcv       += frame->MVcv;
204   section->mv_in_out_count  += frame->mv_in_out_count;
205   section->new_mv_count += frame->new_mv_count;
206   section->count      += frame->count;
207   section->duration   += frame->duration;
208 }
209 
subtract_stats(FIRSTPASS_STATS * section,const FIRSTPASS_STATS * frame)210 static void subtract_stats(FIRSTPASS_STATS *section,
211                            const FIRSTPASS_STATS *frame) {
212   section->frame -= frame->frame;
213   section->weight -= frame->weight;
214   section->intra_error -= frame->intra_error;
215   section->coded_error -= frame->coded_error;
216   section->sr_coded_error -= frame->sr_coded_error;
217   section->pcnt_inter  -= frame->pcnt_inter;
218   section->pcnt_motion -= frame->pcnt_motion;
219   section->pcnt_second_ref -= frame->pcnt_second_ref;
220   section->pcnt_neutral -= frame->pcnt_neutral;
221   section->intra_skip_pct -= frame->intra_skip_pct;
222   section->inactive_zone_rows -= frame->inactive_zone_rows;
223   section->inactive_zone_cols -= frame->inactive_zone_cols;
224   section->MVr -= frame->MVr;
225   section->mvr_abs     -= frame->mvr_abs;
226   section->MVc        -= frame->MVc;
227   section->mvc_abs     -= frame->mvc_abs;
228   section->MVrv       -= frame->MVrv;
229   section->MVcv       -= frame->MVcv;
230   section->mv_in_out_count  -= frame->mv_in_out_count;
231   section->new_mv_count -= frame->new_mv_count;
232   section->count      -= frame->count;
233   section->duration   -= frame->duration;
234 }
235 
236 // Calculate an active area of the image that discounts formatting
237 // bars and partially discounts other 0 energy areas.
238 #define MIN_ACTIVE_AREA 0.5
239 #define MAX_ACTIVE_AREA 1.0
calculate_active_area(const VP9_COMP * cpi,const FIRSTPASS_STATS * this_frame)240 static double calculate_active_area(const VP9_COMP *cpi,
241                                     const FIRSTPASS_STATS *this_frame) {
242   double active_pct;
243 
244   active_pct = 1.0 -
245     ((this_frame->intra_skip_pct / 2) +
246      ((this_frame->inactive_zone_rows * 2) / (double)cpi->common.mb_rows));
247   return fclamp(active_pct, MIN_ACTIVE_AREA, MAX_ACTIVE_AREA);
248 }
249 
250 // Calculate a modified Error used in distributing bits between easier and
251 // harder frames.
252 #define ACT_AREA_CORRECTION 0.5
calculate_modified_err(const VP9_COMP * cpi,const TWO_PASS * twopass,const VP9EncoderConfig * oxcf,const FIRSTPASS_STATS * this_frame)253 static double calculate_modified_err(const VP9_COMP *cpi,
254                                      const TWO_PASS *twopass,
255                                      const VP9EncoderConfig *oxcf,
256                                      const FIRSTPASS_STATS *this_frame) {
257   const FIRSTPASS_STATS *const stats = &twopass->total_stats;
258   const double av_weight = stats->weight / stats->count;
259   const double av_err = (stats->coded_error * av_weight) / stats->count;
260   double modified_error =
261     av_err * pow(this_frame->coded_error * this_frame->weight /
262                  DOUBLE_DIVIDE_CHECK(av_err), oxcf->two_pass_vbrbias / 100.0);
263 
264   // Correction for active area. Frames with a reduced active area
265   // (eg due to formatting bars) have a higher error per mb for the
266   // remaining active MBs. The correction here assumes that coding
267   // 0.5N blocks of complexity 2X is a little easier than coding N
268   // blocks of complexity X.
269   modified_error *=
270     pow(calculate_active_area(cpi, this_frame), ACT_AREA_CORRECTION);
271 
272   return fclamp(modified_error,
273                 twopass->modified_error_min, twopass->modified_error_max);
274 }
275 
276 // This function returns the maximum target rate per frame.
frame_max_bits(const RATE_CONTROL * rc,const VP9EncoderConfig * oxcf)277 static int frame_max_bits(const RATE_CONTROL *rc,
278                           const VP9EncoderConfig *oxcf) {
279   int64_t max_bits = ((int64_t)rc->avg_frame_bandwidth *
280                           (int64_t)oxcf->two_pass_vbrmax_section) / 100;
281   if (max_bits < 0)
282     max_bits = 0;
283   else if (max_bits > rc->max_frame_bandwidth)
284     max_bits = rc->max_frame_bandwidth;
285 
286   return (int)max_bits;
287 }
288 
vp9_init_first_pass(VP9_COMP * cpi)289 void vp9_init_first_pass(VP9_COMP *cpi) {
290   zero_stats(&cpi->twopass.total_stats);
291 }
292 
vp9_end_first_pass(VP9_COMP * cpi)293 void vp9_end_first_pass(VP9_COMP *cpi) {
294   if (is_two_pass_svc(cpi)) {
295     int i;
296     for (i = 0; i < cpi->svc.number_spatial_layers; ++i) {
297       output_stats(&cpi->svc.layer_context[i].twopass.total_stats,
298                    cpi->output_pkt_list);
299     }
300   } else {
301     output_stats(&cpi->twopass.total_stats, cpi->output_pkt_list);
302   }
303 }
304 
get_block_variance_fn(BLOCK_SIZE bsize)305 static vpx_variance_fn_t get_block_variance_fn(BLOCK_SIZE bsize) {
306   switch (bsize) {
307     case BLOCK_8X8:
308       return vpx_mse8x8;
309     case BLOCK_16X8:
310       return vpx_mse16x8;
311     case BLOCK_8X16:
312       return vpx_mse8x16;
313     default:
314       return vpx_mse16x16;
315   }
316 }
317 
get_prediction_error(BLOCK_SIZE bsize,const struct buf_2d * src,const struct buf_2d * ref)318 static unsigned int get_prediction_error(BLOCK_SIZE bsize,
319                                          const struct buf_2d *src,
320                                          const struct buf_2d *ref) {
321   unsigned int sse;
322   const vpx_variance_fn_t fn = get_block_variance_fn(bsize);
323   fn(src->buf, src->stride, ref->buf, ref->stride, &sse);
324   return sse;
325 }
326 
327 #if CONFIG_VP9_HIGHBITDEPTH
highbd_get_block_variance_fn(BLOCK_SIZE bsize,int bd)328 static vpx_variance_fn_t highbd_get_block_variance_fn(BLOCK_SIZE bsize,
329                                                       int bd) {
330   switch (bd) {
331     default:
332       switch (bsize) {
333         case BLOCK_8X8:
334           return vpx_highbd_8_mse8x8;
335         case BLOCK_16X8:
336           return vpx_highbd_8_mse16x8;
337         case BLOCK_8X16:
338           return vpx_highbd_8_mse8x16;
339         default:
340           return vpx_highbd_8_mse16x16;
341       }
342       break;
343     case 10:
344       switch (bsize) {
345         case BLOCK_8X8:
346           return vpx_highbd_10_mse8x8;
347         case BLOCK_16X8:
348           return vpx_highbd_10_mse16x8;
349         case BLOCK_8X16:
350           return vpx_highbd_10_mse8x16;
351         default:
352           return vpx_highbd_10_mse16x16;
353       }
354       break;
355     case 12:
356       switch (bsize) {
357         case BLOCK_8X8:
358           return vpx_highbd_12_mse8x8;
359         case BLOCK_16X8:
360           return vpx_highbd_12_mse16x8;
361         case BLOCK_8X16:
362           return vpx_highbd_12_mse8x16;
363         default:
364           return vpx_highbd_12_mse16x16;
365       }
366       break;
367   }
368 }
369 
highbd_get_prediction_error(BLOCK_SIZE bsize,const struct buf_2d * src,const struct buf_2d * ref,int bd)370 static unsigned int highbd_get_prediction_error(BLOCK_SIZE bsize,
371                                                 const struct buf_2d *src,
372                                                 const struct buf_2d *ref,
373                                                 int bd) {
374   unsigned int sse;
375   const vpx_variance_fn_t fn = highbd_get_block_variance_fn(bsize, bd);
376   fn(src->buf, src->stride, ref->buf, ref->stride, &sse);
377   return sse;
378 }
379 #endif  // CONFIG_VP9_HIGHBITDEPTH
380 
381 // Refine the motion search range according to the frame dimension
382 // for first pass test.
get_search_range(const VP9_COMP * cpi)383 static int get_search_range(const VP9_COMP *cpi) {
384   int sr = 0;
385   const int dim = VPXMIN(cpi->initial_width, cpi->initial_height);
386 
387   while ((dim << sr) < MAX_FULL_PEL_VAL)
388     ++sr;
389   return sr;
390 }
391 
first_pass_motion_search(VP9_COMP * cpi,MACROBLOCK * x,const MV * ref_mv,MV * best_mv,int * best_motion_err)392 static void first_pass_motion_search(VP9_COMP *cpi, MACROBLOCK *x,
393                                      const MV *ref_mv, MV *best_mv,
394                                      int *best_motion_err) {
395   MACROBLOCKD *const xd = &x->e_mbd;
396   MV tmp_mv = {0, 0};
397   MV ref_mv_full = {ref_mv->row >> 3, ref_mv->col >> 3};
398   int num00, tmp_err, n;
399   const BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type;
400   vp9_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[bsize];
401   const int new_mv_mode_penalty = NEW_MV_MODE_PENALTY;
402 
403   int step_param = 3;
404   int further_steps = (MAX_MVSEARCH_STEPS - 1) - step_param;
405   const int sr = get_search_range(cpi);
406   step_param += sr;
407   further_steps -= sr;
408 
409   // Override the default variance function to use MSE.
410   v_fn_ptr.vf = get_block_variance_fn(bsize);
411 #if CONFIG_VP9_HIGHBITDEPTH
412   if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
413     v_fn_ptr.vf = highbd_get_block_variance_fn(bsize, xd->bd);
414   }
415 #endif  // CONFIG_VP9_HIGHBITDEPTH
416 
417   // Center the initial step/diamond search on best mv.
418   tmp_err = cpi->diamond_search_sad(x, &cpi->ss_cfg, &ref_mv_full, &tmp_mv,
419                                     step_param,
420                                     x->sadperbit16, &num00, &v_fn_ptr, ref_mv);
421   if (tmp_err < INT_MAX)
422     tmp_err = vp9_get_mvpred_var(x, &tmp_mv, ref_mv, &v_fn_ptr, 1);
423   if (tmp_err < INT_MAX - new_mv_mode_penalty)
424     tmp_err += new_mv_mode_penalty;
425 
426   if (tmp_err < *best_motion_err) {
427     *best_motion_err = tmp_err;
428     *best_mv = tmp_mv;
429   }
430 
431   // Carry out further step/diamond searches as necessary.
432   n = num00;
433   num00 = 0;
434 
435   while (n < further_steps) {
436     ++n;
437 
438     if (num00) {
439       --num00;
440     } else {
441       tmp_err = cpi->diamond_search_sad(x, &cpi->ss_cfg, &ref_mv_full, &tmp_mv,
442                                         step_param + n, x->sadperbit16,
443                                         &num00, &v_fn_ptr, ref_mv);
444       if (tmp_err < INT_MAX)
445         tmp_err = vp9_get_mvpred_var(x, &tmp_mv, ref_mv, &v_fn_ptr, 1);
446       if (tmp_err < INT_MAX - new_mv_mode_penalty)
447         tmp_err += new_mv_mode_penalty;
448 
449       if (tmp_err < *best_motion_err) {
450         *best_motion_err = tmp_err;
451         *best_mv = tmp_mv;
452       }
453     }
454   }
455 }
456 
get_bsize(const VP9_COMMON * cm,int mb_row,int mb_col)457 static BLOCK_SIZE get_bsize(const VP9_COMMON *cm, int mb_row, int mb_col) {
458   if (2 * mb_col + 1 < cm->mi_cols) {
459     return 2 * mb_row + 1 < cm->mi_rows ? BLOCK_16X16
460                                         : BLOCK_16X8;
461   } else {
462     return 2 * mb_row + 1 < cm->mi_rows ? BLOCK_8X16
463                                         : BLOCK_8X8;
464   }
465 }
466 
find_fp_qindex(vpx_bit_depth_t bit_depth)467 static int find_fp_qindex(vpx_bit_depth_t bit_depth) {
468   int i;
469 
470   for (i = 0; i < QINDEX_RANGE; ++i)
471     if (vp9_convert_qindex_to_q(i, bit_depth) >= FIRST_PASS_Q)
472       break;
473 
474   if (i == QINDEX_RANGE)
475     i--;
476 
477   return i;
478 }
479 
set_first_pass_params(VP9_COMP * cpi)480 static void set_first_pass_params(VP9_COMP *cpi) {
481   VP9_COMMON *const cm = &cpi->common;
482   if (!cpi->refresh_alt_ref_frame &&
483       (cm->current_video_frame == 0 ||
484        (cpi->frame_flags & FRAMEFLAGS_KEY))) {
485     cm->frame_type = KEY_FRAME;
486   } else {
487     cm->frame_type = INTER_FRAME;
488   }
489   // Do not use periodic key frames.
490   cpi->rc.frames_to_key = INT_MAX;
491 }
492 
493 #define UL_INTRA_THRESH 50
494 #define INVALID_ROW -1
vp9_first_pass(VP9_COMP * cpi,const struct lookahead_entry * source)495 void vp9_first_pass(VP9_COMP *cpi, const struct lookahead_entry *source) {
496   int mb_row, mb_col;
497   MACROBLOCK *const x = &cpi->td.mb;
498   VP9_COMMON *const cm = &cpi->common;
499   MACROBLOCKD *const xd = &x->e_mbd;
500   TileInfo tile;
501   struct macroblock_plane *const p = x->plane;
502   struct macroblockd_plane *const pd = xd->plane;
503   const PICK_MODE_CONTEXT *ctx = &cpi->td.pc_root->none;
504   int i;
505 
506   int recon_yoffset, recon_uvoffset;
507   int64_t intra_error = 0;
508   int64_t coded_error = 0;
509   int64_t sr_coded_error = 0;
510 
511   int sum_mvr = 0, sum_mvc = 0;
512   int sum_mvr_abs = 0, sum_mvc_abs = 0;
513   int64_t sum_mvrs = 0, sum_mvcs = 0;
514   int mvcount = 0;
515   int intercount = 0;
516   int second_ref_count = 0;
517   const int intrapenalty = INTRA_MODE_PENALTY;
518   double neutral_count;
519   int intra_skip_count = 0;
520   int image_data_start_row = INVALID_ROW;
521   int new_mv_count = 0;
522   int sum_in_vectors = 0;
523   MV lastmv = {0, 0};
524   TWO_PASS *twopass = &cpi->twopass;
525   const MV zero_mv = {0, 0};
526   int recon_y_stride, recon_uv_stride, uv_mb_height;
527 
528   YV12_BUFFER_CONFIG *const lst_yv12 = get_ref_frame_buffer(cpi, LAST_FRAME);
529   YV12_BUFFER_CONFIG *gld_yv12 = get_ref_frame_buffer(cpi, GOLDEN_FRAME);
530   YV12_BUFFER_CONFIG *const new_yv12 = get_frame_new_buffer(cm);
531   const YV12_BUFFER_CONFIG *first_ref_buf = lst_yv12;
532 
533   LAYER_CONTEXT *const lc = is_two_pass_svc(cpi) ?
534         &cpi->svc.layer_context[cpi->svc.spatial_layer_id] : NULL;
535   double intra_factor;
536   double brightness_factor;
537   BufferPool *const pool = cm->buffer_pool;
538 
539   // First pass code requires valid last and new frame buffers.
540   assert(new_yv12 != NULL);
541   assert((lc != NULL) || frame_is_intra_only(cm) || (lst_yv12 != NULL));
542 
543 #if CONFIG_FP_MB_STATS
544   if (cpi->use_fp_mb_stats) {
545     vp9_zero_array(cpi->twopass.frame_mb_stats_buf, cm->initial_mbs);
546   }
547 #endif
548 
549   vpx_clear_system_state();
550 
551   intra_factor = 0.0;
552   brightness_factor = 0.0;
553   neutral_count = 0.0;
554 
555   set_first_pass_params(cpi);
556   vp9_set_quantizer(cm, find_fp_qindex(cm->bit_depth));
557 
558   if (lc != NULL) {
559     twopass = &lc->twopass;
560 
561     cpi->lst_fb_idx = cpi->svc.spatial_layer_id;
562     cpi->ref_frame_flags = VP9_LAST_FLAG;
563 
564     if (cpi->svc.number_spatial_layers + cpi->svc.spatial_layer_id <
565         REF_FRAMES) {
566       cpi->gld_fb_idx =
567           cpi->svc.number_spatial_layers + cpi->svc.spatial_layer_id;
568       cpi->ref_frame_flags |= VP9_GOLD_FLAG;
569       cpi->refresh_golden_frame = (lc->current_video_frame_in_layer == 0);
570     } else {
571       cpi->refresh_golden_frame = 0;
572     }
573 
574     if (lc->current_video_frame_in_layer == 0)
575       cpi->ref_frame_flags = 0;
576 
577     vp9_scale_references(cpi);
578 
579     // Use either last frame or alt frame for motion search.
580     if (cpi->ref_frame_flags & VP9_LAST_FLAG) {
581       first_ref_buf = vp9_get_scaled_ref_frame(cpi, LAST_FRAME);
582       if (first_ref_buf == NULL)
583         first_ref_buf = get_ref_frame_buffer(cpi, LAST_FRAME);
584     }
585 
586     if (cpi->ref_frame_flags & VP9_GOLD_FLAG) {
587       gld_yv12 = vp9_get_scaled_ref_frame(cpi, GOLDEN_FRAME);
588       if (gld_yv12 == NULL) {
589         gld_yv12 = get_ref_frame_buffer(cpi, GOLDEN_FRAME);
590       }
591     } else {
592       gld_yv12 = NULL;
593     }
594 
595     set_ref_ptrs(cm, xd,
596                  (cpi->ref_frame_flags & VP9_LAST_FLAG) ? LAST_FRAME: NONE,
597                  (cpi->ref_frame_flags & VP9_GOLD_FLAG) ? GOLDEN_FRAME : NONE);
598 
599     cpi->Source = vp9_scale_if_required(cm, cpi->un_scaled_source,
600                                         &cpi->scaled_source, 0);
601   }
602 
603   vp9_setup_block_planes(&x->e_mbd, cm->subsampling_x, cm->subsampling_y);
604 
605   vp9_setup_src_planes(x, cpi->Source, 0, 0);
606   vp9_setup_dst_planes(xd->plane, new_yv12, 0, 0);
607 
608   if (!frame_is_intra_only(cm)) {
609     vp9_setup_pre_planes(xd, 0, first_ref_buf, 0, 0, NULL);
610   }
611 
612   xd->mi = cm->mi_grid_visible;
613   xd->mi[0] = cm->mi;
614 
615   vp9_frame_init_quantizer(cpi);
616 
617   for (i = 0; i < MAX_MB_PLANE; ++i) {
618     p[i].coeff = ctx->coeff_pbuf[i][1];
619     p[i].qcoeff = ctx->qcoeff_pbuf[i][1];
620     pd[i].dqcoeff = ctx->dqcoeff_pbuf[i][1];
621     p[i].eobs = ctx->eobs_pbuf[i][1];
622   }
623   x->skip_recode = 0;
624 
625   vp9_init_mv_probs(cm);
626   vp9_initialize_rd_consts(cpi);
627 
628   // Tiling is ignored in the first pass.
629   vp9_tile_init(&tile, cm, 0, 0);
630 
631   recon_y_stride = new_yv12->y_stride;
632   recon_uv_stride = new_yv12->uv_stride;
633   uv_mb_height = 16 >> (new_yv12->y_height > new_yv12->uv_height);
634 
635   for (mb_row = 0; mb_row < cm->mb_rows; ++mb_row) {
636     MV best_ref_mv = {0, 0};
637 
638     // Reset above block coeffs.
639     xd->up_available = (mb_row != 0);
640     recon_yoffset = (mb_row * recon_y_stride * 16);
641     recon_uvoffset = (mb_row * recon_uv_stride * uv_mb_height);
642 
643     // Set up limit values for motion vectors to prevent them extending
644     // outside the UMV borders.
645     x->mv_row_min = -((mb_row * 16) + BORDER_MV_PIXELS_B16);
646     x->mv_row_max = ((cm->mb_rows - 1 - mb_row) * 16)
647                     + BORDER_MV_PIXELS_B16;
648 
649     for (mb_col = 0; mb_col < cm->mb_cols; ++mb_col) {
650       int this_error;
651       const int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
652       const BLOCK_SIZE bsize = get_bsize(cm, mb_row, mb_col);
653       double log_intra;
654       int level_sample;
655 
656 #if CONFIG_FP_MB_STATS
657       const int mb_index = mb_row * cm->mb_cols + mb_col;
658 #endif
659 
660       vpx_clear_system_state();
661 
662       xd->plane[0].dst.buf = new_yv12->y_buffer + recon_yoffset;
663       xd->plane[1].dst.buf = new_yv12->u_buffer + recon_uvoffset;
664       xd->plane[2].dst.buf = new_yv12->v_buffer + recon_uvoffset;
665       xd->left_available = (mb_col != 0);
666       xd->mi[0]->mbmi.sb_type = bsize;
667       xd->mi[0]->mbmi.ref_frame[0] = INTRA_FRAME;
668       set_mi_row_col(xd, &tile,
669                      mb_row << 1, num_8x8_blocks_high_lookup[bsize],
670                      mb_col << 1, num_8x8_blocks_wide_lookup[bsize],
671                      cm->mi_rows, cm->mi_cols);
672 
673       // Do intra 16x16 prediction.
674       x->skip_encode = 0;
675       xd->mi[0]->mbmi.mode = DC_PRED;
676       xd->mi[0]->mbmi.tx_size = use_dc_pred ?
677          (bsize >= BLOCK_16X16 ? TX_16X16 : TX_8X8) : TX_4X4;
678       vp9_encode_intra_block_plane(x, bsize, 0);
679       this_error = vpx_get_mb_ss(x->plane[0].src_diff);
680 
681       // Keep a record of blocks that have almost no intra error residual
682       // (i.e. are in effect completely flat and untextured in the intra
683       // domain). In natural videos this is uncommon, but it is much more
684       // common in animations, graphics and screen content, so may be used
685       // as a signal to detect these types of content.
686       if (this_error < UL_INTRA_THRESH) {
687         ++intra_skip_count;
688       } else if ((mb_col > 0) && (image_data_start_row == INVALID_ROW)) {
689         image_data_start_row = mb_row;
690       }
691 
692 #if CONFIG_VP9_HIGHBITDEPTH
693       if (cm->use_highbitdepth) {
694         switch (cm->bit_depth) {
695           case VPX_BITS_8:
696             break;
697           case VPX_BITS_10:
698             this_error >>= 4;
699             break;
700           case VPX_BITS_12:
701             this_error >>= 8;
702             break;
703           default:
704             assert(0 && "cm->bit_depth should be VPX_BITS_8, "
705                         "VPX_BITS_10 or VPX_BITS_12");
706             return;
707         }
708       }
709 #endif  // CONFIG_VP9_HIGHBITDEPTH
710 
711       vpx_clear_system_state();
712       log_intra = log(this_error + 1.0);
713       if (log_intra < 10.0)
714         intra_factor += 1.0 + ((10.0 - log_intra) * 0.05);
715       else
716         intra_factor += 1.0;
717 
718 #if CONFIG_VP9_HIGHBITDEPTH
719       if (cm->use_highbitdepth)
720         level_sample = CONVERT_TO_SHORTPTR(x->plane[0].src.buf)[0];
721       else
722         level_sample = x->plane[0].src.buf[0];
723 #else
724       level_sample = x->plane[0].src.buf[0];
725 #endif
726       if ((level_sample < DARK_THRESH) && (log_intra < 9.0))
727         brightness_factor += 1.0 + (0.01 * (DARK_THRESH - level_sample));
728       else
729         brightness_factor += 1.0;
730 
731       // Intrapenalty below deals with situations where the intra and inter
732       // error scores are very low (e.g. a plain black frame).
733       // We do not have special cases in first pass for 0,0 and nearest etc so
734       // all inter modes carry an overhead cost estimate for the mv.
735       // When the error score is very low this causes us to pick all or lots of
736       // INTRA modes and throw lots of key frames.
737       // This penalty adds a cost matching that of a 0,0 mv to the intra case.
738       this_error += intrapenalty;
739 
740       // Accumulate the intra error.
741       intra_error += (int64_t)this_error;
742 
743 #if CONFIG_FP_MB_STATS
744       if (cpi->use_fp_mb_stats) {
745         // initialization
746         cpi->twopass.frame_mb_stats_buf[mb_index] = 0;
747       }
748 #endif
749 
750       // Set up limit values for motion vectors to prevent them extending
751       // outside the UMV borders.
752       x->mv_col_min = -((mb_col * 16) + BORDER_MV_PIXELS_B16);
753       x->mv_col_max = ((cm->mb_cols - 1 - mb_col) * 16) + BORDER_MV_PIXELS_B16;
754 
755       // Other than for the first frame do a motion search.
756       if ((lc == NULL && cm->current_video_frame > 0) ||
757           (lc != NULL && lc->current_video_frame_in_layer > 0)) {
758         int tmp_err, motion_error, raw_motion_error;
759         // Assume 0,0 motion with no mv overhead.
760         MV mv = {0, 0} , tmp_mv = {0, 0};
761         struct buf_2d unscaled_last_source_buf_2d;
762 
763         xd->plane[0].pre[0].buf = first_ref_buf->y_buffer + recon_yoffset;
764 #if CONFIG_VP9_HIGHBITDEPTH
765         if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
766           motion_error = highbd_get_prediction_error(
767               bsize, &x->plane[0].src, &xd->plane[0].pre[0], xd->bd);
768         } else {
769           motion_error = get_prediction_error(
770               bsize, &x->plane[0].src, &xd->plane[0].pre[0]);
771         }
772 #else
773         motion_error = get_prediction_error(
774             bsize, &x->plane[0].src, &xd->plane[0].pre[0]);
775 #endif  // CONFIG_VP9_HIGHBITDEPTH
776 
777         // Compute the motion error of the 0,0 motion using the last source
778         // frame as the reference. Skip the further motion search on
779         // reconstructed frame if this error is small.
780         unscaled_last_source_buf_2d.buf =
781             cpi->unscaled_last_source->y_buffer + recon_yoffset;
782         unscaled_last_source_buf_2d.stride =
783             cpi->unscaled_last_source->y_stride;
784 #if CONFIG_VP9_HIGHBITDEPTH
785         if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
786           raw_motion_error = highbd_get_prediction_error(
787               bsize, &x->plane[0].src, &unscaled_last_source_buf_2d, xd->bd);
788         } else {
789           raw_motion_error = get_prediction_error(
790               bsize, &x->plane[0].src, &unscaled_last_source_buf_2d);
791         }
792 #else
793         raw_motion_error = get_prediction_error(
794             bsize, &x->plane[0].src, &unscaled_last_source_buf_2d);
795 #endif  // CONFIG_VP9_HIGHBITDEPTH
796 
797         // TODO(pengchong): Replace the hard-coded threshold
798         if (raw_motion_error > 25 || lc != NULL) {
799           // Test last reference frame using the previous best mv as the
800           // starting point (best reference) for the search.
801           first_pass_motion_search(cpi, x, &best_ref_mv, &mv, &motion_error);
802 
803           // If the current best reference mv is not centered on 0,0 then do a
804           // 0,0 based search as well.
805           if (!is_zero_mv(&best_ref_mv)) {
806             tmp_err = INT_MAX;
807             first_pass_motion_search(cpi, x, &zero_mv, &tmp_mv, &tmp_err);
808 
809             if (tmp_err < motion_error) {
810               motion_error = tmp_err;
811               mv = tmp_mv;
812             }
813           }
814 
815           // Search in an older reference frame.
816           if (((lc == NULL && cm->current_video_frame > 1) ||
817                (lc != NULL && lc->current_video_frame_in_layer > 1))
818               && gld_yv12 != NULL) {
819             // Assume 0,0 motion with no mv overhead.
820             int gf_motion_error;
821 
822             xd->plane[0].pre[0].buf = gld_yv12->y_buffer + recon_yoffset;
823 #if CONFIG_VP9_HIGHBITDEPTH
824             if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
825               gf_motion_error = highbd_get_prediction_error(
826                   bsize, &x->plane[0].src, &xd->plane[0].pre[0], xd->bd);
827             } else {
828               gf_motion_error = get_prediction_error(
829                   bsize, &x->plane[0].src, &xd->plane[0].pre[0]);
830             }
831 #else
832             gf_motion_error = get_prediction_error(
833                 bsize, &x->plane[0].src, &xd->plane[0].pre[0]);
834 #endif  // CONFIG_VP9_HIGHBITDEPTH
835 
836             first_pass_motion_search(cpi, x, &zero_mv, &tmp_mv,
837                                      &gf_motion_error);
838 
839             if (gf_motion_error < motion_error && gf_motion_error < this_error)
840               ++second_ref_count;
841 
842             // Reset to last frame as reference buffer.
843             xd->plane[0].pre[0].buf = first_ref_buf->y_buffer + recon_yoffset;
844             xd->plane[1].pre[0].buf = first_ref_buf->u_buffer + recon_uvoffset;
845             xd->plane[2].pre[0].buf = first_ref_buf->v_buffer + recon_uvoffset;
846 
847             // In accumulating a score for the older reference frame take the
848             // best of the motion predicted score and the intra coded error
849             // (just as will be done for) accumulation of "coded_error" for
850             // the last frame.
851             if (gf_motion_error < this_error)
852               sr_coded_error += gf_motion_error;
853             else
854               sr_coded_error += this_error;
855           } else {
856             sr_coded_error += motion_error;
857           }
858         } else {
859           sr_coded_error += motion_error;
860         }
861 
862         // Start by assuming that intra mode is best.
863         best_ref_mv.row = 0;
864         best_ref_mv.col = 0;
865 
866 #if CONFIG_FP_MB_STATS
867         if (cpi->use_fp_mb_stats) {
868           // intra predication statistics
869           cpi->twopass.frame_mb_stats_buf[mb_index] = 0;
870           cpi->twopass.frame_mb_stats_buf[mb_index] |= FPMB_DCINTRA_MASK;
871           cpi->twopass.frame_mb_stats_buf[mb_index] |= FPMB_MOTION_ZERO_MASK;
872           if (this_error > FPMB_ERROR_LARGE_TH) {
873             cpi->twopass.frame_mb_stats_buf[mb_index] |= FPMB_ERROR_LARGE_MASK;
874           } else if (this_error < FPMB_ERROR_SMALL_TH) {
875             cpi->twopass.frame_mb_stats_buf[mb_index] |= FPMB_ERROR_SMALL_MASK;
876           }
877         }
878 #endif
879 
880         if (motion_error <= this_error) {
881           vpx_clear_system_state();
882 
883           // Keep a count of cases where the inter and intra were very close
884           // and very low. This helps with scene cut detection for example in
885           // cropped clips with black bars at the sides or top and bottom.
886           if (((this_error - intrapenalty) * 9 <= motion_error * 10) &&
887               (this_error < (2 * intrapenalty))) {
888             neutral_count += 1.0;
889           // Also track cases where the intra is not much worse than the inter
890           // and use this in limiting the GF/arf group length.
891           } else if ((this_error > NCOUNT_INTRA_THRESH) &&
892                      (this_error < (NCOUNT_INTRA_FACTOR * motion_error))) {
893             neutral_count += (double)motion_error /
894                              DOUBLE_DIVIDE_CHECK((double)this_error);
895           }
896 
897           mv.row *= 8;
898           mv.col *= 8;
899           this_error = motion_error;
900           xd->mi[0]->mbmi.mode = NEWMV;
901           xd->mi[0]->mbmi.mv[0].as_mv = mv;
902           xd->mi[0]->mbmi.tx_size = TX_4X4;
903           xd->mi[0]->mbmi.ref_frame[0] = LAST_FRAME;
904           xd->mi[0]->mbmi.ref_frame[1] = NONE;
905           vp9_build_inter_predictors_sby(xd, mb_row << 1, mb_col << 1, bsize);
906           vp9_encode_sby_pass1(x, bsize);
907           sum_mvr += mv.row;
908           sum_mvr_abs += abs(mv.row);
909           sum_mvc += mv.col;
910           sum_mvc_abs += abs(mv.col);
911           sum_mvrs += mv.row * mv.row;
912           sum_mvcs += mv.col * mv.col;
913           ++intercount;
914 
915           best_ref_mv = mv;
916 
917 #if CONFIG_FP_MB_STATS
918           if (cpi->use_fp_mb_stats) {
919             // inter predication statistics
920             cpi->twopass.frame_mb_stats_buf[mb_index] = 0;
921             cpi->twopass.frame_mb_stats_buf[mb_index] &= ~FPMB_DCINTRA_MASK;
922             cpi->twopass.frame_mb_stats_buf[mb_index] |= FPMB_MOTION_ZERO_MASK;
923             if (this_error > FPMB_ERROR_LARGE_TH) {
924               cpi->twopass.frame_mb_stats_buf[mb_index] |=
925                   FPMB_ERROR_LARGE_MASK;
926             } else if (this_error < FPMB_ERROR_SMALL_TH) {
927               cpi->twopass.frame_mb_stats_buf[mb_index] |=
928                   FPMB_ERROR_SMALL_MASK;
929             }
930           }
931 #endif
932 
933           if (!is_zero_mv(&mv)) {
934             ++mvcount;
935 
936 #if CONFIG_FP_MB_STATS
937             if (cpi->use_fp_mb_stats) {
938               cpi->twopass.frame_mb_stats_buf[mb_index] &=
939                   ~FPMB_MOTION_ZERO_MASK;
940               // check estimated motion direction
941               if (mv.as_mv.col > 0 && mv.as_mv.col >= abs(mv.as_mv.row)) {
942                 // right direction
943                 cpi->twopass.frame_mb_stats_buf[mb_index] |=
944                     FPMB_MOTION_RIGHT_MASK;
945               } else if (mv.as_mv.row < 0 &&
946                          abs(mv.as_mv.row) >= abs(mv.as_mv.col)) {
947                 // up direction
948                 cpi->twopass.frame_mb_stats_buf[mb_index] |=
949                     FPMB_MOTION_UP_MASK;
950               } else if (mv.as_mv.col < 0 &&
951                          abs(mv.as_mv.col) >= abs(mv.as_mv.row)) {
952                 // left direction
953                 cpi->twopass.frame_mb_stats_buf[mb_index] |=
954                     FPMB_MOTION_LEFT_MASK;
955               } else {
956                 // down direction
957                 cpi->twopass.frame_mb_stats_buf[mb_index] |=
958                     FPMB_MOTION_DOWN_MASK;
959               }
960             }
961 #endif
962 
963             // Non-zero vector, was it different from the last non zero vector?
964             if (!is_equal_mv(&mv, &lastmv))
965               ++new_mv_count;
966             lastmv = mv;
967 
968             // Does the row vector point inwards or outwards?
969             if (mb_row < cm->mb_rows / 2) {
970               if (mv.row > 0)
971                 --sum_in_vectors;
972               else if (mv.row < 0)
973                 ++sum_in_vectors;
974             } else if (mb_row > cm->mb_rows / 2) {
975               if (mv.row > 0)
976                 ++sum_in_vectors;
977               else if (mv.row < 0)
978                 --sum_in_vectors;
979             }
980 
981             // Does the col vector point inwards or outwards?
982             if (mb_col < cm->mb_cols / 2) {
983               if (mv.col > 0)
984                 --sum_in_vectors;
985               else if (mv.col < 0)
986                 ++sum_in_vectors;
987             } else if (mb_col > cm->mb_cols / 2) {
988               if (mv.col > 0)
989                 ++sum_in_vectors;
990               else if (mv.col < 0)
991                 --sum_in_vectors;
992             }
993           }
994         }
995       } else {
996         sr_coded_error += (int64_t)this_error;
997       }
998       coded_error += (int64_t)this_error;
999 
1000       // Adjust to the next column of MBs.
1001       x->plane[0].src.buf += 16;
1002       x->plane[1].src.buf += uv_mb_height;
1003       x->plane[2].src.buf += uv_mb_height;
1004 
1005       recon_yoffset += 16;
1006       recon_uvoffset += uv_mb_height;
1007     }
1008 
1009     // Adjust to the next row of MBs.
1010     x->plane[0].src.buf += 16 * x->plane[0].src.stride - 16 * cm->mb_cols;
1011     x->plane[1].src.buf += uv_mb_height * x->plane[1].src.stride -
1012                            uv_mb_height * cm->mb_cols;
1013     x->plane[2].src.buf += uv_mb_height * x->plane[1].src.stride -
1014                            uv_mb_height * cm->mb_cols;
1015 
1016     vpx_clear_system_state();
1017   }
1018 
1019   // Clamp the image start to rows/2. This number of rows is discarded top
1020   // and bottom as dead data so rows / 2 means the frame is blank.
1021   if ((image_data_start_row > cm->mb_rows / 2) ||
1022       (image_data_start_row == INVALID_ROW)) {
1023     image_data_start_row = cm->mb_rows / 2;
1024   }
1025   // Exclude any image dead zone
1026   if (image_data_start_row > 0) {
1027     intra_skip_count =
1028         VPXMAX(0, intra_skip_count - (image_data_start_row * cm->mb_cols * 2));
1029   }
1030 
1031   {
1032     FIRSTPASS_STATS fps;
1033     // The minimum error here insures some bit allocation to frames even
1034     // in static regions. The allocation per MB declines for larger formats
1035     // where the typical "real" energy per MB also falls.
1036     // Initial estimate here uses sqrt(mbs) to define the min_err, where the
1037     // number of mbs is proportional to the image area.
1038     const int num_mbs = (cpi->oxcf.resize_mode != RESIZE_NONE)
1039                         ? cpi->initial_mbs : cpi->common.MBs;
1040     const double min_err = 200 * sqrt(num_mbs);
1041 
1042     intra_factor = intra_factor / (double)num_mbs;
1043     brightness_factor = brightness_factor / (double)num_mbs;
1044     fps.weight = intra_factor * brightness_factor;
1045 
1046     fps.frame = cm->current_video_frame;
1047     fps.spatial_layer_id = cpi->svc.spatial_layer_id;
1048     fps.coded_error = (double)(coded_error >> 8) + min_err;
1049     fps.sr_coded_error = (double)(sr_coded_error >> 8) + min_err;
1050     fps.intra_error = (double)(intra_error >> 8) + min_err;
1051     fps.count = 1.0;
1052     fps.pcnt_inter = (double)intercount / num_mbs;
1053     fps.pcnt_second_ref = (double)second_ref_count / num_mbs;
1054     fps.pcnt_neutral = (double)neutral_count / num_mbs;
1055     fps.intra_skip_pct = (double)intra_skip_count / num_mbs;
1056     fps.inactive_zone_rows = (double)image_data_start_row;
1057     fps.inactive_zone_cols = (double)0;  // TODO(paulwilkins): fix
1058 
1059     if (mvcount > 0) {
1060       fps.MVr = (double)sum_mvr / mvcount;
1061       fps.mvr_abs = (double)sum_mvr_abs / mvcount;
1062       fps.MVc = (double)sum_mvc / mvcount;
1063       fps.mvc_abs = (double)sum_mvc_abs / mvcount;
1064       fps.MVrv = ((double)sum_mvrs -
1065                   ((double)sum_mvr * sum_mvr / mvcount)) / mvcount;
1066       fps.MVcv = ((double)sum_mvcs -
1067                   ((double)sum_mvc * sum_mvc / mvcount)) / mvcount;
1068       fps.mv_in_out_count = (double)sum_in_vectors / (mvcount * 2);
1069       fps.new_mv_count = new_mv_count;
1070       fps.pcnt_motion = (double)mvcount / num_mbs;
1071     } else {
1072       fps.MVr = 0.0;
1073       fps.mvr_abs = 0.0;
1074       fps.MVc = 0.0;
1075       fps.mvc_abs = 0.0;
1076       fps.MVrv = 0.0;
1077       fps.MVcv = 0.0;
1078       fps.mv_in_out_count = 0.0;
1079       fps.new_mv_count = 0.0;
1080       fps.pcnt_motion = 0.0;
1081     }
1082 
1083     // TODO(paulwilkins):  Handle the case when duration is set to 0, or
1084     // something less than the full time between subsequent values of
1085     // cpi->source_time_stamp.
1086     fps.duration = (double)(source->ts_end - source->ts_start);
1087 
1088     // Don't want to do output stats with a stack variable!
1089     twopass->this_frame_stats = fps;
1090     output_stats(&twopass->this_frame_stats, cpi->output_pkt_list);
1091     accumulate_stats(&twopass->total_stats, &fps);
1092 
1093 #if CONFIG_FP_MB_STATS
1094     if (cpi->use_fp_mb_stats) {
1095       output_fpmb_stats(twopass->frame_mb_stats_buf, cm, cpi->output_pkt_list);
1096     }
1097 #endif
1098   }
1099 
1100   // Copy the previous Last Frame back into gf and and arf buffers if
1101   // the prediction is good enough... but also don't allow it to lag too far.
1102   if ((twopass->sr_update_lag > 3) ||
1103       ((cm->current_video_frame > 0) &&
1104        (twopass->this_frame_stats.pcnt_inter > 0.20) &&
1105        ((twopass->this_frame_stats.intra_error /
1106          DOUBLE_DIVIDE_CHECK(twopass->this_frame_stats.coded_error)) > 2.0))) {
1107     if (gld_yv12 != NULL) {
1108       ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
1109                  cm->ref_frame_map[cpi->lst_fb_idx]);
1110     }
1111     twopass->sr_update_lag = 1;
1112   } else {
1113     ++twopass->sr_update_lag;
1114   }
1115 
1116   vpx_extend_frame_borders(new_yv12);
1117 
1118   if (lc != NULL) {
1119     vp9_update_reference_frames(cpi);
1120   } else {
1121     // The frame we just compressed now becomes the last frame.
1122     ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->lst_fb_idx],
1123                cm->new_fb_idx);
1124   }
1125 
1126   // Special case for the first frame. Copy into the GF buffer as a second
1127   // reference.
1128   if (cm->current_video_frame == 0 && cpi->gld_fb_idx != INVALID_IDX &&
1129       lc == NULL) {
1130     ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
1131                cm->ref_frame_map[cpi->lst_fb_idx]);
1132   }
1133 
1134   // Use this to see what the first pass reconstruction looks like.
1135   if (0) {
1136     char filename[512];
1137     FILE *recon_file;
1138     snprintf(filename, sizeof(filename), "enc%04d.yuv",
1139              (int)cm->current_video_frame);
1140 
1141     if (cm->current_video_frame == 0)
1142       recon_file = fopen(filename, "wb");
1143     else
1144       recon_file = fopen(filename, "ab");
1145 
1146     (void)fwrite(lst_yv12->buffer_alloc, lst_yv12->frame_size, 1, recon_file);
1147     fclose(recon_file);
1148   }
1149 
1150   ++cm->current_video_frame;
1151   if (cpi->use_svc)
1152     vp9_inc_frame_in_layer(cpi);
1153 }
1154 
calc_correction_factor(double err_per_mb,double err_divisor,double pt_low,double pt_high,int q,vpx_bit_depth_t bit_depth)1155 static double calc_correction_factor(double err_per_mb,
1156                                      double err_divisor,
1157                                      double pt_low,
1158                                      double pt_high,
1159                                      int q,
1160                                      vpx_bit_depth_t bit_depth) {
1161   const double error_term = err_per_mb / err_divisor;
1162 
1163   // Adjustment based on actual quantizer to power term.
1164   const double power_term =
1165       VPXMIN(vp9_convert_qindex_to_q(q, bit_depth) * 0.01 + pt_low, pt_high);
1166 
1167   // Calculate correction factor.
1168   if (power_term < 1.0)
1169     assert(error_term >= 0.0);
1170 
1171   return fclamp(pow(error_term, power_term), 0.05, 5.0);
1172 }
1173 
1174 // Larger image formats are expected to be a little harder to code relatively
1175 // given the same prediction error score. This in part at least relates to the
1176 // increased size and hence coding cost of motion vectors.
1177 #define EDIV_SIZE_FACTOR 800
1178 
get_twopass_worst_quality(const VP9_COMP * cpi,const double section_err,double inactive_zone,int section_target_bandwidth,double group_weight_factor)1179 static int get_twopass_worst_quality(const VP9_COMP *cpi,
1180                                      const double section_err,
1181                                      double inactive_zone,
1182                                      int section_target_bandwidth,
1183                                      double group_weight_factor) {
1184   const RATE_CONTROL *const rc = &cpi->rc;
1185   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
1186   // Clamp the target rate to VBR min / max limts.
1187   const int target_rate =
1188       vp9_rc_clamp_pframe_target_size(cpi, section_target_bandwidth);
1189 
1190   inactive_zone = fclamp(inactive_zone, 0.0, 1.0);
1191 
1192   if (target_rate <= 0) {
1193     return rc->worst_quality;  // Highest value allowed
1194   } else {
1195     const int num_mbs = (cpi->oxcf.resize_mode != RESIZE_NONE)
1196                         ? cpi->initial_mbs : cpi->common.MBs;
1197     const int active_mbs = VPXMAX(1, num_mbs - (int)(num_mbs * inactive_zone));
1198     const double av_err_per_mb = section_err / active_mbs;
1199     const double speed_term = 1.0 + 0.04 * oxcf->speed;
1200     const double ediv_size_correction = (double)num_mbs / EDIV_SIZE_FACTOR;
1201     const int target_norm_bits_per_mb = ((uint64_t)target_rate <<
1202                                          BPER_MB_NORMBITS) / active_mbs;
1203 
1204     int q;
1205     int is_svc_upper_layer = 0;
1206 
1207     if (is_two_pass_svc(cpi) && cpi->svc.spatial_layer_id > 0)
1208       is_svc_upper_layer = 1;
1209 
1210 
1211     // Try and pick a max Q that will be high enough to encode the
1212     // content at the given rate.
1213     for (q = rc->best_quality; q < rc->worst_quality; ++q) {
1214       const double factor =
1215           calc_correction_factor(av_err_per_mb,
1216                                  ERR_DIVISOR - ediv_size_correction,
1217                                  is_svc_upper_layer ? SVC_FACTOR_PT_LOW :
1218                                  FACTOR_PT_LOW, FACTOR_PT_HIGH, q,
1219                                  cpi->common.bit_depth);
1220       const int bits_per_mb =
1221         vp9_rc_bits_per_mb(INTER_FRAME, q,
1222                            factor * speed_term * group_weight_factor,
1223                            cpi->common.bit_depth);
1224       if (bits_per_mb <= target_norm_bits_per_mb)
1225         break;
1226     }
1227 
1228     // Restriction on active max q for constrained quality mode.
1229     if (cpi->oxcf.rc_mode == VPX_CQ)
1230       q = VPXMAX(q, oxcf->cq_level);
1231     return q;
1232   }
1233 }
1234 
setup_rf_level_maxq(VP9_COMP * cpi)1235 static void setup_rf_level_maxq(VP9_COMP *cpi) {
1236   int i;
1237   RATE_CONTROL *const rc = &cpi->rc;
1238   for (i = INTER_NORMAL; i < RATE_FACTOR_LEVELS; ++i) {
1239     int qdelta = vp9_frame_type_qdelta(cpi, i, rc->worst_quality);
1240     rc->rf_level_maxq[i] = VPXMAX(rc->worst_quality + qdelta, rc->best_quality);
1241   }
1242 }
1243 
init_subsampling(VP9_COMP * cpi)1244 static void init_subsampling(VP9_COMP *cpi) {
1245   const VP9_COMMON *const cm = &cpi->common;
1246   RATE_CONTROL *const rc = &cpi->rc;
1247   const int w = cm->width;
1248   const int h = cm->height;
1249   int i;
1250 
1251   for (i = 0; i < FRAME_SCALE_STEPS; ++i) {
1252     // Note: Frames with odd-sized dimensions may result from this scaling.
1253     rc->frame_width[i] = (w * 16) / frame_scale_factor[i];
1254     rc->frame_height[i] = (h * 16) / frame_scale_factor[i];
1255   }
1256 
1257   setup_rf_level_maxq(cpi);
1258 }
1259 
calculate_coded_size(VP9_COMP * cpi,int * scaled_frame_width,int * scaled_frame_height)1260 void calculate_coded_size(VP9_COMP *cpi,
1261                           int *scaled_frame_width,
1262                           int *scaled_frame_height) {
1263   RATE_CONTROL *const rc = &cpi->rc;
1264   *scaled_frame_width = rc->frame_width[rc->frame_size_selector];
1265   *scaled_frame_height = rc->frame_height[rc->frame_size_selector];
1266 }
1267 
vp9_init_second_pass(VP9_COMP * cpi)1268 void vp9_init_second_pass(VP9_COMP *cpi) {
1269   SVC *const svc = &cpi->svc;
1270   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
1271   const int is_two_pass_svc = (svc->number_spatial_layers > 1) ||
1272                               (svc->number_temporal_layers > 1);
1273   TWO_PASS *const twopass = is_two_pass_svc ?
1274       &svc->layer_context[svc->spatial_layer_id].twopass : &cpi->twopass;
1275   double frame_rate;
1276   FIRSTPASS_STATS *stats;
1277 
1278   zero_stats(&twopass->total_stats);
1279   zero_stats(&twopass->total_left_stats);
1280 
1281   if (!twopass->stats_in_end)
1282     return;
1283 
1284   stats = &twopass->total_stats;
1285 
1286   *stats = *twopass->stats_in_end;
1287   twopass->total_left_stats = *stats;
1288 
1289   frame_rate = 10000000.0 * stats->count / stats->duration;
1290   // Each frame can have a different duration, as the frame rate in the source
1291   // isn't guaranteed to be constant. The frame rate prior to the first frame
1292   // encoded in the second pass is a guess. However, the sum duration is not.
1293   // It is calculated based on the actual durations of all frames from the
1294   // first pass.
1295 
1296   if (is_two_pass_svc) {
1297     vp9_update_spatial_layer_framerate(cpi, frame_rate);
1298     twopass->bits_left = (int64_t)(stats->duration *
1299         svc->layer_context[svc->spatial_layer_id].target_bandwidth /
1300         10000000.0);
1301   } else {
1302     vp9_new_framerate(cpi, frame_rate);
1303     twopass->bits_left = (int64_t)(stats->duration * oxcf->target_bandwidth /
1304                              10000000.0);
1305   }
1306 
1307   // This variable monitors how far behind the second ref update is lagging.
1308   twopass->sr_update_lag = 1;
1309 
1310   // Scan the first pass file and calculate a modified total error based upon
1311   // the bias/power function used to allocate bits.
1312   {
1313     const double avg_error = stats->coded_error /
1314                              DOUBLE_DIVIDE_CHECK(stats->count);
1315     const FIRSTPASS_STATS *s = twopass->stats_in;
1316     double modified_error_total = 0.0;
1317     twopass->modified_error_min = (avg_error *
1318                                       oxcf->two_pass_vbrmin_section) / 100;
1319     twopass->modified_error_max = (avg_error *
1320                                       oxcf->two_pass_vbrmax_section) / 100;
1321     while (s < twopass->stats_in_end) {
1322       modified_error_total += calculate_modified_err(cpi, twopass, oxcf, s);
1323       ++s;
1324     }
1325     twopass->modified_error_left = modified_error_total;
1326   }
1327 
1328   // Reset the vbr bits off target counters
1329   cpi->rc.vbr_bits_off_target = 0;
1330   cpi->rc.vbr_bits_off_target_fast = 0;
1331 
1332   cpi->rc.rate_error_estimate = 0;
1333 
1334   // Static sequence monitor variables.
1335   twopass->kf_zeromotion_pct = 100;
1336   twopass->last_kfgroup_zeromotion_pct = 100;
1337 
1338   if (oxcf->resize_mode != RESIZE_NONE) {
1339     init_subsampling(cpi);
1340   }
1341 }
1342 
1343 #define SR_DIFF_PART 0.0015
1344 #define MOTION_AMP_PART 0.003
1345 #define INTRA_PART 0.005
1346 #define DEFAULT_DECAY_LIMIT 0.75
1347 #define LOW_SR_DIFF_TRHESH 0.1
1348 #define SR_DIFF_MAX 128.0
1349 
get_sr_decay_rate(const VP9_COMP * cpi,const FIRSTPASS_STATS * frame)1350 static double get_sr_decay_rate(const VP9_COMP *cpi,
1351                                 const FIRSTPASS_STATS *frame) {
1352   const int num_mbs = (cpi->oxcf.resize_mode != RESIZE_NONE)
1353                       ? cpi->initial_mbs : cpi->common.MBs;
1354   double sr_diff =
1355       (frame->sr_coded_error - frame->coded_error) / num_mbs;
1356   double sr_decay = 1.0;
1357   double modified_pct_inter;
1358   double modified_pcnt_intra;
1359   const double motion_amplitude_factor =
1360     frame->pcnt_motion * ((frame->mvc_abs + frame->mvr_abs) / 2);
1361 
1362   modified_pct_inter = frame->pcnt_inter;
1363   if ((frame->intra_error / DOUBLE_DIVIDE_CHECK(frame->coded_error)) <
1364       (double)NCOUNT_FRAME_II_THRESH) {
1365     modified_pct_inter = frame->pcnt_inter - frame->pcnt_neutral;
1366   }
1367   modified_pcnt_intra = 100 * (1.0 - modified_pct_inter);
1368 
1369 
1370   if ((sr_diff > LOW_SR_DIFF_TRHESH)) {
1371     sr_diff = VPXMIN(sr_diff, SR_DIFF_MAX);
1372     sr_decay = 1.0 - (SR_DIFF_PART * sr_diff) -
1373                (MOTION_AMP_PART * motion_amplitude_factor) -
1374                (INTRA_PART * modified_pcnt_intra);
1375   }
1376   return VPXMAX(sr_decay, VPXMIN(DEFAULT_DECAY_LIMIT, modified_pct_inter));
1377 }
1378 
1379 // This function gives an estimate of how badly we believe the prediction
1380 // quality is decaying from frame to frame.
get_zero_motion_factor(const VP9_COMP * cpi,const FIRSTPASS_STATS * frame)1381 static double get_zero_motion_factor(const VP9_COMP *cpi,
1382                                      const FIRSTPASS_STATS *frame) {
1383   const double zero_motion_pct = frame->pcnt_inter -
1384                                  frame->pcnt_motion;
1385   double sr_decay = get_sr_decay_rate(cpi, frame);
1386   return VPXMIN(sr_decay, zero_motion_pct);
1387 }
1388 
1389 #define ZM_POWER_FACTOR 0.75
1390 
get_prediction_decay_rate(const VP9_COMP * cpi,const FIRSTPASS_STATS * next_frame)1391 static double get_prediction_decay_rate(const VP9_COMP *cpi,
1392                                         const FIRSTPASS_STATS *next_frame) {
1393   const double sr_decay_rate = get_sr_decay_rate(cpi, next_frame);
1394   const double zero_motion_factor =
1395     (0.95 * pow((next_frame->pcnt_inter - next_frame->pcnt_motion),
1396                 ZM_POWER_FACTOR));
1397 
1398   return VPXMAX(zero_motion_factor,
1399                 (sr_decay_rate + ((1.0 - sr_decay_rate) * zero_motion_factor)));
1400 }
1401 
1402 // Function to test for a condition where a complex transition is followed
1403 // by a static section. For example in slide shows where there is a fade
1404 // between slides. This is to help with more optimal kf and gf positioning.
detect_transition_to_still(VP9_COMP * cpi,int frame_interval,int still_interval,double loop_decay_rate,double last_decay_rate)1405 static int detect_transition_to_still(VP9_COMP *cpi,
1406                                       int frame_interval, int still_interval,
1407                                       double loop_decay_rate,
1408                                       double last_decay_rate) {
1409   TWO_PASS *const twopass = &cpi->twopass;
1410   RATE_CONTROL *const rc = &cpi->rc;
1411 
1412   // Break clause to detect very still sections after motion
1413   // For example a static image after a fade or other transition
1414   // instead of a clean scene cut.
1415   if (frame_interval > rc->min_gf_interval &&
1416       loop_decay_rate >= 0.999 &&
1417       last_decay_rate < 0.9) {
1418     int j;
1419 
1420     // Look ahead a few frames to see if static condition persists...
1421     for (j = 0; j < still_interval; ++j) {
1422       const FIRSTPASS_STATS *stats = &twopass->stats_in[j];
1423       if (stats >= twopass->stats_in_end)
1424         break;
1425 
1426       if (stats->pcnt_inter - stats->pcnt_motion < 0.999)
1427         break;
1428     }
1429 
1430     // Only if it does do we signal a transition to still.
1431     return j == still_interval;
1432   }
1433 
1434   return 0;
1435 }
1436 
1437 // This function detects a flash through the high relative pcnt_second_ref
1438 // score in the frame following a flash frame. The offset passed in should
1439 // reflect this.
detect_flash(const TWO_PASS * twopass,int offset)1440 static int detect_flash(const TWO_PASS *twopass, int offset) {
1441   const FIRSTPASS_STATS *const next_frame = read_frame_stats(twopass, offset);
1442 
1443   // What we are looking for here is a situation where there is a
1444   // brief break in prediction (such as a flash) but subsequent frames
1445   // are reasonably well predicted by an earlier (pre flash) frame.
1446   // The recovery after a flash is indicated by a high pcnt_second_ref
1447   // compared to pcnt_inter.
1448   return next_frame != NULL &&
1449          next_frame->pcnt_second_ref > next_frame->pcnt_inter &&
1450          next_frame->pcnt_second_ref >= 0.5;
1451 }
1452 
1453 // 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)1454 static void accumulate_frame_motion_stats(const FIRSTPASS_STATS *stats,
1455                                           double *mv_in_out,
1456                                           double *mv_in_out_accumulator,
1457                                           double *abs_mv_in_out_accumulator,
1458                                           double *mv_ratio_accumulator) {
1459   const double pct = stats->pcnt_motion;
1460 
1461   // Accumulate Motion In/Out of frame stats.
1462   *mv_in_out = stats->mv_in_out_count * pct;
1463   *mv_in_out_accumulator += *mv_in_out;
1464   *abs_mv_in_out_accumulator += fabs(*mv_in_out);
1465 
1466   // Accumulate a measure of how uniform (or conversely how random) the motion
1467   // field is (a ratio of abs(mv) / mv).
1468   if (pct > 0.05) {
1469     const double mvr_ratio = fabs(stats->mvr_abs) /
1470                                  DOUBLE_DIVIDE_CHECK(fabs(stats->MVr));
1471     const double mvc_ratio = fabs(stats->mvc_abs) /
1472                                  DOUBLE_DIVIDE_CHECK(fabs(stats->MVc));
1473 
1474     *mv_ratio_accumulator += pct * (mvr_ratio < stats->mvr_abs ?
1475                                        mvr_ratio : stats->mvr_abs);
1476     *mv_ratio_accumulator += pct * (mvc_ratio < stats->mvc_abs ?
1477                                        mvc_ratio : stats->mvc_abs);
1478   }
1479 }
1480 
1481 #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)1482 static double calc_frame_boost(VP9_COMP *cpi,
1483                                const FIRSTPASS_STATS *this_frame,
1484                                double this_frame_mv_in_out,
1485                                double max_boost) {
1486   double frame_boost;
1487   const double lq =
1488     vp9_convert_qindex_to_q(cpi->rc.avg_frame_qindex[INTER_FRAME],
1489                             cpi->common.bit_depth);
1490   const double boost_q_correction = VPXMIN((0.5 + (lq * 0.015)), 1.5);
1491   int num_mbs = (cpi->oxcf.resize_mode != RESIZE_NONE)
1492                 ? cpi->initial_mbs : cpi->common.MBs;
1493 
1494   // Correct for any inactive region in the image
1495   num_mbs = (int)VPXMAX(1, num_mbs * calculate_active_area(cpi, this_frame));
1496 
1497   // Underlying boost factor is based on inter error ratio.
1498   frame_boost = (BASELINE_ERR_PER_MB * num_mbs) /
1499                 DOUBLE_DIVIDE_CHECK(this_frame->coded_error);
1500   frame_boost = frame_boost * BOOST_FACTOR * boost_q_correction;
1501 
1502   // Increase boost for frames where new data coming into frame (e.g. zoom out).
1503   // Slightly reduce boost if there is a net balance of motion out of the frame
1504   // (zoom in). The range for this_frame_mv_in_out is -1.0 to +1.0.
1505   if (this_frame_mv_in_out > 0.0)
1506     frame_boost += frame_boost * (this_frame_mv_in_out * 2.0);
1507   // In the extreme case the boost is halved.
1508   else
1509     frame_boost += frame_boost * (this_frame_mv_in_out / 2.0);
1510 
1511   return VPXMIN(frame_boost, max_boost * boost_q_correction);
1512 }
1513 
calc_arf_boost(VP9_COMP * cpi,int offset,int f_frames,int b_frames,int * f_boost,int * b_boost)1514 static int calc_arf_boost(VP9_COMP *cpi, int offset,
1515                           int f_frames, int b_frames,
1516                           int *f_boost, int *b_boost) {
1517   TWO_PASS *const twopass = &cpi->twopass;
1518   int i;
1519   double boost_score = 0.0;
1520   double mv_ratio_accumulator = 0.0;
1521   double decay_accumulator = 1.0;
1522   double this_frame_mv_in_out = 0.0;
1523   double mv_in_out_accumulator = 0.0;
1524   double abs_mv_in_out_accumulator = 0.0;
1525   int arf_boost;
1526   int flash_detected = 0;
1527 
1528   // Search forward from the proposed arf/next gf position.
1529   for (i = 0; i < f_frames; ++i) {
1530     const FIRSTPASS_STATS *this_frame = read_frame_stats(twopass, i + offset);
1531     if (this_frame == NULL)
1532       break;
1533 
1534     // Update the motion related elements to the boost calculation.
1535     accumulate_frame_motion_stats(this_frame,
1536                                   &this_frame_mv_in_out, &mv_in_out_accumulator,
1537                                   &abs_mv_in_out_accumulator,
1538                                   &mv_ratio_accumulator);
1539 
1540     // We want to discount the flash frame itself and the recovery
1541     // frame that follows as both will have poor scores.
1542     flash_detected = detect_flash(twopass, i + offset) ||
1543                      detect_flash(twopass, i + offset + 1);
1544 
1545     // Accumulate the effect of prediction quality decay.
1546     if (!flash_detected) {
1547       decay_accumulator *= get_prediction_decay_rate(cpi, this_frame);
1548       decay_accumulator = decay_accumulator < MIN_DECAY_FACTOR
1549                           ? MIN_DECAY_FACTOR : decay_accumulator;
1550     }
1551 
1552     boost_score += decay_accumulator * calc_frame_boost(cpi, this_frame,
1553                                                         this_frame_mv_in_out,
1554                                                         GF_MAX_BOOST);
1555   }
1556 
1557   *f_boost = (int)boost_score;
1558 
1559   // Reset for backward looking loop.
1560   boost_score = 0.0;
1561   mv_ratio_accumulator = 0.0;
1562   decay_accumulator = 1.0;
1563   this_frame_mv_in_out = 0.0;
1564   mv_in_out_accumulator = 0.0;
1565   abs_mv_in_out_accumulator = 0.0;
1566 
1567   // Search backward towards last gf position.
1568   for (i = -1; i >= -b_frames; --i) {
1569     const FIRSTPASS_STATS *this_frame = read_frame_stats(twopass, i + offset);
1570     if (this_frame == NULL)
1571       break;
1572 
1573     // Update the motion related elements to the boost calculation.
1574     accumulate_frame_motion_stats(this_frame,
1575                                   &this_frame_mv_in_out, &mv_in_out_accumulator,
1576                                   &abs_mv_in_out_accumulator,
1577                                   &mv_ratio_accumulator);
1578 
1579     // We want to discount the the flash frame itself and the recovery
1580     // frame that follows as both will have poor scores.
1581     flash_detected = detect_flash(twopass, i + offset) ||
1582                      detect_flash(twopass, i + offset + 1);
1583 
1584     // Cumulative effect of prediction quality decay.
1585     if (!flash_detected) {
1586       decay_accumulator *= get_prediction_decay_rate(cpi, this_frame);
1587       decay_accumulator = decay_accumulator < MIN_DECAY_FACTOR
1588                               ? MIN_DECAY_FACTOR : decay_accumulator;
1589     }
1590 
1591     boost_score += decay_accumulator * calc_frame_boost(cpi, this_frame,
1592                                                         this_frame_mv_in_out,
1593                                                         GF_MAX_BOOST);
1594   }
1595   *b_boost = (int)boost_score;
1596 
1597   arf_boost = (*f_boost + *b_boost);
1598   if (arf_boost < ((b_frames + f_frames) * 20))
1599     arf_boost = ((b_frames + f_frames) * 20);
1600   arf_boost = VPXMAX(arf_boost, MIN_ARF_GF_BOOST);
1601 
1602   return arf_boost;
1603 }
1604 
1605 // 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)1606 static int calculate_section_intra_ratio(const FIRSTPASS_STATS *begin,
1607                                          const FIRSTPASS_STATS *end,
1608                                          int section_length) {
1609   const FIRSTPASS_STATS *s = begin;
1610   double intra_error = 0.0;
1611   double coded_error = 0.0;
1612   int i = 0;
1613 
1614   while (s < end && i < section_length) {
1615     intra_error += s->intra_error;
1616     coded_error += s->coded_error;
1617     ++s;
1618     ++i;
1619   }
1620 
1621   return (int)(intra_error / DOUBLE_DIVIDE_CHECK(coded_error));
1622 }
1623 
1624 // Calculate the total bits to allocate in this GF/ARF group.
calculate_total_gf_group_bits(VP9_COMP * cpi,double gf_group_err)1625 static int64_t calculate_total_gf_group_bits(VP9_COMP *cpi,
1626                                              double gf_group_err) {
1627   const RATE_CONTROL *const rc = &cpi->rc;
1628   const TWO_PASS *const twopass = &cpi->twopass;
1629   const int max_bits = frame_max_bits(rc, &cpi->oxcf);
1630   int64_t total_group_bits;
1631 
1632   // Calculate the bits to be allocated to the group as a whole.
1633   if ((twopass->kf_group_bits > 0) && (twopass->kf_group_error_left > 0)) {
1634     total_group_bits = (int64_t)(twopass->kf_group_bits *
1635                                  (gf_group_err / twopass->kf_group_error_left));
1636   } else {
1637     total_group_bits = 0;
1638   }
1639 
1640   // Clamp odd edge cases.
1641   total_group_bits = (total_group_bits < 0) ?
1642      0 : (total_group_bits > twopass->kf_group_bits) ?
1643      twopass->kf_group_bits : total_group_bits;
1644 
1645   // Clip based on user supplied data rate variability limit.
1646   if (total_group_bits > (int64_t)max_bits * rc->baseline_gf_interval)
1647     total_group_bits = (int64_t)max_bits * rc->baseline_gf_interval;
1648 
1649   return total_group_bits;
1650 }
1651 
1652 // 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)1653 static int calculate_boost_bits(int frame_count,
1654                                 int boost, int64_t total_group_bits) {
1655   int allocation_chunks;
1656 
1657   // return 0 for invalid inputs (could arise e.g. through rounding errors)
1658   if (!boost || (total_group_bits <= 0) || (frame_count <= 0) )
1659     return 0;
1660 
1661   allocation_chunks = (frame_count * 100) + boost;
1662 
1663   // Prevent overflow.
1664   if (boost > 1023) {
1665     int divisor = boost >> 10;
1666     boost /= divisor;
1667     allocation_chunks /= divisor;
1668   }
1669 
1670   // Calculate the number of extra bits for use in the boosted frame or frames.
1671   return VPXMAX((int)(((int64_t)boost * total_group_bits) / allocation_chunks),
1672                 0);
1673 }
1674 
1675 // Current limit on maximum number of active arfs in a GF/ARF group.
1676 #define MAX_ACTIVE_ARFS 2
1677 #define ARF_SLOT1 2
1678 #define ARF_SLOT2 3
1679 // This function indirects the choice of buffers for arfs.
1680 // At the moment the values are fixed but this may change as part of
1681 // the integration process with other codec features that swap buffers around.
get_arf_buffer_indices(unsigned char * arf_buffer_indices)1682 static void get_arf_buffer_indices(unsigned char *arf_buffer_indices) {
1683   arf_buffer_indices[0] = ARF_SLOT1;
1684   arf_buffer_indices[1] = ARF_SLOT2;
1685 }
1686 
allocate_gf_group_bits(VP9_COMP * cpi,int64_t gf_group_bits,double group_error,int gf_arf_bits)1687 static void allocate_gf_group_bits(VP9_COMP *cpi, int64_t gf_group_bits,
1688                                    double group_error, int gf_arf_bits) {
1689   RATE_CONTROL *const rc = &cpi->rc;
1690   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
1691   TWO_PASS *const twopass = &cpi->twopass;
1692   GF_GROUP *const gf_group = &twopass->gf_group;
1693   FIRSTPASS_STATS frame_stats;
1694   int i;
1695   int frame_index = 1;
1696   int target_frame_size;
1697   int key_frame;
1698   const int max_bits = frame_max_bits(&cpi->rc, &cpi->oxcf);
1699   int64_t total_group_bits = gf_group_bits;
1700   double modified_err = 0.0;
1701   double err_fraction;
1702   int mid_boost_bits = 0;
1703   int mid_frame_idx;
1704   unsigned char arf_buffer_indices[MAX_ACTIVE_ARFS];
1705   int alt_frame_index = frame_index;
1706   int has_temporal_layers = is_two_pass_svc(cpi) &&
1707                             cpi->svc.number_temporal_layers > 1;
1708 
1709   // Only encode alt reference frame in temporal base layer.
1710   if (has_temporal_layers)
1711     alt_frame_index = cpi->svc.number_temporal_layers;
1712 
1713   key_frame = cpi->common.frame_type == KEY_FRAME ||
1714               vp9_is_upper_layer_key_frame(cpi);
1715 
1716   get_arf_buffer_indices(arf_buffer_indices);
1717 
1718   // For key frames the frame target rate is already set and it
1719   // is also the golden frame.
1720   if (!key_frame) {
1721     if (rc->source_alt_ref_active) {
1722       gf_group->update_type[0] = OVERLAY_UPDATE;
1723       gf_group->rf_level[0] = INTER_NORMAL;
1724       gf_group->bit_allocation[0] = 0;
1725       gf_group->arf_update_idx[0] = arf_buffer_indices[0];
1726       gf_group->arf_ref_idx[0] = arf_buffer_indices[0];
1727     } else {
1728       gf_group->update_type[0] = GF_UPDATE;
1729       gf_group->rf_level[0] = GF_ARF_STD;
1730       gf_group->bit_allocation[0] = gf_arf_bits;
1731       gf_group->arf_update_idx[0] = arf_buffer_indices[0];
1732       gf_group->arf_ref_idx[0] = arf_buffer_indices[0];
1733     }
1734 
1735     // Step over the golden frame / overlay frame
1736     if (EOF == input_stats(twopass, &frame_stats))
1737       return;
1738   }
1739 
1740   // Deduct the boost bits for arf (or gf if it is not a key frame)
1741   // from the group total.
1742   if (rc->source_alt_ref_pending || !key_frame)
1743     total_group_bits -= gf_arf_bits;
1744 
1745   // Store the bits to spend on the ARF if there is one.
1746   if (rc->source_alt_ref_pending) {
1747     gf_group->update_type[alt_frame_index] = ARF_UPDATE;
1748     gf_group->rf_level[alt_frame_index] = GF_ARF_STD;
1749     gf_group->bit_allocation[alt_frame_index] = gf_arf_bits;
1750 
1751     if (has_temporal_layers)
1752       gf_group->arf_src_offset[alt_frame_index] =
1753           (unsigned char)(rc->baseline_gf_interval -
1754                           cpi->svc.number_temporal_layers);
1755     else
1756       gf_group->arf_src_offset[alt_frame_index] =
1757           (unsigned char)(rc->baseline_gf_interval - 1);
1758 
1759     gf_group->arf_update_idx[alt_frame_index] = arf_buffer_indices[0];
1760     gf_group->arf_ref_idx[alt_frame_index] =
1761       arf_buffer_indices[cpi->multi_arf_last_grp_enabled &&
1762                          rc->source_alt_ref_active];
1763     if (!has_temporal_layers)
1764       ++frame_index;
1765 
1766     if (cpi->multi_arf_enabled) {
1767       // Set aside a slot for a level 1 arf.
1768       gf_group->update_type[frame_index] = ARF_UPDATE;
1769       gf_group->rf_level[frame_index] = GF_ARF_LOW;
1770       gf_group->arf_src_offset[frame_index] =
1771         (unsigned char)((rc->baseline_gf_interval >> 1) - 1);
1772       gf_group->arf_update_idx[frame_index] = arf_buffer_indices[1];
1773       gf_group->arf_ref_idx[frame_index] = arf_buffer_indices[0];
1774       ++frame_index;
1775     }
1776   }
1777 
1778   // Define middle frame
1779   mid_frame_idx = frame_index + (rc->baseline_gf_interval >> 1) - 1;
1780 
1781   // Allocate bits to the other frames in the group.
1782   for (i = 0; i < rc->baseline_gf_interval - rc->source_alt_ref_pending; ++i) {
1783     int arf_idx = 0;
1784     if (EOF == input_stats(twopass, &frame_stats))
1785       break;
1786 
1787     if (has_temporal_layers && frame_index == alt_frame_index) {
1788       ++frame_index;
1789     }
1790 
1791     modified_err = calculate_modified_err(cpi, twopass, oxcf, &frame_stats);
1792 
1793     if (group_error > 0)
1794       err_fraction = modified_err / DOUBLE_DIVIDE_CHECK(group_error);
1795     else
1796       err_fraction = 0.0;
1797 
1798     target_frame_size = (int)((double)total_group_bits * err_fraction);
1799 
1800     if (rc->source_alt_ref_pending && cpi->multi_arf_enabled) {
1801       mid_boost_bits += (target_frame_size >> 4);
1802       target_frame_size -= (target_frame_size >> 4);
1803 
1804       if (frame_index <= mid_frame_idx)
1805         arf_idx = 1;
1806     }
1807     gf_group->arf_update_idx[frame_index] = arf_buffer_indices[arf_idx];
1808     gf_group->arf_ref_idx[frame_index] = arf_buffer_indices[arf_idx];
1809 
1810     target_frame_size = clamp(target_frame_size, 0,
1811                               VPXMIN(max_bits, (int)total_group_bits));
1812 
1813     gf_group->update_type[frame_index] = LF_UPDATE;
1814     gf_group->rf_level[frame_index] = INTER_NORMAL;
1815 
1816     gf_group->bit_allocation[frame_index] = target_frame_size;
1817     ++frame_index;
1818   }
1819 
1820   // Note:
1821   // We need to configure the frame at the end of the sequence + 1 that will be
1822   // the start frame for the next group. Otherwise prior to the call to
1823   // vp9_rc_get_second_pass_params() the data will be undefined.
1824   gf_group->arf_update_idx[frame_index] = arf_buffer_indices[0];
1825   gf_group->arf_ref_idx[frame_index] = arf_buffer_indices[0];
1826 
1827   if (rc->source_alt_ref_pending) {
1828     gf_group->update_type[frame_index] = OVERLAY_UPDATE;
1829     gf_group->rf_level[frame_index] = INTER_NORMAL;
1830 
1831     // Final setup for second arf and its overlay.
1832     if (cpi->multi_arf_enabled) {
1833       gf_group->bit_allocation[2] =
1834           gf_group->bit_allocation[mid_frame_idx] + mid_boost_bits;
1835       gf_group->update_type[mid_frame_idx] = OVERLAY_UPDATE;
1836       gf_group->bit_allocation[mid_frame_idx] = 0;
1837     }
1838   } else {
1839     gf_group->update_type[frame_index] = GF_UPDATE;
1840     gf_group->rf_level[frame_index] = GF_ARF_STD;
1841   }
1842 
1843   // Note whether multi-arf was enabled this group for next time.
1844   cpi->multi_arf_last_grp_enabled = cpi->multi_arf_enabled;
1845 }
1846 
1847 // Analyse and define a gf/arf group.
define_gf_group(VP9_COMP * cpi,FIRSTPASS_STATS * this_frame)1848 static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
1849   VP9_COMMON *const cm = &cpi->common;
1850   RATE_CONTROL *const rc = &cpi->rc;
1851   VP9EncoderConfig *const oxcf = &cpi->oxcf;
1852   TWO_PASS *const twopass = &cpi->twopass;
1853   FIRSTPASS_STATS next_frame;
1854   const FIRSTPASS_STATS *const start_pos = twopass->stats_in;
1855   int i;
1856 
1857   double boost_score = 0.0;
1858   double old_boost_score = 0.0;
1859   double gf_group_err = 0.0;
1860 #if GROUP_ADAPTIVE_MAXQ
1861   double gf_group_raw_error = 0.0;
1862 #endif
1863   double gf_group_skip_pct = 0.0;
1864   double gf_group_inactive_zone_rows = 0.0;
1865   double gf_first_frame_err = 0.0;
1866   double mod_frame_err = 0.0;
1867 
1868   double mv_ratio_accumulator = 0.0;
1869   double decay_accumulator = 1.0;
1870   double zero_motion_accumulator = 1.0;
1871 
1872   double loop_decay_rate = 1.00;
1873   double last_loop_decay_rate = 1.00;
1874 
1875   double this_frame_mv_in_out = 0.0;
1876   double mv_in_out_accumulator = 0.0;
1877   double abs_mv_in_out_accumulator = 0.0;
1878   double mv_ratio_accumulator_thresh;
1879   unsigned int allow_alt_ref = is_altref_enabled(cpi);
1880 
1881   int f_boost = 0;
1882   int b_boost = 0;
1883   int flash_detected;
1884   int active_max_gf_interval;
1885   int active_min_gf_interval;
1886   int64_t gf_group_bits;
1887   double gf_group_error_left;
1888   int gf_arf_bits;
1889   const int is_key_frame = frame_is_intra_only(cm);
1890   const int arf_active_or_kf = is_key_frame || rc->source_alt_ref_active;
1891 
1892   // Reset the GF group data structures unless this is a key
1893   // frame in which case it will already have been done.
1894   if (is_key_frame == 0) {
1895     vp9_zero(twopass->gf_group);
1896   }
1897 
1898   vpx_clear_system_state();
1899   vp9_zero(next_frame);
1900 
1901   // Load stats for the current frame.
1902   mod_frame_err = calculate_modified_err(cpi, twopass, oxcf, this_frame);
1903 
1904   // Note the error of the frame at the start of the group. This will be
1905   // the GF frame error if we code a normal gf.
1906   gf_first_frame_err = mod_frame_err;
1907 
1908   // If this is a key frame or the overlay from a previous arf then
1909   // the error score / cost of this frame has already been accounted for.
1910   if (arf_active_or_kf) {
1911     gf_group_err -= gf_first_frame_err;
1912 #if GROUP_ADAPTIVE_MAXQ
1913     gf_group_raw_error -= this_frame->coded_error;
1914 #endif
1915     gf_group_skip_pct -= this_frame->intra_skip_pct;
1916     gf_group_inactive_zone_rows -= this_frame->inactive_zone_rows;
1917   }
1918 
1919   // Motion breakout threshold for loop below depends on image size.
1920   mv_ratio_accumulator_thresh =
1921       (cpi->initial_height + cpi->initial_width) / 4.0;
1922 
1923   // Set a maximum and minimum interval for the GF group.
1924   // If the image appears almost completely static we can extend beyond this.
1925   {
1926     int int_max_q =
1927       (int)(vp9_convert_qindex_to_q(twopass->active_worst_quality,
1928                                    cpi->common.bit_depth));
1929     int int_lbq =
1930       (int)(vp9_convert_qindex_to_q(rc->last_boosted_qindex,
1931                                    cpi->common.bit_depth));
1932     active_min_gf_interval = rc->min_gf_interval + VPXMIN(2, int_max_q / 200);
1933     if (active_min_gf_interval > rc->max_gf_interval)
1934       active_min_gf_interval = rc->max_gf_interval;
1935 
1936     if (cpi->multi_arf_allowed) {
1937       active_max_gf_interval = rc->max_gf_interval;
1938     } else {
1939       // The value chosen depends on the active Q range. At low Q we have
1940       // bits to spare and are better with a smaller interval and smaller boost.
1941       // At high Q when there are few bits to spare we are better with a longer
1942       // interval to spread the cost of the GF.
1943       active_max_gf_interval = 12 + VPXMIN(4, (int_lbq / 6));
1944       if (active_max_gf_interval < active_min_gf_interval)
1945         active_max_gf_interval = active_min_gf_interval;
1946 
1947       if (active_max_gf_interval > rc->max_gf_interval)
1948         active_max_gf_interval = rc->max_gf_interval;
1949       if (active_max_gf_interval < active_min_gf_interval)
1950         active_max_gf_interval = active_min_gf_interval;
1951     }
1952   }
1953 
1954   i = 0;
1955   while (i < rc->static_scene_max_gf_interval && i < rc->frames_to_key) {
1956     ++i;
1957 
1958     // Accumulate error score of frames in this gf group.
1959     mod_frame_err = calculate_modified_err(cpi, twopass, oxcf, this_frame);
1960     gf_group_err += mod_frame_err;
1961 #if GROUP_ADAPTIVE_MAXQ
1962     gf_group_raw_error += this_frame->coded_error;
1963 #endif
1964     gf_group_skip_pct += this_frame->intra_skip_pct;
1965     gf_group_inactive_zone_rows += this_frame->inactive_zone_rows;
1966 
1967     if (EOF == input_stats(twopass, &next_frame))
1968       break;
1969 
1970     // Test for the case where there is a brief flash but the prediction
1971     // quality back to an earlier frame is then restored.
1972     flash_detected = detect_flash(twopass, 0);
1973 
1974     // Update the motion related elements to the boost calculation.
1975     accumulate_frame_motion_stats(&next_frame,
1976                                   &this_frame_mv_in_out, &mv_in_out_accumulator,
1977                                   &abs_mv_in_out_accumulator,
1978                                   &mv_ratio_accumulator);
1979 
1980     // Accumulate the effect of prediction quality decay.
1981     if (!flash_detected) {
1982       last_loop_decay_rate = loop_decay_rate;
1983       loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
1984 
1985       decay_accumulator = decay_accumulator * loop_decay_rate;
1986 
1987       // Monitor for static sections.
1988       zero_motion_accumulator = VPXMIN(
1989           zero_motion_accumulator, get_zero_motion_factor(cpi, &next_frame));
1990 
1991       // Break clause to detect very still sections after motion. For example,
1992       // a static image after a fade or other transition.
1993       if (detect_transition_to_still(cpi, i, 5, loop_decay_rate,
1994                                      last_loop_decay_rate)) {
1995         allow_alt_ref = 0;
1996         break;
1997       }
1998     }
1999 
2000     // Calculate a boost number for this frame.
2001     boost_score += decay_accumulator * calc_frame_boost(cpi, &next_frame,
2002                                                         this_frame_mv_in_out,
2003                                                         GF_MAX_BOOST);
2004 
2005     // Break out conditions.
2006     if (
2007       // Break at active_max_gf_interval unless almost totally static.
2008       (i >= (active_max_gf_interval + arf_active_or_kf) &&
2009             zero_motion_accumulator < 0.995) ||
2010       (
2011         // Don't break out with a very short interval.
2012         (i >= active_min_gf_interval + arf_active_or_kf) &&
2013         (!flash_detected) &&
2014         ((mv_ratio_accumulator > mv_ratio_accumulator_thresh) ||
2015          (abs_mv_in_out_accumulator > 3.0) ||
2016          (mv_in_out_accumulator < -2.0) ||
2017          ((boost_score - old_boost_score) < BOOST_BREAKOUT)))) {
2018       boost_score = old_boost_score;
2019       break;
2020     }
2021 
2022     *this_frame = next_frame;
2023     old_boost_score = boost_score;
2024   }
2025 
2026   twopass->gf_zeromotion_pct = (int)(zero_motion_accumulator * 1000.0);
2027 
2028   // Was the group length constrained by the requirement for a new KF?
2029   rc->constrained_gf_group = (i >= rc->frames_to_key) ? 1 : 0;
2030 
2031   // Should we use the alternate reference frame.
2032   if (allow_alt_ref &&
2033     (i < cpi->oxcf.lag_in_frames) &&
2034     (i >= rc->min_gf_interval)) {
2035     // Calculate the boost for alt ref.
2036     rc->gfu_boost = calc_arf_boost(cpi, 0, (i - 1), (i - 1), &f_boost,
2037       &b_boost);
2038     rc->source_alt_ref_pending = 1;
2039 
2040     // Test to see if multi arf is appropriate.
2041     cpi->multi_arf_enabled =
2042       (cpi->multi_arf_allowed && (rc->baseline_gf_interval >= 6) &&
2043       (zero_motion_accumulator < 0.995)) ? 1 : 0;
2044   } else {
2045     rc->gfu_boost = VPXMAX((int)boost_score, MIN_ARF_GF_BOOST);
2046     rc->source_alt_ref_pending = 0;
2047   }
2048 
2049   // Set the interval until the next gf.
2050   rc->baseline_gf_interval = i - (is_key_frame || rc->source_alt_ref_pending);
2051 
2052   // Only encode alt reference frame in temporal base layer. So
2053   // baseline_gf_interval should be multiple of a temporal layer group
2054   // (typically the frame distance between two base layer frames)
2055   if (is_two_pass_svc(cpi) && cpi->svc.number_temporal_layers > 1) {
2056     int count = (1 << (cpi->svc.number_temporal_layers - 1)) - 1;
2057     int new_gf_interval = (rc->baseline_gf_interval + count) & (~count);
2058     int j;
2059     for (j = 0; j < new_gf_interval - rc->baseline_gf_interval; ++j) {
2060       if (EOF == input_stats(twopass, this_frame))
2061         break;
2062       gf_group_err += calculate_modified_err(cpi, twopass, oxcf, this_frame);
2063 #if GROUP_ADAPTIVE_MAXQ
2064       gf_group_raw_error += this_frame->coded_error;
2065 #endif
2066       gf_group_skip_pct += this_frame->intra_skip_pct;
2067       gf_group_inactive_zone_rows += this_frame->inactive_zone_rows;
2068     }
2069     rc->baseline_gf_interval = new_gf_interval;
2070   }
2071 
2072   rc->frames_till_gf_update_due = rc->baseline_gf_interval;
2073 
2074   // Reset the file position.
2075   reset_fpf_position(twopass, start_pos);
2076 
2077   // Calculate the bits to be allocated to the gf/arf group as a whole
2078   gf_group_bits = calculate_total_gf_group_bits(cpi, gf_group_err);
2079 
2080 #if GROUP_ADAPTIVE_MAXQ
2081   // Calculate an estimate of the maxq needed for the group.
2082   // We are more agressive about correcting for sections
2083   // where there could be significant overshoot than for easier
2084   // sections where we do not wish to risk creating an overshoot
2085   // of the allocated bit budget.
2086   if ((cpi->oxcf.rc_mode != VPX_Q) && (rc->baseline_gf_interval > 1)) {
2087     const int vbr_group_bits_per_frame =
2088       (int)(gf_group_bits / rc->baseline_gf_interval);
2089     const double group_av_err = gf_group_raw_error  / rc->baseline_gf_interval;
2090     const double group_av_skip_pct =
2091       gf_group_skip_pct / rc->baseline_gf_interval;
2092     const double group_av_inactive_zone =
2093       ((gf_group_inactive_zone_rows * 2) /
2094        (rc->baseline_gf_interval * (double)cm->mb_rows));
2095 
2096     int tmp_q;
2097     // rc factor is a weight factor that corrects for local rate control drift.
2098     double rc_factor = 1.0;
2099     if (rc->rate_error_estimate > 0) {
2100       rc_factor = VPXMAX(RC_FACTOR_MIN,
2101                          (double)(100 - rc->rate_error_estimate) / 100.0);
2102     } else {
2103       rc_factor = VPXMIN(RC_FACTOR_MAX,
2104                          (double)(100 - rc->rate_error_estimate) / 100.0);
2105     }
2106     tmp_q =
2107       get_twopass_worst_quality(cpi, group_av_err,
2108                                 (group_av_skip_pct + group_av_inactive_zone),
2109                                 vbr_group_bits_per_frame,
2110                                 twopass->kfgroup_inter_fraction * rc_factor);
2111     twopass->active_worst_quality =
2112         VPXMAX(tmp_q, twopass->active_worst_quality >> 1);
2113   }
2114 #endif
2115 
2116   // Calculate the extra bits to be used for boosted frame(s)
2117   gf_arf_bits = calculate_boost_bits(rc->baseline_gf_interval,
2118                                      rc->gfu_boost, gf_group_bits);
2119 
2120   // Adjust KF group bits and error remaining.
2121   twopass->kf_group_error_left -= (int64_t)gf_group_err;
2122 
2123   // If this is an arf update we want to remove the score for the overlay
2124   // frame at the end which will usually be very cheap to code.
2125   // The overlay frame has already, in effect, been coded so we want to spread
2126   // the remaining bits among the other frames.
2127   // For normal GFs remove the score for the GF itself unless this is
2128   // also a key frame in which case it has already been accounted for.
2129   if (rc->source_alt_ref_pending) {
2130     gf_group_error_left = gf_group_err - mod_frame_err;
2131   } else if (is_key_frame == 0) {
2132     gf_group_error_left = gf_group_err - gf_first_frame_err;
2133   } else {
2134     gf_group_error_left = gf_group_err;
2135   }
2136 
2137   // Allocate bits to each of the frames in the GF group.
2138   allocate_gf_group_bits(cpi, gf_group_bits, gf_group_error_left, gf_arf_bits);
2139 
2140   // Reset the file position.
2141   reset_fpf_position(twopass, start_pos);
2142 
2143   // Calculate a section intra ratio used in setting max loop filter.
2144   if (cpi->common.frame_type != KEY_FRAME) {
2145     twopass->section_intra_rating =
2146         calculate_section_intra_ratio(start_pos, twopass->stats_in_end,
2147                                       rc->baseline_gf_interval);
2148   }
2149 
2150   if (oxcf->resize_mode == RESIZE_DYNAMIC) {
2151     // Default to starting GF groups at normal frame size.
2152     cpi->rc.next_frame_size_selector = UNSCALED;
2153   }
2154 }
2155 
2156 // Threshold for use of the lagging second reference frame. High second ref
2157 // usage may point to a transient event like a flash or occlusion rather than
2158 // a real scene cut.
2159 #define SECOND_REF_USEAGE_THRESH 0.1
2160 // Minimum % intra coding observed in first pass (1.0 = 100%)
2161 #define MIN_INTRA_LEVEL 0.25
2162 // Minimum ratio between the % of intra coding and inter coding in the first
2163 // pass after discounting neutral blocks (discounting neutral blocks in this
2164 // way helps catch scene cuts in clips with very flat areas or letter box
2165 // format clips with image padding.
2166 #define INTRA_VS_INTER_THRESH 2.0
2167 // Hard threshold where the first pass chooses intra for almost all blocks.
2168 // In such a case even if the frame is not a scene cut coding a key frame
2169 // may be a good option.
2170 #define VERY_LOW_INTER_THRESH 0.05
2171 // Maximum threshold for the relative ratio of intra error score vs best
2172 // inter error score.
2173 #define KF_II_ERR_THRESHOLD 2.5
2174 // In real scene cuts there is almost always a sharp change in the intra
2175 // or inter error score.
2176 #define ERR_CHANGE_THRESHOLD 0.4
2177 // For real scene cuts we expect an improvment in the intra inter error
2178 // ratio in the next frame.
2179 #define II_IMPROVEMENT_THRESHOLD 3.5
2180 #define KF_II_MAX 128.0
2181 
test_candidate_kf(TWO_PASS * twopass,const FIRSTPASS_STATS * last_frame,const FIRSTPASS_STATS * this_frame,const FIRSTPASS_STATS * next_frame)2182 static int test_candidate_kf(TWO_PASS *twopass,
2183                              const FIRSTPASS_STATS *last_frame,
2184                              const FIRSTPASS_STATS *this_frame,
2185                              const FIRSTPASS_STATS *next_frame) {
2186   int is_viable_kf = 0;
2187   double pcnt_intra = 1.0 - this_frame->pcnt_inter;
2188   double modified_pcnt_inter =
2189     this_frame->pcnt_inter - this_frame->pcnt_neutral;
2190 
2191   // Does the frame satisfy the primary criteria of a key frame?
2192   // See above for an explanation of the test criteria.
2193   // If so, then examine how well it predicts subsequent frames.
2194   if ((this_frame->pcnt_second_ref < SECOND_REF_USEAGE_THRESH) &&
2195       (next_frame->pcnt_second_ref < SECOND_REF_USEAGE_THRESH) &&
2196       ((this_frame->pcnt_inter < VERY_LOW_INTER_THRESH) ||
2197        ((pcnt_intra > MIN_INTRA_LEVEL) &&
2198         (pcnt_intra > (INTRA_VS_INTER_THRESH * modified_pcnt_inter)) &&
2199         ((this_frame->intra_error /
2200           DOUBLE_DIVIDE_CHECK(this_frame->coded_error)) <
2201           KF_II_ERR_THRESHOLD) &&
2202         ((fabs(last_frame->coded_error - this_frame->coded_error) /
2203           DOUBLE_DIVIDE_CHECK(this_frame->coded_error) >
2204           ERR_CHANGE_THRESHOLD) ||
2205          (fabs(last_frame->intra_error - this_frame->intra_error) /
2206           DOUBLE_DIVIDE_CHECK(this_frame->intra_error) >
2207           ERR_CHANGE_THRESHOLD) ||
2208          ((next_frame->intra_error /
2209           DOUBLE_DIVIDE_CHECK(next_frame->coded_error)) >
2210           II_IMPROVEMENT_THRESHOLD))))) {
2211     int i;
2212     const FIRSTPASS_STATS *start_pos = twopass->stats_in;
2213     FIRSTPASS_STATS local_next_frame = *next_frame;
2214     double boost_score = 0.0;
2215     double old_boost_score = 0.0;
2216     double decay_accumulator = 1.0;
2217 
2218     // Examine how well the key frame predicts subsequent frames.
2219     for (i = 0; i < 16; ++i) {
2220       double next_iiratio = (BOOST_FACTOR * local_next_frame.intra_error /
2221                              DOUBLE_DIVIDE_CHECK(local_next_frame.coded_error));
2222 
2223       if (next_iiratio > KF_II_MAX)
2224         next_iiratio = KF_II_MAX;
2225 
2226       // Cumulative effect of decay in prediction quality.
2227       if (local_next_frame.pcnt_inter > 0.85)
2228         decay_accumulator *= local_next_frame.pcnt_inter;
2229       else
2230         decay_accumulator *= (0.85 + local_next_frame.pcnt_inter) / 2.0;
2231 
2232       // Keep a running total.
2233       boost_score += (decay_accumulator * next_iiratio);
2234 
2235       // Test various breakout clauses.
2236       if ((local_next_frame.pcnt_inter < 0.05) ||
2237           (next_iiratio < 1.5) ||
2238           (((local_next_frame.pcnt_inter -
2239              local_next_frame.pcnt_neutral) < 0.20) &&
2240            (next_iiratio < 3.0)) ||
2241           ((boost_score - old_boost_score) < 3.0) ||
2242           (local_next_frame.intra_error < 200)) {
2243         break;
2244       }
2245 
2246       old_boost_score = boost_score;
2247 
2248       // Get the next frame details
2249       if (EOF == input_stats(twopass, &local_next_frame))
2250         break;
2251     }
2252 
2253     // If there is tolerable prediction for at least the next 3 frames then
2254     // break out else discard this potential key frame and move on
2255     if (boost_score > 30.0 && (i > 3)) {
2256       is_viable_kf = 1;
2257     } else {
2258       // Reset the file position
2259       reset_fpf_position(twopass, start_pos);
2260 
2261       is_viable_kf = 0;
2262     }
2263   }
2264 
2265   return is_viable_kf;
2266 }
2267 
find_next_key_frame(VP9_COMP * cpi,FIRSTPASS_STATS * this_frame)2268 static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
2269   int i, j;
2270   RATE_CONTROL *const rc = &cpi->rc;
2271   TWO_PASS *const twopass = &cpi->twopass;
2272   GF_GROUP *const gf_group = &twopass->gf_group;
2273   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
2274   const FIRSTPASS_STATS first_frame = *this_frame;
2275   const FIRSTPASS_STATS *const start_position = twopass->stats_in;
2276   FIRSTPASS_STATS next_frame;
2277   FIRSTPASS_STATS last_frame;
2278   int kf_bits = 0;
2279   int loop_decay_counter = 0;
2280   double decay_accumulator = 1.0;
2281   double av_decay_accumulator = 0.0;
2282   double zero_motion_accumulator = 1.0;
2283   double boost_score = 0.0;
2284   double kf_mod_err = 0.0;
2285   double kf_group_err = 0.0;
2286   double recent_loop_decay[8] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
2287 
2288   vp9_zero(next_frame);
2289 
2290   cpi->common.frame_type = KEY_FRAME;
2291 
2292   // Reset the GF group data structures.
2293   vp9_zero(*gf_group);
2294 
2295   // Is this a forced key frame by interval.
2296   rc->this_key_frame_forced = rc->next_key_frame_forced;
2297 
2298   // Clear the alt ref active flag and last group multi arf flags as they
2299   // can never be set for a key frame.
2300   rc->source_alt_ref_active = 0;
2301   cpi->multi_arf_last_grp_enabled = 0;
2302 
2303   // KF is always a GF so clear frames till next gf counter.
2304   rc->frames_till_gf_update_due = 0;
2305 
2306   rc->frames_to_key = 1;
2307 
2308   twopass->kf_group_bits = 0;        // Total bits available to kf group
2309   twopass->kf_group_error_left = 0;  // Group modified error score.
2310 
2311   kf_mod_err = calculate_modified_err(cpi, twopass, oxcf, this_frame);
2312 
2313   // Find the next keyframe.
2314   i = 0;
2315   while (twopass->stats_in < twopass->stats_in_end &&
2316          rc->frames_to_key < cpi->oxcf.key_freq) {
2317     // Accumulate kf group error.
2318     kf_group_err += calculate_modified_err(cpi, twopass, oxcf, this_frame);
2319 
2320     // Load the next frame's stats.
2321     last_frame = *this_frame;
2322     input_stats(twopass, this_frame);
2323 
2324     // Provided that we are not at the end of the file...
2325     if (cpi->oxcf.auto_key && twopass->stats_in < twopass->stats_in_end) {
2326       double loop_decay_rate;
2327 
2328       // Check for a scene cut.
2329       if (test_candidate_kf(twopass, &last_frame, this_frame,
2330                             twopass->stats_in))
2331         break;
2332 
2333       // How fast is the prediction quality decaying?
2334       loop_decay_rate = get_prediction_decay_rate(cpi, twopass->stats_in);
2335 
2336       // We want to know something about the recent past... rather than
2337       // as used elsewhere where we are concerned with decay in prediction
2338       // quality since the last GF or KF.
2339       recent_loop_decay[i % 8] = loop_decay_rate;
2340       decay_accumulator = 1.0;
2341       for (j = 0; j < 8; ++j)
2342         decay_accumulator *= recent_loop_decay[j];
2343 
2344       // Special check for transition or high motion followed by a
2345       // static scene.
2346       if (detect_transition_to_still(cpi, i, cpi->oxcf.key_freq - i,
2347                                      loop_decay_rate, decay_accumulator))
2348         break;
2349 
2350       // Step on to the next frame.
2351       ++rc->frames_to_key;
2352 
2353       // If we don't have a real key frame within the next two
2354       // key_freq intervals then break out of the loop.
2355       if (rc->frames_to_key >= 2 * cpi->oxcf.key_freq)
2356         break;
2357     } else {
2358       ++rc->frames_to_key;
2359     }
2360     ++i;
2361   }
2362 
2363   // If there is a max kf interval set by the user we must obey it.
2364   // We already breakout of the loop above at 2x max.
2365   // This code centers the extra kf if the actual natural interval
2366   // is between 1x and 2x.
2367   if (cpi->oxcf.auto_key &&
2368       rc->frames_to_key > cpi->oxcf.key_freq) {
2369     FIRSTPASS_STATS tmp_frame = first_frame;
2370 
2371     rc->frames_to_key /= 2;
2372 
2373     // Reset to the start of the group.
2374     reset_fpf_position(twopass, start_position);
2375 
2376     kf_group_err = 0.0;
2377 
2378     // Rescan to get the correct error data for the forced kf group.
2379     for (i = 0; i < rc->frames_to_key; ++i) {
2380       kf_group_err += calculate_modified_err(cpi, twopass, oxcf, &tmp_frame);
2381       input_stats(twopass, &tmp_frame);
2382     }
2383     rc->next_key_frame_forced = 1;
2384   } else if (twopass->stats_in == twopass->stats_in_end ||
2385              rc->frames_to_key >= cpi->oxcf.key_freq) {
2386     rc->next_key_frame_forced = 1;
2387   } else {
2388     rc->next_key_frame_forced = 0;
2389   }
2390 
2391   if (is_two_pass_svc(cpi) && cpi->svc.number_temporal_layers > 1) {
2392     int count = (1 << (cpi->svc.number_temporal_layers - 1)) - 1;
2393     int new_frame_to_key = (rc->frames_to_key + count) & (~count);
2394     int j;
2395     for (j = 0; j < new_frame_to_key - rc->frames_to_key; ++j) {
2396       if (EOF == input_stats(twopass, this_frame))
2397         break;
2398       kf_group_err += calculate_modified_err(cpi, twopass, oxcf, this_frame);
2399     }
2400     rc->frames_to_key = new_frame_to_key;
2401   }
2402 
2403   // Special case for the last key frame of the file.
2404   if (twopass->stats_in >= twopass->stats_in_end) {
2405     // Accumulate kf group error.
2406     kf_group_err += calculate_modified_err(cpi, twopass, oxcf, this_frame);
2407   }
2408 
2409   // Calculate the number of bits that should be assigned to the kf group.
2410   if (twopass->bits_left > 0 && twopass->modified_error_left > 0.0) {
2411     // Maximum number of bits for a single normal frame (not key frame).
2412     const int max_bits = frame_max_bits(rc, &cpi->oxcf);
2413 
2414     // Maximum number of bits allocated to the key frame group.
2415     int64_t max_grp_bits;
2416 
2417     // Default allocation based on bits left and relative
2418     // complexity of the section.
2419     twopass->kf_group_bits = (int64_t)(twopass->bits_left *
2420        (kf_group_err / twopass->modified_error_left));
2421 
2422     // Clip based on maximum per frame rate defined by the user.
2423     max_grp_bits = (int64_t)max_bits * (int64_t)rc->frames_to_key;
2424     if (twopass->kf_group_bits > max_grp_bits)
2425       twopass->kf_group_bits = max_grp_bits;
2426   } else {
2427     twopass->kf_group_bits = 0;
2428   }
2429   twopass->kf_group_bits = VPXMAX(0, twopass->kf_group_bits);
2430 
2431   // Reset the first pass file position.
2432   reset_fpf_position(twopass, start_position);
2433 
2434   // Scan through the kf group collating various stats used to determine
2435   // how many bits to spend on it.
2436   decay_accumulator = 1.0;
2437   boost_score = 0.0;
2438   for (i = 0; i < (rc->frames_to_key - 1); ++i) {
2439     if (EOF == input_stats(twopass, &next_frame))
2440       break;
2441 
2442     // Monitor for static sections.
2443     zero_motion_accumulator = VPXMIN(
2444         zero_motion_accumulator, get_zero_motion_factor(cpi, &next_frame));
2445 
2446     // Not all frames in the group are necessarily used in calculating boost.
2447     if ((i <= rc->max_gf_interval) ||
2448         ((i <= (rc->max_gf_interval * 4)) && (decay_accumulator > 0.5))) {
2449       const double frame_boost =
2450         calc_frame_boost(cpi, &next_frame, 0, KF_MAX_BOOST);
2451 
2452       // How fast is prediction quality decaying.
2453       if (!detect_flash(twopass, 0)) {
2454         const double loop_decay_rate =
2455           get_prediction_decay_rate(cpi, &next_frame);
2456         decay_accumulator *= loop_decay_rate;
2457         decay_accumulator = VPXMAX(decay_accumulator, MIN_DECAY_FACTOR);
2458         av_decay_accumulator += decay_accumulator;
2459         ++loop_decay_counter;
2460       }
2461       boost_score += (decay_accumulator * frame_boost);
2462     }
2463   }
2464   av_decay_accumulator /= (double)loop_decay_counter;
2465 
2466   reset_fpf_position(twopass, start_position);
2467 
2468   // Store the zero motion percentage
2469   twopass->kf_zeromotion_pct = (int)(zero_motion_accumulator * 100.0);
2470 
2471   // Calculate a section intra ratio used in setting max loop filter.
2472   twopass->section_intra_rating =
2473       calculate_section_intra_ratio(start_position, twopass->stats_in_end,
2474                                     rc->frames_to_key);
2475 
2476   // Apply various clamps for min and max boost
2477   rc->kf_boost = (int)(av_decay_accumulator * boost_score);
2478   rc->kf_boost = VPXMAX(rc->kf_boost, (rc->frames_to_key * 3));
2479   rc->kf_boost = VPXMAX(rc->kf_boost, MIN_KF_BOOST);
2480 
2481   // Work out how many bits to allocate for the key frame itself.
2482   kf_bits = calculate_boost_bits((rc->frames_to_key - 1),
2483                                   rc->kf_boost, twopass->kf_group_bits);
2484 
2485   // Work out the fraction of the kf group bits reserved for the inter frames
2486   // within the group after discounting the bits for the kf itself.
2487   if (twopass->kf_group_bits) {
2488     twopass->kfgroup_inter_fraction =
2489       (double)(twopass->kf_group_bits - kf_bits) /
2490       (double)twopass->kf_group_bits;
2491   } else {
2492     twopass->kfgroup_inter_fraction = 1.0;
2493   }
2494 
2495   twopass->kf_group_bits -= kf_bits;
2496 
2497   // Save the bits to spend on the key frame.
2498   gf_group->bit_allocation[0] = kf_bits;
2499   gf_group->update_type[0] = KF_UPDATE;
2500   gf_group->rf_level[0] = KF_STD;
2501 
2502   // Note the total error score of the kf group minus the key frame itself.
2503   twopass->kf_group_error_left = (int)(kf_group_err - kf_mod_err);
2504 
2505   // Adjust the count of total modified error left.
2506   // The count of bits left is adjusted elsewhere based on real coded frame
2507   // sizes.
2508   twopass->modified_error_left -= kf_group_err;
2509 
2510   if (oxcf->resize_mode == RESIZE_DYNAMIC) {
2511     // Default to normal-sized frame on keyframes.
2512     cpi->rc.next_frame_size_selector = UNSCALED;
2513   }
2514 }
2515 
2516 // Define the reference buffers that will be updated post encode.
configure_buffer_updates(VP9_COMP * cpi)2517 static void configure_buffer_updates(VP9_COMP *cpi) {
2518   TWO_PASS *const twopass = &cpi->twopass;
2519 
2520   cpi->rc.is_src_frame_alt_ref = 0;
2521   switch (twopass->gf_group.update_type[twopass->gf_group.index]) {
2522     case KF_UPDATE:
2523       cpi->refresh_last_frame = 1;
2524       cpi->refresh_golden_frame = 1;
2525       cpi->refresh_alt_ref_frame = 1;
2526       break;
2527     case LF_UPDATE:
2528       cpi->refresh_last_frame = 1;
2529       cpi->refresh_golden_frame = 0;
2530       cpi->refresh_alt_ref_frame = 0;
2531       break;
2532     case GF_UPDATE:
2533       cpi->refresh_last_frame = 1;
2534       cpi->refresh_golden_frame = 1;
2535       cpi->refresh_alt_ref_frame = 0;
2536       break;
2537     case OVERLAY_UPDATE:
2538       cpi->refresh_last_frame = 0;
2539       cpi->refresh_golden_frame = 1;
2540       cpi->refresh_alt_ref_frame = 0;
2541       cpi->rc.is_src_frame_alt_ref = 1;
2542       break;
2543     case ARF_UPDATE:
2544       cpi->refresh_last_frame = 0;
2545       cpi->refresh_golden_frame = 0;
2546       cpi->refresh_alt_ref_frame = 1;
2547       break;
2548     default:
2549       assert(0);
2550       break;
2551   }
2552   if (is_two_pass_svc(cpi)) {
2553     if (cpi->svc.temporal_layer_id > 0) {
2554       cpi->refresh_last_frame = 0;
2555       cpi->refresh_golden_frame = 0;
2556     }
2557     if (cpi->svc.layer_context[cpi->svc.spatial_layer_id].gold_ref_idx < 0)
2558       cpi->refresh_golden_frame = 0;
2559     if (cpi->alt_ref_source == NULL)
2560       cpi->refresh_alt_ref_frame = 0;
2561   }
2562 }
2563 
is_skippable_frame(const VP9_COMP * cpi)2564 static int is_skippable_frame(const VP9_COMP *cpi) {
2565   // If the current frame does not have non-zero motion vector detected in the
2566   // first  pass, and so do its previous and forward frames, then this frame
2567   // can be skipped for partition check, and the partition size is assigned
2568   // according to the variance
2569   const SVC *const svc = &cpi->svc;
2570   const TWO_PASS *const twopass = is_two_pass_svc(cpi) ?
2571       &svc->layer_context[svc->spatial_layer_id].twopass : &cpi->twopass;
2572 
2573   return (!frame_is_intra_only(&cpi->common) &&
2574     twopass->stats_in - 2 > twopass->stats_in_start &&
2575     twopass->stats_in < twopass->stats_in_end &&
2576     (twopass->stats_in - 1)->pcnt_inter - (twopass->stats_in - 1)->pcnt_motion
2577     == 1 &&
2578     (twopass->stats_in - 2)->pcnt_inter - (twopass->stats_in - 2)->pcnt_motion
2579     == 1 &&
2580     twopass->stats_in->pcnt_inter - twopass->stats_in->pcnt_motion == 1);
2581 }
2582 
vp9_rc_get_second_pass_params(VP9_COMP * cpi)2583 void vp9_rc_get_second_pass_params(VP9_COMP *cpi) {
2584   VP9_COMMON *const cm = &cpi->common;
2585   RATE_CONTROL *const rc = &cpi->rc;
2586   TWO_PASS *const twopass = &cpi->twopass;
2587   GF_GROUP *const gf_group = &twopass->gf_group;
2588   int frames_left;
2589   FIRSTPASS_STATS this_frame;
2590 
2591   int target_rate;
2592   LAYER_CONTEXT *const lc = is_two_pass_svc(cpi) ?
2593         &cpi->svc.layer_context[cpi->svc.spatial_layer_id] : 0;
2594 
2595   if (lc != NULL) {
2596     frames_left = (int)(twopass->total_stats.count -
2597                   lc->current_video_frame_in_layer);
2598   } else {
2599     frames_left = (int)(twopass->total_stats.count -
2600                   cm->current_video_frame);
2601   }
2602 
2603   if (!twopass->stats_in)
2604     return;
2605 
2606   // If this is an arf frame then we dont want to read the stats file or
2607   // advance the input pointer as we already have what we need.
2608   if (gf_group->update_type[gf_group->index] == ARF_UPDATE) {
2609     int target_rate;
2610     configure_buffer_updates(cpi);
2611     target_rate = gf_group->bit_allocation[gf_group->index];
2612     target_rate = vp9_rc_clamp_pframe_target_size(cpi, target_rate);
2613     rc->base_frame_target = target_rate;
2614 
2615     cm->frame_type = INTER_FRAME;
2616 
2617     if (lc != NULL) {
2618       if (cpi->svc.spatial_layer_id == 0) {
2619         lc->is_key_frame = 0;
2620       } else {
2621         lc->is_key_frame = cpi->svc.layer_context[0].is_key_frame;
2622 
2623         if (lc->is_key_frame)
2624           cpi->ref_frame_flags &= (~VP9_LAST_FLAG);
2625       }
2626     }
2627 
2628     // Do the firstpass stats indicate that this frame is skippable for the
2629     // partition search?
2630     if (cpi->sf.allow_partition_search_skip &&
2631         cpi->oxcf.pass == 2 && (!cpi->use_svc || is_two_pass_svc(cpi))) {
2632       cpi->partition_search_skippable_frame = is_skippable_frame(cpi);
2633     }
2634 
2635     return;
2636   }
2637 
2638   vpx_clear_system_state();
2639 
2640   if (cpi->oxcf.rc_mode == VPX_Q) {
2641     twopass->active_worst_quality = cpi->oxcf.cq_level;
2642   } else if (cm->current_video_frame == 0 ||
2643              (lc != NULL && lc->current_video_frame_in_layer == 0)) {
2644     // Special case code for first frame.
2645     const int section_target_bandwidth = (int)(twopass->bits_left /
2646                                                frames_left);
2647     const double section_length = twopass->total_left_stats.count;
2648     const double section_error =
2649       twopass->total_left_stats.coded_error / section_length;
2650     const double section_intra_skip =
2651       twopass->total_left_stats.intra_skip_pct / section_length;
2652     const double section_inactive_zone =
2653       (twopass->total_left_stats.inactive_zone_rows * 2) /
2654       ((double)cm->mb_rows * section_length);
2655     const int tmp_q =
2656       get_twopass_worst_quality(cpi, section_error,
2657                                 section_intra_skip + section_inactive_zone,
2658                                 section_target_bandwidth, DEFAULT_GRP_WEIGHT);
2659 
2660     twopass->active_worst_quality = tmp_q;
2661     twopass->baseline_active_worst_quality = tmp_q;
2662     rc->ni_av_qi = tmp_q;
2663     rc->last_q[INTER_FRAME] = tmp_q;
2664     rc->avg_q = vp9_convert_qindex_to_q(tmp_q, cm->bit_depth);
2665     rc->avg_frame_qindex[INTER_FRAME] = tmp_q;
2666     rc->last_q[KEY_FRAME] = (tmp_q + cpi->oxcf.best_allowed_q) / 2;
2667     rc->avg_frame_qindex[KEY_FRAME] = rc->last_q[KEY_FRAME];
2668   }
2669   vp9_zero(this_frame);
2670   if (EOF == input_stats(twopass, &this_frame))
2671     return;
2672 
2673   // Set the frame content type flag.
2674   if (this_frame.intra_skip_pct >= FC_ANIMATION_THRESH)
2675     twopass->fr_content_type = FC_GRAPHICS_ANIMATION;
2676   else
2677     twopass->fr_content_type = FC_NORMAL;
2678 
2679   // Keyframe and section processing.
2680   if (rc->frames_to_key == 0 || (cpi->frame_flags & FRAMEFLAGS_KEY)) {
2681     FIRSTPASS_STATS this_frame_copy;
2682     this_frame_copy = this_frame;
2683     // Define next KF group and assign bits to it.
2684     find_next_key_frame(cpi, &this_frame);
2685     this_frame = this_frame_copy;
2686   } else {
2687     cm->frame_type = INTER_FRAME;
2688   }
2689 
2690   if (lc != NULL) {
2691     if (cpi->svc.spatial_layer_id == 0) {
2692       lc->is_key_frame = (cm->frame_type == KEY_FRAME);
2693       if (lc->is_key_frame) {
2694         cpi->ref_frame_flags &=
2695             (~VP9_LAST_FLAG & ~VP9_GOLD_FLAG & ~VP9_ALT_FLAG);
2696         lc->frames_from_key_frame = 0;
2697         // Encode an intra only empty frame since we have a key frame.
2698         cpi->svc.encode_intra_empty_frame = 1;
2699       }
2700     } else {
2701       cm->frame_type = INTER_FRAME;
2702       lc->is_key_frame = cpi->svc.layer_context[0].is_key_frame;
2703 
2704       if (lc->is_key_frame) {
2705         cpi->ref_frame_flags &= (~VP9_LAST_FLAG);
2706         lc->frames_from_key_frame = 0;
2707       }
2708     }
2709   }
2710 
2711   // Define a new GF/ARF group. (Should always enter here for key frames).
2712   if (rc->frames_till_gf_update_due == 0) {
2713     define_gf_group(cpi, &this_frame);
2714 
2715     rc->frames_till_gf_update_due = rc->baseline_gf_interval;
2716     if (lc != NULL)
2717       cpi->refresh_golden_frame = 1;
2718 
2719 #if ARF_STATS_OUTPUT
2720     {
2721       FILE *fpfile;
2722       fpfile = fopen("arf.stt", "a");
2723       ++arf_count;
2724       fprintf(fpfile, "%10d %10ld %10d %10d %10ld\n",
2725               cm->current_video_frame, rc->frames_till_gf_update_due,
2726               rc->kf_boost, arf_count, rc->gfu_boost);
2727 
2728       fclose(fpfile);
2729     }
2730 #endif
2731   }
2732 
2733   configure_buffer_updates(cpi);
2734 
2735   // Do the firstpass stats indicate that this frame is skippable for the
2736   // partition search?
2737   if (cpi->sf.allow_partition_search_skip && cpi->oxcf.pass == 2 &&
2738       (!cpi->use_svc || is_two_pass_svc(cpi))) {
2739     cpi->partition_search_skippable_frame = is_skippable_frame(cpi);
2740   }
2741 
2742   target_rate = gf_group->bit_allocation[gf_group->index];
2743   rc->base_frame_target = target_rate;
2744 
2745   {
2746     const int num_mbs = (cpi->oxcf.resize_mode != RESIZE_NONE)
2747                         ? cpi->initial_mbs : cpi->common.MBs;
2748     // The multiplication by 256 reverses a scaling factor of (>> 8)
2749     // applied when combining MB error values for the frame.
2750     twopass->mb_av_energy =
2751       log(((this_frame.intra_error * 256.0) / num_mbs) + 1.0);
2752   }
2753 
2754   // Update the total stats remaining structure.
2755   subtract_stats(&twopass->total_left_stats, &this_frame);
2756 }
2757 
2758 #define MINQ_ADJ_LIMIT 48
2759 #define MINQ_ADJ_LIMIT_CQ 20
2760 #define HIGH_UNDERSHOOT_RATIO 2
vp9_twopass_postencode_update(VP9_COMP * cpi)2761 void vp9_twopass_postencode_update(VP9_COMP *cpi) {
2762   TWO_PASS *const twopass = &cpi->twopass;
2763   RATE_CONTROL *const rc = &cpi->rc;
2764   const int bits_used = rc->base_frame_target;
2765 
2766   // VBR correction is done through rc->vbr_bits_off_target. Based on the
2767   // sign of this value, a limited % adjustment is made to the target rate
2768   // of subsequent frames, to try and push it back towards 0. This method
2769   // is designed to prevent extreme behaviour at the end of a clip
2770   // or group of frames.
2771   rc->vbr_bits_off_target += rc->base_frame_target - rc->projected_frame_size;
2772   twopass->bits_left = VPXMAX(twopass->bits_left - bits_used, 0);
2773 
2774   // Calculate the pct rc error.
2775   if (rc->total_actual_bits) {
2776     rc->rate_error_estimate =
2777       (int)((rc->vbr_bits_off_target * 100) / rc->total_actual_bits);
2778     rc->rate_error_estimate = clamp(rc->rate_error_estimate, -100, 100);
2779   } else {
2780     rc->rate_error_estimate = 0;
2781   }
2782 
2783   if (cpi->common.frame_type != KEY_FRAME &&
2784       !vp9_is_upper_layer_key_frame(cpi)) {
2785     twopass->kf_group_bits -= bits_used;
2786     twopass->last_kfgroup_zeromotion_pct = twopass->kf_zeromotion_pct;
2787   }
2788   twopass->kf_group_bits = VPXMAX(twopass->kf_group_bits, 0);
2789 
2790   // Increment the gf group index ready for the next frame.
2791   ++twopass->gf_group.index;
2792 
2793   // If the rate control is drifting consider adjustment to min or maxq.
2794   if ((cpi->oxcf.rc_mode != VPX_Q) &&
2795       (cpi->twopass.gf_zeromotion_pct < VLOW_MOTION_THRESHOLD) &&
2796       !cpi->rc.is_src_frame_alt_ref) {
2797     const int maxq_adj_limit =
2798       rc->worst_quality - twopass->active_worst_quality;
2799     const int minq_adj_limit =
2800         (cpi->oxcf.rc_mode == VPX_CQ ? MINQ_ADJ_LIMIT_CQ : MINQ_ADJ_LIMIT);
2801 
2802     // Undershoot.
2803     if (rc->rate_error_estimate > cpi->oxcf.under_shoot_pct) {
2804       --twopass->extend_maxq;
2805       if (rc->rolling_target_bits >= rc->rolling_actual_bits)
2806         ++twopass->extend_minq;
2807     // Overshoot.
2808     } else if (rc->rate_error_estimate < -cpi->oxcf.over_shoot_pct) {
2809       --twopass->extend_minq;
2810       if (rc->rolling_target_bits < rc->rolling_actual_bits)
2811         ++twopass->extend_maxq;
2812     } else {
2813       // Adjustment for extreme local overshoot.
2814       if (rc->projected_frame_size > (2 * rc->base_frame_target) &&
2815           rc->projected_frame_size > (2 * rc->avg_frame_bandwidth))
2816         ++twopass->extend_maxq;
2817 
2818       // Unwind undershoot or overshoot adjustment.
2819       if (rc->rolling_target_bits < rc->rolling_actual_bits)
2820         --twopass->extend_minq;
2821       else if (rc->rolling_target_bits > rc->rolling_actual_bits)
2822         --twopass->extend_maxq;
2823     }
2824 
2825     twopass->extend_minq = clamp(twopass->extend_minq, 0, minq_adj_limit);
2826     twopass->extend_maxq = clamp(twopass->extend_maxq, 0, maxq_adj_limit);
2827 
2828     // If there is a big and undexpected undershoot then feed the extra
2829     // bits back in quickly. One situation where this may happen is if a
2830     // frame is unexpectedly almost perfectly predicted by the ARF or GF
2831     // but not very well predcited by the previous frame.
2832     if (!frame_is_kf_gf_arf(cpi) && !cpi->rc.is_src_frame_alt_ref) {
2833       int fast_extra_thresh = rc->base_frame_target / HIGH_UNDERSHOOT_RATIO;
2834       if (rc->projected_frame_size < fast_extra_thresh) {
2835         rc->vbr_bits_off_target_fast +=
2836           fast_extra_thresh - rc->projected_frame_size;
2837         rc->vbr_bits_off_target_fast =
2838           VPXMIN(rc->vbr_bits_off_target_fast, (4 * rc->avg_frame_bandwidth));
2839 
2840         // Fast adaptation of minQ if necessary to use up the extra bits.
2841         if (rc->avg_frame_bandwidth) {
2842           twopass->extend_minq_fast =
2843             (int)(rc->vbr_bits_off_target_fast * 8 / rc->avg_frame_bandwidth);
2844         }
2845         twopass->extend_minq_fast = VPXMIN(
2846             twopass->extend_minq_fast, minq_adj_limit - twopass->extend_minq);
2847       } else if (rc->vbr_bits_off_target_fast) {
2848         twopass->extend_minq_fast = VPXMIN(
2849             twopass->extend_minq_fast, minq_adj_limit - twopass->extend_minq);
2850       } else {
2851         twopass->extend_minq_fast = 0;
2852       }
2853     }
2854   }
2855 }
2856