vp9_decodemv.c 23.6 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"

29
static MB_PREDICTION_MODE read_intra_mode(vp9_reader *r, const vp9_prob *p) {
30 31 32
  return (MB_PREDICTION_MODE)treed_read(r, vp9_intra_mode_tree, p);
}

33 34 35 36
static MB_PREDICTION_MODE read_intra_mode_y(VP9_COMMON *cm, vp9_reader *r,
                                            int size_group) {
  const MB_PREDICTION_MODE y_mode = read_intra_mode(r,
                                        cm->fc.y_mode_prob[size_group]);
37 38
  if (!cm->frame_parallel_decoding_mode)
    ++cm->counts.y_mode[size_group][y_mode];
39 40 41 42 43 44 45
  return y_mode;
}

static MB_PREDICTION_MODE read_intra_mode_uv(VP9_COMMON *cm, vp9_reader *r,
                                             MB_PREDICTION_MODE y_mode) {
  const MB_PREDICTION_MODE uv_mode = read_intra_mode(r,
                                         cm->fc.uv_mode_prob[y_mode]);
46 47
  if (!cm->frame_parallel_decoding_mode)
    ++cm->counts.uv_mode[y_mode][uv_mode];
48 49 50
  return uv_mode;
}

51 52
static MB_PREDICTION_MODE read_inter_mode(VP9_COMMON *cm, vp9_reader *r,
                                          uint8_t context) {
53 54
  const MB_PREDICTION_MODE mode = treed_read(r, vp9_inter_mode_tree,
                                             cm->fc.inter_mode_probs[context]);
55 56
  if (!cm->frame_parallel_decoding_mode)
    ++cm->counts.inter_mode[context][inter_mode_offset(mode)];
57
  return mode;
58 59
}

60 61
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
62
}
63

64
static TX_SIZE read_selected_tx_size(VP9_COMMON *cm, MACROBLOCKD *xd,
65
                                     BLOCK_SIZE bsize, vp9_reader *r) {
66 67 68
  const uint8_t context = vp9_get_pred_context_tx_size(xd);
  const vp9_prob *tx_probs = get_tx_probs(bsize, context, &cm->fc.tx_probs);
  TX_SIZE tx_size = vp9_read(r, tx_probs[0]);
69
  if (tx_size != TX_4X4 && bsize >= BLOCK_16X16) {
70
    tx_size += vp9_read(r, tx_probs[1]);
71
    if (tx_size != TX_8X8 && bsize >= BLOCK_32X32)
72
      tx_size += vp9_read(r, tx_probs[2]);
73 74
  }

75 76
  if (!cm->frame_parallel_decoding_mode)
    update_tx_counts(bsize, context, tx_size, &cm->counts.tx);
77
  return tx_size;
78 79
}

80
static TX_SIZE read_tx_size(VP9D_COMP *pbi, TX_MODE tx_mode,
81
                            BLOCK_SIZE bsize, int allow_select,
82
                            vp9_reader *r) {
83 84
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
Yaowu Xu's avatar
Yaowu Xu committed
85
  if (allow_select && tx_mode == TX_MODE_SELECT && bsize >= BLOCK_8X8) {
86
    return read_selected_tx_size(cm, xd, bsize, r);
Yaowu Xu's avatar
Yaowu Xu committed
87 88 89 90 91
  } else {
    const TX_SIZE max_tx_size_block = max_txsize_lookup[bsize];
    const TX_SIZE max_tx_size_txmode = tx_mode_to_biggest_tx_size[tx_mode];
    return MIN(max_tx_size_block, max_tx_size_txmode);
  }
92 93
}

94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
static void set_segment_id(VP9_COMMON *cm, BLOCK_SIZE bsize,
                           int mi_row, int mi_col, int segment_id) {
  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);
  const int xmis = MIN(cm->mi_cols - mi_col, bw);
  const int ymis = MIN(cm->mi_rows - mi_row, bh);
  int x, y;

  assert(segment_id >= 0 && segment_id < MAX_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;
}

110 111
static int read_intra_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
                                 vp9_reader *r) {
112
  MACROBLOCKD *const xd = &pbi->mb;
113
  struct segmentation *const seg = &pbi->common.seg;
114
  const BLOCK_SIZE bsize = xd->mi_8x8[0]->mbmi.sb_type;
115
  int segment_id;
116

117 118 119 120
  if (!seg->enabled)
    return 0;  // Default for disabled segmentation

  if (!seg->update_map)
121
    return 0;
122

123 124 125
  segment_id = read_segment_id(r, seg);
  set_segment_id(&pbi->common, bsize, mi_row, mi_col, segment_id);
  return segment_id;
126 127 128 129 130 131
}

static int read_inter_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
                                 vp9_reader *r) {
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
132
  struct segmentation *const seg = &cm->seg;
133
  const BLOCK_SIZE bsize = xd->mi_8x8[0]->mbmi.sb_type;
134
  int pred_segment_id, segment_id;
135 136 137 138 139 140 141 142 143 144

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

  pred_segment_id = vp9_get_segment_id(cm, cm->last_frame_seg_map,
                                       bsize, mi_row, mi_col);
  if (!seg->update_map)
    return pred_segment_id;

  if (seg->temporal_update) {
145
    const vp9_prob pred_prob = vp9_get_pred_prob_seg_id(seg, xd);
146
    const int pred_flag = vp9_read(r, pred_prob);
147
    vp9_set_pred_flag_seg_id(xd, pred_flag);
148 149
    segment_id = pred_flag ? pred_segment_id
                           : read_segment_id(r, seg);
150
  } else {
151
    segment_id = read_segment_id(r, seg);
152
  }
153 154
  set_segment_id(cm, bsize, mi_row, mi_col, segment_id);
  return segment_id;
155 156
}

157
static uint8_t read_skip_coeff(VP9D_COMP *pbi, int segment_id, vp9_reader *r) {
158
  VP9_COMMON *const cm = &pbi->common;
159
  MACROBLOCKD *const xd = &pbi->mb;
160
  int skip_coeff = vp9_segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP);
161
  if (!skip_coeff) {
162
    const int ctx = vp9_get_pred_context_mbskip(xd);
163
    skip_coeff = vp9_read(r, vp9_get_pred_prob_mbskip(cm, xd));
164 165
    if (!cm->frame_parallel_decoding_mode)
      ++cm->counts.mbskip[ctx][skip_coeff];
Deb Mukherjee's avatar
Deb Mukherjee committed
166
  }
167 168
  return skip_coeff;
}
John Koleszar's avatar
John Koleszar committed
169

Dmitry Kovalev's avatar
Dmitry Kovalev committed
170 171
static void read_intra_frame_mode_info(VP9D_COMP *pbi, MODE_INFO *m,
                                       int mi_row, int mi_col, vp9_reader *r) {
172 173 174
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
  MB_MODE_INFO *const mbmi = &m->mbmi;
175
  const BLOCK_SIZE bsize = mbmi->sb_type;
176
  const MODE_INFO *above_mi = xd->mi_8x8[-cm->mode_info_stride];
177

178
  mbmi->segment_id = read_intra_segment_id(pbi, mi_row, mi_col, r);
Paul Wilkins's avatar
Paul Wilkins committed
179
  mbmi->skip_coeff = read_skip_coeff(pbi, mbmi->segment_id, r);
180
  mbmi->tx_size = read_tx_size(pbi, cm->tx_mode, bsize, 1, r);
181
  mbmi->ref_frame[0] = INTRA_FRAME;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
182
  mbmi->ref_frame[1] = NONE;
183

184
  if (bsize >= BLOCK_8X8) {
185
    const MB_PREDICTION_MODE A = above_block_mode(m, above_mi, 0);
186 187 188
    const MB_PREDICTION_MODE L = xd->left_available
                               ? left_block_mode(m, xd->mi_8x8[-1], 0)
                               : DC_PRED;
189
    mbmi->mode = read_intra_mode(r, vp9_kf_y_mode_prob[A][L]);
190
  } else {
191
    // Only 4x4, 4x8, 8x4 blocks
Dmitry Kovalev's avatar
Dmitry Kovalev committed
192 193
    const int num_4x4_w = num_4x4_blocks_wide_lookup[bsize];  // 1 or 2
    const int num_4x4_h = num_4x4_blocks_high_lookup[bsize];  // 1 or 2
194
    int idx, idy;
195

Dmitry Kovalev's avatar
Dmitry Kovalev committed
196 197
    for (idy = 0; idy < 2; idy += num_4x4_h) {
      for (idx = 0; idx < 2; idx += num_4x4_w) {
198
        const int ib = idy * 2 + idx;
199
        const MB_PREDICTION_MODE A = above_block_mode(m, above_mi, ib);
200 201 202
        const MB_PREDICTION_MODE L = (xd->left_available || idx)
                                   ? left_block_mode(m, xd->mi_8x8[-1], ib)
                                   : DC_PRED;
203
        const MB_PREDICTION_MODE b_mode = read_intra_mode(r,
204
                                              vp9_kf_y_mode_prob[A][L]);
205
        m->bmi[ib].as_mode = b_mode;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
206
        if (num_4x4_h == 2)
207
          m->bmi[ib + 2].as_mode = b_mode;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
208
        if (num_4x4_w == 2)
209
          m->bmi[ib + 1].as_mode = b_mode;
210 211
      }
    }
212

213
    mbmi->mode = m->bmi[3].as_mode;
John Koleszar's avatar
John Koleszar committed
214
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
215

216
  mbmi->uv_mode = read_intra_mode(r, vp9_kf_uv_mode_prob[mbmi->mode]);
Scott LaVarnway's avatar
Scott LaVarnway committed
217
}
John Koleszar's avatar
John Koleszar committed
218

219 220 221
static int read_mv_component(vp9_reader *r,
                             const nmv_component *mvcomp, int usehp) {
  int mag, d, fr, hp;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
222 223
  const int sign = vp9_read(r, mvcomp->sign);
  const int mv_class = treed_read(r, vp9_mv_class_tree, mvcomp->classes);
224
  const int class0 = mv_class == MV_CLASS_0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
225

226
  // Integer part
227
  if (class0) {
228
    d = treed_read(r, vp9_mv_class0_tree, mvcomp->class0);
229
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
230
    int i;
231
    const int n = mv_class + CLASS0_BITS - 1;  // number of bits
Dmitry Kovalev's avatar
Dmitry Kovalev committed
232

233
    d = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
234 235
    for (i = 0; i < n; ++i)
      d |= vp9_read(r, mvcomp->bits[i]) << i;
236 237
  }

238 239
  // Fractional part
  fr = treed_read(r, vp9_mv_fp_tree,
240
                  class0 ? mvcomp->class0_fp[d] : mvcomp->fp);
241 242


243
  // High precision part (if hp is not used, the default value of the hp is 1)
244
  hp = usehp ? vp9_read(r, class0 ? mvcomp->class0_hp : mvcomp->hp)
245
             : 1;
246

247
  // Result
248 249
  mag = vp9_get_mv_mag(mv_class, (d << 3) | (fr << 1) | hp) + 1;
  return sign ? -mag : mag;
250 251
}

252 253
static INLINE void read_mv(vp9_reader *r, MV *mv, const MV *ref,
                           const nmv_context *ctx,
254
                           nmv_context_counts *counts, int allow_hp) {
255
  const MV_JOINT_TYPE j = treed_read(r, vp9_mv_joint_tree, ctx->joints);
256
  const int use_hp = allow_hp && vp9_use_mv_hp(ref);
257 258 259
  MV diff = {0, 0};

  if (mv_joint_vertical(j))
260
    diff.row = read_mv_component(r, &ctx->comps[0], use_hp);
261 262

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

265
  vp9_inc_mv(&diff, counts);
266 267 268 269 270

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
271
static void update_mv(vp9_reader *r, vp9_prob *p) {
272
  if (vp9_read(r, NMV_UPDATE_PROB))
273
    *p = (vp9_read_literal(r, 7) << 1) | 1;
274 275
}

276
static void read_mv_probs(vp9_reader *r, nmv_context *mvc, int allow_hp) {
277
  int i, j, k;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
278 279

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

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
285 286
    update_mv(r, &comp->sign);

Dmitry Kovalev's avatar
Dmitry Kovalev committed
287
    for (j = 0; j < MV_CLASSES - 1; ++j)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
288
      update_mv(r, &comp->classes[j]);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
289 290

    for (j = 0; j < CLASS0_SIZE - 1; ++j)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
291
      update_mv(r, &comp->class0[j]);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
292 293

    for (j = 0; j < MV_OFFSET_BITS; ++j)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
294
      update_mv(r, &comp->bits[j]);
295 296 297
  }

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

300
    for (j = 0; j < CLASS0_SIZE; ++j)
301
      for (k = 0; k < 3; ++k)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
302
        update_mv(r, &comp->class0_fp[j][k]);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
303 304

    for (j = 0; j < 3; ++j)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
305
      update_mv(r, &comp->fp[j]);
306 307
  }

308
  if (allow_hp) {
309
    for (i = 0; i < 2; ++i) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
310 311
      update_mv(r, &mvc->comps[i].class0_hp);
      update_mv(r, &mvc->comps[i].hp);
312 313 314 315
    }
  }
}

316
// Read the referncence frame
Dmitry Kovalev's avatar
Dmitry Kovalev committed
317 318
static void read_ref_frames(VP9D_COMP *pbi, vp9_reader *r,
                            int segment_id, MV_REFERENCE_FRAME ref_frame[2]) {
319
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
320
  MACROBLOCKD *const xd = &pbi->mb;
321
  FRAME_CONTEXT *const fc = &cm->fc;
322
  FRAME_COUNTS *const counts = &cm->counts;
323

324 325
  if (vp9_segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME)) {
    ref_frame[0] = vp9_get_segdata(&cm->seg, segment_id, SEG_LVL_REF_FRAME);
326 327
    ref_frame[1] = NONE;
  } else {
328
    const int comp_ctx = vp9_get_pred_context_comp_inter_inter(cm, xd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
329
    int is_comp;
John Koleszar's avatar
John Koleszar committed
330

Ronald S. Bultje's avatar
Ronald S. Bultje committed
331
    if (cm->comp_pred_mode == HYBRID_PREDICTION) {
332
      is_comp = vp9_read(r, fc->comp_inter_prob[comp_ctx]);
333 334
      if (!cm->frame_parallel_decoding_mode)
        ++counts->comp_inter[comp_ctx][is_comp];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
335 336 337
    } else {
      is_comp = cm->comp_pred_mode == COMP_PREDICTION_ONLY;
    }
John Koleszar's avatar
John Koleszar committed
338

Ronald S. Bultje's avatar
Ronald S. Bultje committed
339 340
    // FIXME(rbultje) I'm pretty sure this breaks segmentation ref frame coding
    if (is_comp) {
341
      const int fix_ref_idx = cm->ref_frame_sign_bias[cm->comp_fixed_ref];
342
      const int ref_ctx = vp9_get_pred_context_comp_ref_p(cm, xd);
343
      const int b = vp9_read(r, fc->comp_ref_prob[ref_ctx]);
344 345
      if (!cm->frame_parallel_decoding_mode)
        ++counts->comp_ref[ref_ctx][b];
346
      ref_frame[fix_ref_idx] = cm->comp_fixed_ref;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
347
      ref_frame[!fix_ref_idx] = cm->comp_var_ref[b];
Dmitry Kovalev's avatar
Dmitry Kovalev committed
348
    } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
349 350
      const int ctx0 = vp9_get_pred_context_single_ref_p1(xd);
      const int bit0 = vp9_read(r, fc->single_ref_prob[ctx0][0]);
351 352
      if (!cm->frame_parallel_decoding_mode)
        ++counts->single_ref[ctx0][0][bit0];
Dmitry Kovalev's avatar
Dmitry Kovalev committed
353 354 355 356
      if (bit0) {
        const int ctx1 = vp9_get_pred_context_single_ref_p2(xd);
        const int bit1 = vp9_read(r, fc->single_ref_prob[ctx1][1]);
        ref_frame[0] = bit1 ? ALTREF_FRAME : GOLDEN_FRAME;
357 358
        if (!cm->frame_parallel_decoding_mode)
          ++counts->single_ref[ctx1][1][bit1];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
359 360
      } else {
        ref_frame[0] = LAST_FRAME;
John Koleszar's avatar
John Koleszar committed
361
      }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
362 363

      ref_frame[1] = NONE;
364
    }
John Koleszar's avatar
John Koleszar committed
365
  }
366
}
John Koleszar's avatar
John Koleszar committed
367

368
static void read_switchable_interp_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
369
  int i, j;
370 371
  for (j = 0; j < SWITCHABLE_FILTERS + 1; ++j)
    for (i = 0; i < SWITCHABLE_FILTERS - 1; ++i)
372
      vp9_diff_update_prob(r, &fc->switchable_interp_prob[j][i]);
373 374
}

375
static void read_inter_mode_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
376 377
  int i, j;
  for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
378
    for (j = 0; j < INTER_MODES - 1; ++j)
379
      vp9_diff_update_prob(r, &fc->inter_mode_probs[i][j]);
380
}
John Koleszar's avatar
John Koleszar committed
381

382 383 384
static INLINE COMPPREDMODE_TYPE read_comp_pred_mode(vp9_reader *r) {
  COMPPREDMODE_TYPE mode = vp9_read_bit(r);
  if (mode)
385
    mode += vp9_read_bit(r);
386 387 388
  return mode;
}

389
static INLINE INTERPOLATIONFILTERTYPE read_switchable_filter_type(
390
    VP9D_COMP *pbi, vp9_reader *r) {
391 392
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
393
  const int ctx = vp9_get_pred_context_switchable_interp(xd);
394 395
  const int type = treed_read(r, vp9_switchable_interp_tree,
                              cm->fc.switchable_interp_prob[ctx]);
396 397
  if (!cm->frame_parallel_decoding_mode)
    ++cm->counts.switchable_interp[ctx][type];
398
  return type;
399 400
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
401
static void read_intra_block_mode_info(VP9D_COMP *pbi, MODE_INFO *mi,
402
                                  vp9_reader *r) {
403
  VP9_COMMON *const cm = &pbi->common;
404
  MB_MODE_INFO *const mbmi = &mi->mbmi;
405
  const BLOCK_SIZE bsize = mi->mbmi.sb_type;
406

Dmitry Kovalev's avatar
Dmitry Kovalev committed
407 408 409
  mbmi->ref_frame[0] = INTRA_FRAME;
  mbmi->ref_frame[1] = NONE;

410
  if (bsize >= BLOCK_8X8) {
411
    mbmi->mode = read_intra_mode_y(cm, r, size_group_lookup[bsize]);
412
  } else {
413
     // Only 4x4, 4x8, 8x4 blocks
Dmitry Kovalev's avatar
Dmitry Kovalev committed
414 415
     const int num_4x4_w = num_4x4_blocks_wide_lookup[bsize];  // 1 or 2
     const int num_4x4_h = num_4x4_blocks_high_lookup[bsize];  // 1 or 2
416
     int idx, idy;
417

Dmitry Kovalev's avatar
Dmitry Kovalev committed
418 419
     for (idy = 0; idy < 2; idy += num_4x4_h) {
       for (idx = 0; idx < 2; idx += num_4x4_w) {
420
         const int ib = idy * 2 + idx;
421
         const int b_mode = read_intra_mode_y(cm, r, 0);
422
         mi->bmi[ib].as_mode = b_mode;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
423
         if (num_4x4_h == 2)
424
           mi->bmi[ib + 2].as_mode = b_mode;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
425
         if (num_4x4_w == 2)
426
           mi->bmi[ib + 1].as_mode = b_mode;
427 428
      }
    }
429
    mbmi->mode = mi->bmi[3].as_mode;
430 431
  }

432
  mbmi->uv_mode = read_intra_mode_uv(cm, r, mbmi->mode);
433 434
}

Yaowu Xu's avatar
Yaowu Xu committed
435
static INLINE int assign_mv(VP9_COMMON *cm, MB_PREDICTION_MODE mode,
436 437 438 439
                             int_mv mv[2], int_mv best_mv[2],
                             int_mv nearest_mv[2], int_mv near_mv[2],
                             int is_compound, int allow_hp, vp9_reader *r) {
  int i;
Yaowu Xu's avatar
Yaowu Xu committed
440
  int ret = 1;
441 442

  switch (mode) {
443 444 445 446 447
    case NEWMV: {
      nmv_context_counts *const mv_counts = cm->frame_parallel_decoding_mode ?
                                            NULL : &cm->counts.mv;
      read_mv(r, &mv[0].as_mv, &best_mv[0].as_mv,
              &cm->fc.nmvc, mv_counts, allow_hp);
448
      if (is_compound)
449 450 451 452 453 454 455 456 457 458 459
        read_mv(r, &mv[1].as_mv, &best_mv[1].as_mv,
                &cm->fc.nmvc, mv_counts, allow_hp);
      for (i = 0; i < 1 + is_compound; ++i) {
        ret = ret && mv[i].as_mv.row < MV_UPP && mv[i].as_mv.row > MV_LOW;
        ret = ret && mv[i].as_mv.col < MV_UPP && mv[i].as_mv.col > MV_LOW;
      }
      break;
    }
    case NEARESTMV: {
      mv[0].as_int = nearest_mv[0].as_int;
      if (is_compound) mv[1].as_int = nearest_mv[1].as_int;
460
      break;
461 462
    }
    case NEARMV: {
463
      mv[0].as_int = near_mv[0].as_int;
464
      if (is_compound) mv[1].as_int = near_mv[1].as_int;
465
      break;
466 467
    }
    case ZEROMV: {
468
      mv[0].as_int = 0;
469
      if (is_compound) mv[1].as_int = 0;
470
      break;
471 472
    }
    default: {
Yaowu Xu's avatar
Yaowu Xu committed
473
      return 0;
474
    }
475
  }
Yaowu Xu's avatar
Yaowu Xu committed
476
  return ret;
477 478
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
479
static int read_is_inter_block(VP9D_COMP *pbi, int segment_id, vp9_reader *r) {
480 481 482
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;

483 484
  if (vp9_segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME)) {
    return vp9_get_segdata(&cm->seg, segment_id, SEG_LVL_REF_FRAME) !=
Dmitry Kovalev's avatar
Dmitry Kovalev committed
485
           INTRA_FRAME;
486
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
487 488
    const int ctx = vp9_get_pred_context_intra_inter(xd);
    const int is_inter = vp9_read(r, vp9_get_pred_prob_intra_inter(cm, xd));
489 490
    if (!cm->frame_parallel_decoding_mode)
      ++cm->counts.intra_inter[ctx][is_inter];
Dmitry Kovalev's avatar
Dmitry Kovalev committed
491
    return is_inter;
492 493 494
  }
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
495
static void read_inter_block_mode_info(VP9D_COMP *pbi, MODE_INFO *mi,
496
                                       int mi_row, int mi_col, vp9_reader *r) {
497
  VP9_COMMON *const cm = &pbi->common;
498
  MACROBLOCKD *const xd = &pbi->mb;
499
  MB_MODE_INFO *const mbmi = &mi->mbmi;
500
  const BLOCK_SIZE bsize = mbmi->sb_type;
501
  const int allow_hp = xd->allow_high_precision_mv;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
502

Yaowu Xu's avatar
Yaowu Xu committed
503
  int_mv nearest[2], nearmv[2], best[2];
504
  uint8_t inter_mode_ctx;
505
  MV_REFERENCE_FRAME ref0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
506
  int is_compound;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
507

508
  mbmi->uv_mode = DC_PRED;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
509
  read_ref_frames(pbi, r, mbmi->segment_id, mbmi->ref_frame);
510
  ref0 = mbmi->ref_frame[0];
511
  is_compound = has_second_ref(mbmi);
512

513 514
  vp9_find_mv_refs(cm, xd, mi, xd->last_mi, ref0, mbmi->ref_mvs[ref0],
                   mi_row, mi_col);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
515

Paul Wilkins's avatar
Paul Wilkins committed
516
  inter_mode_ctx = mbmi->mode_context[ref0];
517

518
  if (vp9_segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) {
519
    mbmi->mode = ZEROMV;
520 521 522 523 524
    if (bsize < BLOCK_8X8) {
        vpx_internal_error(&cm->error, VPX_CODEC_UNSUP_BITSTREAM,
                           "Invalid usage of segement feature on small blocks");
        return;
    }
525 526 527 528
  } else {
    if (bsize >= BLOCK_8X8)
      mbmi->mode = read_inter_mode(cm, r, inter_mode_ctx);
  }
529

530
  // nearest, nearby
531
  if (bsize < BLOCK_8X8 || mbmi->mode != ZEROMV) {
Yaowu Xu's avatar
Yaowu Xu committed
532
    vp9_find_best_ref_mvs(xd, mbmi->ref_mvs[ref0], &nearest[0], &nearmv[0]);
533
    best[0].as_int = nearest[0].as_int;
534
  }
535

Dmitry Kovalev's avatar
Dmitry Kovalev committed
536
  if (is_compound) {
537
    const MV_REFERENCE_FRAME ref1 = mbmi->ref_frame[1];
538
    vp9_find_mv_refs(cm, xd, mi, xd->last_mi,
539
                     ref1, mbmi->ref_mvs[ref1], mi_row, mi_col);
540

541
    if (bsize < BLOCK_8X8 || mbmi->mode != ZEROMV) {
Yaowu Xu's avatar
Yaowu Xu committed
542
      vp9_find_best_ref_mvs(xd, mbmi->ref_mvs[ref1], &nearest[1], &nearmv[1]);
543
      best[1].as_int = nearest[1].as_int;
544
    }
545
  }
546

547 548 549 550
  mbmi->interp_filter = cm->mcomp_filter_type == SWITCHABLE
                              ? read_switchable_filter_type(pbi, r)
                              : cm->mcomp_filter_type;

551
  if (bsize < BLOCK_8X8) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
552 553
    const int num_4x4_w = num_4x4_blocks_wide_lookup[bsize];  // 1 or 2
    const int num_4x4_h = num_4x4_blocks_high_lookup[bsize];  // 1 or 2
554
    int idx, idy;
555
    int b_mode;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
556 557
    for (idy = 0; idy < 2; idy += num_4x4_h) {
      for (idx = 0; idx < 2; idx += num_4x4_w) {
558
        int_mv block[2];
559
        const int j = idy * 2 + idx;
560
        b_mode = read_inter_mode(cm, r, inter_mode_ctx);
561

562
        if (b_mode == NEARESTMV || b_mode == NEARMV) {
Yaowu Xu's avatar
Yaowu Xu committed
563 564
          vp9_append_sub8x8_mvs_for_idx(cm, xd, &nearest[0],
                                        &nearmv[0], j, 0,
565 566
                                        mi_row, mi_col);

Dmitry Kovalev's avatar
Dmitry Kovalev committed
567
          if (is_compound)
Yaowu Xu's avatar
Yaowu Xu committed
568 569
            vp9_append_sub8x8_mvs_for_idx(cm, xd,  &nearest[1],
                                          &nearmv[1], j, 1,
570
                                          mi_row, mi_col);
571
        }
572

Yaowu Xu's avatar
Yaowu Xu committed
573 574 575 576 577 578
        if (!assign_mv(cm, b_mode, block, best, nearest, nearmv,
                       is_compound, allow_hp, r)) {
          xd->corrupted |= 1;
          break;
        };

579

580 581
        mi->bmi[j].as_mv[0].as_int = block[0].as_int;
        if (is_compound)
582
          mi->bmi[j].as_mv[1].as_int = block[1].as_int;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
583

Dmitry Kovalev's avatar
Dmitry Kovalev committed
584
        if (num_4x4_h == 2)
585
          mi->bmi[j + 2] = mi->bmi[j];
Dmitry Kovalev's avatar
Dmitry Kovalev committed
586
        if (num_4x4_w == 2)
587
          mi->bmi[j + 1] = mi->bmi[j];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
588
      }
Scott LaVarnway's avatar
Scott LaVarnway committed
589
    }
590

591
    mi->mbmi.mode = b_mode;
592

593 594 595
    mbmi->mv[0].as_int = mi->bmi[3].as_mv[0].as_int;
    mbmi->mv[1].as_int = mi->bmi[3].as_mv[1].as_int;
  } else {
Yaowu Xu's avatar
Yaowu Xu committed
596 597 598
    xd->corrupted |= !assign_mv(cm, mbmi->mode, mbmi->mv,
                                best, nearest, nearmv,
                                is_compound, allow_hp, r);
John Koleszar's avatar
John Koleszar committed
599
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
600
}
John Koleszar's avatar
John Koleszar committed
601

Dmitry Kovalev's avatar
Dmitry Kovalev committed
602 603
static void read_inter_frame_mode_info(VP9D_COMP *pbi, MODE_INFO *mi,
                                       int mi_row, int mi_col, vp9_reader *r) {
604 605
  VP9_COMMON *const cm = &pbi->common;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
606
  int inter_block;
607

Dmitry Kovalev's avatar
Dmitry Kovalev committed
608 609
  mbmi->mv[0].as_int = 0;
  mbmi->mv[1].as_int = 0;
610
  mbmi->segment_id = read_inter_segment_id(pbi, mi_row, mi_col, r);
Paul Wilkins's avatar
Paul Wilkins committed
611
  mbmi->skip_coeff = read_skip_coeff(pbi, mbmi->segment_id, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
612
  inter_block = read_is_inter_block(pbi, mbmi->segment_id, r);
613 614
  mbmi->tx_size = read_tx_size(pbi, cm->tx_mode, mbmi->sb_type,
                               !mbmi->skip_coeff || !inter_block, r);
615

Dmitry Kovalev's avatar
Dmitry Kovalev committed
616
  if (inter_block)
617
    read_inter_block_mode_info(pbi, mi, mi_row, mi_col, r);
618
  else
Dmitry Kovalev's avatar
Dmitry Kovalev committed
619
    read_intra_block_mode_info(pbi, mi, r);
620 621
}

622 623 624 625 626 627 628 629
static void read_comp_pred(VP9_COMMON *cm, vp9_reader *r) {
  int i;

  cm->comp_pred_mode = cm->allow_comp_inter_inter ? read_comp_pred_mode(r)
                                                  : SINGLE_PREDICTION_ONLY;

  if (cm->comp_pred_mode == HYBRID_PREDICTION)
    for (i = 0; i < COMP_INTER_CONTEXTS; i++)
630
      vp9_diff_update_prob(r, &cm->fc.comp_inter_prob[i]);
631 632 633

  if (cm->comp_pred_mode != COMP_PREDICTION_ONLY)
    for (i = 0; i < REF_CONTEXTS; i++) {
634 635
      vp9_diff_update_prob(r, &cm->fc.single_ref_prob[i][0]);
      vp9_diff_update_prob(r, &cm->fc.single_ref_prob[i][1]);
636 637 638 639
    }

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

643 644
void vp9_prepare_read_mode_info(VP9D_COMP* pbi, vp9_reader *r) {
  VP9_COMMON *const cm = &pbi->common;
645
  int k;
646

647
  // TODO(jkoleszar): does this clear more than MBSKIP_CONTEXTS? Maybe remove.
Deb Mukherjee's avatar
Deb Mukherjee committed
648
  // vpx_memset(cm->fc.mbskip_probs, 0, sizeof(cm->fc.mbskip_probs));
649
  for (k = 0; k < MBSKIP_CONTEXTS; ++k)
650
    vp9_diff_update_prob(r, &cm->fc.mbskip_probs[k]);
651

652
  if (!frame_is_intra_only(cm)) {
653 654 655 656 657 658 659 660 661 662
    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++)