vp9_decodemv.c 32.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 "vp9/decoder/vp9_treereader.h"
13
14
#include "vp9/common/vp9_entropymv.h"
#include "vp9/common/vp9_entropymode.h"
15
#include "vp9/common/vp9_reconinter.h"
16
#include "vp9/decoder/vp9_onyxd_int.h"
17
#include "vp9/common/vp9_findnearmv.h"
Ronald S. Bultje's avatar
Ronald S. Bultje committed
18
#include "vp9/common/vp9_common.h"
19
20
21
22
23
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_pred_common.h"
#include "vp9/common/vp9_entropy.h"
#include "vp9/decoder/vp9_decodemv.h"
#include "vp9/common/vp9_mvref_common.h"
John Koleszar's avatar
John Koleszar committed
24
25
26
#if CONFIG_DEBUG
#include <assert.h>
#endif
27

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

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

38
39
static B_PREDICTION_MODE read_bmode(vp9_reader *r, const vp9_prob *p) {
  B_PREDICTION_MODE m = treed_read(r, vp9_bmode_tree, p);
40
41
42
  return m;
}

43
44
static B_PREDICTION_MODE read_kf_bmode(vp9_reader *r, const vp9_prob *p) {
  return (B_PREDICTION_MODE)treed_read(r, vp9_kf_bmode_tree, p);
Scott LaVarnway's avatar
Scott LaVarnway committed
45
46
}

47
48
static MB_PREDICTION_MODE read_ymode(vp9_reader *r, const vp9_prob *p) {
  return (MB_PREDICTION_MODE)treed_read(r, vp9_ymode_tree, p);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
49
}
Scott LaVarnway's avatar
Scott LaVarnway committed
50

51
52
static MB_PREDICTION_MODE read_sb_ymode(vp9_reader *r, const vp9_prob *p) {
  return (MB_PREDICTION_MODE)treed_read(r, vp9_sb_ymode_tree, p);
53
54
}

55
56
static MB_PREDICTION_MODE read_kf_sb_ymode(vp9_reader *r, const vp9_prob *p) {
  return (MB_PREDICTION_MODE)treed_read(r, vp9_uv_mode_tree, p);
Scott LaVarnway's avatar
Scott LaVarnway committed
57
58
}

59
60
static MB_PREDICTION_MODE read_kf_mb_ymode(vp9_reader *r, const vp9_prob *p) {
  return (MB_PREDICTION_MODE)treed_read(r, vp9_kf_ymode_tree, p);
Scott LaVarnway's avatar
Scott LaVarnway committed
61
62
}

63
64
static MB_PREDICTION_MODE read_uv_mode(vp9_reader *r, const vp9_prob *p) {
  return (MB_PREDICTION_MODE)treed_read(r, vp9_uv_mode_tree, p);
Scott LaVarnway's avatar
Scott LaVarnway committed
65
66
}

67
static int read_mb_segid(vp9_reader *r, MACROBLOCKD *xd) {
68
  return treed_read(r, vp9_segment_tree, xd->mb_segment_tree_probs);
Scott LaVarnway's avatar
Scott LaVarnway committed
69
}
70

71
static void set_segment_id(VP9_COMMON *cm, MB_MODE_INFO *mbmi,
72
73
                           int mi_row, int mi_col, int segment_id) {
  const int mi_index = mi_row * cm->mi_cols + mi_col;
74
  const BLOCK_SIZE_TYPE sb_type = mbmi->sb_type;
75
76
77
78
79
80
81
82
83
84
  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;
85
86
87
88
    }
  }
}

89
90
91
92
93
94
95
96
97
98
99
static TX_SIZE select_txfm_size(VP9_COMMON *cm, vp9_reader *r,
                                int allow_16x16, int allow_32x32) {
  TX_SIZE txfm_size = vp9_read(r, cm->prob_tx[0]);  // TX_4X4 or >TX_4X4
  if (txfm_size != TX_4X4 && allow_16x16) {
    txfm_size += vp9_read(r, cm->prob_tx[1]);       // TX_8X8 or >TX_8X8
    if (txfm_size != TX_8X8 && allow_32x32)
      txfm_size += vp9_read(r, cm->prob_tx[2]);     // TX_16X16 or >TX_16X16
  }
  return txfm_size;
}

100

101
static void kfread_modes(VP9D_COMP *pbi, MODE_INFO *m,
102
                         int mi_row, int mi_col,
103
                         vp9_reader *r) {
104
  VP9_COMMON *const cm = &pbi->common;
105
  MACROBLOCKD *const xd = &pbi->mb;
106
107
  m->mbmi.ref_frame = INTRA_FRAME;

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

115
  m->mbmi.mb_skip_coeff = vp9_segfeature_active(xd, m->mbmi.segment_id,
116
117
                                                SEG_LVL_SKIP);
  if (!m->mbmi.mb_skip_coeff)
118
    m->mbmi.mb_skip_coeff = vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
John Koleszar's avatar
John Koleszar committed
119

120
  // luma mode
121
122
123
124
125
126
127
#if CONFIG_AB4X4
  if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8)
    m->mbmi.mode = read_kf_sb_ymode(r,
                     cm->sb_kf_ymode_prob[cm->kf_ymode_probs_index]);
  else
     m->mbmi.mode = I4X4_PRED;
#else
128
  m->mbmi.mode = m->mbmi.sb_type > BLOCK_SIZE_SB8X8 ?
129
130
      read_kf_sb_ymode(r, cm->sb_kf_ymode_prob[cm->kf_ymode_probs_index]):
      read_kf_mb_ymode(r, cm->kf_ymode_prob[cm->kf_ymode_probs_index]);
131
#endif
132

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

135
136
137
#if CONFIG_AB4X4
  if (m->mbmi.sb_type < BLOCK_SIZE_SB8X8) {
#else
138
  if (m->mbmi.mode == I4X4_PRED) {
139
#endif
140
141
142
143
144
145
146
147
148
149
150
151
    int idx, idy;
    int bw = 1 << b_width_log2(m->mbmi.sb_type);
    int bh = 1 << b_height_log2(m->mbmi.sb_type);
    // FIXME(jingning): fix intra4x4 rate-distortion optimization, then
    // use bw and bh as the increment values.
#if !CONFIG_AB4X4 || CONFIG_AB4X4
    bw = 1, bh = 1;
#endif
    for (idy = 0; idy < 2; idy += bh)
      for (idx = 0; idx < 2; idx += bw)
        m->bmi[idy * 2 + idx].as_mode.first =
            read_kf_sb_ymode(r, cm->sb_kf_ymode_prob[cm->kf_ymode_probs_index]);
John Koleszar's avatar
John Koleszar committed
152
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
153

Jingning Han's avatar
Jingning Han committed
154
  m->mbmi.uv_mode = read_uv_mode(r, cm->kf_uv_mode_prob[m->mbmi.mode]);
155

Dmitry Kovalev's avatar
Dmitry Kovalev committed
156
  if (cm->txfm_mode == TX_MODE_SELECT &&
157
158
159
160
161
162
163
      !m->mbmi.mb_skip_coeff &&
#if CONFIG_AB4X4
      m->mbmi.sb_type >= BLOCK_SIZE_SB8X8
#else
      m->mbmi.mode != I4X4_PRED
#endif
      ) {
164
    const int allow_16x16 = m->mbmi.sb_type >= BLOCK_SIZE_MB16X16;
165
166
    const int allow_32x32 = m->mbmi.sb_type >= BLOCK_SIZE_SB32X32;
    m->mbmi.txfm_size = select_txfm_size(cm, r, allow_16x16, allow_32x32);
167
168
  } else if (cm->txfm_mode >= ALLOW_32X32 &&
             m->mbmi.sb_type >= BLOCK_SIZE_SB32X32) {
169
    m->mbmi.txfm_size = TX_32X32;
170
171
172
  } else if (cm->txfm_mode >= ALLOW_16X16 &&
             m->mbmi.sb_type >= BLOCK_SIZE_MB16X16 &&
             m->mbmi.mode <= TM_PRED) {
173
    m->mbmi.txfm_size = TX_16X16;
174
175
176
177
178
179
180
  } else if (cm->txfm_mode >= ALLOW_8X8 &&
#if CONFIG_AB4X4
             m->mbmi.sb_type >= BLOCK_SIZE_SB8X8
#else
             m->mbmi.mode != I4X4_PRED
#endif
             ) {
181
182
183
184
    m->mbmi.txfm_size = TX_8X8;
  } else {
    m->mbmi.txfm_size = TX_4X4;
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
185
}
John Koleszar's avatar
John Koleszar committed
186

187
188
static int read_mv_component(vp9_reader *r,
                             const nmv_component *mvcomp, int usehp) {
189

190
  int mag, d, fr, hp;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
191
192
193
  const int sign = vp9_read(r, mvcomp->sign);
  const int mv_class = treed_read(r, vp9_mv_class_tree, mvcomp->classes);

194
  // Integer part
Dmitry Kovalev's avatar
Dmitry Kovalev committed
195
  if (mv_class == MV_CLASS_0) {
196
    d = treed_read(r, vp9_mv_class0_tree, mvcomp->class0);
197
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
198
    int i;
199
    const int n = mv_class + CLASS0_BITS - 1;  // number of bits
Dmitry Kovalev's avatar
Dmitry Kovalev committed
200

201
    d = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
202
203
    for (i = 0; i < n; ++i)
      d |= vp9_read(r, mvcomp->bits[i]) << i;
204
205
  }

206
207
208
  // Fractional part
  fr = treed_read(r, vp9_mv_fp_tree,
                  mv_class == MV_CLASS_0 ? mvcomp->class0_fp[d] : mvcomp->fp);
209
210


211
212
213
214
  // 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;
215

216
217
218
  // result
  mag = vp9_get_mv_mag(mv_class, (d << 3) | (fr << 1) | hp) + 1;
  return sign ? -mag : mag;
219
220
}

221
static void update_nmv(vp9_reader *r, vp9_prob *const p,
222
                       const vp9_prob upd_p) {
223
  if (vp9_read(r, upd_p)) {
224
#ifdef LOW_PRECISION_MV_UPDATE
225
    *p = (vp9_read_literal(r, 7) << 1) | 1;
226
#else
227
    *p = (vp9_read_literal(r, 8));
228
229
230
231
#endif
  }
}

232
static void read_nmvprobs(vp9_reader *r, nmv_context *mvctx,
233
234
                          int usehp) {
  int i, j, k;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
235

236
#ifdef MV_GROUP_UPDATE
237
  if (!vp9_read_bit(r))
Dmitry Kovalev's avatar
Dmitry Kovalev committed
238
    return;
239
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
240
  for (j = 0; j < MV_JOINTS - 1; ++j)
241
    update_nmv(r, &mvctx->joints[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
242

243
  for (i = 0; i < 2; ++i) {
244
    update_nmv(r, &mvctx->comps[i].sign, VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
245
    for (j = 0; j < MV_CLASSES - 1; ++j)
246
      update_nmv(r, &mvctx->comps[i].classes[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
247
248

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

    for (j = 0; j < MV_OFFSET_BITS; ++j)
252
      update_nmv(r, &mvctx->comps[i].bits[j], VP9_NMV_UPDATE_PROB);
253
254
255
  }

  for (i = 0; i < 2; ++i) {
256
    for (j = 0; j < CLASS0_SIZE; ++j)
257
      for (k = 0; k < 3; ++k)
258
        update_nmv(r, &mvctx->comps[i].class0_fp[j][k], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
259
260

    for (j = 0; j < 3; ++j)
261
      update_nmv(r, &mvctx->comps[i].fp[j], VP9_NMV_UPDATE_PROB);
262
263
264
265
  }

  if (usehp) {
    for (i = 0; i < 2; ++i) {
266
267
      update_nmv(r, &mvctx->comps[i].class0_hp, VP9_NMV_UPDATE_PROB);
      update_nmv(r, &mvctx->comps[i].hp, VP9_NMV_UPDATE_PROB);
268
269
270
271
    }
  }
}

272
// Read the referncence frame
273
static MV_REFERENCE_FRAME read_ref_frame(VP9D_COMP *pbi,
274
                                         vp9_reader *r,
275
                                         int segment_id) {
John Koleszar's avatar
John Koleszar committed
276
  MV_REFERENCE_FRAME ref_frame;
277
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
278
279
  MACROBLOCKD *const xd = &pbi->mb;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
280
  int seg_ref_count = 0;
281
282
283
284
285
286
287
  const int seg_ref_active = vp9_segfeature_active(xd, segment_id,
                                                   SEG_LVL_REF_FRAME);

  const int intra = vp9_check_segref(xd, segment_id, INTRA_FRAME);
  const int last = vp9_check_segref(xd, segment_id, LAST_FRAME);
  const int golden = vp9_check_segref(xd, segment_id, GOLDEN_FRAME);
  const int altref = vp9_check_segref(xd, segment_id, ALTREF_FRAME);
John Koleszar's avatar
John Koleszar committed
288
289
290

  // If segment coding enabled does the segment allow for more than one
  // possible reference frame
291
292
  if (seg_ref_active)
    seg_ref_count = intra + last + golden + altref;
John Koleszar's avatar
John Koleszar committed
293
294
295

  // Segment reference frame features not available or allows for
  // multiple reference frame options
296
  if (!seg_ref_active || seg_ref_count > 1) {
John Koleszar's avatar
John Koleszar committed
297
298
299
300
    // Values used in prediction model coding
    MV_REFERENCE_FRAME pred_ref;

    // Get the context probability the prediction flag
Dmitry Kovalev's avatar
Dmitry Kovalev committed
301
    vp9_prob pred_prob = vp9_get_pred_prob(cm, xd, PRED_REF);
John Koleszar's avatar
John Koleszar committed
302
303

    // Read the prediction status flag
304
    unsigned char prediction_flag = vp9_read(r, pred_prob);
John Koleszar's avatar
John Koleszar committed
305
306

    // Store the prediction flag.
Paul Wilkins's avatar
Paul Wilkins committed
307
    vp9_set_pred_flag(xd, PRED_REF, prediction_flag);
John Koleszar's avatar
John Koleszar committed
308
309

    // Get the predicted reference frame.
Paul Wilkins's avatar
Paul Wilkins committed
310
    pred_ref = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
311
312
313
314

    // If correctly predicted then use the predicted value
    if (prediction_flag) {
      ref_frame = pred_ref;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
315
316
    } else {
      // decode the explicitly coded value
317
      vp9_prob mod_refprobs[PREDICTION_PROBS];
318
319
      vpx_memcpy(mod_refprobs, cm->mod_refprobs[pred_ref],
                 sizeof(mod_refprobs));
John Koleszar's avatar
John Koleszar committed
320
321
322
323

      // If segment coding enabled blank out options that cant occur by
      // setting the branch probability to 0.
      if (seg_ref_active) {
324
325
326
        mod_refprobs[INTRA_FRAME] *= intra;
        mod_refprobs[LAST_FRAME] *= last;
        mod_refprobs[GOLDEN_FRAME] *= golden * altref;
John Koleszar's avatar
John Koleszar committed
327
328
329
330
331
332
333
      }

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

      // Do we need to decode the Intra/Inter branch
      if (mod_refprobs[0])
334
        ref_frame = vp9_read(r, mod_refprobs[0]);
John Koleszar's avatar
John Koleszar committed
335
336
337
338
339
340
      else
        ref_frame++;

      if (ref_frame) {
        // Do we need to decode the Last/Gf_Arf branch
        if (mod_refprobs[1])
341
          ref_frame += vp9_read(r, mod_refprobs[1]);
342
        else
John Koleszar's avatar
John Koleszar committed
343
344
345
346
          ref_frame++;

        if (ref_frame > 1) {
          // Do we need to decode the GF/Arf branch
347
          if (mod_refprobs[2]) {
348
            ref_frame += vp9_read(r, mod_refprobs[2]);
349
          } else {
350
351
352
353
354
355
            if (seg_ref_active)
              ref_frame = pred_ref == GOLDEN_FRAME || !golden ? ALTREF_FRAME
                                                              : GOLDEN_FRAME;
            else
              ref_frame = pred_ref == GOLDEN_FRAME ? ALTREF_FRAME
                                                   : GOLDEN_FRAME;
John Koleszar's avatar
John Koleszar committed
356
          }
357
        }
John Koleszar's avatar
John Koleszar committed
358
      }
359
    }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
360
361
  } else {
    // Segment reference frame features are enabled
John Koleszar's avatar
John Koleszar committed
362
363
364
    // The reference frame for the mb is considered as correclty predicted
    // if it is signaled at the segment level for the purposes of the
    // common prediction model
Paul Wilkins's avatar
Paul Wilkins committed
365
366
    vp9_set_pred_flag(xd, PRED_REF, 1);
    ref_frame = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
367
368
  }

369
  return ref_frame;
370
}
John Koleszar's avatar
John Koleszar committed
371

372
373
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
374
}
John Koleszar's avatar
John Koleszar committed
375

376
377
static MB_PREDICTION_MODE read_mv_ref(vp9_reader *r, const vp9_prob *p) {
  return (MB_PREDICTION_MODE) treed_read(r, vp9_mv_ref_tree, p);
John Koleszar's avatar
John Koleszar committed
378
379
}

380
static B_PREDICTION_MODE read_sub_mv_ref(vp9_reader *r, const vp9_prob *p) {
381
  return (B_PREDICTION_MODE) treed_read(r, vp9_sub_mv_ref_tree, p);
John Koleszar's avatar
John Koleszar committed
382
}
Scott LaVarnway's avatar
Scott LaVarnway committed
383
384

#ifdef VPX_MODE_COUNT
385
unsigned int vp9_mv_cont_count[5][4] = {
John Koleszar's avatar
John Koleszar committed
386
387
388
389
390
  { 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
391
};
Scott LaVarnway's avatar
Scott LaVarnway committed
392
#endif
John Koleszar's avatar
John Koleszar committed
393

394
static void read_switchable_interp_probs(VP9D_COMP* const pbi, vp9_reader *r) {
395
  VP9_COMMON *const cm = &pbi->common;
396
  int i, j;
397
398
399
  for (j = 0; j < VP9_SWITCHABLE_FILTERS + 1; ++j)
    for (i = 0; i < VP9_SWITCHABLE_FILTERS - 1; ++i)
      cm->fc.switchable_interp_prob[j][i] = vp9_read_prob(r);
400
}
John Koleszar's avatar
John Koleszar committed
401

402
403
404
405
406
407
408
409
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) {
410
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
411

412
413
  if (cm->frame_type == KEY_FRAME) {
    if (!cm->kf_ymode_probs_update)
414
      cm->kf_ymode_probs_index = vp9_read_literal(r, 3);
415
  } else {
416
417
    nmv_context *const nmvc = &pbi->common.fc.nmvc;
    MACROBLOCKD *const xd = &pbi->mb;
418
    int i, j;
419

420
    if (cm->mcomp_filter_type == SWITCHABLE)
421
      read_switchable_interp_probs(pbi, r);
422

423
424
425
426
    // Baseline probabilities for decoding reference frame
    cm->prob_intra_coded = vp9_read_prob(r);
    cm->prob_last_coded  = vp9_read_prob(r);
    cm->prob_gf_coded    = vp9_read_prob(r);
John Koleszar's avatar
John Koleszar committed
427
428
429

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

432
433
    cm->comp_pred_mode = read_comp_pred_mode(r);
    if (cm->comp_pred_mode == HYBRID_PREDICTION)
John Koleszar's avatar
John Koleszar committed
434
      for (i = 0; i < COMP_PRED_CONTEXTS; i++)
435
        cm->prob_comppred[i] = vp9_read_prob(r);
John Koleszar's avatar
John Koleszar committed
436

437
438
    // VP9_YMODES
    if (vp9_read_bit(r))
439
      for (i = 0; i < VP9_YMODES - 1; ++i)
440
        cm->fc.ymode_prob[i] = vp9_read_prob(r);
441

442
443
    // VP9_I32X32_MODES
    if (vp9_read_bit(r))
444
      for (i = 0; i < VP9_I32X32_MODES - 1; ++i)
445
        cm->fc.sb_ymode_prob[i] = vp9_read_prob(r);
446

447
448
449
450
451
    for (j = 0; j < NUM_PARTITION_CONTEXTS; ++j)
      if (vp9_read_bit(r))
        for (i = 0; i < PARTITION_TYPES - 1; ++i)
          cm->fc.partition_prob[j][i] = vp9_read_prob(r);

452
    read_nmvprobs(r, nmvc, xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
453
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
454
}
John Koleszar's avatar
John Koleszar committed
455

456
457
458
// 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
459
static int read_mb_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
460
                              vp9_reader *r) {
461
  VP9_COMMON *const cm = &pbi->common;
462
  MACROBLOCKD *const xd = &pbi->mb;
463
464
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
John Koleszar's avatar
John Koleszar committed
465

466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
  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
482
483
      segment_id = pred_flag ? vp9_get_pred_mi_segid(cm, mbmi->sb_type,
                                                     mi_row, mi_col)
Paul Wilkins's avatar
Paul Wilkins committed
484
                             : read_mb_segid(r, xd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
485
    } else {
486
      segment_id = read_mb_segid(r, xd);  // Normal unpredicted coding mode
487
    }
488

489
    set_segment_id(cm, mbmi, mi_row, mi_col, segment_id);  // Side effect
490
    return segment_id;
John Koleszar's avatar
John Koleszar committed
491
  } else {
492
    return vp9_get_pred_mi_segid(cm, mbmi->sb_type, mi_row, mi_col);
John Koleszar's avatar
John Koleszar committed
493
  }
494
}
495

Dmitry Kovalev's avatar
Dmitry Kovalev committed
496
497
498
499
500
501
502
503
504
505
506

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

507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
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};

  usehp = usehp && vp9_use_nmv_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_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
525
526
}

527
static INLINE INTERPOLATIONFILTERTYPE read_switchable_filter_type(
528
529
    VP9D_COMP *pbi, vp9_reader *r) {
  const int index = treed_read(r, vp9_switchable_interp_tree,
530
531
532
533
534
                               vp9_get_pred_probs(&pbi->common, &pbi->mb,
                                                  PRED_SWITCHABLE_INTERP));
  return vp9_switchable_interp[index];
}

535
static void read_mb_modes_mv(VP9D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
536
                             int mi_row, int mi_col,
537
                             vp9_reader *r) {
538
  VP9_COMMON *const cm = &pbi->common;
539
540
  nmv_context *const nmvc = &cm->fc.nmvc;
  const int mis = cm->mode_info_stride;
541
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
542

543
544
  int_mv *const mv0 = &mbmi->mv[0];
  int_mv *const mv1 = &mbmi->mv[1];
545
546
547
  BLOCK_SIZE_TYPE bsize = mi->mbmi.sb_type;
  int bw = 1 << b_width_log2(bsize);
  int bh = 1 << b_height_log2(bsize);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
548

549
550
  const int use_prev_in_find_mv_refs = cm->width == cm->last_width &&
                                       cm->height == cm->last_height &&
551
552
                                       !cm->error_resilient_mode &&
                                       cm->last_show_frame;
John Koleszar's avatar
John Koleszar 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

John Koleszar's avatar
John Koleszar committed
557
558
  mbmi->need_to_clamp_mvs = 0;
  mbmi->need_to_clamp_secondmv = 0;
559
  mbmi->second_ref_frame = NONE;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
560

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

571
572
  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
573
574
  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
575
576

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

579
580
581
  mbmi->mb_skip_coeff = vp9_segfeature_active(xd, mbmi->segment_id,
                                              SEG_LVL_SKIP);
  if (!mbmi->mb_skip_coeff)
582
    mbmi->mb_skip_coeff = vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
John Koleszar's avatar
John Koleszar committed
583
584

  // Read the reference frame
585
  mbmi->ref_frame = read_ref_frame(pbi, r, mbmi->segment_id);
586

John Koleszar's avatar
John Koleszar committed
587
588
589
590
  // If reference frame is an Inter frame
  if (mbmi->ref_frame) {
    int_mv nearest, nearby, best_mv;
    int_mv nearest_second, nearby_second, best_mv_second;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
591
    vp9_prob mv_ref_p[VP9_MVREFS - 1];
John Koleszar's avatar
John Koleszar committed
592

593
594
595
    const MV_REFERENCE_FRAME ref_frame = mbmi->ref_frame;
    struct scale_factors *sf0 = &xd->scale_factor[0];
    *sf0 = cm->active_ref_scale[mbmi->ref_frame - 1];
596
597

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

601
      setup_pre_planes(xd, &cm->yv12_fb[ref_fb_idx], NULL,
602
                       mi_row, mi_col, xd->scale_factor, xd->scale_factor_uv);
603

604
605
606
607
608
#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
Yunqing Wang's avatar
Yunqing Wang committed
609
610
      vp9_find_mv_refs(cm, xd, mi, use_prev_in_find_mv_refs ?
                       xd->prev_mode_info_context : NULL,
Paul Wilkins's avatar
Paul Wilkins committed
611
612
                       ref_frame, mbmi->ref_mvs[ref_frame],
                       cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
613

614
      vp9_mv_ref_probs(cm, mv_ref_p, mbmi->mb_mode_context[ref_frame]);
615

616
      // If the segment level skip mode enabled
Paul Wilkins's avatar
Paul Wilkins committed
617
618
      if (vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP)) {
        mbmi->mode = ZEROMV;
619
      } else {
620
#if CONFIG_AB4X4
621
        if (bsize >= BLOCK_SIZE_SB8X8)
622
623
624
625
          mbmi->mode = read_sb_mv_ref(r, mv_ref_p);
        else
          mbmi->mode = SPLITMV;
#else
626
627
628
        mbmi->mode = bsize > BLOCK_SIZE_SB8X8 ?
                                   read_sb_mv_ref(r, mv_ref_p)
                                 : read_mv_ref(r, mv_ref_p);
629
#endif
630
        vp9_accum_mv_refs(cm, mbmi->mode, mbmi->mb_mode_context[ref_frame]);
631
632
633
634
635
636
637
      }

      if (mbmi->mode != ZEROMV) {
        vp9_find_best_ref_mvs(xd,
                              mbmi->ref_mvs[ref_frame],
                              &nearest, &nearby);

638
        best_mv.as_int = mbmi->ref_mvs[ref_frame][0].as_int;
639
      }
640

641
642
643
644
645
646
#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
647
    }
John Koleszar's avatar
John Koleszar committed
648

649
650
651
    mbmi->interp_filter = cm->mcomp_filter_type == SWITCHABLE
                              ? read_switchable_filter_type(pbi, r)
                              : cm->mcomp_filter_type;
652

John Koleszar's avatar
John Koleszar committed
653
654
    if (cm->comp_pred_mode == COMP_PREDICTION_ONLY ||
        (cm->comp_pred_mode == HYBRID_PREDICTION &&
655
         vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_COMP)))) {
John Koleszar's avatar
John Koleszar committed
656
657
658
659
660
661
662
663
664
665
      /* Since we have 3 reference frames, we can only have 3 unique
       * combinations of combinations of 2 different reference frames
       * (A-G, G-L or A-L). In the bitstream, we use this to simply
       * derive the second reference frame from the first reference
       * frame, by saying it's the next one in the enumerator, and
       * if that's > n_refs, then the second reference frame is the
       * first one in the enumerator. */
      mbmi->second_ref_frame = mbmi->ref_frame + 1;
      if (mbmi->second_ref_frame == 4)
        mbmi->second_ref_frame = 1;
666
      if (mbmi->second_ref_frame > 0) {
667
668
669
670
        const MV_REFERENCE_FRAME second_ref_frame = mbmi->second_ref_frame;
        struct scale_factors *sf1 = &xd->scale_factor[1];
        const int second_ref_fb_idx = cm->active_ref_idx[second_ref_frame - 1];
        *sf1 = cm->active_ref_scale[second_ref_frame - 1];
671

672
        setup_pre_planes(xd, NULL, &cm->yv12_fb[second_ref_fb_idx],
673
                         mi_row, mi_col, xd->scale_factor, xd->scale_factor_uv);
674

675
        vp9_find_mv_refs(cm, xd, mi,
Yunqing Wang's avatar
Yunqing Wang committed
676
677
                         use_prev_in_find_mv_refs ?
                         xd->prev_mode_info_context : NULL,
678
                         second_ref_frame, mbmi->ref_mvs[second_ref_frame],
Paul Wilkins's avatar
Paul Wilkins committed
679
                         cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
680

681
682
        if (mbmi->mode != ZEROMV) {
          vp9_find_best_ref_mvs(xd,
683
                                mbmi->ref_mvs[second_ref_frame],
684
685
                                &nearest_second,
                                &nearby_second);
686
          best_mv_second.as_int = mbmi->ref_mvs[second_ref_frame][0].as_int;
687
        }
688
      }
Yaowu Xu's avatar
Yaowu Xu committed
689

John Koleszar's avatar
John Koleszar committed
690
    }
691

John Koleszar's avatar
John Koleszar committed
692
693
    mbmi->uv_mode = DC_PRED;
    switch (mbmi->mode) {
694
695
696
      case SPLITMV:
#if !CONFIG_AB4X4
        bw = 1, bh = 1;
697
#endif
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
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
        mbmi->need_to_clamp_mvs = 0;
        for (idy = 0; idy < 2; idy += bh) {
          for (idx = 0; idx < 2; idx += bw) {
            int_mv leftmv, abovemv, second_leftmv, second_abovemv;
            int_mv blockmv, secondmv;
            int mv_contz;
            int blockmode;
            int i, k;
            j = idy * 2 + idx;
            k = j;

            leftmv.as_int = left_block_mv(xd, mi, k);
            abovemv.as_int = above_block_mv(mi, k, mis);
            second_leftmv.as_int = 0;
            second_abovemv.as_int = 0;
            if (mbmi->second_ref_frame > 0) {
              second_leftmv.as_int = left_block_second_mv(xd, mi, k);
              second_abovemv.as_int = above_block_second_mv(mi, k, mis);
            }
            mv_contz = vp9_mv_cont(&leftmv, &abovemv);
            blockmode = read_sub_mv_ref(r, cm->fc.sub_mv_ref_prob[mv_contz]);
            cm->fc.sub_mv_ref_counts[mv_contz][blockmode - LEFT4X4]++;

            switch (blockmode) {
              case NEW4X4:
                decode_mv(r, &blockmv.as_mv, &best_mv.as_mv, nmvc,
                           &cm->fc.NMVcount, xd->allow_high_precision_mv);

                if (mbmi->second_ref_frame > 0)
                  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 LEFT4X4:
                blockmv.as_int = leftmv.as_int;
                if (mbmi->second_ref_frame > 0)
                  secondmv.as_int = second_leftmv.as_int;
  #ifdef VPX_MODE_COUNT
                vp9_mv_cont_count[mv_contz][0]++;
  #endif
                break;
              case ABOVE4X4:
                blockmv.as_int = abovemv.as_int;
                if (mbmi->second_ref_frame > 0)
                  secondmv.as_int = second_abovemv.as_int;
  #ifdef VPX_MODE_COUNT
                vp9_mv_cont_count[mv_contz][1]++;
  #endif
                break;
              case ZERO4X4:
                blockmv.as_int = 0;
                if (mbmi->second_ref_frame > 0)
                  secondmv.as_int = 0;
  #ifdef VPX_MODE_COUNT
                vp9_mv_cont_count[mv_contz][2]++;
  #endif
                break;
              default:
                break;
            }
            mi->bmi[j].as_mv[0].as_int = blockmv.as_int;
            if (mbmi->second_ref_frame > 0)
              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]));
John Koleszar's avatar
John Koleszar committed
769
          }
770
        }
John Koleszar's avatar
John Koleszar committed
771

772
773
774
        mv0->as_int = mi->bmi[3].as_mv[0].as_int;
        mv1->as_int = mi->bmi[3].as_mv[1].as_int;
        break;  /* done with SPLITMV */
John Koleszar's avatar
John Koleszar committed
775
776

      case NEARMV:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
777
        // Clip "next_nearest" so that it does not extend to far out of image
778
779
780
781
        assign_and_clamp_mv(mv0, &nearby, mb_to_left_edge,
                                          mb_to_right_edge,
                                          mb_to_top_edge,
                                          mb_to_bottom_edge);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
782
        if (mbmi->second_ref_frame > 0)
783
784
785
786
          assign_and_clamp_mv(mv1, &nearby_second, mb_to_left_edge,
                                                   mb_to_right_edge,
                                                   mb_to_top_edge,
                                                   mb_to_bottom_edge);
John Koleszar's avatar
John Koleszar committed
787
788
789
        break;

      case NEARESTMV:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
790
        // Clip "next_nearest" so that it does not extend to far out of image
791
792
793
794
        assign_and_clamp_mv(mv0, &nearest, mb_to_left_edge,
                                           mb_to_right_edge,
                                           mb_to_top_edge,
                                           mb_to_bottom_edge);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
795
        if (mbmi->second_ref_frame > 0)
796
797
798
799
          assign_and_clamp_mv(mv1, &nearest_second, mb_to_left_edge,
                                                    mb_to_right_edge,
                                                    mb_to_top_edge,
                                                    mb_to_bottom_edge);
John Koleszar's avatar
John Koleszar committed
800
801
802
        break;

      case ZEROMV:
803
        mv0->as_int = 0;
804
        if (mbmi->second_ref_frame > 0)
805
          mv1->as_int = 0;
John Koleszar's avatar
John Koleszar committed
806
        break;
John Koleszar's avatar
John Koleszar committed
807

John Koleszar's avatar
John Koleszar committed
808
      case NEWMV:
809
810
        decode_mv(r, &mv0->as_mv, &best_mv.as_mv, nmvc, &cm->fc.NMVcount,
                  xd->allow_high_precision_mv);
811
        mbmi->need_to_clamp_mvs = check_mv_bounds(mv0,
812
813
814
815
                                                  mb_to_left_edge,
                                                  mb_to_right_edge,
                                                  mb_to_top_edge,
                                                  mb_to_bottom_edge);
816

817
        if (mbmi->second_ref_frame > 0) {
818
819
          decode_mv(r, &mv1->as_mv, &best_mv_second.as_mv, nmvc,
                    &cm->fc.NMVcount, xd->allow_high_precision_mv);
820
          mbmi->need_to_clamp_secondmv = check_mv_bounds(mv1,
821
822
823
824
                                                         mb_to_left_edge,
                                                         mb_to_right_edge,
                                                         mb_to_top_edge,
                                                         mb_to_bottom_edge);
Scott LaVarnway's avatar
Scott LaVarnway committed
825
        }
John Koleszar's avatar
John Koleszar committed
826
827
828
829
830
831
        break;
      default:
;
#if CONFIG_DEBUG
        assert(0);
#endif
Scott LaVarnway's avatar
Scott LaVarnway committed
832
    }
John Koleszar's avatar
John Koleszar committed
833
  } else {
834
835
    // required for left and above block mv
    mv0->as_int = 0;
John Koleszar's avatar
John Koleszar committed
836

837
#if CONFIG_AB4X4
838
    if (bsize >= BLOCK_SIZE_SB8X8) {
839
840
841
842
843
844
      mbmi->mode = read_sb_ymode(r, cm->fc.sb_ymode_prob);
      cm->fc.sb_ymode_counts[mbmi->mode]++;
    } else {
      mbmi->mode = I4X4_PRED;
    }
#else
845
    if (bsize > BLOCK_SIZE_SB8X8) {
846
847
      mbmi->mode = read_sb_ymode(r, cm->fc.sb_ymode_prob);
      cm->fc.sb_ymode_counts[mbmi->mode]++;
848
    } else {
849
850
      mbmi->mode = read_ymode(r, cm->fc.ymode_prob);
      cm->fc.ymode_counts[mbmi->mode]++;
John Koleszar's avatar
John Koleszar committed
851
    }
852
#endif
Paul Wilkins's avatar
Paul Wilkins committed
853

Yaowu Xu's avatar
Yaowu Xu committed
854
    // If MB mode is I4X4_PRED read the block modes
855
#if CONFIG_AB4X4
856
    if (bsize < BLOCK_SIZE_SB8X8) {
857
#else
Yaowu Xu's avatar
Yaowu Xu committed
858
    if (mbmi->mode == I4X4_PRED) {
859
#endif
860
861
862
863
864
865
866
867
868
869
870
871
872
      int idx, idy;
      // FIXME(jingning): fix intra4x4 rate-distortion optimization, then
      // use bw and bh as the increment values.
#if !CONFIG_AB4X4 || CONFIG_AB4X4
      bw = 1, bh = 1;
#endif
      for (idy = 0; idy < 2; idy += bh) {
        for (idx = 0; idx < 2; idx += bw) {
          int m = read_sb_ymode(r, cm->fc.sb_ymode_prob);
          mi->bmi[idy * 2 + idx].as_mode.first = m;
          cm->fc.sb_ymode_counts[m]++;
        }
      }
John Koleszar's avatar
John Koleszar committed
873
    }
John Koleszar's avatar
John Koleszar committed
874

Jingning Han's avatar
Jingning Han committed
875
876
    mbmi->uv_mode = read_uv_mode(r, cm->fc.uv_mode_prob[mbmi->mode]);
    cm->fc.uv_mode_counts[mbmi->mode][mbmi->uv_mode]++;
John Koleszar's avatar
John Koleszar committed
877
  }
John Koleszar's avatar
John Koleszar committed
878

879
#if CONFIG_AB4X4
880
881
  if (cm->txfm_mode == TX_MODE_SELECT && mbmi->mb_skip_coeff == 0 &&
      bsize >= BLOCK_SIZE_SB8X8) {
882
#else
883
  if (cm->txfm_mode == TX_MODE_SELECT && mbmi->mb_skip_coeff == 0 &&
Jingning Han's avatar
Jingning Han committed
884
885
      ((mbmi->ref_frame == INTRA_FRAME && mbmi->mode != I4X4_PRED) ||
       (mbmi->ref_frame != INTRA_FRAME && mbmi->mode != SPLITMV))) {
886
#endif
887
888
    const int allow_16x16 = bsize >= BLOCK_SIZE_MB16X16;
    const int allow_32x32 = bsize >= BLOCK_SIZE_SB32X32;
889
    mbmi->txfm_size = select_txfm_size(cm, r, allow_16x16, allow_32x32);
890
  } else if (bsize >= BLOCK_SIZE_SB32X32 &&
891
             cm->txfm_mode >= ALLOW_32X32) {
892
    mbmi->txfm_size = TX_32X32;
893
  } else if (cm->txfm_mode >= ALLOW_16X16 &&