vp9_decodemv.c 27.8 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 <assert.h>

13
14
#include "vp9/common/vp9_common.h"
#include "vp9/common/vp9_entropy.h"
15
#include "vp9/common/vp9_entropymode.h"
16
#include "vp9/common/vp9_entropymv.h"
17
#include "vp9/common/vp9_findnearmv.h"
18
#include "vp9/common/vp9_mvref_common.h"
19
#include "vp9/common/vp9_pred_common.h"
20
21
22
#include "vp9/common/vp9_reconinter.h"
#include "vp9/common/vp9_seg_common.h"

23
#include "vp9/decoder/vp9_decodemv.h"
24
#include "vp9/decoder/vp9_decodframe.h"
25
#include "vp9/decoder/vp9_onyxd_int.h"
26
#include "vp9/decoder/vp9_dsubexp.h"
27
28
#include "vp9/decoder/vp9_treereader.h"

John Koleszar's avatar
John Koleszar committed
29
// #define DEBUG_DEC_MV
30
31
32
#ifdef DEBUG_DEC_MV
int dec_mvcount = 0;
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
33

34
35
36
37
// #define DEC_DEBUG
#ifdef DEC_DEBUG
extern int dec_debug;
#endif
38

39
static MB_PREDICTION_MODE read_intra_mode(vp9_reader *r, const vp9_prob *p) {
40
  return treed_read(r, vp9_intra_mode_tree, p);
41
42
}

43
static int read_segment_id(vp9_reader *r, MACROBLOCKD *xd) {
44
  return treed_read(r, vp9_segment_tree, xd->mb_segment_tree_probs);
Scott LaVarnway's avatar
Scott LaVarnway committed
45
}
46

47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
static TX_SIZE select_txfm_size(VP9_COMMON *cm, MACROBLOCKD *xd,
                                vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  const int context = vp9_get_pred_context(cm, xd, PRED_TX_SIZE);
  const vp9_prob *tx_probs = vp9_get_pred_probs(cm, xd, PRED_TX_SIZE);
  TX_SIZE txfm_size = vp9_read(r, tx_probs[0]);
  if (txfm_size != TX_4X4 && bsize >= BLOCK_SIZE_MB16X16) {
    txfm_size += vp9_read(r, tx_probs[1]);
    if (txfm_size != TX_8X8 && bsize >= BLOCK_SIZE_SB32X32)
      txfm_size += vp9_read(r, tx_probs[2]);
  }

  if (bsize >= BLOCK_SIZE_SB32X32)
    cm->fc.tx_count_32x32p[context][txfm_size]++;
  else if (bsize >= BLOCK_SIZE_MB16X16)
    cm->fc.tx_count_16x16p[context][txfm_size]++;
  else
    cm->fc.tx_count_8x8p[context][txfm_size]++;

  return txfm_size;
}

static TX_SIZE get_txfm_size(VP9D_COMP *pbi, TXFM_MODE txfm_mode,
                             BLOCK_SIZE_TYPE bsize, int select_cond,
                             vp9_reader *r) {
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;

  if (txfm_mode == TX_MODE_SELECT && bsize >= BLOCK_SIZE_SB8X8 && select_cond)
    return select_txfm_size(cm, xd, r, bsize);
  else if (txfm_mode >= ALLOW_32X32 && bsize >= BLOCK_SIZE_SB32X32)
    return TX_32X32;
  else if (txfm_mode >= ALLOW_16X16 && bsize >= BLOCK_SIZE_MB16X16)
    return TX_16X16;
  else if (txfm_mode >= ALLOW_8X8 && bsize >= BLOCK_SIZE_SB8X8)
    return TX_8X8;
  else
    return TX_4X4;
}

86
static void set_segment_id(VP9_COMMON *cm, BLOCK_SIZE_TYPE bsize,
87
                           int mi_row, int mi_col, int segment_id) {
88
89
90
  const int mi_offset = mi_row * cm->mi_cols + mi_col;
  const int bw = 1 << mi_width_log2(bsize);
  const int bh = 1 << mi_height_log2(bsize);
91
  const int xmis = MIN(cm->mi_cols - mi_col, bw);
92
  const int ymis = MIN(cm->mi_rows - mi_row, bh);
93
94
  int x, y;

95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
  assert(segment_id >= 0 && segment_id < MAX_MB_SEGMENTS);

  for (y = 0; y < ymis; y++)
    for (x = 0; x < xmis; x++)
      cm->last_frame_seg_map[mi_offset + y * cm->mi_cols + x] = segment_id;
}

static int read_intra_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
                                 vp9_reader *r) {
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
  const BLOCK_SIZE_TYPE bsize = xd->mode_info_context->mbmi.sb_type;

  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
    const int segment_id = read_segment_id(r, xd);
    set_segment_id(cm, bsize, mi_row, mi_col, segment_id);
    return segment_id;
  } else {
    return 0;
114
115
116
  }
}

117
static void kfread_modes(VP9D_COMP *pbi, MODE_INFO *m,
118
                         int mi_row, int mi_col,
119
                         vp9_reader *r) {
120
  VP9_COMMON *const cm = &pbi->common;
121
  MACROBLOCKD *const xd = &pbi->mb;
122
  const int mis = cm->mode_info_stride;
123

124
  m->mbmi.segment_id = read_intra_segment_id(pbi, mi_row, mi_col, r);
125
  m->mbmi.mb_skip_coeff = vp9_segfeature_active(xd, m->mbmi.segment_id,
126
                                                SEG_LVL_SKIP);
Deb Mukherjee's avatar
Deb Mukherjee committed
127
  if (!m->mbmi.mb_skip_coeff) {
128
    m->mbmi.mb_skip_coeff = vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
Deb Mukherjee's avatar
Deb Mukherjee committed
129
130
131
    cm->fc.mbskip_count[vp9_get_pred_context(cm, xd, PRED_MBSKIP)]
                       [m->mbmi.mb_skip_coeff]++;
  }
John Koleszar's avatar
John Koleszar committed
132

133
134
  m->mbmi.txfm_size = get_txfm_size(pbi, cm->txfm_mode, m->mbmi.sb_type,
                                    1, r);
135

136
  // luma mode
Ronald S. Bultje's avatar
Ronald S. Bultje committed
137
  m->mbmi.ref_frame[0] = INTRA_FRAME;
138
139
140
141
  if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
    const MB_PREDICTION_MODE A = above_block_mode(m, 0, mis);
    const MB_PREDICTION_MODE L = xd->left_available ?
                                  left_block_mode(m, 0) : DC_PRED;
142
    m->mbmi.mode = read_intra_mode(r, cm->kf_y_mode_prob[A][L]);
143
  } else {
144
145
146
    int idx, idy;
    int bw = 1 << b_width_log2(m->mbmi.sb_type);
    int bh = 1 << b_height_log2(m->mbmi.sb_type);
147
148
149
150
151
152
153
154
155

    for (idy = 0; idy < 2; idy += bh) {
      for (idx = 0; idx < 2; idx += bw) {
        int ib = idy * 2 + idx;
        int k;
        const MB_PREDICTION_MODE A = above_block_mode(m, ib, mis);
        const MB_PREDICTION_MODE L = (xd->left_available || idx) ?
                                      left_block_mode(m, ib) : DC_PRED;
        m->bmi[ib].as_mode.first =
156
            read_intra_mode(r, cm->kf_y_mode_prob[A][L]);
157
158
159
160
161
162
        for (k = 1; k < bh; ++k)
          m->bmi[ib + k * 2].as_mode.first = m->bmi[ib].as_mode.first;
        for (k = 1; k < bw; ++k)
          m->bmi[ib + k].as_mode.first = m->bmi[ib].as_mode.first;
      }
    }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
163
    m->mbmi.mode = m->bmi[3].as_mode.first;
John Koleszar's avatar
John Koleszar committed
164
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
165

166
  m->mbmi.uv_mode = read_intra_mode(r, cm->kf_uv_mode_prob[m->mbmi.mode]);
Scott LaVarnway's avatar
Scott LaVarnway committed
167
}
John Koleszar's avatar
John Koleszar committed
168

169
170
static int read_mv_component(vp9_reader *r,
                             const nmv_component *mvcomp, int usehp) {
171

172
  int mag, d, fr, hp;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
173
174
175
  const int sign = vp9_read(r, mvcomp->sign);
  const int mv_class = treed_read(r, vp9_mv_class_tree, mvcomp->classes);

176
  // Integer part
Dmitry Kovalev's avatar
Dmitry Kovalev committed
177
  if (mv_class == MV_CLASS_0) {
178
    d = treed_read(r, vp9_mv_class0_tree, mvcomp->class0);
179
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
180
    int i;
181
    const int n = mv_class + CLASS0_BITS - 1;  // number of bits
Dmitry Kovalev's avatar
Dmitry Kovalev committed
182

183
    d = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
184
185
    for (i = 0; i < n; ++i)
      d |= vp9_read(r, mvcomp->bits[i]) << i;
186
187
  }

188
189
190
  // Fractional part
  fr = treed_read(r, vp9_mv_fp_tree,
                  mv_class == MV_CLASS_0 ? mvcomp->class0_fp[d] : mvcomp->fp);
191
192


193
194
195
196
  // High precision part (if hp is not used, the default value of the hp is 1)
  hp = usehp ? vp9_read(r,
                        mv_class == MV_CLASS_0 ? mvcomp->class0_hp : mvcomp->hp)
             : 1;
197

198
199
200
  // result
  mag = vp9_get_mv_mag(mv_class, (d << 3) | (fr << 1) | hp) + 1;
  return sign ? -mag : mag;
201
202
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
203
static void update_mv(vp9_reader *r, vp9_prob *const p,
204
                       const vp9_prob upd_p) {
205
  if (vp9_read(r, upd_p)) {
206
#ifdef LOW_PRECISION_MV_UPDATE
207
    *p = (vp9_read_literal(r, 7) << 1) | 1;
208
#else
209
    *p = (vp9_read_literal(r, 8));
210
211
212
213
#endif
  }
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
214
static void read_mv_probs(vp9_reader *r, nmv_context *mvc, int usehp) {
215
  int i, j, k;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
216

217
#ifdef MV_GROUP_UPDATE
218
  if (!vp9_read_bit(r))
Dmitry Kovalev's avatar
Dmitry Kovalev committed
219
    return;
220
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
221
  for (j = 0; j < MV_JOINTS - 1; ++j)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
222
    update_mv(r, &mvc->joints[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
223

224
  for (i = 0; i < 2; ++i) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
225
    update_mv(r, &mvc->comps[i].sign, VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
226
    for (j = 0; j < MV_CLASSES - 1; ++j)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
227
      update_mv(r, &mvc->comps[i].classes[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
228
229

    for (j = 0; j < CLASS0_SIZE - 1; ++j)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
230
      update_mv(r, &mvc->comps[i].class0[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
231
232

    for (j = 0; j < MV_OFFSET_BITS; ++j)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
233
      update_mv(r, &mvc->comps[i].bits[j], VP9_NMV_UPDATE_PROB);
234
235
236
  }

  for (i = 0; i < 2; ++i) {
237
    for (j = 0; j < CLASS0_SIZE; ++j)
238
      for (k = 0; k < 3; ++k)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
239
        update_mv(r, &mvc->comps[i].class0_fp[j][k], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
240
241

    for (j = 0; j < 3; ++j)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
242
      update_mv(r, &mvc->comps[i].fp[j], VP9_NMV_UPDATE_PROB);
243
244
245
246
  }

  if (usehp) {
    for (i = 0; i < 2; ++i) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
247
248
      update_mv(r, &mvc->comps[i].class0_hp, VP9_NMV_UPDATE_PROB);
      update_mv(r, &mvc->comps[i].hp, VP9_NMV_UPDATE_PROB);
249
250
251
252
    }
  }
}

253
// Read the referncence frame
Ronald S. Bultje's avatar
Ronald S. Bultje committed
254
255
static void read_ref_frame(VP9D_COMP *pbi, vp9_reader *r,
                           int segment_id, MV_REFERENCE_FRAME ref_frame[2]) {
256
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
257
  MACROBLOCKD *const xd = &pbi->mb;
258
259
  const int seg_ref_active = vp9_segfeature_active(xd, segment_id,
                                                   SEG_LVL_REF_FRAME);
260
261
262

  // Segment reference frame features not available.
  if (!seg_ref_active) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
263
264
    int is_comp;
    int comp_ctx = vp9_get_pred_context(cm, xd, PRED_COMP_INTER_INTER);
John Koleszar's avatar
John Koleszar committed
265

Ronald S. Bultje's avatar
Ronald S. Bultje committed
266
267
268
269
270
271
    if (cm->comp_pred_mode == HYBRID_PREDICTION) {
      is_comp = vp9_read(r, cm->fc.comp_inter_prob[comp_ctx]);
      cm->fc.comp_inter_count[comp_ctx][is_comp]++;
    } else {
      is_comp = cm->comp_pred_mode == COMP_PREDICTION_ONLY;
    }
John Koleszar's avatar
John Koleszar committed
272

Ronald S. Bultje's avatar
Ronald S. Bultje committed
273
274
275
276
    // FIXME(rbultje) I'm pretty sure this breaks segmentation ref frame coding
    if (is_comp) {
      int b, fix_ref_idx = cm->ref_frame_sign_bias[cm->comp_fixed_ref];
      int ref_ctx = vp9_get_pred_context(cm, xd, PRED_COMP_REF_P);
John Koleszar's avatar
John Koleszar committed
277

Ronald S. Bultje's avatar
Ronald S. Bultje committed
278
279
280
281
      ref_frame[fix_ref_idx]  = cm->comp_fixed_ref;
      b = vp9_read(r, cm->fc.comp_ref_prob[ref_ctx]);
      cm->fc.comp_ref_count[ref_ctx][b]++;
      ref_frame[!fix_ref_idx] = cm->comp_var_ref[b];
Dmitry Kovalev's avatar
Dmitry Kovalev committed
282
    } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
283
284
285
286
287
288
289
290
291
292
293
      int ref1_ctx = vp9_get_pred_context(cm, xd, PRED_SINGLE_REF_P1);
      ref_frame[1] = NONE;
      if (vp9_read(r, cm->fc.single_ref_prob[ref1_ctx][0])) {
        int ref2_ctx = vp9_get_pred_context(cm, xd, PRED_SINGLE_REF_P2);
        int b2 = vp9_read(r, cm->fc.single_ref_prob[ref2_ctx][1]);
        ref_frame[0] = b2 ? ALTREF_FRAME : GOLDEN_FRAME;
        cm->fc.single_ref_count[ref1_ctx][0][1]++;
        cm->fc.single_ref_count[ref2_ctx][1][b2]++;
      } else {
        ref_frame[0] = LAST_FRAME;
        cm->fc.single_ref_count[ref1_ctx][0][0]++;
John Koleszar's avatar
John Koleszar committed
294
      }
295
    }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
296
  } else {
297
    ref_frame[0] = vp9_get_segdata(xd, segment_id, SEG_LVL_REF_FRAME);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
298
    ref_frame[1] = NONE;
John Koleszar's avatar
John Koleszar committed
299
  }
300
}
John Koleszar's avatar
John Koleszar committed
301

302
303
static MB_PREDICTION_MODE read_sb_mv_ref(vp9_reader *r, const vp9_prob *p) {
  return (MB_PREDICTION_MODE) treed_read(r, vp9_sb_mv_ref_tree, p);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
304
}
John Koleszar's avatar
John Koleszar committed
305

Scott LaVarnway's avatar
Scott LaVarnway committed
306
#ifdef VPX_MODE_COUNT
307
unsigned int vp9_mv_cont_count[5][4] = {
John Koleszar's avatar
John Koleszar committed
308
309
310
311
312
  { 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
313
};
Scott LaVarnway's avatar
Scott LaVarnway committed
314
#endif
John Koleszar's avatar
John Koleszar committed
315

316
static void read_switchable_interp_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
317
  int i, j;
318
319
320
  for (j = 0; j < VP9_SWITCHABLE_FILTERS + 1; ++j)
    for (i = 0; i < VP9_SWITCHABLE_FILTERS - 1; ++i)
      if (vp9_read(r, VP9_MODE_UPDATE_PROB))
321
        vp9_diff_update_prob(r, &fc->switchable_interp_prob[j][i]);
322
323
}

324
static void read_inter_mode_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
325
326
  int i, j;
  for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
327
328
    for (j = 0; j < VP9_INTER_MODES - 1; ++j)
      if (vp9_read(r, VP9_MODE_UPDATE_PROB))
329
        vp9_diff_update_prob(r, &fc->inter_mode_probs[i][j]);
330
}
John Koleszar's avatar
John Koleszar committed
331

332
333
334
335
336
337
338
339
static INLINE COMPPREDMODE_TYPE read_comp_pred_mode(vp9_reader *r) {
  COMPPREDMODE_TYPE mode = vp9_read_bit(r);
  if (mode)
     mode += vp9_read_bit(r);
  return mode;
}

static void mb_mode_mv_init(VP9D_COMP *pbi, vp9_reader *r) {
340
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
341

342
  if (cm->frame_type != KEY_FRAME && !cm->intra_only) {
343
344
    nmv_context *const nmvc = &pbi->common.fc.nmvc;
    MACROBLOCKD *const xd = &pbi->mb;
345
    int i, j;
346

347
    read_inter_mode_probs(&cm->fc, r);
348

349
    if (cm->mcomp_filter_type == SWITCHABLE)
350
      read_switchable_interp_probs(&cm->fc, r);
351

352
    for (i = 0; i < INTRA_INTER_CONTEXTS; i++)
353
      if (vp9_read(r, VP9_MODE_UPDATE_PROB))
354
        vp9_diff_update_prob(r, &cm->fc.intra_inter_prob[i]);
John Koleszar's avatar
John Koleszar committed
355

Ronald S. Bultje's avatar
Ronald S. Bultje committed
356
357
358
359
    if (cm->allow_comp_inter_inter) {
      cm->comp_pred_mode = read_comp_pred_mode(r);
      if (cm->comp_pred_mode == HYBRID_PREDICTION)
        for (i = 0; i < COMP_INTER_CONTEXTS; i++)
360
          if (vp9_read(r, VP9_MODE_UPDATE_PROB))
361
            vp9_diff_update_prob(r, &cm->fc.comp_inter_prob[i]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
362
363
364
365
366
367
    } else {
      cm->comp_pred_mode = SINGLE_PREDICTION_ONLY;
    }

    if (cm->comp_pred_mode != COMP_PREDICTION_ONLY)
      for (i = 0; i < REF_CONTEXTS; i++) {
368
        if (vp9_read(r, VP9_MODE_UPDATE_PROB))
369
370
          vp9_diff_update_prob(r, &cm->fc.single_ref_prob[i][0]);

371
        if (vp9_read(r, VP9_MODE_UPDATE_PROB))
372
          vp9_diff_update_prob(r, &cm->fc.single_ref_prob[i][1]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
373
      }
John Koleszar's avatar
John Koleszar committed
374

Ronald S. Bultje's avatar
Ronald S. Bultje committed
375
376
    if (cm->comp_pred_mode != SINGLE_PREDICTION_ONLY)
      for (i = 0; i < REF_CONTEXTS; i++)
377
        if (vp9_read(r, VP9_MODE_UPDATE_PROB))
378
          vp9_diff_update_prob(r, &cm->fc.comp_ref_prob[i]);
John Koleszar's avatar
John Koleszar committed
379

380
    // VP9_INTRA_MODES
381
382
383
384
385
386
387
388
389
    for (j = 0; j < BLOCK_SIZE_GROUPS; j++)
      for (i = 0; i < VP9_INTRA_MODES - 1; ++i)
        if (vp9_read(r, VP9_MODE_UPDATE_PROB))
          vp9_diff_update_prob(r, &cm->fc.y_mode_prob[j][i]);

    for (j = 0; j < NUM_PARTITION_CONTEXTS; ++j)
      for (i = 0; i < PARTITION_TYPES - 1; ++i)
        if (vp9_read(r, VP9_MODE_UPDATE_PROB))
          vp9_diff_update_prob(r, &cm->fc.partition_prob[INTER_FRAME][j][i]);
390

Dmitry Kovalev's avatar
Dmitry Kovalev committed
391
    read_mv_probs(r, nmvc, xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
392
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
393
}
John Koleszar's avatar
John Koleszar committed
394

395
396
static int read_inter_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
                                 vp9_reader *r) {
397
  VP9_COMMON *const cm = &pbi->common;
398
  MACROBLOCKD *const xd = &pbi->mb;
399
400
401
402
  const BLOCK_SIZE_TYPE bsize = xd->mode_info_context->mbmi.sb_type;
  const int pred_segment_id = vp9_get_segment_id(cm, cm->last_frame_seg_map,
                                                 bsize, mi_row, mi_col);
  int segment_id;
John Koleszar's avatar
John Koleszar committed
403

404
405
406
  if (!xd->segmentation_enabled)
    return 0;  // Default for disabled segmentation

407
408
  if (!xd->update_mb_segmentation_map)
    return pred_segment_id;
409

410
411
412
  if (cm->temporal_update) {
    const vp9_prob pred_prob = vp9_get_pred_prob(cm, xd, PRED_SEG_ID);
    const int pred_flag = vp9_read(r, pred_prob);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
413
    vp9_set_pred_flag(xd, bsize, PRED_SEG_ID, pred_flag);
414
415
    segment_id = pred_flag ? pred_segment_id
                           : read_segment_id(r, xd);
John Koleszar's avatar
John Koleszar committed
416
  } else {
417
    segment_id = read_segment_id(r, xd);
John Koleszar's avatar
John Koleszar committed
418
  }
419
420
  set_segment_id(cm, bsize, mi_row, mi_col, segment_id);
  return segment_id;
421
}
422

Dmitry Kovalev's avatar
Dmitry Kovalev committed
423
424
425
426
427
428
429
430
431
432
433

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

434
435
436
437
438
439
440
static INLINE void decode_mv(vp9_reader *r, MV *mv, const MV *ref,
                             const nmv_context *ctx,
                             nmv_context_counts *counts,
                             int usehp) {
  const MV_JOINT_TYPE j = treed_read(r, vp9_mv_joint_tree, ctx->joints);
  MV diff = {0, 0};

441
  usehp = usehp && vp9_use_mv_hp(ref);
442
443
444
445
446
447
  if (mv_joint_vertical(j))
    diff.row = read_mv_component(r, &ctx->comps[0], usehp);

  if (mv_joint_horizontal(j))
    diff.col = read_mv_component(r, &ctx->comps[1], usehp);

Dmitry Kovalev's avatar
Dmitry Kovalev committed
448
  vp9_inc_mv(&diff, ref, counts, usehp);
449
450
451

  mv->row = diff.row + ref->row;
  mv->col = diff.col + ref->col;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
452
453
}

454
static INLINE INTERPOLATIONFILTERTYPE read_switchable_filter_type(
455
    VP9D_COMP *pbi, vp9_reader *r) {
456
457
458
459
460
461
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
  const vp9_prob *probs = vp9_get_pred_probs(cm, xd, PRED_SWITCHABLE_INTERP);
  const int index = treed_read(r, vp9_switchable_interp_tree, probs);
  const int ctx = vp9_get_pred_context(cm, xd, PRED_SWITCHABLE_INTERP);
  ++cm->fc.switchable_interp_count[ctx][index];
462
463
464
  return vp9_switchable_interp[index];
}

465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
static void read_intra_block_modes(VP9D_COMP *pbi, MODE_INFO *mi,
                                   MB_MODE_INFO *mbmi, vp9_reader *r) {
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
  const BLOCK_SIZE_TYPE bsize = mi->mbmi.sb_type;
  const int bw = 1 << b_width_log2(bsize);
  const int bh = 1 << b_height_log2(bsize);

  if (bsize >= BLOCK_SIZE_SB8X8) {
    const BLOCK_SIZE_TYPE bsize = xd->mode_info_context->mbmi.sb_type;
    const int bwl = b_width_log2(bsize), bhl = b_height_log2(bsize);
    const int bsl = MIN(bwl, bhl);
    mbmi->mode = read_intra_mode(r, cm->fc.y_mode_prob[MIN(3, bsl)]);
    cm->fc.y_mode_counts[MIN(3, bsl)][mbmi->mode]++;
  } else {
     int idx, idy;
     for (idy = 0; idy < 2; idy += bh) {
       for (idx = 0; idx < 2; idx += bw) {
         int ib = idy * 2 + idx, k;
         int m = read_intra_mode(r, cm->fc.y_mode_prob[0]);
         mi->bmi[ib].as_mode.first = m;
         cm->fc.y_mode_counts[0][m]++;
         for (k = 1; k < bh; ++k)
           mi->bmi[ib + k * 2].as_mode.first = m;
         for (k = 1; k < bw; ++k)
           mi->bmi[ib + k].as_mode.first = m;
      }
    }
    mbmi->mode = mi->bmi[3].as_mode.first;
  }

  mbmi->uv_mode = read_intra_mode(r, cm->fc.uv_mode_prob[mbmi->mode]);
  cm->fc.uv_mode_counts[mbmi->mode][mbmi->uv_mode]++;
}

static MV_REFERENCE_FRAME read_reference_frame(VP9D_COMP *pbi, int segment_id,
                                               vp9_reader *r) {
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;

  MV_REFERENCE_FRAME ref;
  if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_REF_FRAME)) {
    const int ctx = vp9_get_pred_context(cm, xd, PRED_INTRA_INTER);
    ref = (MV_REFERENCE_FRAME)
              vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_INTRA_INTER));
    cm->fc.intra_inter_count[ctx][ref != INTRA_FRAME]++;
  } else {
    ref = (MV_REFERENCE_FRAME)
              vp9_get_segdata(xd, segment_id, SEG_LVL_REF_FRAME) != INTRA_FRAME;
  }
  return ref;
}

518
static void read_mb_modes_mv(VP9D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
519
                             int mi_row, int mi_col,
520
                             vp9_reader *r) {
521
  VP9_COMMON *const cm = &pbi->common;
522
  MACROBLOCKD *const xd = &pbi->mb;
523
  nmv_context *const nmvc = &cm->fc.nmvc;
John Koleszar's avatar
John Koleszar committed
524

525
526
  int_mv *const mv0 = &mbmi->mv[0];
  int_mv *const mv1 = &mbmi->mv[1];
527
528
529
  const BLOCK_SIZE_TYPE bsize = mi->mbmi.sb_type;
  const int bw = 1 << b_width_log2(bsize);
  const int bh = 1 << b_height_log2(bsize);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
530

531
  int mb_to_left_edge, mb_to_right_edge, mb_to_top_edge, mb_to_bottom_edge;
532
  int j, idx, idy;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
533

Ronald S. Bultje's avatar
Ronald S. Bultje committed
534
  mbmi->ref_frame[1] = NONE;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
535

536
537
538
539
  // Make sure the MACROBLOCKD mode info pointer is pointed at the
  // correct entry for the current macroblock.
  xd->mode_info_context = mi;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
540
541
542
  // 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
543
544
  set_mi_row_col(cm, xd, mi_row, 1 << mi_height_log2(bsize),
                         mi_col, 1 << mi_width_log2(bsize));
545

546
547
  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
548
549
  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
550
551

  // Read the macroblock segment id.
552
  mbmi->segment_id = read_inter_segment_id(pbi, mi_row, mi_col, r);
John Koleszar's avatar
John Koleszar committed
553

554
555
  mbmi->mb_skip_coeff = vp9_segfeature_active(xd, mbmi->segment_id,
                                              SEG_LVL_SKIP);
Deb Mukherjee's avatar
Deb Mukherjee committed
556
  if (!mbmi->mb_skip_coeff) {
557
    mbmi->mb_skip_coeff = vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
Deb Mukherjee's avatar
Deb Mukherjee committed
558
559
560
    cm->fc.mbskip_count[vp9_get_pred_context(cm, xd, PRED_MBSKIP)]
                       [mbmi->mb_skip_coeff]++;
  }
John Koleszar's avatar
John Koleszar committed
561

562
563
564
  mbmi->ref_frame[0] = read_reference_frame(pbi, mbmi->segment_id, r);
  mbmi->txfm_size = get_txfm_size(pbi, cm->txfm_mode, bsize,
     (mbmi->mb_skip_coeff == 0 || mbmi->ref_frame[0] == INTRA_FRAME), r);
565

John Koleszar's avatar
John Koleszar committed
566
  // If reference frame is an Inter frame
Ronald S. Bultje's avatar
Ronald S. Bultje committed
567
  if (mbmi->ref_frame[0] != INTRA_FRAME) {
John Koleszar's avatar
John Koleszar committed
568
569
    int_mv nearest, nearby, best_mv;
    int_mv nearest_second, nearby_second, best_mv_second;
570
    vp9_prob *mv_ref_p;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
571
572

    read_ref_frame(pbi, r, mbmi->segment_id, mbmi->ref_frame);
573
574

    {
575
576
577
578
579
#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
Ronald S. Bultje's avatar
Ronald S. Bultje committed
580
581
582
      vp9_find_mv_refs(cm, xd, mi, xd->prev_mode_info_context,
                       mbmi->ref_frame[0], mbmi->ref_mvs[mbmi->ref_frame[0]],
                       cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
583

584
585
      mv_ref_p = cm->fc.inter_mode_probs[
        mbmi->mb_mode_context[mbmi->ref_frame[0]]];
586

587
      // If the segment level skip mode enabled
Paul Wilkins's avatar
Paul Wilkins committed
588
589
      if (vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP)) {
        mbmi->mode = ZEROMV;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
590
591
      } else if (bsize >= BLOCK_SIZE_SB8X8) {
        mbmi->mode = read_sb_mv_ref(r, mv_ref_p);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
592
593
        vp9_accum_mv_refs(cm, mbmi->mode,
                          mbmi->mb_mode_context[mbmi->ref_frame[0]]);
594
595
      }

Ronald S. Bultje's avatar
Ronald S. Bultje committed
596
      if (bsize < BLOCK_SIZE_SB8X8 || mbmi->mode != ZEROMV) {
597
        vp9_find_best_ref_mvs(xd,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
598
                              mbmi->ref_mvs[mbmi->ref_frame[0]],
599
600
                              &nearest, &nearby);

Ronald S. Bultje's avatar
Ronald S. Bultje committed
601
        best_mv.as_int = mbmi->ref_mvs[mbmi->ref_frame[0]][0].as_int;
602
      }
603

604
605
606
607
608
609
#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
610
    }
John Koleszar's avatar
John Koleszar committed
611

612
613
614
    mbmi->interp_filter = cm->mcomp_filter_type == SWITCHABLE
                              ? read_switchable_filter_type(pbi, r)
                              : cm->mcomp_filter_type;
615

Ronald S. Bultje's avatar
Ronald S. Bultje committed
616
617
618
619
620
621
622
623
624
625
626
627
    if (mbmi->ref_frame[1] > INTRA_FRAME) {
      vp9_find_mv_refs(cm, xd, mi, xd->prev_mode_info_context,
                       mbmi->ref_frame[1],
                       mbmi->ref_mvs[mbmi->ref_frame[1]],
                       cm->ref_frame_sign_bias);

      if (bsize < BLOCK_SIZE_SB8X8 || mbmi->mode != ZEROMV) {
        vp9_find_best_ref_mvs(xd,
                              mbmi->ref_mvs[mbmi->ref_frame[1]],
                              &nearest_second,
                              &nearby_second);
        best_mv_second.as_int = mbmi->ref_mvs[mbmi->ref_frame[1]][0].as_int;
628
      }
John Koleszar's avatar
John Koleszar committed
629
    }
630

John Koleszar's avatar
John Koleszar committed
631
    mbmi->uv_mode = DC_PRED;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
632
633
634
635
636
637
638
639
640
    if (mbmi->sb_type < BLOCK_SIZE_SB8X8) {
      for (idy = 0; idy < 2; idy += bh) {
        for (idx = 0; idx < 2; idx += bw) {
          int_mv blockmv, secondmv;
          int blockmode;
          int i;
          j = idy * 2 + idx;

          blockmode = read_sb_mv_ref(r, mv_ref_p);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
641
642
          vp9_accum_mv_refs(cm, blockmode,
                            mbmi->mb_mode_context[mbmi->ref_frame[0]]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
643
          if (blockmode == NEARESTMV || blockmode == NEARMV) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
644
            MV_REFERENCE_FRAME rf2 = mbmi->ref_frame[1];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
645
646
647
648
            vp9_append_sub8x8_mvs_for_idx(cm, xd, &nearest, &nearby, j, 0);
            if (rf2 > 0) {
              vp9_append_sub8x8_mvs_for_idx(cm, xd,  &nearest_second,
                                            &nearby_second, j, 1);
649
            }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
650
          }
651

Ronald S. Bultje's avatar
Ronald S. Bultje committed
652
653
654
655
656
          switch (blockmode) {
            case NEWMV:
              decode_mv(r, &blockmv.as_mv, &best_mv.as_mv, nmvc,
                         &cm->fc.NMVcount, xd->allow_high_precision_mv);

Ronald S. Bultje's avatar
Ronald S. Bultje committed
657
              if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
658
659
660
661
662
663
664
665
666
                decode_mv(r, &secondmv.as_mv, &best_mv_second.as_mv, nmvc,
                          &cm->fc.NMVcount, xd->allow_high_precision_mv);

#ifdef VPX_MODE_COUNT
              vp9_mv_cont_count[mv_contz][3]++;
#endif
              break;
            case NEARESTMV:
              blockmv.as_int = nearest.as_int;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
667
              if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
668
669
670
671
672
673
674
                secondmv.as_int = nearest_second.as_int;
#ifdef VPX_MODE_COUNT
              vp9_mv_cont_count[mv_contz][0]++;
#endif
              break;
            case NEARMV:
              blockmv.as_int = nearby.as_int;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
675
              if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
676
677
678
679
680
681
682
                secondmv.as_int = nearby_second.as_int;
#ifdef VPX_MODE_COUNT
              vp9_mv_cont_count[mv_contz][1]++;
#endif
              break;
            case ZEROMV:
              blockmv.as_int = 0;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
683
              if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
684
685
686
687
688
689
690
                secondmv.as_int = 0;
#ifdef VPX_MODE_COUNT
              vp9_mv_cont_count[mv_contz][2]++;
#endif
              break;
            default:
              break;
John Koleszar's avatar
John Koleszar committed
691
          }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
692
          mi->bmi[j].as_mv[0].as_int = blockmv.as_int;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
693
          if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
694
695
696
697
698
699
700
            mi->bmi[j].as_mv[1].as_int = secondmv.as_int;

          for (i = 1; i < bh; ++i)
            vpx_memcpy(&mi->bmi[j + i * 2], &mi->bmi[j], sizeof(mi->bmi[j]));
          for (i = 1; i < bw; ++i)
            vpx_memcpy(&mi->bmi[j + i], &mi->bmi[j], sizeof(mi->bmi[j]));
          mi->mbmi.mode = blockmode;
701
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
702
      }
John Koleszar's avatar
John Koleszar committed
703

Ronald S. Bultje's avatar
Ronald S. Bultje committed
704
705
706
707
708
709
710
711
712
713
      mv0->as_int = mi->bmi[3].as_mv[0].as_int;
      mv1->as_int = mi->bmi[3].as_mv[1].as_int;
    } else {
      switch (mbmi->mode) {
        case NEARMV:
          // Clip "next_nearest" so that it does not extend to far out of image
          assign_and_clamp_mv(mv0, &nearby, mb_to_left_edge,
                                            mb_to_right_edge,
                                            mb_to_top_edge,
                                            mb_to_bottom_edge);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
714
          if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
715
716
717
718
719
720
721
722
723
724
725
726
            assign_and_clamp_mv(mv1, &nearby_second, mb_to_left_edge,
                                                     mb_to_right_edge,
                                                     mb_to_top_edge,
                                                     mb_to_bottom_edge);
          break;

        case NEARESTMV:
          // Clip "next_nearest" so that it does not extend to far out of image
          assign_and_clamp_mv(mv0, &nearest, mb_to_left_edge,
                                             mb_to_right_edge,
                                             mb_to_top_edge,
                                             mb_to_bottom_edge);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
727
          if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
728
729
730
731
732
733
734
735
            assign_and_clamp_mv(mv1, &nearest_second, mb_to_left_edge,
                                                      mb_to_right_edge,
                                                      mb_to_top_edge,
                                                      mb_to_bottom_edge);
          break;

        case ZEROMV:
          mv0->as_int = 0;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
736
          if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
737
738
739
740
741
742
            mv1->as_int = 0;
          break;

        case NEWMV:
          decode_mv(r, &mv0->as_mv, &best_mv.as_mv, nmvc, &cm->fc.NMVcount,
                    xd->allow_high_precision_mv);
743
          if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
744
745
746
747
748
749
750
            decode_mv(r, &mv1->as_mv, &best_mv_second.as_mv, nmvc,
                      &cm->fc.NMVcount, xd->allow_high_precision_mv);
          break;
        default:
          assert(0);
          break;
      }
Scott LaVarnway's avatar
Scott LaVarnway committed
751
    }
John Koleszar's avatar
John Koleszar committed
752
  } else {
753
754
    mv0->as_int = 0;  // required for left and above block mv
    read_intra_block_modes(pbi, mi, mbmi, r);
John Koleszar's avatar
John Koleszar committed
755
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
756
}
John Koleszar's avatar
John Koleszar committed
757

758
void vp9_decode_mode_mvs_init(VP9D_COMP* const pbi, vp9_reader *r) {
759
  VP9_COMMON *cm = &pbi->common;
760
  int k;
761

762
  // TODO(jkoleszar): does this clear more than MBSKIP_CONTEXTS? Maybe remove.
Deb Mukherjee's avatar
Deb Mukherjee committed
763
  // vpx_memset(cm->fc.mbskip_probs, 0, sizeof(cm->fc.mbskip_probs));
764
765
  for (k = 0; k < MBSKIP_CONTEXTS; ++k)
    if (vp9_read(r, VP9_MODE_UPDATE_PROB))
766
      vp9_diff_update_prob(r, &cm->fc.mbskip_probs[k]);
767

768
  mb_mode_mv_init(pbi, r);
769
}
770

771
772
void vp9_decode_mb_mode_mv(VP9D_COMP* const pbi,
                           MACROBLOCKD* const xd,
773
774
                           int mi_row,
                           int mi_col,
775
                           vp9_reader *r) {
776
  VP9_COMMON *const cm = &pbi->common;
777
  MODE_INFO *mi = xd->mode_info_context;
778
  MB_MODE_INFO *const mbmi = &mi->mbmi;
779

780
  if (cm->frame_type == KEY_FRAME || cm->intra_only) {
781
    kfread_modes(pbi, mi, mi_row, mi_col, r);
782
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
783
    read_mb_modes_mv(pbi, mi, &mi->mbmi, mi_row, mi_col, r);
784
  }
785

786
787
788
789
790
  if (1) {
    const int bw = 1 << mi_width_log2(mbmi->sb_type);
    const int bh = 1 << mi_height_log2(mbmi->sb_type);
    const int y_mis = MIN(bh, cm->mi_rows - mi_row);
    const int x_mis = MIN(bw, cm->mi_cols - mi_col);
791
792
793
    const int mis = cm->mode_info_stride;
    int x, y;

794
795
    for (y = 0; y < y_mis; y++)
      for (x = !y; x < x_mis; x++)
796
797
        mi[y * mis + x] = *mi;
  }
798
}