firstpass.c 106 KB
Newer Older
Jingning Han's avatar
Jingning Han committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include <limits.h>
#include <math.h>
#include <stdio.h>

#include "./vpx_dsp_rtcd.h"
#include "./vpx_scale_rtcd.h"

18
#include "vpx_dsp/vpx_dsp_common.h"
Jingning Han's avatar
Jingning Han committed
19
20
#include "vpx_mem/vpx_mem.h"
#include "vpx_ports/mem.h"
21
#include "vpx_ports/system_state.h"
Jingning Han's avatar
Jingning Han committed
22
23
24
#include "vpx_scale/vpx_scale.h"
#include "vpx_scale/yv12config.h"

25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include "vp10/common/entropymv.h"
#include "vp10/common/quant_common.h"
#include "vp10/common/reconinter.h"  // vp10_setup_dst_planes()
#include "vp10/encoder/aq_variance.h"
#include "vp10/encoder/block.h"
#include "vp10/encoder/encodeframe.h"
#include "vp10/encoder/encodemb.h"
#include "vp10/encoder/encodemv.h"
#include "vp10/encoder/encoder.h"
#include "vp10/encoder/extend.h"
#include "vp10/encoder/firstpass.h"
#include "vp10/encoder/mcomp.h"
#include "vp10/encoder/quantize.h"
#include "vp10/encoder/rd.h"
Jingning Han's avatar
Jingning Han committed
39
40
#include "vpx_dsp/variance.h"

41
42
#define OUTPUT_FPF 0
#define ARF_STATS_OUTPUT 0
Jingning Han's avatar
Jingning Han committed
43
44
45

#define GROUP_ADAPTIVE_MAXQ 1

46
47
48
49
50
51
52
53
54
55
56
#define BOOST_BREAKOUT 12.5
#define BOOST_FACTOR 12.5
#define FACTOR_PT_LOW 0.70
#define FACTOR_PT_HIGH 0.90
#define FIRST_PASS_Q 10.0
#define GF_MAX_BOOST 96.0
#define INTRA_MODE_PENALTY 1024
#define KF_MAX_BOOST 128.0
#define MIN_ARF_GF_BOOST 240
#define MIN_DECAY_FACTOR 0.01
#define MIN_KF_BOOST 300
Jingning Han's avatar
Jingning Han committed
57
#define NEW_MV_MODE_PENALTY 32
58
59
60
61
#define DARK_THRESH 64
#define DEFAULT_GRP_WEIGHT 1.0
#define RC_FACTOR_MIN 0.75
#define RC_FACTOR_MAX 1.75
Jingning Han's avatar
Jingning Han committed
62
63
64
65
66

#define NCOUNT_INTRA_THRESH 8192
#define NCOUNT_INTRA_FACTOR 3
#define NCOUNT_FRAME_II_THRESH 5.0

67
#define DOUBLE_DIVIDE_CHECK(x) ((x) < 0 ? (x)-0.000001 : (x) + 0.000001)
Jingning Han's avatar
Jingning Han committed
68
69
70
71
72
73
74

#if ARF_STATS_OUTPUT
unsigned int arf_count = 0;
#endif

// Resets the first pass file to the given position using a relative seek from
// the current position.
75
static void reset_fpf_position(TWO_PASS *p, const FIRSTPASS_STATS *position) {
Jingning Han's avatar
Jingning Han committed
76
77
78
79
80
81
82
83
84
85
86
87
88
89
  p->stats_in = position;
}

// Read frame stats at an offset from the current position.
static const FIRSTPASS_STATS *read_frame_stats(const TWO_PASS *p, int offset) {
  if ((offset >= 0 && p->stats_in + offset >= p->stats_in_end) ||
      (offset < 0 && p->stats_in + offset < p->stats_in_start)) {
    return NULL;
  }

  return &p->stats_in[offset];
}

static int input_stats(TWO_PASS *p, FIRSTPASS_STATS *fps) {
90
  if (p->stats_in >= p->stats_in_end) return EOF;
Jingning Han's avatar
Jingning Han committed
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

  *fps = *p->stats_in;
  ++p->stats_in;
  return 1;
}

static void output_stats(FIRSTPASS_STATS *stats,
                         struct vpx_codec_pkt_list *pktlist) {
  struct vpx_codec_cx_pkt pkt;
  pkt.kind = VPX_CODEC_STATS_PKT;
  pkt.data.twopass_stats.buf = stats;
  pkt.data.twopass_stats.sz = sizeof(FIRSTPASS_STATS);
  vpx_codec_pkt_list_add(pktlist, &pkt);

// TEMP debug code
#if OUTPUT_FPF
  {
    FILE *fpfile;
    fpfile = fopen("firstpass.stt", "a");

111
112
    fprintf(fpfile,
            "%12.0lf %12.4lf %12.0lf %12.0lf %12.0lf %12.4lf %12.4lf"
Jingning Han's avatar
Jingning Han committed
113
114
            "%12.4lf %12.4lf %12.4lf %12.4lf %12.4lf %12.4lf %12.4lf %12.4lf"
            "%12.4lf %12.4lf %12.0lf %12.0lf %12.0lf %12.4lf\n",
115
116
117
118
119
120
121
            stats->frame, stats->weight, stats->intra_error, stats->coded_error,
            stats->sr_coded_error, stats->pcnt_inter, stats->pcnt_motion,
            stats->pcnt_second_ref, stats->pcnt_neutral, stats->intra_skip_pct,
            stats->inactive_zone_rows, stats->inactive_zone_cols, stats->MVr,
            stats->mvr_abs, stats->MVc, stats->mvc_abs, stats->MVrv,
            stats->MVcv, stats->mv_in_out_count, stats->new_mv_count,
            stats->count, stats->duration);
Jingning Han's avatar
Jingning Han committed
122
123
124
125
126
127
    fclose(fpfile);
  }
#endif
}

#if CONFIG_FP_MB_STATS
128
static void output_fpmb_stats(uint8_t *this_frame_mb_stats, VP10_COMMON *cm,
Yaowu Xu's avatar
Yaowu Xu committed
129
                              struct vpx_codec_pkt_list *pktlist) {
Jingning Han's avatar
Jingning Han committed
130
131
132
133
134
135
136
137
138
139
140
141
142
143
  struct vpx_codec_cx_pkt pkt;
  pkt.kind = VPX_CODEC_FPMB_STATS_PKT;
  pkt.data.firstpass_mb_stats.buf = this_frame_mb_stats;
  pkt.data.firstpass_mb_stats.sz = cm->initial_mbs * sizeof(uint8_t);
  vpx_codec_pkt_list_add(pktlist, &pkt);
}
#endif

static void zero_stats(FIRSTPASS_STATS *section) {
  section->frame = 0.0;
  section->weight = 0.0;
  section->intra_error = 0.0;
  section->coded_error = 0.0;
  section->sr_coded_error = 0.0;
144
145
  section->pcnt_inter = 0.0;
  section->pcnt_motion = 0.0;
Jingning Han's avatar
Jingning Han committed
146
147
148
149
150
151
  section->pcnt_second_ref = 0.0;
  section->pcnt_neutral = 0.0;
  section->intra_skip_pct = 0.0;
  section->inactive_zone_rows = 0.0;
  section->inactive_zone_cols = 0.0;
  section->MVr = 0.0;
152
153
154
155
156
157
  section->mvr_abs = 0.0;
  section->MVc = 0.0;
  section->mvc_abs = 0.0;
  section->MVrv = 0.0;
  section->MVcv = 0.0;
  section->mv_in_out_count = 0.0;
Jingning Han's avatar
Jingning Han committed
158
  section->new_mv_count = 0.0;
159
160
  section->count = 0.0;
  section->duration = 1.0;
Jingning Han's avatar
Jingning Han committed
161
162
163
164
165
166
167
168
169
}

static void accumulate_stats(FIRSTPASS_STATS *section,
                             const FIRSTPASS_STATS *frame) {
  section->frame += frame->frame;
  section->weight += frame->weight;
  section->intra_error += frame->intra_error;
  section->coded_error += frame->coded_error;
  section->sr_coded_error += frame->sr_coded_error;
170
  section->pcnt_inter += frame->pcnt_inter;
Jingning Han's avatar
Jingning Han committed
171
172
173
174
175
176
177
  section->pcnt_motion += frame->pcnt_motion;
  section->pcnt_second_ref += frame->pcnt_second_ref;
  section->pcnt_neutral += frame->pcnt_neutral;
  section->intra_skip_pct += frame->intra_skip_pct;
  section->inactive_zone_rows += frame->inactive_zone_rows;
  section->inactive_zone_cols += frame->inactive_zone_cols;
  section->MVr += frame->MVr;
178
179
180
181
182
183
  section->mvr_abs += frame->mvr_abs;
  section->MVc += frame->MVc;
  section->mvc_abs += frame->mvc_abs;
  section->MVrv += frame->MVrv;
  section->MVcv += frame->MVcv;
  section->mv_in_out_count += frame->mv_in_out_count;
Jingning Han's avatar
Jingning Han committed
184
  section->new_mv_count += frame->new_mv_count;
185
186
  section->count += frame->count;
  section->duration += frame->duration;
Jingning Han's avatar
Jingning Han committed
187
188
189
190
191
192
193
194
195
}

static void subtract_stats(FIRSTPASS_STATS *section,
                           const FIRSTPASS_STATS *frame) {
  section->frame -= frame->frame;
  section->weight -= frame->weight;
  section->intra_error -= frame->intra_error;
  section->coded_error -= frame->coded_error;
  section->sr_coded_error -= frame->sr_coded_error;
196
  section->pcnt_inter -= frame->pcnt_inter;
Jingning Han's avatar
Jingning Han committed
197
198
199
200
201
202
203
  section->pcnt_motion -= frame->pcnt_motion;
  section->pcnt_second_ref -= frame->pcnt_second_ref;
  section->pcnt_neutral -= frame->pcnt_neutral;
  section->intra_skip_pct -= frame->intra_skip_pct;
  section->inactive_zone_rows -= frame->inactive_zone_rows;
  section->inactive_zone_cols -= frame->inactive_zone_cols;
  section->MVr -= frame->MVr;
204
205
206
207
208
209
  section->mvr_abs -= frame->mvr_abs;
  section->MVc -= frame->MVc;
  section->mvc_abs -= frame->mvc_abs;
  section->MVrv -= frame->MVrv;
  section->MVcv -= frame->MVcv;
  section->mv_in_out_count -= frame->mv_in_out_count;
Jingning Han's avatar
Jingning Han committed
210
  section->new_mv_count -= frame->new_mv_count;
211
212
  section->count -= frame->count;
  section->duration -= frame->duration;
Jingning Han's avatar
Jingning Han committed
213
214
}

paulwilkins's avatar
paulwilkins committed
215
216
217
218
219
220
221
// Calculate the linear size relative to a baseline of 1080P
#define BASE_SIZE 2073600.0  // 1920x1080
static double get_linear_size_factor(const VP10_COMP *cpi) {
  const double this_area = cpi->initial_width * cpi->initial_height;
  return pow(this_area / BASE_SIZE, 0.5);
}

Jingning Han's avatar
Jingning Han committed
222
223
224
225
// Calculate an active area of the image that discounts formatting
// bars and partially discounts other 0 energy areas.
#define MIN_ACTIVE_AREA 0.5
#define MAX_ACTIVE_AREA 1.0
Yaowu Xu's avatar
Yaowu Xu committed
226
static double calculate_active_area(const VP10_COMP *cpi,
227
                                    const FIRSTPASS_STATS *this_frame) {
Jingning Han's avatar
Jingning Han committed
228
229
  double active_pct;

230
231
232
233
  active_pct =
      1.0 -
      ((this_frame->intra_skip_pct / 2) +
       ((this_frame->inactive_zone_rows * 2) / (double)cpi->common.mb_rows));
Jingning Han's avatar
Jingning Han committed
234
235
236
237
238
239
  return fclamp(active_pct, MIN_ACTIVE_AREA, MAX_ACTIVE_AREA);
}

// Calculate a modified Error used in distributing bits between easier and
// harder frames.
#define ACT_AREA_CORRECTION 0.5
Yaowu Xu's avatar
Yaowu Xu committed
240
static double calculate_modified_err(const VP10_COMP *cpi,
Jingning Han's avatar
Jingning Han committed
241
                                     const TWO_PASS *twopass,
hui su's avatar
hui su committed
242
                                     const VP10EncoderConfig *oxcf,
Jingning Han's avatar
Jingning Han committed
243
244
245
246
247
                                     const FIRSTPASS_STATS *this_frame) {
  const FIRSTPASS_STATS *const stats = &twopass->total_stats;
  const double av_weight = stats->weight / stats->count;
  const double av_err = (stats->coded_error * av_weight) / stats->count;
  double modified_error =
248
249
250
      av_err * pow(this_frame->coded_error * this_frame->weight /
                       DOUBLE_DIVIDE_CHECK(av_err),
                   oxcf->two_pass_vbrbias / 100.0);
Jingning Han's avatar
Jingning Han committed
251
252
253
254
255
256
257

  // Correction for active area. Frames with a reduced active area
  // (eg due to formatting bars) have a higher error per mb for the
  // remaining active MBs. The correction here assumes that coding
  // 0.5N blocks of complexity 2X is a little easier than coding N
  // blocks of complexity X.
  modified_error *=
258
      pow(calculate_active_area(cpi, this_frame), ACT_AREA_CORRECTION);
Jingning Han's avatar
Jingning Han committed
259

260
261
  return fclamp(modified_error, twopass->modified_error_min,
                twopass->modified_error_max);
Jingning Han's avatar
Jingning Han committed
262
263
264
265
}

// This function returns the maximum target rate per frame.
static int frame_max_bits(const RATE_CONTROL *rc,
hui su's avatar
hui su committed
266
                          const VP10EncoderConfig *oxcf) {
Jingning Han's avatar
Jingning Han committed
267
  int64_t max_bits = ((int64_t)rc->avg_frame_bandwidth *
268
269
                      (int64_t)oxcf->two_pass_vbrmax_section) /
                     100;
Jingning Han's avatar
Jingning Han committed
270
271
272
273
274
275
276
277
  if (max_bits < 0)
    max_bits = 0;
  else if (max_bits > rc->max_frame_bandwidth)
    max_bits = rc->max_frame_bandwidth;

  return (int)max_bits;
}

Yaowu Xu's avatar
Yaowu Xu committed
278
void vp10_init_first_pass(VP10_COMP *cpi) {
Jingning Han's avatar
Jingning Han committed
279
280
281
  zero_stats(&cpi->twopass.total_stats);
}

Yaowu Xu's avatar
Yaowu Xu committed
282
void vp10_end_first_pass(VP10_COMP *cpi) {
Yunqing Wang's avatar
Yunqing Wang committed
283
  output_stats(&cpi->twopass.total_stats, cpi->output_pkt_list);
Jingning Han's avatar
Jingning Han committed
284
285
286
287
}

static vpx_variance_fn_t get_block_variance_fn(BLOCK_SIZE bsize) {
  switch (bsize) {
288
289
290
291
    case BLOCK_8X8: return vpx_mse8x8;
    case BLOCK_16X8: return vpx_mse16x8;
    case BLOCK_8X16: return vpx_mse8x16;
    default: return vpx_mse16x16;
Jingning Han's avatar
Jingning Han committed
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
  }
}

static unsigned int get_prediction_error(BLOCK_SIZE bsize,
                                         const struct buf_2d *src,
                                         const struct buf_2d *ref) {
  unsigned int sse;
  const vpx_variance_fn_t fn = get_block_variance_fn(bsize);
  fn(src->buf, src->stride, ref->buf, ref->stride, &sse);
  return sse;
}

#if CONFIG_VP9_HIGHBITDEPTH
static vpx_variance_fn_t highbd_get_block_variance_fn(BLOCK_SIZE bsize,
                                                      int bd) {
  switch (bd) {
    default:
      switch (bsize) {
310
311
312
313
        case BLOCK_8X8: return vpx_highbd_8_mse8x8;
        case BLOCK_16X8: return vpx_highbd_8_mse16x8;
        case BLOCK_8X16: return vpx_highbd_8_mse8x16;
        default: return vpx_highbd_8_mse16x16;
Jingning Han's avatar
Jingning Han committed
314
315
316
317
      }
      break;
    case 10:
      switch (bsize) {
318
319
320
321
        case BLOCK_8X8: return vpx_highbd_10_mse8x8;
        case BLOCK_16X8: return vpx_highbd_10_mse16x8;
        case BLOCK_8X16: return vpx_highbd_10_mse8x16;
        default: return vpx_highbd_10_mse16x16;
Jingning Han's avatar
Jingning Han committed
322
323
324
325
      }
      break;
    case 12:
      switch (bsize) {
326
327
328
329
        case BLOCK_8X8: return vpx_highbd_12_mse8x8;
        case BLOCK_16X8: return vpx_highbd_12_mse16x8;
        case BLOCK_8X16: return vpx_highbd_12_mse8x16;
        default: return vpx_highbd_12_mse16x16;
Jingning Han's avatar
Jingning Han committed
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
      }
      break;
  }
}

static unsigned int highbd_get_prediction_error(BLOCK_SIZE bsize,
                                                const struct buf_2d *src,
                                                const struct buf_2d *ref,
                                                int bd) {
  unsigned int sse;
  const vpx_variance_fn_t fn = highbd_get_block_variance_fn(bsize, bd);
  fn(src->buf, src->stride, ref->buf, ref->stride, &sse);
  return sse;
}
#endif  // CONFIG_VP9_HIGHBITDEPTH

// Refine the motion search range according to the frame dimension
// for first pass test.
Yaowu Xu's avatar
Yaowu Xu committed
348
static int get_search_range(const VP10_COMP *cpi) {
Jingning Han's avatar
Jingning Han committed
349
  int sr = 0;
350
  const int dim = VPXMIN(cpi->initial_width, cpi->initial_height);
Jingning Han's avatar
Jingning Han committed
351

352
  while ((dim << sr) < MAX_FULL_PEL_VAL) ++sr;
Jingning Han's avatar
Jingning Han committed
353
354
355
  return sr;
}

Yaowu Xu's avatar
Yaowu Xu committed
356
static void first_pass_motion_search(VP10_COMP *cpi, MACROBLOCK *x,
Jingning Han's avatar
Jingning Han committed
357
358
359
                                     const MV *ref_mv, MV *best_mv,
                                     int *best_motion_err) {
  MACROBLOCKD *const xd = &x->e_mbd;
360
361
  MV tmp_mv = { 0, 0 };
  MV ref_mv_full = { ref_mv->row >> 3, ref_mv->col >> 3 };
Jingning Han's avatar
Jingning Han committed
362
363
  int num00, tmp_err, n;
  const BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type;
364
  vpx_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[bsize];
Jingning Han's avatar
Jingning Han committed
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
  const int new_mv_mode_penalty = NEW_MV_MODE_PENALTY;

  int step_param = 3;
  int further_steps = (MAX_MVSEARCH_STEPS - 1) - step_param;
  const int sr = get_search_range(cpi);
  step_param += sr;
  further_steps -= sr;

  // Override the default variance function to use MSE.
  v_fn_ptr.vf = get_block_variance_fn(bsize);
#if CONFIG_VP9_HIGHBITDEPTH
  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
    v_fn_ptr.vf = highbd_get_block_variance_fn(bsize, xd->bd);
  }
#endif  // CONFIG_VP9_HIGHBITDEPTH

  // Center the initial step/diamond search on best mv.
  tmp_err = cpi->diamond_search_sad(x, &cpi->ss_cfg, &ref_mv_full, &tmp_mv,
383
384
                                    step_param, x->sadperbit16, &num00,
                                    &v_fn_ptr, ref_mv);
Jingning Han's avatar
Jingning Han committed
385
386
  if (tmp_err < INT_MAX)
    tmp_err = vp10_get_mvpred_var(x, &tmp_mv, ref_mv, &v_fn_ptr, 1);
387
  if (tmp_err < INT_MAX - new_mv_mode_penalty) tmp_err += new_mv_mode_penalty;
Jingning Han's avatar
Jingning Han committed
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404

  if (tmp_err < *best_motion_err) {
    *best_motion_err = tmp_err;
    *best_mv = tmp_mv;
  }

  // Carry out further step/diamond searches as necessary.
  n = num00;
  num00 = 0;

  while (n < further_steps) {
    ++n;

    if (num00) {
      --num00;
    } else {
      tmp_err = cpi->diamond_search_sad(x, &cpi->ss_cfg, &ref_mv_full, &tmp_mv,
405
406
                                        step_param + n, x->sadperbit16, &num00,
                                        &v_fn_ptr, ref_mv);
Jingning Han's avatar
Jingning Han committed
407
408
409
410
411
412
413
414
415
416
417
418
419
      if (tmp_err < INT_MAX)
        tmp_err = vp10_get_mvpred_var(x, &tmp_mv, ref_mv, &v_fn_ptr, 1);
      if (tmp_err < INT_MAX - new_mv_mode_penalty)
        tmp_err += new_mv_mode_penalty;

      if (tmp_err < *best_motion_err) {
        *best_motion_err = tmp_err;
        *best_mv = tmp_mv;
      }
    }
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
420
static BLOCK_SIZE get_bsize(const VP10_COMMON *cm, int mb_row, int mb_col) {
Jingning Han's avatar
Jingning Han committed
421
  if (2 * mb_col + 1 < cm->mi_cols) {
422
    return 2 * mb_row + 1 < cm->mi_rows ? BLOCK_16X16 : BLOCK_16X8;
Jingning Han's avatar
Jingning Han committed
423
  } else {
424
    return 2 * mb_row + 1 < cm->mi_rows ? BLOCK_8X16 : BLOCK_8X8;
Jingning Han's avatar
Jingning Han committed
425
426
427
428
429
430
431
  }
}

static int find_fp_qindex(vpx_bit_depth_t bit_depth) {
  int i;

  for (i = 0; i < QINDEX_RANGE; ++i)
432
    if (vp10_convert_qindex_to_q(i, bit_depth) >= FIRST_PASS_Q) break;
Jingning Han's avatar
Jingning Han committed
433

434
  if (i == QINDEX_RANGE) i--;
Jingning Han's avatar
Jingning Han committed
435
436
437
438

  return i;
}

Yaowu Xu's avatar
Yaowu Xu committed
439
static void set_first_pass_params(VP10_COMP *cpi) {
Yaowu Xu's avatar
Yaowu Xu committed
440
  VP10_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
441
  if (!cpi->refresh_alt_ref_frame &&
442
      (cm->current_video_frame == 0 || (cpi->frame_flags & FRAMEFLAGS_KEY))) {
Jingning Han's avatar
Jingning Han committed
443
444
445
446
447
448
449
450
451
452
    cm->frame_type = KEY_FRAME;
  } else {
    cm->frame_type = INTER_FRAME;
  }
  // Do not use periodic key frames.
  cpi->rc.frames_to_key = INT_MAX;
}

#define UL_INTRA_THRESH 50
#define INVALID_ROW -1
Yaowu Xu's avatar
Yaowu Xu committed
453
void vp10_first_pass(VP10_COMP *cpi, const struct lookahead_entry *source) {
Jingning Han's avatar
Jingning Han committed
454
455
  int mb_row, mb_col;
  MACROBLOCK *const x = &cpi->td.mb;
Yaowu Xu's avatar
Yaowu Xu committed
456
  VP10_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
457
458
459
460
  MACROBLOCKD *const xd = &x->e_mbd;
  TileInfo tile;
  struct macroblock_plane *const p = x->plane;
  struct macroblockd_plane *const pd = xd->plane;
Geza Lore's avatar
Geza Lore committed
461
462
  const PICK_MODE_CONTEXT *ctx =
      &cpi->td.pc_root[MAX_MIB_SIZE_LOG2 - MIN_MIB_SIZE_LOG2]->none;
Jingning Han's avatar
Jingning Han committed
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
  int i;

  int recon_yoffset, recon_uvoffset;
  int64_t intra_error = 0;
  int64_t coded_error = 0;
  int64_t sr_coded_error = 0;

  int sum_mvr = 0, sum_mvc = 0;
  int sum_mvr_abs = 0, sum_mvc_abs = 0;
  int64_t sum_mvrs = 0, sum_mvcs = 0;
  int mvcount = 0;
  int intercount = 0;
  int second_ref_count = 0;
  const int intrapenalty = INTRA_MODE_PENALTY;
  double neutral_count;
  int intra_skip_count = 0;
  int image_data_start_row = INVALID_ROW;
  int new_mv_count = 0;
  int sum_in_vectors = 0;
482
  MV lastmv = { 0, 0 };
Jingning Han's avatar
Jingning Han committed
483
  TWO_PASS *twopass = &cpi->twopass;
484
  const MV zero_mv = { 0, 0 };
Jingning Han's avatar
Jingning Han committed
485
486
487
488
489
490
491
492
493
494
495
496
  int recon_y_stride, recon_uv_stride, uv_mb_height;

  YV12_BUFFER_CONFIG *const lst_yv12 = get_ref_frame_buffer(cpi, LAST_FRAME);
  YV12_BUFFER_CONFIG *gld_yv12 = get_ref_frame_buffer(cpi, GOLDEN_FRAME);
  YV12_BUFFER_CONFIG *const new_yv12 = get_frame_new_buffer(cm);
  const YV12_BUFFER_CONFIG *first_ref_buf = lst_yv12;
  double intra_factor;
  double brightness_factor;
  BufferPool *const pool = cm->buffer_pool;

  // First pass code requires valid last and new frame buffers.
  assert(new_yv12 != NULL);
Yunqing Wang's avatar
Yunqing Wang committed
497
  assert(frame_is_intra_only(cm) || (lst_yv12 != NULL));
Jingning Han's avatar
Jingning Han committed
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545

#if CONFIG_FP_MB_STATS
  if (cpi->use_fp_mb_stats) {
    vp10_zero_array(cpi->twopass.frame_mb_stats_buf, cm->initial_mbs);
  }
#endif

  vpx_clear_system_state();

  intra_factor = 0.0;
  brightness_factor = 0.0;
  neutral_count = 0.0;

  set_first_pass_params(cpi);
  vp10_set_quantizer(cm, find_fp_qindex(cm->bit_depth));

  vp10_setup_block_planes(&x->e_mbd, cm->subsampling_x, cm->subsampling_y);

  vp10_setup_src_planes(x, cpi->Source, 0, 0);
  vp10_setup_dst_planes(xd->plane, new_yv12, 0, 0);

  if (!frame_is_intra_only(cm)) {
    vp10_setup_pre_planes(xd, 0, first_ref_buf, 0, 0, NULL);
  }

  xd->mi = cm->mi_grid_visible;
  xd->mi[0] = cm->mi;

  vp10_frame_init_quantizer(cpi);

  for (i = 0; i < MAX_MB_PLANE; ++i) {
    p[i].coeff = ctx->coeff_pbuf[i][1];
    p[i].qcoeff = ctx->qcoeff_pbuf[i][1];
    pd[i].dqcoeff = ctx->dqcoeff_pbuf[i][1];
    p[i].eobs = ctx->eobs_pbuf[i][1];
  }

  vp10_init_mv_probs(cm);
  vp10_initialize_rd_consts(cpi);

  // Tiling is ignored in the first pass.
  vp10_tile_init(&tile, cm, 0, 0);

  recon_y_stride = new_yv12->y_stride;
  recon_uv_stride = new_yv12->uv_stride;
  uv_mb_height = 16 >> (new_yv12->y_height > new_yv12->uv_height);

  for (mb_row = 0; mb_row < cm->mb_rows; ++mb_row) {
546
    MV best_ref_mv = { 0, 0 };
Jingning Han's avatar
Jingning Han committed
547
548
549
550
551
552
553
554
555

    // Reset above block coeffs.
    xd->up_available = (mb_row != 0);
    recon_yoffset = (mb_row * recon_y_stride * 16);
    recon_uvoffset = (mb_row * recon_uv_stride * uv_mb_height);

    // Set up limit values for motion vectors to prevent them extending
    // outside the UMV borders.
    x->mv_row_min = -((mb_row * 16) + BORDER_MV_PIXELS_B16);
556
    x->mv_row_max = ((cm->mb_rows - 1 - mb_row) * 16) + BORDER_MV_PIXELS_B16;
Jingning Han's avatar
Jingning Han committed
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576

    for (mb_col = 0; mb_col < cm->mb_cols; ++mb_col) {
      int this_error;
      const int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
      const BLOCK_SIZE bsize = get_bsize(cm, mb_row, mb_col);
      double log_intra;
      int level_sample;

#if CONFIG_FP_MB_STATS
      const int mb_index = mb_row * cm->mb_cols + mb_col;
#endif

      vpx_clear_system_state();

      xd->plane[0].dst.buf = new_yv12->y_buffer + recon_yoffset;
      xd->plane[1].dst.buf = new_yv12->u_buffer + recon_uvoffset;
      xd->plane[2].dst.buf = new_yv12->v_buffer + recon_uvoffset;
      xd->left_available = (mb_col != 0);
      xd->mi[0]->mbmi.sb_type = bsize;
      xd->mi[0]->mbmi.ref_frame[0] = INTRA_FRAME;
577
      set_mi_row_col(xd, &tile, mb_row << 1, num_8x8_blocks_high_lookup[bsize],
Jingning Han's avatar
Jingning Han committed
578
579
580
581
                     mb_col << 1, num_8x8_blocks_wide_lookup[bsize],
                     cm->mi_rows, cm->mi_cols);

      // Do intra 16x16 prediction.
582
      xd->mi[0]->mbmi.segment_id = 0;
583
584
585
#if CONFIG_SUPERTX
      xd->mi[0]->mbmi.segment_id_supertx = 0;
#endif  // CONFIG_SUPERTX
Jingning Han's avatar
Jingning Han committed
586
      xd->mi[0]->mbmi.mode = DC_PRED;
587
588
      xd->mi[0]->mbmi.tx_size =
          use_dc_pred ? (bsize >= BLOCK_16X16 ? TX_16X16 : TX_8X8) : TX_4X4;
hui su's avatar
hui su committed
589
      vp10_encode_intra_block_plane(x, bsize, 0, 0);
Jingning Han's avatar
Jingning Han committed
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
      this_error = vpx_get_mb_ss(x->plane[0].src_diff);

      // Keep a record of blocks that have almost no intra error residual
      // (i.e. are in effect completely flat and untextured in the intra
      // domain). In natural videos this is uncommon, but it is much more
      // common in animations, graphics and screen content, so may be used
      // as a signal to detect these types of content.
      if (this_error < UL_INTRA_THRESH) {
        ++intra_skip_count;
      } else if ((mb_col > 0) && (image_data_start_row == INVALID_ROW)) {
        image_data_start_row = mb_row;
      }

#if CONFIG_VP9_HIGHBITDEPTH
      if (cm->use_highbitdepth) {
        switch (cm->bit_depth) {
606
607
608
          case VPX_BITS_8: break;
          case VPX_BITS_10: this_error >>= 4; break;
          case VPX_BITS_12: this_error >>= 8; break;
Jingning Han's avatar
Jingning Han committed
609
          default:
610
611
612
            assert(0 &&
                   "cm->bit_depth should be VPX_BITS_8, "
                   "VPX_BITS_10 or VPX_BITS_12");
Jingning Han's avatar
Jingning Han committed
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
            return;
        }
      }
#endif  // CONFIG_VP9_HIGHBITDEPTH

      vpx_clear_system_state();
      log_intra = log(this_error + 1.0);
      if (log_intra < 10.0)
        intra_factor += 1.0 + ((10.0 - log_intra) * 0.05);
      else
        intra_factor += 1.0;

#if CONFIG_VP9_HIGHBITDEPTH
      if (cm->use_highbitdepth)
        level_sample = CONVERT_TO_SHORTPTR(x->plane[0].src.buf)[0];
      else
        level_sample = x->plane[0].src.buf[0];
#else
      level_sample = x->plane[0].src.buf[0];
#endif
      if ((level_sample < DARK_THRESH) && (log_intra < 9.0))
        brightness_factor += 1.0 + (0.01 * (DARK_THRESH - level_sample));
      else
        brightness_factor += 1.0;

      // Intrapenalty below deals with situations where the intra and inter
      // error scores are very low (e.g. a plain black frame).
      // We do not have special cases in first pass for 0,0 and nearest etc so
      // all inter modes carry an overhead cost estimate for the mv.
      // When the error score is very low this causes us to pick all or lots of
      // INTRA modes and throw lots of key frames.
      // This penalty adds a cost matching that of a 0,0 mv to the intra case.
      this_error += intrapenalty;

      // Accumulate the intra error.
      intra_error += (int64_t)this_error;

#if CONFIG_FP_MB_STATS
      if (cpi->use_fp_mb_stats) {
        // initialization
        cpi->twopass.frame_mb_stats_buf[mb_index] = 0;
      }
#endif

      // Set up limit values for motion vectors to prevent them extending
      // outside the UMV borders.
      x->mv_col_min = -((mb_col * 16) + BORDER_MV_PIXELS_B16);
      x->mv_col_max = ((cm->mb_cols - 1 - mb_col) * 16) + BORDER_MV_PIXELS_B16;

      // Other than for the first frame do a motion search.
Yunqing Wang's avatar
Yunqing Wang committed
663
      if (cm->current_video_frame > 0) {
Jingning Han's avatar
Jingning Han committed
664
665
        int tmp_err, motion_error, raw_motion_error;
        // Assume 0,0 motion with no mv overhead.
666
        MV mv = { 0, 0 }, tmp_mv = { 0, 0 };
Jingning Han's avatar
Jingning Han committed
667
668
669
670
671
672
673
674
        struct buf_2d unscaled_last_source_buf_2d;

        xd->plane[0].pre[0].buf = first_ref_buf->y_buffer + recon_yoffset;
#if CONFIG_VP9_HIGHBITDEPTH
        if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
          motion_error = highbd_get_prediction_error(
              bsize, &x->plane[0].src, &xd->plane[0].pre[0], xd->bd);
        } else {
675
676
          motion_error = get_prediction_error(bsize, &x->plane[0].src,
                                              &xd->plane[0].pre[0]);
Jingning Han's avatar
Jingning Han committed
677
678
        }
#else
679
680
        motion_error =
            get_prediction_error(bsize, &x->plane[0].src, &xd->plane[0].pre[0]);
Jingning Han's avatar
Jingning Han committed
681
682
683
684
685
686
687
688
689
690
691
692
693
694
#endif  // CONFIG_VP9_HIGHBITDEPTH

        // Compute the motion error of the 0,0 motion using the last source
        // frame as the reference. Skip the further motion search on
        // reconstructed frame if this error is small.
        unscaled_last_source_buf_2d.buf =
            cpi->unscaled_last_source->y_buffer + recon_yoffset;
        unscaled_last_source_buf_2d.stride =
            cpi->unscaled_last_source->y_stride;
#if CONFIG_VP9_HIGHBITDEPTH
        if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
          raw_motion_error = highbd_get_prediction_error(
              bsize, &x->plane[0].src, &unscaled_last_source_buf_2d, xd->bd);
        } else {
695
696
          raw_motion_error = get_prediction_error(bsize, &x->plane[0].src,
                                                  &unscaled_last_source_buf_2d);
Jingning Han's avatar
Jingning Han committed
697
698
        }
#else
699
700
        raw_motion_error = get_prediction_error(bsize, &x->plane[0].src,
                                                &unscaled_last_source_buf_2d);
Jingning Han's avatar
Jingning Han committed
701
702
703
#endif  // CONFIG_VP9_HIGHBITDEPTH

        // TODO(pengchong): Replace the hard-coded threshold
Yunqing Wang's avatar
Yunqing Wang committed
704
        if (raw_motion_error > 25) {
Jingning Han's avatar
Jingning Han committed
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
          // Test last reference frame using the previous best mv as the
          // starting point (best reference) for the search.
          first_pass_motion_search(cpi, x, &best_ref_mv, &mv, &motion_error);

          // If the current best reference mv is not centered on 0,0 then do a
          // 0,0 based search as well.
          if (!is_zero_mv(&best_ref_mv)) {
            tmp_err = INT_MAX;
            first_pass_motion_search(cpi, x, &zero_mv, &tmp_mv, &tmp_err);

            if (tmp_err < motion_error) {
              motion_error = tmp_err;
              mv = tmp_mv;
            }
          }

          // Search in an older reference frame.
Yunqing Wang's avatar
Yunqing Wang committed
722
          if ((cm->current_video_frame > 1) && gld_yv12 != NULL) {
Jingning Han's avatar
Jingning Han committed
723
724
725
726
727
728
729
730
731
            // Assume 0,0 motion with no mv overhead.
            int gf_motion_error;

            xd->plane[0].pre[0].buf = gld_yv12->y_buffer + recon_yoffset;
#if CONFIG_VP9_HIGHBITDEPTH
            if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
              gf_motion_error = highbd_get_prediction_error(
                  bsize, &x->plane[0].src, &xd->plane[0].pre[0], xd->bd);
            } else {
732
733
              gf_motion_error = get_prediction_error(bsize, &x->plane[0].src,
                                                     &xd->plane[0].pre[0]);
Jingning Han's avatar
Jingning Han committed
734
735
            }
#else
736
737
            gf_motion_error = get_prediction_error(bsize, &x->plane[0].src,
                                                   &xd->plane[0].pre[0]);
Jingning Han's avatar
Jingning Han committed
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
#endif  // CONFIG_VP9_HIGHBITDEPTH

            first_pass_motion_search(cpi, x, &zero_mv, &tmp_mv,
                                     &gf_motion_error);

            if (gf_motion_error < motion_error && gf_motion_error < this_error)
              ++second_ref_count;

            // Reset to last frame as reference buffer.
            xd->plane[0].pre[0].buf = first_ref_buf->y_buffer + recon_yoffset;
            xd->plane[1].pre[0].buf = first_ref_buf->u_buffer + recon_uvoffset;
            xd->plane[2].pre[0].buf = first_ref_buf->v_buffer + recon_uvoffset;

            // In accumulating a score for the older reference frame take the
            // best of the motion predicted score and the intra coded error
            // (just as will be done for) accumulation of "coded_error" for
            // the last frame.
            if (gf_motion_error < this_error)
              sr_coded_error += gf_motion_error;
            else
              sr_coded_error += this_error;
          } else {
            sr_coded_error += motion_error;
          }
        } else {
          sr_coded_error += motion_error;
        }

        // Start by assuming that intra mode is best.
        best_ref_mv.row = 0;
        best_ref_mv.col = 0;

#if CONFIG_FP_MB_STATS
        if (cpi->use_fp_mb_stats) {
          // intra predication statistics
          cpi->twopass.frame_mb_stats_buf[mb_index] = 0;
          cpi->twopass.frame_mb_stats_buf[mb_index] |= FPMB_DCINTRA_MASK;
          cpi->twopass.frame_mb_stats_buf[mb_index] |= FPMB_MOTION_ZERO_MASK;
          if (this_error > FPMB_ERROR_LARGE_TH) {
            cpi->twopass.frame_mb_stats_buf[mb_index] |= FPMB_ERROR_LARGE_MASK;
          } else if (this_error < FPMB_ERROR_SMALL_TH) {
            cpi->twopass.frame_mb_stats_buf[mb_index] |= FPMB_ERROR_SMALL_MASK;
          }
        }
#endif

        if (motion_error <= this_error) {
          vpx_clear_system_state();

          // Keep a count of cases where the inter and intra were very close
          // and very low. This helps with scene cut detection for example in
          // cropped clips with black bars at the sides or top and bottom.
          if (((this_error - intrapenalty) * 9 <= motion_error * 10) &&
              (this_error < (2 * intrapenalty))) {
            neutral_count += 1.0;
793
794
            // Also track cases where the intra is not much worse than the inter
            // and use this in limiting the GF/arf group length.
Jingning Han's avatar
Jingning Han committed
795
796
          } else if ((this_error > NCOUNT_INTRA_THRESH) &&
                     (this_error < (NCOUNT_INTRA_FACTOR * motion_error))) {
797
798
            neutral_count +=
                (double)motion_error / DOUBLE_DIVIDE_CHECK((double)this_error);
Jingning Han's avatar
Jingning Han committed
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
          }

          mv.row *= 8;
          mv.col *= 8;
          this_error = motion_error;
          xd->mi[0]->mbmi.mode = NEWMV;
          xd->mi[0]->mbmi.mv[0].as_mv = mv;
          xd->mi[0]->mbmi.tx_size = TX_4X4;
          xd->mi[0]->mbmi.ref_frame[0] = LAST_FRAME;
          xd->mi[0]->mbmi.ref_frame[1] = NONE;
          vp10_build_inter_predictors_sby(xd, mb_row << 1, mb_col << 1, bsize);
          vp10_encode_sby_pass1(x, bsize);
          sum_mvr += mv.row;
          sum_mvr_abs += abs(mv.row);
          sum_mvc += mv.col;
          sum_mvc_abs += abs(mv.col);
          sum_mvrs += mv.row * mv.row;
          sum_mvcs += mv.col * mv.col;
          ++intercount;

          best_ref_mv = mv;

#if CONFIG_FP_MB_STATS
          if (cpi->use_fp_mb_stats) {
            // inter predication statistics
            cpi->twopass.frame_mb_stats_buf[mb_index] = 0;
            cpi->twopass.frame_mb_stats_buf[mb_index] &= ~FPMB_DCINTRA_MASK;
            cpi->twopass.frame_mb_stats_buf[mb_index] |= FPMB_MOTION_ZERO_MASK;
            if (this_error > FPMB_ERROR_LARGE_TH) {
              cpi->twopass.frame_mb_stats_buf[mb_index] |=
                  FPMB_ERROR_LARGE_MASK;
            } else if (this_error < FPMB_ERROR_SMALL_TH) {
              cpi->twopass.frame_mb_stats_buf[mb_index] |=
                  FPMB_ERROR_SMALL_MASK;
            }
          }
#endif

          if (!is_zero_mv(&mv)) {
            ++mvcount;

#if CONFIG_FP_MB_STATS
            if (cpi->use_fp_mb_stats) {
              cpi->twopass.frame_mb_stats_buf[mb_index] &=
                  ~FPMB_MOTION_ZERO_MASK;
              // check estimated motion direction
              if (mv.as_mv.col > 0 && mv.as_mv.col >= abs(mv.as_mv.row)) {
                // right direction
                cpi->twopass.frame_mb_stats_buf[mb_index] |=
                    FPMB_MOTION_RIGHT_MASK;
              } else if (mv.as_mv.row < 0 &&
                         abs(mv.as_mv.row) >= abs(mv.as_mv.col)) {
                // up direction
                cpi->twopass.frame_mb_stats_buf[mb_index] |=
                    FPMB_MOTION_UP_MASK;
              } else if (mv.as_mv.col < 0 &&
                         abs(mv.as_mv.col) >= abs(mv.as_mv.row)) {
                // left direction
                cpi->twopass.frame_mb_stats_buf[mb_index] |=
                    FPMB_MOTION_LEFT_MASK;
              } else {
                // down direction
                cpi->twopass.frame_mb_stats_buf[mb_index] |=
                    FPMB_MOTION_DOWN_MASK;
              }
            }
#endif

            // Non-zero vector, was it different from the last non zero vector?
868
            if (!is_equal_mv(&mv, &lastmv)) ++new_mv_count;
Jingning Han's avatar
Jingning Han committed
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
            lastmv = mv;

            // Does the row vector point inwards or outwards?
            if (mb_row < cm->mb_rows / 2) {
              if (mv.row > 0)
                --sum_in_vectors;
              else if (mv.row < 0)
                ++sum_in_vectors;
            } else if (mb_row > cm->mb_rows / 2) {
              if (mv.row > 0)
                ++sum_in_vectors;
              else if (mv.row < 0)
                --sum_in_vectors;
            }

            // Does the col vector point inwards or outwards?
            if (mb_col < cm->mb_cols / 2) {
              if (mv.col > 0)
                --sum_in_vectors;
              else if (mv.col < 0)
                ++sum_in_vectors;
            } else if (mb_col > cm->mb_cols / 2) {
              if (mv.col > 0)
                ++sum_in_vectors;
              else if (mv.col < 0)
                --sum_in_vectors;
            }
          }
        }
      } else {
        sr_coded_error += (int64_t)this_error;
      }
      coded_error += (int64_t)this_error;

      // Adjust to the next column of MBs.
      x->plane[0].src.buf += 16;
      x->plane[1].src.buf += uv_mb_height;
      x->plane[2].src.buf += uv_mb_height;

      recon_yoffset += 16;
      recon_uvoffset += uv_mb_height;
    }

    // Adjust to the next row of MBs.
    x->plane[0].src.buf += 16 * x->plane[0].src.stride - 16 * cm->mb_cols;
914
915
916
917
    x->plane[1].src.buf +=
        uv_mb_height * x->plane[1].src.stride - uv_mb_height * cm->mb_cols;
    x->plane[2].src.buf +=
        uv_mb_height * x->plane[1].src.stride - uv_mb_height * cm->mb_cols;
Jingning Han's avatar
Jingning Han committed
918
919
920
921
922
923
924
925
926
927
928
929
930

    vpx_clear_system_state();
  }

  // Clamp the image start to rows/2. This number of rows is discarded top
  // and bottom as dead data so rows / 2 means the frame is blank.
  if ((image_data_start_row > cm->mb_rows / 2) ||
      (image_data_start_row == INVALID_ROW)) {
    image_data_start_row = cm->mb_rows / 2;
  }
  // Exclude any image dead zone
  if (image_data_start_row > 0) {
    intra_skip_count =
931
        VPXMAX(0, intra_skip_count - (image_data_start_row * cm->mb_cols * 2));
Jingning Han's avatar
Jingning Han committed
932
933
934
935
936
937
938
939
940
941
  }

  {
    FIRSTPASS_STATS fps;
    // The minimum error here insures some bit allocation to frames even
    // in static regions. The allocation per MB declines for larger formats
    // where the typical "real" energy per MB also falls.
    // Initial estimate here uses sqrt(mbs) to define the min_err, where the
    // number of mbs is proportional to the image area.
    const int num_mbs = (cpi->oxcf.resize_mode != RESIZE_NONE)
942
943
                            ? cpi->initial_mbs
                            : cpi->common.MBs;
Jingning Han's avatar
Jingning Han committed
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
    const double min_err = 200 * sqrt(num_mbs);

    intra_factor = intra_factor / (double)num_mbs;
    brightness_factor = brightness_factor / (double)num_mbs;
    fps.weight = intra_factor * brightness_factor;

    fps.frame = cm->current_video_frame;
    fps.coded_error = (double)(coded_error >> 8) + min_err;
    fps.sr_coded_error = (double)(sr_coded_error >> 8) + min_err;
    fps.intra_error = (double)(intra_error >> 8) + min_err;
    fps.count = 1.0;
    fps.pcnt_inter = (double)intercount / num_mbs;
    fps.pcnt_second_ref = (double)second_ref_count / num_mbs;
    fps.pcnt_neutral = (double)neutral_count / num_mbs;
    fps.intra_skip_pct = (double)intra_skip_count / num_mbs;
    fps.inactive_zone_rows = (double)image_data_start_row;
    fps.inactive_zone_cols = (double)0;  // TODO(paulwilkins): fix

    if (mvcount > 0) {
      fps.MVr = (double)sum_mvr / mvcount;
      fps.mvr_abs = (double)sum_mvr_abs / mvcount;
      fps.MVc = (double)sum_mvc / mvcount;
      fps.mvc_abs = (double)sum_mvc_abs / mvcount;
967
968
969
970
      fps.MVrv =
          ((double)sum_mvrs - ((double)sum_mvr * sum_mvr / mvcount)) / mvcount;
      fps.MVcv =
          ((double)sum_mvcs - ((double)sum_mvc * sum_mvc / mvcount)) / mvcount;
Jingning Han's avatar
Jingning Han committed
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
      fps.mv_in_out_count = (double)sum_in_vectors / (mvcount * 2);
      fps.new_mv_count = new_mv_count;
      fps.pcnt_motion = (double)mvcount / num_mbs;
    } else {
      fps.MVr = 0.0;
      fps.mvr_abs = 0.0;
      fps.MVc = 0.0;
      fps.mvc_abs = 0.0;
      fps.MVrv = 0.0;
      fps.MVcv = 0.0;
      fps.mv_in_out_count = 0.0;
      fps.new_mv_count = 0.0;
      fps.pcnt_motion = 0.0;
    }

    // TODO(paulwilkins):  Handle the case when duration is set to 0, or
    // something less than the full time between subsequent values of
    // cpi->source_time_stamp.
    fps.duration = (double)(source->ts_end - source->ts_start);

    // Don't want to do output stats with a stack variable!
    twopass->this_frame_stats = fps;
    output_stats(&twopass->this_frame_stats, cpi->output_pkt_list);
    accumulate_stats(&twopass->total_stats, &fps);

#if CONFIG_FP_MB_STATS
    if (cpi->use_fp_mb_stats) {
      output_fpmb_stats(twopass->frame_mb_stats_buf, cm, cpi->output_pkt_list);
    }
#endif
  }

  // Copy the previous Last Frame back into gf and and arf buffers if
  // the prediction is good enough... but also don't allow it to lag too far.
  if ((twopass->sr_update_lag > 3) ||
      ((cm->current_video_frame > 0) &&
       (twopass->this_frame_stats.pcnt_inter > 0.20) &&
       ((twopass->this_frame_stats.intra_error /
         DOUBLE_DIVIDE_CHECK(twopass->this_frame_stats.coded_error)) > 2.0))) {
    if (gld_yv12 != NULL) {
1011
1012
1013
1014
#if CONFIG_EXT_REFS
      ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
                 cm->ref_frame_map[cpi->lst_fb_idxes[LAST_FRAME - LAST_FRAME]]);
#else
Jingning Han's avatar
Jingning Han committed
1015
1016
      ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
                 cm->ref_frame_map[cpi->lst_fb_idx]);
1017
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
1018
1019
1020
1021
1022
1023
    }
    twopass->sr_update_lag = 1;
  } else {
    ++twopass->sr_update_lag;
  }

1024
  vpx_extend_frame_borders(new_yv12);
Jingning Han's avatar
Jingning Han committed
1025

1026
// The frame we just compressed now becomes the last frame.
1027
1028
1029
1030
1031
#if CONFIG_EXT_REFS
  ref_cnt_fb(pool->frame_bufs,
             &cm->ref_frame_map[cpi->lst_fb_idxes[LAST_FRAME - LAST_FRAME]],
             cm->new_fb_idx);
#else
Yunqing Wang's avatar
Yunqing Wang committed
1032
1033
  ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->lst_fb_idx],
             cm->new_fb_idx);
1034
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
1035
1036
1037

  // Special case for the first frame. Copy into the GF buffer as a second
  // reference.
Yunqing Wang's avatar
Yunqing Wang committed
1038
  if (cm->current_video_frame == 0 && cpi->gld_fb_idx != INVALID_IDX) {
1039
1040
1041
1042
#if CONFIG_EXT_REFS
    ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
               cm->ref_frame_map[cpi->lst_fb_idxes[LAST_FRAME - LAST_FRAME]]);
#else
Jingning Han's avatar
Jingning Han committed
1043
1044
    ref_cnt_fb(pool->frame_bufs, &cm->ref_frame_map[cpi->gld_fb_idx],
               cm->ref_frame_map[cpi->lst_fb_idx]);
1045
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
  }

  // Use this to see what the first pass reconstruction looks like.
  if (0) {
    char filename[512];
    FILE *recon_file;
    snprintf(filename, sizeof(filename), "enc%04d.yuv",
             (int)cm->current_video_frame);

    if (cm->current_video_frame == 0)
      recon_file = fopen(filename, "wb");
    else
      recon_file = fopen(filename, "ab");

    (void)fwrite(lst_yv12->buffer_alloc, lst_yv12->frame_size, 1, recon_file);
    fclose(recon_file);
  }

  ++cm->current_video_frame;
}

1067
1068
static double calc_correction_factor(double err_per_mb, double err_divisor,
                                     double pt_low, double pt_high, int q,
Jingning Han's avatar
Jingning Han committed
1069
1070
1071
1072
1073
                                     vpx_bit_depth_t bit_depth) {
  const double error_term = err_per_mb / err_divisor;

  // Adjustment based on actual quantizer to power term.
  const double power_term =
1074
      VPXMIN(vp10_convert_qindex_to_q(q, bit_depth) * 0.01 + pt_low, pt_high);
Jingning Han's avatar
Jingning Han committed
1075
1076

  // Calculate correction factor.
1077
  if (power_term < 1.0) assert(error_term >= 0.0);
Jingning Han's avatar
Jingning Han committed
1078
1079
1080
1081

  return fclamp(pow(error_term, power_term), 0.05, 5.0);
}

1082
#define ERR_DIVISOR 100.0
Yaowu Xu's avatar
Yaowu Xu committed
1083
static int get_twopass_worst_quality(const VP10_COMP *cpi,
Jingning Han's avatar
Jingning Han committed
1084
1085
1086
1087
1088
                                     const double section_err,
                                     double inactive_zone,
                                     int section_target_bandwidth,
                                     double group_weight_factor) {
  const RATE_CONTROL *const rc = &cpi->rc;
hui su's avatar
hui su committed
1089
  const VP10EncoderConfig *const oxcf = &cpi->oxcf;
Jingning Han's avatar
Jingning Han committed
1090
1091
1092
1093
1094
1095
1096

  inactive_zone = fclamp(inactive_zone, 0.0, 1.0);

  if (section_target_bandwidth <= 0) {
    return rc->worst_quality;  // Highest value allowed
  } else {
    const int num_mbs = (cpi->oxcf.resize_mode != RESIZE_NONE)
1097
1098
                            ? cpi->initial_mbs
                            : cpi->common.MBs;
1099
    const int active_mbs = VPXMAX(1, num_mbs - (int)(num_mbs * inactive_zone));
Jingning Han's avatar
Jingning Han committed
1100
1101
    const double av_err_per_mb = section_err / active_mbs;
    const double speed_term = 1.0 + 0.04 * oxcf->speed;
paulwilkins's avatar
paulwilkins committed
1102
    double ediv_size_correction;
1103
1104
    const int target_norm_bits_per_mb =
        ((uint64_t)section_target_bandwidth << BPER_MB_NORMBITS) / active_mbs;
Jingning Han's avatar
Jingning Han committed
1105
1106
    int q;

paulwilkins's avatar
paulwilkins committed
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
    // Larger image formats are expected to be a little harder to code
    // relatively given the same prediction error score. This in part at
    // least relates to the increased size and hence coding overheads of
    // motion vectors. Some account of this is made through adjustment of
    // the error divisor.
    ediv_size_correction =
        VPXMAX(0.2, VPXMIN(5.0, get_linear_size_factor(cpi)));
    if (ediv_size_correction < 1.0)
      ediv_size_correction = -(1.0 / ediv_size_correction);
    ediv_size_correction *= 4.0;

Jingning Han's avatar
Jingning Han committed
1118
1119
1120
    // Try and pick a max Q that will be high enough to encode the
    // content at the given rate.
    for (q = rc->best_quality; q < rc->worst_quality; ++q) {
1121
1122
1123
1124
1125
1126
1127
      const double factor = calc_correction_factor(
          av_err_per_mb, ERR_DIVISOR - ediv_size_correction, FACTOR_PT_LOW,
          FACTOR_PT_HIGH, q, cpi->common.bit_depth);
      const int bits_per_mb = vp10_rc_bits_per_mb(
          INTER_FRAME, q, factor * speed_term * group_weight_factor,
          cpi->common.bit_depth);
      if (bits_per_mb <= target_norm_bits_per_mb) break;
Jingning Han's avatar
Jingning Han committed
1128
1129
1130
    }

    // Restriction on active max q for constrained quality mode.
1131
    if (cpi->oxcf.rc_mode == VPX_CQ) q = VPXMAX(q, oxcf->cq_level);
Jingning Han's avatar
Jingning Han committed
1132
1133
1134
1135
    return q;
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
1136
static void setup_rf_level_maxq(VP10_COMP *cpi) {
Jingning Han's avatar
Jingning Han committed
1137
1138
1139
1140
  int i;
  RATE_CONTROL *const rc = &cpi->rc;
  for (i = INTER_NORMAL; i < RATE_FACTOR_LEVELS; ++i) {
    int qdelta = vp10_frame_type_qdelta(cpi, i, rc->worst_quality);
1141
    rc->rf_level_maxq[i] = VPXMAX(rc->worst_quality + qdelta, rc->best_quality);
Jingning Han's avatar
Jingning Han committed
1142
1143
1144
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
1145
void vp10_init_subsampling(VP10_COMP *cpi) {
Yaowu Xu's avatar
Yaowu Xu committed
1146
  const VP10_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
  RATE_CONTROL *const rc = &cpi->rc;
  const int w = cm->width;
  const int h = cm->height;
  int i;

  for (i = 0; i < FRAME_SCALE_STEPS; ++i) {
    // Note: Frames with odd-sized dimensions may result from this scaling.
    rc->frame_width[i] = (w * 16) / frame_scale_factor[i];
    rc->frame_height[i] = (h * 16) / frame_scale_factor[i];
  }

  setup_rf_level_maxq(cpi);
}

1161
1162
void vp10_calculate_coded_size(VP10_COMP *cpi, int *scaled_frame_width,
                               int *scaled_frame_height) {
Jingning Han's avatar
Jingning Han committed
1163
1164
1165
1166
1167
  RATE_CONTROL *const rc = &cpi->rc;
  *scaled_frame_width = rc->frame_width[rc->frame_size_selector];
  *scaled_frame_height = rc->frame_height[rc->frame_size_selector];
}

Yaowu Xu's avatar
Yaowu Xu committed
1168
void vp10_init_second_pass(VP10_COMP *cpi) {
hui su's avatar
hui su committed
1169
  const VP10EncoderConfig *const oxcf = &cpi->oxcf;
Yunqing Wang's avatar
Yunqing Wang committed
1170
  TWO_PASS *const twopass = &cpi->twopass;
Jingning Han's avatar
Jingning Han committed
1171
1172
1173
1174
1175
1176
  double frame_rate;
  FIRSTPASS_STATS *stats;

  zero_stats(&twopass->total_stats);
  zero_stats(&twopass->total_left_stats);

1177
  if (!twopass->stats_in_end) return;
Jingning Han's avatar
Jingning Han committed
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189

  stats = &twopass->total_stats;

  *stats = *twopass->stats_in_end;
  twopass->total_left_stats = *stats;

  frame_rate = 10000000.0 * stats->count / stats->duration;
  // Each frame can have a different duration, as the frame rate in the source
  // isn't guaranteed to be constant. The frame rate prior to the first frame
  // encoded in the second pass is a guess. However, the sum duration is not.
  // It is calculated based on the actual durations of all frames from the
  // first pass.
Yunqing Wang's avatar
Yunqing Wang committed
1190
  vp10_new_framerate(cpi, frame_rate);
1191
1192
  twopass->bits_left =
      (int64_t)(stats->duration * oxcf->target_bandwidth / 10000000.0);
Jingning Han's avatar
Jingning Han committed
1193
1194
1195
1196
1197
1198
1199

  // This variable monitors how far behind the second ref update is lagging.
  twopass->sr_update_lag = 1;

  // Scan the first pass file and calculate a modified total error based upon
  // the bias/power function used to allocate bits.
  {
1200
1201
    const double avg_error =
        stats->coded_error / DOUBLE_DIVIDE_CHECK(stats->count);
Jingning Han's avatar
Jingning Han committed
1202
1203
    const FIRSTPASS_STATS *s = twopass->stats_in;
    double modified_error_total = 0.0;
1204
1205
1206
1207
    twopass->modified_error_min =
        (avg_error * oxcf->two_pass_vbrmin_section) / 100;
    twopass->modified_error_max =
        (avg_error * oxcf->two_pass_vbrmax_section) / 100;
Jingning Han's avatar
Jingning Han committed
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
    while (s < twopass->stats_in_end) {
      modified_error_total += calculate_modified_err(cpi, twopass, oxcf, s);
      ++s;
    }
    twopass->modified_error_left = modified_error_total;
  }

  // Reset the vbr bits off target counters
  cpi->rc.vbr_bits_off_target = 0;
  cpi->rc.vbr_bits_off_target_fast = 0;

  cpi->rc.rate_error_estimate = 0;

  // Static sequence monitor variables.
  twopass->kf_zeromotion_pct = 100;
  twopass->last_kfgroup_zeromotion_pct = 100;

  if (oxcf->resize_mode != RESIZE_NONE) {
    vp10_init_subsampling(cpi);
  }
}

#define SR_DIFF_PART 0.0015
#define MOTION_AMP_PART 0.003
#define INTRA_PART 0.005
#define DEFAULT_DECAY_LIMIT 0.75
#define LOW_SR_DIFF_TRHESH 0.1
#define SR_DIFF_MAX 128.0

Yaowu Xu's avatar
Yaowu Xu committed
1237
static double get_sr_decay_rate(const VP10_COMP *cpi,
Jingning Han's avatar
Jingning Han committed
1238
                                const FIRSTPASS_STATS *frame) {
1239
1240
1241
  const int num_mbs = (cpi->oxcf.resize_mode != RESIZE_NONE) ? cpi->initial_mbs
                                                             : cpi->common.MBs;
  double sr_diff = (frame->sr_coded_error - frame->coded_error) / num_mbs;
Jingning Han's avatar
Jingning Han committed
1242
1243
1244
1245
  double sr_decay = 1.0;
  double modified_pct_inter;
  double modified_pcnt_intra;
  const double motion_amplitude_factor =
1246
      frame->pcnt_motion * ((frame->mvc_abs + frame->mvr_abs) / 2);
Jingning Han's avatar
Jingning Han committed
1247
1248
1249
1250
1251
1252
1253
1254
1255

  modified_pct_inter = frame->pcnt_inter;
  if ((frame->intra_error / DOUBLE_DIVIDE_CHECK(frame->coded_error)) <
      (double)NCOUNT_FRAME_II_THRESH) {
    modified_pct_inter = frame->pcnt_inter - frame->pcnt_neutral;
  }
  modified_pcnt_intra = 100 * (1.0 - modified_pct_inter);

  if ((sr_diff > LOW_SR_DIFF_TRHESH)) {
1256
    sr_diff = VPXMIN(sr_diff, SR_DIFF_MAX);
Jingning Han's avatar
Jingning Han committed
1257
1258
1259
1260
    sr_decay = 1.0 - (SR_DIFF_PART * sr_diff) -
               (MOTION_AMP_PART * motion_amplitude_factor) -
               (INTRA_PART * modified_pcnt_intra);
  }
1261
  return VPXMAX(sr_decay, VPXMIN(DEFAULT_DECAY_LIMIT, modified_pct_inter));
Jingning Han's avatar
Jingning Han committed
1262
1263
1264
1265
}

// This function gives an estimate of how badly we believe the prediction
// quality is decaying from frame to frame.
Yaowu Xu's avatar
Yaowu Xu committed
1266
static double get_zero_motion_factor(const VP10_COMP *cpi,
Jingning Han's avatar
Jingning Han committed
1267
                                     const FIRSTPASS_STATS *frame) {
1268
  const double zero_motion_pct = frame->pcnt_inter - frame->pcnt_motion;
Jingning Han's avatar
Jingning Han committed
1269
  double sr_decay = get_sr_decay_rate(cpi, frame);
1270
  return VPXMIN(sr_decay, zero_motion_pct);
Jingning Han's avatar
Jingning Han committed
1271
1272
1273
1274
}

#define ZM_POWER_FACTOR 0.75

Yaowu Xu's avatar
Yaowu Xu committed
1275
static double get_prediction_decay_rate(const VP10_COMP *cpi,
Jingning Han's avatar
Jingning Han committed
1276
1277
1278
                                        const FIRSTPASS_STATS *next_frame) {
  const double sr_decay_rate = get_sr_decay_rate(cpi, next_frame);
  const double zero_motion_factor =
1279
1280
      (0.95 * pow((next_frame->pcnt_inter - next_frame->pcnt_motion),
                  ZM_POWER_FACTOR));
Jingning Han's avatar
Jingning Han committed
1281

1282
1283
  return VPXMAX(zero_motion_factor,
                (sr_decay_rate + ((1.0 - sr_decay_rate) * zero_motion_factor)));
Jingning Han's avatar
Jingning Han committed
1284
1285
1286
1287
1288
}

// Function to test for a condition where a complex transition is followed
// by a static section. For example in slide shows where there is a fade
// between slides. This is to help with more optimal kf and gf positioning.
1289
1290
static int detect_transition_to_still(VP10_COMP *cpi, int frame_interval,
                                      int still_interval,
Jingning Han's avatar
Jingning Han committed
1291
1292
1293
1294
1295
1296
1297
1298
                                      double loop_decay_rate,
                                      double last_decay_rate) {
  TWO_PASS *const twopass = &cpi->twopass;
  RATE_CONTROL *const rc = &cpi->rc;

  // Break clause to detect very still sections after motion
  // For example a static image after a fade or other transition
  // instead of a clean scene cut.
1299
  if (frame_interval > rc->min_gf_interval && loop_decay_rate >= 0.999 &&
Jingning Han's avatar
Jingning Han committed
1300
1301
1302
1303
1304
1305
      last_decay_rate < 0.9) {
    int j;

    // Look ahead a few frames to see if static condition persists...
    for (j = 0; j < still_interval; ++j) {
      const FIRSTPASS_STATS *stats = &twopass->stats_in[j];
1306
      if (stats >= twopass->stats_in_end) break;
Jingning Han's avatar
Jingning Han committed
1307

1308
      if (stats->pcnt_inter - stats->pcnt_motion < 0.999) break;
Jingning Han's avatar
Jingning Han committed
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
    }

    // Only if it does do we signal a transition to still.
    return j == still_interval;
  }

  return 0;
}

// This function detects a flash through the high relative pcnt_second_ref
// score in the frame following a flash frame. The offset passed in should
// reflect this.
static int detect_flash(const TWO_PASS *twopass, int offset) {
  const FIRSTPASS_STATS *const next_frame = read_frame_stats(twopass, offset);

  // What we are looking for here is a situation where there is a
  // brief break in prediction (such as a flash) but subsequent frames
  // are reasonably well predicted by an earlier (pre flash) frame.
  // The recovery after a flash is indicated by a high pcnt_second_ref
  // compared to pcnt_inter.
  return next_frame != NULL &&
         next_frame->pcnt_second_ref > next_frame->pcnt_inter &&
         next_frame->pcnt_second_ref >= 0.5;
}

// Update the motion related elements to the GF arf boost calculation.
static void 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) {
  const double pct = stats->pcnt_motion;

  // Accumulate Motion In/Out of frame stats.
  *mv_in_out = stats->mv_in_out_count * pct;
  *mv_in_out_accumulator += *mv_in_out;
  *abs_mv_in_out_accumulator += fabs(*mv_in_out);

  // Accumulate a measure of how uniform (or conversely how random) the motion
  // field is (a ratio of abs(mv) / mv).
  if (pct > 0.05) {
1350
1351
1352
1353
    const double mvr_ratio =
        fabs(stats->mvr_abs) / DOUBLE_DIVIDE_CHECK(fabs(stats->MVr));
    const double mvc_ratio =
        fabs(stats->mvc_abs) / DOUBLE_DIVIDE_CHECK(fabs(stats->MVc));
Jingning Han's avatar
Jingning Han committed
1354

1355
1356
1357
1358
    *mv_ratio_accumulator +=
        pct * (mvr_ratio < stats->mvr_abs ? mvr_ratio : stats->mvr_abs);
    *mv_ratio_accumulator +=
        pct * (mvc_ratio < stats->mvc_abs ? mvc_ratio : stats->mvc_abs);
Jingning Han's avatar
Jingning Han committed
1359
1360
1361
1362
  }
}

#define BASELINE_ERR_PER_MB 1000.0
Yaowu Xu's avatar
Yaowu Xu committed
1363
static double calc_frame_boost(VP10_COMP *cpi,
Jingning Han's avatar
Jingning Han committed
1364
                               const FIRSTPASS_STATS *this_frame,
1365
                               double this_frame_mv_in_out, double max_boost) {
Jingning Han's avatar
Jingning Han committed
1366
  double frame_boost;
1367
1368
  const double lq = vp10_convert_qindex_to_q(
      cpi->rc.avg_frame_qindex[INTER_FRAME], cpi->common.bit_depth);
1369
  const double boost_q_correction = VPXMIN((0.5 + (lq * 0.015)), 1.5);
1370
1371
  int num_mbs = (cpi->oxcf.resize_mode != RESIZE_NONE) ? cpi->initial_mbs
                                                       : cpi->common.MBs;
Jingning Han's avatar
Jingning Han committed
1372
1373

  // Correct for any inactive region in the image
1374
  num_mbs = (int)VPXMAX(1, num_mbs * calculate_active_area(cpi, this_frame));
Jingning Han's avatar
Jingning Han committed
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389

  // Underlying boost factor is based on inter error ratio.
  frame_boost = (BASELINE_ERR_PER_MB * num_mbs) /
                DOUBLE_DIVIDE_CHECK(this_frame->coded_error);
  frame_boost = frame_boost * BOOST_FACTOR * boost_q_correction;

  // Increase boost for frames where new data coming into frame (e.g. zoom out).
  // Slightly reduce boost if there is a net balance of motion out of the frame
  // (zoom in). The range for this_frame_mv_in_out is -1.0 to +1.0.
  if (this_frame_mv_in_out > 0.0)
    frame_boost += frame_boost * (this_frame_mv_in_out * 2.0);
  // In the extreme case the boost is halved.
  else
    frame_boost += frame_boost * (this_frame_mv_in_out / 2.0);

1390
  return VPXMIN(frame_boost, max_boost * boost_q_correction);
Jingning Han's avatar
Jingning Han committed
1391
1392
}

1393
1394
static int calc_arf_boost(VP10_COMP *cpi, int offset, int f_frames,
                          int b_frames, int *f_boost, int *b_boost) {
Jingning Han's avatar
Jingning Han committed
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
  TWO_PASS *const twopass = &cpi->twopass;
  int i;
  double boost_score = 0.0;
  double mv_ratio_accumulator = 0.0;
  double decay_accumulator = 1.0;
  double this_frame_mv_in_out = 0.0;
  double mv_in_out_accumulator = 0.0;
  double abs_mv_in_out_accumulator = 0.0;
  int arf_boost;
  int flash_detected = 0;

  // Search forward from the proposed arf/next gf position.
  for (i = 0; i < f_frames; ++i) {
    const FIRSTPASS_STATS *this_frame = read_frame_stats(twopass, i + offset);
1409
    if (this_frame == NULL) break;
Jingning Han's avatar
Jingning Han committed
1410
1411

    // Update the motion related elements to the boost calculation.
1412
1413
1414
    accumulate_frame_motion_stats(
        this_frame, &this_frame_mv_in_out, &mv_in_out_accumulator,
        &abs_mv_in_out_accumulator, &mv_ratio_accumulator);
Jingning Han's avatar
Jingning Han committed
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424

    // We want to discount the flash frame itself and the recovery
    // frame that follows as both will have poor scores.
    flash_detected = detect_flash(twopass, i + offset) ||
                     detect_flash(twopass, i + offset + 1);

    // Accumulate the effect of prediction quality decay.
    if (!flash_detected) {
      decay_accumulator *= get_prediction_decay_rate(cpi, this_frame);
      decay_accumulator = decay_accumulator < MIN_DECAY_FACTOR
1425
1426
                              ? MIN_DECAY_FACTOR
                              : decay_accumulator;
Jingning Han's avatar
Jingning Han committed
1427
1428
    }

1429
1430
1431
    boost_score +=
        decay_accumulator *
        calc_frame_boost(cpi, this_frame, this_frame_mv_in_out, GF_MAX_BOOST);
Jingning Han's avatar
Jingning Han committed
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
  }

  *f_boost = (int)boost_score;

  // Reset for backward looking loop.
  boost_score = 0.0;
  mv_ratio_accumulator = 0.0;
  decay_accumulator = 1.0;
  this_frame_mv_in_out = 0.0;
  mv_in_out_accumulator = 0.0;
  abs_mv_in_out_accumulator = 0.0;

  // Search backward towards last gf position.
  for (i = -1; i >= -b_frames; --i) {
    const FIRSTPASS_STATS *this_frame = read_frame_stats(twopass, i + offset);
1447
    if (this_frame == NULL) break;
Jingning Han's avatar
Jingning Han committed
1448
1449

    // Update the motion related elements to the boost calculation.
1450
1451
1452
    accumulate_frame_motion_stats(
        this_frame, &this_frame_mv_in_out, &mv_in_out_accumulator,
        &abs_mv_in_out_accumulator, &mv_ratio_accumulator);
Jingning Han's avatar
Jingning Han committed
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462

    // We want to discount the the flash frame itself and the recovery
    // frame that follows as both will have poor scores.
    flash_detected = detect_flash(twopass, i + offset) ||
                     detect_flash(twopass, i + offset + 1);

    // Cumulative effect of prediction quality decay.
    if (!flash_detected) {
      decay_accumulator *= get_prediction_decay_rate(cpi, this_frame);
      decay_accumulator = decay_accumulator < MIN_DECAY_FACTOR
1463
1464
                              ? MIN_DECAY_FACTOR
                              : decay_accumulator;
Jingning Han's avatar
Jingning Han committed
1465
1466
    }

1467
1468
1469
    boost_score +=
        decay_accumulator *
        calc_frame_boost(cpi, this_frame, this_frame_mv_in_out, GF_MAX_BOOST);
Jingning Han's avatar
Jingning Han committed
1470
1471
1472
1473
1474
1475
  }
  *b_boost = (int)boost_score;

  arf_boost = (*f_boost + *b_boost);
  if (arf_boost < ((b_frames + f_frames) * 20))
    arf_boost = ((b_frames + f_frames) * 20);
1476
  arf_boost = VPXMAX(arf_boost, MIN_ARF_GF_BOOST);
Jingning Han's avatar
Jingning Han committed
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500

  return arf_boost;
}

// Calculate a section intra ratio used in setting max loop filter.
static int calculate_section_intra_ratio(const FIRSTPASS_STATS *begin,
                                         const FIRSTPASS_STATS *end,
                                         int section_length) {
  const FIRSTPASS_STATS *s = begin;
  double intra_error = 0.0;
  double coded_error = 0.0;
  int i = 0;

  while (s < end && i < section_length) {
    intra_error += s->intra_error;
    coded_error += s->coded_error;
    ++s;
    ++i;
  }

  return (int)(intra_error / DOUBLE_DIVIDE_CHECK(coded_error));
}

// Calculate the total bits to allocate in this GF/ARF group.
Yaowu Xu's avatar
Yaowu Xu committed
1501
static int64_t calculate_total_gf_group_bits(VP10_COMP *cpi,
Jingning Han's avatar
Jingning Han committed
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
                                             double gf_group_err) {
  const RATE_CONTROL *const rc = &cpi->rc;
  const TWO_PASS *const twopass = &cpi->twopass;
  const int max_bits = frame_max_bits(rc