vp9_decodemv.c 31.8 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5 6
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
7
 *  in the file PATENTS.  All contributing project authors may
8
 *  be found in the AUTHORS file in the root of the source tree.
John Koleszar's avatar
John Koleszar committed
9 10 11
 */


12
#include "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 23
#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"
#include "vp9/common/vp9_mvref_common.h"
John Koleszar's avatar
John Koleszar committed
24 25 26
#if CONFIG_DEBUG
#include <assert.h>
#endif
27

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

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

38 39
static B_PREDICTION_MODE read_bmode(vp9_reader *r, const vp9_prob *p) {
  B_PREDICTION_MODE m = treed_read(r, vp9_bmode_tree, p);
40 41 42
  return m;
}

43 44
static B_PREDICTION_MODE read_kf_bmode(vp9_reader *r, const vp9_prob *p) {
  return (B_PREDICTION_MODE)treed_read(r, vp9_kf_bmode_tree, p);
Scott LaVarnway's avatar
Scott LaVarnway committed
45 46
}

47 48
static MB_PREDICTION_MODE read_ymode(vp9_reader *r, const vp9_prob *p) {
  return (MB_PREDICTION_MODE)treed_read(r, vp9_ymode_tree, p);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
49
}
Scott LaVarnway's avatar
Scott LaVarnway committed
50

51 52
static MB_PREDICTION_MODE read_sb_ymode(vp9_reader *r, const vp9_prob *p) {
  return (MB_PREDICTION_MODE)treed_read(r, vp9_sb_ymode_tree, p);
53 54
}

55 56
static MB_PREDICTION_MODE read_kf_sb_ymode(vp9_reader *r, const vp9_prob *p) {
  return (MB_PREDICTION_MODE)treed_read(r, vp9_uv_mode_tree, p);
Scott LaVarnway's avatar
Scott LaVarnway committed
57 58
}

59 60
static MB_PREDICTION_MODE read_kf_mb_ymode(vp9_reader *r, const vp9_prob *p) {
  return (MB_PREDICTION_MODE)treed_read(r, vp9_kf_ymode_tree, p);
Scott LaVarnway's avatar
Scott LaVarnway committed
61 62
}

63 64
static MB_PREDICTION_MODE read_uv_mode(vp9_reader *r, const vp9_prob *p) {
  return (MB_PREDICTION_MODE)treed_read(r, vp9_uv_mode_tree, p);
Scott LaVarnway's avatar
Scott LaVarnway committed
65 66
}

67
static int read_mb_segid(vp9_reader *r, MACROBLOCKD *xd) {
68
  return treed_read(r, vp9_segment_tree, xd->mb_segment_tree_probs);
Scott LaVarnway's avatar
Scott LaVarnway committed
69
}
70

71
static void set_segment_id(VP9_COMMON *cm, MB_MODE_INFO *mbmi,
72 73
                           int mi_row, int mi_col, int segment_id) {
  const int mi_index = mi_row * cm->mi_cols + mi_col;
74
  const BLOCK_SIZE_TYPE sb_type = mbmi->sb_type;
75 76 77 78 79 80 81 82 83 84
  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;
85 86 87 88
    }
  }
}

89 90 91 92 93 94 95 96 97 98 99
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;
}

100

101
static void kfread_modes(VP9D_COMP *pbi, MODE_INFO *m,
102
                         int mi_row, int mi_col,
103
                         vp9_reader *r) {
104
  VP9_COMMON *const cm = &pbi->common;
105
  MACROBLOCKD *const xd = &pbi->mb;
106
  const int mis = cm->mode_info_stride;
107 108
  m->mbmi.ref_frame = INTRA_FRAME;

109
  // Read segmentation map if it is being updated explicitly this frame
John Koleszar's avatar
John Koleszar committed
110
  m->mbmi.segment_id = 0;
111 112
  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
    m->mbmi.segment_id = read_mb_segid(r, xd);
113
    set_segment_id(cm, &m->mbmi, mi_row, mi_col, m->mbmi.segment_id);
John Koleszar's avatar
John Koleszar committed
114 115
  }

116
  m->mbmi.mb_skip_coeff = vp9_segfeature_active(xd, m->mbmi.segment_id,
117 118
                                                SEG_LVL_SKIP);
  if (!m->mbmi.mb_skip_coeff)
119
    m->mbmi.mb_skip_coeff = vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
John Koleszar's avatar
John Koleszar committed
120

121
  // luma mode
122 123 124 125 126 127
  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;
    m->mbmi.mode = read_kf_bmode(r, cm->kf_bmode_prob[A][L]);
  } else {
128
     m->mbmi.mode = I4X4_PRED;
129
  }
130

John Koleszar's avatar
John Koleszar committed
131
  m->mbmi.ref_frame = INTRA_FRAME;
Paul Wilkins's avatar
Paul Wilkins committed
132

133
  if (m->mbmi.sb_type < BLOCK_SIZE_SB8X8) {
134 135 136
    int idx, idy;
    int bw = 1 << b_width_log2(m->mbmi.sb_type);
    int bh = 1 << b_height_log2(m->mbmi.sb_type);
137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152

    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 =
            read_kf_bmode(r, cm->kf_bmode_prob[A][L]);
        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;
      }
    }
John Koleszar's avatar
John Koleszar committed
153
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
154

Jingning Han's avatar
Jingning Han committed
155
  m->mbmi.uv_mode = read_uv_mode(r, cm->kf_uv_mode_prob[m->mbmi.mode]);
156

Dmitry Kovalev's avatar
Dmitry Kovalev committed
157
  if (cm->txfm_mode == TX_MODE_SELECT &&
158
    !(m->mbmi.mb_skip_coeff && m->mbmi.ref_frame != INTRA_FRAME)
159
      && m->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
160
    const int allow_16x16 = m->mbmi.sb_type >= BLOCK_SIZE_MB16X16;
161 162
    const int allow_32x32 = m->mbmi.sb_type >= BLOCK_SIZE_SB32X32;
    m->mbmi.txfm_size = select_txfm_size(cm, r, allow_16x16, allow_32x32);
163 164
  } else if (cm->txfm_mode >= ALLOW_32X32 &&
             m->mbmi.sb_type >= BLOCK_SIZE_SB32X32) {
165
    m->mbmi.txfm_size = TX_32X32;
166 167 168
  } else if (cm->txfm_mode >= ALLOW_16X16 &&
             m->mbmi.sb_type >= BLOCK_SIZE_MB16X16 &&
             m->mbmi.mode <= TM_PRED) {
169
    m->mbmi.txfm_size = TX_16X16;
170
  } else if (cm->txfm_mode >= ALLOW_8X8 &&
171
             m->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
172 173 174 175
    m->mbmi.txfm_size = TX_8X8;
  } else {
    m->mbmi.txfm_size = TX_4X4;
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
176
}
John Koleszar's avatar
John Koleszar committed
177

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

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

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

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

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


202 203 204 205
  // 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;
206

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

212
static void update_nmv(vp9_reader *r, vp9_prob *const p,
213
                       const vp9_prob upd_p) {
214
  if (vp9_read(r, upd_p)) {
215
#ifdef LOW_PRECISION_MV_UPDATE
216
    *p = (vp9_read_literal(r, 7) << 1) | 1;
217
#else
218
    *p = (vp9_read_literal(r, 8));
219 220 221 222
#endif
  }
}

223
static void read_nmvprobs(vp9_reader *r, nmv_context *mvctx,
224 225
                          int usehp) {
  int i, j, k;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
226

227
#ifdef MV_GROUP_UPDATE
228
  if (!vp9_read_bit(r))
Dmitry Kovalev's avatar
Dmitry Kovalev committed
229
    return;
230
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
231
  for (j = 0; j < MV_JOINTS - 1; ++j)
232
    update_nmv(r, &mvctx->joints[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
233

234
  for (i = 0; i < 2; ++i) {
235
    update_nmv(r, &mvctx->comps[i].sign, VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
236
    for (j = 0; j < MV_CLASSES - 1; ++j)
237
      update_nmv(r, &mvctx->comps[i].classes[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
238 239

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

    for (j = 0; j < MV_OFFSET_BITS; ++j)
243
      update_nmv(r, &mvctx->comps[i].bits[j], VP9_NMV_UPDATE_PROB);
244 245 246
  }

  for (i = 0; i < 2; ++i) {
247
    for (j = 0; j < CLASS0_SIZE; ++j)
248
      for (k = 0; k < 3; ++k)
249
        update_nmv(r, &mvctx->comps[i].class0_fp[j][k], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
250 251

    for (j = 0; j < 3; ++j)
252
      update_nmv(r, &mvctx->comps[i].fp[j], VP9_NMV_UPDATE_PROB);
253 254 255 256
  }

  if (usehp) {
    for (i = 0; i < 2; ++i) {
257 258
      update_nmv(r, &mvctx->comps[i].class0_hp, VP9_NMV_UPDATE_PROB);
      update_nmv(r, &mvctx->comps[i].hp, VP9_NMV_UPDATE_PROB);
259 260 261 262
    }
  }
}

263
// Read the referncence frame
264
static MV_REFERENCE_FRAME read_ref_frame(VP9D_COMP *pbi,
265
                                         vp9_reader *r,
266
                                         int segment_id) {
John Koleszar's avatar
John Koleszar committed
267
  MV_REFERENCE_FRAME ref_frame;
268
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
269 270
  MACROBLOCKD *const xd = &pbi->mb;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
271
  int seg_ref_count = 0;
272 273 274 275 276 277 278
  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
279 280 281

  // If segment coding enabled does the segment allow for more than one
  // possible reference frame
282 283
  if (seg_ref_active)
    seg_ref_count = intra + last + golden + altref;
John Koleszar's avatar
John Koleszar committed
284 285 286

  // Segment reference frame features not available or allows for
  // multiple reference frame options
287
  if (!seg_ref_active || seg_ref_count > 1) {
John Koleszar's avatar
John Koleszar committed
288 289 290 291
    // 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
292
    vp9_prob pred_prob = vp9_get_pred_prob(cm, xd, PRED_REF);
John Koleszar's avatar
John Koleszar committed
293 294

    // Read the prediction status flag
295
    unsigned char prediction_flag = vp9_read(r, pred_prob);
John Koleszar's avatar
John Koleszar committed
296 297

    // Store the prediction flag.
Paul Wilkins's avatar
Paul Wilkins committed
298
    vp9_set_pred_flag(xd, PRED_REF, prediction_flag);
John Koleszar's avatar
John Koleszar committed
299 300

    // Get the predicted reference frame.
Paul Wilkins's avatar
Paul Wilkins committed
301
    pred_ref = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
302 303 304 305

    // If correctly predicted then use the predicted value
    if (prediction_flag) {
      ref_frame = pred_ref;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
306 307
    } else {
      // decode the explicitly coded value
308
      vp9_prob mod_refprobs[PREDICTION_PROBS];
309 310
      vpx_memcpy(mod_refprobs, cm->mod_refprobs[pred_ref],
                 sizeof(mod_refprobs));
John Koleszar's avatar
John Koleszar committed
311 312 313 314

      // If segment coding enabled blank out options that cant occur by
      // setting the branch probability to 0.
      if (seg_ref_active) {
315 316 317
        mod_refprobs[INTRA_FRAME] *= intra;
        mod_refprobs[LAST_FRAME] *= last;
        mod_refprobs[GOLDEN_FRAME] *= golden * altref;
John Koleszar's avatar
John Koleszar committed
318 319 320 321 322 323 324
      }

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

      // Do we need to decode the Intra/Inter branch
      if (mod_refprobs[0])
325
        ref_frame = vp9_read(r, mod_refprobs[0]);
John Koleszar's avatar
John Koleszar committed
326 327 328 329 330 331
      else
        ref_frame++;

      if (ref_frame) {
        // Do we need to decode the Last/Gf_Arf branch
        if (mod_refprobs[1])
332
          ref_frame += vp9_read(r, mod_refprobs[1]);
333
        else
John Koleszar's avatar
John Koleszar committed
334 335 336 337
          ref_frame++;

        if (ref_frame > 1) {
          // Do we need to decode the GF/Arf branch
338
          if (mod_refprobs[2]) {
339
            ref_frame += vp9_read(r, mod_refprobs[2]);
340
          } else {
341 342 343 344 345 346
            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
347
          }
348
        }
John Koleszar's avatar
John Koleszar committed
349
      }
350
    }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
351 352
  } else {
    // Segment reference frame features are enabled
John Koleszar's avatar
John Koleszar committed
353 354 355
    // 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
356 357
    vp9_set_pred_flag(xd, PRED_REF, 1);
    ref_frame = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
358 359
  }

360
  return ref_frame;
361
}
John Koleszar's avatar
John Koleszar committed
362

363 364
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
365
}
John Koleszar's avatar
John Koleszar committed
366

367 368
static MB_PREDICTION_MODE read_mv_ref(vp9_reader *r, const vp9_prob *p) {
  return (MB_PREDICTION_MODE) treed_read(r, vp9_mv_ref_tree, p);
John Koleszar's avatar
John Koleszar committed
369 370
}

371
static B_PREDICTION_MODE read_sub_mv_ref(vp9_reader *r, const vp9_prob *p) {
372
  return (B_PREDICTION_MODE) treed_read(r, vp9_sub_mv_ref_tree, p);
John Koleszar's avatar
John Koleszar committed
373
}
Scott LaVarnway's avatar
Scott LaVarnway committed
374 375

#ifdef VPX_MODE_COUNT
376
unsigned int vp9_mv_cont_count[5][4] = {
John Koleszar's avatar
John Koleszar committed
377 378 379 380 381
  { 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
382
};
Scott LaVarnway's avatar
Scott LaVarnway committed
383
#endif
John Koleszar's avatar
John Koleszar committed
384

385
static void read_switchable_interp_probs(VP9D_COMP* const pbi, vp9_reader *r) {
386
  VP9_COMMON *const cm = &pbi->common;
387
  int i, j;
388 389 390
  for (j = 0; j < VP9_SWITCHABLE_FILTERS + 1; ++j)
    for (i = 0; i < VP9_SWITCHABLE_FILTERS - 1; ++i)
      cm->fc.switchable_interp_prob[j][i] = vp9_read_prob(r);
391
}
John Koleszar's avatar
John Koleszar committed
392

393 394 395 396 397 398 399 400
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) {
401
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
402

403 404
  if (cm->frame_type == KEY_FRAME) {
    if (!cm->kf_ymode_probs_update)
405
      cm->kf_ymode_probs_index = vp9_read_literal(r, 3);
406
  } else {
407 408
    nmv_context *const nmvc = &pbi->common.fc.nmvc;
    MACROBLOCKD *const xd = &pbi->mb;
409
    int i, j;
410

411
    if (cm->mcomp_filter_type == SWITCHABLE)
412
      read_switchable_interp_probs(pbi, r);
413

414 415 416 417
    // 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
418 419 420

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

423 424
    cm->comp_pred_mode = read_comp_pred_mode(r);
    if (cm->comp_pred_mode == HYBRID_PREDICTION)
John Koleszar's avatar
John Koleszar committed
425
      for (i = 0; i < COMP_PRED_CONTEXTS; i++)
426
        cm->prob_comppred[i] = vp9_read_prob(r);
John Koleszar's avatar
John Koleszar committed
427

428 429
    // VP9_YMODES
    if (vp9_read_bit(r))
430
      for (i = 0; i < VP9_YMODES - 1; ++i)
431
        cm->fc.ymode_prob[i] = vp9_read_prob(r);
432

433 434
    // VP9_I32X32_MODES
    if (vp9_read_bit(r))
435
      for (i = 0; i < VP9_I32X32_MODES - 1; ++i)
436
        cm->fc.sb_ymode_prob[i] = vp9_read_prob(r);
437

438 439 440 441 442
    for (j = 0; j < NUM_PARTITION_CONTEXTS; ++j)
      if (vp9_read_bit(r))
        for (i = 0; i < PARTITION_TYPES - 1; ++i)
          cm->fc.partition_prob[j][i] = vp9_read_prob(r);

443
    read_nmvprobs(r, nmvc, xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
444
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
445
}
John Koleszar's avatar
John Koleszar committed
446

447 448 449
// 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
450
static int read_mb_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
451
                              vp9_reader *r) {
452
  VP9_COMMON *const cm = &pbi->common;
453
  MACROBLOCKD *const xd = &pbi->mb;
454 455
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
John Koleszar's avatar
John Koleszar committed
456

457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472
  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
473 474
      segment_id = pred_flag ? vp9_get_pred_mi_segid(cm, mbmi->sb_type,
                                                     mi_row, mi_col)
Paul Wilkins's avatar
Paul Wilkins committed
475
                             : read_mb_segid(r, xd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
476
    } else {
477
      segment_id = read_mb_segid(r, xd);  // Normal unpredicted coding mode
478
    }
479

480
    set_segment_id(cm, mbmi, mi_row, mi_col, segment_id);  // Side effect
481
    return segment_id;
John Koleszar's avatar
John Koleszar committed
482
  } else {
483
    return vp9_get_pred_mi_segid(cm, mbmi->sb_type, mi_row, mi_col);
John Koleszar's avatar
John Koleszar committed
484
  }
485
}
486

Dmitry Kovalev's avatar
Dmitry Kovalev committed
487 488 489 490 491 492 493 494 495 496 497

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

498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
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
516 517
}

518
static INLINE INTERPOLATIONFILTERTYPE read_switchable_filter_type(
519 520
    VP9D_COMP *pbi, vp9_reader *r) {
  const int index = treed_read(r, vp9_switchable_interp_tree,
521 522 523 524 525
                               vp9_get_pred_probs(&pbi->common, &pbi->mb,
                                                  PRED_SWITCHABLE_INTERP));
  return vp9_switchable_interp[index];
}

526
static void read_mb_modes_mv(VP9D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
527
                             int mi_row, int mi_col,
528
                             vp9_reader *r) {
529
  VP9_COMMON *const cm = &pbi->common;
530 531
  nmv_context *const nmvc = &cm->fc.nmvc;
  const int mis = cm->mode_info_stride;
532
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
533

534 535
  int_mv *const mv0 = &mbmi->mv[0];
  int_mv *const mv1 = &mbmi->mv[1];
536 537 538
  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
539

540 541
  const int use_prev_in_find_mv_refs = cm->width == cm->last_width &&
                                       cm->height == cm->last_height &&
542 543
                                       !cm->error_resilient_mode &&
                                       cm->last_show_frame;
John Koleszar's avatar
John Koleszar committed
544

545
  int mb_to_left_edge, mb_to_right_edge, mb_to_top_edge, mb_to_bottom_edge;
546
  int j, idx, idy;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
547

John Koleszar's avatar
John Koleszar committed
548 549
  mbmi->need_to_clamp_mvs = 0;
  mbmi->need_to_clamp_secondmv = 0;
550
  mbmi->second_ref_frame = NONE;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
551

552 553 554 555
  // 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
556 557 558
  // 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
559 560
  set_mi_row_col(cm, xd, mi_row, 1 << mi_height_log2(bsize),
                         mi_col, 1 << mi_width_log2(bsize));
561

562 563
  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
564 565
  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
566 567

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

570 571 572
  mbmi->mb_skip_coeff = vp9_segfeature_active(xd, mbmi->segment_id,
                                              SEG_LVL_SKIP);
  if (!mbmi->mb_skip_coeff)
573
    mbmi->mb_skip_coeff = vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
John Koleszar's avatar
John Koleszar committed
574 575

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

John Koleszar's avatar
John Koleszar committed
578 579 580 581
  // 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;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
582
    vp9_prob mv_ref_p[VP9_MVREFS - 1];
John Koleszar's avatar
John Koleszar committed
583

584 585 586
    const MV_REFERENCE_FRAME ref_frame = mbmi->ref_frame;
    struct scale_factors *sf0 = &xd->scale_factor[0];
    *sf0 = cm->active_ref_scale[mbmi->ref_frame - 1];
587 588

    {
589
      // Select the appropriate reference frame for this MB
Dmitry Kovalev's avatar
Dmitry Kovalev committed
590
      const int ref_fb_idx = cm->active_ref_idx[ref_frame - 1];
591

592
      setup_pre_planes(xd, &cm->yv12_fb[ref_fb_idx], NULL,
593
                       mi_row, mi_col, xd->scale_factor, xd->scale_factor_uv);
594

595 596 597 598 599
#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
Yunqing Wang's avatar
Yunqing Wang committed
600 601
      vp9_find_mv_refs(cm, xd, mi, use_prev_in_find_mv_refs ?
                       xd->prev_mode_info_context : NULL,
Paul Wilkins's avatar
Paul Wilkins committed
602 603
                       ref_frame, mbmi->ref_mvs[ref_frame],
                       cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
604

605
      vp9_mv_ref_probs(cm, mv_ref_p, mbmi->mb_mode_context[ref_frame]);
606

607
      // If the segment level skip mode enabled
Paul Wilkins's avatar
Paul Wilkins committed
608 609
      if (vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP)) {
        mbmi->mode = ZEROMV;
610
      } else {
611
        if (bsize >= BLOCK_SIZE_SB8X8)
612 613 614
          mbmi->mode = read_sb_mv_ref(r, mv_ref_p);
        else
          mbmi->mode = SPLITMV;
615
        vp9_accum_mv_refs(cm, mbmi->mode, mbmi->mb_mode_context[ref_frame]);
616 617 618 619 620 621 622
      }

      if (mbmi->mode != ZEROMV) {
        vp9_find_best_ref_mvs(xd,
                              mbmi->ref_mvs[ref_frame],
                              &nearest, &nearby);

623
        best_mv.as_int = mbmi->ref_mvs[ref_frame][0].as_int;
624
      }
625

626 627 628 629 630 631
#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
632
    }
John Koleszar's avatar
John Koleszar committed
633

634 635 636
    mbmi->interp_filter = cm->mcomp_filter_type == SWITCHABLE
                              ? read_switchable_filter_type(pbi, r)
                              : cm->mcomp_filter_type;
637

John Koleszar's avatar
John Koleszar committed
638 639
    if (cm->comp_pred_mode == COMP_PREDICTION_ONLY ||
        (cm->comp_pred_mode == HYBRID_PREDICTION &&
640
         vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_COMP)))) {
John Koleszar's avatar
John Koleszar committed
641 642 643 644 645 646 647 648 649 650
      /* 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;
651
      if (mbmi->second_ref_frame > 0) {
652 653 654 655
        const MV_REFERENCE_FRAME second_ref_frame = mbmi->second_ref_frame;
        struct scale_factors *sf1 = &xd->scale_factor[1];
        const int second_ref_fb_idx = cm->active_ref_idx[second_ref_frame - 1];
        *sf1 = cm->active_ref_scale[second_ref_frame - 1];
656

657
        setup_pre_planes(xd, NULL, &cm->yv12_fb[second_ref_fb_idx],
658
                         mi_row, mi_col, xd->scale_factor, xd->scale_factor_uv);
659

660
        vp9_find_mv_refs(cm, xd, mi,
Yunqing Wang's avatar
Yunqing Wang committed
661 662
                         use_prev_in_find_mv_refs ?
                         xd->prev_mode_info_context : NULL,
663
                         second_ref_frame, mbmi->ref_mvs[second_ref_frame],
Paul Wilkins's avatar
Paul Wilkins committed
664
                         cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
665

666 667
        if (mbmi->mode != ZEROMV) {
          vp9_find_best_ref_mvs(xd,
668
                                mbmi->ref_mvs[second_ref_frame],
669 670
                                &nearest_second,
                                &nearby_second);
671
          best_mv_second.as_int = mbmi->ref_mvs[second_ref_frame][0].as_int;
672
        }
673
      }
Yaowu Xu's avatar
Yaowu Xu committed
674

John Koleszar's avatar
John Koleszar committed
675
    }
676

John Koleszar's avatar
John Koleszar committed
677 678
    mbmi->uv_mode = DC_PRED;
    switch (mbmi->mode) {
679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 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
      case SPLITMV:
        mbmi->need_to_clamp_mvs = 0;
        for (idy = 0; idy < 2; idy += bh) {
          for (idx = 0; idx < 2; idx += bw) {
            int_mv leftmv, abovemv, second_leftmv, second_abovemv;
            int_mv blockmv, secondmv;
            int mv_contz;
            int blockmode;
            int i, k;
            j = idy * 2 + idx;
            k = j;

            leftmv.as_int = left_block_mv(xd, mi, k);
            abovemv.as_int = above_block_mv(mi, k, mis);
            second_leftmv.as_int = 0;
            second_abovemv.as_int = 0;
            if (mbmi->second_ref_frame > 0) {
              second_leftmv.as_int = left_block_second_mv(xd, mi, k);
              second_abovemv.as_int = above_block_second_mv(mi, k, mis);
            }
            mv_contz = vp9_mv_cont(&leftmv, &abovemv);
            blockmode = read_sub_mv_ref(r, cm->fc.sub_mv_ref_prob[mv_contz]);
            cm->fc.sub_mv_ref_counts[mv_contz][blockmode - LEFT4X4]++;

            switch (blockmode) {
              case NEW4X4:
                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 LEFT4X4:
                blockmv.as_int = leftmv.as_int;
                if (mbmi->second_ref_frame > 0)
                  secondmv.as_int = second_leftmv.as_int;
  #ifdef VPX_MODE_COUNT
                vp9_mv_cont_count[mv_contz][0]++;
  #endif
                break;
              case ABOVE4X4:
                blockmv.as_int = abovemv.as_int;
                if (mbmi->second_ref_frame > 0)
                  secondmv.as_int = second_abovemv.as_int;
  #ifdef VPX_MODE_COUNT
                vp9_mv_cont_count[mv_contz][1]++;
  #endif
                break;
              case ZERO4X4:
                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;
            }
            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]));
John Koleszar's avatar
John Koleszar committed
751
          }
752
        }
John Koleszar's avatar
John Koleszar committed
753

754 755 756
        mv0->as_int = mi->bmi[3].as_mv[0].as_int;
        mv1->as_int = mi->bmi[3].as_mv[1].as_int;
        break;  /* done with SPLITMV */
John Koleszar's avatar
John Koleszar committed
757 758

      case NEARMV:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
759
        // Clip "next_nearest" so that it does not extend to far out of image
760 761 762 763
        assign_and_clamp_mv(mv0, &nearby, mb_to_left_edge,
                                          mb_to_right_edge,
                                          mb_to_top_edge,
                                          mb_to_bottom_edge);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
764
        if (mbmi->second_ref_frame > 0)
765 766 767 768
          assign_and_clamp_mv(mv1, &nearby_second, mb_to_left_edge,
                                                   mb_to_right_edge,
                                                   mb_to_top_edge,
                                                   mb_to_bottom_edge);
John Koleszar's avatar
John Koleszar committed
769 770 771
        break;

      case NEARESTMV:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
772
        // Clip "next_nearest" so that it does not extend to far out of image
773 774 775 776
        assign_and_clamp_mv(mv0, &nearest, mb_to_left_edge,
                                           mb_to_right_edge,
                                           mb_to_top_edge,
                                           mb_to_bottom_edge);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
777
        if (mbmi->second_ref_frame > 0)
778 779 780 781
          assign_and_clamp_mv(mv1, &nearest_second, mb_to_left_edge,
                                                    mb_to_right_edge,
                                                    mb_to_top_edge,
                                                    mb_to_bottom_edge);
John Koleszar's avatar
John Koleszar committed
782 783 784
        break;

      case ZEROMV:
785
        mv0->as_int = 0;
786
        if (mbmi->second_ref_frame > 0)
787
          mv1->as_int = 0;
John Koleszar's avatar
John Koleszar committed
788
        break;
John Koleszar's avatar
John Koleszar committed
789

John Koleszar's avatar
John Koleszar committed
790
      case NEWMV:
791 792
        decode_mv(r, &mv0->as_mv, &best_mv.as_mv, nmvc, &cm->fc.NMVcount,
                  xd->allow_high_precision_mv);
793
        mbmi->need_to_clamp_mvs = check_mv_bounds(mv0,
794 795 796 797
                                                  mb_to_left_edge,
                                                  mb_to_right_edge,
                                                  mb_to_top_edge,
                                                  mb_to_bottom_edge);
798

799
        if (mbmi->second_ref_frame > 0) {
800 801
          decode_mv(r, &mv1->as_mv, &best_mv_second.as_mv, nmvc,
                    &cm->fc.NMVcount, xd->allow_high_precision_mv);
802
          mbmi->need_to_clamp_secondmv = check_mv_bounds(mv1,