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[3]);
#endif
Paul Wilkins's avatar
Paul Wilkins committed
772
    }
John Koleszar's avatar
John Koleszar committed
773

Dmitry Kovalev's avatar
Dmitry Kovalev committed
774
    if (mbmi->mode >= NEARESTMV && mbmi->mode <= SPLITMV) {
775
776
777
      mbmi->interp_filter = cm->mcomp_filter_type == SWITCHABLE
                                ? read_switchable_filter_type(pbi, bc)
                                : cm->mcomp_filter_type;
778
    }
779

John Koleszar's avatar
John Koleszar committed
780
781
    if (cm->comp_pred_mode == COMP_PREDICTION_ONLY ||
        (cm->comp_pred_mode == HYBRID_PREDICTION &&
782
         vp9_read(bc, vp9_get_pred_prob(cm, xd, PRED_COMP)))) {
John Koleszar's avatar
John Koleszar committed
783
784
785
786
787
788
789
790
791
792
      /* 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;
793
      if (mbmi->second_ref_frame > 0) {
794
795
796
797
798
799
800
801
802
        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];
803

804
        setup_pred_block(&xd->second_pre, &cm->yv12_fb[second_ref_fb_idx],
805
                         mb_row, mb_col, sf1, sf_uv1);
806

807
808
809
        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
810
                         cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
811

812
813
        if (mbmi->mode != ZEROMV) {
          vp9_find_best_ref_mvs(xd,
814
815
816
                                use_prev_in_find_best_ref ?
                                    xd->second_pre.y_buffer : NULL,
                                xd->second_pre.y_stride,
817
                                mbmi->ref_mvs[second_ref_frame],
818
819
                                &nearest_second,
                                &nearby_second);
820
          best_mv_second.as_int = mbmi->ref_mvs[second_ref_frame][0].as_int;
821
        }
822
      }
Yaowu Xu's avatar
Yaowu Xu committed
823

John Koleszar's avatar
John Koleszar committed
824
    } else {
825
826
827
828
829
830
831
832
833
834
835
#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
836
          mbmi->interintra_mode = read_ymode(bc, pbi->common.fc.ymode_prob);
837
838
          pbi->common.fc.ymode_counts[mbmi->interintra_mode]++;
#if SEPARATE_INTERINTRA_UV
Dmitry Kovalev's avatar
Dmitry Kovalev committed
839
840
          mbmi->interintra_uv_mode = read_uv_mode(bc,
              pbi->common.fc.uv_mode_prob[mbmi->interintra_mode]);
841
842
843
844
845
846
847
848
849
850
          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
851
    }
852

853
854
855
856
857
858
859
860
#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 =
861
        vp9_read_mv_ref_id(bc, xd->mb_mv_ref_probs[ref_frame]);
862
863
864
865
866
867
868
869

      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 =