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 139 140 141 142 143 144 145 146 147 148 149
    if (m->mbmi.sb_type) {
      const int nmbs = 1 << m->mbmi.sb_type;
      const int ymbs = MIN(cm->mb_rows - mb_row, nmbs);
      const int xmbs = MIN(cm->mb_cols - mb_col, nmbs);
      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;
        }
      }
150
    } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
151 152
      cm->last_frame_seg_map[map_index] = m->mbmi.segment_id;
    }
John Koleszar's avatar
John Koleszar committed
153 154 155 156
  }

  m->mbmi.mb_skip_coeff = 0;
  if (pbi->common.mb_no_coeff_skip &&
Dmitry Kovalev's avatar
Dmitry Kovalev committed
157
      (!vp9_segfeature_active(&pbi->mb, m->mbmi.segment_id, SEG_LVL_SKIP))) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
158 159
    m->mbmi.mb_skip_coeff = vp9_read(bc, vp9_get_pred_prob(cm, &pbi->mb,
                                                           PRED_MBSKIP));
John Koleszar's avatar
John Koleszar committed
160
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
161 162
    m->mbmi.mb_skip_coeff = vp9_segfeature_active(&pbi->mb, m->mbmi.segment_id,
                                                  SEG_LVL_SKIP);
John Koleszar's avatar
John Koleszar committed
163 164
  }

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

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

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

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

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

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

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

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

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

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
257
  offset += f << 1;
258 259

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

269
static void read_nmv(vp9_reader *r, MV *mv, const MV *ref,
270
                     const nmv_context *mvctx) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
271
  const MV_JOINT_TYPE j = treed_read(r, vp9_mv_joint_tree, mvctx->joints);
272 273 274 275
  mv->row = mv-> col = 0;
  if (j == MV_JOINT_HZVNZ || j == MV_JOINT_HNZVNZ) {
    mv->row = read_nmv_component(r, ref->row, &mvctx->comps[0]);
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
276

277 278 279 280 281
  if (j == MV_JOINT_HNZVZ || j == MV_JOINT_HNZVNZ) {
    mv->col = read_nmv_component(r, ref->col, &mvctx->comps[1]);
  }
}

282
static void read_nmv_fp(vp9_reader *r, MV *mv, const MV *ref,
283
                        const nmv_context *mvctx, int usehp) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
284
  const MV_JOINT_TYPE j = vp9_get_mv_joint(*mv);
285
  usehp = usehp && vp9_use_nmv_hp(ref);
286 287 288 289 290 291 292 293
  if (j == MV_JOINT_HZVNZ || j == MV_JOINT_HNZVNZ) {
    mv->row = read_nmv_component_fp(r, mv->row, ref->row, &mvctx->comps[0],
                                    usehp);
  }
  if (j == MV_JOINT_HNZVZ || j == MV_JOINT_HNZVNZ) {
    mv->col = read_nmv_component_fp(r, mv->col, ref->col, &mvctx->comps[1],
                                    usehp);
  }
294 295 296 297
  /*
  printf("MV: %d %d REF: %d %d\n", mv->row + ref->row, mv->col + ref->col,
	 ref->row, ref->col);
	 */
298 299
}

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

311
static void read_nmvprobs(vp9_reader *bc, nmv_context *mvctx,
312 313
                          int usehp) {
  int i, j, k;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
314

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

322
  for (i = 0; i < 2; ++i) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
323 324 325 326 327 328 329 330 331
    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);
332 333 334 335 336
  }

  for (i = 0; i < 2; ++i) {
    for (j = 0; j < CLASS0_SIZE; ++j) {
      for (k = 0; k < 3; ++k)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
337
        update_nmv(bc, &mvctx->comps[i].class0_fp[j][k], VP9_NMV_UPDATE_PROB);
338
    }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
339 340 341

    for (j = 0; j < 3; ++j)
      update_nmv(bc, &mvctx->comps[i].fp[j], VP9_NMV_UPDATE_PROB);
342 343 344 345
  }

  if (usehp) {
    for (i = 0; i < 2; ++i) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
346 347
      update_nmv(bc, &mvctx->comps[i].class0_hp, VP9_NMV_UPDATE_PROB);
      update_nmv(bc, &mvctx->comps[i].hp, VP9_NMV_UPDATE_PROB);
348 349 350 351
    }
  }
}

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
360 361
  int seg_ref_count = 0;
  int seg_ref_active = vp9_segfeature_active(xd, segment_id, SEG_LVL_REF_FRAME);
John Koleszar's avatar
John Koleszar committed
362 363 364 365

  // If segment coding enabled does the segment allow for more than one
  // possible reference frame
  if (seg_ref_active) {
366 367 368 369
    seg_ref_count = vp9_check_segref(xd, segment_id, INTRA_FRAME) +
                    vp9_check_segref(xd, segment_id, LAST_FRAME) +
                    vp9_check_segref(xd, segment_id, GOLDEN_FRAME) +
                    vp9_check_segref(xd, segment_id, ALTREF_FRAME);
John Koleszar's avatar
John Koleszar committed
370 371 372 373 374 375 376 377 378
  }

  // Segment reference frame features not available or allows for
  // multiple reference frame options
  if (!seg_ref_active || (seg_ref_count > 1)) {
    // 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
379
    vp9_prob pred_prob = vp9_get_pred_prob(cm, xd, PRED_REF);
John Koleszar's avatar
John Koleszar committed
380 381

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

    // Store the prediction flag.
Paul Wilkins's avatar
Paul Wilkins committed
385
    vp9_set_pred_flag(xd, PRED_REF, prediction_flag);
John Koleszar's avatar
John Koleszar committed
386 387

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

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

      // If segment coding enabled blank out options that cant occur by
      // setting the branch probability to 0.
      if (seg_ref_active) {
        mod_refprobs[INTRA_FRAME] *=
403
          vp9_check_segref(xd, segment_id, INTRA_FRAME);
John Koleszar's avatar
John Koleszar committed
404
        mod_refprobs[LAST_FRAME] *=
405
          vp9_check_segref(xd, segment_id, LAST_FRAME);
John Koleszar's avatar
John Koleszar committed
406
        mod_refprobs[GOLDEN_FRAME] *=
407 408
          (vp9_check_segref(xd, segment_id, GOLDEN_FRAME) *
           vp9_check_segref(xd, segment_id, ALTREF_FRAME));
John Koleszar's avatar
John Koleszar committed
409 410 411 412 413 414 415
      }

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

      // Do we need to decode the Intra/Inter branch
      if (mod_refprobs[0])
416
        ref_frame = (MV_REFERENCE_FRAME) vp9_read(bc, mod_refprobs[0]);
John Koleszar's avatar
John Koleszar committed
417 418 419 420 421 422
      else
        ref_frame++;

      if (ref_frame) {
        // Do we need to decode the Last/Gf_Arf branch
        if (mod_refprobs[1])
423
          ref_frame += vp9_read(bc, mod_refprobs[1]);
424
        else
John Koleszar's avatar
John Koleszar committed
425 426 427 428 429
          ref_frame++;

        if (ref_frame > 1) {
          // Do we need to decode the GF/Arf branch
          if (mod_refprobs[2])
430
            ref_frame += vp9_read(bc, mod_refprobs[2]);
John Koleszar's avatar
John Koleszar committed
431 432 433
          else {
            if (seg_ref_active) {
              if ((pred_ref == GOLDEN_FRAME) ||
434
                  !vp9_check_segref(xd, segment_id, GOLDEN_FRAME)) {
John Koleszar's avatar
John Koleszar committed
435 436 437 438 439 440 441
                ref_frame = ALTREF_FRAME;
              } else
                ref_frame = GOLDEN_FRAME;
            } else
              ref_frame = (pred_ref == GOLDEN_FRAME)
                          ? ALTREF_FRAME : GOLDEN_FRAME;
          }
442
        }
John Koleszar's avatar
John Koleszar committed
443
      }
444
    }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
445 446
  } else {
    // Segment reference frame features are enabled
John Koleszar's avatar
John Koleszar committed
447 448 449
    // 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
450 451
    vp9_set_pred_flag(xd, PRED_REF, 1);
    ref_frame = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
452 453 454
  }

  return (MV_REFERENCE_FRAME)ref_frame;
455
}
John Koleszar's avatar
John Koleszar committed
456

457 458
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
459
}
John Koleszar's avatar
John Koleszar committed
460

461 462
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
463 464
}

465 466
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
467
}
Scott LaVarnway's avatar
Scott LaVarnway committed
468 469

#ifdef VPX_MODE_COUNT
470
unsigned int vp9_mv_cont_count[5][4] = {
John Koleszar's avatar
John Koleszar committed
471 472 473 474 475
  { 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
476
};
Scott LaVarnway's avatar
Scott LaVarnway committed
477
#endif
John Koleszar's avatar
John Koleszar committed
478

Dmitry Kovalev's avatar
Dmitry Kovalev committed
479
static const unsigned char mbsplit_fill_count[4] = { 8, 8, 4, 1 };
480
static const unsigned char mbsplit_fill_offset[4][16] = {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
481 482 483 484
  { 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
485
};
John Koleszar's avatar
John Koleszar committed
486

487
static void read_switchable_interp_probs(VP9D_COMP* const pbi,
John Koleszar's avatar
John Koleszar committed
488
                                         BOOL_DECODER* const bc) {
489
  VP9_COMMON *const cm = &pbi->common;
490
  int i, j;
491 492
  for (j = 0; j <= VP9_SWITCHABLE_FILTERS; ++j) {
    for (i = 0; i < VP9_SWITCHABLE_FILTERS - 1; ++i) {
493
      cm->fc.switchable_interp_prob[j][i] = vp9_read_prob(bc);
494 495 496 497 498
    }
  }
  //printf("DECODER: %d %d\n", cm->fc.switchable_interp_prob[0],
  //cm->fc.switchable_interp_prob[1]);
}
John Koleszar's avatar
John Koleszar committed
499

500
static void mb_mode_mv_init(VP9D_COMP *pbi, vp9_reader *bc) {
501
  VP9_COMMON *const cm = &pbi->common;
502
  nmv_context *const nmvc = &pbi->common.fc.nmvc;
John Koleszar's avatar
John Koleszar committed
503
  MACROBLOCKD *const xd  = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
504

505 506
  if (cm->frame_type == KEY_FRAME) {
    if (!cm->kf_ymode_probs_update)
507
      cm->kf_ymode_probs_index = vp9_read_literal(bc, 3);
508
  } else {
509
    if (cm->mcomp_filter_type == SWITCHABLE)
John Koleszar's avatar
John Koleszar committed
510
      read_switchable_interp_probs(pbi, bc);
511 512 513
#if CONFIG_COMP_INTERINTRA_PRED
    if (cm->use_interintra) {
      if (vp9_read(bc, VP9_UPD_INTERINTRA_PROB))
514
        cm->fc.interintra_prob = vp9_read_prob(bc);
515 516
    }
#endif
John Koleszar's avatar
John Koleszar committed
517
    // Decode the baseline probabilities for decoding reference frame
518 519 520
    cm->prob_intra_coded = vp9_read_prob(bc);
    cm->prob_last_coded  = vp9_read_prob(bc);
    cm->prob_gf_coded    = vp9_read_prob(bc);
John Koleszar's avatar
John Koleszar committed
521 522 523

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

526
    pbi->common.comp_pred_mode = vp9_read(bc, 128);
John Koleszar's avatar
John Koleszar committed
527
    if (cm->comp_pred_mode)
528
      cm->comp_pred_mode += vp9_read(bc, 128);
John Koleszar's avatar
John Koleszar committed
529 530 531
    if (cm->comp_pred_mode == HYBRID_PREDICTION) {
      int i;
      for (i = 0; i < COMP_PRED_CONTEXTS; i++)
532
        cm->prob_comppred[i] = vp9_read_prob(bc);
John Koleszar's avatar
John Koleszar committed
533
    }
John Koleszar's avatar
John Koleszar committed
534

535
    if (vp9_read_bit(bc)) {
John Koleszar's avatar
John Koleszar committed
536
      int i = 0;
John Koleszar's avatar
John Koleszar committed
537

John Koleszar's avatar
John Koleszar committed
538
      do {
539
        cm->fc.ymode_prob[i] = vp9_read_prob(bc);
540
      } while (++i < VP9_YMODES - 1);
John Koleszar's avatar
John Koleszar committed
541
    }
542

543 544 545 546
    if (vp9_read_bit(bc)) {
      int i = 0;

      do {
547
        cm->fc.sb_ymode_prob[i] = vp9_read_prob(bc);
548 549 550
      } while (++i < VP9_I32X32_MODES - 1);
    }

551
    read_nmvprobs(bc, nmvc, xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
552
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
553
}
John Koleszar's avatar
John Koleszar committed
554

555 556 557
// 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
558
static void read_mb_segment_id(VP9D_COMP *pbi,
John Koleszar's avatar
John Koleszar committed
559 560
                               int mb_row, int mb_col,
                               BOOL_DECODER* const bc) {
561
  VP9_COMMON *const cm = &pbi->common;
562
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
563 564
  MODE_INFO *mi = xd->mode_info_context;
  MB_MODE_INFO *mbmi = &mi->mbmi;
565
  int mb_index = mb_row * pbi->common.mb_cols + mb_col;
John Koleszar's avatar
John Koleszar committed
566 567 568 569 570 571 572

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

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

John Koleszar's avatar
John Koleszar committed
578
        // Store the prediction flag.
Paul Wilkins's avatar
Paul Wilkins committed
579
        vp9_set_pred_flag(xd, PRED_SEG_ID, seg_pred_flag);
John Koleszar's avatar
John Koleszar committed
580 581 582 583

        // If the value is flagged as correctly predicted
        // then use the predicted value
        if (seg_pred_flag) {
584
          mbmi->segment_id = vp9_get_pred_mb_segid(cm, xd, mb_index);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
585 586
        } else {
          // Decode it explicitly
587
          read_mb_segid_except(cm, bc, mbmi, xd, mb_row, mb_col);
John Koleszar's avatar
John Koleszar committed
588
        }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
589 590
      } else {
        // Normal unpredicted coding mode
591
        read_mb_segid(bc, mbmi, xd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
592
      }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
593

Ronald S. Bultje's avatar
Ronald S. Bultje committed
594 595 596 597 598 599 600 601
      if (mbmi->sb_type) {
        const int nmbs = 1 << mbmi->sb_type;
        const int ymbs = MIN(cm->mb_rows - mb_row, nmbs);
        const int xmbs = MIN(cm->mb_cols - mb_col, nmbs);
        int x, y;

        for (y = 0; y < ymbs; y++) {
          for (x = 0; x < xmbs; x++) {
602
            cm->last_frame_seg_map[mb_index + x + y * cm->mb_cols] =
Ronald S. Bultje's avatar
Ronald S. Bultje committed
603 604
                mbmi->segment_id;
          }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
605
        }
606
      } else {
607
        cm->last_frame_seg_map[mb_index] = mbmi->segment_id;
John Koleszar's avatar
John Koleszar committed
608
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
609
    } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
610 611 612 613 614 615 616 617 618 619
      if (mbmi->sb_type) {
        const int nmbs = 1 << mbmi->sb_type;
        const int ymbs = MIN(cm->mb_rows - mb_row, nmbs);
        const int xmbs = MIN(cm->mb_cols - mb_col, nmbs);
        unsigned segment_id = -1;
        int x, y;

        for (y = 0; y < ymbs; y++) {
          for (x = 0; x < xmbs; x++) {
            segment_id = MIN(segment_id,
620
                cm->last_frame_seg_map[mb_index + x + y * cm->mb_cols]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
621
          }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
622
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
623
        mbmi->segment_id = segment_id;
624
      } else {
625
        mbmi->segment_id = cm->last_frame_seg_map[mb_index];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
626
      }
627
    }
John Koleszar's avatar
John Koleszar committed
628 629 630 631 632
  } else {
    // The encoder explicitly sets the segment_id to 0
    // when segmentation is disabled
    mbmi->segment_id = 0;
  }
633
}
634

Dmitry Kovalev's avatar
Dmitry Kovalev committed
635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655

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

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

665
  int_mv *const mv = &mbmi->mv[0];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
666
  const int mb_size = 1 << mi->mbmi.sb_type;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
667

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

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

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

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

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

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

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

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

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

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

721
    MV_REFERENCE_FRAME ref_frame = mbmi->ref_frame;
722
    xd->scale_factor[0] = cm->active_ref_scale[mbmi->ref_frame - 1];
723 724

    {
725 726 727 728 729
      const int use_prev_in_find_best_ref =
          xd->scale_factor[0].x_num == xd->scale_factor[0].x_den &&
          xd->scale_factor[0].y_num == xd->scale_factor[0].y_den &&
          !cm->error_resilient_mode &&
          !cm->frame_parallel_decoding_mode;
730 731

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

734 735
      setup_pred_block(&xd->pre, &cm->yv12_fb[ref_fb_idx],
          mb_row, mb_col, &xd->scale_factor[0], &xd->scale_factor_uv[0]);
736

737 738 739 740 741
#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
742 743
      // if (cm->current_video_frame == 1 && mb_row == 4 && mb_col == 5)
      //  printf("Dello\n");
744
      vp9_find_mv_refs(cm, xd, mi, use_prev_in_find_mv_refs ? prev_mi : NULL,
Paul Wilkins's avatar
Paul Wilkins committed
745 746
                       ref_frame, mbmi->ref_mvs[ref_frame],
                       cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
747

Paul Wilkins's avatar
Paul Wilkins committed
748 749
      vp9_mv_ref_probs(&pbi->common, mv_ref_p,
                       mbmi->mb_mode_context[ref_frame]);
750

751
      // If the segment level skip mode enabled
Paul Wilkins's avatar
Paul Wilkins committed
752 753
      if (vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP)) {
        mbmi->mode = ZEROMV;
754
      } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
755 756
        mbmi->mode = mbmi->sb_type ? read_sb_mv_ref(bc, mv_ref_p)
                                   : read_mv_ref(bc, mv_ref_p);
757 758 759 760 761 762
        vp9_accum_mv_refs(&pbi->common, mbmi->mode,
                          mbmi->mb_mode_context[ref_frame]);
      }

      if (mbmi->mode != ZEROMV) {
        vp9_find_best_ref_mvs(xd,
763 764 765
                              use_prev_in_find_best_ref ?
                                  xd->pre.y_buffer : NULL,
                              xd->pre.y_stride,
766 767 768 769 770
                              mbmi->ref_mvs[ref_frame],
                              &nearest, &nearby);

        best_mv.as_int = (mbmi->ref_mvs[ref_frame][0]).as_int;
      }
771

772 773 774 775 776 777
#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
778
    }
John Koleszar's avatar
John Koleszar committed
779

Dmitry Kovalev's avatar
Dmitry Kovalev committed
780
    if (mbmi->mode >= NEARESTMV && mbmi->mode <= SPLITMV) {
781
      if (cm->mcomp_filter_type == SWITCHABLE) {
782
        mbmi->interp_filter = vp9_switchable_interp[
783 784
            treed_read(bc, vp9_switchable_interp_tree,
                       vp9_get_pred_probs(cm, xd, PRED_SWITCHABLE_INTERP))];
785 786 787 788
      } else {
        mbmi->interp_filter = cm->mcomp_filter_type;
      }
    }
789

John Koleszar's avatar
John Koleszar committed
790 791
    if (cm->comp_pred_mode == COMP_PREDICTION_ONLY