vp9_encodeframe.c 91 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5 6
 *  that can be found in the LICENSE file in the root of the source
 *  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.
John Koleszar's avatar
John Koleszar committed
9 10 11
 */


12
#include "./vpx_config.h"
13
#include "vp9/encoder/vp9_encodeframe.h"
14 15
#include "vp9/encoder/vp9_encodemb.h"
#include "vp9/encoder/vp9_encodemv.h"
16
#include "vp9/common/vp9_common.h"
17
#include "vp9/encoder/vp9_onyx_int.h"
18
#include "vp9/common/vp9_extend.h"
Yaowu Xu's avatar
Yaowu Xu committed
19
#include "vp9/common/vp9_entropy.h"
20 21
#include "vp9/common/vp9_entropymode.h"
#include "vp9/common/vp9_quant_common.h"
22
#include "vp9/encoder/vp9_segmentation.h"
23
#include "vp9/common/vp9_setupintrarecon.h"
24
#include "vp9/encoder/vp9_encodeintra.h"
25 26
#include "vp9/common/vp9_reconinter.h"
#include "vp9/common/vp9_invtrans.h"
27
#include "vp9/encoder/vp9_rdopt.h"
28 29 30 31
#include "vp9/common/vp9_findnearmv.h"
#include "vp9/common/vp9_reconintra.h"
#include "vp9/common/vp9_seg_common.h"
#include "vp9/encoder/vp9_tokenize.h"
32
#include "vp9_rtcd.h"
John Koleszar's avatar
John Koleszar committed
33
#include <stdio.h>
34
#include <math.h>
John Koleszar's avatar
John Koleszar committed
35 36
#include <limits.h>
#include "vpx_ports/vpx_timer.h"
37 38
#include "vp9/common/vp9_pred_common.h"
#include "vp9/common/vp9_mvref_common.h"
Paul Wilkins's avatar
Paul Wilkins committed
39

Yaowu Xu's avatar
Yaowu Xu committed
40
#define DBG_PRNT_SEGMAP 0
41

42
// #define ENC_DEBUG
43
#ifdef ENC_DEBUG
John Koleszar's avatar
John Koleszar committed
44
int enc_debug = 0;
45 46
#endif

47 48
extern void select_interp_filter_type(VP9_COMP *cpi);

Ronald S. Bultje's avatar
Ronald S. Bultje committed
49 50
static void encode_macroblock(VP9_COMP *cpi, TOKENEXTRA **t,
                              int output_enabled, int mb_row, int mb_col);
51

Ronald S. Bultje's avatar
Ronald S. Bultje committed
52 53 54 55 56
static void encode_superblock32(VP9_COMP *cpi, TOKENEXTRA **t,
                                int output_enabled, int mb_row, int mb_col);

static void encode_superblock64(VP9_COMP *cpi, TOKENEXTRA **t,
                                int output_enabled, int mb_row, int mb_col);
57

58
static void adjust_act_zbin(VP9_COMP *cpi, MACROBLOCK *x);
59

John Koleszar's avatar
John Koleszar committed
60
#ifdef MODE_STATS
61
unsigned int inter_y_modes[MB_MODE_COUNT];
62
unsigned int inter_uv_modes[VP9_UV_MODES];
63
unsigned int inter_b_modes[B_MODE_COUNT];
64 65 66 67
unsigned int y_modes[VP9_YMODES];
unsigned int i8x8_modes[VP9_I8X8_MODES];
unsigned int uv_modes[VP9_UV_MODES];
unsigned int uv_modes_y[VP9_YMODES][VP9_UV_MODES];
68
unsigned int b_modes[B_MODE_COUNT];
John Koleszar's avatar
John Koleszar committed
69 70 71
#endif


72 73 74
/* activity_avg must be positive, or flat regions could get a zero weight
 *  (infinite lambda), which confounds analysis.
 * This also avoids the need for divide by zero checks in
75
 *  vp9_activity_masking().
76
 */
77
#define VP9_ACTIVITY_AVG_MIN (64)
78 79 80 81 82 83

/* This is used as a reference when computing the source variance for the
 *  purposes of activity masking.
 * Eventually this should be replaced by custom no-reference routines,
 *  which will be faster.
 */
84
static const uint8_t VP9_VAR_OFFS[16] = {
John Koleszar's avatar
John Koleszar committed
85
  128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128
86 87
};

88 89

// Original activity measure from Tim T's code.
90
static unsigned int tt_activity_measure(VP9_COMP *cpi, MACROBLOCK *x) {
John Koleszar's avatar
John Koleszar committed
91 92 93 94 95 96 97 98 99
  unsigned int act;
  unsigned int sse;
  /* TODO: This could also be done over smaller areas (8x8), but that would
   *  require extensive changes elsewhere, as lambda is assumed to be fixed
   *  over an entire MB in most of the code.
   * Another option is to compute four 8x8 variances, and pick a single
   *  lambda using a non-linear combination (e.g., the smallest, or second
   *  smallest, etc.).
   */
100
  act = vp9_variance16x16(x->src.y_buffer, x->src.y_stride, VP9_VAR_OFFS, 0,
101
                          &sse);
John Koleszar's avatar
John Koleszar committed
102 103 104 105 106 107 108
  act = act << 4;

  /* If the region is flat, lower the activity some more. */
  if (act < 8 << 12)
    act = act < 5 << 12 ? act : 5 << 12;

  return act;
109 110
}

111
// Stub for alternative experimental activity measures.
112
static unsigned int alt_activity_measure(VP9_COMP *cpi,
John Koleszar's avatar
John Koleszar committed
113
                                         MACROBLOCK *x, int use_dc_pred) {
114
  return vp9_encode_intra(cpi, x, use_dc_pred);
115 116 117 118 119
}


// Measure the activity of the current macroblock
// What we measure here is TBD so abstracted to this function
120
#define ALT_ACT_MEASURE 1
121
static unsigned int mb_activity_measure(VP9_COMP *cpi, MACROBLOCK *x,
John Koleszar's avatar
John Koleszar committed
122 123
                                        int mb_row, int mb_col) {
  unsigned int mb_activity;
124

John Koleszar's avatar
John Koleszar committed
125 126
  if (ALT_ACT_MEASURE) {
    int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
127

John Koleszar's avatar
John Koleszar committed
128 129 130 131 132 133
    // Or use and alternative.
    mb_activity = alt_activity_measure(cpi, x, use_dc_pred);
  } else {
    // Original activity measure from Tim T's code.
    mb_activity = tt_activity_measure(cpi, x);
  }
134

135 136
  if (mb_activity < VP9_ACTIVITY_AVG_MIN)
    mb_activity = VP9_ACTIVITY_AVG_MIN;
137

John Koleszar's avatar
John Koleszar committed
138
  return mb_activity;
139 140 141
}

// Calculate an "average" mb activity value for the frame
142
#define ACT_MEDIAN 0
143
static void calc_av_activity(VP9_COMP *cpi, int64_t activity_sum) {
144
#if ACT_MEDIAN
John Koleszar's avatar
John Koleszar committed
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
  // Find median: Simple n^2 algorithm for experimentation
  {
    unsigned int median;
    unsigned int i, j;
    unsigned int *sortlist;
    unsigned int tmp;

    // Create a list to sort to
    CHECK_MEM_ERROR(sortlist,
    vpx_calloc(sizeof(unsigned int),
    cpi->common.MBs));

    // Copy map to sort list
    vpx_memcpy(sortlist, cpi->mb_activity_map,
    sizeof(unsigned int) * cpi->common.MBs);


    // Ripple each value down to its correct position
    for (i = 1; i < cpi->common.MBs; i ++) {
      for (j = i; j > 0; j --) {
        if (sortlist[j] < sortlist[j - 1]) {
          // Swap values
          tmp = sortlist[j - 1];
          sortlist[j - 1] = sortlist[j];
          sortlist[j] = tmp;
        } else
          break;
      }
    }
174

John Koleszar's avatar
John Koleszar committed
175 176 177
    // Even number MBs so estimate median as mean of two either side.
    median = (1 + sortlist[cpi->common.MBs >> 1] +
              sortlist[(cpi->common.MBs >> 1) + 1]) >> 1;
178

John Koleszar's avatar
John Koleszar committed
179
    cpi->activity_avg = median;
180

John Koleszar's avatar
John Koleszar committed
181 182
    vpx_free(sortlist);
  }
183
#else
John Koleszar's avatar
John Koleszar committed
184 185
  // Simple mean for now
  cpi->activity_avg = (unsigned int)(activity_sum / cpi->common.MBs);
186 187
#endif

188 189
  if (cpi->activity_avg < VP9_ACTIVITY_AVG_MIN)
    cpi->activity_avg = VP9_ACTIVITY_AVG_MIN;
190

John Koleszar's avatar
John Koleszar committed
191 192 193
  // Experimental code: return fixed value normalized for several clips
  if (ALT_ACT_MEASURE)
    cpi->activity_avg = 100000;
194 195
}

196
#define USE_ACT_INDEX   0
197
#define OUTPUT_NORM_ACT_STATS   0
198 199 200

#if USE_ACT_INDEX
// Calculate and activity index for each mb
201 202
static void calc_activity_index(VP9_COMP *cpi, MACROBLOCK *x) {
  VP9_COMMON *const cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
203
  int mb_row, mb_col;
204

John Koleszar's avatar
John Koleszar committed
205 206 207
  int64_t act;
  int64_t a;
  int64_t b;
208 209

#if OUTPUT_NORM_ACT_STATS
John Koleszar's avatar
John Koleszar committed
210 211
  FILE *f = fopen("norm_act.stt", "a");
  fprintf(f, "\n%12d\n", cpi->activity_avg);
212 213
#endif

John Koleszar's avatar
John Koleszar committed
214 215
  // Reset pointers to start of activity map
  x->mb_activity_ptr = cpi->mb_activity_map;
216

John Koleszar's avatar
John Koleszar committed
217 218 219 220 221 222
  // Calculate normalized mb activity number.
  for (mb_row = 0; mb_row < cm->mb_rows; mb_row++) {
    // for each macroblock col in image
    for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) {
      // Read activity from the map
      act = *(x->mb_activity_ptr);
223

John Koleszar's avatar
John Koleszar committed
224 225 226
      // Calculate a normalized activity number
      a = act + 4 * cpi->activity_avg;
      b = 4 * act + cpi->activity_avg;
227

John Koleszar's avatar
John Koleszar committed
228 229 230 231
      if (b >= a)
        *(x->activity_ptr) = (int)((b + (a >> 1)) / a) - 1;
      else
        *(x->activity_ptr) = 1 - (int)((a + (b >> 1)) / b);
232 233

#if OUTPUT_NORM_ACT_STATS
John Koleszar's avatar
John Koleszar committed
234
      fprintf(f, " %6d", *(x->mb_activity_ptr));
235
#endif
John Koleszar's avatar
John Koleszar committed
236 237 238
      // Increment activity map pointers
      x->mb_activity_ptr++;
    }
239 240

#if OUTPUT_NORM_ACT_STATS
John Koleszar's avatar
John Koleszar committed
241
    fprintf(f, "\n");
242 243
#endif

John Koleszar's avatar
John Koleszar committed
244
  }
245 246

#if OUTPUT_NORM_ACT_STATS
John Koleszar's avatar
John Koleszar committed
247
  fclose(f);
248 249 250
#endif

}
251
#endif
252 253 254

// Loop through all MBs. Note activity of each, average activity and
// calculate a normalized activity for each
255
static void build_activity_map(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
256
  MACROBLOCK *const x = &cpi->mb;
John Koleszar's avatar
John Koleszar committed
257
  MACROBLOCKD *xd = &x->e_mbd;
258
  VP9_COMMON *const cm = &cpi->common;
259

260
#if ALT_ACT_MEASURE
John Koleszar's avatar
John Koleszar committed
261 262 263
  YV12_BUFFER_CONFIG *new_yv12 = &cm->yv12_fb[cm->new_fb_idx];
  int recon_yoffset;
  int recon_y_stride = new_yv12->y_stride;
264 265
#endif

John Koleszar's avatar
John Koleszar committed
266 267 268
  int mb_row, mb_col;
  unsigned int mb_activity;
  int64_t activity_sum = 0;
269

John Koleszar's avatar
John Koleszar committed
270 271
  // for each macroblock row in image
  for (mb_row = 0; mb_row < cm->mb_rows; mb_row++) {
272
#if ALT_ACT_MEASURE
John Koleszar's avatar
John Koleszar committed
273 274 275
    // reset above block coeffs
    xd->up_available = (mb_row != 0);
    recon_yoffset = (mb_row * recon_y_stride * 16);
276
#endif
John Koleszar's avatar
John Koleszar committed
277 278
    // for each macroblock col in image
    for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) {
279
#if ALT_ACT_MEASURE
John Koleszar's avatar
John Koleszar committed
280 281 282
      xd->dst.y_buffer = new_yv12->y_buffer + recon_yoffset;
      xd->left_available = (mb_col != 0);
      recon_yoffset += 16;
283
#endif
284

John Koleszar's avatar
John Koleszar committed
285 286
      // measure activity
      mb_activity = mb_activity_measure(cpi, x, mb_row, mb_col);
287

John Koleszar's avatar
John Koleszar committed
288 289
      // Keep frame sum
      activity_sum += mb_activity;
290

John Koleszar's avatar
John Koleszar committed
291 292
      // Store MB level activity details.
      *x->mb_activity_ptr = mb_activity;
293

John Koleszar's avatar
John Koleszar committed
294 295
      // Increment activity map pointer
      x->mb_activity_ptr++;
296

John Koleszar's avatar
John Koleszar committed
297 298 299
      // adjust to the next column of source macroblocks
      x->src.y_buffer += 16;
    }
300

301

John Koleszar's avatar
John Koleszar committed
302 303
    // adjust to the next row of mbs
    x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
304 305

#if ALT_ACT_MEASURE
John Koleszar's avatar
John Koleszar committed
306
    // extend the recon for intra prediction
307
    vp9_extend_mb_row(new_yv12, xd->dst.y_buffer + 16,
John Koleszar's avatar
John Koleszar committed
308
                      xd->dst.u_buffer + 8, xd->dst.v_buffer + 8);
309 310
#endif

John Koleszar's avatar
John Koleszar committed
311
  }
312

John Koleszar's avatar
John Koleszar committed
313 314
  // Calculate an "average" MB activity
  calc_av_activity(cpi, activity_sum);
315

316
#if USE_ACT_INDEX
John Koleszar's avatar
John Koleszar committed
317 318
  // Calculate an activity index number of each mb
  calc_activity_index(cpi, x);
319 320
#endif

321 322
}

323
// Macroblock activity masking
324
void vp9_activity_masking(VP9_COMP *cpi, MACROBLOCK *x) {
325
#if USE_ACT_INDEX
John Koleszar's avatar
John Koleszar committed
326 327 328
  x->rdmult += *(x->mb_activity_ptr) * (x->rdmult >> 2);
  x->errorperbit = x->rdmult * 100 / (110 * x->rddiv);
  x->errorperbit += (x->errorperbit == 0);
329
#else
John Koleszar's avatar
John Koleszar committed
330 331 332
  int64_t a;
  int64_t b;
  int64_t act = *(x->mb_activity_ptr);
333

John Koleszar's avatar
John Koleszar committed
334 335 336
  // Apply the masking to the RD multiplier.
  a = act + (2 * cpi->activity_avg);
  b = (2 * act) + cpi->activity_avg;
337

John Koleszar's avatar
John Koleszar committed
338 339 340
  x->rdmult = (unsigned int)(((int64_t)x->rdmult * b + (a >> 1)) / a);
  x->errorperbit = x->rdmult * 100 / (110 * x->rddiv);
  x->errorperbit += (x->errorperbit == 0);
341
#endif
342

John Koleszar's avatar
John Koleszar committed
343 344
  // Activity based Zbin adjustment
  adjust_act_zbin(cpi, x);
345
}
John Koleszar's avatar
John Koleszar committed
346

Deb Mukherjee's avatar
Deb Mukherjee committed
347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391
#if CONFIG_NEW_MVREF
static int vp9_cost_mv_ref_id(vp9_prob * ref_id_probs, int mv_ref_id) {
  int cost;

  // Encode the index for the MV reference.
  switch (mv_ref_id) {
    case 0:
      cost = vp9_cost_zero(ref_id_probs[0]);
      break;
    case 1:
      cost = vp9_cost_one(ref_id_probs[0]);
      cost += vp9_cost_zero(ref_id_probs[1]);
      break;
    case 2:
      cost = vp9_cost_one(ref_id_probs[0]);
      cost += vp9_cost_one(ref_id_probs[1]);
      cost += vp9_cost_zero(ref_id_probs[2]);
      break;
    case 3:
      cost = vp9_cost_one(ref_id_probs[0]);
      cost += vp9_cost_one(ref_id_probs[1]);
      cost += vp9_cost_one(ref_id_probs[2]);
      break;

      // TRAP.. This should not happen
    default:
      assert(0);
      break;
  }
  return cost;
}

// Estimate the cost of each coding the vector using each reference candidate
static unsigned int pick_best_mv_ref(MACROBLOCK *x,
                                     MV_REFERENCE_FRAME ref_frame,
                                     int_mv target_mv,
                                     int_mv * mv_ref_list,
                                     int_mv * best_ref) {
  int i;
  int best_index = 0;
  int cost, cost2;
  int zero_seen = (mv_ref_list[0].as_int) ? FALSE : TRUE;
  MACROBLOCKD *xd = &x->e_mbd;
  int max_mv = MV_MAX;

392
  cost = vp9_cost_mv_ref_id(xd->mb_mv_ref_probs[ref_frame], 0) +
Deb Mukherjee's avatar
Deb Mukherjee committed
393 394 395
         vp9_mv_bit_cost(&target_mv, &mv_ref_list[0], x->nmvjointcost,
                         x->mvcost, 96, xd->allow_high_precision_mv);

Paul Wilkins's avatar
Paul Wilkins committed
396
  for (i = 1; i < MAX_MV_REF_CANDIDATES; ++i) {
Deb Mukherjee's avatar
Deb Mukherjee committed
397 398
    // If we see a 0,0 reference vector for a second time we have reached
    // the end of the list of valid candidate vectors.
Jim Bankoski's avatar
Jim Bankoski committed
399
    if (!mv_ref_list[i].as_int) {
Deb Mukherjee's avatar
Deb Mukherjee committed
400 401 402 403
      if (zero_seen)
        break;
      else
        zero_seen = TRUE;
Jim Bankoski's avatar
Jim Bankoski committed
404
    }
Deb Mukherjee's avatar
Deb Mukherjee committed
405 406 407 408 409 410 411 412

    // Check for cases where the reference choice would give rise to an
    // uncodable/out of range residual for row or col.
    if ((abs(target_mv.as_mv.row - mv_ref_list[i].as_mv.row) > max_mv) ||
        (abs(target_mv.as_mv.col - mv_ref_list[i].as_mv.col) > max_mv)) {
      continue;
    }

413
    cost2 = vp9_cost_mv_ref_id(xd->mb_mv_ref_probs[ref_frame], i) +
Deb Mukherjee's avatar
Deb Mukherjee committed
414 415 416 417 418 419 420 421 422 423 424 425 426 427
            vp9_mv_bit_cost(&target_mv, &mv_ref_list[i], x->nmvjointcost,
                            x->mvcost, 96, xd->allow_high_precision_mv);

    if (cost2 < cost) {
      cost = cost2;
      best_index = i;
    }
  }
  best_ref->as_int = mv_ref_list[best_index].as_int;

  return best_index;
}
#endif

428
static void update_state(VP9_COMP *cpi,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
429 430 431
                         PICK_MODE_CONTEXT *ctx, int block_size,
                         int output_enabled) {
  int i, x_idx, y;
432 433
  MACROBLOCK *const x = &cpi->mb;
  MACROBLOCKD *const xd = &x->e_mbd;
John Koleszar's avatar
John Koleszar committed
434
  MODE_INFO *mi = &ctx->mic;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
435
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
John Koleszar's avatar
John Koleszar committed
436 437
  int mb_mode = mi->mbmi.mode;
  int mb_mode_index = ctx->best_mode_index;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
438 439
  const int mis = cpi->common.mode_info_stride;
  int mb_block_size = 1 << mi->mbmi.sb_type;
Adrian Grange's avatar
Adrian Grange committed
440 441

#if CONFIG_DEBUG
John Koleszar's avatar
John Koleszar committed
442 443 444
  assert(mb_mode < MB_MODE_COUNT);
  assert(mb_mode_index < MAX_MODES);
  assert(mi->mbmi.ref_frame < MAX_REF_FRAMES);
Adrian Grange's avatar
Adrian Grange committed
445
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
446
  assert(mi->mbmi.sb_type == (block_size >> 5));
Adrian Grange's avatar
Adrian Grange committed
447

John Koleszar's avatar
John Koleszar committed
448 449
  // Restore the coding context of the MB to that that was in place
  // when the mode was picked for it
Ronald S. Bultje's avatar
Ronald S. Bultje committed
450 451 452 453 454 455 456 457
  for (y = 0; y < mb_block_size; y++) {
    for (x_idx = 0; x_idx < mb_block_size; x_idx++) {
      if ((xd->mb_to_right_edge >> 7) + mb_block_size > x_idx &&
          (xd->mb_to_bottom_edge >> 7) + mb_block_size > y) {
        MODE_INFO *mi_addr = xd->mode_info_context + x_idx + y * mis;

        vpx_memcpy(mi_addr, mi, sizeof(MODE_INFO));
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
458
    }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
459 460
  }
  if (block_size == 16) {
461
    ctx->txfm_rd_diff[ALLOW_32X32] = ctx->txfm_rd_diff[ALLOW_16X16];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
462
  }
Adrian Grange's avatar
Adrian Grange committed
463

John Koleszar's avatar
John Koleszar committed
464 465 466
  if (mb_mode == B_PRED) {
    for (i = 0; i < 16; i++) {
      xd->block[i].bmi.as_mode = xd->mode_info_context->bmi[i].as_mode;
Frank Galligan's avatar
Frank Galligan committed
467
      assert(xd->block[i].bmi.as_mode.first < B_MODE_COUNT);
Adrian Grange's avatar
Adrian Grange committed
468
    }
John Koleszar's avatar
John Koleszar committed
469 470 471
  } else if (mb_mode == I8X8_PRED) {
    for (i = 0; i < 16; i++) {
      xd->block[i].bmi = xd->mode_info_context->bmi[i];
Adrian Grange's avatar
Adrian Grange committed
472
    }
John Koleszar's avatar
John Koleszar committed
473 474 475 476
  } else if (mb_mode == SPLITMV) {
    vpx_memcpy(x->partition_info, &ctx->partition_info,
               sizeof(PARTITION_INFO));

477 478
    mbmi->mv[0].as_int = x->partition_info->bmi[15].mv.as_int;
    mbmi->mv[1].as_int = x->partition_info->bmi[15].second_mv.as_int;
John Koleszar's avatar
John Koleszar committed
479 480
  }

481
  x->skip = ctx->skip;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
482 483 484
  if (!output_enabled)
    return;

485 486
  {
    int segment_id = mbmi->segment_id;
Paul Wilkins's avatar
Paul Wilkins committed
487
    if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
488 489 490 491 492 493
      for (i = 0; i < NB_TXFM_MODES; i++) {
        cpi->rd_tx_select_diff[i] += ctx->txfm_rd_diff[i];
      }
    }
  }

John Koleszar's avatar
John Koleszar committed
494 495 496 497 498 499 500 501 502
  if (cpi->common.frame_type == KEY_FRAME) {
    // Restore the coding modes to that held in the coding context
    // if (mb_mode == B_PRED)
    //    for (i = 0; i < 16; i++)
    //    {
    //        xd->block[i].bmi.as_mode =
    //                          xd->mode_info_context->bmi[i].as_mode;
    //        assert(xd->mode_info_context->bmi[i].as_mode < MB_MODE_COUNT);
    //    }
503
#if CONFIG_INTERNAL_STATS
John Koleszar's avatar
John Koleszar committed
504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
    static const int kf_mode_index[] = {
      THR_DC /*DC_PRED*/,
      THR_V_PRED /*V_PRED*/,
      THR_H_PRED /*H_PRED*/,
      THR_D45_PRED /*D45_PRED*/,
      THR_D135_PRED /*D135_PRED*/,
      THR_D117_PRED /*D117_PRED*/,
      THR_D153_PRED /*D153_PRED*/,
      THR_D27_PRED /*D27_PRED*/,
      THR_D63_PRED /*D63_PRED*/,
      THR_TM /*TM_PRED*/,
      THR_I8X8_PRED /*I8X8_PRED*/,
      THR_B_PRED /*B_PRED*/,
    };
    cpi->mode_chosen_counts[kf_mode_index[mb_mode]]++;
519
#endif
John Koleszar's avatar
John Koleszar committed
520 521 522 523 524 525 526
  } else {
    /*
            // Reduce the activation RD thresholds for the best choice mode
            if ((cpi->rd_baseline_thresh[mb_mode_index] > 0) &&
                (cpi->rd_baseline_thresh[mb_mode_index] < (INT_MAX >> 2)))
            {
                int best_adjustment = (cpi->rd_thresh_mult[mb_mode_index] >> 2);
Adrian Grange's avatar
Adrian Grange committed
527

John Koleszar's avatar
John Koleszar committed
528 529 530 531 532 533 534 535
                cpi->rd_thresh_mult[mb_mode_index] =
                        (cpi->rd_thresh_mult[mb_mode_index]
                         >= (MIN_THRESHMULT + best_adjustment)) ?
                                cpi->rd_thresh_mult[mb_mode_index] - best_adjustment :
                                MIN_THRESHMULT;
                cpi->rd_threshes[mb_mode_index] =
                        (cpi->rd_baseline_thresh[mb_mode_index] >> 7)
                        * cpi->rd_thresh_mult[mb_mode_index];
Adrian Grange's avatar
Adrian Grange committed
536

John Koleszar's avatar
John Koleszar committed
537 538 539 540
            }
    */
    // Note how often each mode chosen as best
    cpi->mode_chosen_counts[mb_mode_index]++;
Deb Mukherjee's avatar
Deb Mukherjee committed
541 542 543
    if (mbmi->mode == SPLITMV || mbmi->mode == NEWMV) {
      int_mv best_mv, best_second_mv;
      MV_REFERENCE_FRAME rf = mbmi->ref_frame;
Jim Bankoski's avatar
Jim Bankoski committed
544 545
#if CONFIG_NEW_MVREF
      unsigned int best_index;
Deb Mukherjee's avatar
Deb Mukherjee committed
546
      MV_REFERENCE_FRAME sec_ref_frame = mbmi->second_ref_frame;
Jim Bankoski's avatar
Jim Bankoski committed
547
#endif
Deb Mukherjee's avatar
Deb Mukherjee committed
548 549 550 551 552 553 554 555 556
      best_mv.as_int = ctx->best_ref_mv.as_int;
      best_second_mv.as_int = ctx->second_best_ref_mv.as_int;
      if (mbmi->mode == NEWMV) {
        best_mv.as_int = mbmi->ref_mvs[rf][0].as_int;
        best_second_mv.as_int = mbmi->ref_mvs[mbmi->second_ref_frame][0].as_int;
#if CONFIG_NEW_MVREF
        best_index = pick_best_mv_ref(x, rf, mbmi->mv[0],
                                      mbmi->ref_mvs[rf], &best_mv);
        mbmi->best_index = best_index;
557
        ++cpi->mb_mv_ref_count[rf][best_index];
Deb Mukherjee's avatar
Deb Mukherjee committed
558

559
        if (mbmi->second_ref_frame > 0) {
Deb Mukherjee's avatar
Deb Mukherjee committed
560 561 562 563 564 565
          unsigned int best_index;
          best_index =
              pick_best_mv_ref(x, sec_ref_frame, mbmi->mv[1],
                               mbmi->ref_mvs[sec_ref_frame],
                               &best_second_mv);
          mbmi->best_second_index = best_index;
566
          ++cpi->mb_mv_ref_count[sec_ref_frame][best_index];
Deb Mukherjee's avatar
Deb Mukherjee committed
567 568 569 570 571 572 573
        }
#endif
      }
      mbmi->best_mv.as_int = best_mv.as_int;
      mbmi->best_second_mv.as_int = best_second_mv.as_int;
      vp9_update_nmv_count(cpi, x, &best_mv, &best_second_mv);
    }
574 575 576 577 578 579 580 581 582 583 584 585 586
#if CONFIG_COMP_INTERINTRA_PRED
    if (mbmi->mode >= NEARESTMV && mbmi->mode < SPLITMV &&
        mbmi->second_ref_frame <= INTRA_FRAME) {
      if (mbmi->second_ref_frame == INTRA_FRAME) {
        ++cpi->interintra_count[1];
        ++cpi->ymode_count[mbmi->interintra_mode];
#if SEPARATE_INTERINTRA_UV
        ++cpi->y_uv_mode_count[mbmi->interintra_mode][mbmi->interintra_uv_mode];
#endif
      } else {
        ++cpi->interintra_count[0];
      }
    }
587
#endif
588 589 590 591 592 593 594
    if (cpi->common.mcomp_filter_type == SWITCHABLE &&
        mbmi->mode >= NEARESTMV &&
        mbmi->mode <= SPLITMV) {
      ++cpi->switchable_interp_count
          [vp9_get_pred_context(&cpi->common, xd, PRED_SWITCHABLE_INTERP)]
          [vp9_switchable_interp_map[mbmi->interp_filter]];
    }
Adrian Grange's avatar
Adrian Grange committed
595

John Koleszar's avatar
John Koleszar committed
596 597
    cpi->prediction_error += ctx->distortion;
    cpi->intra_error += ctx->intra_error;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
598

599 600 601
    cpi->rd_comp_pred_diff[SINGLE_PREDICTION_ONLY] += ctx->single_pred_diff;
    cpi->rd_comp_pred_diff[COMP_PREDICTION_ONLY]   += ctx->comp_pred_diff;
    cpi->rd_comp_pred_diff[HYBRID_PREDICTION]      += ctx->hybrid_pred_diff;
John Koleszar's avatar
John Koleszar committed
602
  }
Adrian Grange's avatar
Adrian Grange committed
603 604
}

Ronald S. Bultje's avatar
Ronald S. Bultje committed
605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622
static unsigned find_seg_id(uint8_t *buf, int block_size,
                            int start_y, int height, int start_x, int width) {
  const int end_x = MIN(start_x + block_size, width);
  const int end_y = MIN(start_y + block_size, height);
  int x, y;
  unsigned seg_id = -1;

  buf += width * start_y;
  for (y = start_y; y < end_y; y++, buf += width) {
    for (x = start_x; x < end_x; x++) {
      seg_id = MIN(seg_id, buf[x]);
    }
  }

  return seg_id;
}

static void set_offsets(VP9_COMP *cpi,
623
                        int mb_row, int mb_col, int block_size) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
624 625 626 627 628 629 630 631
  MACROBLOCK *const x = &cpi->mb;
  VP9_COMMON *const cm = &cpi->common;
  MACROBLOCKD *const xd = &x->e_mbd;
  MB_MODE_INFO *mbmi;
  const int dst_fb_idx = cm->new_fb_idx;
  const int idx_map = mb_row * cm->mb_cols + mb_col;
  const int idx_str = xd->mode_info_stride * mb_row + mb_col;

632 633 634 635
#ifdef ENC_DEBUG
  enc_debug = (cpi->common.current_video_frame == 2 &&
               mb_row == 4 && mb_col == 5);
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653
  // entropy context structures
  xd->above_context = cm->above_context + mb_col;
  xd->left_context  = cm->left_context + (mb_row & 3);

  // GF active flags data structure
  x->gf_active_ptr = (signed char *)&cpi->gf_active_flags[idx_map];

  // Activity map pointer
  x->mb_activity_ptr = &cpi->mb_activity_map[idx_map];
  x->active_ptr = cpi->active_map + idx_map;

  /* pointers to mode info contexts */
  x->partition_info          = x->pi + idx_str;
  xd->mode_info_context      = cm->mi + idx_str;
  mbmi = &xd->mode_info_context->mbmi;
  xd->prev_mode_info_context = cm->prev_mi + idx_str;

  // Set up destination pointers
654 655 656
  setup_pred_block(&xd->dst,
                   &cm->yv12_fb[dst_fb_idx],
                   mb_row, mb_col);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675

  /* Set up limit values for MV components to prevent them from
   * extending beyond the UMV borders assuming 16x16 block size */
  x->mv_row_min = -((mb_row * 16) + VP9BORDERINPIXELS - VP9_INTERP_EXTEND);
  x->mv_col_min = -((mb_col * 16) + VP9BORDERINPIXELS - VP9_INTERP_EXTEND);
  x->mv_row_max = ((cm->mb_rows - mb_row) * 16 +
                   (VP9BORDERINPIXELS - block_size - VP9_INTERP_EXTEND));
  x->mv_col_max = ((cm->mb_cols - mb_col) * 16 +
                   (VP9BORDERINPIXELS - block_size - VP9_INTERP_EXTEND));

  // Set up distance of MB to edge of frame in 1/8th pel units
  block_size >>= 4;  // in macroblock units
  assert(!(mb_col & (block_size - 1)) && !(mb_row & (block_size - 1)));
  xd->mb_to_top_edge    = -((mb_row * 16) << 3);
  xd->mb_to_left_edge   = -((mb_col * 16) << 3);
  xd->mb_to_bottom_edge = ((cm->mb_rows - block_size - mb_row) * 16) << 3;
  xd->mb_to_right_edge  = ((cm->mb_cols - block_size - mb_col) * 16) << 3;

  // Are edges available for intra prediction?
676 677 678
  xd->up_available    = (mb_row != 0);
  xd->left_available  = (mb_col > cm->cur_tile_mb_col_start);
  xd->right_available = (mb_col + block_size < cm->cur_tile_mb_col_end);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
679 680

  /* set up source buffers */
681
  setup_pred_block(&x->src, cpi->Source, mb_row, mb_col);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711

  /* R/D setup */
  x->rddiv = cpi->RDDIV;
  x->rdmult = cpi->RDMULT;

  /* segment ID */
  if (xd->segmentation_enabled) {
    if (xd->update_mb_segmentation_map) {
      mbmi->segment_id = find_seg_id(cpi->segmentation_map, block_size,
                                     mb_row, cm->mb_rows, mb_col, cm->mb_cols);
    } else {
      mbmi->segment_id = find_seg_id(cm->last_frame_seg_map, block_size,
                                     mb_row, cm->mb_rows, mb_col, cm->mb_cols);
    }
    assert(mbmi->segment_id <= 3);
    vp9_mb_init_quantizer(cpi, x);

    if (xd->segmentation_enabled && cpi->seg0_cnt > 0 &&
        !vp9_segfeature_active(xd, 0, SEG_LVL_REF_FRAME) &&
        vp9_segfeature_active(xd, 1, SEG_LVL_REF_FRAME) &&
        vp9_check_segref(xd, 1, INTRA_FRAME)  +
        vp9_check_segref(xd, 1, LAST_FRAME)   +
        vp9_check_segref(xd, 1, GOLDEN_FRAME) +
        vp9_check_segref(xd, 1, ALTREF_FRAME) == 1) {
      cpi->seg0_progress = (cpi->seg0_idx << 16) / cpi->seg0_cnt;
    } else {
      const int y = mb_row & ~3;
      const int x = mb_col & ~3;
      const int p16 = ((mb_row & 1) << 1) +  (mb_col & 1);
      const int p32 = ((mb_row & 2) << 2) + ((mb_col & 2) << 1);
712 713
      const int tile_progress = cm->cur_tile_mb_col_start * cm->mb_rows;
      const int mb_cols = cm->cur_tile_mb_col_end - cm->cur_tile_mb_col_start;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
714 715

      cpi->seg0_progress =
716
          ((y * mb_cols + x * 4 + p32 + p16 + tile_progress) << 16) / cm->MBs;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
717 718 719 720 721 722
    }
  } else {
    mbmi->segment_id = 0;
  }
}

723
static int pick_mb_modes(VP9_COMP *cpi,
724 725
                         int mb_row0,
                         int mb_col0,
726 727 728
                         TOKENEXTRA **tp,
                         int *totalrate,
                         int *totaldist) {
729 730 731
  VP9_COMMON *const cm = &cpi->common;
  MACROBLOCK *const x = &cpi->mb;
  MACROBLOCKD *const xd = &x->e_mbd;
John Koleszar's avatar
John Koleszar committed
732
  int i;
733
  int splitmodes_used = 0;
John Koleszar's avatar
John Koleszar committed
734 735 736
  ENTROPY_CONTEXT_PLANES left_context[2];
  ENTROPY_CONTEXT_PLANES above_context[2];
  ENTROPY_CONTEXT_PLANES *initial_above_context_ptr = cm->above_context
737
                                                      + mb_col0;
John Koleszar's avatar
John Koleszar committed
738 739 740

  /* Function should not modify L & A contexts; save and restore on exit */
  vpx_memcpy(left_context,
741
             cm->left_context + (mb_row0 & 2),
John Koleszar's avatar
John Koleszar committed
742 743 744 745 746 747 748
             sizeof(left_context));
  vpx_memcpy(above_context,
             initial_above_context_ptr,
             sizeof(above_context));

  /* Encode MBs in raster order within the SB */
  for (i = 0; i < 4; i++) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
749
    const int x_idx = i & 1, y_idx = i >> 1;
750 751
    const int mb_row = mb_row0 + y_idx;
    const int mb_col = mb_col0 + x_idx;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
752
    MB_MODE_INFO *mbmi;
John Koleszar's avatar
John Koleszar committed
753

754
    if ((mb_row >= cm->mb_rows) || (mb_col >= cm->mb_cols)) {
John Koleszar's avatar
John Koleszar committed
755 756 757
      // MB lies outside frame, move on
      continue;
    }
758

John Koleszar's avatar
John Koleszar committed
759 760
    // Index of the MB in the SB 0..3
    xd->mb_index = i;
761
    set_offsets(cpi, mb_row, mb_col, 16);
John Koleszar's avatar
John Koleszar committed
762 763

    if (cpi->oxcf.tuning == VP8_TUNE_SSIM)
764
      vp9_activity_masking(cpi, x);
John Koleszar's avatar
John Koleszar committed
765

Ronald S. Bultje's avatar
Ronald S. Bultje committed
766 767
    mbmi = &xd->mode_info_context->mbmi;
    mbmi->sb_type = BLOCK_SIZE_MB16X16;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
768

John Koleszar's avatar
John Koleszar committed
769 770 771
    // Find best coding mode & reconstruct the MB so it is available
    // as a predictor for MBs that follow in the SB
    if (cm->frame_type == KEY_FRAME) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
772
      int r, d;
773 774 775 776
#ifdef ENC_DEBUG
      if (enc_debug)
        printf("intra pick_mb_modes %d %d\n", mb_row, mb_col);
#endif
777
      vp9_rd_pick_intra_mode(cpi, x, &r, &d);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
778 779
      *totalrate += r;
      *totaldist += d;
John Koleszar's avatar
John Koleszar committed
780 781

      // Dummy encode, do not do the tokenization
782 783
      encode_macroblock(cpi, tp, 0, mb_row, mb_col);

John Koleszar's avatar
John Koleszar committed
784
      // Note the encoder may have changed the segment_id
Ronald S. Bultje's avatar
Ronald S. Bultje committed
785 786

      // Save the coding context
Ronald S. Bultje's avatar
Ronald S. Bultje committed
787
      vpx_memcpy(&x->mb_context[xd->sb_index][i].mic, xd->mode_info_context,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
788
                 sizeof(MODE_INFO));
John Koleszar's avatar
John Koleszar committed
789
    } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
790
      int seg_id, r, d;
John Koleszar's avatar
John Koleszar committed
791

792 793
#ifdef ENC_DEBUG
      if (enc_debug)
794
        printf("inter pick_mb_modes %d %d\n", mb_row, mb_col);
795
#endif
796
      vp9_pick_mode_inter_macroblock(cpi, x, mb_row, mb_col, &r, &d);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
797 798
      *totalrate += r;
      *totaldist += d;
John Koleszar's avatar
John Koleszar committed
799

800 801
      splitmodes_used += (mbmi->mode == SPLITMV);

John Koleszar's avatar
John Koleszar committed
802
      // Dummy encode, do not do the tokenization
803
      encode_macroblock(cpi, tp, 0, mb_row, mb_col);
John Koleszar's avatar
John Koleszar committed
804

Paul Wilkins's avatar
Paul Wilkins committed
805
      seg_id = mbmi->segment_id;
John Koleszar's avatar
John Koleszar committed
806 807 808 809
      if (cpi->mb.e_mbd.segmentation_enabled && seg_id == 0) {
        cpi->seg0_idx++;
      }
      if (!xd->segmentation_enabled ||
810 811 812 813 814
          !vp9_segfeature_active(xd, seg_id, SEG_LVL_REF_FRAME) ||
          vp9_check_segref(xd, seg_id, INTRA_FRAME)  +
          vp9_check_segref(xd, seg_id, LAST_FRAME)   +
          vp9_check_segref(xd, seg_id, GOLDEN_FRAME) +
          vp9_check_segref(xd, seg_id, ALTREF_FRAME) > 1) {
John Koleszar's avatar
John Koleszar committed
815
        // Get the prediction context and status
Paul Wilkins's avatar
Paul Wilkins committed
816 817
        int pred_flag = vp9_get_pred_flag(xd, PRED_REF);
        int pred_context = vp9_get_pred_context(cm, xd, PRED_REF);
John Koleszar's avatar
John Koleszar committed
818 819 820 821 822 823 824 825

        // Count prediction success
        cpi->ref_pred_count[pred_context][pred_flag]++;
      }
    }
  }

  /* Restore L & A coding context to those in place on entry */
826
  vpx_memcpy(cm->left_context + (mb_row0 & 2),
John Koleszar's avatar
John Koleszar committed
827 828 829 830 831
             left_context,
             sizeof(left_context));
  vpx_memcpy(initial_above_context_ptr,
             above_context,
             sizeof(above_context));
832 833

  return splitmodes_used;
Adrian Grange's avatar
Adrian Grange committed
834 835
}

Ronald S. Bultje's avatar
Ronald S. Bultje committed
836 837 838 839 840 841
static void pick_sb_modes(VP9_COMP *cpi,
                          int mb_row,
                          int mb_col,
                          TOKENEXTRA **tp,
                          int *totalrate,
                          int *totaldist) {
842 843 844
  VP9_COMMON *const cm = &cpi->common;
  MACROBLOCK *const x = &cpi->mb;
  MACROBLOCKD *const xd = &x->e_mbd;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
845

846
  set_offsets(cpi, mb_row, mb_col, 32);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
847 848
  xd->mode_info_context->mbmi.sb_type = BLOCK_SIZE_SB32X32;
  if (cpi->oxcf.tuning == VP8_TUNE_SSIM)
849
    vp9_activity_masking(cpi, x);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
850 851 852

  /* Find best coding mode & reconstruct the MB so it is available
   * as a predictor for MBs that follow in the SB */
Ronald S. Bultje's avatar
Ronald S. Bultje committed
853 854 855 856
  if (cm->frame_type == KEY_FRAME) {
    vp9_rd_pick_intra_mode_sb32(cpi, x,
                                totalrate,
                                totaldist);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
857 858

    /* Save the coding context */
Ronald S. Bultje's avatar
Ronald S. Bultje committed
859
    vpx_memcpy(&x->sb32_context[xd->sb_index].mic, xd->mode_info_context,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
860
               sizeof(MODE_INFO));
861
  } else {
862
    vp9_rd_pick_inter_mode_sb32(cpi, x, mb_row, mb_col, totalrate, totaldist);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
863 864 865
  }
}

Ronald S. Bultje's avatar
Ronald S. Bultje committed
866 867 868 869 870 871
static void pick_sb64_modes(VP9_COMP *cpi,
                            int mb_row,
                            int mb_col,
                            TOKENEXTRA **tp,
                            int *totalrate,
                            int *totaldist) {
872 873 874
  VP9_COMMON *const cm = &cpi->common;
  MACROBLOCK *const x = &cpi->mb;
  MACROBLOCKD *const xd = &x->e_mbd;
John Koleszar's avatar
John Koleszar committed
875

876
  set_offsets(cpi, mb_row, mb_col, 64);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
877 878 879
  xd->mode_info_context->mbmi.sb_type = BLOCK_SIZE_SB64X64;
  if (cpi->oxcf.tuning == VP8_TUNE_SSIM)
    vp9_activity_masking(cpi, x);
John Koleszar's avatar
John Koleszar committed
880

Ronald S. Bultje's avatar
Ronald S. Bultje committed
881 882 883 884 885 886
  /* Find best coding mode & reconstruct the MB so it is available
   * as a predictor for MBs that follow in the SB */
  if (cm->frame_type == KEY_FRAME) {
    vp9_rd_pick_intra_mode_sb64(cpi, x,
                                totalrate,
                                totaldist);
Adrian Grange's avatar
Adrian Grange committed
887

Ronald S. Bultje's avatar
Ronald S. Bultje committed
888 889 890 891
    /* Save the coding context */
    vpx_memcpy(&x->sb64_context.mic, xd->mode_info_context,
               sizeof(MODE_INFO));
  } else {
892
    vp9_rd_pick_inter_mode_sb64(cpi, x, mb_row, mb_col, totalrate, totaldist);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
893 894
  }
}
Adrian Grange's avatar
Adrian Grange committed
895

Ronald S. Bultje's avatar
Ronald S. Bultje committed
896 897 898 899 900 901
static void update_stats(VP9_COMP *cpi) {
  VP9_COMMON *const cm = &cpi->common;
  MACROBLOCK *const x = &cpi->mb;
  MACROBLOCKD *const xd = &x->e_mbd;
  MODE_INFO *mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
Adrian Grange's avatar
Adrian Grange committed
902

Ronald S. Bultje's avatar
Ronald S. Bultje committed
903 904 905
  if (cm->frame_type == KEY_FRAME) {
#ifdef MODE_STATS
    y_modes[mbmi->mode]++;
Adrian Grange's avatar
Adrian Grange committed
906
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
907 908
  } else {
    int segment_id, seg_ref_active;
John Koleszar's avatar
John Koleszar committed
909

Ronald S. Bultje's avatar
Ronald S. Bultje committed
910 911
    if (mbmi->ref_frame) {
      int pred_context = vp9_get_pred_context(cm, xd, PRED_COMP);
912

Ronald S. Bultje's avatar
Ronald S. Bultje committed
913 914 915 916
      if (mbmi->second_ref_frame <= INTRA_FRAME)
        cpi->single_pred_count[pred_context]++;
      else
        cpi->comp_pred_count[pred_context]++;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
917
    }
Adrian Grange's avatar
Adrian Grange committed