decodeframe.c 145 KB
Newer Older
Jingning Han's avatar
Jingning Han committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include <assert.h>
#include <stdlib.h>  // qsort()

#include "./vp10_rtcd.h"
#include "./vpx_dsp_rtcd.h"
#include "./vpx_scale_rtcd.h"

#include "vpx_dsp/bitreader_buffer.h"
#include "vpx_dsp/bitreader.h"
20
#include "vpx_dsp/vpx_dsp_common.h"
Jingning Han's avatar
Jingning Han committed
21 22 23 24 25 26
#include "vpx_mem/vpx_mem.h"
#include "vpx_ports/mem.h"
#include "vpx_ports/mem_ops.h"
#include "vpx_scale/vpx_scale.h"
#include "vpx_util/vpx_thread.h"

27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
#include "vp10/common/alloccommon.h"
#include "vp10/common/common.h"
#include "vp10/common/entropy.h"
#include "vp10/common/entropymode.h"
#include "vp10/common/idct.h"
#include "vp10/common/thread_common.h"
#include "vp10/common/pred_common.h"
#include "vp10/common/quant_common.h"
#include "vp10/common/reconintra.h"
#include "vp10/common/reconinter.h"
#include "vp10/common/seg_common.h"
#include "vp10/common/tile_common.h"

#include "vp10/decoder/decodeframe.h"
#include "vp10/decoder/detokenize.h"
#include "vp10/decoder/decodemv.h"
#include "vp10/decoder/decoder.h"
#include "vp10/decoder/dsubexp.h"
Jingning Han's avatar
Jingning Han committed
45 46 47

#define MAX_VP9_HEADER_SIZE 80

Yaowu Xu's avatar
Yaowu Xu committed
48
static int is_compound_reference_allowed(const VP10_COMMON *cm) {
Jingning Han's avatar
Jingning Han committed
49
  int i;
50 51
  if (frame_is_intra_only(cm))
    return 0;
Jingning Han's avatar
Jingning Han committed
52 53 54 55 56 57 58
  for (i = 1; i < REFS_PER_FRAME; ++i)
    if (cm->ref_frame_sign_bias[i + 1] != cm->ref_frame_sign_bias[1])
      return 1;

  return 0;
}

Yaowu Xu's avatar
Yaowu Xu committed
59
static void setup_compound_reference_mode(VP10_COMMON *cm) {
Jingning Han's avatar
Jingning Han committed
60 61 62 63
  if (cm->ref_frame_sign_bias[LAST_FRAME] ==
          cm->ref_frame_sign_bias[GOLDEN_FRAME]) {
    cm->comp_fixed_ref = ALTREF_FRAME;
    cm->comp_var_ref[0] = LAST_FRAME;
64 65 66 67 68 69
#if CONFIG_EXT_REFS
    cm->comp_var_ref[1] = LAST2_FRAME;
    cm->comp_var_ref[2] = LAST3_FRAME;
    cm->comp_var_ref[3] = LAST4_FRAME;
    cm->comp_var_ref[4] = GOLDEN_FRAME;
#else
Jingning Han's avatar
Jingning Han committed
70
    cm->comp_var_ref[1] = GOLDEN_FRAME;
71
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
72 73
  } else if (cm->ref_frame_sign_bias[LAST_FRAME] ==
                 cm->ref_frame_sign_bias[ALTREF_FRAME]) {
74 75 76
#if CONFIG_EXT_REFS
    assert(0);
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
77 78 79 80
    cm->comp_fixed_ref = GOLDEN_FRAME;
    cm->comp_var_ref[0] = LAST_FRAME;
    cm->comp_var_ref[1] = ALTREF_FRAME;
  } else {
81 82 83
#if CONFIG_EXT_REFS
    assert(0);
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
    cm->comp_fixed_ref = LAST_FRAME;
    cm->comp_var_ref[0] = GOLDEN_FRAME;
    cm->comp_var_ref[1] = ALTREF_FRAME;
  }
}

static int read_is_valid(const uint8_t *start, size_t len, const uint8_t *end) {
  return len != 0 && len <= (size_t)(end - start);
}

static int decode_unsigned_max(struct vpx_read_bit_buffer *rb, int max) {
  const int data = vpx_rb_read_literal(rb, get_unsigned_bits(max));
  return data > max ? max : data;
}

99 100 101
static TX_MODE read_tx_mode(struct vpx_read_bit_buffer *rb) {
  return vpx_rb_read_bit(rb) ? TX_MODE_SELECT : vpx_rb_read_literal(rb, 2);
}
Jingning Han's avatar
Jingning Han committed
102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126

static void read_tx_mode_probs(struct tx_probs *tx_probs, vpx_reader *r) {
  int i, j;

  for (i = 0; i < TX_SIZE_CONTEXTS; ++i)
    for (j = 0; j < TX_SIZES - 3; ++j)
      vp10_diff_update_prob(r, &tx_probs->p8x8[i][j]);

  for (i = 0; i < TX_SIZE_CONTEXTS; ++i)
    for (j = 0; j < TX_SIZES - 2; ++j)
      vp10_diff_update_prob(r, &tx_probs->p16x16[i][j]);

  for (i = 0; i < TX_SIZE_CONTEXTS; ++i)
    for (j = 0; j < TX_SIZES - 1; ++j)
      vp10_diff_update_prob(r, &tx_probs->p32x32[i][j]);
}

static void read_switchable_interp_probs(FRAME_CONTEXT *fc, vpx_reader *r) {
  int i, j;
  for (j = 0; j < SWITCHABLE_FILTER_CONTEXTS; ++j)
    for (i = 0; i < SWITCHABLE_FILTERS - 1; ++i)
      vp10_diff_update_prob(r, &fc->switchable_interp_prob[j][i]);
}

static void read_inter_mode_probs(FRAME_CONTEXT *fc, vpx_reader *r) {
127 128 129 130 131 132 133 134
  int i;
#if CONFIG_REF_MV
  for (i = 0; i < NEWMV_MODE_CONTEXTS; ++i)
    vp10_diff_update_prob(r, &fc->newmv_prob[i]);
  for (i = 0; i < ZEROMV_MODE_CONTEXTS; ++i)
    vp10_diff_update_prob(r, &fc->zeromv_prob[i]);
  for (i = 0; i < REFMV_MODE_CONTEXTS; ++i)
    vp10_diff_update_prob(r, &fc->refmv_prob[i]);
135 136 137 138
  for (i = 0; i < DRL_MODE_CONTEXTS; ++i)
    vp10_diff_update_prob(r, &fc->drl_prob0[i]);
  for (i = 0; i < DRL_MODE_CONTEXTS; ++i)
    vp10_diff_update_prob(r, &fc->drl_prob1[i]);
Yue Chen's avatar
Yue Chen committed
139 140 141
#if CONFIG_EXT_INTER
  vp10_diff_update_prob(r, &fc->new2mv_prob);
#endif  // CONFIG_EXT_INTER
142 143
#else
  int j;
Jingning Han's avatar
Jingning Han committed
144 145 146
  for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
    for (j = 0; j < INTER_MODES - 1; ++j)
      vp10_diff_update_prob(r, &fc->inter_mode_probs[i][j]);
147
#endif
Jingning Han's avatar
Jingning Han committed
148 149
}

150 151 152 153 154 155 156 157 158 159 160 161 162
#if CONFIG_EXT_INTER
static void read_inter_compound_mode_probs(FRAME_CONTEXT *fc, vpx_reader *r) {
  int i, j;
  if (vpx_read(r, GROUP_DIFF_UPDATE_PROB)) {
    for (j = 0; j < INTER_MODE_CONTEXTS; ++j) {
      for (i = 0; i < INTER_COMPOUND_MODES - 1; ++i) {
        vp10_diff_update_prob(r, &fc->inter_compound_mode_probs[j][i]);
      }
    }
  }
}
#endif  // CONFIG_EXT_INTER

163 164 165 166 167 168 169 170 171 172
static REFERENCE_MODE read_frame_reference_mode(const VP10_COMMON *cm,
    struct vpx_read_bit_buffer *rb) {
  if (is_compound_reference_allowed(cm)) {
    return vpx_rb_read_bit(rb) ? REFERENCE_MODE_SELECT
                               : (vpx_rb_read_bit(rb) ? COMPOUND_REFERENCE
                                                      : SINGLE_REFERENCE);
  } else {
    return SINGLE_REFERENCE;
  }
}
Jingning Han's avatar
Jingning Han committed
173

Yaowu Xu's avatar
Yaowu Xu committed
174
static void read_frame_reference_mode_probs(VP10_COMMON *cm, vpx_reader *r) {
Jingning Han's avatar
Jingning Han committed
175
  FRAME_CONTEXT *const fc = cm->fc;
176
  int i, j;
Jingning Han's avatar
Jingning Han committed
177 178 179 180 181

  if (cm->reference_mode == REFERENCE_MODE_SELECT)
    for (i = 0; i < COMP_INTER_CONTEXTS; ++i)
      vp10_diff_update_prob(r, &fc->comp_inter_prob[i]);

182
  if (cm->reference_mode != COMPOUND_REFERENCE) {
Jingning Han's avatar
Jingning Han committed
183
    for (i = 0; i < REF_CONTEXTS; ++i) {
184 185 186
      for (j = 0; j < (SINGLE_REFS - 1); ++j) {
        vp10_diff_update_prob(r, &fc->single_ref_prob[i][j]);
      }
Jingning Han's avatar
Jingning Han committed
187
    }
188
  }
Jingning Han's avatar
Jingning Han committed
189

190 191 192 193 194 195 196
  if (cm->reference_mode != SINGLE_REFERENCE) {
    for (i = 0; i < REF_CONTEXTS; ++i) {
      for (j = 0; j < (COMP_REFS - 1); ++j) {
        vp10_diff_update_prob(r, &fc->comp_ref_prob[i][j]);
      }
    }
  }
Jingning Han's avatar
Jingning Han committed
197 198 199 200 201
}

static void update_mv_probs(vpx_prob *p, int n, vpx_reader *r) {
  int i;
  for (i = 0; i < n; ++i)
202
    vp10_diff_update_prob(r, &p[i]);
Jingning Han's avatar
Jingning Han committed
203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
}

static void read_mv_probs(nmv_context *ctx, int allow_hp, vpx_reader *r) {
  int i, j;

  update_mv_probs(ctx->joints, MV_JOINTS - 1, r);

  for (i = 0; i < 2; ++i) {
    nmv_component *const comp_ctx = &ctx->comps[i];
    update_mv_probs(&comp_ctx->sign, 1, r);
    update_mv_probs(comp_ctx->classes, MV_CLASSES - 1, r);
    update_mv_probs(comp_ctx->class0, CLASS0_SIZE - 1, r);
    update_mv_probs(comp_ctx->bits, MV_OFFSET_BITS, r);
  }

  for (i = 0; i < 2; ++i) {
    nmv_component *const comp_ctx = &ctx->comps[i];
    for (j = 0; j < CLASS0_SIZE; ++j)
      update_mv_probs(comp_ctx->class0_fp[j], MV_FP_SIZE - 1, r);
    update_mv_probs(comp_ctx->fp, 3, r);
  }

  if (allow_hp) {
    for (i = 0; i < 2; ++i) {
      nmv_component *const comp_ctx = &ctx->comps[i];
      update_mv_probs(&comp_ctx->class0_hp, 1, r);
      update_mv_probs(&comp_ctx->hp, 1, r);
    }
  }
}

static void inverse_transform_block_inter(MACROBLOCKD* xd, int plane,
                                          const TX_SIZE tx_size,
                                          uint8_t *dst, int stride,
hui su's avatar
hui su committed
237
                                          int eob, int block) {
Jingning Han's avatar
Jingning Han committed
238
  struct macroblockd_plane *const pd = &xd->plane[plane];
hui su's avatar
hui su committed
239
  TX_TYPE tx_type = get_tx_type(pd->plane_type, xd, block, tx_size);
240
  const int seg_id = xd->mi[0]->mbmi.segment_id;
Jingning Han's avatar
Jingning Han committed
241 242 243 244
  if (eob > 0) {
    tran_low_t *const dqcoeff = pd->dqcoeff;
#if CONFIG_VP9_HIGHBITDEPTH
    if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
hui su's avatar
hui su committed
245 246 247
      switch (tx_size) {
        case TX_4X4:
          vp10_highbd_inv_txfm_add_4x4(dqcoeff, dst, stride, eob, xd->bd,
248
                                       tx_type, xd->lossless[seg_id]);
hui su's avatar
hui su committed
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
          break;
        case TX_8X8:
          vp10_highbd_inv_txfm_add_8x8(dqcoeff, dst, stride, eob, xd->bd,
                                       tx_type);
          break;
        case TX_16X16:
          vp10_highbd_inv_txfm_add_16x16(dqcoeff, dst, stride, eob, xd->bd,
                                         tx_type);
          break;
        case TX_32X32:
          vp10_highbd_inv_txfm_add_32x32(dqcoeff, dst, stride, eob, xd->bd,
                                         tx_type);
          break;
        default:
          assert(0 && "Invalid transform size");
          return;
Jingning Han's avatar
Jingning Han committed
265 266
      }
    } else {
267
#endif  // CONFIG_VP9_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
268 269
      switch (tx_size) {
        case TX_4X4:
hui su's avatar
hui su committed
270
          vp10_inv_txfm_add_4x4(dqcoeff, dst, stride, eob, tx_type,
271
                                xd->lossless[seg_id]);
Jingning Han's avatar
Jingning Han committed
272 273
          break;
        case TX_8X8:
hui su's avatar
hui su committed
274
          vp10_inv_txfm_add_8x8(dqcoeff, dst, stride, eob, tx_type);
Jingning Han's avatar
Jingning Han committed
275 276
          break;
        case TX_16X16:
hui su's avatar
hui su committed
277
          vp10_inv_txfm_add_16x16(dqcoeff, dst, stride, eob, tx_type);
Jingning Han's avatar
Jingning Han committed
278 279
          break;
        case TX_32X32:
hui su's avatar
hui su committed
280
          vp10_inv_txfm_add_32x32(dqcoeff, dst, stride, eob, tx_type);
Jingning Han's avatar
Jingning Han committed
281 282 283 284 285
          break;
        default:
          assert(0 && "Invalid transform size");
          return;
      }
hui su's avatar
hui su committed
286
#if CONFIG_VP9_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
287 288 289 290 291 292
    }
#endif  // CONFIG_VP9_HIGHBITDEPTH

    if (eob == 1) {
      dqcoeff[0] = 0;
    } else {
293
      if (tx_type == DCT_DCT && tx_size <= TX_16X16 && eob <= 10)
Jingning Han's avatar
Jingning Han committed
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308
        memset(dqcoeff, 0, 4 * (4 << tx_size) * sizeof(dqcoeff[0]));
      else if (tx_size == TX_32X32 && eob <= 34)
        memset(dqcoeff, 0, 256 * sizeof(dqcoeff[0]));
      else
        memset(dqcoeff, 0, (16 << (tx_size << 1)) * sizeof(dqcoeff[0]));
    }
  }
}

static void inverse_transform_block_intra(MACROBLOCKD* xd, int plane,
                                          const TX_TYPE tx_type,
                                          const TX_SIZE tx_size,
                                          uint8_t *dst, int stride,
                                          int eob) {
  struct macroblockd_plane *const pd = &xd->plane[plane];
309
  const int seg_id = xd->mi[0]->mbmi.segment_id;
Jingning Han's avatar
Jingning Han committed
310 311 312 313
  if (eob > 0) {
    tran_low_t *const dqcoeff = pd->dqcoeff;
#if CONFIG_VP9_HIGHBITDEPTH
    if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
hui su's avatar
hui su committed
314 315 316
      switch (tx_size) {
        case TX_4X4:
          vp10_highbd_inv_txfm_add_4x4(dqcoeff, dst, stride, eob, xd->bd,
317
                                       tx_type, xd->lossless[seg_id]);
hui su's avatar
hui su committed
318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
          break;
        case TX_8X8:
          vp10_highbd_inv_txfm_add_8x8(dqcoeff, dst, stride, eob, xd->bd,
                                       tx_type);
          break;
        case TX_16X16:
          vp10_highbd_inv_txfm_add_16x16(dqcoeff, dst, stride, eob, xd->bd,
                                         tx_type);
          break;
        case TX_32X32:
          vp10_highbd_inv_txfm_add_32x32(dqcoeff, dst, stride, eob, xd->bd,
                                         tx_type);
          break;
        default:
          assert(0 && "Invalid transform size");
          return;
Jingning Han's avatar
Jingning Han committed
334 335
      }
    } else {
336
#endif  // CONFIG_VP9_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
337 338
      switch (tx_size) {
        case TX_4X4:
hui su's avatar
hui su committed
339
          vp10_inv_txfm_add_4x4(dqcoeff, dst, stride, eob, tx_type,
340
                                xd->lossless[seg_id]);
Jingning Han's avatar
Jingning Han committed
341 342
          break;
        case TX_8X8:
hui su's avatar
hui su committed
343
          vp10_inv_txfm_add_8x8(dqcoeff, dst, stride, eob, tx_type);
Jingning Han's avatar
Jingning Han committed
344 345
          break;
        case TX_16X16:
hui su's avatar
hui su committed
346
          vp10_inv_txfm_add_16x16(dqcoeff, dst, stride, eob, tx_type);
Jingning Han's avatar
Jingning Han committed
347 348
          break;
        case TX_32X32:
hui su's avatar
hui su committed
349
          vp10_inv_txfm_add_32x32(dqcoeff, dst, stride, eob, tx_type);
Jingning Han's avatar
Jingning Han committed
350 351 352 353 354
          break;
        default:
          assert(0 && "Invalid transform size");
          return;
      }
hui su's avatar
hui su committed
355
#if CONFIG_VP9_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372
    }
#endif  // CONFIG_VP9_HIGHBITDEPTH

    if (eob == 1) {
      dqcoeff[0] = 0;
    } else {
      if (tx_type == DCT_DCT && tx_size <= TX_16X16 && eob <= 10)
        memset(dqcoeff, 0, 4 * (4 << tx_size) * sizeof(dqcoeff[0]));
      else if (tx_size == TX_32X32 && eob <= 34)
        memset(dqcoeff, 0, 256 * sizeof(dqcoeff[0]));
      else
        memset(dqcoeff, 0, (16 << (tx_size << 1)) * sizeof(dqcoeff[0]));
    }
  }
}

static void predict_and_reconstruct_intra_block(MACROBLOCKD *const xd,
Alex Converse's avatar
Alex Converse committed
373 374 375 376
#if CONFIG_ANS
                                         const rans_dec_lut *const token_tab,
                                                struct AnsDecoder *const r,
#else
Jingning Han's avatar
Jingning Han committed
377
                                                vpx_reader *r,
Alex Converse's avatar
Alex Converse committed
378
#endif  // CONFIG_ANS
Jingning Han's avatar
Jingning Han committed
379 380 381 382 383 384
                                                MB_MODE_INFO *const mbmi,
                                                int plane,
                                                int row, int col,
                                                TX_SIZE tx_size) {
  struct macroblockd_plane *const pd = &xd->plane[plane];
  PREDICTION_MODE mode = (plane == 0) ? mbmi->mode : mbmi->uv_mode;
hui su's avatar
hui su committed
385
  PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
Jingning Han's avatar
Jingning Han committed
386
  uint8_t *dst;
hui su's avatar
hui su committed
387
  int block_idx = (row << 1) + col;
Jingning Han's avatar
Jingning Han committed
388 389 390 391 392 393
  dst = &pd->dst.buf[4 * row * pd->dst.stride + 4 * col];

  if (mbmi->sb_type < BLOCK_8X8)
    if (plane == 0)
      mode = xd->mi[0]->bmi[(row << 1) + col].as_mode;

394
  vp10_predict_intra_block(xd, pd->n4_wl, pd->n4_hl, tx_size, mode,
Jingning Han's avatar
Jingning Han committed
395 396 397 398
                          dst, pd->dst.stride, dst, pd->dst.stride,
                          col, row, plane);

  if (!mbmi->skip) {
hui su's avatar
hui su committed
399
    TX_TYPE tx_type = get_tx_type(plane_type, xd, block_idx, tx_size);
400
    const scan_order *sc = get_scan(tx_size, tx_type, 0);
Alex Converse's avatar
Alex Converse committed
401 402 403 404 405
    const int eob = vp10_decode_block_tokens(xd,
#if CONFIG_ANS
                                             token_tab,
#endif  // CONFIG_ANS
                                             plane, sc, col, row, tx_size,
hui su's avatar
hui su committed
406
                                             r, mbmi->segment_id);
Jingning Han's avatar
Jingning Han committed
407 408 409 410 411
    inverse_transform_block_intra(xd, plane, tx_type, tx_size,
                                  dst, pd->dst.stride, eob);
  }
}

412 413 414 415 416 417 418
#if CONFIG_VAR_TX
static void decode_reconstruct_tx(MACROBLOCKD *const xd, vpx_reader *r,
                                  MB_MODE_INFO *const mbmi,
                                  int plane, BLOCK_SIZE plane_bsize,
                                  int block, int blk_row, int blk_col,
                                  TX_SIZE tx_size, int *eob_total) {
  const struct macroblockd_plane *const pd = &xd->plane[plane];
419
  const BLOCK_SIZE bsize = txsize_to_bsize[tx_size];
420 421
  int tx_idx = (blk_row >> (1 - pd->subsampling_y)) * 8 +
               (blk_col >> (1 - pd->subsampling_x));
422
  TX_SIZE plane_tx_size = plane ?
423
      get_uv_tx_size_impl(mbmi->inter_tx_size[tx_idx], bsize, 0, 0) :
424
      mbmi->inter_tx_size[tx_idx];
425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
  int max_blocks_high = num_4x4_blocks_high_lookup[plane_bsize];
  int max_blocks_wide = num_4x4_blocks_wide_lookup[plane_bsize];

  if (xd->mb_to_bottom_edge < 0)
    max_blocks_high += xd->mb_to_bottom_edge >> (5 + pd->subsampling_y);
  if (xd->mb_to_right_edge < 0)
    max_blocks_wide += xd->mb_to_right_edge >> (5 + pd->subsampling_x);

  if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide)
    return;

  if (tx_size == plane_tx_size) {
    PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
    TX_TYPE tx_type = get_tx_type(plane_type, xd, block, tx_size);
    const scan_order *sc = get_scan(tx_size, tx_type, 1);
    const int eob = vp10_decode_block_tokens(xd, plane, sc,
                                             blk_col, blk_row, tx_size,
                                             r, mbmi->segment_id);
    inverse_transform_block_inter(xd, plane, tx_size,
        &pd->dst.buf[4 * blk_row * pd->dst.stride + 4 * blk_col],
        pd->dst.stride, eob, block);
    *eob_total += eob;
  } else {
    int bsl = b_width_log2_lookup[bsize];
    int i;

    assert(bsl > 0);
    --bsl;

    for (i = 0; i < 4; ++i) {
      const int offsetr = blk_row + ((i >> 1) << bsl);
      const int offsetc = blk_col + ((i & 0x01) << bsl);
      int step = 1 << (2 * (tx_size - 1));

      if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide)
        continue;

      decode_reconstruct_tx(xd, r, mbmi, plane, plane_bsize, block + i * step,
                            offsetr, offsetc, tx_size - 1, eob_total);
    }
  }
}
467
#endif  // CONFIG_VAR_TX
468

469
#if !CONFIG_VAR_TX || CONFIG_SUPERTX
Alex Converse's avatar
Alex Converse committed
470 471 472 473 474 475 476
static int reconstruct_inter_block(MACROBLOCKD *const xd,
#if CONFIG_ANS
                                   const rans_dec_lut *const token_tab,
                                   struct AnsDecoder *const r,
#else
                                   vpx_reader *r,
#endif
Jingning Han's avatar
Jingning Han committed
477 478 479
                                   MB_MODE_INFO *const mbmi, int plane,
                                   int row, int col, TX_SIZE tx_size) {
  struct macroblockd_plane *const pd = &xd->plane[plane];
hui su's avatar
hui su committed
480 481
  PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
  int block_idx = (row << 1) + col;
hui su's avatar
hui su committed
482
  TX_TYPE tx_type = get_tx_type(plane_type, xd, block_idx, tx_size);
483
  const scan_order *sc = get_scan(tx_size, tx_type, 1);
Alex Converse's avatar
Alex Converse committed
484 485 486 487 488 489
  const int eob = vp10_decode_block_tokens(xd,
#if CONFIG_ANS
                                           token_tab,
#endif
                                           plane, sc, col, row, tx_size, r,
                                           mbmi->segment_id);
Jingning Han's avatar
Jingning Han committed
490 491 492

  inverse_transform_block_inter(xd, plane, tx_size,
                            &pd->dst.buf[4 * row * pd->dst.stride + 4 * col],
hui su's avatar
hui su committed
493
                            pd->dst.stride, eob, block_idx);
Jingning Han's avatar
Jingning Han committed
494 495
  return eob;
}
496
#endif  // !CONFIG_VAR_TX || CONFIG_SUPER_TX
Jingning Han's avatar
Jingning Han committed
497

498
#if (CONFIG_SUPERTX || CONFIG_OBMC)
Jingning Han's avatar
Jingning Han committed
499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
static void build_mc_border(const uint8_t *src, int src_stride,
                            uint8_t *dst, int dst_stride,
                            int x, int y, int b_w, int b_h, int w, int h) {
  // Get a pointer to the start of the real data for this row.
  const uint8_t *ref_row = src - x - y * src_stride;

  if (y >= h)
    ref_row += (h - 1) * src_stride;
  else if (y > 0)
    ref_row += y * src_stride;

  do {
    int right = 0, copy;
    int left = x < 0 ? -x : 0;

    if (left > b_w)
      left = b_w;

    if (x + b_w > w)
      right = x + b_w - w;

    if (right > b_w)
      right = b_w;

    copy = b_w - left - right;

    if (left)
      memset(dst, ref_row[0], left);

    if (copy)
      memcpy(dst + left, ref_row + x + left, copy);

    if (right)
      memset(dst + left + copy, ref_row[w - 1], right);

    dst += dst_stride;
    ++y;

    if (y > 0 && y < h)
      ref_row += src_stride;
  } while (--b_h);
}

#if CONFIG_VP9_HIGHBITDEPTH
static void high_build_mc_border(const uint8_t *src8, int src_stride,
                                 uint16_t *dst, int dst_stride,
                                 int x, int y, int b_w, int b_h,
                                 int w, int h) {
  // Get a pointer to the start of the real data for this row.
  const uint16_t *src = CONVERT_TO_SHORTPTR(src8);
  const uint16_t *ref_row = src - x - y * src_stride;

  if (y >= h)
    ref_row += (h - 1) * src_stride;
  else if (y > 0)
    ref_row += y * src_stride;

  do {
    int right = 0, copy;
    int left = x < 0 ? -x : 0;

    if (left > b_w)
      left = b_w;

    if (x + b_w > w)
      right = x + b_w - w;

    if (right > b_w)
      right = b_w;

    copy = b_w - left - right;

    if (left)
      vpx_memset16(dst, ref_row[0], left);

    if (copy)
      memcpy(dst + left, ref_row + x + left, copy * sizeof(uint16_t));

    if (right)
      vpx_memset16(dst + left + copy, ref_row[w - 1], right);

    dst += dst_stride;
    ++y;

    if (y > 0 && y < h)
      ref_row += src_stride;
  } while (--b_h);
}

static void extend_and_predict(const uint8_t *buf_ptr1, int pre_buf_stride,
                               int x0, int y0, int b_w, int b_h,
                               int frame_width, int frame_height,
                               int border_offset,
                               uint8_t *const dst, int dst_buf_stride,
                               int subpel_x, int subpel_y,
594
                               const INTERP_FILTER interp_filter,
Jingning Han's avatar
Jingning Han committed
595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612
                               const struct scale_factors *sf,
                               MACROBLOCKD *xd,
                               int w, int h, int ref, int xs, int ys) {
  DECLARE_ALIGNED(16, uint16_t, mc_buf_high[80 * 2 * 80 * 2]);
  const uint8_t *buf_ptr;

  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
    high_build_mc_border(buf_ptr1, pre_buf_stride, mc_buf_high, b_w,
                         x0, y0, b_w, b_h, frame_width, frame_height);
    buf_ptr = CONVERT_TO_BYTEPTR(mc_buf_high) + border_offset;
  } else {
    build_mc_border(buf_ptr1, pre_buf_stride, (uint8_t *)mc_buf_high, b_w,
                    x0, y0, b_w, b_h, frame_width, frame_height);
    buf_ptr = ((uint8_t *)mc_buf_high) + border_offset;
  }

  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
    high_inter_predictor(buf_ptr, b_w, dst, dst_buf_stride, subpel_x,
613 614
                         subpel_y, sf, w, h, ref, interp_filter,
                         xs, ys, xd->bd);
Jingning Han's avatar
Jingning Han committed
615 616
  } else {
    inter_predictor(buf_ptr, b_w, dst, dst_buf_stride, subpel_x,
617
                    subpel_y, sf, w, h, ref, interp_filter, xs, ys);
Jingning Han's avatar
Jingning Han committed
618 619 620 621 622 623 624 625 626
  }
}
#else
static void extend_and_predict(const uint8_t *buf_ptr1, int pre_buf_stride,
                               int x0, int y0, int b_w, int b_h,
                               int frame_width, int frame_height,
                               int border_offset,
                               uint8_t *const dst, int dst_buf_stride,
                               int subpel_x, int subpel_y,
627
                               const INTERP_FILTER interp_filter,
Jingning Han's avatar
Jingning Han committed
628 629 630 631 632 633 634 635 636 637
                               const struct scale_factors *sf,
                               int w, int h, int ref, int xs, int ys) {
  DECLARE_ALIGNED(16, uint8_t, mc_buf[80 * 2 * 80 * 2]);
  const uint8_t *buf_ptr;

  build_mc_border(buf_ptr1, pre_buf_stride, mc_buf, b_w,
                  x0, y0, b_w, b_h, frame_width, frame_height);
  buf_ptr = mc_buf + border_offset;

  inter_predictor(buf_ptr, b_w, dst, dst_buf_stride, subpel_x,
638
                  subpel_y, sf, w, h, ref, interp_filter, xs, ys);
Jingning Han's avatar
Jingning Han committed
639 640
}
#endif  // CONFIG_VP9_HIGHBITDEPTH
Yaowu Xu's avatar
Yaowu Xu committed
641
static void dec_build_inter_predictors(VP10Decoder *const pbi, MACROBLOCKD *xd,
Jingning Han's avatar
Jingning Han committed
642 643
                                       int plane, int bw, int bh, int x,
                                       int y, int w, int h, int mi_x, int mi_y,
644
                                       const INTERP_FILTER interp_filter,
Jingning Han's avatar
Jingning Han committed
645 646 647 648 649
                                       const struct scale_factors *sf,
                                       struct buf_2d *pre_buf,
                                       struct buf_2d *dst_buf, const MV* mv,
                                       RefCntBuffer *ref_frame_buf,
                                       int is_scaled, int ref) {
650
  VP10_COMMON *const cm = &pbi->common;
Jingning Han's avatar
Jingning Han committed
651 652 653
  struct macroblockd_plane *const pd = &xd->plane[plane];
  uint8_t *const dst = dst_buf->buf + dst_buf->stride * y + x;
  MV32 scaled_mv;
654
  MV mv_q4;
Jingning Han's avatar
Jingning Han committed
655 656 657
  int xs, ys, x0, y0, x0_16, y0_16, frame_width, frame_height,
      buf_stride, subpel_x, subpel_y;
  uint8_t *ref_frame, *buf_ptr;
658
#if CONFIG_EXT_INTERP
659
  const int i_filter = IsInterpolatingFilter(interp_filter);
660
#endif  // CONFIG_EXT_INTERP
Jingning Han's avatar
Jingning Han committed
661 662 663 664 665 666 667 668 669 670 671 672 673

  // Get reference frame pointer, width and height.
  if (plane == 0) {
    frame_width = ref_frame_buf->buf.y_crop_width;
    frame_height = ref_frame_buf->buf.y_crop_height;
    ref_frame = ref_frame_buf->buf.y_buffer;
  } else {
    frame_width = ref_frame_buf->buf.uv_crop_width;
    frame_height = ref_frame_buf->buf.uv_crop_height;
    ref_frame = plane == 1 ? ref_frame_buf->buf.u_buffer
                         : ref_frame_buf->buf.v_buffer;
  }

674 675 676
  mv_q4 = clamp_mv_to_umv_border_sb(xd, mv, bw, bh,
                                    pd->subsampling_x,
                                    pd->subsampling_y);
Jingning Han's avatar
Jingning Han committed
677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708
  if (is_scaled) {
    // Co-ordinate of containing block to pixel precision.
    int x_start = (-xd->mb_to_left_edge >> (3 + pd->subsampling_x));
    int y_start = (-xd->mb_to_top_edge >> (3 + pd->subsampling_y));

    // Co-ordinate of the block to 1/16th pixel precision.
    x0_16 = (x_start + x) << SUBPEL_BITS;
    y0_16 = (y_start + y) << SUBPEL_BITS;

    // Co-ordinate of current block in reference frame
    // to 1/16th pixel precision.
    x0_16 = sf->scale_value_x(x0_16, sf);
    y0_16 = sf->scale_value_y(y0_16, sf);

    // Map the top left corner of the block into the reference frame.
    x0 = sf->scale_value_x(x_start + x, sf);
    y0 = sf->scale_value_y(y_start + y, sf);

    // Scale the MV and incorporate the sub-pixel offset of the block
    // in the reference frame.
    scaled_mv = vp10_scale_mv(&mv_q4, mi_x + x, mi_y + y, sf);
    xs = sf->x_step_q4;
    ys = sf->y_step_q4;
  } else {
    // Co-ordinate of containing block to pixel precision.
    x0 = (-xd->mb_to_left_edge >> (3 + pd->subsampling_x)) + x;
    y0 = (-xd->mb_to_top_edge >> (3 + pd->subsampling_y)) + y;

    // Co-ordinate of the block to 1/16th pixel precision.
    x0_16 = x0 << SUBPEL_BITS;
    y0_16 = y0 << SUBPEL_BITS;

709 710
    scaled_mv.row = mv_q4.row;
    scaled_mv.col = mv_q4.col;
Jingning Han's avatar
Jingning Han committed
711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729
    xs = ys = 16;
  }
  subpel_x = scaled_mv.col & SUBPEL_MASK;
  subpel_y = scaled_mv.row & SUBPEL_MASK;

  // Calculate the top left corner of the best matching block in the
  // reference frame.
  x0 += scaled_mv.col >> SUBPEL_BITS;
  y0 += scaled_mv.row >> SUBPEL_BITS;
  x0_16 += scaled_mv.col;
  y0_16 += scaled_mv.row;

  // Get reference block pointer.
  buf_ptr = ref_frame + y0 * pre_buf->stride + x0;
  buf_stride = pre_buf->stride;

  // Do border extension if there is motion or the
  // width/height is not a multiple of 8 pixels.
  if (is_scaled || scaled_mv.col || scaled_mv.row ||
730 731 732
#if CONFIG_EXT_INTERP
      !i_filter ||
#endif
Jingning Han's avatar
Jingning Han committed
733 734 735 736 737 738 739
      (frame_width & 0x7) || (frame_height & 0x7)) {
    int y1 = ((y0_16 + (h - 1) * ys) >> SUBPEL_BITS) + 1;

    // Get reference block bottom right horizontal coordinate.
    int x1 = ((x0_16 + (w - 1) * xs) >> SUBPEL_BITS) + 1;
    int x_pad = 0, y_pad = 0;

740 741
    InterpFilterParams filter_params =
        vp10_get_interp_filter_params(interp_filter);
742
    int filter_size = filter_params.taps;
743

744 745 746 747 748
    if (subpel_x ||
#if CONFIG_EXT_INTERP
        !i_filter ||
#endif
        (sf->x_step_q4 != SUBPEL_SHIFTS)) {
749 750
      x0 -= filter_size / 2 - 1;
      x1 += filter_size / 2;
Jingning Han's avatar
Jingning Han committed
751 752 753
      x_pad = 1;
    }

754 755 756 757 758
    if (subpel_y ||
#if CONFIG_EXT_INTERP
        !i_filter ||
#endif
        (sf->y_step_q4 != SUBPEL_SHIFTS)) {
759 760
      y0 -= filter_size / 2 - 1;
      y1 += filter_size / 2;
Jingning Han's avatar
Jingning Han committed
761 762 763 764 765
      y_pad = 1;
    }

    // Wait until reference block is ready. Pad 7 more pixels as last 7
    // pixels of each superblock row can be changed by next superblock row.
766
    if (cm->frame_parallel_decode)
Jingning Han's avatar
Jingning Han committed
767
      vp10_frameworker_wait(pbi->frame_worker_owner, ref_frame_buf,
768
                            VPXMAX(0, (y1 + 7)) << (plane == 0 ? 0 : 1));
Jingning Han's avatar
Jingning Han committed
769 770 771 772 773 774 775 776

    // Skip border extension if block is inside the frame.
    if (x0 < 0 || x0 > frame_width - 1 || x1 < 0 || x1 > frame_width - 1 ||
        y0 < 0 || y0 > frame_height - 1 || y1 < 0 || y1 > frame_height - 1) {
      // Extend the border.
      const uint8_t *const buf_ptr1 = ref_frame + y0 * buf_stride + x0;
      const int b_w = x1 - x0 + 1;
      const int b_h = y1 - y0 + 1;
777 778
      const int border_offset = y_pad * (filter_size / 2 - 1) * b_w +
                                x_pad * (filter_size / 2 - 1);
Jingning Han's avatar
Jingning Han committed
779 780 781 782 783

      extend_and_predict(buf_ptr1, buf_stride, x0, y0, b_w, b_h,
                         frame_width, frame_height, border_offset,
                         dst, dst_buf->stride,
                         subpel_x, subpel_y,
784
                         interp_filter, sf,
Jingning Han's avatar
Jingning Han committed
785 786 787 788 789 790 791 792 793
#if CONFIG_VP9_HIGHBITDEPTH
                         xd,
#endif
                         w, h, ref, xs, ys);
      return;
    }
  } else {
    // Wait until reference block is ready. Pad 7 more pixels as last 7
    // pixels of each superblock row can be changed by next superblock row.
794
     if (cm->frame_parallel_decode) {
Jingning Han's avatar
Jingning Han committed
795 796
       const int y1 = (y0_16 + (h - 1) * ys) >> SUBPEL_BITS;
       vp10_frameworker_wait(pbi->frame_worker_owner, ref_frame_buf,
797
                             VPXMAX(0, (y1 + 7)) << (plane == 0 ? 0 : 1));
Jingning Han's avatar
Jingning Han committed
798 799 800 801 802
     }
  }
#if CONFIG_VP9_HIGHBITDEPTH
  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
    high_inter_predictor(buf_ptr, buf_stride, dst, dst_buf->stride, subpel_x,
803 804
                         subpel_y, sf, w, h, ref, interp_filter,
                         xs, ys, xd->bd);
Jingning Han's avatar
Jingning Han committed
805 806
  } else {
    inter_predictor(buf_ptr, buf_stride, dst, dst_buf->stride, subpel_x,
807
                    subpel_y, sf, w, h, ref, interp_filter, xs, ys);
Jingning Han's avatar
Jingning Han committed
808 809 810
  }
#else
  inter_predictor(buf_ptr, buf_stride, dst, dst_buf->stride, subpel_x,
811
                  subpel_y, sf, w, h, ref, interp_filter, xs, ys);
Jingning Han's avatar
Jingning Han committed
812 813 814
#endif  // CONFIG_VP9_HIGHBITDEPTH
}

Yaowu Xu's avatar
Yaowu Xu committed
815
static void dec_build_inter_predictors_sb(VP10Decoder *const pbi,
Jingning Han's avatar
Jingning Han committed
816 817 818 819 820 821
                                          MACROBLOCKD *xd,
                                          int mi_row, int mi_col) {
  int plane;
  const int mi_x = mi_col * MI_SIZE;
  const int mi_y = mi_row * MI_SIZE;
  const MODE_INFO *mi = xd->mi[0];
822
  const INTERP_FILTER interp_filter = mi->mbmi.interp_filter;
Jingning Han's avatar
Jingning Han committed
823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844
  const BLOCK_SIZE sb_type = mi->mbmi.sb_type;
  const int is_compound = has_second_ref(&mi->mbmi);

  for (plane = 0; plane < MAX_MB_PLANE; ++plane) {
    struct macroblockd_plane *const pd = &xd->plane[plane];
    struct buf_2d *const dst_buf = &pd->dst;
    const int num_4x4_w = pd->n4_w;
    const int num_4x4_h = pd->n4_h;

    const int n4w_x4 = 4 * num_4x4_w;
    const int n4h_x4 = 4 * num_4x4_h;
    int ref;

    for (ref = 0; ref < 1 + is_compound; ++ref) {
      const struct scale_factors *const sf = &xd->block_refs[ref]->sf;
      struct buf_2d *const pre_buf = &pd->pre[ref];
      const int idx = xd->block_refs[ref]->idx;
      BufferPool *const pool = pbi->common.buffer_pool;
      RefCntBuffer *const ref_frame_buf = &pool->frame_bufs[idx];
      const int is_scaled = vp10_is_scaled(sf);

      if (sb_type < BLOCK_8X8) {
845 846 847 848 849 850 851
        const PARTITION_TYPE bp = BLOCK_8X8 - sb_type;
        const int have_vsplit = bp != PARTITION_HORZ;
        const int have_hsplit = bp != PARTITION_VERT;
        const int num_4x4_w = 2 >> ((!have_vsplit) | pd->subsampling_x);
        const int num_4x4_h = 2 >> ((!have_hsplit) | pd->subsampling_y);
        const int pw = 8 >> (have_vsplit | pd->subsampling_x);
        const int ph = 8 >> (have_hsplit | pd->subsampling_y);
852
        int x, y;
Jingning Han's avatar
Jingning Han committed
853 854
        for (y = 0; y < num_4x4_h; ++y) {
          for (x = 0; x < num_4x4_w; ++x) {
855
            const MV mv = average_split_mvs(pd, mi, ref, y * 2 + x);
Jingning Han's avatar
Jingning Han committed
856
            dec_build_inter_predictors(pbi, xd, plane, n4w_x4, n4h_x4,
857 858 859
                                       4 * x, 4 * y, pw, ph, mi_x, mi_y,
                                       interp_filter, sf, pre_buf, dst_buf,
                                       &mv, ref_frame_buf, is_scaled, ref);
Jingning Han's avatar
Jingning Han committed
860 861 862 863 864
          }
        }
      } else {
        const MV mv = mi->mbmi.mv[ref].as_mv;
        dec_build_inter_predictors(pbi, xd, plane, n4w_x4, n4h_x4,
865 866 867
                                   0, 0, n4w_x4, n4h_x4, mi_x, mi_y,
                                   interp_filter, sf, pre_buf, dst_buf,
                                   &mv, ref_frame_buf,
Jingning Han's avatar
Jingning Han committed
868 869 870 871
                                   is_scaled, ref);
      }
    }
  }
872 873 874 875 876 877 878 879 880 881 882
#if CONFIG_EXT_INTER
  if (is_interintra_pred(&xd->mi[0]->mbmi))
    vp10_build_interintra_predictors(xd,
                                     xd->plane[0].dst.buf,
                                     xd->plane[1].dst.buf,
                                     xd->plane[2].dst.buf,
                                     xd->plane[0].dst.stride,
                                     xd->plane[1].dst.stride,
                                     xd->plane[2].dst.stride,
                                     sb_type);
#endif  // CONFIG_EXT_INTER
Jingning Han's avatar
Jingning Han committed
883
}
884
#endif  // (CONFIG_SUPERTX || CONFIG_OBMC)
885

Yaowu Xu's avatar
Yaowu Xu committed
886
#if CONFIG_SUPERTX
887 888 889 890 891 892 893 894 895 896
static void dec_build_inter_predictors_sb_sub8x8(VP10Decoder *const pbi,
                                                 MACROBLOCKD *xd,
                                                 int mi_row, int mi_col,
                                                 int block) {
  // Prediction function used in supertx:
  // Use the mv at current block (which is less than 8x8)
  int plane;
  const int mi_x = mi_col * MI_SIZE;
  const int mi_y = mi_row * MI_SIZE;
  const MODE_INFO *mi = xd->mi[0];
897
  const INTERP_FILTER interp_filter = mi->mbmi.interp_filter;
898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922
  const int is_compound = has_second_ref(&mi->mbmi);

  // For sub8x8 uv:
  // Skip uv prediction in supertx except the first block (block = 0)
  int max_plane = block ? 1 : MAX_MB_PLANE;

  for (plane = 0; plane < max_plane; ++plane) {
    struct macroblockd_plane *const pd = &xd->plane[plane];
    struct buf_2d *const dst_buf = &pd->dst;
    const int num_4x4_w = pd->n4_w;
    const int num_4x4_h = pd->n4_h;

    const int n4w_x4 = 4 * num_4x4_w;
    const int n4h_x4 = 4 * num_4x4_h;
    int ref;

    for (ref = 0; ref < 1 + is_compound; ++ref) {
      const struct scale_factors *const sf = &xd->block_refs[ref]->sf;
      struct buf_2d *const pre_buf = &pd->pre[ref];
      const int idx = xd->block_refs[ref]->idx;
      BufferPool *const pool = pbi->common.buffer_pool;
      RefCntBuffer *const ref_frame_buf = &pool->frame_bufs[idx];
      const int is_scaled = vp10_is_scaled(sf);
      const MV mv = average_split_mvs(pd, mi, ref, block);
      dec_build_inter_predictors(pbi, xd, plane, n4w_x4, n4h_x4,
923 924 925
                                 0, 0, n4w_x4, n4h_x4, mi_x, mi_y,
                                 interp_filter, sf, pre_buf, dst_buf,
                                 &mv, ref_frame_buf, is_scaled, ref);
926 927
    }
  }
928 929 930 931 932 933 934 935 936 937 938
#if CONFIG_EXT_INTER
  if (is_interintra_pred(&xd->mi[0]->mbmi))
    vp10_build_interintra_predictors(xd,
                                     xd->plane[0].dst.buf,
                                     xd->plane[1].dst.buf,
                                     xd->plane[2].dst.buf,
                                     xd->plane[0].dst.stride,
                                     xd->plane[1].dst.stride,
                                     xd->plane[2].dst.stride,
                                     xd->mi[0]->mbmi.sb_type);
#endif  // CONFIG_EXT_INTER
939
}
940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
#endif  // CONFIG_SUPERTX

#if CONFIG_OBMC
static void dec_build_prediction_by_above_preds(VP10Decoder *const pbi,
                                                MACROBLOCKD *xd,
                                                int mi_row, int mi_col,
                                                uint8_t *tmp_buf[MAX_MB_PLANE],
                                                int tmp_stride[MAX_MB_PLANE]) {
  VP10_COMMON *const cm = &pbi->common;
  BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type;
  int i, j, mi_step, ref;

  if (mi_row == 0)
    return;

  for (i = 0; i < VPXMIN(xd->n8_w, cm->mi_cols - mi_col); i += mi_step) {
    int mi_row_offset = -1;
    int mi_col_offset = i;
    int mi_x, mi_y, bw, bh;
    const MODE_INFO *mi = xd->mi[mi_col_offset + mi_row_offset * cm->mi_stride];
    const MB_MODE_INFO *mbmi = &mi->mbmi;
    const BLOCK_SIZE sb_type = mbmi->sb_type;
    const int is_compound = has_second_ref(mbmi);
    const INTERP_FILTER interp_filter = mbmi->interp_filter;

    mi_step = VPXMIN(xd->n8_w, num_8x8_blocks_wide_lookup[sb_type]);

    if (!is_inter_block(mbmi))
      continue;

    for (j = 0; j < MAX_MB_PLANE; ++j) {
      struct macroblockd_plane *const pd = &xd->plane[j];
      setup_pred_plane(&pd->dst,
                       tmp_buf[j], tmp_stride[j],
                       0, i, NULL,
                       pd->subsampling_x, pd->subsampling_y);
    }
    for (ref = 0; ref < 1 + is_compound; ++ref) {
      MV_REFERENCE_FRAME frame = mbmi->ref_frame[ref];
      RefBuffer *ref_buf = &cm->frame_refs[frame - LAST_FRAME];

      xd->block_refs[ref] = ref_buf;
      if ((!vp10_is_valid_scale(&ref_buf->sf)))
        vpx_internal_error(xd->error_info, VPX_CODEC_UNSUP_BITSTREAM,
                           "Reference frame has invalid dimensions");
      vp10_setup_pre_planes(xd, ref, ref_buf->buf, mi_row, mi_col + i,
                            &ref_buf->sf);
    }

    xd->mb_to_left_edge = -(((mi_col + i) * MI_SIZE) * 8);
    mi_x = (mi_col + i) << MI_SIZE_LOG2;
    mi_y = mi_row << MI_SIZE_LOG2;

    for (j = 0; j < MAX_MB_PLANE; ++j) {
      struct macroblockd_plane *pd = &xd->plane[j];
      struct buf_2d *const dst_buf = &pd->dst;
      bw = (mi_step * 8) >> pd->subsampling_x;
      bh = VPXMAX((num_4x4_blocks_high_lookup[bsize] * 2) >> pd->subsampling_y,
                  4);

      for (ref = 0; ref < 1 + is_compound; ++ref) {
        const struct scale_factors *const sf = &xd->block_refs[ref]->sf;
        struct buf_2d *const pre_buf = &pd->pre[ref];
        const int idx = xd->block_refs[ref]->idx;
        BufferPool *const pool = pbi->common.buffer_pool;
        RefCntBuffer *const ref_frame_buf = &pool->frame_bufs[idx];
        const int is_scaled = vp10_is_scaled(sf);

        if (sb_type < BLOCK_8X8) {
          const PARTITION_TYPE bp = BLOCK_8X8 - sb_type;
          const int have_vsplit = bp != PARTITION_HORZ;
          const int have_hsplit = bp != PARTITION_VERT;
          const int num_4x4_w = 2 >> ((!have_vsplit) | pd->subsampling_x);
          const int num_4x4_h = 2 >> ((!have_hsplit) | pd->subsampling_y);
          const int pw = 8 >> (have_vsplit | pd->subsampling_x);
          int x, y;

          for (y = 0; y < num_4x4_h; ++y)
            for (x = 0; x < num_4x4_w; ++x) {
              const MV mv = average_split_mvs(pd, mi, ref, y * 2 + x);
              if ((bp == PARTITION_HORZ || bp == PARTITION_SPLIT)
                  && y == 0 && !pd->subsampling_y)
                continue;

              dec_build_inter_predictors(pbi, xd, j, bw, bh,
                                         4 * x, 0, pw, bh, mi_x, mi_y,
                                         interp_filter, sf, pre_buf, dst_buf,
                                         &mv, ref_frame_buf, is_scaled, ref);
            }
        } else {
          const MV mv = mi->mbmi.mv[ref].as_mv;
          dec_build_inter_predictors(pbi, xd, j, bw, bh,
                                     0, 0, bw, bh, mi_x, mi_y, interp_filter,
                                     sf, pre_buf, dst_buf, &mv, ref_frame_buf,
                                     is_scaled, ref);
        }
      }
    }
  }
  xd->mb_to_left_edge   = -((mi_col * MI_SIZE) * 8);
}

static void dec_build_prediction_by_left_preds(VP10Decoder *const pbi,
                                               MACROBLOCKD *xd,
                                               int mi_row, int mi_col,
                                               uint8_t *tmp_buf[MAX_MB_PLANE],
                                               int tmp_stride[MAX_MB_PLANE]) {
  VP10_COMMON *const cm = &pbi->common;
  const TileInfo *const tile = &xd->tile;
  BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type;
  int i, j, mi_step, ref;

  if (mi_col == 0 || (mi_col - 1 < tile->mi_col_start) ||
      (mi_col - 1) >= tile->mi_col_end)
    return;

  for (i = 0; i < VPXMIN(xd->n8_h, cm->mi_rows - mi_row); i += mi_step) {
    int mi_row_offset = i;
    int mi_col_offset = -1;
    int mi_x, mi_y, bw, bh;
    const MODE_INFO *mi = xd->mi[mi_col_offset + mi_row_offset * cm->mi_stride];
    const MB_MODE_INFO *mbmi = &mi->mbmi;
    const BLOCK_SIZE sb_type = mbmi->sb_type;
    const int is_compound = has_second_ref(mbmi);
    const INTERP_FILTER interp_filter = mbmi->interp_filter;

    mi_step = VPXMIN(xd->n8_h, num_8x8_blocks_high_lookup[sb_type]);

    if (!is_inter_block(mbmi))
      continue;

    for (j = 0; j < MAX_MB_PLANE; ++j) {
      struct macroblockd_plane *const pd = &xd->plane[j];
      setup_pred_plane(&pd->dst,
                       tmp_buf[j], tmp_stride[j],
                       i, 0, NULL,
                       pd->subsampling_x, pd->subsampling_y);
    }

    for (ref = 0; ref < 1 + is_compound; ++ref) {
      MV_REFERENCE_FRAME frame = mbmi->ref_frame[ref];
      RefBuffer *ref_buf = &cm->frame_refs[frame - LAST_FRAME];

      xd->block_refs[ref] = ref_buf;
      if ((!vp10_is_valid_scale(&ref_buf->sf)))
        vpx_internal_error(xd->error_info, VPX_CODEC_UNSUP_BITSTREAM,
                           "Reference frame has invalid dimensions");
      vp10_setup_pre_planes(xd, ref, ref_buf->buf, mi_row + i, mi_col,
                            &ref_buf->sf);
    }

    xd->mb_to_top_edge    = -(((mi_row + i) * MI_SIZE) * 8);
    mi_x = mi_col << MI_SIZE_LOG2;
    mi_y = (mi_row + i) << MI_SIZE_LOG2;

    for (j = 0; j < MAX_MB_PLANE; ++j) {
      struct macroblockd_plane *pd = &xd->plane[j];
      struct buf_2d *const dst_buf = &pd->dst;
      bw = VPXMAX((num_4x4_blocks_wide_lookup[bsize] * 2) >> pd->subsampling_x,
                  4);
      bh = (mi_step << MI_SIZE_LOG2) >> pd->subsampling_y;

      for (ref = 0; ref < 1 + is_compound; ++ref) {
        const struct scale_factors *const sf = &xd->block_refs[ref]->sf;
        struct buf_2d *const pre_buf = &pd->pre[ref];
        const int idx = xd->block_refs[ref]->idx;
        BufferPool *const pool = pbi->common.buffer_pool;
        RefCntBuffer *const ref_frame_buf = &pool->frame_bufs[idx];
        const int is_scaled = vp10_is_scaled(sf);

        if (sb_type < BLOCK_8X8) {
          const PARTITION_TYPE bp = BLOCK_8X8 - sb_type;
          const int have_vsplit = bp != PARTITION_HORZ;
          const int have_hsplit = bp != PARTITION_VERT;
          const int num_4x4_w = 2 >> ((!have_vsplit) | pd->subsampling_x);
          const int num_4x4_h = 2 >> ((!have_hsplit) | pd->subsampling_y);
          const int ph = 8 >> (have_hsplit | pd->subsampling_y);
          int x, y;

          for (y = 0; y < num_4x4_h; ++y)
            for (x = 0; x < num_4x4_w; ++x) {
              const MV mv = average_split_mvs(pd, mi, ref, y * 2 + x);
              if ((bp == PARTITION_VERT || bp == PARTITION_SPLIT)
                  && x == 0 && !pd->subsampling_x)
                continue;

              dec_build_inter_predictors(pbi, xd, j, bw, bh,
                                         0, 4 * y, bw, ph, mi_x, mi_y,
                                         interp_filter, sf, pre_buf, dst_buf,
                                         &mv, ref_frame_buf, is_scaled, ref);
            }
        } else {
          const MV mv = mi->mbmi.mv[ref].as_mv;
          dec_build_inter_predictors(pbi, xd, j, bw, bh,
                                     0, 0, bw, bh, mi_x, mi_y, interp_filter,
                                     sf, pre_buf, dst_buf, &mv, ref_frame_buf,
                                     is_scaled, ref);
        }
      }
    }
  }
  xd->mb_to_top_edge    = -((mi_row * MI_SIZE) * 8);
}
#endif  // CONFIG_OBMC

Jingning Han's avatar
Jingning Han committed
1145 1146 1147
static INLINE TX_SIZE dec_get_uv_tx_size(const MB_MODE_INFO *mbmi,
                                         int n4_wl, int n4_hl) {
  // get minimum log2 num4x4s dimension
1148 1149
  const int x = VPXMIN(n4_wl, n4_hl);
  return VPXMIN(mbmi->tx_size,  x);
Jingning Han's avatar
Jingning Han committed
1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
}

static INLINE void dec_reset_skip_context(MACROBLOCKD *xd) {
  int i;
  for (i = 0; i < MAX_MB_PLANE; i++) {
    struct macroblockd_plane *const pd = &xd->plane[i];
    memset(pd->above_context, 0, sizeof(ENTROPY_CONTEXT) * pd->n4_w);
    memset(pd->left_context, 0, sizeof(ENTROPY_CONTEXT) * pd->n4_h);
  }
}

static void set_plane_n4(MACROBLOCKD *const xd, int bw, int bh, int bwl,
                         int bhl) {
  int i;
  for (i = 0; i < MAX_MB_PLANE; i++) {
    xd->plane[i].n4_w = (bw << 1) >> xd->plane[i].subsampling_x;
    xd->plane[i].n4_h = (bh << 1) >> xd->plane[i].subsampling_y;
    xd->plane[i].n4_wl = bwl - xd->plane[i].subsampling_x;
    xd->plane[i].n4_hl = bhl - xd->plane[i].subsampling_y;
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
1172
static MB_MODE_INFO *set_offsets(VP10_COMMON *const cm, MACROBLOCKD *const xd,
Jingning Han's avatar
Jingning Han committed
1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193
                                 BLOCK_SIZE bsize, int mi_row, int mi_col,
                                 int bw, int bh, int x_mis, int y_mis,
                                 int bwl, int bhl) {
  const int offset = mi_row * cm->mi_stride + mi_col;
  int x, y;
  const TileInfo *const tile = &xd->tile;

  xd->mi = cm->mi_grid_visible + offset;
  xd->mi[0] = &cm->mi[offset];
  // TODO(slavarnway): Generate sb_type based on bwl and bhl, instead of
  // passing bsize from decode_partition().
  xd->mi[0]->mbmi.sb_type = bsize;
  for (y = 0; y < y_mis; ++y)
    for (x = !y; x < x_mis; ++x) {
      xd->mi[y * cm->mi_stride + x] = xd->mi[0];
    }

  set_plane_n4(xd, bw, bh, bwl, bhl);

  set_skip_context(xd, mi_row, mi_col);

1194 1195 1196 1197 1198

#if CONFIG_VAR_TX
  xd->max_tx_size = max_txsize_lookup[bsize];
#endif

Jingning Han's avatar
Jingning Han committed
1199 1200 1201 1202 1203 1204 1205 1206
  // Distance of Mb to the various image edges. These are specified to 8th pel
  // as they are always compared to values that are in 1/8th pel units
  set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, cm->mi_rows, cm->mi_cols);

  vp10_setup_dst_planes(xd->plane, get_frame_new_buffer(cm), mi_row, mi_col);
  return &xd->mi[0]->mbmi;
}

1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
#if CONFIG_SUPERTX
static MB_MODE_INFO *set_offsets_extend(VP10_COMMON *const cm,
                                        MACROBLOCKD *const xd,
                                        const TileInfo *const tile,
                                        BLOCK_SIZE bsize_pred,
                                        int mi_row_pred, int mi_col_pred,
                                        int mi_row_ori, int mi_col_ori) {
  // Used in supertx
  // (mi_row_ori, mi_col_ori): location for mv
  // (mi_row_pred, mi_col_pred, bsize_pred): region to predict
  const int bw = num_8x8_blocks_wide_lookup[bsize_pred];
  const int bh = num_8x8_blocks_high_lookup[bsize_pred];
  const int offset = mi_row_ori * cm->mi_stride + mi_col_ori;
  const int bwl = b_width_log2_lookup[bsize_pred];
  const int bhl = b_height_log2_lookup[bsize_pred];
  xd->mi = cm->mi_grid_visible + offset;
  xd->mi[0] = cm->mi + offset;
  set_mi_row_col(xd, tile, mi_row_pred, bh, mi_col_pred, bw,
                 cm->mi_rows, cm->mi_cols);

  xd->up_available    = (mi_row_ori != 0);
  xd->left_available  = (mi_col_ori > tile->mi_col_start);

  set_plane_n4(xd, bw, bh, bwl, bhl);

  return &xd->mi[0]->mbmi;
}

static MB_MODE_INFO *set_mb_offsets(VP10_COMMON *const cm,
                                    MACROBLOCKD *const xd,
                                    BLOCK_SIZE bsize,