decodeframe.c 172 KB
Newer Older
Jingning Han's avatar
Jingning Han committed
1
/*
2
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
Jingning Han's avatar
Jingning Han committed
3
 *
4 5 6 7 8 9
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
Jingning Han's avatar
Jingning Han committed
10 11 12 13 14
 */

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

15 16 17
#include "./aom_config.h"
#include "./aom_dsp_rtcd.h"
#include "./aom_scale_rtcd.h"
Jingning Han's avatar
Jingning Han committed
18
#include "./av1_rtcd.h"
Jingning Han's avatar
Jingning Han committed
19

20
#include "aom/aom_codec.h"
21
#include "aom_dsp/aom_dsp_common.h"
Jingning Han's avatar
Jingning Han committed
22 23
#include "aom_dsp/bitreader.h"
#include "aom_dsp/bitreader_buffer.h"
24
#include "aom_mem/aom_mem.h"
25 26
#include "aom_ports/mem.h"
#include "aom_ports/mem_ops.h"
27 28
#include "aom_scale/aom_scale.h"
#include "aom_util/aom_thread.h"
Jingning Han's avatar
Jingning Han committed
29

30
#include "av1/common/alloccommon.h"
31
#if CONFIG_CLPF
Steinar Midtskogen's avatar
Steinar Midtskogen committed
32
#include "aom/aom_image.h"
33
#include "av1/common/clpf.h"
34
#endif
35
#include "av1/common/common.h"
Yaowu Xu's avatar
Yaowu Xu committed
36
#if CONFIG_DERING
37
#include "av1/common/dering.h"
Yaowu Xu's avatar
Yaowu Xu committed
38
#endif  // CONFIG_DERING
39 40
#include "av1/common/entropy.h"
#include "av1/common/entropymode.h"
41
#include "av1/common/entropymv.h"
42 43 44 45
#include "av1/common/idct.h"
#include "av1/common/pred_common.h"
#include "av1/common/quant_common.h"
#include "av1/common/reconinter.h"
Jingning Han's avatar
Jingning Han committed
46
#include "av1/common/reconintra.h"
47
#include "av1/common/seg_common.h"
Jingning Han's avatar
Jingning Han committed
48
#include "av1/common/thread_common.h"
49
#include "av1/common/tile_common.h"
50

51 52 53
#include "av1/decoder/decodeframe.h"
#include "av1/decoder/decodemv.h"
#include "av1/decoder/decoder.h"
Jingning Han's avatar
Jingning Han committed
54
#include "av1/decoder/detokenize.h"
55
#include "av1/decoder/dsubexp.h"
Jingning Han's avatar
Jingning Han committed
56

Yue Chen's avatar
Yue Chen committed
57 58 59 60
#if CONFIG_WARPED_MOTION
#include "av1/common/warped_motion.h"
#endif  // CONFIG_WARPED_MOTION

61
#define MAX_AV1_HEADER_SIZE 80
Michael Bebenita's avatar
Michael Bebenita committed
62
#define ACCT_STR __func__
Jingning Han's avatar
Jingning Han committed
63

64 65
#if CONFIG_PVQ
#include "av1/decoder/pvq_decoder.h"
66
#include "av1/common/pvq.h"
67 68 69 70 71 72 73 74
#include "av1/encoder/encodemb.h"

#include "aom_dsp/entdec.h"
#include "av1/common/partition.h"
#include "av1/decoder/decint.h"
#include "av1/encoder/hybrid_fwd_txfm.h"
#endif

75 76 77 78 79 80 81 82
static struct aom_read_bit_buffer *init_read_bit_buffer(
    AV1Decoder *pbi, struct aom_read_bit_buffer *rb, const uint8_t *data,
    const uint8_t *data_end, uint8_t clear_data[MAX_AV1_HEADER_SIZE]);
static int read_compressed_header(AV1Decoder *pbi, const uint8_t *data,
                                  size_t partition_size);
static size_t read_uncompressed_header(AV1Decoder *pbi,
                                       struct aom_read_bit_buffer *rb);

83
static int is_compound_reference_allowed(const AV1_COMMON *cm) {
Jingning Han's avatar
Jingning Han committed
84
  int i;
85
  if (frame_is_intra_only(cm)) return 0;
86
  for (i = 1; i < INTER_REFS_PER_FRAME; ++i)
87
    if (cm->ref_frame_sign_bias[i + 1] != cm->ref_frame_sign_bias[1]) return 1;
Jingning Han's avatar
Jingning Han committed
88 89 90 91

  return 0;
}

92
static void setup_compound_reference_mode(AV1_COMMON *cm) {
93
#if CONFIG_EXT_REFS
94
  cm->comp_fwd_ref[0] = LAST_FRAME;
95 96 97 98
  cm->comp_fwd_ref[1] = LAST2_FRAME;
  cm->comp_fwd_ref[2] = LAST3_FRAME;
  cm->comp_fwd_ref[3] = GOLDEN_FRAME;

99 100
  cm->comp_bwd_ref[0] = BWDREF_FRAME;
  cm->comp_bwd_ref[1] = ALTREF_FRAME;
101
#else
Jingning Han's avatar
Jingning Han committed
102
  if (cm->ref_frame_sign_bias[LAST_FRAME] ==
103
      cm->ref_frame_sign_bias[GOLDEN_FRAME]) {
Jingning Han's avatar
Jingning Han committed
104 105 106 107
    cm->comp_fixed_ref = ALTREF_FRAME;
    cm->comp_var_ref[0] = LAST_FRAME;
    cm->comp_var_ref[1] = GOLDEN_FRAME;
  } else if (cm->ref_frame_sign_bias[LAST_FRAME] ==
108
             cm->ref_frame_sign_bias[ALTREF_FRAME]) {
Jingning Han's avatar
Jingning Han committed
109 110 111 112 113 114 115 116
    cm->comp_fixed_ref = GOLDEN_FRAME;
    cm->comp_var_ref[0] = LAST_FRAME;
    cm->comp_var_ref[1] = ALTREF_FRAME;
  } else {
    cm->comp_fixed_ref = LAST_FRAME;
    cm->comp_var_ref[0] = GOLDEN_FRAME;
    cm->comp_var_ref[1] = ALTREF_FRAME;
  }
117
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
118 119 120 121 122 123
}

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

124 125
static int decode_unsigned_max(struct aom_read_bit_buffer *rb, int max) {
  const int data = aom_rb_read_literal(rb, get_unsigned_bits(max));
Jingning Han's avatar
Jingning Han committed
126 127 128
  return data > max ? max : data;
}

129
static TX_MODE read_tx_mode(struct aom_read_bit_buffer *rb) {
130 131 132 133 134 135
#if CONFIG_TX64X64
  TX_MODE tx_mode =
      aom_rb_read_bit(rb) ? TX_MODE_SELECT : aom_rb_read_literal(rb, 2);
  if (tx_mode == ALLOW_32X32) tx_mode += aom_rb_read_bit(rb);
  return tx_mode;
#else
136
  return aom_rb_read_bit(rb) ? TX_MODE_SELECT : aom_rb_read_literal(rb, 2);
137
#endif  // CONFIG_TX64X64
138
}
Jingning Han's avatar
Jingning Han committed
139

Yaowu Xu's avatar
Yaowu Xu committed
140 141 142 143 144 145 146 147
static void read_tx_size_probs(FRAME_CONTEXT *fc, aom_reader *r) {
  int i, j, k;
  for (i = 0; i < MAX_TX_DEPTH; ++i)
    for (j = 0; j < TX_SIZE_CONTEXTS; ++j)
      for (k = 0; k < i + 1; ++k)
        av1_diff_update_prob(r, &fc->tx_size_probs[i][j][k], ACCT_STR);
}

148
#if !CONFIG_EC_ADAPT
149
static void read_switchable_interp_probs(FRAME_CONTEXT *fc, aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
150
  int i, j;
151
  for (j = 0; j < SWITCHABLE_FILTER_CONTEXTS; ++j) {
Jingning Han's avatar
Jingning Han committed
152
    for (i = 0; i < SWITCHABLE_FILTERS - 1; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
153
      av1_diff_update_prob(r, &fc->switchable_interp_prob[j][i], ACCT_STR);
154
  }
Jingning Han's avatar
Jingning Han committed
155
}
156
#endif
Jingning Han's avatar
Jingning Han committed
157

158
static void read_inter_mode_probs(FRAME_CONTEXT *fc, aom_reader *r) {
159
#if CONFIG_REF_MV
160
  int i;
161
  for (i = 0; i < NEWMV_MODE_CONTEXTS; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
162
    av1_diff_update_prob(r, &fc->newmv_prob[i], ACCT_STR);
163
  for (i = 0; i < ZEROMV_MODE_CONTEXTS; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
164
    av1_diff_update_prob(r, &fc->zeromv_prob[i], ACCT_STR);
165
  for (i = 0; i < REFMV_MODE_CONTEXTS; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
166
    av1_diff_update_prob(r, &fc->refmv_prob[i], ACCT_STR);
167
  for (i = 0; i < DRL_MODE_CONTEXTS; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
168
    av1_diff_update_prob(r, &fc->drl_prob[i], ACCT_STR);
Yue Chen's avatar
Yue Chen committed
169
#if CONFIG_EXT_INTER
Michael Bebenita's avatar
Michael Bebenita committed
170
  av1_diff_update_prob(r, &fc->new2mv_prob, ACCT_STR);
Yue Chen's avatar
Yue Chen committed
171
#endif  // CONFIG_EXT_INTER
172
#else
173
#if !CONFIG_EC_ADAPT
174
  int i, j;
175
  for (i = 0; i < INTER_MODE_CONTEXTS; ++i) {
Jingning Han's avatar
Jingning Han committed
176
    for (j = 0; j < INTER_MODES - 1; ++j)
Michael Bebenita's avatar
Michael Bebenita committed
177
      av1_diff_update_prob(r, &fc->inter_mode_probs[i][j], ACCT_STR);
178
  }
179 180 181
#else
  (void)fc;
  (void)r;
182
#endif
183
#endif
Jingning Han's avatar
Jingning Han committed
184 185
}

186
#if CONFIG_EXT_INTER
187
static void read_inter_compound_mode_probs(FRAME_CONTEXT *fc, aom_reader *r) {
188
  int i, j;
Michael Bebenita's avatar
Michael Bebenita committed
189
  if (aom_read(r, GROUP_DIFF_UPDATE_PROB, ACCT_STR)) {
190 191
    for (j = 0; j < INTER_MODE_CONTEXTS; ++j) {
      for (i = 0; i < INTER_COMPOUND_MODES - 1; ++i) {
Michael Bebenita's avatar
Michael Bebenita committed
192
        av1_diff_update_prob(r, &fc->inter_compound_mode_probs[j][i], ACCT_STR);
193 194 195 196 197
      }
    }
  }
}
#endif  // CONFIG_EXT_INTER
198
#if !CONFIG_EC_ADAPT
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
#if !CONFIG_EXT_TX
static void read_ext_tx_probs(FRAME_CONTEXT *fc, aom_reader *r) {
  int i, j, k;
  if (aom_read(r, GROUP_DIFF_UPDATE_PROB, ACCT_STR)) {
    for (i = TX_4X4; i < EXT_TX_SIZES; ++i) {
      for (j = 0; j < TX_TYPES; ++j) {
        for (k = 0; k < TX_TYPES - 1; ++k)
          av1_diff_update_prob(r, &fc->intra_ext_tx_prob[i][j][k], ACCT_STR);
      }
    }
  }
  if (aom_read(r, GROUP_DIFF_UPDATE_PROB, ACCT_STR)) {
    for (i = TX_4X4; i < EXT_TX_SIZES; ++i) {
      for (k = 0; k < TX_TYPES - 1; ++k)
        av1_diff_update_prob(r, &fc->inter_ext_tx_prob[i][k], ACCT_STR);
    }
  }
}
#endif
#endif
219

220
static REFERENCE_MODE read_frame_reference_mode(
221
    const AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
222
  if (is_compound_reference_allowed(cm)) {
223
    return aom_rb_read_bit(rb)
224
               ? REFERENCE_MODE_SELECT
225
               : (aom_rb_read_bit(rb) ? COMPOUND_REFERENCE : SINGLE_REFERENCE);
226 227 228 229
  } else {
    return SINGLE_REFERENCE;
  }
}
Jingning Han's avatar
Jingning Han committed
230

231
static void read_frame_reference_mode_probs(AV1_COMMON *cm, aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
232
  FRAME_CONTEXT *const fc = cm->fc;
233
  int i, j;
Jingning Han's avatar
Jingning Han committed
234 235 236

  if (cm->reference_mode == REFERENCE_MODE_SELECT)
    for (i = 0; i < COMP_INTER_CONTEXTS; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
237
      av1_diff_update_prob(r, &fc->comp_inter_prob[i], ACCT_STR);
Jingning Han's avatar
Jingning Han committed
238

239
  if (cm->reference_mode != COMPOUND_REFERENCE) {
Jingning Han's avatar
Jingning Han committed
240
    for (i = 0; i < REF_CONTEXTS; ++i) {
241
      for (j = 0; j < (SINGLE_REFS - 1); ++j) {
Michael Bebenita's avatar
Michael Bebenita committed
242
        av1_diff_update_prob(r, &fc->single_ref_prob[i][j], ACCT_STR);
243
      }
Jingning Han's avatar
Jingning Han committed
244
    }
245
  }
Jingning Han's avatar
Jingning Han committed
246

247 248
  if (cm->reference_mode != SINGLE_REFERENCE) {
    for (i = 0; i < REF_CONTEXTS; ++i) {
249
#if CONFIG_EXT_REFS
250
      for (j = 0; j < (FWD_REFS - 1); ++j)
Michael Bebenita's avatar
Michael Bebenita committed
251
        av1_diff_update_prob(r, &fc->comp_ref_prob[i][j], ACCT_STR);
252
      for (j = 0; j < (BWD_REFS - 1); ++j)
Michael Bebenita's avatar
Michael Bebenita committed
253
        av1_diff_update_prob(r, &fc->comp_bwdref_prob[i][j], ACCT_STR);
254 255
#else
      for (j = 0; j < (COMP_REFS - 1); ++j)
Michael Bebenita's avatar
Michael Bebenita committed
256
        av1_diff_update_prob(r, &fc->comp_ref_prob[i][j], ACCT_STR);
257
#endif  // CONFIG_EXT_REFS
258 259
    }
  }
Jingning Han's avatar
Jingning Han committed
260 261
}

262
static void update_mv_probs(aom_prob *p, int n, aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
263
  int i;
Michael Bebenita's avatar
Michael Bebenita committed
264
  for (i = 0; i < n; ++i) av1_diff_update_prob(r, &p[i], ACCT_STR);
Jingning Han's avatar
Jingning Han committed
265 266
}

267
static void read_mv_probs(nmv_context *ctx, int allow_hp, aom_reader *r) {
268
  int i;
Jingning Han's avatar
Jingning Han committed
269

Yaowu Xu's avatar
Yaowu Xu committed
270
#if !CONFIG_EC_ADAPT
271
  int j;
Jingning Han's avatar
Jingning Han committed
272 273 274 275 276 277 278 279 280 281 282
  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];
283
    for (j = 0; j < CLASS0_SIZE; ++j) {
Jingning Han's avatar
Jingning Han committed
284
      update_mv_probs(comp_ctx->class0_fp[j], MV_FP_SIZE - 1, r);
285
    }
286
    update_mv_probs(comp_ctx->fp, MV_FP_SIZE - 1, r);
Jingning Han's avatar
Jingning Han committed
287
  }
288
#endif  // !CONFIG_EC_ADAPT
Jingning Han's avatar
Jingning Han committed
289 290 291 292 293 294 295 296 297 298

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

299
static void inverse_transform_block(MACROBLOCKD *xd, int plane,
300
                                    const TX_TYPE tx_type,
301
                                    const TX_SIZE tx_size, uint8_t *dst,
302
                                    int stride, int16_t scan_line, int eob) {
Jingning Han's avatar
Jingning Han committed
303
  struct macroblockd_plane *const pd = &xd->plane[plane];
304 305 306 307 308 309
  tran_low_t *const dqcoeff = pd->dqcoeff;
  INV_TXFM_PARAM inv_txfm_param;
  inv_txfm_param.tx_type = tx_type;
  inv_txfm_param.tx_size = tx_size;
  inv_txfm_param.eob = eob;
  inv_txfm_param.lossless = xd->lossless[xd->mi[0]->mbmi.segment_id];
Angie Chiang's avatar
Angie Chiang committed
310

311
#if CONFIG_AOM_HIGHBITDEPTH
312 313 314 315
  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
    inv_txfm_param.bd = xd->bd;
    highbd_inv_txfm_add(dqcoeff, dst, stride, &inv_txfm_param);
  } else {
316
#endif  // CONFIG_AOM_HIGHBITDEPTH
317
    inv_txfm_add(dqcoeff, dst, stride, &inv_txfm_param);
318
#if CONFIG_AOM_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
319
  }
320 321
#endif  // CONFIG_AOM_HIGHBITDEPTH
  memset(dqcoeff, 0, (scan_line + 1) * sizeof(dqcoeff[0]));
Jingning Han's avatar
Jingning Han committed
322 323
}

324 325 326 327 328 329 330 331 332
#if CONFIG_PVQ
static int av1_pvq_decode_helper(od_dec_ctx *dec, int16_t *ref_coeff,
                                 int16_t *dqcoeff, int16_t *quant, int pli,
                                 int bs, TX_TYPE tx_type, int xdec,
                                 int ac_dc_coded) {
  unsigned int flags;  // used for daala's stream analyzer.
  int off;
  const int is_keyframe = 0;
  const int has_dc_skip = 1;
333
  int quant_shift = get_tx_scale(bs);
334 335 336 337 338 339
  // DC quantizer for PVQ
  int pvq_dc_quant;
  int lossless = (quant[0] == 0);
  const int blk_size = tx_size_wide[bs];
  int eob = 0;
  int i;
340
  int use_activity_masking = dec->use_activity_masking;
341 342
  DECLARE_ALIGNED(16, int16_t, dqcoeff_pvq[OD_TXSIZE_MAX * OD_TXSIZE_MAX]);
  DECLARE_ALIGNED(16, int16_t, ref_coeff_pvq[OD_TXSIZE_MAX * OD_TXSIZE_MAX]);
343

344 345
  od_coeff ref_int32[OD_TXSIZE_MAX * OD_TXSIZE_MAX];
  od_coeff out_int32[OD_TXSIZE_MAX * OD_TXSIZE_MAX];
346 347 348 349 350 351 352

  od_raster_to_coding_order(ref_coeff_pvq, blk_size, tx_type, ref_coeff,
                            blk_size);

  if (lossless)
    pvq_dc_quant = 1;
  else {
353 354 355 356 357 358 359
    if (use_activity_masking)
      pvq_dc_quant = OD_MAXI(
          1, (quant[0] >> quant_shift) *
                     dec->state.pvq_qm_q4[pli][od_qm_get_index(bs, 0)] >>
                 4);
    else
      pvq_dc_quant = OD_MAXI(1, quant[0] >> quant_shift);
360 361 362 363 364 365 366 367 368
  }

  off = od_qm_offset(bs, xdec);

  // copy int16 inputs to int32
  for (i = 0; i < blk_size * blk_size; i++) ref_int32[i] = ref_coeff_pvq[i];

  od_pvq_decode(dec, ref_int32, out_int32, (int)quant[1] >> quant_shift, pli,
                bs, OD_PVQ_BETA[use_activity_masking][pli][bs],
369 370
                OD_ROBUST_STREAM, is_keyframe, &flags, ac_dc_coded,
                dec->state.qm + off, dec->state.qm_inv + off);
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391

  // copy int32 result back to int16
  for (i = 0; i < blk_size * blk_size; i++) dqcoeff_pvq[i] = out_int32[i];

  if (!has_dc_skip || dqcoeff_pvq[0]) {
    dqcoeff_pvq[0] =
        has_dc_skip + generic_decode(dec->ec, &dec->state.adapt.model_dc[pli],
                                     -1, &dec->state.adapt.ex_dc[pli][bs][0], 2,
                                     "dc:mag");
    if (dqcoeff_pvq[0])
      dqcoeff_pvq[0] *= od_ec_dec_bits(dec->ec, 1, "dc:sign") ? -1 : 1;
  }
  dqcoeff_pvq[0] = dqcoeff_pvq[0] * pvq_dc_quant + ref_coeff_pvq[0];

  od_coding_order_to_raster(dqcoeff, blk_size, tx_type, dqcoeff_pvq, blk_size);

  eob = blk_size * blk_size;

  return eob;
}

392 393 394
static int av1_pvq_decode_helper2(MACROBLOCKD *const xd,
                                  MB_MODE_INFO *const mbmi, int plane, int row,
                                  int col, TX_SIZE tx_size, TX_TYPE tx_type) {
395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423
  struct macroblockd_plane *const pd = &xd->plane[plane];
  // transform block size in pixels
  int tx_blk_size = tx_size_wide[tx_size];
  int i, j;
  tran_low_t *pvq_ref_coeff = pd->pvq_ref_coeff;
  const int diff_stride = tx_blk_size;
  int16_t *pred = pd->pred;
  tran_low_t *const dqcoeff = pd->dqcoeff;
  int ac_dc_coded;  // bit0: DC coded, bit1 : AC coded
  uint8_t *dst;
  int eob;

  eob = 0;
  dst = &pd->dst.buf[4 * row * pd->dst.stride + 4 * col];

  // decode ac/dc coded flag. bit0: DC coded, bit1 : AC coded
  // NOTE : we don't use 5 symbols for luma here in aom codebase,
  // since block partition is taken care of by aom.
  // So, only AC/DC skip info is coded
  ac_dc_coded = od_decode_cdf_adapt(
      xd->daala_dec.ec,
      xd->daala_dec.state.adapt.skip_cdf[2 * tx_size + (plane != 0)], 4,
      xd->daala_dec.state.adapt.skip_increment, "skip");

  if (ac_dc_coded) {
    int xdec = pd->subsampling_x;
    int seg_id = mbmi->segment_id;
    int16_t *quant;
    FWD_TXFM_PARAM fwd_txfm_param;
424 425
    // ToDo(yaowu): correct this with optimal number from decoding process.
    const int max_scan_line = tx_size_2d[tx_size];
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

    for (j = 0; j < tx_blk_size; j++)
      for (i = 0; i < tx_blk_size; i++) {
        pred[diff_stride * j + i] = dst[pd->dst.stride * j + i];
      }

    fwd_txfm_param.tx_type = tx_type;
    fwd_txfm_param.tx_size = tx_size;
    fwd_txfm_param.fwd_txfm_opt = FWD_TXFM_OPT_NORMAL;
    fwd_txfm_param.rd_transform = 0;
    fwd_txfm_param.lossless = xd->lossless[seg_id];

    fwd_txfm(pred, pvq_ref_coeff, diff_stride, &fwd_txfm_param);

    quant = &pd->seg_dequant[seg_id][0];  // aom's quantizer

    eob = av1_pvq_decode_helper(&xd->daala_dec, pvq_ref_coeff, dqcoeff, quant,
                                plane, tx_size, tx_type, xdec, ac_dc_coded);

    // Since av1 does not have separate inverse transform
    // but also contains adding to predicted image,
    // pass blank dummy image to av1_inv_txfm_add_*x*(), i.e. set dst as zeros
    for (j = 0; j < tx_blk_size; j++)
      for (i = 0; i < tx_blk_size; i++) dst[j * pd->dst.stride + i] = 0;

451 452
    inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride,
                            max_scan_line, eob);
453 454 455 456 457 458
  }

  return eob;
}
#endif

Angie Chiang's avatar
Angie Chiang committed
459 460
static void predict_and_reconstruct_intra_block(AV1_COMMON *cm,
                                                MACROBLOCKD *const xd,
Alex Converse's avatar
Alex Converse committed
461 462 463
#if CONFIG_ANS
                                                struct AnsDecoder *const r,
#else
464
                                                aom_reader *r,
Alex Converse's avatar
Alex Converse committed
465
#endif  // CONFIG_ANS
Jingning Han's avatar
Jingning Han committed
466
                                                MB_MODE_INFO *const mbmi,
467
                                                int plane, int row, int col,
Jingning Han's avatar
Jingning Han committed
468 469 470
                                                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
471
  PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
Jingning Han's avatar
Jingning Han committed
472
  uint8_t *dst;
hui su's avatar
hui su committed
473
  int block_idx = (row << 1) + col;
474 475 476 477
#if CONFIG_PVQ
  (void)cm;
  (void)r;
#endif
478
  dst = &pd->dst.buf[(row * pd->dst.stride + col) << tx_size_wide_log2[0]];
Jingning Han's avatar
Jingning Han committed
479

480
#if !CONFIG_CB4X4
Jingning Han's avatar
Jingning Han committed
481
  if (mbmi->sb_type < BLOCK_8X8)
482
    if (plane == 0) mode = xd->mi[0]->bmi[(row << 1) + col].as_mode;
483
#endif
Jingning Han's avatar
Jingning Han committed
484

485
  av1_predict_intra_block(xd, pd->width, pd->height, tx_size, mode, dst,
486
                          pd->dst.stride, dst, pd->dst.stride, col, row, plane);
Jingning Han's avatar
Jingning Han committed
487 488

  if (!mbmi->skip) {
hui su's avatar
hui su committed
489
    TX_TYPE tx_type = get_tx_type(plane_type, xd, block_idx, tx_size);
490
#if !CONFIG_PVQ
Angie Chiang's avatar
Angie Chiang committed
491
    const SCAN_ORDER *scan_order = get_scan(cm, tx_size, tx_type, 0);
492 493 494 495
    int16_t max_scan_line = 0;
    const int eob =
        av1_decode_block_tokens(xd, plane, scan_order, col, row, tx_size,
                                tx_type, &max_scan_line, r, mbmi->segment_id);
Angie Chiang's avatar
Angie Chiang committed
496 497 498
#if CONFIG_ADAPT_SCAN
    av1_update_scan_count_facade(cm, tx_size, tx_type, pd->dqcoeff, eob);
#endif
499 500 501
    if (eob)
      inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride,
                              max_scan_line, eob);
502 503 504
#else
    av1_pvq_decode_helper2(xd, mbmi, plane, row, col, tx_size, tx_type);
#endif
Jingning Han's avatar
Jingning Han committed
505 506 507
  }
}

508
#if CONFIG_VAR_TX
Angie Chiang's avatar
Angie Chiang committed
509 510
static void decode_reconstruct_tx(AV1_COMMON *cm, MACROBLOCKD *const xd,
                                  aom_reader *r, MB_MODE_INFO *const mbmi,
511
                                  int plane, BLOCK_SIZE plane_bsize,
512 513
                                  int blk_row, int blk_col, TX_SIZE tx_size,
                                  int *eob_total) {
514
  const struct macroblockd_plane *const pd = &xd->plane[plane];
515
  const BLOCK_SIZE bsize = txsize_to_bsize[tx_size];
516 517
  const int tx_row = blk_row >> (1 - pd->subsampling_y);
  const int tx_col = blk_col >> (1 - pd->subsampling_x);
518
  const TX_SIZE plane_tx_size =
519
      plane ? uv_txsize_lookup[bsize][mbmi->inter_tx_size[tx_row][tx_col]][0][0]
520
            : mbmi->inter_tx_size[tx_row][tx_col];
521
  // Scale to match transform block unit.
522 523
  const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
  const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
524

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

527
  if (tx_size == plane_tx_size) {
528
    PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
529 530
    int block_idx = (blk_row << 1) + blk_col;
    TX_TYPE tx_type = get_tx_type(plane_type, xd, block_idx, plane_tx_size);
Angie Chiang's avatar
Angie Chiang committed
531
    const SCAN_ORDER *sc = get_scan(cm, plane_tx_size, tx_type, 1);
532
    int16_t max_scan_line = 0;
533
    const int eob =
534
        av1_decode_block_tokens(xd, plane, sc, blk_col, blk_row, plane_tx_size,
535
                                tx_type, &max_scan_line, r, mbmi->segment_id);
536 537
    inverse_transform_block(
        xd, plane, tx_type, plane_tx_size,
538
        &pd->dst.buf[4 * blk_row * pd->dst.stride + 4 * blk_col],
539
        pd->dst.stride, max_scan_line, eob);
540 541
    *eob_total += eob;
  } else {
542 543
    const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
    const int bsl = tx_size_wide_unit[sub_txs];
544 545 546 547 548
    int i;

    assert(bsl > 0);

    for (i = 0; i < 4; ++i) {
549 550
      const int offsetr = blk_row + (i >> 1) * bsl;
      const int offsetc = blk_col + (i & 0x01) * bsl;
551

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

554
      decode_reconstruct_tx(cm, xd, r, mbmi, plane, plane_bsize, offsetr,
555
                            offsetc, sub_txs, eob_total);
556 557 558
    }
  }
}
559
#endif  // CONFIG_VAR_TX
560

561 562
#if !CONFIG_VAR_TX || CONFIG_SUPERTX || \
    (!CONFIG_VAR_TX && CONFIG_EXT_TX && CONFIG_RECT_TX)
Angie Chiang's avatar
Angie Chiang committed
563
static int reconstruct_inter_block(AV1_COMMON *cm, MACROBLOCKD *const xd,
Alex Converse's avatar
Alex Converse committed
564 565 566
#if CONFIG_ANS
                                   struct AnsDecoder *const r,
#else
567
                                   aom_reader *r,
Alex Converse's avatar
Alex Converse committed
568
#endif
569 570
                                   int segment_id, int plane, int row, int col,
                                   TX_SIZE tx_size) {
hui su's avatar
hui su committed
571 572
  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
573
  TX_TYPE tx_type = get_tx_type(plane_type, xd, block_idx, tx_size);
574 575 576 577
#if CONFIG_PVQ
  int eob;
  (void)cm;
  (void)r;
578 579 580
  (void)segment_id;
#else
  struct macroblockd_plane *const pd = &xd->plane[plane];
581 582 583
#endif

#if !CONFIG_PVQ
Angie Chiang's avatar
Angie Chiang committed
584
  const SCAN_ORDER *scan_order = get_scan(cm, tx_size, tx_type, 1);
585 586 587 588
  int16_t max_scan_line = 0;
  const int eob =
      av1_decode_block_tokens(xd, plane, scan_order, col, row, tx_size, tx_type,
                              &max_scan_line, r, segment_id);
589 590
  uint8_t *dst =
      &pd->dst.buf[(row * pd->dst.stride + col) << tx_size_wide_log2[0]];
Angie Chiang's avatar
Angie Chiang committed
591 592 593
#if CONFIG_ADAPT_SCAN
  av1_update_scan_count_facade(cm, tx_size, tx_type, pd->dqcoeff, eob);
#endif
594
  if (eob)
595 596
    inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride,
                            max_scan_line, eob);
597
#else
598 599
  eob = av1_pvq_decode_helper2(xd, &xd->mi[0]->mbmi, plane, row, col, tx_size,
                               tx_type);
600
#endif
Jingning Han's avatar
Jingning Han committed
601 602
  return eob;
}
603
#endif  // !CONFIG_VAR_TX || CONFIG_SUPER_TX
Jingning Han's avatar
Jingning Han committed
604

605
static MB_MODE_INFO *set_offsets(AV1_COMMON *const cm, MACROBLOCKD *const xd,
Jingning Han's avatar
Jingning Han committed
606
                                 BLOCK_SIZE bsize, int mi_row, int mi_col,
Jingning Han's avatar
Jingning Han committed
607
                                 int bw, int bh, int x_mis, int y_mis) {
Jingning Han's avatar
Jingning Han committed
608 609 610 611 612 613 614 615 616
  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;
617 618 619 620
#if CONFIG_RD_DEBUG
  xd->mi[0]->mbmi.mi_row = mi_row;
  xd->mi[0]->mbmi.mi_col = mi_col;
#endif
Jingning Han's avatar
Jingning Han committed
621
  for (y = 0; y < y_mis; ++y)
Jingning Han's avatar
Jingning Han committed
622
    for (x = !y; x < x_mis; ++x) xd->mi[y * cm->mi_stride + x] = xd->mi[0];
Jingning Han's avatar
Jingning Han committed
623

Jingning Han's avatar
Jingning Han committed
624
  set_plane_n4(xd, bw, bh);
Jingning Han's avatar
Jingning Han committed
625 626
  set_skip_context(xd, mi_row, mi_col);

627 628 629 630
#if CONFIG_VAR_TX
  xd->max_tx_size = max_txsize_lookup[bsize];
#endif

Jingning Han's avatar
Jingning Han committed
631 632 633 634
  // 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);

635
  av1_setup_dst_planes(xd->plane, get_frame_new_buffer(cm), mi_row, mi_col);
Jingning Han's avatar
Jingning Han committed
636 637 638
  return &xd->mi[0]->mbmi;
}

639
#if CONFIG_SUPERTX
640
static MB_MODE_INFO *set_offsets_extend(AV1_COMMON *const cm,
641 642
                                        MACROBLOCKD *const xd,
                                        const TileInfo *const tile,
643 644 645
                                        BLOCK_SIZE bsize_pred, int mi_row_pred,
                                        int mi_col_pred, int mi_row_ori,
                                        int mi_col_ori) {
646 647 648
  // Used in supertx
  // (mi_row_ori, mi_col_ori): location for mv
  // (mi_row_pred, mi_col_pred, bsize_pred): region to predict
649 650
  const int bw = mi_size_wide[bsize_pred];
  const int bh = mi_size_high[bsize_pred];
651 652 653
  const int offset = mi_row_ori * cm->mi_stride + mi_col_ori;
  xd->mi = cm->mi_grid_visible + offset;
  xd->mi[0] = cm->mi + offset;
654 655
  set_mi_row_col(xd, tile, mi_row_pred, bh, mi_col_pred, bw, cm->mi_rows,
                 cm->mi_cols);
656

657 658
  xd->up_available = (mi_row_ori > tile->mi_row_start);
  xd->left_available = (mi_col_ori > tile->mi_col_start);
659

Jingning Han's avatar
Jingning Han committed
660
  set_plane_n4(xd, bw, bh);
661 662 663 664

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

665 666 667
static MB_MODE_INFO *set_mb_offsets(AV1_COMMON *const cm, MACROBLOCKD *const xd,
                                    BLOCK_SIZE bsize, int mi_row, int mi_col,
                                    int bw, int bh, int x_mis, int y_mis) {
668 669 670 671 672 673 674 675
  const int offset = mi_row * cm->mi_stride + mi_col;
  const TileInfo *const tile = &xd->tile;
  int x, y;

  xd->mi = cm->mi_grid_visible + offset;
  xd->mi[0] = cm->mi + offset;
  xd->mi[0]->mbmi.sb_type = bsize;
  for (y = 0; y < y_mis; ++y)
676
    for (x = !y; x < x_mis; ++x) xd->mi[y * cm->mi_stride + x] = xd->mi[0];
677 678 679 680 681

  set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, cm->mi_rows, cm->mi_cols);
  return &xd->mi[0]->mbmi;
}

682
static void set_offsets_topblock(AV1_COMMON *const cm, MACROBLOCKD *const xd,
683 684
                                 const TileInfo *const tile, BLOCK_SIZE bsize,
                                 int mi_row, int mi_col) {
685 686
  const int bw = mi_size_wide[bsize];
  const int bh = mi_size_high[bsize];
687 688 689 690 691
  const int offset = mi_row * cm->mi_stride + mi_col;

  xd->mi = cm->mi_grid_visible + offset;
  xd->mi[0] = cm->mi + offset;

Jingning Han's avatar
Jingning Han committed
692
  set_plane_n4(xd, bw, bh);
693 694 695

  set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, cm->mi_rows, cm->mi_cols);

696
  av1_setup_dst_planes(xd->plane, get_frame_new_buffer(cm), mi_row, mi_col);
697 698
}

699
static void set_param_topblock(AV1_COMMON *const cm, MACROBLOCKD *const xd,
700
                               BLOCK_SIZE bsize, int mi_row, int mi_col,
701
                               int txfm, int skip) {
702 703
  const int bw = mi_size_wide[bsize];
  const int bh = mi_size_high[bsize];
704 705
  const int x_mis = AOMMIN(bw, cm->mi_cols - mi_col);
  const int y_mis = AOMMIN(bh, cm->mi_rows - mi_row);
706 707 708 709 710 711 712 713 714 715 716
  const int offset = mi_row * cm->mi_stride + mi_col;
  int x, y;

  xd->mi = cm->mi_grid_visible + offset;
  xd->mi[0] = cm->mi + offset;

  for (y = 0; y < y_mis; ++y)
    for (x = 0; x < x_mis; ++x) {
      xd->mi[y * cm->mi_stride + x]->mbmi.skip = skip;
      xd->mi[y * cm->mi_stride + x]->mbmi.tx_type = txfm;
    }
717 718
#if CONFIG_VAR_TX
  xd->above_txfm_context = cm->above_txfm_context + mi_col;
719
  xd->left_txfm_context =
720
      xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK);
721
  set_txfm_ctxs(xd->mi[0]->mbmi.tx_size, bw, bh, skip, xd);
722
#endif
723 724
}

725
static void set_ref(AV1_COMMON *const cm, MACROBLOCKD *const xd, int idx,
726
                    int mi_row, int mi_col) {
727 728 729
  MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
  RefBuffer *ref_buffer = &cm->frame_refs[mbmi->ref_frame[idx] - LAST_FRAME];
  xd->block_refs[idx] = ref_buffer;
730 731
  if (!av1_is_valid_scale(&ref_buffer->sf))
    aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
732
                       "Invalid scale factors");
733 734
  av1_setup_pre_planes(xd, idx, ref_buffer->buf, mi_row, mi_col,
                       &ref_buffer->sf);
735 736 737 738
  xd->corrupted |= ref_buffer->buf->corrupted;
}

static void dec_predict_b_extend(
739
    AV1Decoder *const pbi, MACROBLOCKD *const xd, const TileInfo *const tile,
740 741 742
    int block, int mi_row_ori, int mi_col_ori, int mi_row_pred, int mi_col_pred,
    int mi_row_top, int mi_col_top, uint8_t *dst_buf[3], int dst_stride[3],
    BLOCK_SIZE bsize_top, BLOCK_SIZE bsize_pred, int b_sub8x8, int bextend) {
743 744 745 746 747 748 749 750 751
  // Used in supertx
  // (mi_row_ori, mi_col_ori): location for mv
  // (mi_row_pred, mi_col_pred, bsize_pred): region to predict
  // (mi_row_top, mi_col_top, bsize_top): region of the top partition size
  // block: sub location of sub8x8 blocks
  // b_sub8x8: 1: ori is sub8x8; 0: ori is not sub8x8
  // bextend: 1: region to predict is an extension of ori; 0: not
  int r = (mi_row_pred - mi_row_top) * MI_SIZE;
  int c = (mi_col_pred - mi_col_top) * MI_SIZE;
752 753
  const int mi_width_top = mi_size_wide[bsize_top];
  const int mi_height_top = mi_size_high[bsize_top];
754
  MB_MODE_INFO *mbmi;
755
  AV1_COMMON *const cm = &pbi->common;
756 757 758

  if (mi_row_pred < mi_row_top || mi_col_pred < mi_col_top ||
      mi_row_pred >= mi_row_top + mi_height_top ||
759 760
      mi_col_pred >= mi_col_top + mi_width_top || mi_row_pred >= cm->mi_rows ||
      mi_col_pred >= cm->mi_cols)
761 762
    return;

763
  mbmi = set_offsets_extend(cm, xd, tile, bsize_pred, mi_row_pred, mi_col_pred,
764 765 766 767 768 769 770
                            mi_row_ori, mi_col_ori);
  set_ref(cm, xd, 0, mi_row_pred, mi_col_pred);
  if (has_second_ref(&xd->mi[0]->mbmi))
    set_ref(cm, xd, 1, mi_row_pred, mi_col_pred);

  if (!bextend) {
    mbmi->tx_size = b_width_log2_lookup[bsize_top];
771 772 773
#if CONFIG_CB4X4
    ++mbmi->tx_size;
#endif
774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789
  }

  xd->plane[0].dst.stride = dst_stride[0];
  xd->plane[1].dst.stride = dst_stride[1];
  xd->plane[2].dst.stride = dst_stride[2];
  xd->plane[0].dst.buf = dst_buf[0] +
                         (r >> xd->plane[0].subsampling_y) * dst_stride[0] +
                         (c >> xd->plane[0].subsampling_x);
  xd->plane[1].dst.buf = dst_buf[1] +
                         (r >> xd->plane[1].subsampling_y) * dst_stride[1] +
                         (c >> xd->plane[1].subsampling_x);
  xd->plane[2].dst.buf = dst_buf[2] +
                         (r >> xd->plane[2].subsampling_y) * dst_stride[2] +
                         (c >> xd->plane[2].subsampling_x);

  if (!b_sub8x8)
790
    av1_build_inter_predictors_sb_extend(xd,
791
#if CONFIG_EXT_INTER
792
                                         mi_row_ori, mi_col_ori,
793
#endif  // CONFIG_EXT_INTER
794
                                         mi_row_pred, mi_col_pred, bsize_pred);
795
  else
796
    av1_build_inter_predictors_sb_sub8x8_extend(xd,
797
#if CONFIG_EXT_INTER
798
                                                mi_row_ori, mi_col_ori,
799
#endif  // CONFIG_EXT_INTER
800 801
                                                mi_row_pred, mi_col_pred,
                                                bsize_pred, block);
802 803
}

804
static void dec_extend_dir(AV1Decoder *const pbi, MACROBLOCKD *const xd,
805
                           const TileInfo *const tile, int block,
806 807 808
                           BLOCK_SIZE bsize, BLOCK_SIZE top_bsize, int mi_row,
                           int mi_col, int mi_row_top, int mi_col_top,
                           uint8_t *dst_buf[3], int dst_stride[3], int dir) {
809 810
  // dir: 0-lower, 1-upper, 2-left, 3-right
  //      4-lowerleft, 5-upperleft, 6-lowerright, 7-upperright
811 812
  const int mi_width = mi_size_wide[bsize];
  const int mi_height = mi_size_high[bsize];
813 814
  int xss = xd->plane[1].subsampling_x;
  int yss = xd->plane[1].subsampling_y;
815 816 817 818 819 820
#if CONFIG_CB4X4
  const int unify_bsize = 1;
#else
  const int unify_bsize = 0;
#endif
  int b_sub8x8 = (bsize < BLOCK_8X8) && !unify_bsize ? 1 : 0;
821 822 823 824
  BLOCK_SIZE extend_bsize;
  int unit, mi_row_pred, mi_col_pred;

  if (dir == 0 || dir == 1) {
825 826 827 828 829 830
    extend_bsize =
        (mi_width == mi_size_wide[BLOCK_8X8] || bsize < BLOCK_8X8 || xss < yss)
            ? BLOCK_8X8
            : BLOCK_16X8;
    unit = mi_size_wide[extend_bsize];
    mi_row_pred = mi_row + ((dir == 0) ? mi_height : -mi_size_high[BLOCK_8X8]);
831 832
    mi_col_pred = mi_col;

833 834 835
    dec_predict_b_extend(pbi, xd, tile, block, mi_row, mi_col, mi_row_pred,
                         mi_col_pred, mi_row_top, mi_col_top, dst_buf,
                         dst_stride, top_bsize, extend_bsize, b_sub8x8, 1);
836 837 838 839

    if (mi_width > unit) {
      int i;
      assert(!b_sub8x8);
840
      for (i = 0; i < mi_width; i += unit) {
841
        mi_col_pred += unit;
842 843 844
        dec_predict_b_extend(pbi, xd, tile, block, mi_row, mi_col, mi_row_pred,
                             mi_col_pred, mi_row_top, mi_col_top, dst_buf,
                             dst_stride, top_bsize, extend_bsize, b_sub8x8, 1);
845 846 847
      }
    }
  } else if (dir == 2 || dir == 3) {
Jingning Han's avatar
Jingning Han committed
848 849 850 851 852
    extend_bsize =
        (mi_height == mi_size_high[BLOCK_8X8] || bsize < BLOCK_8X8 || yss < xss)
            ? BLOCK_8X8
            : BLOCK_8X16;
    unit = mi_size_high[extend_bsize];
853
    mi_row_pred = mi_row;
Jingning Han's avatar
Jingning Han committed
854
    mi_col_pred = mi_col + ((dir == 3) ? mi_width : -mi_size_wide[BLOCK_8X8]);
855

856 857 858
    dec_predict_b_extend(pbi, xd, tile, block, mi_row, mi_col, mi_row_pred,
                         mi_col_pred, mi_row_top, mi_col_top, dst_buf,
                         dst_stride, top_bsize, extend_bsize, b_sub8x8, 1);
859 860 861

    if (mi_height > unit) {
      int i;
862
      for (i = 0; i < mi_height; i += unit) {
863
        mi_row_pred += unit;
864 865 866
        dec_predict_b_extend(pbi, xd, tile, block, mi_row, mi_col, mi_row_pred,
                             mi_col_pred, mi_row_top, mi_col_top, dst_buf,
                             dst_stride, top_bsize, extend_bsize, b_sub8x8, 1);
867 868 869 870
      }
    }
  } else {
    extend_bsize = BLOCK_8X8;
Jingning Han's avatar
Jingning Han committed
871 872 873 874
    mi_row_pred = mi_row + ((dir == 4 || dir == 6) ? mi_height
                                                   : -mi_size_high[BLOCK_8X8]);
    mi_col_pred =
        mi_col + ((dir == 6 || dir == 7) ? mi_width : -mi_size_wide[BLOCK_8X8]);
875 876 877
    dec_predict_b_extend(pbi, xd, tile, block, mi_row, mi_col, mi_row_pred,
                         mi_col_pred, mi_row_top, mi_col_top, dst_buf,
                         dst_stride, top_bsize, extend_bsize, b_sub8x8, 1);
878 879 880
  }
}

881
static void dec_extend_all(AV1Decoder *const pbi, MACROBLOCKD *const xd,
882
                           const TileInfo *const tile, int block,
883 884 885
                           BLOCK_SIZE bsize, BLOCK_SIZE top_bsize, int mi_row,
                           int mi_col, int mi_row_top, int mi_col_top,
                           uint8_t *dst_buf[3], int dst_stride[3]) {
886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903
  dec_extend_dir(pbi, xd, tile, block, bsize, top_bsize, mi_row, mi_col,
                 mi_row_top, mi_col_top, dst_buf, dst_stride, 0);
  dec_extend_dir(pbi, xd, tile, block, bsize, top_bsize, mi_row, mi_col,
                 mi_row_top, mi_col_top, dst_buf, dst_stride, 1);
  dec_extend_dir(pbi, xd, tile, block, bsize, top_bsize, mi_row, mi_col,
                 mi_row_top, mi_col_top, dst_buf, dst_stride, 2);
  dec_extend_dir(pbi, xd, tile, block, bsize, top_bsize, mi_row, mi_col,
                 mi_row_top, mi_col_top, dst_buf, dst_stride, 3);
  dec_extend_dir(pbi, xd, tile, block, bsize, top_bsize, mi_row, mi_col,
                 mi_row_top, mi_col_top, dst_buf, dst_stride, 4);
  dec_extend_dir(pbi, xd, tile, block, bsize, top_bsize, mi_row, mi_col,
                 mi_row_top, mi_col_top, dst_buf, dst_stride, 5);
  dec_extend_dir(pbi, xd, tile, block, bsize, top_bsize, mi_row, mi_col,
                 mi_row_top, mi_col_top, dst_buf, dst_stride, 6);
  dec_extend_dir(pbi, xd, tile, block, bsize, top_bsize, mi_row, mi_col,
                 mi_row_top, mi_col_top, dst_buf, dst_stride, 7);
}

904
static void dec_predict_sb_complex(AV1Decoder *const pbi, MACROBLOCKD *const xd,
905 906
                                   const TileInfo *const tile, int mi_row,
                                   int mi_col, int mi_row_top, int mi_col_top,
907 908
                                   BLOCK_SIZE bsize, BLOCK_SIZE top_bsize,
                                   uint8_t *dst_buf[3], int dst_stride[3]) {
909
  const AV1_COMMON *const cm = &pbi->common;
Jingning Han's avatar
Jingning Han committed
910
  const int hbs = mi_size_wide[bsize] / 2;
911 912
  const PARTITION_TYPE partition = get_partition(cm, mi_row, mi_col, bsize);
  const BLOCK_SIZE subsize = get_subsize(bsize, partition);
913
#if CONFIG_EXT_PARTITION_TYPES
914
  const BLOCK_SIZE bsize2 = get_subsize(bsize, PARTITION_SPLIT);
915
#endif
916 917
  int i;
  const int mi_offset = mi_row * cm->mi_stride + mi_col;
918
  uint8_t *dst_buf1[3], *dst_buf2[3], *dst_buf3[3];
919 920 921 922 923
#if CONFIG_CB4X4
  const int unify_bsize = 1;
#else
  const int unify_bsize = 0;
#endif
924

925 926 927 928 929 930
  DECLARE_ALIGNED(16, uint8_t, tmp_buf1[MAX_MB_PLANE * MAX_TX_SQUARE * 2]);
  DECLARE_ALIGNED(16, uint8_t, tmp_buf2[MAX_MB_PLANE * MAX_TX_SQUARE * 2]);
  DECLARE_ALIGNED(16, uint8_t, tmp_buf3[MAX_MB_PLANE * MAX_TX_SQUARE * 2]);
  int dst_stride1[3] = { MAX_TX_SIZE, MAX_TX_SIZE, MAX_TX_SIZE };
  int dst_stride2[3] = { MAX_TX_SIZE, MAX_TX_SIZE, MAX_TX_SIZE };
  int dst_stride3[3] = { MAX_TX_SIZE, MAX_TX_SIZE, MAX_TX_SIZE };
931

932
#if CONFIG_AOM_HIGHBITDEPTH
933 934 935
  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
    int len = sizeof(uint16_t);
    dst_buf1[0] = CONVERT_TO_BYTEPTR(tmp_buf1);
936 937
    dst_buf1[1] = CONVERT_TO_BYTEPTR(tmp_buf1 + MAX_TX_SQUARE * len);
    dst_buf1[2] = CONVERT_TO_BYTEPTR(tmp_buf1 + 2 * MAX_TX_SQUARE * len);
938
    dst_buf2[0] = CONVERT_TO_BYTEPTR(tmp_buf2);
939 940
    dst_buf2[1] = CONVERT_TO_BYTEPTR(tmp_buf2 + MAX_TX_SQUARE * len);
    dst_buf2[2] = CONVERT_TO_BYTEPTR(tmp_buf2 + 2 * MAX_TX_SQUARE * len);
941
    dst_buf3[0] = CONVERT_TO_BYTEPTR(tmp_buf3);
942 943
    dst_buf3[1] = CONVERT_TO_BYTEPTR(tmp_buf3 + MAX_TX_SQUARE * len);
    dst_buf3[2] = CONVERT_TO_BYTEPTR(tmp_buf3 + 2 * MAX_TX_SQUARE * len);
944 945 946
  } else {
#endif
    dst_buf1[0] = tmp_buf1;
947 948
    dst_buf1[1] = tmp_buf1 + MAX_TX_SQUARE;
    dst_buf1[2] = tmp_buf1 + 2 * MAX_TX_SQUARE;
949
    dst_buf2[0] = tmp_buf2;
950 951
    dst_buf2[1] = tmp_buf2 + MAX_TX_SQUARE;
    dst_buf2[2] = tmp_buf2 + 2 * MAX_TX_SQUARE;
952
    dst_buf3[0] = tmp_buf3;
953 954
    dst_buf3[1] = tmp_buf3 + MAX_TX_SQUARE;
    dst_buf3[2] = tmp_buf3 + 2 * MAX_TX_SQUARE;
955
#if CONFIG_AOM_HIGHBITDEPTH
956 957 958
  }
#endif

959
  if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols) return;
960

961 962
  xd->mi = cm->mi_grid_visible + mi_offset;
  xd->mi[0] = cm->mi + mi_offset;
963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978

  for (i = 0; i < MAX_MB_PLANE; i++) {
    xd->plane[i].dst.buf = dst_buf[i];
    xd->plane[i].dst.stride = dst_stride[i];
  }

  switch (partition) {
    case PARTITION_NONE:
      assert(bsize < top_bsize);
      dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col, mi_row, mi_col,
                           mi_row_top, mi_col_top, dst_buf, dst_stride,
                           top_bsize, bsize, 0, 0);
      dec_extend_all(pbi, xd, tile, 0, bsize, top_bsize, mi_row, mi_col,
                     mi_row_top, mi_col_top, dst_buf, dst_stride);
      break;
    case PARTITION_HORZ:
979
      if (bsize == BLOCK_8X8 && !