vp9_decodemv.c 25.8 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 <assert.h>

13 14
#include "vp9/common/vp9_common.h"
#include "vp9/common/vp9_entropy.h"
15
#include "vp9/common/vp9_entropymode.h"
16
#include "vp9/common/vp9_entropymv.h"
17
#include "vp9/common/vp9_findnearmv.h"
18
#include "vp9/common/vp9_mvref_common.h"
19
#include "vp9/common/vp9_pred_common.h"
20 21 22
#include "vp9/common/vp9_reconinter.h"
#include "vp9/common/vp9_seg_common.h"

23
#include "vp9/decoder/vp9_decodemv.h"
24
#include "vp9/decoder/vp9_decodframe.h"
25
#include "vp9/decoder/vp9_onyxd_int.h"
26
#include "vp9/decoder/vp9_dsubexp.h"
27 28
#include "vp9/decoder/vp9_treereader.h"

John Koleszar's avatar
John Koleszar committed
29
// #define DEBUG_DEC_MV
30 31 32
#ifdef DEBUG_DEC_MV
int dec_mvcount = 0;
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
33

34 35 36 37
// #define DEC_DEBUG
#ifdef DEC_DEBUG
extern int dec_debug;
#endif
38

39
static MB_PREDICTION_MODE read_intra_mode(vp9_reader *r, const vp9_prob *p) {
40 41 42 43 44
  return (MB_PREDICTION_MODE)treed_read(r, vp9_intra_mode_tree, p);
}

static MB_PREDICTION_MODE read_inter_mode(vp9_reader *r, const vp9_prob *p) {
  return (MB_PREDICTION_MODE)treed_read(r, vp9_sb_mv_ref_tree, p);
45 46
}

47 48
static int read_segment_id(vp9_reader *r, const struct segmentation *seg) {
  return treed_read(r, vp9_segment_tree, seg->tree_probs);
Scott LaVarnway's avatar
Scott LaVarnway committed
49
}
50

51 52
static TX_SIZE read_selected_txfm_size(VP9_COMMON *cm, MACROBLOCKD *xd,
                                       BLOCK_SIZE_TYPE bsize, vp9_reader *r) {
53 54
  const int context = vp9_get_pred_context_tx_size(cm, xd);
  const vp9_prob *tx_probs = vp9_get_pred_probs_tx_size(cm, xd);
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
  TX_SIZE txfm_size = vp9_read(r, tx_probs[0]);
  if (txfm_size != TX_4X4 && bsize >= BLOCK_SIZE_MB16X16) {
    txfm_size += vp9_read(r, tx_probs[1]);
    if (txfm_size != TX_8X8 && bsize >= BLOCK_SIZE_SB32X32)
      txfm_size += vp9_read(r, tx_probs[2]);
  }

  if (bsize >= BLOCK_SIZE_SB32X32)
    cm->fc.tx_count_32x32p[context][txfm_size]++;
  else if (bsize >= BLOCK_SIZE_MB16X16)
    cm->fc.tx_count_16x16p[context][txfm_size]++;
  else
    cm->fc.tx_count_8x8p[context][txfm_size]++;

  return txfm_size;
}

72 73 74
static TX_SIZE read_txfm_size(VP9D_COMP *pbi, TXFM_MODE txfm_mode,
                              BLOCK_SIZE_TYPE bsize, int select_cond,
                              vp9_reader *r) {
75 76 77 78
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;

  if (txfm_mode == TX_MODE_SELECT && bsize >= BLOCK_SIZE_SB8X8 && select_cond)
79
    return read_selected_txfm_size(cm, xd, bsize, r);
80 81 82 83 84 85 86 87 88 89
  else if (txfm_mode >= ALLOW_32X32 && bsize >= BLOCK_SIZE_SB32X32)
    return TX_32X32;
  else if (txfm_mode >= ALLOW_16X16 && bsize >= BLOCK_SIZE_MB16X16)
    return TX_16X16;
  else if (txfm_mode >= ALLOW_8X8 && bsize >= BLOCK_SIZE_SB8X8)
    return TX_8X8;
  else
    return TX_4X4;
}

90
static void set_segment_id(VP9_COMMON *cm, BLOCK_SIZE_TYPE bsize,
91
                           int mi_row, int mi_col, int segment_id) {
92 93 94
  const int mi_offset = mi_row * cm->mi_cols + mi_col;
  const int bw = 1 << mi_width_log2(bsize);
  const int bh = 1 << mi_height_log2(bsize);
95
  const int xmis = MIN(cm->mi_cols - mi_col, bw);
96
  const int ymis = MIN(cm->mi_rows - mi_row, bh);
97 98
  int x, y;

99 100 101 102 103 104 105 106 107 108
  assert(segment_id >= 0 && segment_id < MAX_MB_SEGMENTS);

  for (y = 0; y < ymis; y++)
    for (x = 0; x < xmis; x++)
      cm->last_frame_seg_map[mi_offset + y * cm->mi_cols + x] = segment_id;
}

static int read_intra_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
                                 vp9_reader *r) {
  MACROBLOCKD *const xd = &pbi->mb;
109
  struct segmentation *const seg = &xd->seg;
110 111
  const BLOCK_SIZE_TYPE bsize = xd->mode_info_context->mbmi.sb_type;

112 113 114
  if (seg->enabled && seg->update_map) {
    const int segment_id = read_segment_id(r, seg);
    set_segment_id(&pbi->common, bsize, mi_row, mi_col, segment_id);
115 116 117
    return segment_id;
  } else {
    return 0;
118 119 120
  }
}

121
static uint8_t read_skip_coeff(VP9D_COMP *pbi, int segment_id, vp9_reader *r) {
122
  VP9_COMMON *const cm = &pbi->common;
123
  MACROBLOCKD *const xd = &pbi->mb;
124
  int skip_coeff = vp9_segfeature_active(&xd->seg, segment_id, SEG_LVL_SKIP);
125
  if (!skip_coeff) {
126
    const int ctx = vp9_get_pred_context_mbskip(xd);
127
    skip_coeff = vp9_read(r, vp9_get_pred_prob_mbskip(cm, xd));
128
    cm->fc.mbskip_count[ctx][skip_coeff]++;
Deb Mukherjee's avatar
Deb Mukherjee committed
129
  }
130 131
  return skip_coeff;
}
John Koleszar's avatar
John Koleszar committed
132

133 134 135 136 137 138 139
static void read_intra_mode_info(VP9D_COMP *pbi, MODE_INFO *m,
                                 int mi_row, int mi_col, vp9_reader *r) {
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
  MB_MODE_INFO *const mbmi = &m->mbmi;
  const BLOCK_SIZE_TYPE bsize = mbmi->sb_type;
  const int mis = cm->mode_info_stride;
140

141 142
  mbmi->segment_id = read_intra_segment_id(pbi, mi_row, mi_col, r);
  mbmi->mb_skip_coeff = read_skip_coeff(pbi, mbmi->segment_id, r);
143
  mbmi->txfm_size = read_txfm_size(pbi, cm->txfm_mode, bsize, 1, r);
144 145 146
  mbmi->ref_frame[0] = INTRA_FRAME;

  if (bsize >= BLOCK_SIZE_SB8X8) {
147 148 149
    const MB_PREDICTION_MODE A = above_block_mode(m, 0, mis);
    const MB_PREDICTION_MODE L = xd->left_available ?
                                  left_block_mode(m, 0) : DC_PRED;
150
    mbmi->mode = read_intra_mode(r, cm->kf_y_mode_prob[A][L]);
151
  } else {
152 153 154
    // Only 4x4, 4x8, 8x4 blocks
    const int bw = 1 << b_width_log2(bsize);
    const int bh = 1 << b_height_log2(bsize);
155
    int idx, idy;
156 157 158

    for (idy = 0; idy < 2; idy += bh) {
      for (idx = 0; idx < 2; idx += bw) {
159
        const int ib = idy * 2 + idx;
160 161 162
        const MB_PREDICTION_MODE A = above_block_mode(m, ib, mis);
        const MB_PREDICTION_MODE L = (xd->left_available || idx) ?
                                      left_block_mode(m, ib) : DC_PRED;
163 164
        const MB_PREDICTION_MODE b_mode = read_intra_mode(r,
                                              cm->kf_y_mode_prob[A][L]);
165
        m->bmi[ib].as_mode = b_mode;
166
        if (bh == 2)
167
          m->bmi[ib + 2].as_mode = b_mode;
168
        if (bw == 2)
169
          m->bmi[ib + 1].as_mode = b_mode;
170 171
      }
    }
172

173
    mbmi->mode = m->bmi[3].as_mode;
John Koleszar's avatar
John Koleszar committed
174
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
175

176
  mbmi->uv_mode = read_intra_mode(r, cm->kf_uv_mode_prob[mbmi->mode]);
Scott LaVarnway's avatar
Scott LaVarnway committed
177
}
John Koleszar's avatar
John Koleszar committed
178

179 180
static int read_mv_component(vp9_reader *r,
                             const nmv_component *mvcomp, int usehp) {
181

182
  int mag, d, fr, hp;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
183 184
  const int sign = vp9_read(r, mvcomp->sign);
  const int mv_class = treed_read(r, vp9_mv_class_tree, mvcomp->classes);
185
  const int class0 = mv_class == MV_CLASS_0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
186

187
  // Integer part
188
  if (class0) {
189
    d = treed_read(r, vp9_mv_class0_tree, mvcomp->class0);
190
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
191
    int i;
192
    const int n = mv_class + CLASS0_BITS - 1;  // number of bits
Dmitry Kovalev's avatar
Dmitry Kovalev committed
193

194
    d = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
195 196
    for (i = 0; i < n; ++i)
      d |= vp9_read(r, mvcomp->bits[i]) << i;
197 198
  }

199 200
  // Fractional part
  fr = treed_read(r, vp9_mv_fp_tree,
201
                  class0 ? mvcomp->class0_fp[d] : mvcomp->fp);
202 203


204
  // High precision part (if hp is not used, the default value of the hp is 1)
205
  hp = usehp ? vp9_read(r, class0 ? mvcomp->class0_hp : mvcomp->hp)
206
             : 1;
207

208
  // Result
209 210
  mag = vp9_get_mv_mag(mv_class, (d << 3) | (fr << 1) | hp) + 1;
  return sign ? -mag : mag;
211 212
}

213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
static INLINE void read_mv(vp9_reader *r, MV *mv, const MV *ref,
                           const nmv_context *ctx,
                           nmv_context_counts *counts, int usehp) {
  const MV_JOINT_TYPE j = treed_read(r, vp9_mv_joint_tree, ctx->joints);
  MV diff = {0, 0};

  usehp = usehp && vp9_use_mv_hp(ref);
  if (mv_joint_vertical(j))
    diff.row = read_mv_component(r, &ctx->comps[0], usehp);

  if (mv_joint_horizontal(j))
    diff.col = read_mv_component(r, &ctx->comps[1], usehp);

  vp9_inc_mv(&diff, ref, counts, usehp);

  mv->row = ref->row + diff.row;
  mv->col = ref->col + diff.col;
}

232
static void update_mv(vp9_reader *r, vp9_prob *p, vp9_prob upd_p) {
233
  if (vp9_read(r, upd_p)) {
234
#ifdef LOW_PRECISION_MV_UPDATE
235
    *p = (vp9_read_literal(r, 7) << 1) | 1;
236
#else
237
    *p = vp9_read_literal(r, 8);
238 239 240 241
#endif
  }
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
242
static void read_mv_probs(vp9_reader *r, nmv_context *mvc, int usehp) {
243
  int i, j, k;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
244

245
#ifdef MV_GROUP_UPDATE
246
  if (!vp9_read_bit(r))
Dmitry Kovalev's avatar
Dmitry Kovalev committed
247
    return;
248
#endif
249

Dmitry Kovalev's avatar
Dmitry Kovalev committed
250
  for (j = 0; j < MV_JOINTS - 1; ++j)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
251
    update_mv(r, &mvc->joints[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
252

253
  for (i = 0; i < 2; ++i) {
254 255 256
    nmv_component *const comp = &mvc->comps[i];

    update_mv(r, &comp->sign, VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
257
    for (j = 0; j < MV_CLASSES - 1; ++j)
258
      update_mv(r, &comp->classes[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
259 260

    for (j = 0; j < CLASS0_SIZE - 1; ++j)
261
      update_mv(r, &comp->class0[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
262 263

    for (j = 0; j < MV_OFFSET_BITS; ++j)
264
      update_mv(r, &comp->bits[j], VP9_NMV_UPDATE_PROB);
265 266 267
  }

  for (i = 0; i < 2; ++i) {
268 269
    nmv_component *const comp = &mvc->comps[i];

270
    for (j = 0; j < CLASS0_SIZE; ++j)
271
      for (k = 0; k < 3; ++k)
272
        update_mv(r, &comp->class0_fp[j][k], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
273 274

    for (j = 0; j < 3; ++j)
275
      update_mv(r, &comp->fp[j], VP9_NMV_UPDATE_PROB);
276 277 278 279
  }

  if (usehp) {
    for (i = 0; i < 2; ++i) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
280 281
      update_mv(r, &mvc->comps[i].class0_hp, VP9_NMV_UPDATE_PROB);
      update_mv(r, &mvc->comps[i].hp, VP9_NMV_UPDATE_PROB);
282 283 284 285
    }
  }
}

286
// Read the referncence frame
Ronald S. Bultje's avatar
Ronald S. Bultje committed
287 288
static void read_ref_frame(VP9D_COMP *pbi, vp9_reader *r,
                           int segment_id, MV_REFERENCE_FRAME ref_frame[2]) {
289
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
290
  MACROBLOCKD *const xd = &pbi->mb;
291
  FRAME_CONTEXT *const fc = &cm->fc;
292

293 294
  if (vp9_segfeature_active(&xd->seg, segment_id, SEG_LVL_REF_FRAME)) {
    ref_frame[0] = vp9_get_segdata(&xd->seg, segment_id, SEG_LVL_REF_FRAME);
295 296
    ref_frame[1] = NONE;
  } else {
297
    const int comp_ctx = vp9_get_pred_context_comp_inter_inter(cm, xd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
298
    int is_comp;
John Koleszar's avatar
John Koleszar committed
299

Ronald S. Bultje's avatar
Ronald S. Bultje committed
300
    if (cm->comp_pred_mode == HYBRID_PREDICTION) {
301 302
      is_comp = vp9_read(r, fc->comp_inter_prob[comp_ctx]);
      fc->comp_inter_count[comp_ctx][is_comp]++;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
303 304 305
    } else {
      is_comp = cm->comp_pred_mode == COMP_PREDICTION_ONLY;
    }
John Koleszar's avatar
John Koleszar committed
306

Ronald S. Bultje's avatar
Ronald S. Bultje committed
307 308
    // FIXME(rbultje) I'm pretty sure this breaks segmentation ref frame coding
    if (is_comp) {
309
      const int fix_ref_idx = cm->ref_frame_sign_bias[cm->comp_fixed_ref];
310
      const int ref_ctx = vp9_get_pred_context_comp_ref_p(cm, xd);
311 312 313
      const int b = vp9_read(r, fc->comp_ref_prob[ref_ctx]);
      fc->comp_ref_count[ref_ctx][b]++;
      ref_frame[fix_ref_idx] = cm->comp_fixed_ref;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
314
      ref_frame[!fix_ref_idx] = cm->comp_var_ref[b];
Dmitry Kovalev's avatar
Dmitry Kovalev committed
315
    } else {
316
      const int ref1_ctx = vp9_get_pred_context_single_ref_p1(cm, xd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
317
      ref_frame[1] = NONE;
318
      if (vp9_read(r, fc->single_ref_prob[ref1_ctx][0])) {
319
        const int ref2_ctx = vp9_get_pred_context_single_ref_p2(cm, xd);
320 321 322 323
        const int b = vp9_read(r, fc->single_ref_prob[ref2_ctx][1]);
        ref_frame[0] = b ? ALTREF_FRAME : GOLDEN_FRAME;
        fc->single_ref_count[ref1_ctx][0][1]++;
        fc->single_ref_count[ref2_ctx][1][b]++;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
324 325
      } else {
        ref_frame[0] = LAST_FRAME;
326
        fc->single_ref_count[ref1_ctx][0][0]++;
John Koleszar's avatar
John Koleszar committed
327
      }
328
    }
John Koleszar's avatar
John Koleszar committed
329
  }
330
}
John Koleszar's avatar
John Koleszar committed
331

332
static void read_switchable_interp_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
333
  int i, j;
334 335 336
  for (j = 0; j < VP9_SWITCHABLE_FILTERS + 1; ++j)
    for (i = 0; i < VP9_SWITCHABLE_FILTERS - 1; ++i)
      if (vp9_read(r, VP9_MODE_UPDATE_PROB))
337
        vp9_diff_update_prob(r, &fc->switchable_interp_prob[j][i]);
338 339
}

340
static void read_inter_mode_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
341 342
  int i, j;
  for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
343 344
    for (j = 0; j < VP9_INTER_MODES - 1; ++j)
      if (vp9_read(r, VP9_MODE_UPDATE_PROB))
345
        vp9_diff_update_prob(r, &fc->inter_mode_probs[i][j]);
346
}
John Koleszar's avatar
John Koleszar committed
347

348 349 350
static INLINE COMPPREDMODE_TYPE read_comp_pred_mode(vp9_reader *r) {
  COMPPREDMODE_TYPE mode = vp9_read_bit(r);
  if (mode)
351
    mode += vp9_read_bit(r);
352 353 354
  return mode;
}

355 356
static int read_inter_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
                                 vp9_reader *r) {
357
  VP9_COMMON *const cm = &pbi->common;
358
  MACROBLOCKD *const xd = &pbi->mb;
359
  struct segmentation *const seg = &xd->seg;
360
  const BLOCK_SIZE_TYPE bsize = xd->mode_info_context->mbmi.sb_type;
361
  int pred_segment_id;
362
  int segment_id;
John Koleszar's avatar
John Koleszar committed
363

364
  if (!seg->enabled)
365 366
    return 0;  // Default for disabled segmentation

367
  pred_segment_id = vp9_get_segment_id(cm, cm->last_frame_seg_map,
368 369
                                       bsize, mi_row, mi_col);
  if (!seg->update_map)
370
    return pred_segment_id;
371

372
  if (seg->temporal_update) {
373
    const vp9_prob pred_prob = vp9_get_pred_prob_seg_id(xd);
374
    const int pred_flag = vp9_read(r, pred_prob);
375
    vp9_set_pred_flag_seg_id(xd, bsize, pred_flag);
376
    segment_id = pred_flag ? pred_segment_id
377
                           : read_segment_id(r, seg);
John Koleszar's avatar
John Koleszar committed
378
  } else {
379
    segment_id = read_segment_id(r, seg);
John Koleszar's avatar
John Koleszar committed
380
  }
381 382
  set_segment_id(cm, bsize, mi_row, mi_col, segment_id);
  return segment_id;
383
}
384

Dmitry Kovalev's avatar
Dmitry Kovalev committed
385 386 387 388 389 390 391 392 393 394 395

static INLINE void assign_and_clamp_mv(int_mv *dst, const int_mv *src,
                                       int mb_to_left_edge,
                                       int mb_to_right_edge,
                                       int mb_to_top_edge,
                                       int mb_to_bottom_edge) {
  dst->as_int = src->as_int;
  clamp_mv(dst, mb_to_left_edge, mb_to_right_edge, mb_to_top_edge,
           mb_to_bottom_edge);
}

396
static INLINE INTERPOLATIONFILTERTYPE read_switchable_filter_type(
397
    VP9D_COMP *pbi, vp9_reader *r) {
398 399
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
400
  const vp9_prob *probs = vp9_get_pred_probs_switchable_interp(cm, xd);
401
  const int index = treed_read(r, vp9_switchable_interp_tree, probs);
402
  const int ctx = vp9_get_pred_context_switchable_interp(cm, xd);
403
  ++cm->fc.switchable_interp_count[ctx][index];
404 405 406
  return vp9_switchable_interp[index];
}

407
static void read_intra_block_modes(VP9D_COMP *pbi, MODE_INFO *mi,
408
                                   vp9_reader *r) {
409
  VP9_COMMON *const cm = &pbi->common;
410
  MB_MODE_INFO *const mbmi = &mi->mbmi;
411
  const BLOCK_SIZE_TYPE bsize = mi->mbmi.sb_type;
412
  const int bwl = b_width_log2(bsize), bhl = b_height_log2(bsize);
413 414

  if (bsize >= BLOCK_SIZE_SB8X8) {
415 416 417
    const int size_group = MIN(3, MIN(bwl, bhl));
    mbmi->mode = read_intra_mode(r, cm->fc.y_mode_prob[size_group]);
    cm->fc.y_mode_counts[size_group][mbmi->mode]++;
418
  } else {
419 420
     // Only 4x4, 4x8, 8x4 blocks
     const int bw = 1 << bwl, bh = 1 << bhl;
421
     int idx, idy;
422

423 424
     for (idy = 0; idy < 2; idy += bh) {
       for (idx = 0; idx < 2; idx += bw) {
425 426
         const int ib = idy * 2 + idx;
         const int b_mode = read_intra_mode(r, cm->fc.y_mode_prob[0]);
427
         mi->bmi[ib].as_mode = b_mode;
428 429 430
         cm->fc.y_mode_counts[0][b_mode]++;

         if (bh == 2)
431
           mi->bmi[ib + 2].as_mode = b_mode;
432
         if (bw == 2)
433
           mi->bmi[ib + 1].as_mode = b_mode;
434 435
      }
    }
436
    mbmi->mode = mi->bmi[3].as_mode;
437 438 439 440 441 442 443 444 445 446 447 448
  }

  mbmi->uv_mode = read_intra_mode(r, cm->fc.uv_mode_prob[mbmi->mode]);
  cm->fc.uv_mode_counts[mbmi->mode][mbmi->uv_mode]++;
}

static MV_REFERENCE_FRAME read_reference_frame(VP9D_COMP *pbi, int segment_id,
                                               vp9_reader *r) {
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;

  MV_REFERENCE_FRAME ref;
449
  if (!vp9_segfeature_active(&xd->seg, segment_id, SEG_LVL_REF_FRAME)) {
450
    const int ctx = vp9_get_pred_context_intra_inter(cm, xd);
451
    ref = (MV_REFERENCE_FRAME)
452
              vp9_read(r, vp9_get_pred_prob_intra_inter(cm, xd));
453 454
    cm->fc.intra_inter_count[ctx][ref != INTRA_FRAME]++;
  } else {
455 456
    ref = (MV_REFERENCE_FRAME) vp9_get_segdata(&xd->seg, segment_id,
                                   SEG_LVL_REF_FRAME) != INTRA_FRAME;
457 458 459 460
  }
  return ref;
}

461 462
static void read_inter_mode_info(VP9D_COMP *pbi, MODE_INFO *mi,
                                 int mi_row, int mi_col, vp9_reader *r) {
463
  VP9_COMMON *const cm = &pbi->common;
464
  MACROBLOCKD *const xd = &pbi->mb;
465
  nmv_context *const nmvc = &cm->fc.nmvc;
466
  MB_MODE_INFO *const mbmi = &mi->mbmi;
John Koleszar's avatar
John Koleszar committed
467

468 469
  int_mv *const mv0 = &mbmi->mv[0];
  int_mv *const mv1 = &mbmi->mv[1];
470 471 472
  const BLOCK_SIZE_TYPE bsize = mi->mbmi.sb_type;
  const int bw = 1 << b_width_log2(bsize);
  const int bh = 1 << b_height_log2(bsize);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
473

474
  int idx, idy;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
475 476 477 478

  // Distance of Mb to the various image edges.
  // These specified to 8th pel as they are always compared to MV values
  // that are in 1/8th pel units
479 480
  set_mi_row_col(cm, xd, mi_row, 1 << mi_height_log2(bsize),
                         mi_col, 1 << mi_width_log2(bsize));
481

482
  mbmi->segment_id = read_inter_segment_id(pbi, mi_row, mi_col, r);
483
  mbmi->mb_skip_coeff = read_skip_coeff(pbi, mbmi->segment_id, r);
484
  mbmi->ref_frame[0] = read_reference_frame(pbi, mbmi->segment_id, r);
485 486 487
  mbmi->ref_frame[1] = NONE;
  mbmi->txfm_size = read_txfm_size(pbi, cm->txfm_mode, bsize,
     (!mbmi->mb_skip_coeff || mbmi->ref_frame[0] == INTRA_FRAME), r);
488

Ronald S. Bultje's avatar
Ronald S. Bultje committed
489
  if (mbmi->ref_frame[0] != INTRA_FRAME) {
John Koleszar's avatar
John Koleszar committed
490 491
    int_mv nearest, nearby, best_mv;
    int_mv nearest_second, nearby_second, best_mv_second;
492
    vp9_prob *mv_ref_p;
493
    MV_REFERENCE_FRAME ref0, ref1;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
494 495

    read_ref_frame(pbi, r, mbmi->segment_id, mbmi->ref_frame);
496 497
    ref0 = mbmi->ref_frame[0];
    ref1 = mbmi->ref_frame[1];
498

499
#ifdef DEC_DEBUG
500 501 502
    if (dec_debug)
      printf("%d %d\n", xd->mode_info_context->mbmi.mv[0].as_mv.row,
             xd->mode_info_context->mbmi.mv[0].as_mv.col);
503
#endif
504 505
    vp9_find_mv_refs(cm, xd, mi, xd->prev_mode_info_context,
                     ref0, mbmi->ref_mvs[ref0], cm->ref_frame_sign_bias);
506

507
    mv_ref_p = cm->fc.inter_mode_probs[mbmi->mb_mode_context[ref0]];
508

509
    if (vp9_segfeature_active(&xd->seg, mbmi->segment_id, SEG_LVL_SKIP)) {
510 511 512 513 514 515 516 517 518 519 520 521
      mbmi->mode = ZEROMV;
    } else if (bsize >= BLOCK_SIZE_SB8X8) {
      mbmi->mode = read_inter_mode(r, mv_ref_p);
      vp9_accum_mv_refs(cm, mbmi->mode, mbmi->mb_mode_context[ref0]);
    }
    mbmi->uv_mode = DC_PRED;

    // nearest, nearby
    if (bsize < BLOCK_SIZE_SB8X8 || mbmi->mode != ZEROMV) {
      vp9_find_best_ref_mvs(xd, mbmi->ref_mvs[ref0], &nearest, &nearby);
      best_mv.as_int = mbmi->ref_mvs[ref0][0].as_int;
    }
522

523
#ifdef DEC_DEBUG
524 525 526 527
    if (dec_debug)
      printf("[D %d %d] %d %d %d %d\n", ref_frame,
             mbmi->mb_mode_context[ref_frame],
             mv_ref_p[0], mv_ref_p[1], mv_ref_p[2], mv_ref_p[3]);
528
#endif
John Koleszar's avatar
John Koleszar committed
529

530 531 532
    mbmi->interp_filter = cm->mcomp_filter_type == SWITCHABLE
                              ? read_switchable_filter_type(pbi, r)
                              : cm->mcomp_filter_type;
533

534
    if (ref1 > INTRA_FRAME) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
535
      vp9_find_mv_refs(cm, xd, mi, xd->prev_mode_info_context,
536
                       ref1, mbmi->ref_mvs[ref1], cm->ref_frame_sign_bias);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
537 538

      if (bsize < BLOCK_SIZE_SB8X8 || mbmi->mode != ZEROMV) {
539 540 541
        vp9_find_best_ref_mvs(xd, mbmi->ref_mvs[ref1],
                              &nearest_second, &nearby_second);
        best_mv_second.as_int = mbmi->ref_mvs[ref1][0].as_int;
542
      }
John Koleszar's avatar
John Koleszar committed
543
    }
544

545

Ronald S. Bultje's avatar
Ronald S. Bultje committed
546 547 548 549
    if (mbmi->sb_type < BLOCK_SIZE_SB8X8) {
      for (idy = 0; idy < 2; idy += bh) {
        for (idx = 0; idx < 2; idx += bw) {
          int_mv blockmv, secondmv;
550
          const int j = idy * 2 + idx;
551
          const int blockmode = read_inter_mode(r, mv_ref_p);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
552

553
          vp9_accum_mv_refs(cm, blockmode, mbmi->mb_mode_context[ref0]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
554 555
          if (blockmode == NEARESTMV || blockmode == NEARMV) {
            vp9_append_sub8x8_mvs_for_idx(cm, xd, &nearest, &nearby, j, 0);
556
            if (ref1 > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
557 558 559
              vp9_append_sub8x8_mvs_for_idx(cm, xd,  &nearest_second,
                                            &nearby_second, j, 1);
          }
560

Ronald S. Bultje's avatar
Ronald S. Bultje committed
561 562
          switch (blockmode) {
            case NEWMV:
563 564
              read_mv(r, &blockmv.as_mv, &best_mv.as_mv, nmvc,
                      &cm->fc.NMVcount, xd->allow_high_precision_mv);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
565

566
              if (ref1 > 0)
567 568
                read_mv(r, &secondmv.as_mv, &best_mv_second.as_mv, nmvc,
                        &cm->fc.NMVcount, xd->allow_high_precision_mv);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
569 570 571
              break;
            case NEARESTMV:
              blockmv.as_int = nearest.as_int;
572
              if (ref1 > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
573 574 575 576
                secondmv.as_int = nearest_second.as_int;
              break;
            case NEARMV:
              blockmv.as_int = nearby.as_int;
577
              if (ref1 > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
578 579 580 581
                secondmv.as_int = nearby_second.as_int;
              break;
            case ZEROMV:
              blockmv.as_int = 0;
582
              if (ref1 > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
583 584 585
                secondmv.as_int = 0;
              break;
            default:
586
              assert(!"Invalid inter mode value");
John Koleszar's avatar
John Koleszar committed
587
          }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
588
          mi->bmi[j].as_mv[0].as_int = blockmv.as_int;
589
          if (ref1 > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
590 591
            mi->bmi[j].as_mv[1].as_int = secondmv.as_int;

592 593 594 595
          if (bh == 2)
            vpx_memcpy(&mi->bmi[j + 2], &mi->bmi[j], sizeof(mi->bmi[j]));
          if (bw == 2)
            vpx_memcpy(&mi->bmi[j + 1], &mi->bmi[j], sizeof(mi->bmi[j]));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
596
          mi->mbmi.mode = blockmode;
597
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
598
      }
John Koleszar's avatar
John Koleszar committed
599

Ronald S. Bultje's avatar
Ronald S. Bultje committed
600 601 602
      mv0->as_int = mi->bmi[3].as_mv[0].as_int;
      mv1->as_int = mi->bmi[3].as_mv[1].as_int;
    } else {
603 604 605 606 607
      const int mb_to_top_edge = xd->mb_to_top_edge - LEFT_TOP_MARGIN;
      const int mb_to_bottom_edge = xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN;
      const int mb_to_left_edge = xd->mb_to_left_edge - LEFT_TOP_MARGIN;
      const int mb_to_right_edge = xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN;

Ronald S. Bultje's avatar
Ronald S. Bultje committed
608 609 610 611 612 613 614
      switch (mbmi->mode) {
        case NEARMV:
          // Clip "next_nearest" so that it does not extend to far out of image
          assign_and_clamp_mv(mv0, &nearby, mb_to_left_edge,
                                            mb_to_right_edge,
                                            mb_to_top_edge,
                                            mb_to_bottom_edge);
615
          if (ref1 > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
616 617 618 619 620 621 622 623 624 625 626 627
            assign_and_clamp_mv(mv1, &nearby_second, mb_to_left_edge,
                                                     mb_to_right_edge,
                                                     mb_to_top_edge,
                                                     mb_to_bottom_edge);
          break;

        case NEARESTMV:
          // Clip "next_nearest" so that it does not extend to far out of image
          assign_and_clamp_mv(mv0, &nearest, mb_to_left_edge,
                                             mb_to_right_edge,
                                             mb_to_top_edge,
                                             mb_to_bottom_edge);
628
          if (ref1 > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
629 630 631 632 633 634 635 636
            assign_and_clamp_mv(mv1, &nearest_second, mb_to_left_edge,
                                                      mb_to_right_edge,
                                                      mb_to_top_edge,
                                                      mb_to_bottom_edge);
          break;

        case ZEROMV:
          mv0->as_int = 0;
637
          if (ref1 > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
638 639 640 641
            mv1->as_int = 0;
          break;

        case NEWMV:
642 643
          read_mv(r, &mv0->as_mv, &best_mv.as_mv, nmvc, &cm->fc.NMVcount,
                  xd->allow_high_precision_mv);
644
          if (ref1 > 0)
645 646
            read_mv(r, &mv1->as_mv, &best_mv_second.as_mv, nmvc,
                    &cm->fc.NMVcount, xd->allow_high_precision_mv);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
647 648
          break;
        default:
649
          assert(!"Invalid inter mode value");
Ronald S. Bultje's avatar
Ronald S. Bultje committed
650
      }
Scott LaVarnway's avatar
Scott LaVarnway committed
651
    }
John Koleszar's avatar
John Koleszar committed
652
  } else {
653
    mv0->as_int = 0;  // required for left and above block mv
654
    read_intra_block_modes(pbi, mi, r);
John Koleszar's avatar
John Koleszar committed
655
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
656
}
John Koleszar's avatar
John Koleszar committed
657

658 659
void vp9_prepare_read_mode_info(VP9D_COMP* pbi, vp9_reader *r) {
  VP9_COMMON *const cm = &pbi->common;
660
  int k;
661

662
  // TODO(jkoleszar): does this clear more than MBSKIP_CONTEXTS? Maybe remove.
Deb Mukherjee's avatar
Deb Mukherjee committed
663
  // vpx_memset(cm->fc.mbskip_probs, 0, sizeof(cm->fc.mbskip_probs));
664 665
  for (k = 0; k < MBSKIP_CONTEXTS; ++k)
    if (vp9_read(r, VP9_MODE_UPDATE_PROB))
666
      vp9_diff_update_prob(r, &cm->fc.mbskip_probs[k]);
667

668 669 670 671 672 673 674 675 676 677 678 679 680 681 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 712 713 714 715 716 717 718
  if (cm->frame_type != KEY_FRAME && !cm->intra_only) {
    nmv_context *const nmvc = &pbi->common.fc.nmvc;
    MACROBLOCKD *const xd = &pbi->mb;
    int i, j;

    read_inter_mode_probs(&cm->fc, r);

    if (cm->mcomp_filter_type == SWITCHABLE)
      read_switchable_interp_probs(&cm->fc, r);

    for (i = 0; i < INTRA_INTER_CONTEXTS; i++)
      if (vp9_read(r, VP9_MODE_UPDATE_PROB))
        vp9_diff_update_prob(r, &cm->fc.intra_inter_prob[i]);

    if (cm->allow_comp_inter_inter) {
      cm->comp_pred_mode = read_comp_pred_mode(r);
      if (cm->comp_pred_mode == HYBRID_PREDICTION)
        for (i = 0; i < COMP_INTER_CONTEXTS; i++)
          if (vp9_read(r, VP9_MODE_UPDATE_PROB))
            vp9_diff_update_prob(r, &cm->fc.comp_inter_prob[i]);
    } else {
      cm->comp_pred_mode = SINGLE_PREDICTION_ONLY;
    }

    if (cm->comp_pred_mode != COMP_PREDICTION_ONLY)
      for (i = 0; i < REF_CONTEXTS; i++) {
        if (vp9_read(r, VP9_MODE_UPDATE_PROB))
          vp9_diff_update_prob(r, &cm->fc.single_ref_prob[i][0]);

        if (vp9_read(r, VP9_MODE_UPDATE_PROB))
          vp9_diff_update_prob(r, &cm->fc.single_ref_prob[i][1]);
      }

    if (cm->comp_pred_mode != SINGLE_PREDICTION_ONLY)
      for (i = 0; i < REF_CONTEXTS; i++)
        if (vp9_read(r, VP9_MODE_UPDATE_PROB))
          vp9_diff_update_prob(r, &cm->fc.comp_ref_prob[i]);

    // VP9_INTRA_MODES
    for (j = 0; j < BLOCK_SIZE_GROUPS; j++)
      for (i = 0; i < VP9_INTRA_MODES - 1; ++i)
        if (vp9_read(r, VP9_MODE_UPDATE_PROB))
          vp9_diff_update_prob(r, &cm->fc.y_mode_prob[j][i]);

    for (j = 0; j < NUM_PARTITION_CONTEXTS; ++j)
      for (i = 0; i < PARTITION_TYPES - 1; ++i)
        if (vp9_read(r, VP9_MODE_UPDATE_PROB))
          vp9_diff_update_prob(r, &cm->fc.partition_prob[INTER_FRAME][j][i]);

    read_mv_probs(r, nmvc, xd->allow_high_precision_mv);
  }
719
}
720

721
void vp9_read_mode_info(VP9D_COMP* pbi, int mi_row, int mi_col, vp9_reader *r) {
722
  VP9_COMMON *const cm = &pbi->common;
723
  MACROBLOCKD *const xd = &pbi->mb;
724
  MODE_INFO *mi = xd->mode_info_context;
725
  const BLOCK_SIZE_TYPE bsize = mi->mbmi.sb_type;
Jim Bankoski's avatar
Jim Bankoski committed
726 727 728 729 730
  const int bw = 1 << mi_width_log2(bsize);
  const int bh = 1 << mi_height_log2(bsize);
  const int y_mis = MIN(bh, cm->mi_rows - mi_row);
  const int x_mis = MIN(bw, cm->mi_cols - mi_col);
  int x, y;
731

732 733 734 735
  if (cm->frame_type == KEY_FRAME || cm->intra_only)
    read_intra_mode_info(pbi, mi, mi_row, mi_col, r);
  else
    read_inter_mode_info(pbi, mi, mi_row, mi_col, r);
736

Jim Bankoski's avatar
Jim Bankoski committed
737 738 739
  for (y = 0; y < y_mis; y++)
    for (x = !y; x < x_mis; x++)
      mi[y * cm->mode_info_stride + x] = *mi;
740
}