vp9_decodemv.c 30 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 "vp9/decoder/vp9_treereader.h"
13
14
#include "vp9/common/vp9_entropymv.h"
#include "vp9/common/vp9_entropymode.h"
15
#include "vp9/common/vp9_reconinter.h"
16
#include "vp9/decoder/vp9_onyxd_int.h"
17
#include "vp9/common/vp9_findnearmv.h"
Ronald S. Bultje's avatar
Ronald S. Bultje committed
18
#include "vp9/common/vp9_common.h"
19
20
21
22
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_pred_common.h"
#include "vp9/common/vp9_entropy.h"
#include "vp9/decoder/vp9_decodemv.h"
23
#include "vp9/decoder/vp9_decodframe.h"
24
#include "vp9/common/vp9_mvref_common.h"
John Koleszar's avatar
John Koleszar committed
25
26
27
#if CONFIG_DEBUG
#include <assert.h>
#endif
28

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
40
static MB_PREDICTION_MODE read_intra_mode(vp9_reader *r, const vp9_prob *p) {
  MB_PREDICTION_MODE m = treed_read(r, vp9_intra_mode_tree, p);
41
42
43
  return m;
}

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

48
static void set_segment_id(VP9_COMMON *cm, MB_MODE_INFO *mbmi,
49
50
                           int mi_row, int mi_col, int segment_id) {
  const int mi_index = mi_row * cm->mi_cols + mi_col;
51
  const BLOCK_SIZE_TYPE sb_type = mbmi->sb_type;
52
53
54
55
56
57
58
59
60
61
  const int bw = 1 << mi_width_log2(sb_type);
  const int bh = 1 << mi_height_log2(sb_type);
  const int ymis = MIN(cm->mi_rows - mi_row, bh);
  const int xmis = MIN(cm->mi_cols - mi_col, bw);
  int x, y;

  for (y = 0; y < ymis; y++) {
    for (x = 0; x < xmis; x++) {
      const int index = mi_index + (y * cm->mi_cols + x);
      cm->last_frame_seg_map[index] = segment_id;
62
63
64
65
    }
  }
}

66
67
68
69
70
71
72
73
74
75
76
static TX_SIZE select_txfm_size(VP9_COMMON *cm, vp9_reader *r,
                                int allow_16x16, int allow_32x32) {
  TX_SIZE txfm_size = vp9_read(r, cm->prob_tx[0]);  // TX_4X4 or >TX_4X4
  if (txfm_size != TX_4X4 && allow_16x16) {
    txfm_size += vp9_read(r, cm->prob_tx[1]);       // TX_8X8 or >TX_8X8
    if (txfm_size != TX_8X8 && allow_32x32)
      txfm_size += vp9_read(r, cm->prob_tx[2]);     // TX_16X16 or >TX_16X16
  }
  return txfm_size;
}

77

78
static void kfread_modes(VP9D_COMP *pbi, MODE_INFO *m,
79
                         int mi_row, int mi_col,
80
                         vp9_reader *r) {
81
  VP9_COMMON *const cm = &pbi->common;
82
  MACROBLOCKD *const xd = &pbi->mb;
83
  const int mis = cm->mode_info_stride;
84
85
  m->mbmi.ref_frame = INTRA_FRAME;

86
  // Read segmentation map if it is being updated explicitly this frame
John Koleszar's avatar
John Koleszar committed
87
  m->mbmi.segment_id = 0;
88
89
  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
    m->mbmi.segment_id = read_mb_segid(r, xd);
90
    set_segment_id(cm, &m->mbmi, mi_row, mi_col, m->mbmi.segment_id);
John Koleszar's avatar
John Koleszar committed
91
92
  }

93
  m->mbmi.mb_skip_coeff = vp9_segfeature_active(xd, m->mbmi.segment_id,
94
95
                                                SEG_LVL_SKIP);
  if (!m->mbmi.mb_skip_coeff)
96
    m->mbmi.mb_skip_coeff = vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
John Koleszar's avatar
John Koleszar committed
97

98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
  if (cm->txfm_mode == TX_MODE_SELECT &&
      m->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
    const int allow_16x16 = m->mbmi.sb_type >= BLOCK_SIZE_MB16X16;
    const int allow_32x32 = m->mbmi.sb_type >= BLOCK_SIZE_SB32X32;
    m->mbmi.txfm_size = select_txfm_size(cm, r, allow_16x16, allow_32x32);
  } else if (cm->txfm_mode >= ALLOW_32X32 &&
             m->mbmi.sb_type >= BLOCK_SIZE_SB32X32) {
    m->mbmi.txfm_size = TX_32X32;
  } else if (cm->txfm_mode >= ALLOW_16X16 &&
             m->mbmi.sb_type >= BLOCK_SIZE_MB16X16) {
    m->mbmi.txfm_size = TX_16X16;
  } else if (cm->txfm_mode >= ALLOW_8X8 &&
             m->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
    m->mbmi.txfm_size = TX_8X8;
  } else {
    m->mbmi.txfm_size = TX_4X4;
  }

116
  // luma mode
117
  m->mbmi.ref_frame = INTRA_FRAME;
118
119
120
121
  if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
    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;
122
    m->mbmi.mode = read_intra_mode(r, cm->kf_y_mode_prob[A][L]);
123
  } else {
124
125
126
    int idx, idy;
    int bw = 1 << b_width_log2(m->mbmi.sb_type);
    int bh = 1 << b_height_log2(m->mbmi.sb_type);
127
128
129
130
131
132
133
134
135

    for (idy = 0; idy < 2; idy += bh) {
      for (idx = 0; idx < 2; idx += bw) {
        int ib = idy * 2 + idx;
        int k;
        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;
        m->bmi[ib].as_mode.first =
136
            read_intra_mode(r, cm->kf_y_mode_prob[A][L]);
137
138
139
140
141
142
        for (k = 1; k < bh; ++k)
          m->bmi[ib + k * 2].as_mode.first = m->bmi[ib].as_mode.first;
        for (k = 1; k < bw; ++k)
          m->bmi[ib + k].as_mode.first = m->bmi[ib].as_mode.first;
      }
    }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
143
    m->mbmi.mode = m->bmi[3].as_mode.first;
John Koleszar's avatar
John Koleszar committed
144
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
145

146
  m->mbmi.uv_mode = read_intra_mode(r, cm->kf_uv_mode_prob[m->mbmi.mode]);
Scott LaVarnway's avatar
Scott LaVarnway committed
147
}
John Koleszar's avatar
John Koleszar committed
148

149
150
static int read_mv_component(vp9_reader *r,
                             const nmv_component *mvcomp, int usehp) {
151

152
  int mag, d, fr, hp;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
153
154
155
  const int sign = vp9_read(r, mvcomp->sign);
  const int mv_class = treed_read(r, vp9_mv_class_tree, mvcomp->classes);

156
  // Integer part
Dmitry Kovalev's avatar
Dmitry Kovalev committed
157
  if (mv_class == MV_CLASS_0) {
158
    d = treed_read(r, vp9_mv_class0_tree, mvcomp->class0);
159
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
160
    int i;
161
    const int n = mv_class + CLASS0_BITS - 1;  // number of bits
Dmitry Kovalev's avatar
Dmitry Kovalev committed
162

163
    d = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
164
165
    for (i = 0; i < n; ++i)
      d |= vp9_read(r, mvcomp->bits[i]) << i;
166
167
  }

168
169
170
  // Fractional part
  fr = treed_read(r, vp9_mv_fp_tree,
                  mv_class == MV_CLASS_0 ? mvcomp->class0_fp[d] : mvcomp->fp);
171
172


173
174
175
176
  // 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;
177

178
179
180
  // result
  mag = vp9_get_mv_mag(mv_class, (d << 3) | (fr << 1) | hp) + 1;
  return sign ? -mag : mag;
181
182
}

183
static void update_nmv(vp9_reader *r, vp9_prob *const p,
184
                       const vp9_prob upd_p) {
185
  if (vp9_read(r, upd_p)) {
186
#ifdef LOW_PRECISION_MV_UPDATE
187
    *p = (vp9_read_literal(r, 7) << 1) | 1;
188
#else
189
    *p = (vp9_read_literal(r, 8));
190
191
192
193
#endif
  }
}

194
static void read_nmvprobs(vp9_reader *r, nmv_context *mvctx,
195
196
                          int usehp) {
  int i, j, k;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
197

198
#ifdef MV_GROUP_UPDATE
199
  if (!vp9_read_bit(r))
Dmitry Kovalev's avatar
Dmitry Kovalev committed
200
    return;
201
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
202
  for (j = 0; j < MV_JOINTS - 1; ++j)
203
    update_nmv(r, &mvctx->joints[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
204

205
  for (i = 0; i < 2; ++i) {
206
    update_nmv(r, &mvctx->comps[i].sign, VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
207
    for (j = 0; j < MV_CLASSES - 1; ++j)
208
      update_nmv(r, &mvctx->comps[i].classes[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
209
210

    for (j = 0; j < CLASS0_SIZE - 1; ++j)
211
      update_nmv(r, &mvctx->comps[i].class0[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
212
213

    for (j = 0; j < MV_OFFSET_BITS; ++j)
214
      update_nmv(r, &mvctx->comps[i].bits[j], VP9_NMV_UPDATE_PROB);
215
216
217
  }

  for (i = 0; i < 2; ++i) {
218
    for (j = 0; j < CLASS0_SIZE; ++j)
219
      for (k = 0; k < 3; ++k)
220
        update_nmv(r, &mvctx->comps[i].class0_fp[j][k], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
221
222

    for (j = 0; j < 3; ++j)
223
      update_nmv(r, &mvctx->comps[i].fp[j], VP9_NMV_UPDATE_PROB);
224
225
226
227
  }

  if (usehp) {
    for (i = 0; i < 2; ++i) {
228
229
      update_nmv(r, &mvctx->comps[i].class0_hp, VP9_NMV_UPDATE_PROB);
      update_nmv(r, &mvctx->comps[i].hp, VP9_NMV_UPDATE_PROB);
230
231
232
233
    }
  }
}

234
// Read the referncence frame
235
static MV_REFERENCE_FRAME read_ref_frame(VP9D_COMP *pbi,
236
                                         vp9_reader *r,
237
                                         int segment_id) {
John Koleszar's avatar
John Koleszar committed
238
  MV_REFERENCE_FRAME ref_frame;
239
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
240
241
  MACROBLOCKD *const xd = &pbi->mb;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
242
  int seg_ref_count = 0;
243
244
245
246
247
248
249
  const int seg_ref_active = vp9_segfeature_active(xd, segment_id,
                                                   SEG_LVL_REF_FRAME);

  const int intra = vp9_check_segref(xd, segment_id, INTRA_FRAME);
  const int last = vp9_check_segref(xd, segment_id, LAST_FRAME);
  const int golden = vp9_check_segref(xd, segment_id, GOLDEN_FRAME);
  const int altref = vp9_check_segref(xd, segment_id, ALTREF_FRAME);
John Koleszar's avatar
John Koleszar committed
250
251
252

  // If segment coding enabled does the segment allow for more than one
  // possible reference frame
253
254
  if (seg_ref_active)
    seg_ref_count = intra + last + golden + altref;
John Koleszar's avatar
John Koleszar committed
255
256
257

  // Segment reference frame features not available or allows for
  // multiple reference frame options
258
  if (!seg_ref_active || seg_ref_count > 1) {
John Koleszar's avatar
John Koleszar committed
259
260
261
262
    // Values used in prediction model coding
    MV_REFERENCE_FRAME pred_ref;

    // Get the context probability the prediction flag
Dmitry Kovalev's avatar
Dmitry Kovalev committed
263
    vp9_prob pred_prob = vp9_get_pred_prob(cm, xd, PRED_REF);
John Koleszar's avatar
John Koleszar committed
264
265

    // Read the prediction status flag
266
    unsigned char prediction_flag = vp9_read(r, pred_prob);
John Koleszar's avatar
John Koleszar committed
267
268

    // Store the prediction flag.
Paul Wilkins's avatar
Paul Wilkins committed
269
    vp9_set_pred_flag(xd, PRED_REF, prediction_flag);
John Koleszar's avatar
John Koleszar committed
270
271

    // Get the predicted reference frame.
Paul Wilkins's avatar
Paul Wilkins committed
272
    pred_ref = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
273
274
275
276

    // If correctly predicted then use the predicted value
    if (prediction_flag) {
      ref_frame = pred_ref;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
277
278
    } else {
      // decode the explicitly coded value
279
      vp9_prob mod_refprobs[PREDICTION_PROBS];
280
281
      vpx_memcpy(mod_refprobs, cm->mod_refprobs[pred_ref],
                 sizeof(mod_refprobs));
John Koleszar's avatar
John Koleszar committed
282
283
284
285

      // If segment coding enabled blank out options that cant occur by
      // setting the branch probability to 0.
      if (seg_ref_active) {
286
287
288
        mod_refprobs[INTRA_FRAME] *= intra;
        mod_refprobs[LAST_FRAME] *= last;
        mod_refprobs[GOLDEN_FRAME] *= golden * altref;
John Koleszar's avatar
John Koleszar committed
289
290
291
292
293
294
295
      }

      // Default to INTRA_FRAME (value 0)
      ref_frame = INTRA_FRAME;

      // Do we need to decode the Intra/Inter branch
      if (mod_refprobs[0])
296
        ref_frame = vp9_read(r, mod_refprobs[0]);
John Koleszar's avatar
John Koleszar committed
297
298
299
300
301
302
      else
        ref_frame++;

      if (ref_frame) {
        // Do we need to decode the Last/Gf_Arf branch
        if (mod_refprobs[1])
303
          ref_frame += vp9_read(r, mod_refprobs[1]);
304
        else
John Koleszar's avatar
John Koleszar committed
305
306
307
308
          ref_frame++;

        if (ref_frame > 1) {
          // Do we need to decode the GF/Arf branch
309
          if (mod_refprobs[2]) {
310
            ref_frame += vp9_read(r, mod_refprobs[2]);
311
          } else {
312
313
314
315
316
317
            if (seg_ref_active)
              ref_frame = pred_ref == GOLDEN_FRAME || !golden ? ALTREF_FRAME
                                                              : GOLDEN_FRAME;
            else
              ref_frame = pred_ref == GOLDEN_FRAME ? ALTREF_FRAME
                                                   : GOLDEN_FRAME;
John Koleszar's avatar
John Koleszar committed
318
          }
319
        }
John Koleszar's avatar
John Koleszar committed
320
      }
321
    }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
322
323
  } else {
    // Segment reference frame features are enabled
John Koleszar's avatar
John Koleszar committed
324
325
326
    // The reference frame for the mb is considered as correclty predicted
    // if it is signaled at the segment level for the purposes of the
    // common prediction model
Paul Wilkins's avatar
Paul Wilkins committed
327
328
    vp9_set_pred_flag(xd, PRED_REF, 1);
    ref_frame = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
329
330
  }

331
  return ref_frame;
332
}
John Koleszar's avatar
John Koleszar committed
333

334
335
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
336
}
John Koleszar's avatar
John Koleszar committed
337

Scott LaVarnway's avatar
Scott LaVarnway committed
338
#ifdef VPX_MODE_COUNT
339
unsigned int vp9_mv_cont_count[5][4] = {
John Koleszar's avatar
John Koleszar committed
340
341
342
343
344
  { 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
345
};
Scott LaVarnway's avatar
Scott LaVarnway committed
346
#endif
John Koleszar's avatar
John Koleszar committed
347

348
static void read_switchable_interp_probs(VP9_COMMON* const cm, vp9_reader *r) {
349
  int i, j;
350
351
352
353
354
355
356
357
358
359
360
361
362
  for (j = 0; j <= VP9_SWITCHABLE_FILTERS; ++j)
    for (i = 0; i < VP9_SWITCHABLE_FILTERS - 1; ++i) {
      if (vp9_read(r, VP9_DEF_UPDATE_PROB)) {
        cm->fc.switchable_interp_prob[j][i] =
            // vp9_read_prob(r);
            vp9_read_prob_diff_update(r, cm->fc.switchable_interp_prob[j][i]);
      }
    }
}

static void read_inter_mode_probs(VP9_COMMON *const cm, vp9_reader *r) {
  int i, j;
  for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
363
    for (j = 0; j < VP9_INTER_MODES - 1; ++j) {
364
365
366
367
368
369
      if (vp9_read(r, VP9_DEF_UPDATE_PROB)) {
        // cm->fc.inter_mode_probs[i][j] = vp9_read_prob(r);
        cm->fc.inter_mode_probs[i][j] =
            vp9_read_prob_diff_update(r, cm->fc.inter_mode_probs[i][j]);
      }
    }
370
}
John Koleszar's avatar
John Koleszar committed
371

372
373
374
375
376
377
378
379
static INLINE COMPPREDMODE_TYPE read_comp_pred_mode(vp9_reader *r) {
  COMPPREDMODE_TYPE mode = vp9_read_bit(r);
  if (mode)
     mode += vp9_read_bit(r);
  return mode;
}

static void mb_mode_mv_init(VP9D_COMP *pbi, vp9_reader *r) {
380
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
381

382
  if (cm->frame_type != KEY_FRAME) {
383
384
    nmv_context *const nmvc = &pbi->common.fc.nmvc;
    MACROBLOCKD *const xd = &pbi->mb;
385
    int i, j;
386

387
388
    read_inter_mode_probs(cm, r);

389
    if (cm->mcomp_filter_type == SWITCHABLE)
390
      read_switchable_interp_probs(cm, r);
391

392
393
394
395
    // Baseline probabilities for decoding reference frame
    cm->prob_intra_coded = vp9_read_prob(r);
    cm->prob_last_coded  = vp9_read_prob(r);
    cm->prob_gf_coded    = vp9_read_prob(r);
John Koleszar's avatar
John Koleszar committed
396
397
398

    // Computes a modified set of probabilities for use when reference
    // frame prediction fails.
Paul Wilkins's avatar
Paul Wilkins committed
399
    vp9_compute_mod_refprobs(cm);
John Koleszar's avatar
John Koleszar committed
400

401
402
    cm->comp_pred_mode = read_comp_pred_mode(r);
    if (cm->comp_pred_mode == HYBRID_PREDICTION)
John Koleszar's avatar
John Koleszar committed
403
      for (i = 0; i < COMP_PRED_CONTEXTS; i++)
404
        cm->prob_comppred[i] = vp9_read_prob(r);
John Koleszar's avatar
John Koleszar committed
405

406
    // VP9_INTRA_MODES
407
408
409
410
411
412
    for (j = 0; j < BLOCK_SIZE_GROUPS; j++) {
      for (i = 0; i < VP9_INTRA_MODES - 1; ++i) {
        if (vp9_read(r, VP9_DEF_UPDATE_PROB)) {
          cm->fc.y_mode_prob[j][i] =
              vp9_read_prob_diff_update(r, cm->fc.y_mode_prob[j][i]);
        }
413
414
415
416
417
      }
    }
    for (j = 0; j < NUM_PARTITION_CONTEXTS; ++j) {
      for (i = 0; i < PARTITION_TYPES - 1; ++i) {
        if (vp9_read(r, VP9_DEF_UPDATE_PROB)) {
418
419
420
          cm->fc.partition_prob[INTER_FRAME][j][i] =
              vp9_read_prob_diff_update(r,
                  cm->fc.partition_prob[INTER_FRAME][j][i]);
421
422
423
        }
      }
    }
424

425
    read_nmvprobs(r, nmvc, xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
426
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
427
}
John Koleszar's avatar
John Koleszar committed
428

429
430
431
// This function either reads the segment id for the current macroblock from
// the bitstream or if the value is temporally predicted asserts the predicted
// value
432
static int read_mb_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
433
                              vp9_reader *r) {
434
  VP9_COMMON *const cm = &pbi->common;
435
  MACROBLOCKD *const xd = &pbi->mb;
436
437
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
John Koleszar's avatar
John Koleszar committed
438

439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
  if (!xd->segmentation_enabled)
    return 0;  // Default for disabled segmentation

  if (xd->update_mb_segmentation_map) {
    int segment_id;

    if (cm->temporal_update) {
      // Temporal coding of the segment id for this mb is enabled.
      // Get the context based probability for reading the
      // prediction status flag
      const vp9_prob pred_prob = vp9_get_pred_prob(cm, xd, PRED_SEG_ID);
      const int pred_flag = vp9_read(r, pred_prob);
      vp9_set_pred_flag(xd, PRED_SEG_ID, pred_flag);

      // If the value is flagged as correctly predicted
      // then use the predicted value, otherwise decode it explicitly
455
456
      segment_id = pred_flag ? vp9_get_pred_mi_segid(cm, mbmi->sb_type,
                                                     mi_row, mi_col)
Paul Wilkins's avatar
Paul Wilkins committed
457
                             : read_mb_segid(r, xd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
458
    } else {
459
      segment_id = read_mb_segid(r, xd);  // Normal unpredicted coding mode
460
    }
461

462
    set_segment_id(cm, mbmi, mi_row, mi_col, segment_id);  // Side effect
463
    return segment_id;
John Koleszar's avatar
John Koleszar committed
464
  } else {
465
    return vp9_get_pred_mi_segid(cm, mbmi->sb_type, mi_row, mi_col);
John Koleszar's avatar
John Koleszar committed
466
  }
467
}
468

Dmitry Kovalev's avatar
Dmitry Kovalev committed
469
470
471
472
473
474
475
476
477
478
479

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

480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
static INLINE void decode_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_nmv_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_increment_nmv(&diff, ref, counts, usehp);

  mv->row = diff.row + ref->row;
  mv->col = diff.col + ref->col;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
498
499
}

500
static INLINE INTERPOLATIONFILTERTYPE read_switchable_filter_type(
501
502
    VP9D_COMP *pbi, vp9_reader *r) {
  const int index = treed_read(r, vp9_switchable_interp_tree,
503
504
                               vp9_get_pred_probs(&pbi->common, &pbi->mb,
                                                  PRED_SWITCHABLE_INTERP));
505
506
507
  ++pbi->common.fc.switchable_interp_count
                [vp9_get_pred_context(
                    &pbi->common, &pbi->mb, PRED_SWITCHABLE_INTERP)][index];
508
509
510
  return vp9_switchable_interp[index];
}

511
static void read_mb_modes_mv(VP9D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
512
                             int mi_row, int mi_col,
513
                             vp9_reader *r) {
514
  VP9_COMMON *const cm = &pbi->common;
515
  nmv_context *const nmvc = &cm->fc.nmvc;
516
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
517

518
519
  int_mv *const mv0 = &mbmi->mv[0];
  int_mv *const mv1 = &mbmi->mv[1];
520
521
522
  BLOCK_SIZE_TYPE bsize = mi->mbmi.sb_type;
  int bw = 1 << b_width_log2(bsize);
  int bh = 1 << b_height_log2(bsize);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
523

524
  int mb_to_left_edge, mb_to_right_edge, mb_to_top_edge, mb_to_bottom_edge;
525
  int j, idx, idy;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
526

John Koleszar's avatar
John Koleszar committed
527
528
  mbmi->need_to_clamp_mvs = 0;
  mbmi->need_to_clamp_secondmv = 0;
529
  mbmi->second_ref_frame = NONE;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
530

531
532
533
534
  // 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
535
536
537
  // 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
538
539
  set_mi_row_col(cm, xd, mi_row, 1 << mi_height_log2(bsize),
                         mi_col, 1 << mi_width_log2(bsize));
540

541
542
  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
543
544
  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
545
546

  // Read the macroblock segment id.
547
  mbmi->segment_id = read_mb_segment_id(pbi, mi_row, mi_col, r);
John Koleszar's avatar
John Koleszar committed
548

549
550
551
  mbmi->mb_skip_coeff = vp9_segfeature_active(xd, mbmi->segment_id,
                                              SEG_LVL_SKIP);
  if (!mbmi->mb_skip_coeff)
552
    mbmi->mb_skip_coeff = vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
John Koleszar's avatar
John Koleszar committed
553
554

  // Read the reference frame
555
  mbmi->ref_frame = read_ref_frame(pbi, r, mbmi->segment_id);
556

557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
  if (cm->txfm_mode == TX_MODE_SELECT &&
      (mbmi->mb_skip_coeff == 0 || mbmi->ref_frame == INTRA_FRAME) &&
      bsize >= BLOCK_SIZE_SB8X8) {
    const int allow_16x16 = bsize >= BLOCK_SIZE_MB16X16;
    const int allow_32x32 = bsize >= BLOCK_SIZE_SB32X32;
    mbmi->txfm_size = select_txfm_size(cm, r, allow_16x16, allow_32x32);
  } else if (bsize >= BLOCK_SIZE_SB32X32 &&
             cm->txfm_mode >= ALLOW_32X32) {
    mbmi->txfm_size = TX_32X32;
  } else if (cm->txfm_mode >= ALLOW_16X16 &&
             bsize >= BLOCK_SIZE_MB16X16) {
    mbmi->txfm_size = TX_16X16;
  } else if (cm->txfm_mode >= ALLOW_8X8 && (bsize >= BLOCK_SIZE_SB8X8)) {
    mbmi->txfm_size = TX_8X8;
  } else {
    mbmi->txfm_size = TX_4X4;
  }

John Koleszar's avatar
John Koleszar committed
575
576
577
578
  // If reference frame is an Inter frame
  if (mbmi->ref_frame) {
    int_mv nearest, nearby, best_mv;
    int_mv nearest_second, nearby_second, best_mv_second;
579
    vp9_prob mv_ref_p[VP9_INTER_MODES - 1];
580
    const MV_REFERENCE_FRAME ref_frame = mbmi->ref_frame;
581
582

    {
583
584
585
586
587
#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
588
589
      vp9_find_mv_refs(cm, xd, mi, xd->prev_mode_info_context, ref_frame,
                       mbmi->ref_mvs[ref_frame], cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
590

591
      vp9_mv_ref_probs(cm, mv_ref_p, mbmi->mb_mode_context[ref_frame]);
592

593
      // If the segment level skip mode enabled
Paul Wilkins's avatar
Paul Wilkins committed
594
595
      if (vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP)) {
        mbmi->mode = ZEROMV;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
596
597
      } else if (bsize >= BLOCK_SIZE_SB8X8) {
        mbmi->mode = read_sb_mv_ref(r, mv_ref_p);
598
        vp9_accum_mv_refs(cm, mbmi->mode, mbmi->mb_mode_context[ref_frame]);
599
600
      }

Ronald S. Bultje's avatar
Ronald S. Bultje committed
601
      if (bsize < BLOCK_SIZE_SB8X8 || mbmi->mode != ZEROMV) {
602
603
604
605
        vp9_find_best_ref_mvs(xd,
                              mbmi->ref_mvs[ref_frame],
                              &nearest, &nearby);

606
        best_mv.as_int = mbmi->ref_mvs[ref_frame][0].as_int;
607
      }
608

609
610
611
612
613
614
#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
615
    }
John Koleszar's avatar
John Koleszar committed
616

617
618
619
    mbmi->interp_filter = cm->mcomp_filter_type == SWITCHABLE
                              ? read_switchable_filter_type(pbi, r)
                              : cm->mcomp_filter_type;
620

John Koleszar's avatar
John Koleszar committed
621
622
    if (cm->comp_pred_mode == COMP_PREDICTION_ONLY ||
        (cm->comp_pred_mode == HYBRID_PREDICTION &&
623
         vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_COMP)))) {
John Koleszar's avatar
John Koleszar committed
624
625
626
627
628
629
630
631
632
633
      /* Since we have 3 reference frames, we can only have 3 unique
       * combinations of combinations of 2 different reference frames
       * (A-G, G-L or A-L). In the bitstream, we use this to simply
       * derive the second reference frame from the first reference
       * frame, by saying it's the next one in the enumerator, and
       * if that's > n_refs, then the second reference frame is the
       * first one in the enumerator. */
      mbmi->second_ref_frame = mbmi->ref_frame + 1;
      if (mbmi->second_ref_frame == 4)
        mbmi->second_ref_frame = 1;
634
      if (mbmi->second_ref_frame > 0) {
635
        const MV_REFERENCE_FRAME second_ref_frame = mbmi->second_ref_frame;
636

637
        vp9_find_mv_refs(cm, xd, mi, xd->prev_mode_info_context,
638
                         second_ref_frame, mbmi->ref_mvs[second_ref_frame],
Paul Wilkins's avatar
Paul Wilkins committed
639
                         cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
640

Ronald S. Bultje's avatar
Ronald S. Bultje committed
641
        if (bsize < BLOCK_SIZE_SB8X8 || mbmi->mode != ZEROMV) {
642
          vp9_find_best_ref_mvs(xd,
643
                                mbmi->ref_mvs[second_ref_frame],
644
645
                                &nearest_second,
                                &nearby_second);
646
          best_mv_second.as_int = mbmi->ref_mvs[second_ref_frame][0].as_int;
647
        }
648
      }
John Koleszar's avatar
John Koleszar committed
649
    }
650

John Koleszar's avatar
John Koleszar committed
651
    mbmi->uv_mode = DC_PRED;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
    if (mbmi->sb_type < BLOCK_SIZE_SB8X8) {
      mbmi->need_to_clamp_mvs = 0;
      for (idy = 0; idy < 2; idy += bh) {
        for (idx = 0; idx < 2; idx += bw) {
          int_mv blockmv, secondmv;
          int blockmode;
          int i;
          j = idy * 2 + idx;

          blockmode = read_sb_mv_ref(r, mv_ref_p);
          vp9_accum_mv_refs(cm, blockmode, mbmi->mb_mode_context[ref_frame]);
          if (blockmode == NEARESTMV || blockmode == NEARMV) {
            MV_REFERENCE_FRAME rf2 = mbmi->second_ref_frame;
            vp9_append_sub8x8_mvs_for_idx(cm, xd, &nearest, &nearby, j, 0);
            if (rf2 > 0) {
              vp9_append_sub8x8_mvs_for_idx(cm, xd,  &nearest_second,
                                            &nearby_second, j, 1);
669
            }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
670
          }
671

Ronald S. Bultje's avatar
Ronald S. Bultje committed
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
          switch (blockmode) {
            case NEWMV:
              decode_mv(r, &blockmv.as_mv, &best_mv.as_mv, nmvc,
                         &cm->fc.NMVcount, xd->allow_high_precision_mv);

              if (mbmi->second_ref_frame > 0)
                decode_mv(r, &secondmv.as_mv, &best_mv_second.as_mv, nmvc,
                          &cm->fc.NMVcount, xd->allow_high_precision_mv);

#ifdef VPX_MODE_COUNT
              vp9_mv_cont_count[mv_contz][3]++;
#endif
              break;
            case NEARESTMV:
              blockmv.as_int = nearest.as_int;
              if (mbmi->second_ref_frame > 0)
                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;
              if (mbmi->second_ref_frame > 0)
                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;
              if (mbmi->second_ref_frame > 0)
                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
711
          }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
712
713
714
715
716
717
718
719
720
          mi->bmi[j].as_mv[0].as_int = blockmv.as_int;
          if (mbmi->second_ref_frame > 0)
            mi->bmi[j].as_mv[1].as_int = secondmv.as_int;

          for (i = 1; i < bh; ++i)
            vpx_memcpy(&mi->bmi[j + i * 2], &mi->bmi[j], sizeof(mi->bmi[j]));
          for (i = 1; i < bw; ++i)
            vpx_memcpy(&mi->bmi[j + i], &mi->bmi[j], sizeof(mi->bmi[j]));
          mi->mbmi.mode = blockmode;
721
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
722
      }
John Koleszar's avatar
John Koleszar committed
723

Ronald S. Bultje's avatar
Ronald S. Bultje committed
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
757
758
759
760
761
762
763
764
      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);
          if (mbmi->second_ref_frame > 0)
            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);
          if (mbmi->second_ref_frame > 0)
            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;
          if (mbmi->second_ref_frame > 0)
            mv1->as_int = 0;
          break;

        case NEWMV:
          decode_mv(r, &mv0->as_mv, &best_mv.as_mv, nmvc, &cm->fc.NMVcount,
                    xd->allow_high_precision_mv);
          mbmi->need_to_clamp_mvs = check_mv_bounds(mv0,
                                                    mb_to_left_edge,
765
766
767
                                                    mb_to_right_edge,
                                                    mb_to_top_edge,
                                                    mb_to_bottom_edge);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
768
769
770
771
772
773
774
775
776
777
778
779

          if (mbmi->second_ref_frame > 0) {
            decode_mv(r, &mv1->as_mv, &best_mv_second.as_mv, nmvc,
                      &cm->fc.NMVcount, xd->allow_high_precision_mv);
            mbmi->need_to_clamp_secondmv = check_mv_bounds(mv1,
                                                             mb_to_left_edge,
                                                             mb_to_right_edge,
                                                             mb_to_top_edge,
                                                             mb_to_bottom_edge);
          }
          break;
        default:
John Koleszar's avatar
John Koleszar committed
780
#if CONFIG_DEBUG
Ronald S. Bultje's avatar
Ronald S. Bultje committed
781
          assert(0);
John Koleszar's avatar
John Koleszar committed
782
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
783
784
          break;
      }
Scott LaVarnway's avatar
Scott LaVarnway committed
785
    }
John Koleszar's avatar
John Koleszar committed
786
  } else {
787
788
    // required for left and above block mv
    mv0->as_int = 0;
John Koleszar's avatar
John Koleszar committed
789

790
    if (bsize >= BLOCK_SIZE_SB8X8) {
791
792
793
794
795
      const BLOCK_SIZE_TYPE bsize = xd->mode_info_context->mbmi.sb_type;
      const int bwl = b_width_log2(bsize), bhl = b_height_log2(bsize);
      const int bsl = MIN(bwl, bhl);
      mbmi->mode = read_intra_mode(r, cm->fc.y_mode_prob[MIN(3, bsl)]);
      cm->fc.y_mode_counts[MIN(3, bsl)][mbmi->mode]++;
796
    } else {
797
798
799
      int idx, idy;
      for (idy = 0; idy < 2; idy += bh) {
        for (idx = 0; idx < 2; idx += bw) {
800
          int ib = idy * 2 + idx, k;
801
          int m = read_intra_mode(r, cm->fc.y_mode_prob[0]);
802
          mi->bmi[ib].as_mode.first = m;
803
          cm->fc.y_mode_counts[0][m]++;
804
805
806
807
          for (k = 1; k < bh; ++k)
            mi->bmi[ib + k * 2].as_mode.first = m;
          for (k = 1; k < bw; ++k)
            mi->bmi[ib + k].as_mode.first = m;
808
809
        }
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
810
      mbmi->mode = mi->bmi[3].as_mode.first;
John Koleszar's avatar
John Koleszar committed
811
    }
John Koleszar's avatar
John Koleszar committed
812

813
    mbmi->uv_mode = read_intra_mode(r, cm->fc.uv_mode_prob[mbmi->mode]);
Jingning Han's avatar
Jingning Han committed
814
    cm->fc.uv_mode_counts[mbmi->mode][mbmi->uv_mode]++;
John Koleszar's avatar
John Koleszar committed
815
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
816
}
John Koleszar's avatar
John Koleszar committed
817

818
void vp9_decode_mode_mvs_init(VP9D_COMP* const pbi, vp9_reader *r) {
819
  VP9_COMMON *cm = &pbi->common;
820
  int k;
821

822
  // TODO(jkoleszar): does this clear more than MBSKIP_CONTEXTS? Maybe remove.
823
  vpx_memset(cm->mbskip_pred_probs, 0, sizeof(cm->mbskip_pred_probs));
824
825
  for (k = 0; k < MBSKIP_CONTEXTS; ++k)
    cm->mbskip_pred_probs[k] = vp9_read_prob(r);
826

827
  mb_mode_mv_init(pbi, r);
828
}
829

830
831
void vp9_decode_mb_mode_mv(VP9D_COMP* const pbi,
                           MACROBLOCKD* const xd,
832
833
                           int mi_row,
                           int mi_col,
834
                           vp9_reader *r) {
835
  VP9_COMMON *const cm = &pbi->common;
836
  MODE_INFO *mi = xd->mode_info_context;
837
  MB_MODE_INFO *const mbmi = &mi->mbmi;
838

839
  if (cm->frame_type == KEY_FRAME) {
840
    kfread_modes(pbi, mi, mi_row, mi_col, r);
841
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
842
    read_mb_modes_mv(pbi, mi, &mi->mbmi, mi_row, mi_col, r);
843
  }
844

845
846
847
848
849
  if (1) {
    const int bw = 1 << mi_width_log2(mbmi->sb_type);
    const int bh = 1 << mi_height_log2(mbmi->sb_type);
    const int y_mis = MIN(bh, cm->mi_rows - mi_row);
    const int x_mis = MIN(bw, cm->mi_cols - mi_col);
850
851
852
    const int mis = cm->mode_info_stride;
    int x, y;

853
854
    for (y = 0; y < y_mis; y++)
      for (x = !y; x < x_mis; x++)
855
856
        mi[y * mis + x] = *mi;
  }
857
}