vp9_decodemv.c 50.5 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 ||
        (cm->comp_pred_mode == HYBRID_PREDICTION &&
792
         vp9_read(bc, vp9_get_pred_prob(cm, xd, PRED_COMP)))) {
John Koleszar's avatar
John Koleszar committed
793
794
795
796
797
798
799
800
801
802
      /* 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;
803
      if (mbmi->second_ref_frame > 0) {
804
        int second_ref_fb_idx;
805
806
807
808
809
810
811
812
        int use_prev_in_find_best_ref;

        xd->scale_factor[1] = cm->active_ref_scale[mbmi->second_ref_frame - 1];
        use_prev_in_find_best_ref =
            xd->scale_factor[1].x_num == xd->scale_factor[1].x_den &&
            xd->scale_factor[1].y_num == xd->scale_factor[1].y_den &&
            !cm->error_resilient_mode &&
            !cm->frame_parallel_decoding_mode;
813

814
        /* Select the appropriate reference frame for this MB */
815
        second_ref_fb_idx = cm->active_ref_idx[mbmi->second_ref_frame - 1];
816

817
        setup_pred_block(&xd->second_pre, &cm->yv12_fb[second_ref_fb_idx],
818
             mb_row, mb_col, &xd->scale_factor[1], &xd->scale_factor_uv[1]);
819
820

        vp9_find_mv_refs(cm, xd, mi, use_prev_in_find_mv_refs ? prev_mi : NULL,
Paul Wilkins's avatar
Paul Wilkins committed
821
822
823
                         mbmi->second_ref_frame,
                         mbmi->ref_mvs[mbmi->second_ref_frame],
                         cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
824

825
826
        if (mbmi->mode != ZEROMV) {
          vp9_find_best_ref_mvs(xd,
827
828
829
                                use_prev_in_find_best_ref ?
                                    xd->second_pre.y_buffer : NULL,
                                xd->second_pre.y_stride,
830
831
832
833
834
                                mbmi->ref_mvs[mbmi->second_ref_frame],
                                &nearest_second,
                                &nearby_second);
          best_mv_second = mbmi->ref_mvs[mbmi->second_ref_frame][0];
        }
835
      }
Yaowu Xu's avatar
Yaowu Xu committed
836

John Koleszar's avatar
John Koleszar committed
837
    } else {
838
839
840
841
842
843
844
845
846
847
848
#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
849
          mbmi->interintra_mode = read_ymode(bc, pbi->common.fc.ymode_prob);
850
851
          pbi->common.fc.ymode_counts[mbmi->interintra_mode]++;
#if SEPARATE_INTERINTRA_UV
Dmitry Kovalev's avatar
Dmitry Kovalev committed
852
853
          mbmi->interintra_uv_mode = read_uv_mode(bc,
              pbi->common.fc.uv_mode_prob[mbmi->interintra_mode]);
854
855
856
857
858
859
860
861
862
863
          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
864
    }
865

866
867
868
869
870
871
872
873
#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 =
874
        vp9_read_mv_ref_id(bc, xd->mb_mv_ref_probs[ref_frame]);
875
876
877
878
879
880
881
882

      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 =
883
          vp9_read_mv_ref_id(bc, xd->mb_mv_ref_probs[ref_frame]);
884
885
886
887
888
        best_mv_second.as_int = mbmi->ref_mvs[ref_frame][best_index].as_int;
      }
    }
#endif

John Koleszar's avatar
John Koleszar committed
889
890
891
    mbmi->uv_mode = DC_PRED;
    switch (mbmi->mode) {
      case SPLITMV: {
892
893
        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
894
        int j = 0;
John Koleszar's avatar
John Koleszar committed
895

896
        cm->fc.mbsplit_counts[s]++;
John Koleszar's avatar
John Koleszar committed
897
        mbmi->need_to_clamp_mvs = 0;
898
        mbmi->partitioning = s;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
899
        do {  // for each subset j
John Koleszar's avatar
John Koleszar committed
900
901
902
903
          int_mv leftmv, abovemv, second_leftmv, second_abovemv;
          int_mv blockmv, secondmv;
          int mv_contz;
          int blockmode;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
904
          int k = vp9_mbsplit_offset[s][j];  // first block in subset j
John Koleszar's avatar
John Koleszar committed
905

906
          leftmv.as_int = left_block_mv(xd, mi, k);
John Koleszar's avatar
John Koleszar committed
907
          abovemv.as_int = above_block_mv(mi, k, mis);
908
909
          second_leftmv.as_int = 0;
          second_abovemv.as_int = 0;
910
          if (mbmi->second_ref_frame > 0) {
911
            second_leftmv.as_int = left_block_second_mv(xd, mi, k);
John Koleszar's avatar
John Koleszar committed
912
913
            second_abovemv.as_int = above_block_second_mv(mi, k, mis);
          }
914
          mv_contz = vp9_mv_cont(&leftmv, &abovemv);
John Koleszar's avatar
John Koleszar committed
915
916
          blockmode = sub_mv_ref(bc, cm->fc.sub_mv_ref_prob [mv_contz]);
          cm->fc.sub_mv_ref_counts[mv_contz][blockmode - LEFT4X4]++;
John Koleszar's avatar
John Koleszar committed
917