vp9_decodemv.c 27.2 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
  return treed_read(r, vp9_intra_mode_tree, p);
41
42
}

43
static int read_segment_id(vp9_reader *r, MACROBLOCKD *xd) {
44
  return treed_read(r, vp9_segment_tree, xd->mb_segment_tree_probs);
Scott LaVarnway's avatar
Scott LaVarnway committed
45
}
46

47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
static TX_SIZE select_txfm_size(VP9_COMMON *cm, MACROBLOCKD *xd,
                                vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  const int context = vp9_get_pred_context(cm, xd, PRED_TX_SIZE);
  const vp9_prob *tx_probs = vp9_get_pred_probs(cm, xd, PRED_TX_SIZE);
  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;
}

static TX_SIZE get_txfm_size(VP9D_COMP *pbi, TXFM_MODE txfm_mode,
                             BLOCK_SIZE_TYPE bsize, int select_cond,
                             vp9_reader *r) {
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;

  if (txfm_mode == TX_MODE_SELECT && bsize >= BLOCK_SIZE_SB8X8 && select_cond)
    return select_txfm_size(cm, xd, r, bsize);
  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;
}

86
static void set_segment_id(VP9_COMMON *cm, BLOCK_SIZE_TYPE bsize,
87
                           int mi_row, int mi_col, int segment_id) {
88
89
90
  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);
91
  const int xmis = MIN(cm->mi_cols - mi_col, bw);
92
  const int ymis = MIN(cm->mi_rows - mi_row, bh);
93
94
  int x, y;

95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
  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) {
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
  const BLOCK_SIZE_TYPE bsize = xd->mode_info_context->mbmi.sb_type;

  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
    const int segment_id = read_segment_id(r, xd);
    set_segment_id(cm, bsize, mi_row, mi_col, segment_id);
    return segment_id;
  } else {
    return 0;
114
115
116
  }
}

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

129
130
131
132
133
134
135
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;
136

137
138
139
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);
  mbmi->txfm_size = get_txfm_size(pbi, cm->txfm_mode, bsize, 1, r);
  mbmi->ref_frame[0] = INTRA_FRAME;

  if (bsize >= BLOCK_SIZE_SB8X8) {
143
144
145
    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;
146
    mbmi->mode = read_intra_mode(r, cm->kf_y_mode_prob[A][L]);
147
  } else {
148
149
150
    // Only 4x4, 4x8, 8x4 blocks
    const int bw = 1 << b_width_log2(bsize);
    const int bh = 1 << b_height_log2(bsize);
151
    int idx, idy;
152
153
154

    for (idy = 0; idy < 2; idy += bh) {
      for (idx = 0; idx < 2; idx += bw) {
155
        const int ib = idy * 2 + idx;
156
157
158
        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;
159
160
161
162
163
164
165
        const MB_PREDICTION_MODE b_mode = read_intra_mode(r,
                                              cm->kf_y_mode_prob[A][L]);
        m->bmi[ib].as_mode.first = b_mode;
        if (bh == 2)
          m->bmi[ib + 2].as_mode.first = b_mode;
        if (bw == 2)
          m->bmi[ib + 1].as_mode.first = b_mode;
166
167
      }
    }
168
169

    mbmi->mode = m->bmi[3].as_mode.first;
John Koleszar's avatar
John Koleszar committed
170
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
171

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

175
176
static int read_mv_component(vp9_reader *r,
                             const nmv_component *mvcomp, int usehp) {
177

178
  int mag, d, fr, hp;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
179
180
181
  const int sign = vp9_read(r, mvcomp->sign);
  const int mv_class = treed_read(r, vp9_mv_class_tree, mvcomp->classes);

182
  // Integer part
Dmitry Kovalev's avatar
Dmitry Kovalev committed
183
  if (mv_class == MV_CLASS_0) {
184
    d = treed_read(r, vp9_mv_class0_tree, mvcomp->class0);
185
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
186
    int i;
187
    const int n = mv_class + CLASS0_BITS - 1;  // number of bits
Dmitry Kovalev's avatar
Dmitry Kovalev committed
188

189
    d = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
190
191
    for (i = 0; i < n; ++i)
      d |= vp9_read(r, mvcomp->bits[i]) << i;
192
193
  }

194
195
196
  // Fractional part
  fr = treed_read(r, vp9_mv_fp_tree,
                  mv_class == MV_CLASS_0 ? mvcomp->class0_fp[d] : mvcomp->fp);
197
198


199
200
201
202
  // High precision part (if hp is not used, the default value of the hp is 1)
  hp = usehp ? vp9_read(r,
                        mv_class == MV_CLASS_0 ? mvcomp->class0_hp : mvcomp->hp)
             : 1;
203

204
205
206
  // result
  mag = vp9_get_mv_mag(mv_class, (d << 3) | (fr << 1) | hp) + 1;
  return sign ? -mag : mag;
207
208
}

209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
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;
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
228
static void update_mv(vp9_reader *r, vp9_prob *const p,
229
                       const vp9_prob upd_p) {
230
  if (vp9_read(r, upd_p)) {
231
#ifdef LOW_PRECISION_MV_UPDATE
232
    *p = (vp9_read_literal(r, 7) << 1) | 1;
233
#else
234
    *p = (vp9_read_literal(r, 8));
235
236
237
238
#endif
  }
}

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

242
#ifdef MV_GROUP_UPDATE
243
  if (!vp9_read_bit(r))
Dmitry Kovalev's avatar
Dmitry Kovalev committed
244
    return;
245
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
246
  for (j = 0; j < MV_JOINTS - 1; ++j)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
247
    update_mv(r, &mvc->joints[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
248

249
  for (i = 0; i < 2; ++i) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
250
    update_mv(r, &mvc->comps[i].sign, VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
251
    for (j = 0; j < MV_CLASSES - 1; ++j)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
252
      update_mv(r, &mvc->comps[i].classes[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
253
254

    for (j = 0; j < CLASS0_SIZE - 1; ++j)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
255
      update_mv(r, &mvc->comps[i].class0[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
256
257

    for (j = 0; j < MV_OFFSET_BITS; ++j)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
258
      update_mv(r, &mvc->comps[i].bits[j], VP9_NMV_UPDATE_PROB);
259
260
261
  }

  for (i = 0; i < 2; ++i) {
262
    for (j = 0; j < CLASS0_SIZE; ++j)
263
      for (k = 0; k < 3; ++k)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
264
        update_mv(r, &mvc->comps[i].class0_fp[j][k], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
265
266

    for (j = 0; j < 3; ++j)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
267
      update_mv(r, &mvc->comps[i].fp[j], VP9_NMV_UPDATE_PROB);
268
269
270
271
  }

  if (usehp) {
    for (i = 0; i < 2; ++i) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
272
273
      update_mv(r, &mvc->comps[i].class0_hp, VP9_NMV_UPDATE_PROB);
      update_mv(r, &mvc->comps[i].hp, VP9_NMV_UPDATE_PROB);
274
275
276
277
    }
  }
}

278
// Read the referncence frame
Ronald S. Bultje's avatar
Ronald S. Bultje committed
279
280
static void read_ref_frame(VP9D_COMP *pbi, vp9_reader *r,
                           int segment_id, MV_REFERENCE_FRAME ref_frame[2]) {
281
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
282
  MACROBLOCKD *const xd = &pbi->mb;
283
284
  const int seg_ref_active = vp9_segfeature_active(xd, segment_id,
                                                   SEG_LVL_REF_FRAME);
285
286
287

  // Segment reference frame features not available.
  if (!seg_ref_active) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
288
289
    int is_comp;
    int comp_ctx = vp9_get_pred_context(cm, xd, PRED_COMP_INTER_INTER);
John Koleszar's avatar
John Koleszar committed
290

Ronald S. Bultje's avatar
Ronald S. Bultje committed
291
292
293
294
295
296
    if (cm->comp_pred_mode == HYBRID_PREDICTION) {
      is_comp = vp9_read(r, cm->fc.comp_inter_prob[comp_ctx]);
      cm->fc.comp_inter_count[comp_ctx][is_comp]++;
    } else {
      is_comp = cm->comp_pred_mode == COMP_PREDICTION_ONLY;
    }
John Koleszar's avatar
John Koleszar committed
297

Ronald S. Bultje's avatar
Ronald S. Bultje committed
298
299
300
301
    // FIXME(rbultje) I'm pretty sure this breaks segmentation ref frame coding
    if (is_comp) {
      int b, fix_ref_idx = cm->ref_frame_sign_bias[cm->comp_fixed_ref];
      int ref_ctx = vp9_get_pred_context(cm, xd, PRED_COMP_REF_P);
John Koleszar's avatar
John Koleszar committed
302

Ronald S. Bultje's avatar
Ronald S. Bultje committed
303
304
305
306
      ref_frame[fix_ref_idx]  = cm->comp_fixed_ref;
      b = vp9_read(r, cm->fc.comp_ref_prob[ref_ctx]);
      cm->fc.comp_ref_count[ref_ctx][b]++;
      ref_frame[!fix_ref_idx] = cm->comp_var_ref[b];
Dmitry Kovalev's avatar
Dmitry Kovalev committed
307
    } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
308
309
310
311
312
313
314
315
316
317
318
      int ref1_ctx = vp9_get_pred_context(cm, xd, PRED_SINGLE_REF_P1);
      ref_frame[1] = NONE;
      if (vp9_read(r, cm->fc.single_ref_prob[ref1_ctx][0])) {
        int ref2_ctx = vp9_get_pred_context(cm, xd, PRED_SINGLE_REF_P2);
        int b2 = vp9_read(r, cm->fc.single_ref_prob[ref2_ctx][1]);
        ref_frame[0] = b2 ? ALTREF_FRAME : GOLDEN_FRAME;
        cm->fc.single_ref_count[ref1_ctx][0][1]++;
        cm->fc.single_ref_count[ref2_ctx][1][b2]++;
      } else {
        ref_frame[0] = LAST_FRAME;
        cm->fc.single_ref_count[ref1_ctx][0][0]++;
John Koleszar's avatar
John Koleszar committed
319
      }
320
    }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
321
  } else {
322
    ref_frame[0] = vp9_get_segdata(xd, segment_id, SEG_LVL_REF_FRAME);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
323
    ref_frame[1] = NONE;
John Koleszar's avatar
John Koleszar committed
324
  }
325
}
John Koleszar's avatar
John Koleszar committed
326

327
328
static MB_PREDICTION_MODE read_sb_mv_ref(vp9_reader *r, const vp9_prob *p) {
  return (MB_PREDICTION_MODE) treed_read(r, vp9_sb_mv_ref_tree, p);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
329
}
John Koleszar's avatar
John Koleszar committed
330

Scott LaVarnway's avatar
Scott LaVarnway committed
331
#ifdef VPX_MODE_COUNT
332
unsigned int vp9_mv_cont_count[5][4] = {
John Koleszar's avatar
John Koleszar committed
333
334
335
336
337
  { 0, 0, 0, 0 },
  { 0, 0, 0, 0 },
  { 0, 0, 0, 0 },
  { 0, 0, 0, 0 },
  { 0, 0, 0, 0 }
John Koleszar's avatar
John Koleszar committed
338
};
Scott LaVarnway's avatar
Scott LaVarnway committed
339
#endif
John Koleszar's avatar
John Koleszar committed
340

341
static void read_switchable_interp_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
342
  int i, j;
343
344
345
  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))
346
        vp9_diff_update_prob(r, &fc->switchable_interp_prob[j][i]);
347
348
}

349
static void read_inter_mode_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
350
351
  int i, j;
  for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
352
353
    for (j = 0; j < VP9_INTER_MODES - 1; ++j)
      if (vp9_read(r, VP9_MODE_UPDATE_PROB))
354
        vp9_diff_update_prob(r, &fc->inter_mode_probs[i][j]);
355
}
John Koleszar's avatar
John Koleszar committed
356

357
358
359
static INLINE COMPPREDMODE_TYPE read_comp_pred_mode(vp9_reader *r) {
  COMPPREDMODE_TYPE mode = vp9_read_bit(r);
  if (mode)
360
    mode += vp9_read_bit(r);
361
362
363
  return mode;
}

364
365
static int read_inter_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
                                 vp9_reader *r) {
366
  VP9_COMMON *const cm = &pbi->common;
367
  MACROBLOCKD *const xd = &pbi->mb;
368
369
370
371
  const BLOCK_SIZE_TYPE bsize = xd->mode_info_context->mbmi.sb_type;
  const int pred_segment_id = vp9_get_segment_id(cm, cm->last_frame_seg_map,
                                                 bsize, mi_row, mi_col);
  int segment_id;
John Koleszar's avatar
John Koleszar committed
372

373
374
375
  if (!xd->segmentation_enabled)
    return 0;  // Default for disabled segmentation

376
377
  if (!xd->update_mb_segmentation_map)
    return pred_segment_id;
378

379
380
381
  if (cm->temporal_update) {
    const vp9_prob pred_prob = vp9_get_pred_prob(cm, xd, PRED_SEG_ID);
    const int pred_flag = vp9_read(r, pred_prob);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
382
    vp9_set_pred_flag(xd, bsize, PRED_SEG_ID, pred_flag);
383
384
    segment_id = pred_flag ? pred_segment_id
                           : read_segment_id(r, xd);
John Koleszar's avatar
John Koleszar committed
385
  } else {
386
    segment_id = read_segment_id(r, xd);
John Koleszar's avatar
John Koleszar committed
387
  }
388
389
  set_segment_id(cm, bsize, mi_row, mi_col, segment_id);
  return segment_id;
390
}
391

Dmitry Kovalev's avatar
Dmitry Kovalev committed
392
393
394
395
396
397
398
399
400
401
402

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);
}

403
static INLINE INTERPOLATIONFILTERTYPE read_switchable_filter_type(
404
    VP9D_COMP *pbi, vp9_reader *r) {
405
406
407
408
409
410
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
  const vp9_prob *probs = vp9_get_pred_probs(cm, xd, PRED_SWITCHABLE_INTERP);
  const int index = treed_read(r, vp9_switchable_interp_tree, probs);
  const int ctx = vp9_get_pred_context(cm, xd, PRED_SWITCHABLE_INTERP);
  ++cm->fc.switchable_interp_count[ctx][index];
411
412
413
  return vp9_switchable_interp[index];
}

414
static void read_intra_block_modes(VP9D_COMP *pbi, MODE_INFO *mi,
415
                                   vp9_reader *r) {
416
  VP9_COMMON *const cm = &pbi->common;
417
  MB_MODE_INFO *const mbmi = &mi->mbmi;
418
  const BLOCK_SIZE_TYPE bsize = mi->mbmi.sb_type;
419
  const int bwl = b_width_log2(bsize), bhl = b_height_log2(bsize);
420
421

  if (bsize >= BLOCK_SIZE_SB8X8) {
422
423
424
    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]++;
425
  } else {
426
427
     // Only 4x4, 4x8, 8x4 blocks
     const int bw = 1 << bwl, bh = 1 << bhl;
428
     int idx, idy;
429

430
431
     for (idy = 0; idy < 2; idy += bh) {
       for (idx = 0; idx < 2; idx += bw) {
432
433
434
435
436
437
438
439
440
         const int ib = idy * 2 + idx;
         const int b_mode = read_intra_mode(r, cm->fc.y_mode_prob[0]);
         mi->bmi[ib].as_mode.first = b_mode;
         cm->fc.y_mode_counts[0][b_mode]++;

         if (bh == 2)
           mi->bmi[ib + 2].as_mode.first = b_mode;
         if (bw == 2)
           mi->bmi[ib + 1].as_mode.first = b_mode;
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
      }
    }
    mbmi->mode = mi->bmi[3].as_mode.first;
  }

  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;
  if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_REF_FRAME)) {
    const int ctx = vp9_get_pred_context(cm, xd, PRED_INTRA_INTER);
    ref = (MV_REFERENCE_FRAME)
              vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_INTRA_INTER));
    cm->fc.intra_inter_count[ctx][ref != INTRA_FRAME]++;
  } else {
    ref = (MV_REFERENCE_FRAME)
              vp9_get_segdata(xd, segment_id, SEG_LVL_REF_FRAME) != INTRA_FRAME;
  }
  return ref;
}

468
469
static void read_inter_mode_info(VP9D_COMP *pbi, MODE_INFO *mi,
                                 int mi_row, int mi_col, vp9_reader *r) {
470
  VP9_COMMON *const cm = &pbi->common;
471
  MACROBLOCKD *const xd = &pbi->mb;
472
  nmv_context *const nmvc = &cm->fc.nmvc;
473
  MB_MODE_INFO *const mbmi = &mi->mbmi;
John Koleszar's avatar
John Koleszar committed
474

475
476
  int_mv *const mv0 = &mbmi->mv[0];
  int_mv *const mv1 = &mbmi->mv[1];
477
478
479
  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
480

481
  int mb_to_left_edge, mb_to_right_edge, mb_to_top_edge, mb_to_bottom_edge;
482
  int idx, idy;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
483

Ronald S. Bultje's avatar
Ronald S. Bultje committed
484
  mbmi->ref_frame[1] = NONE;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
485

486
487
488
489
  // Make sure the MACROBLOCKD mode info pointer is pointed at the
  // correct entry for the current macroblock.
  xd->mode_info_context = mi;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
490
491
492
  // 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
493
494
  set_mi_row_col(cm, xd, mi_row, 1 << mi_height_log2(bsize),
                         mi_col, 1 << mi_width_log2(bsize));
495

496
497
  mb_to_top_edge = xd->mb_to_top_edge - LEFT_TOP_MARGIN;
  mb_to_bottom_edge = xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
498
499
  mb_to_left_edge = xd->mb_to_left_edge - LEFT_TOP_MARGIN;
  mb_to_right_edge = xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN;
John Koleszar's avatar
John Koleszar committed
500

501
  mbmi->segment_id = read_inter_segment_id(pbi, mi_row, mi_col, r);
502
  mbmi->mb_skip_coeff = read_skip_coeff(pbi, mbmi->segment_id, r);
503
504
505
  mbmi->ref_frame[0] = read_reference_frame(pbi, mbmi->segment_id, r);
  mbmi->txfm_size = get_txfm_size(pbi, cm->txfm_mode, bsize,
     (mbmi->mb_skip_coeff == 0 || mbmi->ref_frame[0] == INTRA_FRAME), r);
506

John Koleszar's avatar
John Koleszar committed
507
  // If reference frame is an Inter frame
Ronald S. Bultje's avatar
Ronald S. Bultje committed
508
  if (mbmi->ref_frame[0] != INTRA_FRAME) {
John Koleszar's avatar
John Koleszar committed
509
510
    int_mv nearest, nearby, best_mv;
    int_mv nearest_second, nearby_second, best_mv_second;
511
    vp9_prob *mv_ref_p;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
512
513

    read_ref_frame(pbi, r, mbmi->segment_id, mbmi->ref_frame);
514
515

    {
516
517
518
519
520
#ifdef DEC_DEBUG
      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);
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
521
522
523
      vp9_find_mv_refs(cm, xd, mi, xd->prev_mode_info_context,
                       mbmi->ref_frame[0], mbmi->ref_mvs[mbmi->ref_frame[0]],
                       cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
524

525
526
      mv_ref_p = cm->fc.inter_mode_probs[
        mbmi->mb_mode_context[mbmi->ref_frame[0]]];
527

528
      // If the segment level skip mode enabled
Paul Wilkins's avatar
Paul Wilkins committed
529
530
      if (vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP)) {
        mbmi->mode = ZEROMV;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
531
532
      } else if (bsize >= BLOCK_SIZE_SB8X8) {
        mbmi->mode = read_sb_mv_ref(r, mv_ref_p);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
533
534
        vp9_accum_mv_refs(cm, mbmi->mode,
                          mbmi->mb_mode_context[mbmi->ref_frame[0]]);
535
536
      }

Ronald S. Bultje's avatar
Ronald S. Bultje committed
537
      if (bsize < BLOCK_SIZE_SB8X8 || mbmi->mode != ZEROMV) {
538
        vp9_find_best_ref_mvs(xd,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
539
                              mbmi->ref_mvs[mbmi->ref_frame[0]],
540
541
                              &nearest, &nearby);

Ronald S. Bultje's avatar
Ronald S. Bultje committed
542
        best_mv.as_int = mbmi->ref_mvs[mbmi->ref_frame[0]][0].as_int;
543
      }
544

545
546
547
548
549
550
#ifdef DEC_DEBUG
      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]);
#endif
Paul Wilkins's avatar
Paul Wilkins committed
551
    }
John Koleszar's avatar
John Koleszar committed
552

553
554
555
    mbmi->interp_filter = cm->mcomp_filter_type == SWITCHABLE
                              ? read_switchable_filter_type(pbi, r)
                              : cm->mcomp_filter_type;
556

Ronald S. Bultje's avatar
Ronald S. Bultje committed
557
558
559
560
561
562
563
564
565
566
567
568
    if (mbmi->ref_frame[1] > INTRA_FRAME) {
      vp9_find_mv_refs(cm, xd, mi, xd->prev_mode_info_context,
                       mbmi->ref_frame[1],
                       mbmi->ref_mvs[mbmi->ref_frame[1]],
                       cm->ref_frame_sign_bias);

      if (bsize < BLOCK_SIZE_SB8X8 || mbmi->mode != ZEROMV) {
        vp9_find_best_ref_mvs(xd,
                              mbmi->ref_mvs[mbmi->ref_frame[1]],
                              &nearest_second,
                              &nearby_second);
        best_mv_second.as_int = mbmi->ref_mvs[mbmi->ref_frame[1]][0].as_int;
569
      }
John Koleszar's avatar
John Koleszar committed
570
    }
571

John Koleszar's avatar
John Koleszar committed
572
    mbmi->uv_mode = DC_PRED;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
573
574
575
576
    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;
577
578
          const int j = idy * 2 + idx;
          const int blockmode = read_sb_mv_ref(r, mv_ref_p);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
579

Ronald S. Bultje's avatar
Ronald S. Bultje committed
580
581
          vp9_accum_mv_refs(cm, blockmode,
                            mbmi->mb_mode_context[mbmi->ref_frame[0]]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
582
          if (blockmode == NEARESTMV || blockmode == NEARMV) {
583
            const MV_REFERENCE_FRAME rf2 = mbmi->ref_frame[1];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
584
            vp9_append_sub8x8_mvs_for_idx(cm, xd, &nearest, &nearby, j, 0);
585
            if (rf2 > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
586
587
588
              vp9_append_sub8x8_mvs_for_idx(cm, xd,  &nearest_second,
                                            &nearby_second, j, 1);
          }
589

Ronald S. Bultje's avatar
Ronald S. Bultje committed
590
591
          switch (blockmode) {
            case NEWMV:
592
593
              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
594

Ronald S. Bultje's avatar
Ronald S. Bultje committed
595
              if (mbmi->ref_frame[1] > 0)
596
597
                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
598
599
600
601
602
603
604

#ifdef VPX_MODE_COUNT
              vp9_mv_cont_count[mv_contz][3]++;
#endif
              break;
            case NEARESTMV:
              blockmv.as_int = nearest.as_int;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
605
              if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
606
607
608
609
610
611
612
                secondmv.as_int = nearest_second.as_int;
#ifdef VPX_MODE_COUNT
              vp9_mv_cont_count[mv_contz][0]++;
#endif
              break;
            case NEARMV:
              blockmv.as_int = nearby.as_int;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
613
              if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
614
615
616
617
618
619
620
                secondmv.as_int = nearby_second.as_int;
#ifdef VPX_MODE_COUNT
              vp9_mv_cont_count[mv_contz][1]++;
#endif
              break;
            case ZEROMV:
              blockmv.as_int = 0;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
621
              if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
622
623
624
625
626
627
628
                secondmv.as_int = 0;
#ifdef VPX_MODE_COUNT
              vp9_mv_cont_count[mv_contz][2]++;
#endif
              break;
            default:
              break;
John Koleszar's avatar
John Koleszar committed
629
          }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
630
          mi->bmi[j].as_mv[0].as_int = blockmv.as_int;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
631
          if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
632
633
            mi->bmi[j].as_mv[1].as_int = secondmv.as_int;

634
635
636
637
          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
638
          mi->mbmi.mode = blockmode;
639
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
640
      }
John Koleszar's avatar
John Koleszar committed
641

Ronald S. Bultje's avatar
Ronald S. Bultje committed
642
643
644
645
646
647
648
649
650
651
      mv0->as_int = mi->bmi[3].as_mv[0].as_int;
      mv1->as_int = mi->bmi[3].as_mv[1].as_int;
    } else {
      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);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
652
          if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
653
654
655
656
657
658
659
660
661
662
663
664
            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);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
665
          if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
666
667
668
669
670
671
672
673
            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;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
674
          if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
675
676
677
678
            mv1->as_int = 0;
          break;

        case NEWMV:
679
680
          read_mv(r, &mv0->as_mv, &best_mv.as_mv, nmvc, &cm->fc.NMVcount,
                  xd->allow_high_precision_mv);
681
          if (mbmi->ref_frame[1] > 0)
682
683
            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
684
685
686
687
688
          break;
        default:
          assert(0);
          break;
      }
Scott LaVarnway's avatar
Scott LaVarnway committed
689
    }
John Koleszar's avatar
John Koleszar committed
690
  } else {
691
    mv0->as_int = 0;  // required for left and above block mv
692
    read_intra_block_modes(pbi, mi, r);
John Koleszar's avatar
John Koleszar committed
693
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
694
}
John Koleszar's avatar
John Koleszar committed
695

696
697
void vp9_prepare_read_mode_info(VP9D_COMP* pbi, vp9_reader *r) {
  VP9_COMMON *const cm = &pbi->common;
698
  int k;
699

700
  // TODO(jkoleszar): does this clear more than MBSKIP_CONTEXTS? Maybe remove.
Deb Mukherjee's avatar
Deb Mukherjee committed
701
  // vpx_memset(cm->fc.mbskip_probs, 0, sizeof(cm->fc.mbskip_probs));
702
703
  for (k = 0; k < MBSKIP_CONTEXTS; ++k)
    if (vp9_read(r, VP9_MODE_UPDATE_PROB))
704
      vp9_diff_update_prob(r, &cm->fc.mbskip_probs[k]);
705

706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
  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);
  }
757
}
758

759
void vp9_read_mode_info(VP9D_COMP* pbi, int mi_row, int mi_col, vp9_reader *r) {
760
  VP9_COMMON *const cm = &pbi->common;
761
  MACROBLOCKD *const xd = &pbi->mb;
762
  MODE_INFO *mi = xd->mode_info_context;
763
  const BLOCK_SIZE_TYPE bsize = mi->mbmi.sb_type;
764

765
766
767
768
  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);
769

770
  if (1) {
771
772
    const int bw = 1 << mi_width_log2(bsize);
    const int bh = 1 << mi_height_log2(bsize);
773
774
    const int y_mis = MIN(bh, cm->mi_rows - mi_row);
    const int x_mis = MIN(bw, cm->mi_cols - mi_col);
775
776
777
    const int mis = cm->mode_info_stride;
    int x, y;

778
779
    for (y = 0; y < y_mis; y++)
      for (x = !y; x < x_mis; x++)
780
781
        mi[y * mis + x] = *mi;
  }
782
}