decodeframe.c 205 KB
Newer Older
Jingning Han's avatar
Jingning Han committed
1
/*
Yaowu Xu's avatar
Yaowu Xu committed
2
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
Jingning Han's avatar
Jingning Han committed
3
 *
Yaowu Xu's avatar
Yaowu Xu committed
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()

Yaowu Xu's avatar
Yaowu Xu committed
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"
Yaowu Xu's avatar
Yaowu Xu committed
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_dsp/binary_codes_reader.h"
Yaowu Xu's avatar
Yaowu Xu committed
25
#include "aom_mem/aom_mem.h"
26
27
#include "aom_ports/mem.h"
#include "aom_ports/mem_ops.h"
Yaowu Xu's avatar
Yaowu Xu committed
28
29
#include "aom_scale/aom_scale.h"
#include "aom_util/aom_thread.h"
Jingning Han's avatar
Jingning Han committed
30

31
32
33
34
#if CONFIG_BITSTREAM_DEBUG
#include "aom_util/debug_util.h"
#endif  // CONFIG_BITSTREAM_DEBUG

35
#include "av1/common/alloccommon.h"
36
#if CONFIG_CDEF
37
#include "av1/common/cdef.h"
38
#endif
39
40
41
#if CONFIG_INSPECTION
#include "av1/decoder/inspection.h"
#endif
42
43
44
#include "av1/common/common.h"
#include "av1/common/entropy.h"
#include "av1/common/entropymode.h"
45
#include "av1/common/entropymv.h"
46
#include "av1/common/idct.h"
47
#include "av1/common/mvref_common.h"
48
49
50
#include "av1/common/pred_common.h"
#include "av1/common/quant_common.h"
#include "av1/common/reconinter.h"
Jingning Han's avatar
Jingning Han committed
51
#include "av1/common/reconintra.h"
52
53
54
#if CONFIG_FRAME_SUPERRES
#include "av1/common/resize.h"
#endif  // CONFIG_FRAME_SUPERRES
55
#include "av1/common/seg_common.h"
Jingning Han's avatar
Jingning Han committed
56
#include "av1/common/thread_common.h"
57
#include "av1/common/tile_common.h"
58

59
60
61
#include "av1/decoder/decodeframe.h"
#include "av1/decoder/decodemv.h"
#include "av1/decoder/decoder.h"
Angie Chiang's avatar
Angie Chiang committed
62
63
64
#if CONFIG_LV_MAP
#include "av1/decoder/decodetxb.h"
#endif
Jingning Han's avatar
Jingning Han committed
65
#include "av1/decoder/detokenize.h"
66
#include "av1/decoder/dsubexp.h"
Jingning Han's avatar
Jingning Han committed
67

68
#if CONFIG_WARPED_MOTION || CONFIG_GLOBAL_MOTION
Yue Chen's avatar
Yue Chen committed
69
#include "av1/common/warped_motion.h"
70
#endif  // CONFIG_WARPED_MOTION || CONFIG_GLOBAL_MOTION
Yue Chen's avatar
Yue Chen committed
71

Yaowu Xu's avatar
Yaowu Xu committed
72
#define MAX_AV1_HEADER_SIZE 80
Michael Bebenita's avatar
Michael Bebenita committed
73
#define ACCT_STR __func__
Jingning Han's avatar
Jingning Han committed
74

75
76
#if CONFIG_PVQ
#include "av1/common/partition.h"
hui su's avatar
hui su committed
77
78
#include "av1/common/pvq.h"
#include "av1/common/scan.h"
79
#include "av1/decoder/decint.h"
hui su's avatar
hui su committed
80
81
#include "av1/decoder/pvq_decoder.h"
#include "av1/encoder/encodemb.h"
82
83
84
#include "av1/encoder/hybrid_fwd_txfm.h"
#endif

85
86
87
88
#if CONFIG_CFL
#include "av1/common/cfl.h"
#endif

89
90
91
92
93
94
95
#if CONFIG_LOOP_RESTORATION
static void loop_restoration_read_sb_coeffs(const AV1_COMMON *const cm,
                                            MACROBLOCKD *xd,
                                            aom_reader *const r, int plane,
                                            int rtile_idx);
#endif

96
97
98
99
100
101
102
103
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);

Yaowu Xu's avatar
Yaowu Xu committed
104
static int is_compound_reference_allowed(const AV1_COMMON *cm) {
105
#if CONFIG_ONE_SIDED_COMPOUND  // Normative in decoder
106
107
  return !frame_is_intra_only(cm);
#else
Jingning Han's avatar
Jingning Han committed
108
  int i;
109
  if (frame_is_intra_only(cm)) return 0;
110
  for (i = 1; i < INTER_REFS_PER_FRAME; ++i)
111
    if (cm->ref_frame_sign_bias[i + 1] != cm->ref_frame_sign_bias[1]) return 1;
Jingning Han's avatar
Jingning Han committed
112
113

  return 0;
114
#endif  // CONFIG_ONE_SIDED_COMPOUND
Jingning Han's avatar
Jingning Han committed
115
116
}

Yaowu Xu's avatar
Yaowu Xu committed
117
static void setup_compound_reference_mode(AV1_COMMON *cm) {
118
#if CONFIG_EXT_REFS
119
  cm->comp_fwd_ref[0] = LAST_FRAME;
120
121
122
123
  cm->comp_fwd_ref[1] = LAST2_FRAME;
  cm->comp_fwd_ref[2] = LAST3_FRAME;
  cm->comp_fwd_ref[3] = GOLDEN_FRAME;

124
  cm->comp_bwd_ref[0] = BWDREF_FRAME;
Zoe Liu's avatar
Zoe Liu committed
125
126
127
  cm->comp_bwd_ref[1] = ALTREF2_FRAME;
  cm->comp_bwd_ref[2] = ALTREF_FRAME;
#else   // !CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
128
  if (cm->ref_frame_sign_bias[LAST_FRAME] ==
129
      cm->ref_frame_sign_bias[GOLDEN_FRAME]) {
Jingning Han's avatar
Jingning Han committed
130
131
132
133
    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] ==
134
             cm->ref_frame_sign_bias[ALTREF_FRAME]) {
Jingning Han's avatar
Jingning Han committed
135
136
137
138
139
140
141
142
    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;
  }
143
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
144
145
146
147
148
149
}

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

Yaowu Xu's avatar
Yaowu Xu committed
150
151
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
152
153
154
  return data > max ? max : data;
}

155
static TX_MODE read_tx_mode(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
156
#if CONFIG_TX64X64
157
158
  TX_MODE tx_mode;
#endif
159
  if (cm->all_lossless) return ONLY_4X4;
160
161
162
163
#if CONFIG_VAR_TX_NO_TX_MODE
  (void)rb;
  return TX_MODE_SELECT;
#else
164
165
#if CONFIG_TX64X64
  tx_mode = aom_rb_read_bit(rb) ? TX_MODE_SELECT : aom_rb_read_literal(rb, 2);
166
167
168
  if (tx_mode == ALLOW_32X32) tx_mode += aom_rb_read_bit(rb);
  return tx_mode;
#else
Yaowu Xu's avatar
Yaowu Xu committed
169
  return aom_rb_read_bit(rb) ? TX_MODE_SELECT : aom_rb_read_literal(rb, 2);
170
#endif  // CONFIG_TX64X64
171
#endif  // CONFIG_VAR_TX_NO_TX_MODE
172
}
Jingning Han's avatar
Jingning Han committed
173

174
#if !CONFIG_NEW_MULTISYMBOL
Yaowu Xu's avatar
Yaowu Xu committed
175
static void read_inter_mode_probs(FRAME_CONTEXT *fc, aom_reader *r) {
176
  int i;
177
  for (i = 0; i < NEWMV_MODE_CONTEXTS; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
178
    av1_diff_update_prob(r, &fc->newmv_prob[i], ACCT_STR);
179
  for (i = 0; i < ZEROMV_MODE_CONTEXTS; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
180
    av1_diff_update_prob(r, &fc->zeromv_prob[i], ACCT_STR);
181
  for (i = 0; i < REFMV_MODE_CONTEXTS; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
182
    av1_diff_update_prob(r, &fc->refmv_prob[i], ACCT_STR);
183
  for (i = 0; i < DRL_MODE_CONTEXTS; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
184
    av1_diff_update_prob(r, &fc->drl_prob[i], ACCT_STR);
Jingning Han's avatar
Jingning Han committed
185
}
186
#endif
Jingning Han's avatar
Jingning Han committed
187

188
static REFERENCE_MODE read_frame_reference_mode(
Yaowu Xu's avatar
Yaowu Xu committed
189
    const AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
190
  if (is_compound_reference_allowed(cm)) {
Zoe Liu's avatar
Zoe Liu committed
191
192
193
#if CONFIG_REF_ADAPT
    return aom_rb_read_bit(rb) ? REFERENCE_MODE_SELECT : SINGLE_REFERENCE;
#else
Yaowu Xu's avatar
Yaowu Xu committed
194
    return aom_rb_read_bit(rb)
195
               ? REFERENCE_MODE_SELECT
Yaowu Xu's avatar
Yaowu Xu committed
196
               : (aom_rb_read_bit(rb) ? COMPOUND_REFERENCE : SINGLE_REFERENCE);
Zoe Liu's avatar
Zoe Liu committed
197
#endif  // CONFIG_REF_ADAPT
198
199
200
201
  } else {
    return SINGLE_REFERENCE;
  }
}
Jingning Han's avatar
Jingning Han committed
202

Yaowu Xu's avatar
Yaowu Xu committed
203
static void read_frame_reference_mode_probs(AV1_COMMON *cm, aom_reader *r) {
204
205
206
#if CONFIG_NEW_MULTISYMBOL && !CONFIG_EXT_COMP_REFS
  (void)r;
#else
Jingning Han's avatar
Jingning Han committed
207
  FRAME_CONTEXT *const fc = cm->fc;
208
209
  int i;
#endif
Jingning Han's avatar
Jingning Han committed
210

211
#if !CONFIG_NEW_MULTISYMBOL
Jingning Han's avatar
Jingning Han committed
212
213
  if (cm->reference_mode == REFERENCE_MODE_SELECT)
    for (i = 0; i < COMP_INTER_CONTEXTS; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
214
      av1_diff_update_prob(r, &fc->comp_inter_prob[i], ACCT_STR);
Jingning Han's avatar
Jingning Han committed
215

216
  if (cm->reference_mode != COMPOUND_REFERENCE) {
Jingning Han's avatar
Jingning Han committed
217
    for (i = 0; i < REF_CONTEXTS; ++i) {
218
      int j;
219
      for (j = 0; j < (SINGLE_REFS - 1); ++j) {
Michael Bebenita's avatar
Michael Bebenita committed
220
        av1_diff_update_prob(r, &fc->single_ref_prob[i][j], ACCT_STR);
221
      }
Jingning Han's avatar
Jingning Han committed
222
    }
223
  }
224
#endif
Jingning Han's avatar
Jingning Han committed
225

226
  if (cm->reference_mode != SINGLE_REFERENCE) {
Zoe Liu's avatar
Zoe Liu committed
227
228
229
230
#if CONFIG_EXT_COMP_REFS
    for (i = 0; i < COMP_REF_TYPE_CONTEXTS; ++i)
      av1_diff_update_prob(r, &fc->comp_ref_type_prob[i], ACCT_STR);

231
232
    for (i = 0; i < UNI_COMP_REF_CONTEXTS; ++i) {
      int j;
Zoe Liu's avatar
Zoe Liu committed
233
234
      for (j = 0; j < (UNIDIR_COMP_REFS - 1); ++j)
        av1_diff_update_prob(r, &fc->uni_comp_ref_prob[i][j], ACCT_STR);
235
    }
Zoe Liu's avatar
Zoe Liu committed
236
237
#endif  // CONFIG_EXT_COMP_REFS

238
#if !CONFIG_NEW_MULTISYMBOL
239
    for (i = 0; i < REF_CONTEXTS; ++i) {
240
      int j;
241
#if CONFIG_EXT_REFS
242
      for (j = 0; j < (FWD_REFS - 1); ++j)
Michael Bebenita's avatar
Michael Bebenita committed
243
        av1_diff_update_prob(r, &fc->comp_ref_prob[i][j], ACCT_STR);
244
      for (j = 0; j < (BWD_REFS - 1); ++j)
Michael Bebenita's avatar
Michael Bebenita committed
245
        av1_diff_update_prob(r, &fc->comp_bwdref_prob[i][j], ACCT_STR);
246
247
#else
      for (j = 0; j < (COMP_REFS - 1); ++j)
Michael Bebenita's avatar
Michael Bebenita committed
248
        av1_diff_update_prob(r, &fc->comp_ref_prob[i][j], ACCT_STR);
249
#endif  // CONFIG_EXT_REFS
250
    }
251
#endif  // CONFIG_NEW_MULTISYMBOL
252
  }
Jingning Han's avatar
Jingning Han committed
253
254
}

255
#if !CONFIG_NEW_MULTISYMBOL
Yaowu Xu's avatar
Yaowu Xu committed
256
static void update_mv_probs(aom_prob *p, int n, aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
257
  int i;
Michael Bebenita's avatar
Michael Bebenita committed
258
  for (i = 0; i < n; ++i) av1_diff_update_prob(r, &p[i], ACCT_STR);
Jingning Han's avatar
Jingning Han committed
259
260
}

Yaowu Xu's avatar
Yaowu Xu committed
261
static void read_mv_probs(nmv_context *ctx, int allow_hp, aom_reader *r) {
262
  int i;
Jingning Han's avatar
Jingning Han committed
263
264
265
266
267
268
269
270
  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);
    }
  }
}
271
#endif
Jingning Han's avatar
Jingning Han committed
272

273
static void inverse_transform_block(MACROBLOCKD *xd, int plane,
Lester Lu's avatar
Lester Lu committed
274
275
276
#if CONFIG_LGT
                                    PREDICTION_MODE mode,
#endif
277
                                    const TX_TYPE tx_type,
278
                                    const TX_SIZE tx_size, uint8_t *dst,
279
                                    int stride, int16_t scan_line, int eob) {
Jingning Han's avatar
Jingning Han committed
280
  struct macroblockd_plane *const pd = &xd->plane[plane];
281
  tran_low_t *const dqcoeff = pd->dqcoeff;
Lester Lu's avatar
Lester Lu committed
282
283
284
285
286
  av1_inverse_transform_block(xd, dqcoeff,
#if CONFIG_LGT
                              mode,
#endif
                              tx_type, tx_size, dst, stride, eob);
287
  memset(dqcoeff, 0, (scan_line + 1) * sizeof(dqcoeff[0]));
Jingning Han's avatar
Jingning Han committed
288
289
}

290
291
292
293
294
295
296
297
298
299
300
301
302
static int get_block_idx(const MACROBLOCKD *xd, int plane, int row, int col) {
  const int bsize = xd->mi[0]->mbmi.sb_type;
  const struct macroblockd_plane *pd = &xd->plane[plane];
#if CONFIG_CHROMA_SUB8X8
  const BLOCK_SIZE plane_bsize =
      AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
#elif CONFIG_CB4X4
  const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
#else
  const BLOCK_SIZE plane_bsize =
      get_plane_block_size(AOMMAX(BLOCK_8X8, bsize), pd);
#endif
  const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
303
  const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
304
305
306
307
  const uint8_t txh_unit = tx_size_high_unit[tx_size];
  return row * max_blocks_wide + col * txh_unit;
}

308
#if CONFIG_PVQ
Thomas Daede's avatar
Thomas Daede committed
309
static int av1_pvq_decode_helper(MACROBLOCKD *xd, tran_low_t *ref_coeff,
310
                                 tran_low_t *dqcoeff, int16_t *quant, int pli,
311
                                 int bs, TX_TYPE tx_type, int xdec,
ltrudeau's avatar
ltrudeau committed
312
                                 PVQ_SKIP_TYPE ac_dc_coded) {
313
314
315
316
  unsigned int flags;  // used for daala's stream analyzer.
  int off;
  const int is_keyframe = 0;
  const int has_dc_skip = 1;
317
  int coeff_shift = 3 - av1_get_tx_scale(bs);
Thomas Daede's avatar
Thomas Daede committed
318
  int hbd_downshift = 0;
319
  int rounding_mask;
320
321
322
323
324
325
  // 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;
Thomas Daede's avatar
Thomas Daede committed
326
  od_dec_ctx *dec = &xd->daala_dec;
327
  int use_activity_masking = dec->use_activity_masking;
328
329
  DECLARE_ALIGNED(16, tran_low_t, dqcoeff_pvq[OD_TXSIZE_MAX * OD_TXSIZE_MAX]);
  DECLARE_ALIGNED(16, tran_low_t, ref_coeff_pvq[OD_TXSIZE_MAX * OD_TXSIZE_MAX]);
330

331
332
  od_coeff ref_int32[OD_TXSIZE_MAX * OD_TXSIZE_MAX];
  od_coeff out_int32[OD_TXSIZE_MAX * OD_TXSIZE_MAX];
333

Thomas Daede's avatar
Thomas Daede committed
334
335
  hbd_downshift = xd->bd - 8;

336
337
338
  od_raster_to_coding_order(ref_coeff_pvq, blk_size, tx_type, ref_coeff,
                            blk_size);

Thomas Daede's avatar
Thomas Daede committed
339
  assert(OD_COEFF_SHIFT >= 4);
340
341
342
  if (lossless)
    pvq_dc_quant = 1;
  else {
343
344
    if (use_activity_masking)
      pvq_dc_quant = OD_MAXI(
Thomas Daede's avatar
Thomas Daede committed
345
          1, (quant[0] << (OD_COEFF_SHIFT - 3) >> hbd_downshift) *
346
347
348
                     dec->state.pvq_qm_q4[pli][od_qm_get_index(bs, 0)] >>
                 4);
    else
Thomas Daede's avatar
Thomas Daede committed
349
350
      pvq_dc_quant =
          OD_MAXI(1, quant[0] << (OD_COEFF_SHIFT - 3) >> hbd_downshift);
351
352
353
354
355
  }

  off = od_qm_offset(bs, xdec);

  // copy int16 inputs to int32
356
  for (i = 0; i < blk_size * blk_size; i++) {
357
    ref_int32[i] =
Thomas Daede's avatar
Thomas Daede committed
358
359
        AOM_SIGNED_SHL(ref_coeff_pvq[i], OD_COEFF_SHIFT - coeff_shift) >>
        hbd_downshift;
360
  }
361

Thomas Daede's avatar
Thomas Daede committed
362
363
  od_pvq_decode(dec, ref_int32, out_int32,
                OD_MAXI(1, quant[1] << (OD_COEFF_SHIFT - 3) >> hbd_downshift),
364
                pli, bs, OD_PVQ_BETA[use_activity_masking][pli][bs],
365
366
                is_keyframe, &flags, ac_dc_coded, dec->state.qm + off,
                dec->state.qm_inv + off);
367

368
369
  if (!has_dc_skip || out_int32[0]) {
    out_int32[0] =
370
        has_dc_skip + generic_decode(dec->r, &dec->state.adapt->model_dc[pli],
371
372
                                     &dec->state.adapt->ex_dc[pli][bs][0], 2,
                                     "dc:mag");
373
374
375
376
377
378
379
380
    if (out_int32[0]) out_int32[0] *= aom_read_bit(dec->r, "dc:sign") ? -1 : 1;
  }
  out_int32[0] = out_int32[0] * pvq_dc_quant + ref_int32[0];

  // copy int32 result back to int16
  assert(OD_COEFF_SHIFT > coeff_shift);
  rounding_mask = (1 << (OD_COEFF_SHIFT - coeff_shift - 1)) - 1;
  for (i = 0; i < blk_size * blk_size; i++) {
Thomas Daede's avatar
Thomas Daede committed
381
    out_int32[i] = AOM_SIGNED_SHL(out_int32[i], hbd_downshift);
382
383
    dqcoeff_pvq[i] = (out_int32[i] + (out_int32[i] < 0) + rounding_mask) >>
                     (OD_COEFF_SHIFT - coeff_shift);
384
385
386
387
388
389
390
391
392
  }

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

  eob = blk_size * blk_size;

  return eob;
}

ltrudeau's avatar
ltrudeau committed
393
394
395
396
397
398
static PVQ_SKIP_TYPE read_pvq_skip(AV1_COMMON *cm, MACROBLOCKD *const xd,
                                   int plane, TX_SIZE tx_size) {
  // 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
399
  const int ac_dc_coded = aom_read_symbol(
ltrudeau's avatar
ltrudeau committed
400
      xd->daala_dec.r,
401
      xd->daala_dec.state.adapt->skip_cdf[2 * tx_size + (plane != 0)], 4,
402
      "skip");
ltrudeau's avatar
ltrudeau committed
403
404
405
406
407
408
409
410
  if (ac_dc_coded < 0 || ac_dc_coded > 3) {
    aom_internal_error(&cm->error, AOM_CODEC_INVALID_PARAM,
                       "Invalid PVQ Skip Type");
  }
  return ac_dc_coded;
}

static int av1_pvq_decode_helper2(AV1_COMMON *cm, MACROBLOCKD *const xd,
411
412
                                  MB_MODE_INFO *const mbmi, int plane, int row,
                                  int col, TX_SIZE tx_size, TX_TYPE tx_type) {
413
414
415
416
417
418
419
420
421
422
  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;
  uint8_t *dst;
  int eob;
ltrudeau's avatar
ltrudeau committed
423
  const PVQ_SKIP_TYPE ac_dc_coded = read_pvq_skip(cm, xd, plane, tx_size);
424
425
426
427
428
429
430
431

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

  if (ac_dc_coded) {
    int xdec = pd->subsampling_x;
    int seg_id = mbmi->segment_id;
    int16_t *quant;
432
    TxfmParam txfm_param;
433
434
    // ToDo(yaowu): correct this with optimal number from decoding process.
    const int max_scan_line = tx_size_2d[tx_size];
435
#if CONFIG_HIGHBITDEPTH
Thomas Daede's avatar
Thomas Daede committed
436
437
438
439
440
441
442
443
444
445
    if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
      for (j = 0; j < tx_blk_size; j++)
        for (i = 0; i < tx_blk_size; i++)
          pred[diff_stride * j + i] =
              CONVERT_TO_SHORTPTR(dst)[pd->dst.stride * j + i];
    } else {
#endif
      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];
446
#if CONFIG_HIGHBITDEPTH
Thomas Daede's avatar
Thomas Daede committed
447
448
    }
#endif
449

450
451
452
    txfm_param.tx_type = tx_type;
    txfm_param.tx_size = tx_size;
    txfm_param.lossless = xd->lossless[seg_id];
453

454
#if CONFIG_HIGHBITDEPTH
Thomas Daede's avatar
Thomas Daede committed
455
    if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
456
457
      txfm_param.bd = xd->bd;
      av1_highbd_fwd_txfm(pred, pvq_ref_coeff, diff_stride, &txfm_param);
Thomas Daede's avatar
Thomas Daede committed
458
    } else {
459
#endif  // CONFIG_HIGHBITDEPTH
460
      av1_fwd_txfm(pred, pvq_ref_coeff, diff_stride, &txfm_param);
461
#if CONFIG_HIGHBITDEPTH
Thomas Daede's avatar
Thomas Daede committed
462
    }
463
#endif  // CONFIG_HIGHBITDEPTH
464
465
466

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

Thomas Daede's avatar
Thomas Daede committed
467
468
    eob = av1_pvq_decode_helper(xd, pvq_ref_coeff, dqcoeff, quant, plane,
                                tx_size, tx_type, xdec, ac_dc_coded);
469

Lester Lu's avatar
Lester Lu committed
470
    inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride,
471
                            max_scan_line, eob);
472
473
474
475
476
477
  }

  return eob;
}
#endif

478
479
480
static void predict_and_reconstruct_intra_block(
    AV1_COMMON *cm, MACROBLOCKD *const xd, aom_reader *const r,
    MB_MODE_INFO *const mbmi, int plane, int row, int col, TX_SIZE tx_size) {
481
  PLANE_TYPE plane_type = get_plane_type(plane);
482
  const int block_idx = get_block_idx(xd, plane, row, col);
483
484
485
#if CONFIG_PVQ
  (void)r;
#endif
486
  av1_predict_intra_block_facade(xd, plane, block_idx, col, row, tx_size);
Jingning Han's avatar
Jingning Han committed
487
488

  if (!mbmi->skip) {
489
#if !CONFIG_PVQ
490
    struct macroblockd_plane *const pd = &xd->plane[plane];
Angie Chiang's avatar
Angie Chiang committed
491
492
#if CONFIG_LV_MAP
    int16_t max_scan_line = 0;
493
494
    int eob;
    av1_read_coeffs_txb_facade(cm, xd, r, row, col, block_idx, plane,
Jingning Han's avatar
Jingning Han committed
495
                               pd->dqcoeff, tx_size, &max_scan_line, &eob);
496
    // tx_type will be read out in av1_read_coeffs_txb_facade
497
498
    const TX_TYPE tx_type =
        av1_get_tx_type(plane_type, xd, row, col, block_idx, tx_size);
Angie Chiang's avatar
Angie Chiang committed
499
#else   // CONFIG_LV_MAP
500
501
    const TX_TYPE tx_type =
        av1_get_tx_type(plane_type, xd, row, col, block_idx, tx_size);
Angie Chiang's avatar
Angie Chiang committed
502
    const SCAN_ORDER *scan_order = get_scan(cm, tx_size, tx_type, mbmi);
503
504
    int16_t max_scan_line = 0;
    const int eob =
505
        av1_decode_block_tokens(cm, xd, plane, scan_order, col, row, tx_size,
506
                                tx_type, &max_scan_line, r, mbmi->segment_id);
Angie Chiang's avatar
Angie Chiang committed
507
#endif  // CONFIG_LV_MAP
508
509
510
    if (eob) {
      uint8_t *dst =
          &pd->dst.buf[(row * pd->dst.stride + col) << tx_size_wide_log2[0]];
Hui Su's avatar
Hui Su committed
511
      inverse_transform_block(xd, plane,
Lester Lu's avatar
Lester Lu committed
512
#if CONFIG_LGT
Lester Lu's avatar
Lester Lu committed
513
                              mbmi->mode,
Lester Lu's avatar
Lester Lu committed
514
#endif
Hui Su's avatar
Hui Su committed
515
516
                              tx_type, tx_size, dst, pd->dst.stride,
                              max_scan_line, eob);
517
    }
Lester Lu's avatar
Lester Lu committed
518
#else   // !CONFIG_PVQ
519
520
    const TX_TYPE tx_type =
        av1_get_tx_type(plane_type, xd, row, col, block_idx, tx_size);
ltrudeau's avatar
ltrudeau committed
521
    av1_pvq_decode_helper2(cm, xd, mbmi, plane, row, col, tx_size, tx_type);
Lester Lu's avatar
Lester Lu committed
522
#endif  // !CONFIG_PVQ
Jingning Han's avatar
Jingning Han committed
523
  }
524
#if CONFIG_CFL
525
  if (plane == AOM_PLANE_Y && xd->cfl->store_y) {
526
    struct macroblockd_plane *const pd = &xd->plane[plane];
527
#if CONFIG_CHROMA_SUB8X8
528
529
530
531
    const BLOCK_SIZE plane_bsize =
        AOMMAX(BLOCK_4X4, get_plane_block_size(mbmi->sb_type, pd));
#else
    const BLOCK_SIZE plane_bsize = get_plane_block_size(mbmi->sb_type, pd);
Luc Trudeau's avatar
Luc Trudeau committed
532
#endif  // CONFIG_CHROMA_SUB8X8
533
534
    uint8_t *dst =
        &pd->dst.buf[(row * pd->dst.stride + col) << tx_size_wide_log2[0]];
535
536
537
    // TODO (ltrudeau) Store sub-8x8 inter blocks when bottom right block is
    // intra predicted.
    cfl_store(xd->cfl, dst, pd->dst.stride, row, col, tx_size, plane_bsize);
538
  }
Luc Trudeau's avatar
Luc Trudeau committed
539
#endif  // CONFIG_CFL
Jingning Han's avatar
Jingning Han committed
540
541
}

542
#if CONFIG_VAR_TX && !CONFIG_COEF_INTERLEAVE
Angie Chiang's avatar
Angie Chiang committed
543
544
static void decode_reconstruct_tx(AV1_COMMON *cm, MACROBLOCKD *const xd,
                                  aom_reader *r, MB_MODE_INFO *const mbmi,
545
                                  int plane, BLOCK_SIZE plane_bsize,
546
547
                                  int blk_row, int blk_col, int block,
                                  TX_SIZE tx_size, int *eob_total) {
548
  const struct macroblockd_plane *const pd = &xd->plane[plane];
549
  const BLOCK_SIZE bsize = txsize_to_bsize[tx_size];
550
551
  const int tx_row = blk_row >> (1 - pd->subsampling_y);
  const int tx_col = blk_col >> (1 - pd->subsampling_x);
552
  const TX_SIZE plane_tx_size =
553
      plane ? uv_txsize_lookup[bsize][mbmi->inter_tx_size[tx_row][tx_col]][0][0]
554
            : mbmi->inter_tx_size[tx_row][tx_col];
555
  // Scale to match transform block unit.
556
557
  const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
  const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
558

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

561
  if (tx_size == plane_tx_size) {
562
    PLANE_TYPE plane_type = get_plane_type(plane);
Angie Chiang's avatar
Angie Chiang committed
563
564
#if CONFIG_LV_MAP
    int16_t max_scan_line = 0;
565
    int eob;
566
    av1_read_coeffs_txb_facade(cm, xd, r, blk_row, blk_col, block, plane,
Jingning Han's avatar
Jingning Han committed
567
                               pd->dqcoeff, tx_size, &max_scan_line, &eob);
568
    // tx_type will be read out in av1_read_coeffs_txb_facade
hui su's avatar
hui su committed
569
    const TX_TYPE tx_type =
570
        av1_get_tx_type(plane_type, xd, blk_row, blk_col, block, plane_tx_size);
Angie Chiang's avatar
Angie Chiang committed
571
#else   // CONFIG_LV_MAP
hui su's avatar
hui su committed
572
    const TX_TYPE tx_type =
573
        av1_get_tx_type(plane_type, xd, blk_row, blk_col, block, plane_tx_size);
Angie Chiang's avatar
Angie Chiang committed
574
    const SCAN_ORDER *sc = get_scan(cm, plane_tx_size, tx_type, mbmi);
575
    int16_t max_scan_line = 0;
576
577
578
    const int eob = av1_decode_block_tokens(
        cm, xd, plane, sc, blk_col, blk_row, plane_tx_size, tx_type,
        &max_scan_line, r, mbmi->segment_id);
Angie Chiang's avatar
Angie Chiang committed
579
#endif  // CONFIG_LV_MAP
Lester Lu's avatar
Lester Lu committed
580
581
582
583
584
    inverse_transform_block(xd, plane,
#if CONFIG_LGT
                            mbmi->mode,
#endif
                            tx_type, plane_tx_size,
585
586
587
                            &pd->dst.buf[(blk_row * pd->dst.stride + blk_col)
                                         << tx_size_wide_log2[0]],
                            pd->dst.stride, max_scan_line, eob);
588
589
    *eob_total += eob;
  } else {
Yue Chen's avatar
Yue Chen committed
590
591
592
593
594
#if CONFIG_RECT_TX_EXT
    int is_qttx = plane_tx_size == quarter_txsize_lookup[plane_bsize];
    const TX_SIZE sub_txs = is_qttx ? plane_tx_size : sub_tx_size_map[tx_size];
    if (is_qttx) assert(blk_row == 0 && blk_col == 0 && block == 0);
#else
595
    const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
Yue Chen's avatar
Yue Chen committed
596
597
    assert(sub_txs < tx_size);
#endif
598
    const int bsl = tx_size_wide_unit[sub_txs];
599
    int sub_step = tx_size_wide_unit[sub_txs] * tx_size_high_unit[sub_txs];
600
601
602
603
604
    int i;

    assert(bsl > 0);

    for (i = 0; i < 4; ++i) {
Yue Chen's avatar
Yue Chen committed
605
606
607
608
609
610
611
612
613
#if CONFIG_RECT_TX_EXT
      int is_wide_tx = tx_size_wide_unit[sub_txs] > tx_size_high_unit[sub_txs];
      const int offsetr =
          is_qttx ? (is_wide_tx ? i * tx_size_high_unit[sub_txs] : 0)
                  : blk_row + ((i >> 1) * bsl);
      const int offsetc =
          is_qttx ? (is_wide_tx ? 0 : i * tx_size_wide_unit[sub_txs])
                  : blk_col + (i & 0x01) * bsl;
#else
614
615
      const int offsetr = blk_row + (i >> 1) * bsl;
      const int offsetc = blk_col + (i & 0x01) * bsl;
Yue Chen's avatar
Yue Chen committed
616
#endif
617

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

620
      decode_reconstruct_tx(cm, xd, r, mbmi, plane, plane_bsize, offsetr,
621
622
                            offsetc, block, sub_txs, eob_total);
      block += sub_step;
623
624
625
    }
  }
}
626
#endif  // CONFIG_VAR_TX
627

628
#if !CONFIG_VAR_TX || CONFIG_SUPERTX || CONFIG_COEF_INTERLEAVE || \
629
    (!CONFIG_VAR_TX && CONFIG_EXT_TX && CONFIG_RECT_TX)
Angie Chiang's avatar
Angie Chiang committed
630
static int reconstruct_inter_block(AV1_COMMON *cm, MACROBLOCKD *const xd,
631
632
                                   aom_reader *const r, int segment_id,
                                   int plane, int row, int col,
633
                                   TX_SIZE tx_size) {
634
  PLANE_TYPE plane_type = get_plane_type(plane);
635
  int block_idx = get_block_idx(xd, plane, row, col);
636
637
638
#if CONFIG_PVQ
  int eob;
  (void)r;
639
640
641
  (void)segment_id;
#else
  struct macroblockd_plane *const pd = &xd->plane[plane];
642
643
644
#endif

#if !CONFIG_PVQ
Angie Chiang's avatar
Angie Chiang committed
645
646
#if CONFIG_LV_MAP
  (void)segment_id;
647
  int16_t max_scan_line = 0;
648
649
  int eob;
  av1_read_coeffs_txb_facade(cm, xd, r, row, col, block_idx, plane, pd->dqcoeff,
Angie Chiang's avatar
Angie Chiang committed
650
                             tx_size, &max_scan_line, &eob);
651
  // tx_type will be read out in av1_read_coeffs_txb_facade
652
653
  const TX_TYPE tx_type =
      av1_get_tx_type(plane_type, xd, row, col, block_idx, tx_size);
Angie Chiang's avatar
Angie Chiang committed
654
655
#else   // CONFIG_LV_MAP
  int16_t max_scan_line = 0;
656
657
  const TX_TYPE tx_type =
      av1_get_tx_type(plane_type, xd, row, col, block_idx, tx_size);
Angie Chiang's avatar
Angie Chiang committed
658
659
  const SCAN_ORDER *scan_order =
      get_scan(cm, tx_size, tx_type, &xd->mi[0]->mbmi);
660
  const int eob =
661
662
      av1_decode_block_tokens(cm, xd, plane, scan_order, col, row, tx_size,
                              tx_type, &max_scan_line, r, segment_id);
Angie Chiang's avatar
Angie Chiang committed
663
#endif  // CONFIG_LV_MAP
664
665
  uint8_t *dst =
      &pd->dst.buf[(row * pd->dst.stride + col) << tx_size_wide_log2[0]];
666
  if (eob)
Lester Lu's avatar
Lester Lu committed
667
668
669
670
671
    inverse_transform_block(xd, plane,
#if CONFIG_LGT
                            xd->mi[0]->mbmi.mode,
#endif
                            tx_type, tx_size, dst, pd->dst.stride,
672
                            max_scan_line, eob);
673
#else
674
675
  const TX_TYPE tx_type =
      av1_get_tx_type(plane_type, xd, row, col, block_idx, tx_size);
ltrudeau's avatar
ltrudeau committed
676
677
  eob = av1_pvq_decode_helper2(cm, xd, &xd->mi[0]->mbmi, plane, row, col,
                               tx_size, tx_type);
678
#endif
Jingning Han's avatar
Jingning Han committed
679
680
  return eob;
}
681
#endif  // !CONFIG_VAR_TX || CONFIG_SUPER_TX
Jingning Han's avatar
Jingning Han committed
682

683
684
685
static void set_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) {
Jingning Han's avatar
Jingning Han committed
686
687
688
689
690
691
692
693
694
  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;
695
696
697
#if CONFIG_RD_DEBUG
  xd->mi[0]->mbmi.mi_row = mi_row;
  xd->mi[0]->mbmi.mi_col = mi_col;
698
699
700
701
#endif
#if CONFIG_CFL
  xd->cfl->mi_row = mi_row;
  xd->cfl->mi_col = mi_col;
702
#endif
Jingning Han's avatar
Jingning Han committed
703
  for (y = 0; y < y_mis; ++y)
Jingning Han's avatar
Jingning Han committed
704
    for (x = !y; x < x_mis; ++x) xd->mi[y * cm->mi_stride + x] = xd->mi[0];
Jingning Han's avatar
Jingning Han committed
705

Jingning Han's avatar
Jingning Han committed
706
  set_plane_n4(xd, bw, bh);
Jingning Han's avatar
Jingning Han committed
707
708
  set_skip_context(xd, mi_row, mi_col);

709
710
711
712
#if CONFIG_VAR_TX
  xd->max_tx_size = max_txsize_lookup[bsize];
#endif

713
714
715
  // 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,
716
#if CONFIG_DEPENDENT_HORZTILES
717
718
719
                 cm->dependent_horz_tiles,
#endif  // CONFIG_DEPENDENT_HORZTILES
                 cm->mi_rows, cm->mi_cols);
Jingning Han's avatar
Jingning Han committed
720

721
722
  av1_setup_dst_planes(xd->plane, bsize, get_frame_new_buffer(cm), mi_row,
                       mi_col);
Jingning Han's avatar
Jingning Han committed
723
724
}

725
#if CONFIG_SUPERTX
Yaowu Xu's avatar
Yaowu Xu committed
726
static MB_MODE_INFO *set_offsets_extend(AV1_COMMON *const cm,
727
728
                                        MACROBLOCKD *const xd,
                                        const TileInfo *const tile,
729
730
731
                                        BLOCK_SIZE bsize_pred, int mi_row_pred,
                                        int mi_col_pred, int mi_row_ori,
                                        int mi_col_ori) {
732
733
734
  // Used in supertx
  // (mi_row_ori, mi_col_ori): location for mv
  // (mi_row_pred, mi_col_pred, bsize_pred): region to predict
Jingning Han's avatar
Jingning Han committed
735
736
  const int bw = mi_size_wide[bsize_pred];
  const int bh = mi_size_high[bsize_pred];
737
738
739
  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;
740
  set_mi_row_col(xd, tile, mi_row_pred, bh, mi_col_pred, bw,
741
#if CONFIG_DEPENDENT_HORZTILES
742
743
744
                 cm->dependent_horz_tiles,
#endif  // CONFIG_DEPENDENT_HORZTILES
                 cm->mi_rows, cm->mi_cols);
745

746
747
  xd->up_available = (mi_row_ori > tile->mi_row_start);
  xd->left_available = (mi_col_ori > tile->mi_col_start);
748

Jingning Han's avatar
Jingning Han committed
749
  set_plane_n4(xd, bw, bh);
750
751
752
753

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

Angie Chiang's avatar
Angie Chiang committed
754
#if CONFIG_SUPERTX
Yaowu Xu's avatar
Yaowu Xu committed
755
756
757
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) {
758
759
760
761
762
763
764
765
  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)
766
    for (x = !y; x < x_mis; ++x) xd->mi[y * cm->mi_stride + x] = xd->mi[0];
767

768
  set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw,
769
#if CONFIG_DEPENDENT_HORZTILES
770
771
772
                 cm->dependent_horz_tiles,
#endif  // CONFIG_DEPENDENT_HORZTILES
                 cm->mi_rows, cm->mi_cols);
773
774
  return &xd->mi[0]->mbmi;
}
Angie Chiang's avatar
Angie Chiang committed
775
#endif
776

Yaowu Xu's avatar
Yaowu Xu committed
777
static void set_offsets_topblock(AV1_COMMON *const cm, MACROBLOCKD *const xd,
778
779
                                 const TileInfo *const tile, BLOCK_SIZE bsize,
                                 int mi_row, int mi_col) {
Jingning Han's avatar
Jingning Han committed
780
781
  const int bw = mi_size_wide[bsize];
  const int bh = mi_size_high[bsize];
782
783
784
785
786
  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
787
  set_plane_n4(xd, bw, bh);
788

789
  set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw,
790
#if CONFIG_DEPENDENT_HORZTILES
791
792
793
                 cm->dependent_horz_tiles,
#endif  // CONFIG_DEPENDENT_HORZTILES
                 cm->mi_rows, cm->mi_cols);
794

795
796
  av1_setup_dst_planes(xd->plane, bsize, get_frame_new_buffer(cm), mi_row,
                       mi_col);
797
798
}

Yaowu Xu's avatar
Yaowu Xu committed
799
static void set_param_topblock(AV1_COMMON *const cm, MACROBLOCKD *const xd,
800
                               BLOCK_SIZE bsize, int mi_row, int mi_col,
801
                               int txfm, int skip) {
Jingning Han's avatar
Jingning Han committed
802
803
  const int bw = mi_size_wide[bsize];
  const int bh = mi_size_high[bsize];
Yaowu Xu's avatar
Yaowu Xu committed
804
805
  const int x_mis = AOMMIN(bw, cm->mi_cols - mi_col);
  const int y_mis = AOMMIN(bh, cm->mi_rows - mi_row);
806
807
808
809
810
811
812
813
814
815
816
  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;
    }
817
818
#if CONFIG_VAR_TX
  xd->above_txfm_context = cm->above_txfm_context + mi_col;
819
  xd->left_txfm_context =
820
      xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK);
821
  set_txfm_ctxs(xd->mi[0]->mbmi.tx_size, bw, bh, skip, xd);
822
#endif
823
824
}

Yaowu Xu's avatar
Yaowu Xu committed
825
static void set_ref(AV1_COMMON *const cm, MACROBLOCKD *const xd, int idx,
826
                    int mi_row, int mi_col) {
827
  MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
828
829
830
831
832
#if CONFIG_EXT_INTER && CONFIG_COMPOUND_SINGLEREF
  RefBuffer *ref_buffer =
      has_second_ref(mbmi) ? &cm->frame_refs[mbmi->ref_frame[idx] - LAST_FRAME]
                           : &cm->frame_refs[mbmi->ref_frame[0] - LAST_FRAME];
#else
833
  RefBuffer *ref_buffer = &cm->frame_refs[mbmi->ref_frame[idx] - LAST_FRAME];
834
#endif  // CONFIG_EXT_INTER && CONFIG_COMPOUND_SINGLEREF
835
  xd->block_refs[idx] = ref_buffer;
Yaowu Xu's avatar
Yaowu Xu committed
836
837
  if (!av1_is_valid_scale(&ref_buffer->sf))
    aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
838
                       "Invalid scale factors");
Yaowu Xu's avatar
Yaowu Xu committed
839
840
  av1_setup_pre_planes(xd, idx, ref_buffer->buf, mi_row, mi_col,
                       &ref_buffer->sf);
841
  aom_merge_corrupted_flag(&xd->corrupted, ref_buffer->buf->corrupted);
842
843
844
}

static void dec_predict_b_extend(
Yaowu Xu's avatar
Yaowu Xu committed
845
    AV1Decoder *const pbi, MACROBLOCKD *const xd, const TileInfo *const tile,
846
    int block, int mi_row_ori, int mi_col_ori, int mi_row_pred, int mi_col_pred,
847
    int mi_row_top, int mi_col_top, int plane, uint8_t *dst_buf, int dst_stride,
848
    BLOCK_SIZE bsize_top, BLOCK_SIZE bsize_pred, int b_sub8x8, int bextend) {
849
850
851