vp9_decodemv.c 33.4 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
#if CONFIG_AB4X4
123 124 125 126 127 128
  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 {
129
     m->mbmi.mode = I4X4_PRED;
130
  }
131
#else
132
  m->mbmi.mode = m->mbmi.sb_type > BLOCK_SIZE_SB8X8 ?
133 134
      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]);
135
#endif
136

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

139 140 141
#if CONFIG_AB4X4
  if (m->mbmi.sb_type < BLOCK_SIZE_SB8X8) {
#else
142
  if (m->mbmi.mode == I4X4_PRED) {
143
#endif
144 145 146
    int idx, idy;
    int bw = 1 << b_width_log2(m->mbmi.sb_type);
    int bh = 1 << b_height_log2(m->mbmi.sb_type);
147 148

#if !CONFIG_AB4X4
149 150
    bw = 1, bh = 1;
#endif
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
    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
166
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
167

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
170
  if (cm->txfm_mode == TX_MODE_SELECT &&
171
    !(m->mbmi.mb_skip_coeff && m->mbmi.ref_frame != INTRA_FRAME)
172
#if CONFIG_AB4X4
173
      && m->mbmi.sb_type >= BLOCK_SIZE_SB8X8
174
#else
175
      && m->mbmi.mode != I4X4_PRED
176 177
#endif
      ) {
178
    const int allow_16x16 = m->mbmi.sb_type >= BLOCK_SIZE_MB16X16;
179 180
    const int allow_32x32 = m->mbmi.sb_type >= BLOCK_SIZE_SB32X32;
    m->mbmi.txfm_size = select_txfm_size(cm, r, allow_16x16, allow_32x32);
181 182
  } else if (cm->txfm_mode >= ALLOW_32X32 &&
             m->mbmi.sb_type >= BLOCK_SIZE_SB32X32) {
183
    m->mbmi.txfm_size = TX_32X32;
184 185 186
  } else if (cm->txfm_mode >= ALLOW_16X16 &&
             m->mbmi.sb_type >= BLOCK_SIZE_MB16X16 &&
             m->mbmi.mode <= TM_PRED) {
187
    m->mbmi.txfm_size = TX_16X16;
188 189 190 191 192 193 194
  } else if (cm->txfm_mode >= ALLOW_8X8 &&
#if CONFIG_AB4X4
             m->mbmi.sb_type >= BLOCK_SIZE_SB8X8
#else
             m->mbmi.mode != I4X4_PRED
#endif
             ) {
195 196 197 198
    m->mbmi.txfm_size = TX_8X8;
  } else {
    m->mbmi.txfm_size = TX_4X4;
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
199
}
John Koleszar's avatar
John Koleszar committed
200

201 202
static int read_mv_component(vp9_reader *r,
                             const nmv_component *mvcomp, int usehp) {
203

204
  int mag, d, fr, hp;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
205 206 207
  const int sign = vp9_read(r, mvcomp->sign);
  const int mv_class = treed_read(r, vp9_mv_class_tree, mvcomp->classes);

208
  // Integer part
Dmitry Kovalev's avatar
Dmitry Kovalev committed
209
  if (mv_class == MV_CLASS_0) {
210
    d = treed_read(r, vp9_mv_class0_tree, mvcomp->class0);
211
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
212
    int i;
213
    const int n = mv_class + CLASS0_BITS - 1;  // number of bits
Dmitry Kovalev's avatar
Dmitry Kovalev committed
214

215
    d = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
216 217
    for (i = 0; i < n; ++i)
      d |= vp9_read(r, mvcomp->bits[i]) << i;
218 219
  }

220 221 222
  // Fractional part
  fr = treed_read(r, vp9_mv_fp_tree,
                  mv_class == MV_CLASS_0 ? mvcomp->class0_fp[d] : mvcomp->fp);
223 224


225 226 227 228
  // 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;
229

230 231 232
  // result
  mag = vp9_get_mv_mag(mv_class, (d << 3) | (fr << 1) | hp) + 1;
  return sign ? -mag : mag;
233 234
}

235
static void update_nmv(vp9_reader *r, vp9_prob *const p,
236
                       const vp9_prob upd_p) {
237
  if (vp9_read(r, upd_p)) {
238
#ifdef LOW_PRECISION_MV_UPDATE
239
    *p = (vp9_read_literal(r, 7) << 1) | 1;
240
#else
241
    *p = (vp9_read_literal(r, 8));
242 243 244 245
#endif
  }
}

246
static void read_nmvprobs(vp9_reader *r, nmv_context *mvctx,
247 248
                          int usehp) {
  int i, j, k;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
249

250
#ifdef MV_GROUP_UPDATE
251
  if (!vp9_read_bit(r))
Dmitry Kovalev's avatar
Dmitry Kovalev committed
252
    return;
253
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
254
  for (j = 0; j < MV_JOINTS - 1; ++j)
255
    update_nmv(r, &mvctx->joints[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
256

257
  for (i = 0; i < 2; ++i) {
258
    update_nmv(r, &mvctx->comps[i].sign, VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
259
    for (j = 0; j < MV_CLASSES - 1; ++j)
260
      update_nmv(r, &mvctx->comps[i].classes[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
261 262

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

    for (j = 0; j < MV_OFFSET_BITS; ++j)
266
      update_nmv(r, &mvctx->comps[i].bits[j], VP9_NMV_UPDATE_PROB);
267 268 269
  }

  for (i = 0; i < 2; ++i) {
270
    for (j = 0; j < CLASS0_SIZE; ++j)
271
      for (k = 0; k < 3; ++k)
272
        update_nmv(r, &mvctx->comps[i].class0_fp[j][k], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
273 274

    for (j = 0; j < 3; ++j)
275
      update_nmv(r, &mvctx->comps[i].fp[j], VP9_NMV_UPDATE_PROB);
276 277 278 279
  }

  if (usehp) {
    for (i = 0; i < 2; ++i) {
280 281
      update_nmv(r, &mvctx->comps[i].class0_hp, VP9_NMV_UPDATE_PROB);
      update_nmv(r, &mvctx->comps[i].hp, VP9_NMV_UPDATE_PROB);
282 283 284 285
    }
  }
}

286
// Read the referncence frame
287
static MV_REFERENCE_FRAME read_ref_frame(VP9D_COMP *pbi,
288
                                         vp9_reader *r,
289
                                         int segment_id) {
John Koleszar's avatar
John Koleszar committed
290
  MV_REFERENCE_FRAME ref_frame;
291
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
292 293
  MACROBLOCKD *const xd = &pbi->mb;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
294
  int seg_ref_count = 0;
295 296 297 298 299 300 301
  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
302 303 304

  // If segment coding enabled does the segment allow for more than one
  // possible reference frame
305 306
  if (seg_ref_active)
    seg_ref_count = intra + last + golden + altref;
John Koleszar's avatar
John Koleszar committed
307 308 309

  // Segment reference frame features not available or allows for
  // multiple reference frame options
310
  if (!seg_ref_active || seg_ref_count > 1) {
John Koleszar's avatar
John Koleszar committed
311 312 313 314
    // 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
315
    vp9_prob pred_prob = vp9_get_pred_prob(cm, xd, PRED_REF);
John Koleszar's avatar
John Koleszar committed
316 317

    // Read the prediction status flag
318
    unsigned char prediction_flag = vp9_read(r, pred_prob);
John Koleszar's avatar
John Koleszar committed
319 320

    // Store the prediction flag.
Paul Wilkins's avatar
Paul Wilkins committed
321
    vp9_set_pred_flag(xd, PRED_REF, prediction_flag);
John Koleszar's avatar
John Koleszar committed
322 323

    // Get the predicted reference frame.
Paul Wilkins's avatar
Paul Wilkins committed
324
    pred_ref = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
325 326 327 328

    // If correctly predicted then use the predicted value
    if (prediction_flag) {
      ref_frame = pred_ref;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
329 330
    } else {
      // decode the explicitly coded value
331
      vp9_prob mod_refprobs[PREDICTION_PROBS];
332 333
      vpx_memcpy(mod_refprobs, cm->mod_refprobs[pred_ref],
                 sizeof(mod_refprobs));
John Koleszar's avatar
John Koleszar committed
334 335 336 337

      // If segment coding enabled blank out options that cant occur by
      // setting the branch probability to 0.
      if (seg_ref_active) {
338 339 340
        mod_refprobs[INTRA_FRAME] *= intra;
        mod_refprobs[LAST_FRAME] *= last;
        mod_refprobs[GOLDEN_FRAME] *= golden * altref;
John Koleszar's avatar
John Koleszar committed
341 342 343 344 345 346 347
      }

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

      // Do we need to decode the Intra/Inter branch
      if (mod_refprobs[0])
348
        ref_frame = vp9_read(r, mod_refprobs[0]);
John Koleszar's avatar
John Koleszar committed
349 350 351 352 353 354
      else
        ref_frame++;

      if (ref_frame) {
        // Do we need to decode the Last/Gf_Arf branch
        if (mod_refprobs[1])
355
          ref_frame += vp9_read(r, mod_refprobs[1]);
356
        else
John Koleszar's avatar
John Koleszar committed
357 358 359 360
          ref_frame++;

        if (ref_frame > 1) {
          // Do we need to decode the GF/Arf branch
361
          if (mod_refprobs[2]) {
362
            ref_frame += vp9_read(r, mod_refprobs[2]);
363
          } else {
364 365 366 367 368 369
            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
370
          }
371
        }
John Koleszar's avatar
John Koleszar committed
372
      }
373
    }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
374 375
  } else {
    // Segment reference frame features are enabled
John Koleszar's avatar
John Koleszar committed
376 377 378
    // 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
379 380
    vp9_set_pred_flag(xd, PRED_REF, 1);
    ref_frame = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
381 382
  }

383
  return ref_frame;
384
}
John Koleszar's avatar
John Koleszar committed
385

386 387
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
388
}
John Koleszar's avatar
John Koleszar committed
389

390 391
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
392 393
}

394
static B_PREDICTION_MODE read_sub_mv_ref(vp9_reader *r, const vp9_prob *p) {
395
  return (B_PREDICTION_MODE) treed_read(r, vp9_sub_mv_ref_tree, p);
John Koleszar's avatar
John Koleszar committed
396
}
Scott LaVarnway's avatar
Scott LaVarnway committed
397 398

#ifdef VPX_MODE_COUNT
399
unsigned int vp9_mv_cont_count[5][4] = {
John Koleszar's avatar
John Koleszar committed
400 401 402 403 404
  { 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
405
};
Scott LaVarnway's avatar
Scott LaVarnway committed
406
#endif
John Koleszar's avatar
John Koleszar committed
407

408
static void read_switchable_interp_probs(VP9D_COMP* const pbi, vp9_reader *r) {
409
  VP9_COMMON *const cm = &pbi->common;
410
  int i, j;
411 412 413
  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);
414
}
John Koleszar's avatar
John Koleszar committed
415

416 417 418 419 420 421 422 423
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) {
424
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
425

426 427
  if (cm->frame_type == KEY_FRAME) {
    if (!cm->kf_ymode_probs_update)
428
      cm->kf_ymode_probs_index = vp9_read_literal(r, 3);
429
  } else {
430 431
    nmv_context *const nmvc = &pbi->common.fc.nmvc;
    MACROBLOCKD *const xd = &pbi->mb;
432
    int i, j;
433

434
    if (cm->mcomp_filter_type == SWITCHABLE)
435
      read_switchable_interp_probs(pbi, r);
436

437 438 439 440
    // 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
441 442 443

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

446 447
    cm->comp_pred_mode = read_comp_pred_mode(r);
    if (cm->comp_pred_mode == HYBRID_PREDICTION)
John Koleszar's avatar
John Koleszar committed
448
      for (i = 0; i < COMP_PRED_CONTEXTS; i++)
449
        cm->prob_comppred[i] = vp9_read_prob(r);
John Koleszar's avatar
John Koleszar committed
450

451 452
    // VP9_YMODES
    if (vp9_read_bit(r))
453
      for (i = 0; i < VP9_YMODES - 1; ++i)
454
        cm->fc.ymode_prob[i] = vp9_read_prob(r);
455

456 457
    // VP9_I32X32_MODES
    if (vp9_read_bit(r))
458
      for (i = 0; i < VP9_I32X32_MODES - 1; ++i)
459
        cm->fc.sb_ymode_prob[i] = vp9_read_prob(r);
460

461 462 463 464 465
    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);

466
    read_nmvprobs(r, nmvc, xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
467
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
468
}
John Koleszar's avatar
John Koleszar committed
469

470 471 472
// 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
473
static int read_mb_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
474
                              vp9_reader *r) {
475
  VP9_COMMON *const cm = &pbi->common;
476
  MACROBLOCKD *const xd = &pbi->mb;
477 478
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
John Koleszar's avatar
John Koleszar committed
479

480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495
  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
496 497
      segment_id = pred_flag ? vp9_get_pred_mi_segid(cm, mbmi->sb_type,
                                                     mi_row, mi_col)
Paul Wilkins's avatar
Paul Wilkins committed
498
                             : read_mb_segid(r, xd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
499
    } else {
500
      segment_id = read_mb_segid(r, xd);  // Normal unpredicted coding mode
501
    }
502

503
    set_segment_id(cm, mbmi, mi_row, mi_col, segment_id);  // Side effect
504
    return segment_id;
John Koleszar's avatar
John Koleszar committed
505
  } else {
506
    return vp9_get_pred_mi_segid(cm, mbmi->sb_type, mi_row, mi_col);
John Koleszar's avatar
John Koleszar committed
507
  }
508
}
509

Dmitry Kovalev's avatar
Dmitry Kovalev committed
510 511 512 513 514 515 516 517 518 519 520

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

521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
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
539 540
}

541
static INLINE INTERPOLATIONFILTERTYPE read_switchable_filter_type(
542 543
    VP9D_COMP *pbi, vp9_reader *r) {
  const int index = treed_read(r, vp9_switchable_interp_tree,
544 545 546 547 548
                               vp9_get_pred_probs(&pbi->common, &pbi->mb,
                                                  PRED_SWITCHABLE_INTERP));
  return vp9_switchable_interp[index];
}

549
static void read_mb_modes_mv(VP9D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
550
                             int mi_row, int mi_col,
551
                             vp9_reader *r) {
552
  VP9_COMMON *const cm = &pbi->common;
553 554
  nmv_context *const nmvc = &cm->fc.nmvc;
  const int mis = cm->mode_info_stride;
555
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
556

557 558
  int_mv *const mv0 = &mbmi->mv[0];
  int_mv *const mv1 = &mbmi->mv[1];
559 560 561
  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
562

563 564
  const int use_prev_in_find_mv_refs = cm->width == cm->last_width &&
                                       cm->height == cm->last_height &&
565 566
                                       !cm->error_resilient_mode &&
                                       cm->last_show_frame;
John Koleszar's avatar
John Koleszar committed
567

568
  int mb_to_left_edge, mb_to_right_edge, mb_to_top_edge, mb_to_bottom_edge;
569
  int j, idx, idy;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
570

John Koleszar's avatar
John Koleszar committed
571 572
  mbmi->need_to_clamp_mvs = 0;
  mbmi->need_to_clamp_secondmv = 0;
573
  mbmi->second_ref_frame = NONE;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
574

575 576 577 578
  // 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
579 580 581
  // 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
582 583
  set_mi_row_col(cm, xd, mi_row, 1 << mi_height_log2(bsize),
                         mi_col, 1 << mi_width_log2(bsize));
584

585 586
  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
587 588
  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
589 590

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

593 594 595
  mbmi->mb_skip_coeff = vp9_segfeature_active(xd, mbmi->segment_id,
                                              SEG_LVL_SKIP);
  if (!mbmi->mb_skip_coeff)
596
    mbmi->mb_skip_coeff = vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
John Koleszar's avatar
John Koleszar committed
597 598

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

John Koleszar's avatar
John Koleszar committed
601 602 603 604
  // 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
605
    vp9_prob mv_ref_p[VP9_MVREFS - 1];
John Koleszar's avatar
John Koleszar committed
606

607 608 609
    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];
610 611

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

615
      setup_pre_planes(xd, &cm->yv12_fb[ref_fb_idx], NULL,
616
                       mi_row, mi_col, xd->scale_factor, xd->scale_factor_uv);
617

618 619 620 621 622
#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
623 624
      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
625 626
                       ref_frame, mbmi->ref_mvs[ref_frame],
                       cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
627

628
      vp9_mv_ref_probs(cm, mv_ref_p, mbmi->mb_mode_context[ref_frame]);
629

630
      // If the segment level skip mode enabled
Paul Wilkins's avatar
Paul Wilkins committed
631 632
      if (vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP)) {
        mbmi->mode = ZEROMV;
633
      } else {
634
#if CONFIG_AB4X4
635
        if (bsize >= BLOCK_SIZE_SB8X8)
636 637 638 639
          mbmi->mode = read_sb_mv_ref(r, mv_ref_p);
        else
          mbmi->mode = SPLITMV;
#else
640 641 642
        mbmi->mode = bsize > BLOCK_SIZE_SB8X8 ?
                                   read_sb_mv_ref(r, mv_ref_p)
                                 : read_mv_ref(r, mv_ref_p);
643
#endif
644
        vp9_accum_mv_refs(cm, mbmi->mode, mbmi->mb_mode_context[ref_frame]);
645 646 647 648 649 650 651
      }

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

652
        best_mv.as_int = mbmi->ref_mvs[ref_frame][0].as_int;
653
      }
654

655 656 657 658 659 660
#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
661
    }
John Koleszar's avatar
John Koleszar committed
662

663 664 665
    mbmi->interp_filter = cm->mcomp_filter_type == SWITCHABLE
                              ? read_switchable_filter_type(pbi, r)
                              : cm->mcomp_filter_type;
666

John Koleszar's avatar
John Koleszar committed
667 668
    if (cm->comp_pred_mode == COMP_PREDICTION_ONLY ||
        (cm->comp_pred_mode == HYBRID_PREDICTION &&
669
         vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_COMP)))) {
John Koleszar's avatar
John Koleszar committed
670 671 672 673 674 675 676 677 678 679
      /* 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;
680
      if (mbmi->second_ref_frame > 0) {
681 682 683 684
        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];
685

686
        setup_pre_planes(xd, NULL, &cm->yv12_fb[second_ref_fb_idx],
687
                         mi_row, mi_col, xd->scale_factor, xd->scale_factor_uv);
688

689
        vp9_find_mv_refs(cm, xd, mi,
Yunqing Wang's avatar
Yunqing Wang committed
690 691
                         use_prev_in_find_mv_refs ?
                         xd->prev_mode_info_context : NULL,
692
                         second_ref_frame, mbmi->ref_mvs[second_ref_frame],
Paul Wilkins's avatar
Paul Wilkins committed
693
                         cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
694

695 696
        if (mbmi->mode != ZEROMV) {
          vp9_find_best_ref_mvs(xd,
697
                                mbmi->ref_mvs[second_ref_frame],
698 699
                                &nearest_second,
                                &nearby_second);
700
          best_mv_second.as_int = mbmi->ref_mvs[second_ref_frame][0].as_int;
701
        }
702
      }
Yaowu Xu's avatar
Yaowu Xu committed
703

John Koleszar's avatar
John Koleszar committed
704
    }
705

John Koleszar's avatar
John Koleszar committed
706 707
    mbmi->uv_mode = DC_PRED;
    switch (mbmi->mode) {
708 709 710
      case SPLITMV:
#if !CONFIG_AB4X4
        bw = 1, bh = 1;
711
#endif
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 769 770 771 772 773 774 775 776 777 778 779 780 781 782
        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
783
          }
784
        }
John Koleszar's avatar
John Koleszar committed
785

786 787 788
        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
789 790

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

      case NEARESTMV:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
804
        // Clip "next_nearest" so that it does not extend to far out of image