vp9_decodemv.c 50.9 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) {
John Koleszar's avatar
John Koleszar committed
79
  /* Is segmentation enabled */
Paul Wilkins's avatar
Paul Wilkins committed
80
  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
John Koleszar's avatar
John Koleszar committed
81
    /* If so then read the segment id. */
Dmitry Kovalev's avatar
Dmitry Kovalev committed
82
83
    mi->segment_id = vp9_read(r, xd->mb_segment_tree_probs[0]) ?
        (unsigned char)(2 + vp9_read(r, xd->mb_segment_tree_probs[2])):
84
        (unsigned char)(vp9_read(r, xd->mb_segment_tree_probs[1]));
John Koleszar's avatar
John Koleszar committed
85
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
86
}
87

88
89
90
91
92
93
94
95
96
97
98
99
100
101
// 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) {
  int pred_seg_id = vp9_get_pred_mb_segid(cm, xd,
                                          mb_row * cm->mb_cols + mb_col);
  const vp9_prob *p = xd->mb_segment_tree_probs;
  vp9_prob p1 = xd->mb_segment_mispred_tree_probs[pred_seg_id];

  /* Is segmentation enabled */
  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
    /* If so then read the segment id. */
    if (vp9_read(r, p1)) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
102
103
      mi->segment_id = 2 +
          (pred_seg_id < 2 ? vp9_read(r, p[2]) : (pred_seg_id == 2));
104
    } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
105
106
      mi->segment_id =
          pred_seg_id >= 2 ? vp9_read(r, p[1]) : (pred_seg_id == 0);
107
108
109
110
    }
  }
}

111
#if CONFIG_NEW_MVREF
Dmitry Kovalev's avatar
Dmitry Kovalev committed
112
int vp9_read_mv_ref_id(vp9_reader *r, vp9_prob *ref_id_probs) {
113
114
  int ref_index = 0;

115
  if (vp9_read(r, ref_id_probs[0])) {
116
    ref_index++;
117
    if (vp9_read(r, ref_id_probs[1])) {
118
      ref_index++;
119
      if (vp9_read(r, ref_id_probs[2]))
120
121
122
123
124
125
126
        ref_index++;
    }
  }
  return ref_index;
}
#endif

127
extern const int vp9_i8x8_block[4];
128
static void kfread_modes(VP9D_COMP *pbi,
John Koleszar's avatar
John Koleszar committed
129
130
131
132
                         MODE_INFO *m,
                         int mb_row,
                         int mb_col,
                         BOOL_DECODER* const bc) {
133
  VP9_COMMON *const cm = &pbi->common;
134
  MACROBLOCKD *const xd  = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
135
136
137
138
  const int mis = pbi->common.mode_info_stride;
  int map_index = mb_row * pbi->common.mb_cols + mb_col;
  MB_PREDICTION_MODE y_mode;

139
140
  m->mbmi.ref_frame = INTRA_FRAME;

John Koleszar's avatar
John Koleszar committed
141
142
143
144
  // 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) {
145
    read_mb_segid(bc, &m->mbmi, &pbi->mb);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
146
147
148
149
150
151
152
153
154
155
156
157
    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;
        }
      }
158
    } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
159
160
      cm->last_frame_seg_map[map_index] = m->mbmi.segment_id;
    }
John Koleszar's avatar
John Koleszar committed
161
162
163
164
  }

  m->mbmi.mb_skip_coeff = 0;
  if (pbi->common.mb_no_coeff_skip &&
Dmitry Kovalev's avatar
Dmitry Kovalev committed
165
      (!vp9_segfeature_active(&pbi->mb, m->mbmi.segment_id, SEG_LVL_SKIP))) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
166
167
    m->mbmi.mb_skip_coeff = vp9_read(bc, vp9_get_pred_prob(cm, &pbi->mb,
                                                           PRED_MBSKIP));
John Koleszar's avatar
John Koleszar committed
168
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
169
170
    m->mbmi.mb_skip_coeff = vp9_segfeature_active(&pbi->mb, m->mbmi.segment_id,
                                                  SEG_LVL_SKIP);
John Koleszar's avatar
John Koleszar committed
171
172
  }

Dmitry Kovalev's avatar
Dmitry Kovalev committed
173
174
175
176
177
  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]);
178

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

John Koleszar's avatar
John Koleszar committed
181
182
183
  if ((m->mbmi.mode = y_mode) == B_PRED) {
    int i = 0;
    do {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
184
185
      const B_PREDICTION_MODE a = above_block_mode(m, i, mis);
      const B_PREDICTION_MODE l = (xd->left_available || (i & 3)) ?
186
                                  left_block_mode(m, i) : B_DC_PRED;
Paul Wilkins's avatar
Paul Wilkins committed
187

Dmitry Kovalev's avatar
Dmitry Kovalev committed
188
189
      m->bmi[i].as_mode.first = read_kf_bmode(bc,
                                              pbi->common.kf_bmode_prob[a][l]);
John Koleszar's avatar
John Koleszar committed
190
191
    } while (++i < 16);
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
192

John Koleszar's avatar
John Koleszar committed
193
194
195
  if ((m->mbmi.mode = y_mode) == I8X8_PRED) {
    int i;
    for (i = 0; i < 4; i++) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
196
197
198
      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
199
200
201
202
203
      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
204
205
206
207
  } else {
    m->mbmi.uv_mode = read_uv_mode(bc,
                                   pbi->common.kf_uv_mode_prob[m->mbmi.mode]);
  }
208

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

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

243
    d = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
244
245
    for (i = 0; i < n; ++i)
      d |= vp9_read(r, mvcomp->bits[i]) << i;
246
247
  }

Dmitry Kovalev's avatar
Dmitry Kovalev committed
248
249
  mag = vp9_get_mv_mag(mv_class, d << 3);
  return sign ? -(mag + 8) : (mag + 8);
250
251
}

252
static int read_nmv_component_fp(vp9_reader *r,
253
254
255
256
                                 int v,
                                 int rv,
                                 const nmv_component *mvcomp,
                                 int usehp) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
257
258
259
260
261
262
263
  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);
264

Dmitry Kovalev's avatar
Dmitry Kovalev committed
265
  offset += f << 1;
266
267

  if (usehp) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
268
269
    offset += mv_class == MV_CLASS_0 ?
        vp9_read(r, mvcomp->class0_hp) : vp9_read(r, mvcomp->hp);
270
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
271
    offset += 1;  // If hp is not used, the default value of the hp bit is 1
272
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
273
274
  mag = vp9_get_mv_mag(mv_class, offset);
  return sign ? -(mag + 1) : (mag + 1);
275
276
}

277
static void read_nmv(vp9_reader *r, MV *mv, const MV *ref,
278
                     const nmv_context *mvctx) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
279
  const MV_JOINT_TYPE j = treed_read(r, vp9_mv_joint_tree, mvctx->joints);
280
281
282
283
  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
284

285
286
287
288
289
  if (j == MV_JOINT_HNZVZ || j == MV_JOINT_HNZVNZ) {
    mv->col = read_nmv_component(r, ref->col, &mvctx->comps[1]);
  }
}

290
static void read_nmv_fp(vp9_reader *r, MV *mv, const MV *ref,
291
                        const nmv_context *mvctx, int usehp) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
292
  const MV_JOINT_TYPE j = vp9_get_mv_joint(*mv);
293
  usehp = usehp && vp9_use_nmv_hp(ref);
294
295
296
297
298
299
300
301
  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);
  }
302
303
304
305
  /*
  printf("MV: %d %d REF: %d %d\n", mv->row + ref->row, mv->col + ref->col,
	 ref->row, ref->col);
	 */
306
307
}

308
309
310
static void update_nmv(vp9_reader *bc, vp9_prob *const p,
                       const vp9_prob upd_p) {
  if (vp9_read(bc, upd_p)) {
311
#ifdef LOW_PRECISION_MV_UPDATE
312
    *p = (vp9_read_literal(bc, 7) << 1) | 1;
313
#else
314
    *p = (vp9_read_literal(bc, 8));
315
316
317
318
#endif
  }
}

319
static void read_nmvprobs(vp9_reader *bc, nmv_context *mvctx,
320
321
                          int usehp) {
  int i, j, k;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
322

323
#ifdef MV_GROUP_UPDATE
Dmitry Kovalev's avatar
Dmitry Kovalev committed
324
325
  if (!vp9_read_bit(bc))
    return;
326
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
327
328
329
  for (j = 0; j < MV_JOINTS - 1; ++j)
    update_nmv(bc, &mvctx->joints[j], VP9_NMV_UPDATE_PROB);

330
  for (i = 0; i < 2; ++i) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
331
332
333
334
335
336
337
338
339
    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);
340
341
342
343
344
  }

  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
345
        update_nmv(bc, &mvctx->comps[i].class0_fp[j][k], VP9_NMV_UPDATE_PROB);
346
    }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
347
348
349

    for (j = 0; j < 3; ++j)
      update_nmv(bc, &mvctx->comps[i].fp[j], VP9_NMV_UPDATE_PROB);
350
351
352
353
  }

  if (usehp) {
    for (i = 0; i < 2; ++i) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
354
355
      update_nmv(bc, &mvctx->comps[i].class0_hp, VP9_NMV_UPDATE_PROB);
      update_nmv(bc, &mvctx->comps[i].hp, VP9_NMV_UPDATE_PROB);
356
357
358
359
    }
  }
}

360
// Read the referncence frame
361
static MV_REFERENCE_FRAME read_ref_frame(VP9D_COMP *pbi,
362
                                         vp9_reader *const bc,
John Koleszar's avatar
John Koleszar committed
363
364
                                         unsigned char segment_id) {
  MV_REFERENCE_FRAME ref_frame;
365
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
366
367
  MACROBLOCKD *const xd = &pbi->mb;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
368
369
  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
370
371
372
373

  // If segment coding enabled does the segment allow for more than one
  // possible reference frame
  if (seg_ref_active) {
374
375
376
377
    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
378
379
380
381
382
383
384
385
386
  }

  // 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
387
    vp9_prob pred_prob = vp9_get_pred_prob(cm, xd, PRED_REF);
John Koleszar's avatar
John Koleszar committed
388
389

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

    // Store the prediction flag.
Paul Wilkins's avatar
Paul Wilkins committed
393
    vp9_set_pred_flag(xd, PRED_REF, prediction_flag);
John Koleszar's avatar
John Koleszar committed
394
395

    // Get the predicted reference frame.
Paul Wilkins's avatar
Paul Wilkins committed
396
    pred_ref = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
397
398
399
400

    // If correctly predicted then use the predicted value
    if (prediction_flag) {
      ref_frame = pred_ref;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
401
402
    } else {
      // decode the explicitly coded value
403
      vp9_prob mod_refprobs[PREDICTION_PROBS];
John Koleszar's avatar
John Koleszar committed
404
405
406
407
408
409
410
      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] *=
411
          vp9_check_segref(xd, segment_id, INTRA_FRAME);
John Koleszar's avatar
John Koleszar committed
412
        mod_refprobs[LAST_FRAME] *=
413
          vp9_check_segref(xd, segment_id, LAST_FRAME);
John Koleszar's avatar
John Koleszar committed
414
        mod_refprobs[GOLDEN_FRAME] *=
415
416
          (vp9_check_segref(xd, segment_id, GOLDEN_FRAME) *
           vp9_check_segref(xd, segment_id, ALTREF_FRAME));
John Koleszar's avatar
John Koleszar committed
417
418
419
420
421
422
423
      }

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

      // Do we need to decode the Intra/Inter branch
      if (mod_refprobs[0])
424
        ref_frame = (MV_REFERENCE_FRAME) vp9_read(bc, mod_refprobs[0]);
John Koleszar's avatar
John Koleszar committed
425
426
427
428
429
430
      else
        ref_frame++;

      if (ref_frame) {
        // Do we need to decode the Last/Gf_Arf branch
        if (mod_refprobs[1])
431
          ref_frame += vp9_read(bc, mod_refprobs[1]);
432
        else
John Koleszar's avatar
John Koleszar committed
433
434
435
436
437
          ref_frame++;

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

  return (MV_REFERENCE_FRAME)ref_frame;
463
}
John Koleszar's avatar
John Koleszar committed
464

465
466
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
467
}
John Koleszar's avatar
John Koleszar committed
468

469
470
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
471
472
}

473
474
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
475
}
Scott LaVarnway's avatar
Scott LaVarnway committed
476
477

#ifdef VPX_MODE_COUNT
478
unsigned int vp9_mv_cont_count[5][4] = {
John Koleszar's avatar
John Koleszar committed
479
480
481
482
483
  { 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
484
};
Scott LaVarnway's avatar
Scott LaVarnway committed
485
#endif
John Koleszar's avatar
John Koleszar committed
486

Dmitry Kovalev's avatar
Dmitry Kovalev committed
487
static const unsigned char mbsplit_fill_count[4] = { 8, 8, 4, 1 };
488
static const unsigned char mbsplit_fill_offset[4][16] = {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
489
490
491
492
  { 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
493
};
John Koleszar's avatar
John Koleszar committed
494

495
static void read_switchable_interp_probs(VP9D_COMP* const pbi,
John Koleszar's avatar
John Koleszar committed
496
                                         BOOL_DECODER* const bc) {
497
  VP9_COMMON *const cm = &pbi->common;
498
  int i, j;
499
500
501
  for (j = 0; j <= VP9_SWITCHABLE_FILTERS; ++j) {
    for (i = 0; i < VP9_SWITCHABLE_FILTERS - 1; ++i) {
      cm->fc.switchable_interp_prob[j][i] = vp9_read_literal(bc, 8);
502
503
504
505
506
    }
  }
  //printf("DECODER: %d %d\n", cm->fc.switchable_interp_prob[0],
  //cm->fc.switchable_interp_prob[1]);
}
John Koleszar's avatar
John Koleszar committed
507

508
static void mb_mode_mv_init(VP9D_COMP *pbi, vp9_reader *bc) {
509
  VP9_COMMON *const cm = &pbi->common;
510
  nmv_context *const nmvc = &pbi->common.fc.nmvc;
John Koleszar's avatar
John Koleszar committed
511
  MACROBLOCKD *const xd  = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
512

513
514
  if (cm->frame_type == KEY_FRAME) {
    if (!cm->kf_ymode_probs_update)
515
      cm->kf_ymode_probs_index = vp9_read_literal(bc, 3);
516
  } else {
517
    if (cm->mcomp_filter_type == SWITCHABLE)
John Koleszar's avatar
John Koleszar committed
518
      read_switchable_interp_probs(pbi, bc);
519
520
521
522
523
524
#if CONFIG_COMP_INTERINTRA_PRED
    if (cm->use_interintra) {
      if (vp9_read(bc, VP9_UPD_INTERINTRA_PROB))
        cm->fc.interintra_prob  = (vp9_prob)vp9_read_literal(bc, 8);
    }
#endif
John Koleszar's avatar
John Koleszar committed
525
    // Decode the baseline probabilities for decoding reference frame
526
527
528
    cm->prob_intra_coded = (vp9_prob)vp9_read_literal(bc, 8);
    cm->prob_last_coded  = (vp9_prob)vp9_read_literal(bc, 8);
    cm->prob_gf_coded    = (vp9_prob)vp9_read_literal(bc, 8);
John Koleszar's avatar
John Koleszar committed
529
530
531

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

534
    pbi->common.comp_pred_mode = vp9_read(bc, 128);
John Koleszar's avatar
John Koleszar committed
535
    if (cm->comp_pred_mode)
536
      cm->comp_pred_mode += vp9_read(bc, 128);
John Koleszar's avatar
John Koleszar committed
537
538
539
    if (cm->comp_pred_mode == HYBRID_PREDICTION) {
      int i;
      for (i = 0; i < COMP_PRED_CONTEXTS; i++)
540
        cm->prob_comppred[i] = (vp9_prob)vp9_read_literal(bc, 8);
John Koleszar's avatar
John Koleszar committed
541
    }
John Koleszar's avatar
John Koleszar committed
542

543
    if (vp9_read_bit(bc)) {
John Koleszar's avatar
John Koleszar committed
544
      int i = 0;
John Koleszar's avatar
John Koleszar committed
545

John Koleszar's avatar
John Koleszar committed
546
      do {
547
548
        cm->fc.ymode_prob[i] = (vp9_prob) vp9_read_literal(bc, 8);
      } while (++i < VP9_YMODES - 1);
John Koleszar's avatar
John Koleszar committed
549
    }
550

551
552
553
554
555
556
557
558
    if (vp9_read_bit(bc)) {
      int i = 0;

      do {
        cm->fc.sb_ymode_prob[i] = (vp9_prob) vp9_read_literal(bc, 8);
      } while (++i < VP9_I32X32_MODES - 1);
    }

559
    read_nmvprobs(bc, nmvc, xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
560
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
561
}
John Koleszar's avatar
John Koleszar committed
562

563
564
565
// 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
566
static void read_mb_segment_id(VP9D_COMP *pbi,
John Koleszar's avatar
John Koleszar committed
567
568
                               int mb_row, int mb_col,
                               BOOL_DECODER* const bc) {
569
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
570
  MACROBLOCKD *const xd  = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
571
572
573
574
575
576
577
578
579
580
  MODE_INFO *mi = xd->mode_info_context;
  MB_MODE_INFO *mbmi = &mi->mbmi;
  int index = mb_row * pbi->common.mb_cols + mb_col;

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

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

John Koleszar's avatar
John Koleszar committed
586
        // Store the prediction flag.
Paul Wilkins's avatar
Paul Wilkins committed
587
        vp9_set_pred_flag(xd, PRED_SEG_ID, seg_pred_flag);
John Koleszar's avatar
John Koleszar committed
588
589
590
591

        // If the value is flagged as correctly predicted
        // then use the predicted value
        if (seg_pred_flag) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
592
          mbmi->segment_id = vp9_get_pred_mb_segid(cm, xd, index);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
593
594
        } else {
          // Decode it explicitly
595
          read_mb_segid_except(cm, bc, mbmi, xd, mb_row, mb_col);
John Koleszar's avatar
John Koleszar committed
596
        }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
597
598
      } else {
        // Normal unpredicted coding mode
599
        read_mb_segid(bc, mbmi, xd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
600
      }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
601

Ronald S. Bultje's avatar
Ronald S. Bultje committed
602
603
604
605
606
607
608
609
610
611
612
      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++) {
            cm->last_frame_seg_map[index + x + y * cm->mb_cols] =
                mbmi->segment_id;
          }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
613
        }
614
      } else {
John Koleszar's avatar
John Koleszar committed
615
616
        cm->last_frame_seg_map[index] = mbmi->segment_id;
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
617
    } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
618
619
620
621
622
623
624
625
626
627
      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,
Dmitry Kovalev's avatar
Dmitry Kovalev committed
628
                cm->last_frame_seg_map[index + x + y * cm->mb_cols]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
629
          }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
630
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
631
        mbmi->segment_id = segment_id;
632
      } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
633
634
        mbmi->segment_id = cm->last_frame_seg_map[index];
      }
635
    }
John Koleszar's avatar
John Koleszar committed
636
637
638
639
640
  } else {
    // The encoder explicitly sets the segment_id to 0
    // when segmentation is disabled
    mbmi->segment_id = 0;
  }
641
}
642

Dmitry Kovalev's avatar
Dmitry Kovalev committed
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663

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

664
static void read_mb_modes_mv(VP9D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
665
                             MODE_INFO *prev_mi,
John Koleszar's avatar
John Koleszar committed
666
667
                             int mb_row, int mb_col,
                             BOOL_DECODER* const bc) {
668
  VP9_COMMON *const cm = &pbi->common;
669
  nmv_context *const nmvc = &pbi->common.fc.nmvc;
John Koleszar's avatar
John Koleszar committed
670
  const int mis = pbi->common.mode_info_stride;
John Koleszar's avatar
John Koleszar committed
671
  MACROBLOCKD *const xd  = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
672

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

676
677
  const int use_prev_in_find_mv_refs = cm->width == cm->last_width &&
                                       cm->height == cm->last_height &&
678
                                       !cm->error_resilient_mode;
John Koleszar's avatar
John Koleszar committed
679

Dmitry Kovalev's avatar
Dmitry Kovalev committed
680
681
  int mb_to_left_edge;
  int mb_to_right_edge;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
682
683
684
  int mb_to_top_edge = xd->mb_to_top_edge - LEFT_TOP_MARGIN;
  int mb_to_bottom_edge = xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN;

John Koleszar's avatar
John Koleszar committed
685
686
  mbmi->need_to_clamp_mvs = 0;
  mbmi->need_to_clamp_secondmv = 0;
687
  mbmi->second_ref_frame = NONE;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
688

689
690
691
692
693
  // 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
694
695
696
  // 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
697
698
699
  set_mb_row(cm, xd, mb_row, mb_size);
  set_mb_col(cm, xd, mb_col, mb_size);

Dmitry Kovalev's avatar
Dmitry Kovalev committed
700
701
  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
702
703

  // Read the macroblock segment id.
John Koleszar's avatar
John Koleszar committed
704
  read_mb_segment_id(pbi, mb_row, mb_col, bc);
John Koleszar's avatar
John Koleszar committed
705
706

  if (pbi->common.mb_no_coeff_skip &&
Paul Wilkins's avatar
Paul Wilkins committed
707
      (!vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP))) {
John Koleszar's avatar
John Koleszar committed
708
709
    // Read the macroblock coeff skip flag if this feature is in use,
    // else default to 0
710
    mbmi->mb_skip_coeff = vp9_read(bc, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
John Koleszar's avatar
John Koleszar committed
711
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
712
713
    mbmi->mb_skip_coeff = vp9_segfeature_active(xd, mbmi->segment_id,
                                                SEG_LVL_SKIP);
John Koleszar's avatar
John Koleszar committed
714
715
716
  }

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

719
720
721
722
723
  /*
  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
724
725
726
727
  // 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
728
    vp9_prob mv_ref_p[VP9_MVREFS - 1];
John Koleszar's avatar
John Koleszar committed
729

730
    MV_REFERENCE_FRAME ref_frame = mbmi->ref_frame;
731
    xd->scale_factor[0] = cm->active_ref_scale[mbmi->ref_frame - 1];
732
733

    {
734
735
736
737
738
      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;
739
740

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

743
744
      setup_pred_block(&xd->pre, &cm->yv12_fb[ref_fb_idx],
          mb_row, mb_col, &xd->scale_factor[0], &xd->scale_factor_uv[0]);
745

746
747
748
749
750
#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
751
752
      // if (cm->current_video_frame == 1 && mb_row == 4 && mb_col == 5)
      //  printf("Dello\n");
753
      vp9_find_mv_refs(cm, xd, mi, use_prev_in_find_mv_refs ? prev_mi : NULL,
Paul Wilkins's avatar
Paul Wilkins committed
754
755
                       ref_frame, mbmi->ref_mvs[ref_frame],
                       cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
756

Paul Wilkins's avatar
Paul Wilkins committed
757
758
      vp9_mv_ref_probs(&pbi->common, mv_ref_p,
                       mbmi->mb_mode_context[ref_frame]);
759

760
      // If the segment level skip mode enabled
Paul Wilkins's avatar
Paul Wilkins committed
761
762
      if (vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP)) {
        mbmi->mode = ZEROMV;
763
      } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
764
765
        mbmi->mode = mbmi->sb_type ? read_sb_mv_ref(bc, mv_ref_p)
                                   : read_mv_ref(bc, mv_ref_p);
766
767
768
769
770
771
        vp9_accum_mv_refs(&pbi->common, mbmi->mode,
                          mbmi->mb_mode_context[ref_frame]);
      }

      if (mbmi->mode != ZEROMV) {
        vp9_find_best_ref_mvs(xd,
772
773
774
                              use_prev_in_find_best_ref ?
                                  xd->pre.y_buffer : NULL,
                              xd->pre.y_stride,
775
776
777
778
779
                              mbmi->ref_mvs[ref_frame],
                              &nearest, &nearby);

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

781
782
783
784
785
786
#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
787
    }
John Koleszar's avatar
John Koleszar committed
788

Dmitry Kovalev's avatar
Dmitry Kovalev committed
789
    if (mbmi->mode >= NEARESTMV && mbmi->mode <= SPLITMV) {
790
      if (cm->mcomp_filter_type == SWITCHABLE) {
791
        mbmi->interp_filter = vp9_switchable_interp[
792
793
            treed_read(bc, vp9_switchable_interp_tree,
                       vp9_get_pred_probs(cm, xd, PRED_SWITCHABLE_INTERP))];
794
795
796
797
      } else {
        mbmi->interp_filter = cm->mcomp_filter_type;
      }
    }
798

John Koleszar's avatar
John Koleszar committed
799
800
    if (cm->comp_pred_mode == COMP_PREDICTION_ONLY ||
        (cm->comp_pred_mode == HYBRID_PREDICTION &&
801
         vp9_read(bc, vp9_get_pred_prob(cm, xd, PRED_COMP)))) {
John Koleszar's avatar
John Koleszar committed
802
803
804
805
806
807
808
809
810
811
      /* 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;
812
      if (mbmi->second_ref_frame > 0) {
813
        int second_ref_fb_idx;
814
815
816
817
818
819
820
821
        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;
822

823
        /* Select the appropriate reference frame for this MB */
824
        second_ref_fb_idx = cm->active_ref_idx[mbmi->second_ref_frame - 1];
825

826
827
828
829
        setup_pred_block(&xd->second_pre, &cm->yv12_fb[second_ref_fb_idx],
            mb_row, mb_col, &xd->scale_factor[1], &xd->scale_factor_uv[1]);

        vp9_find_mv_refs(cm, xd, mi, use_prev_in_find_mv_refs ? prev_mi : NULL,
Paul Wilkins's avatar
Paul Wilkins committed
830
831
832
                         mbmi->second_ref_frame,
                         mbmi->ref_mvs[mbmi->second_ref_frame],
                         cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
833

834
835
        if (mbmi->mode != ZEROMV) {
          vp9_find_best_ref_mvs(xd,
836
837
838
                                use_prev_in_find_best_ref ?
                                    xd->second_pre.y_buffer : NULL,
                                xd->second_pre.y_stride,
839
840
841
842
843
                                mbmi->ref_mvs[mbmi->second_ref_frame],
                                &nearest_second,
                                &nearby_second);
          best_mv_second = mbmi->ref_mvs[mbmi->second_ref_frame][0];
        }
844
      }
Yaowu Xu's avatar
Yaowu Xu committed
845

John Koleszar's avatar
John Koleszar committed
846
    } else {
847
848
849
850
851
852
853
854
855
856
857
#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
858
          mbmi->interintra_mode = read_ymode(bc, pbi->common.fc.ymode_prob);
859
860
          pbi->common.fc.ymode_counts[mbmi->interintra_mode]++;
#if SEPARATE_INTERINTRA_UV
Dmitry Kovalev's avatar
Dmitry Kovalev committed
861
862
          mbmi->interintra_uv_mode = read_uv_mode(bc,
              pbi->common.fc.uv_mode_prob[mbmi->interintra_mode]);
863
864
865
866
867
868
869
870
871
872
          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
873
    }
874

875
876
877
878
879
880
881
882
#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 =
883
        vp9_read_mv_ref_id(bc, xd->mb_mv_ref_probs[ref_frame]);
884
885
886
887
888
889
890
891

      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 =
892
          vp9_read_mv_ref_id(bc, xd->mb_mv_ref_probs[ref_frame]);
893
894
895
896
897
        best_mv_second.as_int = mbmi->ref_mvs[ref_frame][best_index].as_int;
      }
    }
#endif

John Koleszar's avatar
John Koleszar committed
898
899
900
901
    mbmi->uv_mode = DC_PRED;
    switch (mbmi->mode) {
      case SPLITMV: {
        const int s = mbmi->partitioning =
902
                        treed_read(bc, vp9_mbsplit_tree, cm->fc.mbsplit_prob);
903
        const int num_p = vp9_mbsplit_count [s];
John Koleszar's avatar
John Koleszar committed
904
905
        int j = 0;
        cm->fc.mbsplit_counts[s]++;
John Koleszar's avatar
John Koleszar committed
906

John Koleszar's avatar
John Koleszar committed
907
        mbmi->need_to_clamp_mvs = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
908
        do {  // for each subset j
John Koleszar's avatar
John Koleszar committed
909
910
911
912
          int_mv leftmv, abovemv, second_leftmv, second_abovemv;
          int_mv blockmv, secondmv;
          int mv_contz;
          int blockmode;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
913
          int k = vp9_mbsplit_offset[s][j];  // first block in subset j
John Koleszar's avatar
John Koleszar committed
914

915
          leftmv.as_int = left_block_mv(xd, mi, k);
John Koleszar's avatar
John Koleszar committed
916
          abovemv.as_int = above_block_mv(mi, k, mis);
917
918
          second_leftmv.as_int = 0;
          second_abovemv.as_int = 0;
Deb Mukherjee's avatar