vp9_decodemv.c 32.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 107
  m->mbmi.ref_frame = INTRA_FRAME;

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

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

120
  // luma mode
121 122 123 124 125 126 127
#if CONFIG_AB4X4
  if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8)
    m->mbmi.mode = read_kf_sb_ymode(r,
                     cm->sb_kf_ymode_prob[cm->kf_ymode_probs_index]);
  else
     m->mbmi.mode = I4X4_PRED;
#else
128
  m->mbmi.mode = m->mbmi.sb_type > BLOCK_SIZE_SB8X8 ?
129 130
      read_kf_sb_ymode(r, cm->sb_kf_ymode_prob[cm->kf_ymode_probs_index]):
      read_kf_mb_ymode(r, cm->kf_ymode_prob[cm->kf_ymode_probs_index]);
131
#endif
132

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

135 136 137
#if CONFIG_AB4X4
  if (m->mbmi.sb_type < BLOCK_SIZE_SB8X8) {
#else
138
  if (m->mbmi.mode == I4X4_PRED) {
139
#endif
140 141 142 143 144 145 146 147 148 149 150 151
    int idx, idy;
    int bw = 1 << b_width_log2(m->mbmi.sb_type);
    int bh = 1 << b_height_log2(m->mbmi.sb_type);
    // FIXME(jingning): fix intra4x4 rate-distortion optimization, then
    // use bw and bh as the increment values.
#if !CONFIG_AB4X4 || CONFIG_AB4X4
    bw = 1, bh = 1;
#endif
    for (idy = 0; idy < 2; idy += bh)
      for (idx = 0; idx < 2; idx += bw)
        m->bmi[idy * 2 + idx].as_mode.first =
            read_kf_sb_ymode(r, cm->sb_kf_ymode_prob[cm->kf_ymode_probs_index]);
John Koleszar's avatar
John Koleszar committed
152
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
153

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

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

187 188
static int read_mv_component(vp9_reader *r,
                             const nmv_component *mvcomp, int usehp) {
189

190
  int mag, d, fr, hp;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
191 192 193
  const int sign = vp9_read(r, mvcomp->sign);
  const int mv_class = treed_read(r, vp9_mv_class_tree, mvcomp->classes);

194
  // Integer part
Dmitry Kovalev's avatar
Dmitry Kovalev committed
195
  if (mv_class == MV_CLASS_0) {
196
    d = treed_read(r, vp9_mv_class0_tree, mvcomp->class0);
197
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
198
    int i;
199
    const int n = mv_class + CLASS0_BITS - 1;  // number of bits
Dmitry Kovalev's avatar
Dmitry Kovalev committed
200

201
    d = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
202 203
    for (i = 0; i < n; ++i)
      d |= vp9_read(r, mvcomp->bits[i]) << i;
204 205
  }

206 207 208
  // Fractional part
  fr = treed_read(r, vp9_mv_fp_tree,
                  mv_class == MV_CLASS_0 ? mvcomp->class0_fp[d] : mvcomp->fp);
209 210


211 212 213 214
  // 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;
215

216 217 218
  // result
  mag = vp9_get_mv_mag(mv_class, (d << 3) | (fr << 1) | hp) + 1;
  return sign ? -mag : mag;
219 220
}

221
static void update_nmv(vp9_reader *r, vp9_prob *const p,
222
                       const vp9_prob upd_p) {
223
  if (vp9_read(r, upd_p)) {
224
#ifdef LOW_PRECISION_MV_UPDATE
225
    *p = (vp9_read_literal(r, 7) << 1) | 1;
226
#else
227
    *p = (vp9_read_literal(r, 8));
228 229 230 231
#endif
  }
}

232
static void read_nmvprobs(vp9_reader *r, nmv_context *mvctx,
233 234
                          int usehp) {
  int i, j, k;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
235

236
#ifdef MV_GROUP_UPDATE
237
  if (!vp9_read_bit(r))
Dmitry Kovalev's avatar
Dmitry Kovalev committed
238
    return;
239
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
240
  for (j = 0; j < MV_JOINTS - 1; ++j)
241
    update_nmv(r, &mvctx->joints[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
242

243
  for (i = 0; i < 2; ++i) {
244
    update_nmv(r, &mvctx->comps[i].sign, VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
245
    for (j = 0; j < MV_CLASSES - 1; ++j)
246
      update_nmv(r, &mvctx->comps[i].classes[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
247 248

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

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

  for (i = 0; i < 2; ++i) {
256
    for (j = 0; j < CLASS0_SIZE; ++j)
257
      for (k = 0; k < 3; ++k)
258
        update_nmv(r, &mvctx->comps[i].class0_fp[j][k], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
259 260

    for (j = 0; j < 3; ++j)
261
      update_nmv(r, &mvctx->comps[i].fp[j], VP9_NMV_UPDATE_PROB);
262 263 264 265
  }

  if (usehp) {
    for (i = 0; i < 2; ++i) {
266 267
      update_nmv(r, &mvctx->comps[i].class0_hp, VP9_NMV_UPDATE_PROB);
      update_nmv(r, &mvctx->comps[i].hp, VP9_NMV_UPDATE_PROB);
268 269 270 271
    }
  }
}

272
// Read the referncence frame
273
static MV_REFERENCE_FRAME read_ref_frame(VP9D_COMP *pbi,
274
                                         vp9_reader *r,
275
                                         int segment_id) {
John Koleszar's avatar
John Koleszar committed
276
  MV_REFERENCE_FRAME ref_frame;
277
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
278 279
  MACROBLOCKD *const xd = &pbi->mb;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
280
  int seg_ref_count = 0;
281 282 283 284 285 286 287
  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
288 289 290

  // If segment coding enabled does the segment allow for more than one
  // possible reference frame
291 292
  if (seg_ref_active)
    seg_ref_count = intra + last + golden + altref;
John Koleszar's avatar
John Koleszar committed
293 294 295

  // Segment reference frame features not available or allows for
  // multiple reference frame options
296
  if (!seg_ref_active || seg_ref_count > 1) {
John Koleszar's avatar
John Koleszar committed
297 298 299 300
    // 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
301
    vp9_prob pred_prob = vp9_get_pred_prob(cm, xd, PRED_REF);
John Koleszar's avatar
John Koleszar committed
302 303

    // Read the prediction status flag
304
    unsigned char prediction_flag = vp9_read(r, pred_prob);
John Koleszar's avatar
John Koleszar committed
305 306

    // Store the prediction flag.
Paul Wilkins's avatar
Paul Wilkins committed
307
    vp9_set_pred_flag(xd, PRED_REF, prediction_flag);
John Koleszar's avatar
John Koleszar committed
308 309

    // Get the predicted reference frame.
Paul Wilkins's avatar
Paul Wilkins committed
310
    pred_ref = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
311 312 313 314

    // If correctly predicted then use the predicted value
    if (prediction_flag) {
      ref_frame = pred_ref;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
315 316
    } else {
      // decode the explicitly coded value
317
      vp9_prob mod_refprobs[PREDICTION_PROBS];
318 319
      vpx_memcpy(mod_refprobs, cm->mod_refprobs[pred_ref],
                 sizeof(mod_refprobs));
John Koleszar's avatar
John Koleszar committed
320 321 322 323

      // If segment coding enabled blank out options that cant occur by
      // setting the branch probability to 0.
      if (seg_ref_active) {
324 325 326
        mod_refprobs[INTRA_FRAME] *= intra;
        mod_refprobs[LAST_FRAME] *= last;
        mod_refprobs[GOLDEN_FRAME] *= golden * altref;
John Koleszar's avatar
John Koleszar committed
327 328 329 330 331 332 333
      }

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

      // Do we need to decode the Intra/Inter branch
      if (mod_refprobs[0])
334
        ref_frame = vp9_read(r, mod_refprobs[0]);
John Koleszar's avatar
John Koleszar committed
335 336 337 338 339 340
      else
        ref_frame++;

      if (ref_frame) {
        // Do we need to decode the Last/Gf_Arf branch
        if (mod_refprobs[1])
341
          ref_frame += vp9_read(r, mod_refprobs[1]);
342
        else
John Koleszar's avatar
John Koleszar committed
343 344 345 346
          ref_frame++;

        if (ref_frame > 1) {
          // Do we need to decode the GF/Arf branch
347
          if (mod_refprobs[2]) {
348
            ref_frame += vp9_read(r, mod_refprobs[2]);
349
          } else {
350 351 352 353 354 355
            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
356
          }
357
        }
John Koleszar's avatar
John Koleszar committed
358
      }
359
    }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
360 361
  } else {
    // Segment reference frame features are enabled
John Koleszar's avatar
John Koleszar committed
362 363 364
    // 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
365 366
    vp9_set_pred_flag(xd, PRED_REF, 1);
    ref_frame = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
367 368
  }

369
  return ref_frame;
370
}
John Koleszar's avatar
John Koleszar committed
371

372 373
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
374
}
John Koleszar's avatar
John Koleszar committed
375

376 377
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
378 379
}

380
static B_PREDICTION_MODE read_sub_mv_ref(vp9_reader *r, const vp9_prob *p) {
381
  return (B_PREDICTION_MODE) treed_read(r, vp9_sub_mv_ref_tree, p);
John Koleszar's avatar
John Koleszar committed
382
}
Scott LaVarnway's avatar
Scott LaVarnway committed
383 384

#ifdef VPX_MODE_COUNT
385
unsigned int vp9_mv_cont_count[5][4] = {
John Koleszar's avatar
John Koleszar committed
386 387 388 389 390
  { 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
391
};
Scott LaVarnway's avatar
Scott LaVarnway committed
392
#endif
John Koleszar's avatar
John Koleszar committed
393

394
static void read_switchable_interp_probs(VP9D_COMP* const pbi, vp9_reader *r) {
395
  VP9_COMMON *const cm = &pbi->common;
396
  int i, j;
397 398 399
  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);
400
}
John Koleszar's avatar
John Koleszar committed
401

402 403 404 405 406 407 408 409
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) {
410
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
411

412 413
  if (cm->frame_type == KEY_FRAME) {
    if (!cm->kf_ymode_probs_update)
414
      cm->kf_ymode_probs_index = vp9_read_literal(r, 3);
415
  } else {
416 417
    nmv_context *const nmvc = &pbi->common.fc.nmvc;
    MACROBLOCKD *const xd = &pbi->mb;
418
    int i, j;
419

420
    if (cm->mcomp_filter_type == SWITCHABLE)
421
      read_switchable_interp_probs(pbi, r);
422

423 424 425 426
    // 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
427 428 429

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

432 433
    cm->comp_pred_mode = read_comp_pred_mode(r);
    if (cm->comp_pred_mode == HYBRID_PREDICTION)
John Koleszar's avatar
John Koleszar committed
434
      for (i = 0; i < COMP_PRED_CONTEXTS; i++)
435
        cm->prob_comppred[i] = vp9_read_prob(r);
John Koleszar's avatar
John Koleszar committed
436

437 438
    // VP9_YMODES
    if (vp9_read_bit(r))
439
      for (i = 0; i < VP9_YMODES - 1; ++i)
440
        cm->fc.ymode_prob[i] = vp9_read_prob(r);
441

442 443
    // VP9_I32X32_MODES
    if (vp9_read_bit(r))
444
      for (i = 0; i < VP9_I32X32_MODES - 1; ++i)
445
        cm->fc.sb_ymode_prob[i] = vp9_read_prob(r);
446

447 448 449 450 451
    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);

452
    read_nmvprobs(r, nmvc, xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
453
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
454
}
John Koleszar's avatar
John Koleszar committed
455

456 457 458
// 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
459
static int read_mb_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
460
                              vp9_reader *r) {
461
  VP9_COMMON *const cm = &pbi->common;
462
  MACROBLOCKD *const xd = &pbi->mb;
463 464
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
John Koleszar's avatar
John Koleszar committed
465

466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481
  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
482 483
      segment_id = pred_flag ? vp9_get_pred_mi_segid(cm, mbmi->sb_type,
                                                     mi_row, mi_col)
Paul Wilkins's avatar
Paul Wilkins committed
484
                             : read_mb_segid(r, xd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
485
    } else {
486
      segment_id = read_mb_segid(r, xd);  // Normal unpredicted coding mode
487
    }
488

489
    set_segment_id(cm, mbmi, mi_row, mi_col, segment_id);  // Side effect
490
    return segment_id;
John Koleszar's avatar
John Koleszar committed
491
  } else {
492
    return vp9_get_pred_mi_segid(cm, mbmi->sb_type, mi_row, mi_col);
John Koleszar's avatar
John Koleszar committed
493
  }
494
}
495

Dmitry Kovalev's avatar
Dmitry Kovalev committed
496 497 498 499 500 501 502 503 504 505 506

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

507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
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
525 526
}

527
static INLINE INTERPOLATIONFILTERTYPE read_switchable_filter_type(
528 529
    VP9D_COMP *pbi, vp9_reader *r) {
  const int index = treed_read(r, vp9_switchable_interp_tree,
530 531 532 533 534
                               vp9_get_pred_probs(&pbi->common, &pbi->mb,
                                                  PRED_SWITCHABLE_INTERP));
  return vp9_switchable_interp[index];
}

535
static void read_mb_modes_mv(VP9D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
536
                             int mi_row, int mi_col,
537
                             vp9_reader *r) {
538
  VP9_COMMON *const cm = &pbi->common;
539 540
  nmv_context *const nmvc = &cm->fc.nmvc;
  const int mis = cm->mode_info_stride;
541
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
542

543 544
  int_mv *const mv0 = &mbmi->mv[0];
  int_mv *const mv1 = &mbmi->mv[1];
545 546 547
  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
548

549 550
  const int use_prev_in_find_mv_refs = cm->width == cm->last_width &&
                                       cm->height == cm->last_height &&
551 552
                                       !cm->error_resilient_mode &&
                                       cm->last_show_frame;
John Koleszar's avatar
John Koleszar committed
553

554
  int mb_to_left_edge, mb_to_right_edge, mb_to_top_edge, mb_to_bottom_edge;
555
  int j, idx, idy;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
556

John Koleszar's avatar
John Koleszar committed
557 558
  mbmi->need_to_clamp_mvs = 0;
  mbmi->need_to_clamp_secondmv = 0;
559
  mbmi->second_ref_frame = NONE;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
560

561 562 563 564
  // 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
565 566 567
  // 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
568 569
  set_mi_row_col(cm, xd, mi_row, 1 << mi_height_log2(bsize),
                         mi_col, 1 << mi_width_log2(bsize));
570

571 572
  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
573 574
  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
575 576

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

579 580 581
  mbmi->mb_skip_coeff = vp9_segfeature_active(xd, mbmi->segment_id,
                                              SEG_LVL_SKIP);
  if (!mbmi->mb_skip_coeff)
582
    mbmi->mb_skip_coeff = vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
John Koleszar's avatar
John Koleszar committed
583 584

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

John Koleszar's avatar
John Koleszar committed
587 588 589 590
  // 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
591
    vp9_prob mv_ref_p[VP9_MVREFS - 1];
John Koleszar's avatar
John Koleszar committed
592

593 594 595
    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];
596 597

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

601
      setup_pre_planes(xd, &cm->yv12_fb[ref_fb_idx], NULL,
602
                       mi_row, mi_col, xd->scale_factor, xd->scale_factor_uv);
603

604 605 606 607 608
#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
609 610
      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
611 612
                       ref_frame, mbmi->ref_mvs[ref_frame],
                       cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
613

614
      vp9_mv_ref_probs(cm, mv_ref_p, mbmi->mb_mode_context[ref_frame]);
615

616
      // If the segment level skip mode enabled
Paul Wilkins's avatar
Paul Wilkins committed
617 618
      if (vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP)) {
        mbmi->mode = ZEROMV;
619
      } else {
620
#if CONFIG_AB4X4
621
        if (bsize >= BLOCK_SIZE_SB8X8)
622 623 624 625
          mbmi->mode = read_sb_mv_ref(r, mv_ref_p);
        else
          mbmi->mode = SPLITMV;
#else
626 627 628
        mbmi->mode = bsize > BLOCK_SIZE_SB8X8 ?
                                   read_sb_mv_ref(r, mv_ref_p)
                                 : read_mv_ref(r, mv_ref_p);
629
#endif
630
        vp9_accum_mv_refs(cm, mbmi->mode, mbmi->mb_mode_context[ref_frame]);
631 632 633 634 635 636 637
      }

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

638
        best_mv.as_int = mbmi->ref_mvs[ref_frame][0].as_int;
639
      }
640

641 642 643 644 645 646
#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
647
    }
John Koleszar's avatar
John Koleszar committed
648

649 650 651
    mbmi->interp_filter = cm->mcomp_filter_type == SWITCHABLE
                              ? read_switchable_filter_type(pbi, r)
                              : cm->mcomp_filter_type;
652

John Koleszar's avatar
John Koleszar committed
653 654
    if (cm->comp_pred_mode == COMP_PREDICTION_ONLY ||
        (cm->comp_pred_mode == HYBRID_PREDICTION &&
655
         vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_COMP)))) {
John Koleszar's avatar
John Koleszar committed
656 657 658 659 660 661 662 663 664 665
      /* 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;
666
      if (mbmi->second_ref_frame > 0) {
667 668 669 670
        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];
671

672
        setup_pre_planes(xd, NULL, &cm->yv12_fb[second_ref_fb_idx],
673
                         mi_row, mi_col, xd->scale_factor, xd->scale_factor_uv);
674

675
        vp9_find_mv_refs(cm, xd, mi,
Yunqing Wang's avatar
Yunqing Wang committed
676 677
                         use_prev_in_find_mv_refs ?
                         xd->prev_mode_info_context : NULL,
678
                         second_ref_frame, mbmi->ref_mvs[second_ref_frame],
Paul Wilkins's avatar
Paul Wilkins committed
679
                         cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
680

681 682
        if (mbmi->mode != ZEROMV) {
          vp9_find_best_ref_mvs(xd,
683
                                mbmi->ref_mvs[second_ref_frame],
684 685
                                &nearest_second,
                                &nearby_second);
686
          best_mv_second.as_int = mbmi->ref_mvs[second_ref_frame][0].as_int;
687
        }
688
      }
Yaowu Xu's avatar
Yaowu Xu committed
689

John Koleszar's avatar
John Koleszar committed
690
    }
691

John Koleszar's avatar
John Koleszar committed
692 693
    mbmi->uv_mode = DC_PRED;
    switch (mbmi->mode) {
694 695 696
      case SPLITMV:
#if !CONFIG_AB4X4
        bw = 1, bh = 1;
697
#endif
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 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768
        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
769
          }
770
        }
John Koleszar's avatar
John Koleszar committed
771

772 773 774
        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
775 776

      case NEARMV:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
777
        // Clip "next_nearest" so that it does not extend to far out of image
778 779 780 781
        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
782
        if (mbmi->second_ref_frame > 0)
783 784 785 786
          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
787 788 789
        break;

      case NEARESTMV:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
790
        // Clip "next_nearest" so that it does not extend to far out of image
791 792 793 794
        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
795
        if (mbmi->second_ref_frame > 0)
796 797 798 799
          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
800 801 802
        break;

      case ZEROMV:
803
        mv0->as_int = 0;
804
        if (mbmi->second_ref_frame > 0)
805
          mv1->as_int = 0;
John Koleszar's avatar
John Koleszar committed
806
        break;
John Koleszar's avatar
John Koleszar committed
807

John Koleszar's avatar
John Koleszar committed
808
      case NEWMV:
809 810
        decode_mv(r, &mv0->as_mv, &best_mv.as_mv, nmvc, &cm->fc.NMVcount,
                  xd->allow_high_precision_mv);
811
        mbmi->need_to_clamp_mvs = check_mv_bounds(mv0,