vp9_decodemv.c 50.6 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
  }

  m->mbmi.mb_skip_coeff = 0;
  if (pbi->common.mb_no_coeff_skip &&
Dmitry Kovalev's avatar
Dmitry Kovalev committed
158
      (!vp9_segfeature_active(&pbi->mb, m->mbmi.segment_id, SEG_LVL_SKIP))) {
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
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
162 163
    m->mbmi.mb_skip_coeff = vp9_segfeature_active(&pbi->mb, m->mbmi.segment_id,
                                                  SEG_LVL_SKIP);
John Koleszar's avatar
John Koleszar committed
164 165
  }

Dmitry Kovalev's avatar
Dmitry Kovalev committed
166 167 168 169 170
  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]);
171

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

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

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

John Koleszar's avatar
John Koleszar committed
186 187 188
  if ((m->mbmi.mode = y_mode) == I8X8_PRED) {
    int i;
    for (i = 0; i < 4; i++) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
189 190 191
      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
192 193 194 195 196
      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
197 198 199 200
  } else {
    m->mbmi.uv_mode = read_uv_mode(bc,
                                   pbi->common.kf_uv_mode_prob[m->mbmi.mode]);
  }
201

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

224
static int read_nmv_component(vp9_reader *r,
225 226
                              int rv,
                              const nmv_component *mvcomp) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
227 228 229 230 231
  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) {
232
    d = treed_read(r, vp9_mv_class0_tree, mvcomp->class0);
233
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
234 235 236
    int i;
    int n = mv_class + CLASS0_BITS - 1;  // number of bits

237
    d = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
238 239
    for (i = 0; i < n; ++i)
      d |= vp9_read(r, mvcomp->bits[i]) << i;
240 241
  }

Dmitry Kovalev's avatar
Dmitry Kovalev committed
242 243
  mag = vp9_get_mv_mag(mv_class, d << 3);
  return sign ? -(mag + 8) : (mag + 8);
244 245
}

246
static int read_nmv_component_fp(vp9_reader *r,
247 248 249 250
                                 int v,
                                 int rv,
                                 const nmv_component *mvcomp,
                                 int usehp) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
251 252 253 254 255 256 257
  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);
258

Dmitry Kovalev's avatar
Dmitry Kovalev committed
259
  offset += f << 1;
260 261

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

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

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

279
  if (mv_joint_horizontal(j))
280 281 282
    mv->col = read_nmv_component(r, ref->col, &mvctx->comps[1]);
}

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

291
  if (mv_joint_horizontal(j))
292 293 294 295
    mv->col = read_nmv_component_fp(r, mv->col, ref->col, &mvctx->comps[1],
                                    usehp);
}

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

307
static void read_nmvprobs(vp9_reader *bc, nmv_context *mvctx,
308 309
                          int usehp) {
  int i, j, k;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
310

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

318
  for (i = 0; i < 2; ++i) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
319 320 321 322 323 324 325 326 327
    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);
328 329 330
  }

  for (i = 0; i < 2; ++i) {
331
    for (j = 0; j < CLASS0_SIZE; ++j)
332
      for (k = 0; k < 3; ++k)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
333 334 335 336
        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);
337 338 339 340
  }

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

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
355
  int seg_ref_count = 0;
356 357 358 359 360 361 362
  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
363 364 365

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

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

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

    // Store the prediction flag.
Paul Wilkins's avatar
Paul Wilkins committed
382
    vp9_set_pred_flag(xd, PRED_REF, prediction_flag);
John Koleszar's avatar
John Koleszar committed
383 384

    // Get the predicted reference frame.
Paul Wilkins's avatar
Paul Wilkins committed
385
    pred_ref = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
386 387 388 389

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

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

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

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

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

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

444
  return ref_frame;
445
}
John Koleszar's avatar
John Koleszar committed
446

447 448
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
449
}
John Koleszar's avatar
John Koleszar committed
450

451 452
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
453 454
}

455 456
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
457
}
Scott LaVarnway's avatar
Scott LaVarnway committed
458 459

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
469
static const unsigned char mbsplit_fill_count[4] = { 8, 8, 4, 1 };
470
static const unsigned char mbsplit_fill_offset[4][16] = {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
471 472 473 474
  { 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
475
};
John Koleszar's avatar
John Koleszar committed
476

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

490 491 492 493 494 495 496 497
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) {
498
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
499

500 501
  if (cm->frame_type == KEY_FRAME) {
    if (!cm->kf_ymode_probs_update)
502
      cm->kf_ymode_probs_index = vp9_read_literal(r, 3);
503
  } else {
504 505
    int i;

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

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

523 524
    cm->comp_pred_mode = read_comp_pred_mode(r);
    if (cm->comp_pred_mode == HYBRID_PREDICTION)
John Koleszar's avatar
John Koleszar committed
525
      for (i = 0; i < COMP_PRED_CONTEXTS; i++)
526
        cm->prob_comppred[i] = vp9_read_prob(r);
John Koleszar's avatar
John Koleszar committed
527

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

533 534
    // VP9_I32X32_MODES
    if (vp9_read_bit(r))
535
      for (i = 0; i < VP9_I32X32_MODES - 1; ++i)
536
        cm->fc.sb_ymode_prob[i] = vp9_read_prob(r);
537

538
    read_nmvprobs(r, &cm->fc.nmvc, pbi->mb.allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
539
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
540
}
John Koleszar's avatar
John Koleszar committed
541

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

  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
560
        vp9_prob pred_prob = vp9_get_pred_prob(cm, xd, PRED_SEG_ID);
561

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

John Koleszar's avatar
John Koleszar committed
565
        // Store the prediction flag.
Paul Wilkins's avatar
Paul Wilkins committed
566
        vp9_set_pred_flag(xd, PRED_SEG_ID, seg_pred_flag);
John Koleszar's avatar
John Koleszar committed
567 568 569 570

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
581
      if (mbmi->sb_type) {
582 583 584 585
        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
586 587 588 589
        int x, y;

        for (y = 0; y < ymbs; y++) {
          for (x = 0; x < xmbs; x++) {
590
            cm->last_frame_seg_map[mb_index + x + y * cm->mb_cols] =
Ronald S. Bultje's avatar
Ronald S. Bultje committed
591 592
                mbmi->segment_id;
          }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
593
        }
594
      } else {
595
        cm->last_frame_seg_map[mb_index] = mbmi->segment_id;
John Koleszar's avatar
John Koleszar committed
596
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
597
    } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
598
      if (mbmi->sb_type) {
599 600 601 602
        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
603 604 605 606 607 608
        unsigned segment_id = -1;
        int x, y;

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644

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

645 646 647 648 649 650 651 652 653
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];
}

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

663
  int_mv *const mv = &mbmi->mv[0];
664 665
  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
666

667 668
  const int use_prev_in_find_mv_refs = cm->width == cm->last_width &&
                                       cm->height == cm->last_height &&
669
                                       !cm->error_resilient_mode;
John Koleszar's avatar
John Koleszar committed
670

671
  int mb_to_left_edge, mb_to_right_edge, mb_to_top_edge, mb_to_bottom_edge;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
672

John Koleszar's avatar
John Koleszar committed
673 674
  mbmi->need_to_clamp_mvs = 0;
  mbmi->need_to_clamp_secondmv = 0;
675
  mbmi->second_ref_frame = NONE;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
676

677 678 679 680 681
  // 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
682 683 684
  // 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
685 686
  set_mb_row(cm, xd, mb_row, bh);
  set_mb_col(cm, xd, mb_col, bw);
687

688 689
  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
690 691
  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
692 693

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

  if (pbi->common.mb_no_coeff_skip &&
Paul Wilkins's avatar
Paul Wilkins committed
697
      (!vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP))) {
John Koleszar's avatar
John Koleszar committed
698 699
    // Read the macroblock coeff skip flag if this feature is in use,
    // else default to 0
700
    mbmi->mb_skip_coeff = vp9_read(bc, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
John Koleszar's avatar
John Koleszar committed
701
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
702 703
    mbmi->mb_skip_coeff = vp9_segfeature_active(xd, mbmi->segment_id,
                                                SEG_LVL_SKIP);
John Koleszar's avatar
John Koleszar committed
704 705 706
  }

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

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

John Koleszar's avatar
John Koleszar committed
712 713 714 715
  // 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
716
    vp9_prob mv_ref_p[VP9_MVREFS - 1];
John Koleszar's avatar
John Koleszar committed
717

718 719 720 721
    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];
722 723

    {
724 725 726 727
      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;
728

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

732
      setup_pred_block(&xd->pre, &cm->yv12_fb[ref_fb_idx],
733
                       mb_row, mb_col, sf0, sf_uv0);
734

735 736 737 738 739
#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
740
      vp9_find_mv_refs(cm, xd, mi, use_prev_in_find_mv_refs ? prev_mi : NULL,
Paul Wilkins's avatar
Paul Wilkins committed
741 742
                       ref_frame, mbmi->ref_mvs[ref_frame],
                       cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
743

744
      vp9_mv_ref_probs(cm, mv_ref_p, mbmi->mb_mode_context[ref_frame]);
745

746
      // If the segment level skip mode enabled
Paul Wilkins's avatar
Paul Wilkins committed
747 748
      if (vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP)) {
        mbmi->mode = ZEROMV;
749
      } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
750 751
        mbmi->mode = mbmi->sb_type ? read_sb_mv_ref(bc, mv_ref_p)
                                   : read_mv_ref(bc, mv_ref_p);
752
        vp9_accum_mv_refs(cm, mbmi->mode, mbmi->mb_mode_context[ref_frame]);
753 754 755 756
      }

      if (mbmi->mode != ZEROMV) {
        vp9_find_best_ref_mvs(xd,
757 758
                              use_prev_in_find_best_ref ? xd->pre.y_buffer
                                                        : NULL,
759
                              xd->pre.y_stride,
760 761 762
                              mbmi->ref_mvs[ref_frame],
                              &nearest, &nearby);

763
        best_mv.as_int = mbmi->ref_mvs[ref_frame][0].as_int;
764
      }
765

766 767 768 769 770 771
#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