vp9_decodemv.c 50.3 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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
38
static B_PREDICTION_MODE read_bmode(vp9_reader *bc, const vp9_prob *p) {
39 40 41 42 43 44 45 46 47
  B_PREDICTION_MODE m = treed_read(bc, vp9_bmode_tree, p);
#if CONFIG_NEWBINTRAMODES
  if (m == B_CONTEXT_PRED - CONTEXT_PRED_REPLACEMENTS)
    m = B_CONTEXT_PRED;
  assert(m < B_CONTEXT_PRED - CONTEXT_PRED_REPLACEMENTS || m == B_CONTEXT_PRED);
#endif
  return m;
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
48 49
static B_PREDICTION_MODE read_kf_bmode(vp9_reader *bc, const vp9_prob *p) {
  return (B_PREDICTION_MODE)treed_read(bc, vp9_kf_bmode_tree, p);
Scott LaVarnway's avatar
Scott LaVarnway committed
50 51
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
52 53
static MB_PREDICTION_MODE read_ymode(vp9_reader *bc, const vp9_prob *p) {
  return (MB_PREDICTION_MODE)treed_read(bc, vp9_ymode_tree, p);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
54
}
Scott LaVarnway's avatar
Scott LaVarnway committed
55

Dmitry Kovalev's avatar
Dmitry Kovalev committed
56 57
static MB_PREDICTION_MODE read_sb_ymode(vp9_reader *bc, const vp9_prob *p) {
  return (MB_PREDICTION_MODE)treed_read(bc, vp9_sb_ymode_tree, p);
58 59
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
60 61
static MB_PREDICTION_MODE read_kf_sb_ymode(vp9_reader *bc, const vp9_prob *p) {
  return (MB_PREDICTION_MODE)treed_read(bc, vp9_uv_mode_tree, p);
Scott LaVarnway's avatar
Scott LaVarnway committed
62 63
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
64 65
static MB_PREDICTION_MODE read_kf_mb_ymode(vp9_reader *bc, const vp9_prob *p) {
  return (MB_PREDICTION_MODE)treed_read(bc, vp9_kf_ymode_tree, p);
Scott LaVarnway's avatar
Scott LaVarnway committed
66 67
}

68 69
static int read_i8x8_mode(vp9_reader *bc, const vp9_prob *p) {
  return treed_read(bc, vp9_i8x8_mode_tree, p);
Yaowu Xu's avatar
Yaowu Xu committed
70
}
Scott LaVarnway's avatar
Scott LaVarnway committed
71

Dmitry Kovalev's avatar
Dmitry Kovalev committed
72 73
static MB_PREDICTION_MODE read_uv_mode(vp9_reader *bc, const vp9_prob *p) {
  return (MB_PREDICTION_MODE)treed_read(bc, vp9_uv_mode_tree, p);
Scott LaVarnway's avatar
Scott LaVarnway committed
74 75
}

76
// This function reads the current macro block's segnent id from the bitstream
Paul Wilkins's avatar
Paul Wilkins committed
77
// It should only be called if a segment map update is indicated.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
78
static void read_mb_segid(vp9_reader *r, MB_MODE_INFO *mi, MACROBLOCKD *xd) {
Paul Wilkins's avatar
Paul Wilkins committed
79
  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
80 81 82
    const vp9_prob *const p = xd->mb_segment_tree_probs;
    mi->segment_id = vp9_read(r, p[0]) ? 2 + vp9_read(r, p[2])
                                       : vp9_read(r, p[1]);
John Koleszar's avatar
John Koleszar committed
83
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
84
}
85

86 87 88 89 90
// This function reads the current macro block's segnent id from the bitstream
// It should only be called if a segment map update is indicated.
static void read_mb_segid_except(VP9_COMMON *cm,
                                 vp9_reader *r, MB_MODE_INFO *mi,
                                 MACROBLOCKD *xd, int mb_row, int mb_col) {
91 92 93 94
  const int mb_index = mb_row * cm->mb_cols + mb_col;
  const int pred_seg_id = vp9_get_pred_mb_segid(cm, xd, mb_index);
  const vp9_prob *const p = xd->mb_segment_tree_probs;
  const vp9_prob prob = xd->mb_segment_mispred_tree_probs[pred_seg_id];
95 96

  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
97 98 99
    mi->segment_id = vp9_read(r, prob)
        ? 2 + (pred_seg_id  < 2 ? vp9_read(r, p[2]) : (pred_seg_id == 2))
        :     (pred_seg_id >= 2 ? vp9_read(r, p[1]) : (pred_seg_id == 0));
100 101 102
  }
}

103
#if CONFIG_NEW_MVREF
Dmitry Kovalev's avatar
Dmitry Kovalev committed
104
int vp9_read_mv_ref_id(vp9_reader *r, vp9_prob *ref_id_probs) {
105 106
  int ref_index = 0;

107
  if (vp9_read(r, ref_id_probs[0])) {
108
    ref_index++;
109
    if (vp9_read(r, ref_id_probs[1])) {
110
      ref_index++;
111
      if (vp9_read(r, ref_id_probs[2]))
112 113 114 115 116 117 118
        ref_index++;
    }
  }
  return ref_index;
}
#endif

119
extern const int vp9_i8x8_block[4];
120
static void kfread_modes(VP9D_COMP *pbi,
John Koleszar's avatar
John Koleszar committed
121 122 123 124
                         MODE_INFO *m,
                         int mb_row,
                         int mb_col,
                         BOOL_DECODER* const bc) {
125
  VP9_COMMON *const cm = &pbi->common;
126
  MACROBLOCKD *const xd  = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
127 128 129 130
  const int mis = pbi->common.mode_info_stride;
  int map_index = mb_row * pbi->common.mb_cols + mb_col;
  MB_PREDICTION_MODE y_mode;

131 132
  m->mbmi.ref_frame = INTRA_FRAME;

John Koleszar's avatar
John Koleszar committed
133 134 135 136
  // Read the Macroblock segmentation map if it is being updated explicitly
  // this frame (reset to 0 by default).
  m->mbmi.segment_id = 0;
  if (pbi->mb.update_mb_segmentation_map) {
137
    read_mb_segid(bc, &m->mbmi, &pbi->mb);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
138
    if (m->mbmi.sb_type) {
139 140 141 142
      const int bw = 1 << mb_width_log2(m->mbmi.sb_type);
      const int bh = 1 << mb_height_log2(m->mbmi.sb_type);
      const int ymbs = MIN(cm->mb_rows - mb_row, bh);
      const int xmbs = MIN(cm->mb_cols - mb_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
143 144 145 146 147 148 149 150
      int x, y;

      for (y = 0; y < ymbs; y++) {
        for (x = 0; x < xmbs; x++) {
          cm->last_frame_seg_map[map_index + x + y * cm->mb_cols] =
              m->mbmi.segment_id;
        }
      }
151
    } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
152 153
      cm->last_frame_seg_map[map_index] = m->mbmi.segment_id;
    }
John Koleszar's avatar
John Koleszar committed
154 155
  }

156 157 158
  m->mbmi.mb_skip_coeff = vp9_segfeature_active(&pbi->mb, m->mbmi.segment_id,
                                                SEG_LVL_SKIP);
  if (!m->mbmi.mb_skip_coeff)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
159 160
    m->mbmi.mb_skip_coeff = vp9_read(bc, vp9_get_pred_prob(cm, &pbi->mb,
                                                           PRED_MBSKIP));
John Koleszar's avatar
John Koleszar committed
161

Dmitry Kovalev's avatar
Dmitry Kovalev committed
162 163 164 165 166
  y_mode = m->mbmi.sb_type ?
      read_kf_sb_ymode(bc,
          pbi->common.sb_kf_ymode_prob[pbi->common.kf_ymode_probs_index]):
      read_kf_mb_ymode(bc,
          pbi->common.kf_ymode_prob[pbi->common.kf_ymode_probs_index]);
167

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

Yaowu Xu's avatar
Yaowu Xu committed
170
  if ((m->mbmi.mode = y_mode) == I4X4_PRED) {
John Koleszar's avatar
John Koleszar committed
171 172
    int i = 0;
    do {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
173 174
      const B_PREDICTION_MODE a = above_block_mode(m, i, mis);
      const B_PREDICTION_MODE l = (xd->left_available || (i & 3)) ?
175
                                  left_block_mode(m, i) : B_DC_PRED;
Paul Wilkins's avatar
Paul Wilkins committed
176

Dmitry Kovalev's avatar
Dmitry Kovalev committed
177 178
      m->bmi[i].as_mode.first = read_kf_bmode(bc,
                                              pbi->common.kf_bmode_prob[a][l]);
John Koleszar's avatar
John Koleszar committed
179 180
    } while (++i < 16);
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
181

John Koleszar's avatar
John Koleszar committed
182 183 184
  if ((m->mbmi.mode = y_mode) == I8X8_PRED) {
    int i;
    for (i = 0; i < 4; i++) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
185 186 187
      const int ib = vp9_i8x8_block[i];
      const int mode8x8 = read_i8x8_mode(bc, pbi->common.fc.i8x8_mode_prob);

John Koleszar's avatar
John Koleszar committed
188 189 190 191 192
      m->bmi[ib + 0].as_mode.first = mode8x8;
      m->bmi[ib + 1].as_mode.first = mode8x8;
      m->bmi[ib + 4].as_mode.first = mode8x8;
      m->bmi[ib + 5].as_mode.first = mode8x8;
    }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
193 194 195 196
  } else {
    m->mbmi.uv_mode = read_uv_mode(bc,
                                   pbi->common.kf_uv_mode_prob[m->mbmi.mode]);
  }
197

Dmitry Kovalev's avatar
Dmitry Kovalev committed
198 199
  if (cm->txfm_mode == TX_MODE_SELECT &&
      m->mbmi.mb_skip_coeff == 0 &&
200
      m->mbmi.mode <= I8X8_PRED) {
201
    // FIXME(rbultje) code ternary symbol once all experiments are merged
202
    m->mbmi.txfm_size = vp9_read(bc, cm->prob_tx[0]);
203
    if (m->mbmi.txfm_size != TX_4X4 && m->mbmi.mode != I8X8_PRED) {
204
      m->mbmi.txfm_size += vp9_read(bc, cm->prob_tx[1]);
205
      if (m->mbmi.txfm_size != TX_8X8 && m->mbmi.sb_type >= BLOCK_SIZE_SB32X32)
206 207
        m->mbmi.txfm_size += vp9_read(bc, cm->prob_tx[2]);
    }
208 209
  } else if (cm->txfm_mode >= ALLOW_32X32 &&
             m->mbmi.sb_type >= BLOCK_SIZE_SB32X32) {
210
    m->mbmi.txfm_size = TX_32X32;
211
  } else if (cm->txfm_mode >= ALLOW_16X16 && m->mbmi.mode <= TM_PRED) {
212
    m->mbmi.txfm_size = TX_16X16;
Yaowu Xu's avatar
Yaowu Xu committed
213
  } else if (cm->txfm_mode >= ALLOW_8X8 && m->mbmi.mode != I4X4_PRED) {
214 215 216 217
    m->mbmi.txfm_size = TX_8X8;
  } else {
    m->mbmi.txfm_size = TX_4X4;
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
218
}
John Koleszar's avatar
John Koleszar committed
219

220
static int read_nmv_component(vp9_reader *r,
221 222
                              int rv,
                              const nmv_component *mvcomp) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
223 224 225 226 227
  int mag, d;
  const int sign = vp9_read(r, mvcomp->sign);
  const int mv_class = treed_read(r, vp9_mv_class_tree, mvcomp->classes);

  if (mv_class == MV_CLASS_0) {
228
    d = treed_read(r, vp9_mv_class0_tree, mvcomp->class0);
229
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
230 231 232
    int i;
    int n = mv_class + CLASS0_BITS - 1;  // number of bits

233
    d = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
234 235
    for (i = 0; i < n; ++i)
      d |= vp9_read(r, mvcomp->bits[i]) << i;
236 237
  }

Dmitry Kovalev's avatar
Dmitry Kovalev committed
238 239
  mag = vp9_get_mv_mag(mv_class, d << 3);
  return sign ? -(mag + 8) : (mag + 8);
240 241
}

242
static int read_nmv_component_fp(vp9_reader *r,
243 244 245 246
                                 int v,
                                 int rv,
                                 const nmv_component *mvcomp,
                                 int usehp) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
247 248 249 250 251 252 253
  const int sign = v < 0;
  int mag = ((sign ? -v : v) - 1) & ~7;  // magnitude - 1
  int offset;
  const int mv_class = vp9_get_mv_class(mag, &offset);
  const int f = mv_class == MV_CLASS_0 ?
      treed_read(r, vp9_mv_fp_tree, mvcomp->class0_fp[offset >> 3]):
      treed_read(r, vp9_mv_fp_tree, mvcomp->fp);
254

Dmitry Kovalev's avatar
Dmitry Kovalev committed
255
  offset += f << 1;
256 257

  if (usehp) {
258 259
    const vp9_prob p = mv_class == MV_CLASS_0 ? mvcomp->class0_hp : mvcomp->hp;
    offset += vp9_read(r, p);
260
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
261
    offset += 1;  // If hp is not used, the default value of the hp bit is 1
262
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
263 264
  mag = vp9_get_mv_mag(mv_class, offset);
  return sign ? -(mag + 1) : (mag + 1);
265 266
}

267
static void read_nmv(vp9_reader *r, MV *mv, const MV *ref,
268
                     const nmv_context *mvctx) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
269
  const MV_JOINT_TYPE j = treed_read(r, vp9_mv_joint_tree, mvctx->joints);
270 271
  mv->row = mv->col = 0;

272
  if (mv_joint_vertical(j))
273
    mv->row = read_nmv_component(r, ref->row, &mvctx->comps[0]);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
274

275
  if (mv_joint_horizontal(j))
276 277 278
    mv->col = read_nmv_component(r, ref->col, &mvctx->comps[1]);
}

279
static void read_nmv_fp(vp9_reader *r, MV *mv, const MV *ref,
280
                        const nmv_context *mvctx, int usehp) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
281
  const MV_JOINT_TYPE j = vp9_get_mv_joint(*mv);
282
  usehp = usehp && vp9_use_nmv_hp(ref);
283
  if (mv_joint_vertical(j))
284 285
    mv->row = read_nmv_component_fp(r, mv->row, ref->row, &mvctx->comps[0],
                                    usehp);
286

287
  if (mv_joint_horizontal(j))
288 289 290 291
    mv->col = read_nmv_component_fp(r, mv->col, ref->col, &mvctx->comps[1],
                                    usehp);
}

292 293 294
static void update_nmv(vp9_reader *bc, vp9_prob *const p,
                       const vp9_prob upd_p) {
  if (vp9_read(bc, upd_p)) {
295
#ifdef LOW_PRECISION_MV_UPDATE
296
    *p = (vp9_read_literal(bc, 7) << 1) | 1;
297
#else
298
    *p = (vp9_read_literal(bc, 8));
299 300 301 302
#endif
  }
}

303
static void read_nmvprobs(vp9_reader *bc, nmv_context *mvctx,
304 305
                          int usehp) {
  int i, j, k;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
306

307
#ifdef MV_GROUP_UPDATE
Dmitry Kovalev's avatar
Dmitry Kovalev committed
308 309
  if (!vp9_read_bit(bc))
    return;
310
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
311 312 313
  for (j = 0; j < MV_JOINTS - 1; ++j)
    update_nmv(bc, &mvctx->joints[j], VP9_NMV_UPDATE_PROB);

314
  for (i = 0; i < 2; ++i) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
315 316 317 318 319 320 321 322 323
    update_nmv(bc, &mvctx->comps[i].sign, VP9_NMV_UPDATE_PROB);
    for (j = 0; j < MV_CLASSES - 1; ++j)
      update_nmv(bc, &mvctx->comps[i].classes[j], VP9_NMV_UPDATE_PROB);

    for (j = 0; j < CLASS0_SIZE - 1; ++j)
      update_nmv(bc, &mvctx->comps[i].class0[j], VP9_NMV_UPDATE_PROB);

    for (j = 0; j < MV_OFFSET_BITS; ++j)
      update_nmv(bc, &mvctx->comps[i].bits[j], VP9_NMV_UPDATE_PROB);
324 325 326
  }

  for (i = 0; i < 2; ++i) {
327
    for (j = 0; j < CLASS0_SIZE; ++j)
328
      for (k = 0; k < 3; ++k)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
329 330 331 332
        update_nmv(bc, &mvctx->comps[i].class0_fp[j][k], VP9_NMV_UPDATE_PROB);

    for (j = 0; j < 3; ++j)
      update_nmv(bc, &mvctx->comps[i].fp[j], VP9_NMV_UPDATE_PROB);
333 334 335 336
  }

  if (usehp) {
    for (i = 0; i < 2; ++i) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
337 338
      update_nmv(bc, &mvctx->comps[i].class0_hp, VP9_NMV_UPDATE_PROB);
      update_nmv(bc, &mvctx->comps[i].hp, VP9_NMV_UPDATE_PROB);
339 340 341 342
    }
  }
}

343
// Read the referncence frame
344
static MV_REFERENCE_FRAME read_ref_frame(VP9D_COMP *pbi,
345
                                         vp9_reader *const bc,
John Koleszar's avatar
John Koleszar committed
346 347
                                         unsigned char segment_id) {
  MV_REFERENCE_FRAME ref_frame;
348
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
349 350
  MACROBLOCKD *const xd = &pbi->mb;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
351
  int seg_ref_count = 0;
352 353 354 355 356 357 358
  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
359 360 361

  // If segment coding enabled does the segment allow for more than one
  // possible reference frame
362 363
  if (seg_ref_active)
    seg_ref_count = intra + last + golden + altref;
John Koleszar's avatar
John Koleszar committed
364 365 366

  // Segment reference frame features not available or allows for
  // multiple reference frame options
367
  if (!seg_ref_active || seg_ref_count > 1) {
John Koleszar's avatar
John Koleszar committed
368 369 370 371
    // 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
372
    vp9_prob pred_prob = vp9_get_pred_prob(cm, xd, PRED_REF);
John Koleszar's avatar
John Koleszar committed
373 374

    // Read the prediction status flag
Dmitry Kovalev's avatar
Dmitry Kovalev committed
375
    unsigned char prediction_flag = vp9_read(bc, pred_prob);
John Koleszar's avatar
John Koleszar committed
376 377

    // Store the prediction flag.
Paul Wilkins's avatar
Paul Wilkins committed
378
    vp9_set_pred_flag(xd, PRED_REF, prediction_flag);
John Koleszar's avatar
John Koleszar committed
379 380

    // Get the predicted reference frame.
Paul Wilkins's avatar
Paul Wilkins committed
381
    pred_ref = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
382 383 384 385

    // If correctly predicted then use the predicted value
    if (prediction_flag) {
      ref_frame = pred_ref;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
386 387
    } else {
      // decode the explicitly coded value
388
      vp9_prob mod_refprobs[PREDICTION_PROBS];
389 390
      vpx_memcpy(mod_refprobs, cm->mod_refprobs[pred_ref],
                 sizeof(mod_refprobs));
John Koleszar's avatar
John Koleszar committed
391 392 393 394

      // If segment coding enabled blank out options that cant occur by
      // setting the branch probability to 0.
      if (seg_ref_active) {
395 396 397
        mod_refprobs[INTRA_FRAME] *= intra;
        mod_refprobs[LAST_FRAME] *= last;
        mod_refprobs[GOLDEN_FRAME] *= golden * altref;
John Koleszar's avatar
John Koleszar committed
398 399 400 401 402 403 404
      }

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

      // Do we need to decode the Intra/Inter branch
      if (mod_refprobs[0])
405
        ref_frame = vp9_read(bc, mod_refprobs[0]);
John Koleszar's avatar
John Koleszar committed
406 407 408 409 410 411
      else
        ref_frame++;

      if (ref_frame) {
        // Do we need to decode the Last/Gf_Arf branch
        if (mod_refprobs[1])
412
          ref_frame += vp9_read(bc, mod_refprobs[1]);
413
        else
John Koleszar's avatar
John Koleszar committed
414 415 416 417
          ref_frame++;

        if (ref_frame > 1) {
          // Do we need to decode the GF/Arf branch
418
          if (mod_refprobs[2]) {
419
            ref_frame += vp9_read(bc, mod_refprobs[2]);
420
          } else {
421 422 423 424 425 426
            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
427
          }
428
        }
John Koleszar's avatar
John Koleszar committed
429
      }
430
    }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
431 432
  } else {
    // Segment reference frame features are enabled
John Koleszar's avatar
John Koleszar committed
433 434 435
    // 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
436 437
    vp9_set_pred_flag(xd, PRED_REF, 1);
    ref_frame = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
438 439
  }

440
  return ref_frame;
441
}
John Koleszar's avatar
John Koleszar committed
442

443 444
static MB_PREDICTION_MODE read_sb_mv_ref(vp9_reader *bc, const vp9_prob *p) {
  return (MB_PREDICTION_MODE) treed_read(bc, vp9_sb_mv_ref_tree, p);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
445
}
John Koleszar's avatar
John Koleszar committed
446

447 448
static MB_PREDICTION_MODE read_mv_ref(vp9_reader *bc, const vp9_prob *p) {
  return (MB_PREDICTION_MODE) treed_read(bc, vp9_mv_ref_tree, p);
John Koleszar's avatar
John Koleszar committed
449 450
}

451 452
static B_PREDICTION_MODE sub_mv_ref(vp9_reader *bc, const vp9_prob *p) {
  return (B_PREDICTION_MODE) treed_read(bc, vp9_sub_mv_ref_tree, p);
John Koleszar's avatar
John Koleszar committed
453
}
Scott LaVarnway's avatar
Scott LaVarnway committed
454 455

#ifdef VPX_MODE_COUNT
456
unsigned int vp9_mv_cont_count[5][4] = {
John Koleszar's avatar
John Koleszar committed
457 458 459 460 461
  { 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
462
};
Scott LaVarnway's avatar
Scott LaVarnway committed
463
#endif
John Koleszar's avatar
John Koleszar committed
464

Dmitry Kovalev's avatar
Dmitry Kovalev committed
465
static const unsigned char mbsplit_fill_count[4] = { 8, 8, 4, 1 };
466
static const unsigned char mbsplit_fill_offset[4][16] = {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
467 468 469 470
  { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15 },
  { 0,  1,  4,  5,  8,  9, 12, 13,  2,  3,   6,  7, 10, 11, 14, 15 },
  { 0,  1,  4,  5,  2,  3,  6,  7,  8,  9,  12, 13, 10, 11, 14, 15 },
  { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15 }
Scott LaVarnway's avatar
Scott LaVarnway committed
471
};
John Koleszar's avatar
John Koleszar committed
472

473
static void read_switchable_interp_probs(VP9D_COMP* const pbi,
John Koleszar's avatar
John Koleszar committed
474
                                         BOOL_DECODER* const bc) {
475
  VP9_COMMON *const cm = &pbi->common;
476
  int i, j;
477
  for (j = 0; j < VP9_SWITCHABLE_FILTERS + 1; ++j) {
478
    for (i = 0; i < VP9_SWITCHABLE_FILTERS - 1; ++i) {
479
      cm->fc.switchable_interp_prob[j][i] = vp9_read_prob(bc);
480 481 482 483 484
    }
  }
  //printf("DECODER: %d %d\n", cm->fc.switchable_interp_prob[0],
  //cm->fc.switchable_interp_prob[1]);
}
John Koleszar's avatar
John Koleszar committed
485

486 487 488 489 490 491 492 493
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) {
494
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
495

496 497
  if (cm->frame_type == KEY_FRAME) {
    if (!cm->kf_ymode_probs_update)
498
      cm->kf_ymode_probs_index = vp9_read_literal(r, 3);
499
  } else {
500 501
    int i;

502
    if (cm->mcomp_filter_type == SWITCHABLE)
503
      read_switchable_interp_probs(pbi, r);
504 505
#if CONFIG_COMP_INTERINTRA_PRED
    if (cm->use_interintra) {
506 507
      if (vp9_read(r, VP9_UPD_INTERINTRA_PROB))
        cm->fc.interintra_prob = vp9_read_prob(r);
508 509
    }
#endif
510 511 512 513
    // 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
514 515 516

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

519 520
    cm->comp_pred_mode = read_comp_pred_mode(r);
    if (cm->comp_pred_mode == HYBRID_PREDICTION)
John Koleszar's avatar
John Koleszar committed
521
      for (i = 0; i < COMP_PRED_CONTEXTS; i++)
522
        cm->prob_comppred[i] = vp9_read_prob(r);
John Koleszar's avatar
John Koleszar committed
523

524 525
    // VP9_YMODES
    if (vp9_read_bit(r))
526
      for (i = 0; i < VP9_YMODES - 1; ++i)
527
        cm->fc.ymode_prob[i] = vp9_read_prob(r);
528

529 530
    // VP9_I32X32_MODES
    if (vp9_read_bit(r))
531
      for (i = 0; i < VP9_I32X32_MODES - 1; ++i)
532
        cm->fc.sb_ymode_prob[i] = vp9_read_prob(r);
533

534
    read_nmvprobs(r, &cm->fc.nmvc, pbi->mb.allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
535
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
536
}
John Koleszar's avatar
John Koleszar committed
537

538 539 540
// 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
541
static void read_mb_segment_id(VP9D_COMP *pbi,
John Koleszar's avatar
John Koleszar committed
542 543
                               int mb_row, int mb_col,
                               BOOL_DECODER* const bc) {
544
  VP9_COMMON *const cm = &pbi->common;
545
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
546 547
  MODE_INFO *mi = xd->mode_info_context;
  MB_MODE_INFO *mbmi = &mi->mbmi;
548
  int mb_index = mb_row * pbi->common.mb_cols + mb_col;
John Koleszar's avatar
John Koleszar committed
549 550 551 552 553 554 555

  if (xd->segmentation_enabled) {
    if (xd->update_mb_segmentation_map) {
      // Is temporal coding of the segment id for this mb enabled.
      if (cm->temporal_update) {
        // Get the context based probability for reading the
        // prediction status flag
Dmitry Kovalev's avatar
Dmitry Kovalev committed
556
        vp9_prob pred_prob = vp9_get_pred_prob(cm, xd, PRED_SEG_ID);
557

John Koleszar's avatar
John Koleszar committed
558
        // Read the prediction status flag
Dmitry Kovalev's avatar
Dmitry Kovalev committed
559
        unsigned char seg_pred_flag = vp9_read(bc, pred_prob);
560

John Koleszar's avatar
John Koleszar committed
561
        // Store the prediction flag.
Paul Wilkins's avatar
Paul Wilkins committed
562
        vp9_set_pred_flag(xd, PRED_SEG_ID, seg_pred_flag);
John Koleszar's avatar
John Koleszar committed
563 564 565 566

        // If the value is flagged as correctly predicted
        // then use the predicted value
        if (seg_pred_flag) {
567
          mbmi->segment_id = vp9_get_pred_mb_segid(cm, xd, mb_index);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
568 569
        } else {
          // Decode it explicitly
570
          read_mb_segid_except(cm, bc, mbmi, xd, mb_row, mb_col);
John Koleszar's avatar
John Koleszar committed
571
        }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
572 573
      } else {
        // Normal unpredicted coding mode
574
        read_mb_segid(bc, mbmi, xd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
575
      }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
576

Ronald S. Bultje's avatar
Ronald S. Bultje committed
577
      if (mbmi->sb_type) {
578 579 580 581
        const int bw = 1 << mb_width_log2(mbmi->sb_type);
        const int bh = 1 << mb_height_log2(mbmi->sb_type);
        const int ymbs = MIN(cm->mb_rows - mb_row, bh);
        const int xmbs = MIN(cm->mb_cols - mb_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
582 583 584 585
        int x, y;

        for (y = 0; y < ymbs; y++) {
          for (x = 0; x < xmbs; x++) {
586
            cm->last_frame_seg_map[mb_index + x + y * cm->mb_cols] =
Ronald S. Bultje's avatar
Ronald S. Bultje committed
587 588
                mbmi->segment_id;
          }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
589
        }
590
      } else {
591
        cm->last_frame_seg_map[mb_index] = mbmi->segment_id;
John Koleszar's avatar
John Koleszar committed
592
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
593
    } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
594
      if (mbmi->sb_type) {
595 596 597 598
        const int bw = 1 << mb_width_log2(mbmi->sb_type);
        const int bh = 1 << mb_height_log2(mbmi->sb_type);
        const int ymbs = MIN(cm->mb_rows - mb_row, bh);
        const int xmbs = MIN(cm->mb_cols - mb_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
599 600 601 602 603 604
        unsigned segment_id = -1;
        int x, y;

        for (y = 0; y < ymbs; y++) {
          for (x = 0; x < xmbs; x++) {
            segment_id = MIN(segment_id,
605
                cm->last_frame_seg_map[mb_index + x + y * cm->mb_cols]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
606
          }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
607
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
608
        mbmi->segment_id = segment_id;
609
      } else {
610
        mbmi->segment_id = cm->last_frame_seg_map[mb_index];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
611
      }
612
    }
John Koleszar's avatar
John Koleszar committed
613 614 615 616 617
  } else {
    // The encoder explicitly sets the segment_id to 0
    // when segmentation is disabled
    mbmi->segment_id = 0;
  }
618
}
619

Dmitry Kovalev's avatar
Dmitry Kovalev committed
620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640

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

static INLINE void process_mv(BOOL_DECODER* bc, MV *mv, MV *ref,
                              nmv_context *nmvc, nmv_context_counts *mvctx,
                              int usehp) {
  read_nmv(bc, mv, ref, nmvc);
  read_nmv_fp(bc, mv, ref, nmvc, usehp);
  vp9_increment_nmv(mv, ref, mvctx, usehp);
  mv->row += ref->row;
  mv->col += ref->col;
}

641 642 643 644 645 646 647 648 649
static INLINE INTERPOLATIONFILTERTYPE read_switchable_filter_type(
    VP9D_COMP *pbi, BOOL_DECODER* bc) {
  const int index = treed_read(bc,
                               vp9_switchable_interp_tree,
                               vp9_get_pred_probs(&pbi->common, &pbi->mb,
                                                  PRED_SWITCHABLE_INTERP));
  return vp9_switchable_interp[index];
}

650
static void read_mb_modes_mv(VP9D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
651
                             MODE_INFO *prev_mi,
John Koleszar's avatar
John Koleszar committed
652 653
                             int mb_row, int mb_col,
                             BOOL_DECODER* const bc) {
654
  VP9_COMMON *const cm = &pbi->common;
655
  nmv_context *const nmvc = &pbi->common.fc.nmvc;
John Koleszar's avatar
John Koleszar committed
656
  const int mis = pbi->common.mode_info_stride;
657
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
658

659
  int_mv *const mv = &mbmi->mv[0];
660 661
  const int bw = 1 << mb_width_log2(mi->mbmi.sb_type);
  const int bh = 1 << mb_height_log2(mi->mbmi.sb_type);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
662

663 664
  const int use_prev_in_find_mv_refs = cm->width == cm->last_width &&
                                       cm->height == cm->last_height &&
665
                                       !cm->error_resilient_mode;
John Koleszar's avatar
John Koleszar committed
666

667
  int mb_to_left_edge, mb_to_right_edge, mb_to_top_edge, mb_to_bottom_edge;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
668

John Koleszar's avatar
John Koleszar committed
669 670
  mbmi->need_to_clamp_mvs = 0;
  mbmi->need_to_clamp_secondmv = 0;
671
  mbmi->second_ref_frame = NONE;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
672

673 674 675 676 677
  // Make sure the MACROBLOCKD mode info pointer is pointed at the
  // correct entry for the current macroblock.
  xd->mode_info_context = mi;
  xd->prev_mode_info_context = prev_mi;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
678 679 680
  // 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
681 682
  set_mb_row(cm, xd, mb_row, bh);
  set_mb_col(cm, xd, mb_col, bw);
683

684 685
  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
686 687
  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
688 689

  // Read the macroblock segment id.
John Koleszar's avatar
John Koleszar committed
690
  read_mb_segment_id(pbi, mb_row, mb_col, bc);
John Koleszar's avatar
John Koleszar committed
691

692 693 694
  mbmi->mb_skip_coeff = vp9_segfeature_active(xd, mbmi->segment_id,
                                              SEG_LVL_SKIP);
  if (!mbmi->mb_skip_coeff)
695
    mbmi->mb_skip_coeff = vp9_read(bc, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
John Koleszar's avatar
John Koleszar committed
696 697

  // Read the reference frame
Paul Wilkins's avatar
Paul Wilkins committed
698
  mbmi->ref_frame = read_ref_frame(pbi, bc, mbmi->segment_id);
John Koleszar's avatar
John Koleszar committed
699

700 701
  // if (pbi->common.current_video_frame == 1)
  //   printf("ref frame: %d [%d %d]\n", mbmi->ref_frame, mb_row, mb_col);
702

John Koleszar's avatar
John Koleszar committed
703 704 705 706
  // 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
707
    vp9_prob mv_ref_p[VP9_MVREFS - 1];
John Koleszar's avatar
John Koleszar committed
708

709 710 711 712
    const MV_REFERENCE_FRAME ref_frame = mbmi->ref_frame;
    struct scale_factors *sf0 = &xd->scale_factor[0];
    struct scale_factors *sf_uv0 = &xd->scale_factor_uv[0];
    *sf0 = cm->active_ref_scale[mbmi->ref_frame - 1];
713 714

    {
715 716 717 718
      const int use_prev_in_find_best_ref = sf0->x_num == sf0->x_den &&
                                            sf0->y_num == sf0->y_den &&
                                            !cm->error_resilient_mode &&
                                            !cm->frame_parallel_decoding_mode;
719

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

723
      setup_pred_block(&xd->pre, &cm->yv12_fb[ref_fb_idx],
724
                       mb_row, mb_col, sf0, sf_uv0);
725

726 727 728 729 730
#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
731
      vp9_find_mv_refs(cm, xd, mi, use_prev_in_find_mv_refs ? prev_mi : NULL,
Paul Wilkins's avatar
Paul Wilkins committed
732 733
                       ref_frame, mbmi->ref_mvs[ref_frame],
                       cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
734

735
      vp9_mv_ref_probs(cm, mv_ref_p, mbmi->mb_mode_context[ref_frame]);
736

737
      // If the segment level skip mode enabled
Paul Wilkins's avatar
Paul Wilkins committed
738 739
      if (vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP)) {
        mbmi->mode = ZEROMV;
740
      } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
741 742
        mbmi->mode = mbmi->sb_type ? read_sb_mv_ref(bc, mv_ref_p)
                                   : read_mv_ref(bc, mv_ref_p);
743
        vp9_accum_mv_refs(cm, mbmi->mode, mbmi->mb_mode_context[ref_frame]);
744 745 746 747
      }

      if (mbmi->mode != ZEROMV) {
        vp9_find_best_ref_mvs(xd,
748 749
                              use_prev_in_find_best_ref ? xd->pre.y_buffer
                                                        : NULL,
750
                              xd->pre.y_stride,
751 752 753
                              mbmi->ref_mvs[ref_frame],
                              &nearest, &nearby);

754
        best_mv.as_int = mbmi->ref_mvs[ref_frame][0].as_int;
755
      }
756

757 758 759 760 761 762
#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
763
    }
John Koleszar's avatar
John Koleszar committed
764

Dmitry Kovalev's avatar
Dmitry Kovalev committed
765
    if (mbmi->mode >= NEARESTMV && mbmi->mode <= SPLITMV) {
766 767 768
      mbmi->interp_filter = cm->mcomp_filter_type == SWITCHABLE
                                ? read_switchable_filter_type(pbi, bc)
                                : cm->mcomp_filter_type;
769
    }
770

John Koleszar's avatar
John Koleszar committed
771 772
    if (cm->comp_pred_mode == COMP_PREDICTION_ONLY ||
        (cm->comp_pred_mode == HYBRID_PREDICTION &&
773
         vp9_read(bc, vp9_get_pred_prob(cm, xd, PRED_COMP)))) {
John Koleszar's avatar
John Koleszar committed
774 775 776 777 778 779 780 781 782 783
      /* 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;
784
      if (mbmi->second_ref_frame > 0) {
785 786 787 788 789 790 791 792 793
        const MV_REFERENCE_FRAME second_ref_frame = mbmi->second_ref_frame;
        struct scale_factors *sf1 = &xd->scale_factor[1];
        struct scale_factors *sf_uv1 = &xd->scale_factor_uv[1];
        const int use_prev_in_find_best_ref = sf1->x_num == sf1->x_den &&
                                              sf1->y_num == sf1->y_den &&
                                              !cm->error_resilient_mode &&
                                              !cm->frame_parallel_decoding_mode;
        const int second_ref_fb_idx = cm->active_ref_idx[second_ref_frame - 1];
        *sf1 = cm->active_ref_scale[second_ref_frame - 1];
794

795
        setup_pred_block(&xd->second_pre, &cm->yv12_fb[second_ref_fb_idx],
796
                         mb_row, mb_col, sf1, sf_uv1);
797

798 799 800
        vp9_find_mv_refs(cm, xd, mi,
                         use_prev_in_find_mv_refs ? prev_mi : NULL,
                         second_ref_frame, mbmi->ref_mvs[second_ref_frame],