vp9_decodemv.c 28.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/common/vp9_common.h"
#include "vp9/common/vp9_entropy.h"
13
#include "vp9/common/vp9_entropymode.h"
14
#include "vp9/common/vp9_entropymv.h"
15
#include "vp9/common/vp9_findnearmv.h"
16
#include "vp9/common/vp9_mvref_common.h"
17
#include "vp9/common/vp9_pred_common.h"
18
19
20
#include "vp9/common/vp9_reconinter.h"
#include "vp9/common/vp9_seg_common.h"

21
#include "vp9/decoder/vp9_decodemv.h"
22
#include "vp9/decoder/vp9_decodframe.h"
23
24
25
#include "vp9/decoder/vp9_onyxd_int.h"
#include "vp9/decoder/vp9_treereader.h"

John Koleszar's avatar
John Koleszar committed
26
27
28
#if CONFIG_DEBUG
#include <assert.h>
#endif
29

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

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

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

44
static int read_mb_segid(vp9_reader *r, MACROBLOCKD *xd) {
45
  return treed_read(r, vp9_segment_tree, xd->mb_segment_tree_probs);
Scott LaVarnway's avatar
Scott LaVarnway committed
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
86
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;
}

87
static void set_segment_id(VP9_COMMON *cm, MB_MODE_INFO *mbmi,
88
89
                           int mi_row, int mi_col, int segment_id) {
  const int mi_index = mi_row * cm->mi_cols + mi_col;
90
  const BLOCK_SIZE_TYPE sb_type = mbmi->sb_type;
91
92
93
94
95
96
97
98
99
100
  const int bw = 1 << mi_width_log2(sb_type);
  const int bh = 1 << mi_height_log2(sb_type);
  const int ymis = MIN(cm->mi_rows - mi_row, bh);
  const int xmis = MIN(cm->mi_cols - mi_col, bw);
  int x, y;

  for (y = 0; y < ymis; y++) {
    for (x = 0; x < xmis; x++) {
      const int index = mi_index + (y * cm->mi_cols + x);
      cm->last_frame_seg_map[index] = segment_id;
101
102
103
104
    }
  }
}

105
static void kfread_modes(VP9D_COMP *pbi, MODE_INFO *m,
106
                         int mi_row, int mi_col,
107
                         vp9_reader *r) {
108
  VP9_COMMON *const cm = &pbi->common;
109
  MACROBLOCKD *const xd = &pbi->mb;
110
  const int mis = cm->mode_info_stride;
111

112
  // Read segmentation map if it is being updated explicitly this frame
John Koleszar's avatar
John Koleszar committed
113
  m->mbmi.segment_id = 0;
114
115
  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
    m->mbmi.segment_id = read_mb_segid(r, xd);
116
    set_segment_id(cm, &m->mbmi, mi_row, mi_col, m->mbmi.segment_id);
John Koleszar's avatar
John Koleszar committed
117
118
  }

119
  m->mbmi.mb_skip_coeff = vp9_segfeature_active(xd, m->mbmi.segment_id,
120
                                                SEG_LVL_SKIP);
Deb Mukherjee's avatar
Deb Mukherjee committed
121
  if (!m->mbmi.mb_skip_coeff) {
122
    m->mbmi.mb_skip_coeff = vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
Deb Mukherjee's avatar
Deb Mukherjee committed
123
124
125
    cm->fc.mbskip_count[vp9_get_pred_context(cm, xd, PRED_MBSKIP)]
                       [m->mbmi.mb_skip_coeff]++;
  }
John Koleszar's avatar
John Koleszar committed
126

127
128
  m->mbmi.txfm_size = get_txfm_size(pbi, cm->txfm_mode, m->mbmi.sb_type,
                                    1, r);
129

130
  // luma mode
Ronald S. Bultje's avatar
Ronald S. Bultje committed
131
  m->mbmi.ref_frame[0] = INTRA_FRAME;
132
133
134
135
  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;
136
    m->mbmi.mode = read_intra_mode(r, cm->kf_y_mode_prob[A][L]);
137
  } else {
138
139
140
    int idx, idy;
    int bw = 1 << b_width_log2(m->mbmi.sb_type);
    int bh = 1 << b_height_log2(m->mbmi.sb_type);
141
142
143
144
145
146
147
148
149

    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 =
150
            read_intra_mode(r, cm->kf_y_mode_prob[A][L]);
151
152
153
154
155
156
        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
157
    m->mbmi.mode = m->bmi[3].as_mode.first;
John Koleszar's avatar
John Koleszar committed
158
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
159

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

163
164
static int read_mv_component(vp9_reader *r,
                             const nmv_component *mvcomp, int usehp) {
165

166
  int mag, d, fr, hp;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
167
168
169
  const int sign = vp9_read(r, mvcomp->sign);
  const int mv_class = treed_read(r, vp9_mv_class_tree, mvcomp->classes);

170
  // Integer part
Dmitry Kovalev's avatar
Dmitry Kovalev committed
171
  if (mv_class == MV_CLASS_0) {
172
    d = treed_read(r, vp9_mv_class0_tree, mvcomp->class0);
173
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
174
    int i;
175
    const int n = mv_class + CLASS0_BITS - 1;  // number of bits
Dmitry Kovalev's avatar
Dmitry Kovalev committed
176

177
    d = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
178
179
    for (i = 0; i < n; ++i)
      d |= vp9_read(r, mvcomp->bits[i]) << i;
180
181
  }

182
183
184
  // Fractional part
  fr = treed_read(r, vp9_mv_fp_tree,
                  mv_class == MV_CLASS_0 ? mvcomp->class0_fp[d] : mvcomp->fp);
185
186


187
188
189
190
  // 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;
191

192
193
194
  // result
  mag = vp9_get_mv_mag(mv_class, (d << 3) | (fr << 1) | hp) + 1;
  return sign ? -mag : mag;
195
196
}

197
static void update_nmv(vp9_reader *r, vp9_prob *const p,
198
                       const vp9_prob upd_p) {
199
  if (vp9_read(r, upd_p)) {
200
#ifdef LOW_PRECISION_MV_UPDATE
201
    *p = (vp9_read_literal(r, 7) << 1) | 1;
202
#else
203
    *p = (vp9_read_literal(r, 8));
204
205
206
207
#endif
  }
}

208
static void read_nmvprobs(vp9_reader *r, nmv_context *mvctx,
209
210
                          int usehp) {
  int i, j, k;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
211

212
#ifdef MV_GROUP_UPDATE
213
  if (!vp9_read_bit(r))
Dmitry Kovalev's avatar
Dmitry Kovalev committed
214
    return;
215
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
216
  for (j = 0; j < MV_JOINTS - 1; ++j)
217
    update_nmv(r, &mvctx->joints[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
218

219
  for (i = 0; i < 2; ++i) {
220
    update_nmv(r, &mvctx->comps[i].sign, VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
221
    for (j = 0; j < MV_CLASSES - 1; ++j)
222
      update_nmv(r, &mvctx->comps[i].classes[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
223
224

    for (j = 0; j < CLASS0_SIZE - 1; ++j)
225
      update_nmv(r, &mvctx->comps[i].class0[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
226
227

    for (j = 0; j < MV_OFFSET_BITS; ++j)
228
      update_nmv(r, &mvctx->comps[i].bits[j], VP9_NMV_UPDATE_PROB);
229
230
231
  }

  for (i = 0; i < 2; ++i) {
232
    for (j = 0; j < CLASS0_SIZE; ++j)
233
      for (k = 0; k < 3; ++k)
234
        update_nmv(r, &mvctx->comps[i].class0_fp[j][k], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
235
236

    for (j = 0; j < 3; ++j)
237
      update_nmv(r, &mvctx->comps[i].fp[j], VP9_NMV_UPDATE_PROB);
238
239
240
241
  }

  if (usehp) {
    for (i = 0; i < 2; ++i) {
242
243
      update_nmv(r, &mvctx->comps[i].class0_hp, VP9_NMV_UPDATE_PROB);
      update_nmv(r, &mvctx->comps[i].hp, VP9_NMV_UPDATE_PROB);
244
245
246
247
    }
  }
}

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

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
261
262
263
264
265
266
    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
267

Ronald S. Bultje's avatar
Ronald S. Bultje committed
268
269
270
271
    // 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
272

Ronald S. Bultje's avatar
Ronald S. Bultje committed
273
274
275
276
      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
277
    } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
278
279
280
281
282
283
284
285
286
287
288
      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
289
      }
290
    }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
291
  } else {
292
    ref_frame[0] = vp9_get_segdata(xd, segment_id, SEG_LVL_REF_FRAME);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
293
    ref_frame[1] = NONE;
John Koleszar's avatar
John Koleszar committed
294
  }
295
}
John Koleszar's avatar
John Koleszar committed
296

297
298
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
299
}
John Koleszar's avatar
John Koleszar committed
300

Scott LaVarnway's avatar
Scott LaVarnway committed
301
#ifdef VPX_MODE_COUNT
302
unsigned int vp9_mv_cont_count[5][4] = {
John Koleszar's avatar
John Koleszar committed
303
304
305
306
307
  { 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
308
};
Scott LaVarnway's avatar
Scott LaVarnway committed
309
#endif
John Koleszar's avatar
John Koleszar committed
310

311
static void read_switchable_interp_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
312
  int i, j;
313
314
315
316
317
  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))
        fc->switchable_interp_prob[j][i] = vp9_read_prob_diff_update(r,
                                             fc->switchable_interp_prob[j][i]);
318
319
}

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

329
330
331
332
333
334
335
336
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) {
337
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
338

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

344
    read_inter_mode_probs(&cm->fc, r);
345

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

349
    for (i = 0; i < INTRA_INTER_CONTEXTS; i++)
350
      if (vp9_read(r, VP9_MODE_UPDATE_PROB))
Ronald S. Bultje's avatar
Ronald S. Bultje committed
351
352
        cm->fc.intra_inter_prob[i] =
            vp9_read_prob_diff_update(r, cm->fc.intra_inter_prob[i]);
John Koleszar's avatar
John Koleszar committed
353

Ronald S. Bultje's avatar
Ronald S. Bultje committed
354
355
356
357
    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++)
358
          if (vp9_read(r, VP9_MODE_UPDATE_PROB))
Ronald S. Bultje's avatar
Ronald S. Bultje committed
359
360
361
362
363
364
365
366
            cm->fc.comp_inter_prob[i] =
                vp9_read_prob_diff_update(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++) {
367
        if (vp9_read(r, VP9_MODE_UPDATE_PROB))
Ronald S. Bultje's avatar
Ronald S. Bultje committed
368
369
          cm->fc.single_ref_prob[i][0] =
              vp9_read_prob_diff_update(r, cm->fc.single_ref_prob[i][0]);
370
        if (vp9_read(r, VP9_MODE_UPDATE_PROB))
Ronald S. Bultje's avatar
Ronald S. Bultje committed
371
372
373
          cm->fc.single_ref_prob[i][1] =
              vp9_read_prob_diff_update(r, cm->fc.single_ref_prob[i][1]);
      }
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))
Ronald S. Bultje's avatar
Ronald S. Bultje committed
378
379
          cm->fc.comp_ref_prob[i] =
              vp9_read_prob_diff_update(r, cm->fc.comp_ref_prob[i]);
John Koleszar's avatar
John Koleszar committed
380

381
    // VP9_INTRA_MODES
382
383
    for (j = 0; j < BLOCK_SIZE_GROUPS; j++) {
      for (i = 0; i < VP9_INTRA_MODES - 1; ++i) {
384
        if (vp9_read(r, VP9_MODE_UPDATE_PROB)) {
385
386
387
          cm->fc.y_mode_prob[j][i] =
              vp9_read_prob_diff_update(r, cm->fc.y_mode_prob[j][i]);
        }
388
389
390
391
      }
    }
    for (j = 0; j < NUM_PARTITION_CONTEXTS; ++j) {
      for (i = 0; i < PARTITION_TYPES - 1; ++i) {
392
        if (vp9_read(r, VP9_MODE_UPDATE_PROB)) {
393
394
395
          cm->fc.partition_prob[INTER_FRAME][j][i] =
              vp9_read_prob_diff_update(r,
                  cm->fc.partition_prob[INTER_FRAME][j][i]);
396
397
398
        }
      }
    }
399

400
    read_nmvprobs(r, nmvc, xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
401
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
402
}
John Koleszar's avatar
John Koleszar committed
403

404
405
406
// 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
407
static int read_mb_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
408
                              vp9_reader *r) {
409
  VP9_COMMON *const cm = &pbi->common;
410
  MACROBLOCKD *const xd = &pbi->mb;
411
412
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
John Koleszar's avatar
John Koleszar committed
413

414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
  if (!xd->segmentation_enabled)
    return 0;  // Default for disabled segmentation

  if (xd->update_mb_segmentation_map) {
    int segment_id;

    if (cm->temporal_update) {
      // Temporal coding of the segment id for this mb is enabled.
      // Get the context based probability for reading the
      // prediction status flag
      const vp9_prob pred_prob = vp9_get_pred_prob(cm, xd, PRED_SEG_ID);
      const int pred_flag = vp9_read(r, pred_prob);
      vp9_set_pred_flag(xd, PRED_SEG_ID, pred_flag);

      // If the value is flagged as correctly predicted
      // then use the predicted value, otherwise decode it explicitly
430
      segment_id = pred_flag ? vp9_get_pred_mi_segid(cm, mbmi->sb_type,
431
                                                     cm->last_frame_seg_map,
432
                                                     mi_row, mi_col)
Paul Wilkins's avatar
Paul Wilkins committed
433
                             : read_mb_segid(r, xd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
434
    } else {
435
      segment_id = read_mb_segid(r, xd);  // Normal unpredicted coding mode
436
    }
437

438
    set_segment_id(cm, mbmi, mi_row, mi_col, segment_id);  // Side effect
439
    return segment_id;
John Koleszar's avatar
John Koleszar committed
440
  } else {
441
442
    return vp9_get_pred_mi_segid(cm, mbmi->sb_type, cm->last_frame_seg_map,
                                 mi_row, mi_col);
John Koleszar's avatar
John Koleszar committed
443
  }
444
}
445

Dmitry Kovalev's avatar
Dmitry Kovalev committed
446
447
448
449
450
451
452
453
454
455
456

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

457
458
459
460
461
462
463
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};

464
  usehp = usehp && vp9_use_mv_hp(ref);
465
466
467
468
469
470
471
472
473
474
  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_increment_nmv(&diff, ref, counts, usehp);

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

477
static INLINE INTERPOLATIONFILTERTYPE read_switchable_filter_type(
478
    VP9D_COMP *pbi, vp9_reader *r) {
479
480
481
482
483
484
  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];
485
486
487
  return vp9_switchable_interp[index];
}

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
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
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;
}

541
static void read_mb_modes_mv(VP9D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
542
                             int mi_row, int mi_col,
543
                             vp9_reader *r) {
544
  VP9_COMMON *const cm = &pbi->common;
545
  MACROBLOCKD *const xd = &pbi->mb;
546
  nmv_context *const nmvc = &cm->fc.nmvc;
John Koleszar's avatar
John Koleszar committed
547

548
549
  int_mv *const mv0 = &mbmi->mv[0];
  int_mv *const mv1 = &mbmi->mv[1];
550
551
552
  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
553

554
  int mb_to_left_edge, mb_to_right_edge, mb_to_top_edge, mb_to_bottom_edge;
555
  int j, idx, idy;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
556

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

559
560
561
562
  // 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
563
564
565
  // 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
566
567
  set_mi_row_col(cm, xd, mi_row, 1 << mi_height_log2(bsize),
                         mi_col, 1 << mi_width_log2(bsize));
568

569
570
  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
571
572
  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
573
574

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

577
578
  mbmi->mb_skip_coeff = vp9_segfeature_active(xd, mbmi->segment_id,
                                              SEG_LVL_SKIP);
Deb Mukherjee's avatar
Deb Mukherjee committed
579
  if (!mbmi->mb_skip_coeff) {
580
    mbmi->mb_skip_coeff = vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
Deb Mukherjee's avatar
Deb Mukherjee committed
581
582
583
    cm->fc.mbskip_count[vp9_get_pred_context(cm, xd, PRED_MBSKIP)]
                       [mbmi->mb_skip_coeff]++;
  }
John Koleszar's avatar
John Koleszar committed
584

585
586
587
  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);
588

John Koleszar's avatar
John Koleszar committed
589
  // If reference frame is an Inter frame
Ronald S. Bultje's avatar
Ronald S. Bultje committed
590
  if (mbmi->ref_frame[0] != INTRA_FRAME) {
John Koleszar's avatar
John Koleszar committed
591
592
    int_mv nearest, nearby, best_mv;
    int_mv nearest_second, nearby_second, best_mv_second;
593
    vp9_prob *mv_ref_p;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
594
595

    read_ref_frame(pbi, r, mbmi->segment_id, mbmi->ref_frame);
596
597

    {
598
599
600
601
602
#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
603
604
605
      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
606

607
608
      mv_ref_p = cm->fc.inter_mode_probs[
        mbmi->mb_mode_context[mbmi->ref_frame[0]]];
609

610
      // If the segment level skip mode enabled
Paul Wilkins's avatar
Paul Wilkins committed
611
612
      if (vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP)) {
        mbmi->mode = ZEROMV;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
613
614
      } 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
615
616
        vp9_accum_mv_refs(cm, mbmi->mode,
                          mbmi->mb_mode_context[mbmi->ref_frame[0]]);
617
618
      }

Ronald S. Bultje's avatar
Ronald S. Bultje committed
619
      if (bsize < BLOCK_SIZE_SB8X8 || mbmi->mode != ZEROMV) {
620
        vp9_find_best_ref_mvs(xd,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
621
                              mbmi->ref_mvs[mbmi->ref_frame[0]],
622
623
                              &nearest, &nearby);

Ronald S. Bultje's avatar
Ronald S. Bultje committed
624
        best_mv.as_int = mbmi->ref_mvs[mbmi->ref_frame[0]][0].as_int;
625
      }
626

627
628
629
630
631
632
#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
633
    }
John Koleszar's avatar
John Koleszar committed
634

635
636
637
    mbmi->interp_filter = cm->mcomp_filter_type == SWITCHABLE
                              ? read_switchable_filter_type(pbi, r)
                              : cm->mcomp_filter_type;
638

Ronald S. Bultje's avatar
Ronald S. Bultje committed
639
640
641
642
643
644
645
646
647
648
649
650
    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;
651
      }
John Koleszar's avatar
John Koleszar committed
652
    }
653

John Koleszar's avatar
John Koleszar committed
654
    mbmi->uv_mode = DC_PRED;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
655
656
657
658
659
660
661
662
663
    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
664
665
          vp9_accum_mv_refs(cm, blockmode,
                            mbmi->mb_mode_context[mbmi->ref_frame[0]]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
666
          if (blockmode == NEARESTMV || blockmode == NEARMV) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
667
            MV_REFERENCE_FRAME rf2 = mbmi->ref_frame[1];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
668
669
670
671
            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);
672
            }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
673
          }
674

Ronald S. Bultje's avatar
Ronald S. Bultje committed
675
676
677
678
679
          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
680
              if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
681
682
683
684
685
686
687
688
689
                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
690
              if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
691
692
693
694
695
696
697
                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
698
              if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
699
700
701
702
703
704
705
                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
706
              if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
707
708
709
710
711
712
713
                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
714
          }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
715
          mi->bmi[j].as_mv[0].as_int = blockmv.as_int;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
716
          if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
717
718
719
720
721
722
723
            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;
724
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
725
      }
John Koleszar's avatar
John Koleszar committed
726

Ronald S. Bultje's avatar
Ronald S. Bultje committed
727
728
729
730
731
732
733
734
735
736
      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
737
          if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
738
739
740
741
742
743
744
745
746
747
748
749
            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
750
          if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
751
752
753
754
755
756
757
758
            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
759
          if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
760
761
762
763
764
765
            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);
766
          if (mbmi->ref_frame[1] > 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
767
768
769
770
            decode_mv(r, &mv1->as_mv, &best_mv_second.as_mv, nmvc,
                      &cm->fc.NMVcount, xd->allow_high_precision_mv);
          break;
        default:
John Koleszar's avatar
John Koleszar committed
771
#if CONFIG_DEBUG
Ronald S. Bultje's avatar
Ronald S. Bultje committed
772
          assert(0);
John Koleszar's avatar
John Koleszar committed
773
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
774
775
          break;
      }
Scott LaVarnway's avatar
Scott LaVarnway committed
776
    }
John Koleszar's avatar
John Koleszar committed
777
  } else {
778
779
    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
780
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
781
}
John Koleszar's avatar
John Koleszar committed
782

783
void vp9_decode_mode_mvs_init(VP9D_COMP* const pbi, vp9_reader *r) {
784
  VP9_COMMON *cm = &pbi->common;
785
  int k;
786

787
  // TODO(jkoleszar): does this clear more than MBSKIP_CONTEXTS? Maybe remove.
Deb Mukherjee's avatar
Deb Mukherjee committed
788
  // vpx_memset(cm->fc.mbskip_probs, 0, sizeof(cm->fc.mbskip_probs));
789
790
  for (k = 0; k < MBSKIP_CONTEXTS; ++k)
    if (vp9_read(r, VP9_MODE_UPDATE_PROB))
Deb Mukherjee's avatar
Deb Mukherjee committed
791
792
      cm->fc.mbskip_probs[k] =
          vp9_read_prob_diff_update(r, cm->fc.mbskip_probs[k]);
793

794
  mb_mode_mv_init(pbi, r);
795
}
796

797
798
void vp9_decode_mb_mode_mv(VP9D_COMP* const pbi,
                           MACROBLOCKD* const xd,
799
800
                           int mi_row,
                           int mi_col,
801
                           vp9_reader *r) {
802
  VP9_COMMON *const cm = &pbi->common;
803
  MODE_INFO *mi = xd->mode_info_context;
804
  MB_MODE_INFO *const mbmi = &mi->mbmi;
805

806
  if (cm->frame_type == KEY_FRAME || cm->intra_only) {
807
    kfread_modes(pbi, mi, mi_row, mi_col, r);
808
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
809
    read_mb_modes_mv(pbi, mi, &mi->mbmi, mi_row, mi_col, r);
810
  }
811

812
813
814
815
816
  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);
817
818
819
    const int mis = cm->mode_info_stride;
    int x, y;

820
821
    for (y = 0; y < y_mis; y++)
      for (x = !y; x < x_mis; x++)
822
823
        mi[y * mis + x] = *mi;
  }
824
}