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],
Paul Wilkins's avatar
Paul Wilkins committed
801
                         cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
802

803
804
        if (mbmi->mode != ZEROMV) {
          vp9_find_best_ref_mvs(xd,
805
806
807
                                use_prev_in_find_best_ref ?
                                    xd->second_pre.y_buffer : NULL,
                                xd->second_pre.y_stride,
808
                                mbmi->ref_mvs[second_ref_frame],
809
810
                                &nearest_second,
                                &nearby_second);
811
          best_mv_second.as_int = mbmi->ref_mvs[second_ref_frame][0].as_int;
812
        }
813
      }
Yaowu Xu's avatar
Yaowu Xu committed
814

John Koleszar's avatar
John Koleszar committed
815
    } else {
816
817
818
819
820
821
822
823
824
825
826
#if CONFIG_COMP_INTERINTRA_PRED
      if (pbi->common.use_interintra &&
          mbmi->mode >= NEARESTMV && mbmi->mode < SPLITMV &&
          mbmi->second_ref_frame == NONE) {
        mbmi->second_ref_frame = (vp9_read(bc, pbi->common.fc.interintra_prob) ?
                                  INTRA_FRAME : NONE);
        // printf("-- %d (%d)\n", mbmi->second_ref_frame == INTRA_FRAME,
        //        pbi->common.fc.interintra_prob);
        pbi->common.fc.interintra_counts[
            mbmi->second_ref_frame == INTRA_FRAME]++;
        if (mbmi->second_ref_frame == INTRA_FRAME) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
827
          mbmi->interintra_mode = read_ymode(bc, pbi->common.fc.ymode_prob);
828
829
          pbi->common.fc.ymode_counts[mbmi->interintra_mode]++;
#if SEPARATE_INTERINTRA_UV
Dmitry Kovalev's avatar
Dmitry Kovalev committed
830
831
          mbmi->interintra_uv_mode = read_uv_mode(bc,
              pbi->common.fc.uv_mode_prob[mbmi->interintra_mode]);
832
833
834
835
836
837
838
839
840
841
          pbi->common.fc.uv_mode_counts[mbmi->interintra_mode]
                                       [mbmi->interintra_uv_mode]++;
#else
          mbmi->interintra_uv_mode = mbmi->interintra_mode;
#endif
          // printf("** %d %d\n",
          //        mbmi->interintra_mode, mbmi->interintra_uv_mode);
        }
      }
#endif
John Koleszar's avatar
John Koleszar committed
842
    }
843

844
845
846
847
848
849
850
851
#if CONFIG_NEW_MVREF
    // if ((mbmi->mode == NEWMV) || (mbmi->mode == SPLITMV))
    if (mbmi->mode == NEWMV) {
      int best_index;
      MV_REFERENCE_FRAME ref_frame = mbmi->ref_frame;

      // Encode the index of the choice.
      best_index =
852
        vp9_read_mv_ref_id(bc, xd->mb_mv_ref_probs[ref_frame]);
853
854
855
856
857
858
859
860

      best_mv.as_int = mbmi->ref_mvs[ref_frame][best_index].as_int;

      if (mbmi->second_ref_frame > 0) {
        ref_frame = mbmi->second_ref_frame;

        // Encode the index of the choice.
        best_index =
861
          vp9_read_mv_ref_id(bc, xd->mb_mv_ref_probs[ref_frame]);
862
863
864
865
866
        best_mv_second.as_int = mbmi->ref_mvs[ref_frame][best_index].as_int;
      }
    }
#endif

John Koleszar's avatar
John Koleszar committed
867
868
869
    mbmi->uv_mode = DC_PRED;
    switch (mbmi->mode) {
      case SPLITMV: {
870
871
        const int s = treed_read(bc, vp9_mbsplit_tree, cm->fc.mbsplit_prob);
        const int num_p = vp9_mbsplit_count[s];
John Koleszar's avatar
John Koleszar committed
872