vp9_decodemv.c 29.3 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 MB_PREDICTION_MODE read_intra_mode(vp9_reader *r, const vp9_prob *p) {
  MB_PREDICTION_MODE m = treed_read(r, vp9_intra_mode_tree, p);
40 41 42
  return m;
}

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

47
static void set_segment_id(VP9_COMMON *cm, MB_MODE_INFO *mbmi,
48 49
                           int mi_row, int mi_col, int segment_id) {
  const int mi_index = mi_row * cm->mi_cols + mi_col;
50
  const BLOCK_SIZE_TYPE sb_type = mbmi->sb_type;
51 52 53 54 55 56 57 58 59 60
  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;
61 62 63 64
    }
  }
}

65 66 67 68 69 70 71 72 73 74 75
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;
}

76

77
static void kfread_modes(VP9D_COMP *pbi, MODE_INFO *m,
78
                         int mi_row, int mi_col,
79
                         vp9_reader *r) {
80
  VP9_COMMON *const cm = &pbi->common;
81
  MACROBLOCKD *const xd = &pbi->mb;
82
  const int mis = cm->mode_info_stride;
83 84
  m->mbmi.ref_frame = INTRA_FRAME;

85
  // Read segmentation map if it is being updated explicitly this frame
John Koleszar's avatar
John Koleszar committed
86
  m->mbmi.segment_id = 0;
87 88
  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
    m->mbmi.segment_id = read_mb_segid(r, xd);
89
    set_segment_id(cm, &m->mbmi, mi_row, mi_col, m->mbmi.segment_id);
John Koleszar's avatar
John Koleszar committed
90 91
  }

92
  m->mbmi.mb_skip_coeff = vp9_segfeature_active(xd, m->mbmi.segment_id,
93 94
                                                SEG_LVL_SKIP);
  if (!m->mbmi.mb_skip_coeff)
95
    m->mbmi.mb_skip_coeff = vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
John Koleszar's avatar
John Koleszar committed
96

97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
  if (cm->txfm_mode == TX_MODE_SELECT &&
      m->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
    const int allow_16x16 = m->mbmi.sb_type >= BLOCK_SIZE_MB16X16;
    const int allow_32x32 = m->mbmi.sb_type >= BLOCK_SIZE_SB32X32;
    m->mbmi.txfm_size = select_txfm_size(cm, r, allow_16x16, allow_32x32);
  } else if (cm->txfm_mode >= ALLOW_32X32 &&
             m->mbmi.sb_type >= BLOCK_SIZE_SB32X32) {
    m->mbmi.txfm_size = TX_32X32;
  } else if (cm->txfm_mode >= ALLOW_16X16 &&
             m->mbmi.sb_type >= BLOCK_SIZE_MB16X16) {
    m->mbmi.txfm_size = TX_16X16;
  } else if (cm->txfm_mode >= ALLOW_8X8 &&
             m->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
    m->mbmi.txfm_size = TX_8X8;
  } else {
    m->mbmi.txfm_size = TX_4X4;
  }

115
  // luma mode
116
  m->mbmi.ref_frame = INTRA_FRAME;
117 118 119 120
  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;
121
    m->mbmi.mode = read_intra_mode(r, cm->kf_y_mode_prob[A][L]);
122
  } else {
123 124 125
    int idx, idy;
    int bw = 1 << b_width_log2(m->mbmi.sb_type);
    int bh = 1 << b_height_log2(m->mbmi.sb_type);
126 127 128 129 130 131 132 133 134

    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 =
135
            read_intra_mode(r, cm->kf_y_mode_prob[A][L]);
136 137 138 139 140 141
        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
142
    m->mbmi.mode = m->bmi[3].as_mode.first;
John Koleszar's avatar
John Koleszar committed
143
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
144

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

148 149
static int read_mv_component(vp9_reader *r,
                             const nmv_component *mvcomp, int usehp) {
150

151
  int mag, d, fr, hp;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
152 153 154
  const int sign = vp9_read(r, mvcomp->sign);
  const int mv_class = treed_read(r, vp9_mv_class_tree, mvcomp->classes);

155
  // Integer part
Dmitry Kovalev's avatar
Dmitry Kovalev committed
156
  if (mv_class == MV_CLASS_0) {
157
    d = treed_read(r, vp9_mv_class0_tree, mvcomp->class0);
158
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
159
    int i;
160
    const int n = mv_class + CLASS0_BITS - 1;  // number of bits
Dmitry Kovalev's avatar
Dmitry Kovalev committed
161

162
    d = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
163 164
    for (i = 0; i < n; ++i)
      d |= vp9_read(r, mvcomp->bits[i]) << i;
165 166
  }

167 168 169
  // Fractional part
  fr = treed_read(r, vp9_mv_fp_tree,
                  mv_class == MV_CLASS_0 ? mvcomp->class0_fp[d] : mvcomp->fp);
170 171


172 173 174 175
  // 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;
176

177 178 179
  // result
  mag = vp9_get_mv_mag(mv_class, (d << 3) | (fr << 1) | hp) + 1;
  return sign ? -mag : mag;
180 181
}

182
static void update_nmv(vp9_reader *r, vp9_prob *const p,
183
                       const vp9_prob upd_p) {
184
  if (vp9_read(r, upd_p)) {
185
#ifdef LOW_PRECISION_MV_UPDATE
186
    *p = (vp9_read_literal(r, 7) << 1) | 1;
187
#else
188
    *p = (vp9_read_literal(r, 8));
189 190 191 192
#endif
  }
}

193
static void read_nmvprobs(vp9_reader *r, nmv_context *mvctx,
194 195
                          int usehp) {
  int i, j, k;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
196

197
#ifdef MV_GROUP_UPDATE
198
  if (!vp9_read_bit(r))
Dmitry Kovalev's avatar
Dmitry Kovalev committed
199
    return;
200
#endif
Dmitry Kovalev's avatar
Dmitry Kovalev committed
201
  for (j = 0; j < MV_JOINTS - 1; ++j)
202
    update_nmv(r, &mvctx->joints[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
203

204
  for (i = 0; i < 2; ++i) {
205
    update_nmv(r, &mvctx->comps[i].sign, VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
206
    for (j = 0; j < MV_CLASSES - 1; ++j)
207
      update_nmv(r, &mvctx->comps[i].classes[j], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
208 209

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

    for (j = 0; j < MV_OFFSET_BITS; ++j)
213
      update_nmv(r, &mvctx->comps[i].bits[j], VP9_NMV_UPDATE_PROB);
214 215 216
  }

  for (i = 0; i < 2; ++i) {
217
    for (j = 0; j < CLASS0_SIZE; ++j)
218
      for (k = 0; k < 3; ++k)
219
        update_nmv(r, &mvctx->comps[i].class0_fp[j][k], VP9_NMV_UPDATE_PROB);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
220 221

    for (j = 0; j < 3; ++j)
222
      update_nmv(r, &mvctx->comps[i].fp[j], VP9_NMV_UPDATE_PROB);
223 224 225 226
  }

  if (usehp) {
    for (i = 0; i < 2; ++i) {
227 228
      update_nmv(r, &mvctx->comps[i].class0_hp, VP9_NMV_UPDATE_PROB);
      update_nmv(r, &mvctx->comps[i].hp, VP9_NMV_UPDATE_PROB);
229 230 231 232
    }
  }
}

233
// Read the referncence frame
234
static MV_REFERENCE_FRAME read_ref_frame(VP9D_COMP *pbi,
235
                                         vp9_reader *r,
236
                                         int segment_id) {
John Koleszar's avatar
John Koleszar committed
237
  MV_REFERENCE_FRAME ref_frame;
238
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
239 240
  MACROBLOCKD *const xd = &pbi->mb;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
241
  int seg_ref_count = 0;
242 243 244 245 246 247 248
  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
249 250 251

  // If segment coding enabled does the segment allow for more than one
  // possible reference frame
252 253
  if (seg_ref_active)
    seg_ref_count = intra + last + golden + altref;
John Koleszar's avatar
John Koleszar committed
254 255 256

  // Segment reference frame features not available or allows for
  // multiple reference frame options
257
  if (!seg_ref_active || seg_ref_count > 1) {
John Koleszar's avatar
John Koleszar committed
258 259 260 261
    // 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
262
    vp9_prob pred_prob = vp9_get_pred_prob(cm, xd, PRED_REF);
John Koleszar's avatar
John Koleszar committed
263 264

    // Read the prediction status flag
265
    unsigned char prediction_flag = vp9_read(r, pred_prob);
John Koleszar's avatar
John Koleszar committed
266 267

    // Store the prediction flag.
Paul Wilkins's avatar
Paul Wilkins committed
268
    vp9_set_pred_flag(xd, PRED_REF, prediction_flag);
John Koleszar's avatar
John Koleszar committed
269 270

    // Get the predicted reference frame.
Paul Wilkins's avatar
Paul Wilkins committed
271
    pred_ref = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
272 273 274 275

    // If correctly predicted then use the predicted value
    if (prediction_flag) {
      ref_frame = pred_ref;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
276 277
    } else {
      // decode the explicitly coded value
278
      vp9_prob mod_refprobs[PREDICTION_PROBS];
279 280
      vpx_memcpy(mod_refprobs, cm->mod_refprobs[pred_ref],
                 sizeof(mod_refprobs));
John Koleszar's avatar
John Koleszar committed
281 282 283 284

      // If segment coding enabled blank out options that cant occur by
      // setting the branch probability to 0.
      if (seg_ref_active) {
285 286 287
        mod_refprobs[INTRA_FRAME] *= intra;
        mod_refprobs[LAST_FRAME] *= last;
        mod_refprobs[GOLDEN_FRAME] *= golden * altref;
John Koleszar's avatar
John Koleszar committed
288 289 290 291 292 293 294
      }

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

      // Do we need to decode the Intra/Inter branch
      if (mod_refprobs[0])
295
        ref_frame = vp9_read(r, mod_refprobs[0]);
John Koleszar's avatar
John Koleszar committed
296 297 298 299 300 301
      else
        ref_frame++;

      if (ref_frame) {
        // Do we need to decode the Last/Gf_Arf branch
        if (mod_refprobs[1])
302
          ref_frame += vp9_read(r, mod_refprobs[1]);
303
        else
John Koleszar's avatar
John Koleszar committed
304 305 306 307
          ref_frame++;

        if (ref_frame > 1) {
          // Do we need to decode the GF/Arf branch
308
          if (mod_refprobs[2]) {
309
            ref_frame += vp9_read(r, mod_refprobs[2]);
310
          } else {
311 312 313 314 315 316
            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
317
          }
318
        }
John Koleszar's avatar
John Koleszar committed
319
      }
320
    }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
321 322
  } else {
    // Segment reference frame features are enabled
John Koleszar's avatar
John Koleszar committed
323 324 325
    // 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
326 327
    vp9_set_pred_flag(xd, PRED_REF, 1);
    ref_frame = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
328 329
  }

330
  return ref_frame;
331
}
John Koleszar's avatar
John Koleszar committed
332

333 334
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
335
}
John Koleszar's avatar
John Koleszar committed
336

Scott LaVarnway's avatar
Scott LaVarnway committed
337
#ifdef VPX_MODE_COUNT
338
unsigned int vp9_mv_cont_count[5][4] = {
John Koleszar's avatar
John Koleszar committed
339 340 341 342 343
  { 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
344
};
Scott LaVarnway's avatar
Scott LaVarnway committed
345
#endif
John Koleszar's avatar
John Koleszar committed
346

347
static void read_switchable_interp_probs(VP9D_COMP* const pbi, vp9_reader *r) {
348
  VP9_COMMON *const cm = &pbi->common;
349
  int i, j;
350 351 352
  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);
353
}
John Koleszar's avatar
John Koleszar committed
354

355 356 357 358 359 360 361 362
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) {
363
  VP9_COMMON *const cm = &pbi->common;
John Koleszar's avatar
John Koleszar committed
364

365
  if (cm->frame_type != KEY_FRAME) {
366 367
    nmv_context *const nmvc = &pbi->common.fc.nmvc;
    MACROBLOCKD *const xd = &pbi->mb;
368
    int i, j;
369

370
    if (cm->mcomp_filter_type == SWITCHABLE)
371
      read_switchable_interp_probs(pbi, r);
372

373 374 375 376
    // 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
377 378 379

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

382 383
    cm->comp_pred_mode = read_comp_pred_mode(r);
    if (cm->comp_pred_mode == HYBRID_PREDICTION)
John Koleszar's avatar
John Koleszar committed
384
      for (i = 0; i < COMP_PRED_CONTEXTS; i++)
385
        cm->prob_comppred[i] = vp9_read_prob(r);
John Koleszar's avatar
John Koleszar committed
386

387 388
    // VP9_YMODES
    if (vp9_read_bit(r))
389
      for (i = 0; i < VP9_YMODES - 1; ++i)
390
        cm->fc.y_mode_prob[i] = vp9_read_prob(r);
391

392 393 394 395 396
    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);

397
    read_nmvprobs(r, nmvc, xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
398
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
399
}
John Koleszar's avatar
John Koleszar committed
400

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

411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426
  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
427 428
      segment_id = pred_flag ? vp9_get_pred_mi_segid(cm, mbmi->sb_type,
                                                     mi_row, mi_col)
Paul Wilkins's avatar
Paul Wilkins committed
429
                             : read_mb_segid(r, xd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
430
    } else {
431
      segment_id = read_mb_segid(r, xd);  // Normal unpredicted coding mode
432
    }
433

434
    set_segment_id(cm, mbmi, mi_row, mi_col, segment_id);  // Side effect
435
    return segment_id;
John Koleszar's avatar
John Koleszar committed
436
  } else {
437
    return vp9_get_pred_mi_segid(cm, mbmi->sb_type, mi_row, mi_col);
John Koleszar's avatar
John Koleszar committed
438
  }
439
}
440

Dmitry Kovalev's avatar
Dmitry Kovalev committed
441 442 443 444 445 446 447 448 449 450 451

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

452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
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
470 471
}

472
static INLINE INTERPOLATIONFILTERTYPE read_switchable_filter_type(
473 474
    VP9D_COMP *pbi, vp9_reader *r) {
  const int index = treed_read(r, vp9_switchable_interp_tree,
475 476 477 478 479
                               vp9_get_pred_probs(&pbi->common, &pbi->mb,
                                                  PRED_SWITCHABLE_INTERP));
  return vp9_switchable_interp[index];
}

480
static void read_mb_modes_mv(VP9D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
481
                             int mi_row, int mi_col,
482
                             vp9_reader *r) {
483
  VP9_COMMON *const cm = &pbi->common;
484
  nmv_context *const nmvc = &cm->fc.nmvc;
485
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
486

487 488
  int_mv *const mv0 = &mbmi->mv[0];
  int_mv *const mv1 = &mbmi->mv[1];
489 490 491
  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
492

493 494
  const int use_prev_in_find_mv_refs = cm->width == cm->last_width &&
                                       cm->height == cm->last_height &&
495 496
                                       !cm->error_resilient_mode &&
                                       cm->last_show_frame;
John Koleszar's avatar
John Koleszar committed
497

498
  int mb_to_left_edge, mb_to_right_edge, mb_to_top_edge, mb_to_bottom_edge;
499
  int j, idx, idy;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
500

John Koleszar's avatar
John Koleszar committed
501 502
  mbmi->need_to_clamp_mvs = 0;
  mbmi->need_to_clamp_secondmv = 0;
503
  mbmi->second_ref_frame = NONE;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
504

505 506 507 508
  // 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
509 510 511
  // 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
512 513
  set_mi_row_col(cm, xd, mi_row, 1 << mi_height_log2(bsize),
                         mi_col, 1 << mi_width_log2(bsize));
514

515 516
  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
517 518
  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
519 520

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

523 524 525
  mbmi->mb_skip_coeff = vp9_segfeature_active(xd, mbmi->segment_id,
                                              SEG_LVL_SKIP);
  if (!mbmi->mb_skip_coeff)
526
    mbmi->mb_skip_coeff = vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_MBSKIP));
John Koleszar's avatar
John Koleszar committed
527 528

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

531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548
  if (cm->txfm_mode == TX_MODE_SELECT &&
      (mbmi->mb_skip_coeff == 0 || mbmi->ref_frame == INTRA_FRAME) &&
      bsize >= BLOCK_SIZE_SB8X8) {
    const int allow_16x16 = bsize >= BLOCK_SIZE_MB16X16;
    const int allow_32x32 = bsize >= BLOCK_SIZE_SB32X32;
    mbmi->txfm_size = select_txfm_size(cm, r, allow_16x16, allow_32x32);
  } else if (bsize >= BLOCK_SIZE_SB32X32 &&
             cm->txfm_mode >= ALLOW_32X32) {
    mbmi->txfm_size = TX_32X32;
  } else if (cm->txfm_mode >= ALLOW_16X16 &&
             bsize >= BLOCK_SIZE_MB16X16) {
    mbmi->txfm_size = TX_16X16;
  } else if (cm->txfm_mode >= ALLOW_8X8 && (bsize >= BLOCK_SIZE_SB8X8)) {
    mbmi->txfm_size = TX_8X8;
  } else {
    mbmi->txfm_size = TX_4X4;
  }

John Koleszar's avatar
John Koleszar committed
549 550 551 552
  // 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
553
    vp9_prob mv_ref_p[VP9_MVREFS - 1];
554
    const MV_REFERENCE_FRAME ref_frame = mbmi->ref_frame;
555 556

    {
557 558 559 560 561
#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
562 563
      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
564 565
                       ref_frame, mbmi->ref_mvs[ref_frame],
                       cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
566

567
      vp9_mv_ref_probs(cm, mv_ref_p, mbmi->mb_mode_context[ref_frame]);
568

569
      // If the segment level skip mode enabled
Paul Wilkins's avatar
Paul Wilkins committed
570 571
      if (vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP)) {
        mbmi->mode = ZEROMV;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
572 573
      } else if (bsize >= BLOCK_SIZE_SB8X8) {
        mbmi->mode = read_sb_mv_ref(r, mv_ref_p);
574
        vp9_accum_mv_refs(cm, mbmi->mode, mbmi->mb_mode_context[ref_frame]);
575 576
      }

Ronald S. Bultje's avatar
Ronald S. Bultje committed
577
      if (bsize < BLOCK_SIZE_SB8X8 || mbmi->mode != ZEROMV) {
578 579 580 581
        vp9_find_best_ref_mvs(xd,
                              mbmi->ref_mvs[ref_frame],
                              &nearest, &nearby);

582
        best_mv.as_int = mbmi->ref_mvs[ref_frame][0].as_int;
583
      }
584

585 586 587 588 589 590
#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
591
    }
John Koleszar's avatar
John Koleszar committed
592

593 594 595
    mbmi->interp_filter = cm->mcomp_filter_type == SWITCHABLE
                              ? read_switchable_filter_type(pbi, r)
                              : cm->mcomp_filter_type;
596

John Koleszar's avatar
John Koleszar committed
597 598
    if (cm->comp_pred_mode == COMP_PREDICTION_ONLY ||
        (cm->comp_pred_mode == HYBRID_PREDICTION &&
599
         vp9_read(r, vp9_get_pred_prob(cm, xd, PRED_COMP)))) {
John Koleszar's avatar
John Koleszar committed
600 601 602 603 604 605 606 607 608 609
      /* 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;
610
      if (mbmi->second_ref_frame > 0) {
611
        const MV_REFERENCE_FRAME second_ref_frame = mbmi->second_ref_frame;
612

613
        vp9_find_mv_refs(cm, xd, mi,
Yunqing Wang's avatar
Yunqing Wang committed
614 615
                         use_prev_in_find_mv_refs ?
                         xd->prev_mode_info_context : NULL,
616
                         second_ref_frame, mbmi->ref_mvs[second_ref_frame],
Paul Wilkins's avatar
Paul Wilkins committed
617
                         cm->ref_frame_sign_bias);
Paul Wilkins's avatar
Paul Wilkins committed
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,
621
                                mbmi->ref_mvs[second_ref_frame],
622 623
                                &nearest_second,
                                &nearby_second);
624
          best_mv_second.as_int = mbmi->ref_mvs[second_ref_frame][0].as_int;
625
        }
626
      }
John Koleszar's avatar
John Koleszar committed
627
    }
628

John Koleszar's avatar
John Koleszar committed
629
    mbmi->uv_mode = DC_PRED;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646
    if (mbmi->sb_type < BLOCK_SIZE_SB8X8) {
      mbmi->need_to_clamp_mvs = 0;
      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);
          vp9_accum_mv_refs(cm, blockmode, mbmi->mb_mode_context[ref_frame]);
          if (blockmode == NEARESTMV || blockmode == NEARMV) {
            MV_REFERENCE_FRAME rf2 = mbmi->second_ref_frame;
            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);
647
            }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
648
          }
649

Ronald S. Bultje's avatar
Ronald S. Bultje committed
650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688
          switch (blockmode) {
            case NEWMV:
              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 NEARESTMV:
              blockmv.as_int = nearest.as_int;
              if (mbmi->second_ref_frame > 0)
                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;
              if (mbmi->second_ref_frame > 0)
                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;
              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;
John Koleszar's avatar
John Koleszar committed
689
          }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
690 691 692 693 694 695 696 697 698
          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]));
          mi->mbmi.mode = blockmode;
699
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
700
      }
John Koleszar's avatar
John Koleszar committed
701

Ronald S. Bultje's avatar
Ronald S. Bultje committed
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
      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);
          if (mbmi->second_ref_frame > 0)
            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);
          if (mbmi->second_ref_frame > 0)
            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;
          if (mbmi->second_ref_frame > 0)
            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);
          mbmi->need_to_clamp_mvs = check_mv_bounds(mv0,
                                                    mb_to_left_edge,
743 744 745
                                                    mb_to_right_edge,
                                                    mb_to_top_edge,
                                                    mb_to_bottom_edge);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
746 747 748 749 750 751 752 753 754 755 756 757

          if (mbmi->second_ref_frame > 0) {
            decode_mv(r, &mv1->as_mv, &best_mv_second.as_mv, nmvc,
                      &cm->fc.NMVcount, xd->allow_high_precision_mv);
            mbmi->need_to_clamp_secondmv = check_mv_bounds(mv1,
                                                             mb_to_left_edge,
                                                             mb_to_right_edge,
                                                             mb_to_top_edge,
                                                             mb_to_bottom_edge);
          }
          break;
        default:
John Koleszar's avatar
John Koleszar committed
758
#if CONFIG_DEBUG
Ronald S. Bultje's avatar
Ronald S. Bultje committed
759
          assert(0);
John Koleszar's avatar
John Koleszar committed
760
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
761 762
          break;
      }
Scott LaVarnway's avatar
Scott LaVarnway committed
763
    }
John Koleszar's avatar
John Koleszar committed
764
  } else {
765 766
    // required for left and above block mv
    mv0->as_int = 0;
John Koleszar's avatar
John Koleszar committed
767

768
    if (bsize >= BLOCK_SIZE_SB8X8) {
769 770
      mbmi->mode = read_intra_mode(r, cm->fc.y_mode_prob);
      cm->fc.y_mode_counts[mbmi->mode]++;
771
    } else {
772 773 774
      int idx, idy;
      for (idy = 0; idy < 2; idy += bh) {
        for (idx = 0; idx < 2; idx += bw) {
775
          int ib = idy * 2 + idx, k;
776
          int m = read_intra_mode(r, cm->fc.y_mode_prob);
777
          mi->bmi[ib].as_mode.first = m;
778
          cm->fc.y_mode_counts[m]++;
779 780 781 782
          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;
783 784
        }
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
785
      mbmi->mode = mi->bmi[3].as_mode.first;
John Koleszar's avatar
John Koleszar committed
786
    }
John Koleszar's avatar
John Koleszar committed
787

788
    mbmi->uv_mode = read_intra_mode(r, cm->fc.uv_mode_prob[mbmi->mode]);
Jingning Han's avatar
Jingning Han committed
789
    cm->fc.uv_mode_counts[mbmi->mode][mbmi->uv_mode]++;
John Koleszar's avatar
John Koleszar committed
790
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
791
}
John Koleszar's avatar
John Koleszar committed
792

793
void vp9_decode_mode_mvs_init(VP9D_COMP* const pbi, vp9_reader *r) {
794
  VP9_COMMON *cm = &pbi->common;
795
  int k;
796

797
  // TODO(jkoleszar): does this clear more than MBSKIP_CONTEXTS? Maybe remove.
798
  vpx_memset(cm->mbskip_pred_probs, 0, sizeof(cm->mbskip_pred_probs));
799 800
  for (k = 0; k < MBSKIP_CONTEXTS; ++k)
    cm->mbskip_pred_probs[k] = vp9_read_prob(r);
801

802
  mb_mode_mv_init(pbi, r);
803
}
804

805 806
void vp9_decode_mb_mode_mv(VP9D_COMP* const pbi,
                           MACROBLOCKD* const xd,
807 808
                           int mi_row,
                           int mi_col,
809
                           vp9_reader *r) {
810
  VP9_COMMON *const cm = &pbi->common;
811
  MODE_INFO *mi = xd->mode_info_context;
812
  MB_MODE_INFO *const mbmi = &mi->mbmi;
813

814
  if (cm->frame_type == KEY_FRAME) {
815
    kfread_modes(pbi, mi, mi_row, mi_col, r);
816
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
817
    read_mb_modes_mv(pbi, mi, &mi->mbmi, mi_row, mi_col, r);
818 819
    set_scale_factors(xd,
                      mi->mbmi.ref_frame - 1, mi->mbmi.second_ref_frame - 1,
820
                      cm->active_ref_scale);
821
  }
822

823 824 825 826 827
  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);
828 829 830
    const int mis = cm->mode_info_stride;
    int x, y;

831 832
    for (y = 0; y < y_mis; y++)
      for (x = !y; x < x_mis; x++)
833 834
        mi[y * mis + x] = *mi;
  }
835
}