vp9_decodemv.c 32.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 "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
106
  MACROBLOCKD *const xd = &pbi->mb;
  const int mis = cm->mode_info_stride;
107
108
  m->mbmi.ref_frame = INTRA_FRAME;

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

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

121
  // luma mode
122
123
124
125
126
127
128
#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
129
  m->mbmi.mode = m->mbmi.sb_type > BLOCK_SIZE_SB8X8 ?
130
131
      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]);
132
#endif
133

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

136
137
138
#if CONFIG_AB4X4
  if (m->mbmi.sb_type < BLOCK_SIZE_SB8X8) {
#else
139
  if (m->mbmi.mode == I4X4_PRED) {
140
#endif
141
    int i;
Jingning Han's avatar
Jingning Han committed
142
    for (i = 0; i < 4; ++i) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
143
      const B_PREDICTION_MODE a = above_block_mode(m, i, mis);
144
      const B_PREDICTION_MODE l = xd->left_available ||
Jingning Han's avatar
Jingning Han committed
145
                                  (i & 1) ?
146
                                  left_block_mode(m, i) : B_DC_PRED;
147
      m->bmi[i].as_mode.first = read_kf_bmode(r, cm->kf_bmode_prob[a][l]);
148
    }
John Koleszar's avatar
John Koleszar committed
149
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
150

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

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

184
185
static int read_mv_component(vp9_reader *r,
                             const nmv_component *mvcomp, int usehp) {
186

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

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

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

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


208
209
210
211
  // 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;
212

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

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

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

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

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

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

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

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

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

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

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
277
  int seg_ref_count = 0;
278
279
280
281
282
283
284
  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
285
286
287

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

  // Segment reference frame features not available or allows for
  // multiple reference frame options
293
  if (!seg_ref_active || seg_ref_count > 1) {
John Koleszar's avatar
John Koleszar committed
294
295
296
297
    // 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
298
    vp9_prob pred_prob = vp9_get_pred_prob(cm, xd, PRED_REF);
John Koleszar's avatar
John Koleszar committed
299
300

    // Read the prediction status flag
301
    unsigned char prediction_flag = vp9_read(r, pred_prob);
John Koleszar's avatar
John Koleszar committed
302
303

    // Store the prediction flag.
Paul Wilkins's avatar
Paul Wilkins committed
304
    vp9_set_pred_flag(xd, PRED_REF, prediction_flag);
John Koleszar's avatar
John Koleszar committed
305
306

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

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

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

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

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

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

        if (ref_frame > 1) {
          // Do we need to decode the GF/Arf branch
344
          if (mod_refprobs[2]) {
345
            ref_frame += vp9_read(r, mod_refprobs[2]);
346
          } else {
347
348
349
350
351
352
            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
353
          }
354
        }
John Koleszar's avatar
John Koleszar committed
355
      }
356
    }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
357
358
  } else {
    // Segment reference frame features are enabled
John Koleszar's avatar
John Koleszar committed
359
360
361
    // 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
362
363
    vp9_set_pred_flag(xd, PRED_REF, 1);
    ref_frame = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
364
365
  }

366
  return ref_frame;
367
}
John Koleszar's avatar
John Koleszar committed
368

369
370
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
371
}
John Koleszar's avatar
John Koleszar committed
372

373
374
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
375
376
}

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

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

391
static void read_switchable_interp_probs(VP9D_COMP* const pbi, vp9_reader *r) {
392
  VP9_COMMON *const cm = &pbi->common;
393
  int i, j;
394
395
396
  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);
397
}
John Koleszar's avatar
John Koleszar committed
398

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

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

417
    if (cm->mcomp_filter_type == SWITCHABLE)
418
      read_switchable_interp_probs(pbi, r);
419

420
421
422
423
    // 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
424
425
426

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

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

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

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

444
445
446
447
448
    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);

449
    read_nmvprobs(r, nmvc, xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
450
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
451
}
John Koleszar's avatar
John Koleszar committed
452

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

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

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
493
494
495
496
497
498
499
500
501
502
503

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

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

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

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

541
542
  int_mv *const mv0 = &mbmi->mv[0];
  int_mv *const mv1 = &mbmi->mv[1];
543
544
545
  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
546

547
548
  const int use_prev_in_find_mv_refs = cm->width == cm->last_width &&
                                       cm->height == cm->last_height &&
549
550
                                       !cm->error_resilient_mode &&
                                       cm->last_show_frame;
John Koleszar's avatar
John Koleszar committed
551

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

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

559
560
561
562
563
  // Make sure the MACROBLOCKD mode info pointer is pointed at the
  // correct entry for the current macroblock.
  xd->mode_info_context = mi;
  xd->prev_mode_info_context = prev_mi;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
564
565
566
  // 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
567
568
  set_mi_row_col(cm, xd, mi_row, 1 << mi_height_log2(bsize),
                         mi_col, 1 << mi_width_log2(bsize));
569

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

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

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

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

John Koleszar's avatar
John Koleszar committed
586
587
588
589
  // 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
590
    vp9_prob mv_ref_p[VP9_MVREFS - 1];
John Koleszar's avatar
John Koleszar committed
591

592
593
594
    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];
595
596

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

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

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

612
      vp9_mv_ref_probs(cm, mv_ref_p, mbmi->mb_mode_context[ref_frame]);
613

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

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

636
        best_mv.as_int = mbmi->ref_mvs[ref_frame][0].as_int;
637
      }
638

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

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

John Koleszar's avatar
John Koleszar committed
651
652
    if (cm->comp_pred_mode == COMP_PREDICTION_ONLY ||
        (cm->comp_pred_mode == HYBRID_PREDICTION &&
653
         vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_COMP)))) {
John Koleszar's avatar
John Koleszar committed
654
655
656
657
658
659
660
661
662
663
      /* 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;
664
      if (mbmi->second_ref_frame > 0) {
665
666
667
668
        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];
669

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

673
674
675
        vp9_find_mv_refs(cm, xd, mi,
                         use_prev_in_find_mv_refs ? prev_mi : NULL,
                         second_ref_frame, mbmi->ref_mvs[second_ref_frame],
Paul Wilkins's avatar
Paul Wilkins committed
676
                         cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
677

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

John Koleszar's avatar
John Koleszar committed
687
    }
688

John Koleszar's avatar
John Koleszar committed
689
690
    mbmi->uv_mode = DC_PRED;
    switch (mbmi->mode) {
691
692
693
      case SPLITMV:
#if !CONFIG_AB4X4
        bw = 1, bh = 1;
694
#endif
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
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
        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
766
          }
767
        }
John Koleszar's avatar
John Koleszar committed
768

769
770
771
        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
772
773

      case NEARMV:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
774
        // Clip "next_nearest" so that it does not extend to far out of image
775
776
777
778
        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
779
        if (mbmi->second_ref_frame > 0)
780
781
782
783
          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
784
785
786
        break;

      case NEARESTMV:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
787
        // Clip "next_nearest" so that it does not extend to far out of image
788
789
790
791
        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
792
        if (mbmi->second_ref_frame > 0)
793
794
795
796
          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
797
798
799
        break;

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

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

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

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

Yaowu Xu's avatar
Yaowu Xu committed
851
    // If MB mode is I4X4_PRED read the block modes
852
#if CONFIG_AB4X4
853
    if (bsize < BLOCK_SIZE_SB8X8) {
854
#else
Yaowu Xu's avatar
Yaowu Xu committed
855
    if (mbmi->mode == I4X4_PRED) {
856
#endif
John Koleszar's avatar
John Koleszar committed
857
858
      int j = 0;
      do {
859
        int m = read_bmode(r, cm->fc.bmode_prob);
860
        mi->bmi[j].as_mode.first = m;
861
        cm->fc.bmode_counts[m]++;
Jingning Han's avatar
Jingning Han committed
862
      } while (++j < 4);
John Koleszar's avatar
John Koleszar committed
863
    }
John Koleszar's avatar
John Koleszar committed
864

Jingning Han's avatar
Jingning Han committed
865
866
    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
867
  }
John Koleszar's avatar
John Koleszar committed
868

869
#if CONFIG_AB4X4
870
871
  if (cm->txfm_mode == TX_MODE_SELECT && mbmi->mb_skip_coeff == 0 &&
      bsize >= BLOCK_SIZE_SB8X8) {
872
#else
873
  if (cm->txfm_mode == TX_MODE_SELECT && mbmi->mb_skip_coeff == 0 &&
Jingning Han's avatar
Jingning Han committed
874
875
      ((mbmi->ref_frame == INTRA_FRAME && mbmi->mode != I4X4_PRED) ||
       (mbmi->ref_frame != INTRA_FRAME && mbmi->mode != SPLITMV))) {
876
#endif