vp9_decodemv.c 26.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 <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
41
42
43
44
  return (MB_PREDICTION_MODE)treed_read(r, vp9_intra_mode_tree, p);
}

static MB_PREDICTION_MODE read_inter_mode(vp9_reader *r, const vp9_prob *p) {
  return (MB_PREDICTION_MODE)treed_read(r, vp9_sb_mv_ref_tree, p);
45
46
}

47
static int read_segment_id(vp9_reader *r, MACROBLOCKD *xd) {
48
  return treed_read(r, vp9_segment_tree, xd->mb_segment_tree_probs);
Scott LaVarnway's avatar
Scott LaVarnway committed
49
}
50

51
52
static TX_SIZE read_selected_txfm_size(VP9_COMMON *cm, MACROBLOCKD *xd,
                                       BLOCK_SIZE_TYPE bsize, vp9_reader *r) {
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
  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;
}

72
73
74
static TX_SIZE read_txfm_size(VP9D_COMP *pbi, TXFM_MODE txfm_mode,
                              BLOCK_SIZE_TYPE bsize, int select_cond,
                              vp9_reader *r) {
75
76
77
78
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;

  if (txfm_mode == TX_MODE_SELECT && bsize >= BLOCK_SIZE_SB8X8 && select_cond)
79
    return read_selected_txfm_size(cm, xd, bsize, r);
80
81
82
83
84
85
86
87
88
89
  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;
}

90
static void set_segment_id(VP9_COMMON *cm, BLOCK_SIZE_TYPE bsize,
91
                           int mi_row, int mi_col, int segment_id) {
92
93
94
  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);
95
  const int xmis = MIN(cm->mi_cols - mi_col, bw);
96
  const int ymis = MIN(cm->mi_rows - mi_row, bh);
97
98
  int x, y;

99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
  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;
118
119
120
  }
}

121
static uint8_t read_skip_coeff(VP9D_COMP *pbi, int segment_id, vp9_reader *r) {
122
  VP9_COMMON *const cm = &pbi->common;
123
  MACROBLOCKD *const xd = &pbi->mb;
124
125
126
127
128
  int skip_coeff = vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP);
  if (!skip_coeff) {
    const uint8_t ctx = vp9_get_pred_context(cm, xd, PRED_MBSKIP);
    skip_coeff = vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
    cm->fc.mbskip_count[ctx][skip_coeff]++;
Deb Mukherjee's avatar
Deb Mukherjee committed
129
  }
130
131
  return skip_coeff;
}
John Koleszar's avatar
John Koleszar committed
132

133
134
135
136
137
138
139
static void read_intra_mode_info(VP9D_COMP *pbi, MODE_INFO *m,
                                 int mi_row, int mi_col, vp9_reader *r) {
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
  MB_MODE_INFO *const mbmi = &m->mbmi;
  const BLOCK_SIZE_TYPE bsize = mbmi->sb_type;
  const int mis = cm->mode_info_stride;
140

141
142
  mbmi->segment_id = read_intra_segment_id(pbi, mi_row, mi_col, r);
  mbmi->mb_skip_coeff = read_skip_coeff(pbi, mbmi->segment_id, r);
143
  mbmi->txfm_size = read_txfm_size(pbi, cm->txfm_mode, bsize, 1, r);
144
145
146
  mbmi->ref_frame[0] = INTRA_FRAME;

  if (bsize >= BLOCK_SIZE_SB8X8) {
147
148
149
    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;
150
    mbmi->mode = read_intra_mode(r, cm->kf_y_mode_prob[A][L]);
151
  } else {
152
153
154
    // Only 4x4, 4x8, 8x4 blocks
    const int bw = 1 << b_width_log2(bsize);
    const int bh = 1 << b_height_log2(bsize);
155
    int idx, idy;
156
157
158

    for (idy = 0; idy < 2; idy += bh) {
      for (idx = 0; idx < 2; idx += bw) {
159
        const int ib = idy * 2 + idx;
160
161
162
        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;
163
164
165
166
167
168
169
        const MB_PREDICTION_MODE b_mode = read_intra_mode(r,
                                              cm->kf_y_mode_prob[A][L]);
        m->bmi[ib].as_mode.first = b_mode;
        if (bh == 2)
          m->bmi[ib + 2].as_mode.first = b_mode;
        if (bw == 2)
          m->bmi[ib + 1].as_mode.first = b_mode;
170
171
      }
    }
172
173

    mbmi->mode = m->bmi[3].as_mode.first;
John Koleszar's avatar
John Koleszar committed
174
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
175

176
  mbmi->uv_mode = read_intra_mode(r, cm->kf_uv_mode_prob[mbmi->mode]);
Scott LaVarnway's avatar
Scott LaVarnway committed
177
}
John Koleszar's avatar
John Koleszar committed
178

179
180
static int read_mv_component(vp9_reader *r,
                             const nmv_component *mvcomp, int usehp) {
181

182
  int mag, d, fr, hp;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
183
184
  const int sign = vp9_read(r, mvcomp->sign);
  const int mv_class = treed_read(r, vp9_mv_class_tree, mvcomp->classes);
185
  const int class0 = mv_class == MV_CLASS_0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
186

187
  // Integer part
188
  if (class0) {
189
    d = treed_read(r, vp9_mv_class0_tree, mvcomp->class0);
190
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
191
    int i;
192
    const int n = mv_class + CLASS0_BITS - 1;  // number of bits
Dmitry Kovalev's avatar
Dmitry Kovalev committed
193

194
    d = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
195
196
    for (i = 0; i < n; ++i)
      d |= vp9_read(r, mvcomp->bits[i]) << i;
197
198
  }

199
200
  // Fractional part
  fr = treed_read(r, vp9_mv_fp_tree,
201
                  class0 ? mvcomp->class0_fp[d] : mvcomp->fp);
202
203


204
  // High precision part (if hp is not used, the default value of the hp is 1)
205
  hp = usehp ? vp9_read(r, class0 ? mvcomp->class0_hp : mvcomp->hp)
206
             : 1;
207

208
  // Result
209
210
  mag = vp9_get_mv_mag(mv_class, (d << 3) | (fr << 1) | hp) + 1;
  return sign ? -mag : mag;
211
212
}

213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
static INLINE void read_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};

  usehp = usehp && vp9_use_mv_hp(ref);
  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);

  vp9_inc_mv(&diff, ref, counts, usehp);

  mv->row = ref->row + diff.row;
  mv->col = ref->col + diff.col;
}

232
static void update_mv(vp9_reader *r, vp9_prob *p, vp9_prob upd_p) {
233
  if (vp9_read(r, upd_p)) {
234
#ifdef LOW_PRECISION_MV_UPDATE
235
    *p = (vp9_read_literal(r, 7) << 1) | 1;
236
#else
237
    *p = vp9_read_literal(r, 8);
238
239
240
241
#endif
  }
}

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

245
#ifdef MV_GROUP_UPDATE
246
  if (!vp9_read_bit(r))
Dmitry Kovalev's avatar
Dmitry Kovalev committed
247
    return;
248
#endif
249

Dmitry Kovalev's avatar
Dmitry Kovalev committed
250
  for (j = 0; j < MV_JOINTS - 1; ++j)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
251
    update_mv(r, &mvc->joints[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
252

253
  for (i = 0; i < 2; ++i) {
254
255
256
    nmv_component *const comp = &mvc->comps[i];

    update_mv(r, &comp->sign, VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
257
    for (j = 0; j < MV_CLASSES - 1; ++j)
258
      update_mv(r, &comp->classes[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
259
260

    for (j = 0; j < CLASS0_SIZE - 1; ++j)
261
      update_mv(r, &comp->class0[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
262
263

    for (j = 0; j < MV_OFFSET_BITS; ++j)
264
      update_mv(r, &comp->bits[j], VP9_NMV_UPDATE_PROB);
265
266
267
  }

  for (i = 0; i < 2; ++i) {
268
269
    nmv_component *const comp = &mvc->comps[i];

270
    for (j = 0; j < CLASS0_SIZE; ++j)
271
      for (k = 0; k < 3; ++k)
272
        update_mv(r, &comp->class0_fp[j][k], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
273
274

    for (j = 0; j < 3; ++j)
275
      update_mv(r, &comp->fp[j], VP9_NMV_UPDATE_PROB);
276
277
278
279
  }

  if (usehp) {
    for (i = 0; i < 2; ++i) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
280
281
      update_mv(r, &mvc->comps[i].class0_hp, VP9_NMV_UPDATE_PROB);
      update_mv(r, &mvc->comps[i].hp, VP9_NMV_UPDATE_PROB);
282
283
284
285
    }
  }
}

286
// Read the referncence frame
Ronald S. Bultje's avatar
Ronald S. Bultje committed
287
288
static void read_ref_frame(VP9D_COMP *pbi, vp9_reader *r,
                           int segment_id, MV_REFERENCE_FRAME ref_frame[2]) {
289
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
290
  MACROBLOCKD *const xd = &pbi->mb;
291
  FRAME_CONTEXT *const fc = &cm->fc;
292

293
294
295
296
297
  if (vp9_segfeature_active(xd, segment_id, SEG_LVL_REF_FRAME)) {
    ref_frame[0] = vp9_get_segdata(xd, segment_id, SEG_LVL_REF_FRAME);
    ref_frame[1] = NONE;
  } else {
    const int comp_ctx = vp9_get_pred_context(cm, xd, PRED_COMP_INTER_INTER);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
298
    int is_comp;
John Koleszar's avatar
John Koleszar committed
299

Ronald S. Bultje's avatar
Ronald S. Bultje committed
300
    if (cm->comp_pred_mode == HYBRID_PREDICTION) {
301
302
      is_comp = vp9_read(r, fc->comp_inter_prob[comp_ctx]);
      fc->comp_inter_count[comp_ctx][is_comp]++;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
303
304
305
    } else {
      is_comp = cm->comp_pred_mode == COMP_PREDICTION_ONLY;
    }
John Koleszar's avatar
John Koleszar committed
306

Ronald S. Bultje's avatar
Ronald S. Bultje committed
307
308
    // FIXME(rbultje) I'm pretty sure this breaks segmentation ref frame coding
    if (is_comp) {
309
310
311
312
313
      const int fix_ref_idx = cm->ref_frame_sign_bias[cm->comp_fixed_ref];
      const int ref_ctx = vp9_get_pred_context(cm, xd, PRED_COMP_REF_P);
      const int b = vp9_read(r, fc->comp_ref_prob[ref_ctx]);
      fc->comp_ref_count[ref_ctx][b]++;
      ref_frame[fix_ref_idx] = cm->comp_fixed_ref;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
314
      ref_frame[!fix_ref_idx] = cm->comp_var_ref[b];
Dmitry Kovalev's avatar
Dmitry Kovalev committed
315
    } else {
316
      const int ref1_ctx = vp9_get_pred_context(cm, xd, PRED_SINGLE_REF_P1);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
317
      ref_frame[1] = NONE;
318
319
320
321
322
323
      if (vp9_read(r, fc->single_ref_prob[ref1_ctx][0])) {
        const int ref2_ctx = vp9_get_pred_context(cm, xd, PRED_SINGLE_REF_P2);
        const int b = vp9_read(r, fc->single_ref_prob[ref2_ctx][1]);
        ref_frame[0] = b ? ALTREF_FRAME : GOLDEN_FRAME;
        fc->single_ref_count[ref1_ctx][0][1]++;
        fc->single_ref_count[ref2_ctx][1][b]++;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
324
325
      } else {
        ref_frame[0] = LAST_FRAME;
326
        fc->single_ref_count[ref1_ctx][0][0]++;
John Koleszar's avatar
John Koleszar committed
327
      }
328
    }
John Koleszar's avatar
John Koleszar committed
329
  }
330
}
John Koleszar's avatar
John Koleszar committed
331

Scott LaVarnway's avatar
Scott LaVarnway committed
332
#ifdef VPX_MODE_COUNT
333
unsigned int vp9_mv_cont_count[5][4] = {
John Koleszar's avatar
John Koleszar committed
334
335
336
337
338
  { 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
339
};
Scott LaVarnway's avatar
Scott LaVarnway committed
340
#endif
John Koleszar's avatar
John Koleszar committed
341

342
static void read_switchable_interp_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
343
  int i, j;
344
345
346
  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))
347
        vp9_diff_update_prob(r, &fc->switchable_interp_prob[j][i]);
348
349
}

350
static void read_inter_mode_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
351
352
  int i, j;
  for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
353
354
    for (j = 0; j < VP9_INTER_MODES - 1; ++j)
      if (vp9_read(r, VP9_MODE_UPDATE_PROB))
355
        vp9_diff_update_prob(r, &fc->inter_mode_probs[i][j]);
356
}
John Koleszar's avatar
John Koleszar committed
357

358
359
360
static INLINE COMPPREDMODE_TYPE read_comp_pred_mode(vp9_reader *r) {
  COMPPREDMODE_TYPE mode = vp9_read_bit(r);
  if (mode)
361
    mode += vp9_read_bit(r);
362
363
364
  return mode;
}

365
366
static int read_inter_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
                                 vp9_reader *r) {
367
  VP9_COMMON *const cm = &pbi->common;
368
  MACROBLOCKD *const xd = &pbi->mb;
369
370
371
372
  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
373

374
375
376
  if (!xd->segmentation_enabled)
    return 0;  // Default for disabled segmentation

377
378
  if (!xd->update_mb_segmentation_map)
    return pred_segment_id;
379

380
381
382
  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
383
    vp9_set_pred_flag(xd, bsize, PRED_SEG_ID, pred_flag);
384
385
    segment_id = pred_flag ? pred_segment_id
                           : read_segment_id(r, xd);
John Koleszar's avatar
John Koleszar committed
386
  } else {
387
    segment_id = read_segment_id(r, xd);
John Koleszar's avatar
John Koleszar committed
388
  }
389
390
  set_segment_id(cm, bsize, mi_row, mi_col, segment_id);
  return segment_id;
391
}
392

Dmitry Kovalev's avatar
Dmitry Kovalev committed
393
394
395
396
397
398
399
400
401
402
403

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

404
static INLINE INTERPOLATIONFILTERTYPE read_switchable_filter_type(
405
    VP9D_COMP *pbi, vp9_reader *r) {
406
407
408
409
410
411
  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];
412
413
414
  return vp9_switchable_interp[index];
}

415
static void read_intra_block_modes(VP9D_COMP *pbi, MODE_INFO *mi,
416
                                   vp9_reader *r) {
417
  VP9_COMMON *const cm = &pbi->common;
418
  MB_MODE_INFO *const mbmi = &mi->mbmi;
419
  const BLOCK_SIZE_TYPE bsize = mi->mbmi.sb_type;
420
  const int bwl = b_width_log2(bsize), bhl = b_height_log2(bsize);
421
422

  if (bsize >= BLOCK_SIZE_SB8X8) {
423
424
425
    const int size_group = MIN(3, MIN(bwl, bhl));
    mbmi->mode = read_intra_mode(r, cm->fc.y_mode_prob[size_group]);
    cm->fc.y_mode_counts[size_group][mbmi->mode]++;
426
  } else {
427
428
     // Only 4x4, 4x8, 8x4 blocks
     const int bw = 1 << bwl, bh = 1 << bhl;
429
     int idx, idy;
430

431
432
     for (idy = 0; idy < 2; idy += bh) {
       for (idx = 0; idx < 2; idx += bw) {
433
434
435
436
437
438
439
440
441
         const int ib = idy * 2 + idx;
         const int b_mode = read_intra_mode(r, cm->fc.y_mode_prob[0]);
         mi->bmi[ib].as_mode.first = b_mode;
         cm->fc.y_mode_counts[0][b_mode]++;

         if (bh == 2)
           mi->bmi[ib + 2].as_mode.first = b_mode;
         if (bw == 2)
           mi->bmi[ib + 1].as_mode.first = b_mode;
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
      }
    }
    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;
}

469
470
static void read_inter_mode_info(VP9D_COMP *pbi, MODE_INFO *mi,
                                 int mi_row, int mi_col, vp9_reader *r) {
471
  VP9_COMMON *const cm = &pbi->common;
472
  MACROBLOCKD *const xd = &pbi->mb;
473
  nmv_context *const nmvc = &cm->fc.nmvc;
474
  MB_MODE_INFO *const mbmi = &mi->mbmi;
John Koleszar's avatar
John Koleszar committed
475

476
477
  int_mv *const mv0 = &mbmi->mv[0];
  int_mv *const mv1 = &mbmi->mv[1];
478
479
480
  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
481

482
  int idx, idy;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
483

484
485
486
487
  // 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
488
489
490
  // 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
491
492
  set_mi_row_col(cm, xd, mi_row, 1 << mi_height_log2(bsize),
                         mi_col, 1 << mi_width_log2(bsize));
493

494
  mbmi->segment_id = read_inter_segment_id(pbi, mi_row, mi_col, r);
495
  mbmi->mb_skip_coeff = read_skip_coeff(pbi, mbmi->segment_id, r);
496
  mbmi->ref_frame[0] = read_reference_frame(pbi, mbmi->segment_id, r);
497
498
499
  mbmi->ref_frame[1] = NONE;
  mbmi->txfm_size = read_txfm_size(pbi, cm->txfm_mode, bsize,
     (!mbmi->mb_skip_coeff || mbmi->ref_frame[0] == INTRA_FRAME), r);
500

Ronald S. Bultje's avatar
Ronald S. Bultje committed
501
  if (mbmi->ref_frame[0] != INTRA_FRAME) {
John Koleszar's avatar
John Koleszar committed
502
503
    int_mv nearest, nearby, best_mv;
    int_mv nearest_second, nearby_second, best_mv_second;
504
    vp9_prob *mv_ref_p;
505
    MV_REFERENCE_FRAME ref0, ref1;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
506
507

    read_ref_frame(pbi, r, mbmi->segment_id, mbmi->ref_frame);
508
509
    ref0 = mbmi->ref_frame[0];
    ref1 = mbmi->ref_frame[1];
510

511
#ifdef DEC_DEBUG
512
513
514
    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);
515
#endif
516
517
    vp9_find_mv_refs(cm, xd, mi, xd->prev_mode_info_context,
                     ref0, mbmi->ref_mvs[ref0], cm->ref_frame_sign_bias);
518

519
    mv_ref_p = cm->fc.inter_mode_probs[mbmi->mb_mode_context[ref0]];
520

521
522
523
524
525
526
527
528
529
530
531
532
533
    if (vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP)) {
      mbmi->mode = ZEROMV;
    } else if (bsize >= BLOCK_SIZE_SB8X8) {
      mbmi->mode = read_inter_mode(r, mv_ref_p);
      vp9_accum_mv_refs(cm, mbmi->mode, mbmi->mb_mode_context[ref0]);
    }
    mbmi->uv_mode = DC_PRED;

    // nearest, nearby
    if (bsize < BLOCK_SIZE_SB8X8 || mbmi->mode != ZEROMV) {
      vp9_find_best_ref_mvs(xd, mbmi->ref_mvs[ref0], &nearest, &nearby);
      best_mv.as_int = mbmi->ref_mvs[ref0][0].as_int;
    }
534

535
#ifdef DEC_DEBUG
536
537
538
539
    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]);
540
#endif
John Koleszar's avatar
John Koleszar committed
541

542
543
544
    mbmi->interp_filter = cm->mcomp_filter_type == SWITCHABLE
                              ? read_switchable_filter_type(pbi, r)
                              : cm->mcomp_filter_type;
545

546
    if (ref1 > INTRA_FRAME) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
547
      vp9_find_mv_refs(cm, xd, mi, xd->prev_mode_info_context,
548
                       ref1, mbmi->ref_mvs[ref1], cm->ref_frame_sign_bias);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
549
550

      if (bsize < BLOCK_SIZE_SB8X8 || mbmi->mode != ZEROMV) {
551
552
553
        vp9_find_best_ref_mvs(xd, mbmi->ref_mvs[ref1],
                              &nearest_second, &nearby_second);
        best_mv_second.as_int = mbmi->ref_mvs[ref1][0].as_int;
554
      }
John Koleszar's avatar
John Koleszar committed
555
    }
556

557

Ronald S. Bultje's avatar
Ronald S. Bultje committed
558
559
560
561
    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;
562
          const int j = idy * 2 + idx;
563
          const int blockmode = read_inter_mode(r, mv_ref_p);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
564

565
          vp9_accum_mv_refs(cm, blockmode, mbmi->mb_mode_context[ref0]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
566
567
          if (blockmode == NEARESTMV || blockmode == NEARMV) {
            vp9_append_sub8x8_mvs_for_idx(cm, xd, &nearest, &nearby, j, 0);
568
            if (ref1 > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
569
570
571
              vp9_append_sub8x8_mvs_for_idx(cm, xd,  &nearest_second,
                                            &nearby_second, j, 1);
          }
572

Ronald S. Bultje's avatar
Ronald S. Bultje committed
573
574
          switch (blockmode) {
            case NEWMV:
575
576
              read_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
577

578
              if (ref1 > 0)
579
580
                read_mv(r, &secondmv.as_mv, &best_mv_second.as_mv, nmvc,
                        &cm->fc.NMVcount, xd->allow_high_precision_mv);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
581
582
583
584
585
586
587

#ifdef VPX_MODE_COUNT
              vp9_mv_cont_count[mv_contz][3]++;
#endif
              break;
            case NEARESTMV:
              blockmv.as_int = nearest.as_int;
588
              if (ref1 > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
589
590
591
592
593
594
595
                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;
596
              if (ref1 > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
597
598
599
600
601
602
603
                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;
604
              if (ref1 > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
605
606
607
608
609
610
                secondmv.as_int = 0;
#ifdef VPX_MODE_COUNT
              vp9_mv_cont_count[mv_contz][2]++;
#endif
              break;
            default:
611
              assert(!"Invalid inter mode value");
John Koleszar's avatar
John Koleszar committed
612
          }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
613
          mi->bmi[j].as_mv[0].as_int = blockmv.as_int;
614
          if (ref1 > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
615
616
            mi->bmi[j].as_mv[1].as_int = secondmv.as_int;

617
618
619
620
          if (bh == 2)
            vpx_memcpy(&mi->bmi[j + 2], &mi->bmi[j], sizeof(mi->bmi[j]));
          if (bw == 2)
            vpx_memcpy(&mi->bmi[j + 1], &mi->bmi[j], sizeof(mi->bmi[j]));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
621
          mi->mbmi.mode = blockmode;
622
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
623
      }
John Koleszar's avatar
John Koleszar committed
624

Ronald S. Bultje's avatar
Ronald S. Bultje committed
625
626
627
      mv0->as_int = mi->bmi[3].as_mv[0].as_int;
      mv1->as_int = mi->bmi[3].as_mv[1].as_int;
    } else {
628
629
630
631
632
      const int mb_to_top_edge = xd->mb_to_top_edge - LEFT_TOP_MARGIN;
      const int mb_to_bottom_edge = xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN;
      const int mb_to_left_edge = xd->mb_to_left_edge - LEFT_TOP_MARGIN;
      const int mb_to_right_edge = xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN;

Ronald S. Bultje's avatar
Ronald S. Bultje committed
633
634
635
636
637
638
639
      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);
640
          if (ref1 > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
641
642
643
644
645
646
647
648
649
650
651
652
            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);
653
          if (ref1 > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
654
655
656
657
658
659
660
661
            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;
662
          if (ref1 > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
663
664
665
666
            mv1->as_int = 0;
          break;

        case NEWMV:
667
668
          read_mv(r, &mv0->as_mv, &best_mv.as_mv, nmvc, &cm->fc.NMVcount,
                  xd->allow_high_precision_mv);
669
          if (ref1 > 0)
670
671
            read_mv(r, &mv1->as_mv, &best_mv_second.as_mv, nmvc,
                    &cm->fc.NMVcount, xd->allow_high_precision_mv);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
672
673
          break;
        default:
674
          assert(!"Invalid inter mode value");
Ronald S. Bultje's avatar
Ronald S. Bultje committed
675
      }
Scott LaVarnway's avatar
Scott LaVarnway committed
676
    }
John Koleszar's avatar
John Koleszar committed
677
  } else {
678
    mv0->as_int = 0;  // required for left and above block mv
679
    read_intra_block_modes(pbi, mi, r);
John Koleszar's avatar
John Koleszar committed
680
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
681
}
John Koleszar's avatar
John Koleszar committed
682

683
684
void vp9_prepare_read_mode_info(VP9D_COMP* pbi, vp9_reader *r) {
  VP9_COMMON *const cm = &pbi->common;
685
  int k;
686

687
  // TODO(jkoleszar): does this clear more than MBSKIP_CONTEXTS? Maybe remove.
Deb Mukherjee's avatar
Deb Mukherjee committed
688
  // vpx_memset(cm->fc.mbskip_probs, 0, sizeof(cm->fc.mbskip_probs));
689
690
  for (k = 0; k < MBSKIP_CONTEXTS; ++k)
    if (vp9_read(r, VP9_MODE_UPDATE_PROB))
691
      vp9_diff_update_prob(r, &cm->fc.mbskip_probs[k]);
692

693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
  if (cm->frame_type != KEY_FRAME && !cm->intra_only) {
    nmv_context *const nmvc = &pbi->common.fc.nmvc;
    MACROBLOCKD *const xd = &pbi->mb;
    int i, j;

    read_inter_mode_probs(&cm->fc, r);

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

    for (i = 0; i < INTRA_INTER_CONTEXTS; i++)
      if (vp9_read(r, VP9_MODE_UPDATE_PROB))
        vp9_diff_update_prob(r, &cm->fc.intra_inter_prob[i]);

    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++)
          if (vp9_read(r, VP9_MODE_UPDATE_PROB))
            vp9_diff_update_prob(r, &cm->fc.comp_inter_prob[i]);
    } else {
      cm->comp_pred_mode = SINGLE_PREDICTION_ONLY;
    }

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

        if (vp9_read(r, VP9_MODE_UPDATE_PROB))
          vp9_diff_update_prob(r, &cm->fc.single_ref_prob[i][1]);
      }

    if (cm->comp_pred_mode != SINGLE_PREDICTION_ONLY)
      for (i = 0; i < REF_CONTEXTS; i++)
        if (vp9_read(r, VP9_MODE_UPDATE_PROB))
          vp9_diff_update_prob(r, &cm->fc.comp_ref_prob[i]);

    // VP9_INTRA_MODES
    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]);

    read_mv_probs(r, nmvc, xd->allow_high_precision_mv);
  }
744
}
745

746
void vp9_read_mode_info(VP9D_COMP* pbi, int mi_row, int mi_col, vp9_reader *r) {
747
  VP9_COMMON *const cm = &pbi->common;
748
  MACROBLOCKD *const xd = &pbi->mb;
749
  MODE_INFO *mi = xd->mode_info_context;
750
  const BLOCK_SIZE_TYPE bsize = mi->mbmi.sb_type;
751

752
753
754
755
  if (cm->frame_type == KEY_FRAME || cm->intra_only)
    read_intra_mode_info(pbi, mi, mi_row, mi_col, r);
  else
    read_inter_mode_info(pbi, mi, mi_row, mi_col, r);
756

757
  if (1) {
758
759
    const int bw = 1 << mi_width_log2(bsize);
    const int bh = 1 << mi_height_log2(bsize);
760
761
    const int y_mis = MIN(bh, cm->mi_rows - mi_row);
    const int x_mis = MIN(bw, cm->mi_cols - mi_col);
762
763
    int x, y;

764
765
    for (y = 0; y < y_mis; y++)
      for (x = !y; x < x_mis; x++)
766
        mi[y * cm->mode_info_stride + x] = *mi;
767
  }
768
}