decodeframe.c 145 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"
22
#include "aom_dsp/binary_codes_reader.h"
Jingning Han's avatar
Jingning Han committed
23
24
#include "aom_dsp/bitreader.h"
#include "aom_dsp/bitreader_buffer.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"
67
#include "av1/decoder/symbolrate.h"
Jingning Han's avatar
Jingning Han committed
68

Yue Chen's avatar
Yue Chen committed
69
70
#include "av1/common/warped_motion.h"

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

74
75
76
77
#if CONFIG_CFL
#include "av1/common/cfl.h"
#endif

78
79
80
81
#if CONFIG_STRIPED_LOOP_RESTORATION && !CONFIG_LOOP_RESTORATION
#error "striped_loop_restoration requires loop_restoration"
#endif

82
83
84
85
86
87
88
#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

89
90
91
92
93
94
95
96
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
97
static int is_compound_reference_allowed(const AV1_COMMON *cm) {
98
#if CONFIG_ONE_SIDED_COMPOUND  // Normative in decoder
99
100
  return !frame_is_intra_only(cm);
#else
Jingning Han's avatar
Jingning Han committed
101
  int i;
102
  if (frame_is_intra_only(cm)) return 0;
103
  for (i = 1; i < INTER_REFS_PER_FRAME; ++i)
104
    if (cm->ref_frame_sign_bias[i + 1] != cm->ref_frame_sign_bias[1]) return 1;
Jingning Han's avatar
Jingning Han committed
105
106

  return 0;
107
#endif  // CONFIG_ONE_SIDED_COMPOUND
Jingning Han's avatar
Jingning Han committed
108
109
}

Yaowu Xu's avatar
Yaowu Xu committed
110
static void setup_compound_reference_mode(AV1_COMMON *cm) {
111
  cm->comp_fwd_ref[0] = LAST_FRAME;
112
113
114
115
  cm->comp_fwd_ref[1] = LAST2_FRAME;
  cm->comp_fwd_ref[2] = LAST3_FRAME;
  cm->comp_fwd_ref[3] = GOLDEN_FRAME;

116
  cm->comp_bwd_ref[0] = BWDREF_FRAME;
Zoe Liu's avatar
Zoe Liu committed
117
118
  cm->comp_bwd_ref[1] = ALTREF2_FRAME;
  cm->comp_bwd_ref[2] = ALTREF_FRAME;
Jingning Han's avatar
Jingning Han committed
119
120
121
122
123
124
}

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
125
126
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
127
128
129
  return data > max ? max : data;
}

130
131
132
133
134
135
136
137
138
139
140
#if CONFIG_SIMPLIFY_TX_MODE
static TX_MODE read_tx_mode(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
  if (cm->all_lossless) return ONLY_4X4;
#if CONFIG_VAR_TX_NO_TX_MODE
  (void)rb;
  return TX_MODE_SELECT;
#else
  return aom_rb_read_bit(rb) ? TX_MODE_SELECT : TX_MODE_LARGEST;
#endif  // CONFIG_VAR_TX_NO_TX_MODE
}
#else
141
static TX_MODE read_tx_mode(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
142
#if CONFIG_TX64X64
143
144
  TX_MODE tx_mode;
#endif
145
  if (cm->all_lossless) return ONLY_4X4;
146
147
148
149
#if CONFIG_VAR_TX_NO_TX_MODE
  (void)rb;
  return TX_MODE_SELECT;
#else
150
151
#if CONFIG_TX64X64
  tx_mode = aom_rb_read_bit(rb) ? TX_MODE_SELECT : aom_rb_read_literal(rb, 2);
152
153
154
  if (tx_mode == ALLOW_32X32) tx_mode += aom_rb_read_bit(rb);
  return tx_mode;
#else
Yaowu Xu's avatar
Yaowu Xu committed
155
  return aom_rb_read_bit(rb) ? TX_MODE_SELECT : aom_rb_read_literal(rb, 2);
156
#endif  // CONFIG_TX64X64
157
#endif  // CONFIG_VAR_TX_NO_TX_MODE
158
}
159
#endif  // CONFIG_SIMPLIFY_TX_MODE
Jingning Han's avatar
Jingning Han committed
160

Thomas Davies's avatar
Thomas Davies committed
161
#if !CONFIG_NEW_MULTISYMBOL
Yaowu Xu's avatar
Yaowu Xu committed
162
static void read_inter_mode_probs(FRAME_CONTEXT *fc, aom_reader *r) {
163
  int i;
164
  for (i = 0; i < NEWMV_MODE_CONTEXTS; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
165
    av1_diff_update_prob(r, &fc->newmv_prob[i], ACCT_STR);
Sarah Parker's avatar
Sarah Parker committed
166
  for (i = 0; i < GLOBALMV_MODE_CONTEXTS; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
167
    av1_diff_update_prob(r, &fc->zeromv_prob[i], ACCT_STR);
168
  for (i = 0; i < REFMV_MODE_CONTEXTS; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
169
    av1_diff_update_prob(r, &fc->refmv_prob[i], ACCT_STR);
170
  for (i = 0; i < DRL_MODE_CONTEXTS; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
171
    av1_diff_update_prob(r, &fc->drl_prob[i], ACCT_STR);
Jingning Han's avatar
Jingning Han committed
172
}
173
#endif
Jingning Han's avatar
Jingning Han committed
174

175
static REFERENCE_MODE read_frame_reference_mode(
Yaowu Xu's avatar
Yaowu Xu committed
176
    const AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
177
  if (is_compound_reference_allowed(cm)) {
Zoe Liu's avatar
Zoe Liu committed
178
179
180
#if CONFIG_REF_ADAPT
    return aom_rb_read_bit(rb) ? REFERENCE_MODE_SELECT : SINGLE_REFERENCE;
#else
Yaowu Xu's avatar
Yaowu Xu committed
181
    return aom_rb_read_bit(rb)
182
               ? REFERENCE_MODE_SELECT
Yaowu Xu's avatar
Yaowu Xu committed
183
               : (aom_rb_read_bit(rb) ? COMPOUND_REFERENCE : SINGLE_REFERENCE);
Zoe Liu's avatar
Zoe Liu committed
184
#endif  // CONFIG_REF_ADAPT
185
186
187
188
  } else {
    return SINGLE_REFERENCE;
  }
}
Jingning Han's avatar
Jingning Han committed
189

Thomas Davies's avatar
Thomas Davies committed
190
#if !CONFIG_NEW_MULTISYMBOL
Yaowu Xu's avatar
Yaowu Xu committed
191
static void read_frame_reference_mode_probs(AV1_COMMON *cm, aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
192
  FRAME_CONTEXT *const fc = cm->fc;
193
  int i;
Jingning Han's avatar
Jingning Han committed
194
195
196

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

199
  if (cm->reference_mode != COMPOUND_REFERENCE) {
Jingning Han's avatar
Jingning Han committed
200
    for (i = 0; i < REF_CONTEXTS; ++i) {
201
      int j;
202
      for (j = 0; j < (SINGLE_REFS - 1); ++j) {
Michael Bebenita's avatar
Michael Bebenita committed
203
        av1_diff_update_prob(r, &fc->single_ref_prob[i][j], ACCT_STR);
204
      }
Jingning Han's avatar
Jingning Han committed
205
    }
206
  }
Jingning Han's avatar
Jingning Han committed
207

208
  if (cm->reference_mode != SINGLE_REFERENCE) {
Zoe Liu's avatar
Zoe Liu committed
209
210
211
212
#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);

213
214
    for (i = 0; i < UNI_COMP_REF_CONTEXTS; ++i) {
      int j;
Zoe Liu's avatar
Zoe Liu committed
215
216
      for (j = 0; j < (UNIDIR_COMP_REFS - 1); ++j)
        av1_diff_update_prob(r, &fc->uni_comp_ref_prob[i][j], ACCT_STR);
217
    }
Zoe Liu's avatar
Zoe Liu committed
218
219
#endif  // CONFIG_EXT_COMP_REFS

220
    for (i = 0; i < REF_CONTEXTS; ++i) {
221
      int j;
222
      for (j = 0; j < (FWD_REFS - 1); ++j)
Michael Bebenita's avatar
Michael Bebenita committed
223
        av1_diff_update_prob(r, &fc->comp_ref_prob[i][j], ACCT_STR);
224
      for (j = 0; j < (BWD_REFS - 1); ++j)
Michael Bebenita's avatar
Michael Bebenita committed
225
        av1_diff_update_prob(r, &fc->comp_bwdref_prob[i][j], ACCT_STR);
226
227
    }
  }
Jingning Han's avatar
Jingning Han committed
228
229
}

Yaowu Xu's avatar
Yaowu Xu committed
230
static void update_mv_probs(aom_prob *p, int n, aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
231
  int i;
Michael Bebenita's avatar
Michael Bebenita committed
232
  for (i = 0; i < n; ++i) av1_diff_update_prob(r, &p[i], ACCT_STR);
Jingning Han's avatar
Jingning Han committed
233
234
}

Yaowu Xu's avatar
Yaowu Xu committed
235
static void read_mv_probs(nmv_context *ctx, int allow_hp, aom_reader *r) {
236
  int i;
Jingning Han's avatar
Jingning Han committed
237
238
239
240
241
242
243
244
  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);
    }
  }
}
245
#endif
Jingning Han's avatar
Jingning Han committed
246

247
static void inverse_transform_block(MACROBLOCKD *xd, int plane,
248
#if CONFIG_LGT_FROM_PRED
Lester Lu's avatar
Lester Lu committed
249
250
                                    PREDICTION_MODE mode,
#endif
251
                                    const TX_TYPE tx_type,
252
                                    const TX_SIZE tx_size, uint8_t *dst,
253
                                    int stride, int16_t scan_line, int eob) {
Jingning Han's avatar
Jingning Han committed
254
  struct macroblockd_plane *const pd = &xd->plane[plane];
255
  tran_low_t *const dqcoeff = pd->dqcoeff;
Lester Lu's avatar
Lester Lu committed
256
  av1_inverse_transform_block(xd, dqcoeff,
257
#if CONFIG_LGT_FROM_PRED
Lester Lu's avatar
Lester Lu committed
258
259
                              mode,
#endif
Sarah Parker's avatar
Sarah Parker committed
260
261
262
#if CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK
                              xd->mrc_mask,
#endif  // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK
263
                              plane, tx_type, tx_size, dst, stride, eob);
264
  memset(dqcoeff, 0, (scan_line + 1) * sizeof(dqcoeff[0]));
Jingning Han's avatar
Jingning Han committed
265
266
}

267
268
269
270
271
272
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];
  const BLOCK_SIZE plane_bsize =
      AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
  const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
273
  const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
274
275
276
277
  const uint8_t txh_unit = tx_size_high_unit[tx_size];
  return row * max_blocks_wide + col * txh_unit;
}

278
279
280
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) {
281
  PLANE_TYPE plane_type = get_plane_type(plane);
282
  const int block_idx = get_block_idx(xd, plane, row, col);
283
  av1_predict_intra_block_facade(cm, xd, plane, block_idx, col, row, tx_size);
Jingning Han's avatar
Jingning Han committed
284
285

  if (!mbmi->skip) {
286
    struct macroblockd_plane *const pd = &xd->plane[plane];
Angie Chiang's avatar
Angie Chiang committed
287
288
#if CONFIG_LV_MAP
    int16_t max_scan_line = 0;
289
290
    int eob;
    av1_read_coeffs_txb_facade(cm, xd, r, row, col, block_idx, plane,
Jingning Han's avatar
Jingning Han committed
291
                               pd->dqcoeff, tx_size, &max_scan_line, &eob);
292
    // tx_type will be read out in av1_read_coeffs_txb_facade
293
294
    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
295
#else   // CONFIG_LV_MAP
296
297
    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
298
    const SCAN_ORDER *scan_order = get_scan(cm, tx_size, tx_type, mbmi);
299
300
    int16_t max_scan_line = 0;
    const int eob =
301
        av1_decode_block_tokens(cm, xd, plane, scan_order, col, row, tx_size,
302
                                tx_type, &max_scan_line, r, mbmi->segment_id);
Angie Chiang's avatar
Angie Chiang committed
303
#endif  // CONFIG_LV_MAP
304
305
306
    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
307
      inverse_transform_block(xd, plane,
308
#if CONFIG_LGT_FROM_PRED
Lester Lu's avatar
Lester Lu committed
309
                              mbmi->mode,
Lester Lu's avatar
Lester Lu committed
310
#endif
Hui Su's avatar
Hui Su committed
311
312
                              tx_type, tx_size, dst, pd->dst.stride,
                              max_scan_line, eob);
313
    }
Jingning Han's avatar
Jingning Han committed
314
  }
315
#if CONFIG_CFL
316
  if (plane == AOM_PLANE_Y && xd->cfl->store_y) {
317
    cfl_store_tx(xd, row, col, tx_size, mbmi->sb_type);
318
  }
Sebastien Alaiwan's avatar
Sebastien Alaiwan committed
319
#endif  // CONFIG_CFL
Jingning Han's avatar
Jingning Han committed
320
321
}

Angie Chiang's avatar
Angie Chiang committed
322
323
static void decode_reconstruct_tx(AV1_COMMON *cm, MACROBLOCKD *const xd,
                                  aom_reader *r, MB_MODE_INFO *const mbmi,
324
                                  int plane, BLOCK_SIZE plane_bsize,
325
326
                                  int blk_row, int blk_col, int block,
                                  TX_SIZE tx_size, int *eob_total) {
327
  const struct macroblockd_plane *const pd = &xd->plane[plane];
328
  const BLOCK_SIZE bsize = txsize_to_bsize[tx_size];
329
330
  const int tx_row = blk_row >> (1 - pd->subsampling_y);
  const int tx_col = blk_col >> (1 - pd->subsampling_x);
331
  const TX_SIZE plane_tx_size =
332
      plane ? uv_txsize_lookup[bsize][mbmi->inter_tx_size[tx_row][tx_col]][0][0]
333
            : mbmi->inter_tx_size[tx_row][tx_col];
334
  // Scale to match transform block unit.
335
336
  const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
  const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
337

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

340
  if (tx_size == plane_tx_size) {
341
    PLANE_TYPE plane_type = get_plane_type(plane);
Angie Chiang's avatar
Angie Chiang committed
342
343
#if CONFIG_LV_MAP
    int16_t max_scan_line = 0;
344
    int eob;
345
    av1_read_coeffs_txb_facade(cm, xd, r, blk_row, blk_col, block, plane,
Jingning Han's avatar
Jingning Han committed
346
                               pd->dqcoeff, tx_size, &max_scan_line, &eob);
347
    // tx_type will be read out in av1_read_coeffs_txb_facade
hui su's avatar
hui su committed
348
    const TX_TYPE tx_type =
349
        av1_get_tx_type(plane_type, xd, blk_row, blk_col, block, plane_tx_size);
Angie Chiang's avatar
Angie Chiang committed
350
#else   // CONFIG_LV_MAP
hui su's avatar
hui su committed
351
    const TX_TYPE tx_type =
352
        av1_get_tx_type(plane_type, xd, blk_row, blk_col, block, plane_tx_size);
Angie Chiang's avatar
Angie Chiang committed
353
    const SCAN_ORDER *sc = get_scan(cm, plane_tx_size, tx_type, mbmi);
354
    int16_t max_scan_line = 0;
355
356
357
    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
358
#endif  // CONFIG_LV_MAP
Lester Lu's avatar
Lester Lu committed
359
    inverse_transform_block(xd, plane,
360
#if CONFIG_LGT_FROM_PRED
Lester Lu's avatar
Lester Lu committed
361
362
363
                            mbmi->mode,
#endif
                            tx_type, plane_tx_size,
364
365
366
                            &pd->dst.buf[(blk_row * pd->dst.stride + blk_col)
                                         << tx_size_wide_log2[0]],
                            pd->dst.stride, max_scan_line, eob);
367
368
    *eob_total += eob;
  } else {
Yue Chen's avatar
Yue Chen committed
369
370
371
372
373
#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
374
    const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
375
376
    assert(IMPLIES(tx_size <= TX_4X4, sub_txs == tx_size));
    assert(IMPLIES(tx_size > TX_4X4, sub_txs < tx_size));
Yue Chen's avatar
Yue Chen committed
377
#endif
378
    const int bsl = tx_size_wide_unit[sub_txs];
379
    int sub_step = tx_size_wide_unit[sub_txs] * tx_size_high_unit[sub_txs];
380
381
382
383
384
    int i;

    assert(bsl > 0);

    for (i = 0; i < 4; ++i) {
Yue Chen's avatar
Yue Chen committed
385
386
387
388
389
390
391
392
393
#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
394
395
      const int offsetr = blk_row + (i >> 1) * bsl;
      const int offsetc = blk_col + (i & 0x01) * bsl;
Yue Chen's avatar
Yue Chen committed
396
#endif
397

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

400
      decode_reconstruct_tx(cm, xd, r, mbmi, plane, plane_bsize, offsetr,
401
402
                            offsetc, block, sub_txs, eob_total);
      block += sub_step;
403
404
405
    }
  }
}
Jingning Han's avatar
Jingning Han committed
406

407
408
409
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
410
411
412
413
414
415
416
417
418
  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;
419
420
421
#if CONFIG_RD_DEBUG
  xd->mi[0]->mbmi.mi_row = mi_row;
  xd->mi[0]->mbmi.mi_col = mi_col;
422
423
424
425
#endif
#if CONFIG_CFL
  xd->cfl->mi_row = mi_row;
  xd->cfl->mi_col = mi_col;
426
#endif
427
428
429
430
431
432
433
434

  assert(x_mis && y_mis);
  for (x = 1; x < x_mis; ++x) xd->mi[x] = xd->mi[0];
  int idx = cm->mi_stride;
  for (y = 1; y < y_mis; ++y) {
    memcpy(&xd->mi[idx], &xd->mi[0], x_mis * sizeof(xd->mi[0]));
    idx += cm->mi_stride;
  }
Jingning Han's avatar
Jingning Han committed
435

Jingning Han's avatar
Jingning Han committed
436
  set_plane_n4(xd, bw, bh);
Jingning Han's avatar
Jingning Han committed
437
438
  set_skip_context(xd, mi_row, mi_col);

439
440
441
  // 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,
442
#if CONFIG_DEPENDENT_HORZTILES
443
444
445
                 cm->dependent_horz_tiles,
#endif  // CONFIG_DEPENDENT_HORZTILES
                 cm->mi_rows, cm->mi_cols);
Jingning Han's avatar
Jingning Han committed
446

447
448
  av1_setup_dst_planes(xd->plane, bsize, get_frame_new_buffer(cm), mi_row,
                       mi_col);
Jingning Han's avatar
Jingning Han committed
449
450
}

451
452
static void decode_mbmi_block(AV1Decoder *const pbi, MACROBLOCKD *const xd,
                              int mi_row, int mi_col, aom_reader *r,
453
#if CONFIG_EXT_PARTITION_TYPES
454
                              PARTITION_TYPE partition,
455
#endif  // CONFIG_EXT_PARTITION_TYPES
456
                              BLOCK_SIZE bsize) {
Yaowu Xu's avatar
Yaowu Xu committed
457
  AV1_COMMON *const cm = &pbi->common;
458
459
  const int bw = mi_size_wide[bsize];
  const int bh = mi_size_high[bsize];
Yaowu Xu's avatar
Yaowu Xu committed
460
461
  const int x_mis = AOMMIN(bw, cm->mi_cols - mi_col);
  const int y_mis = AOMMIN(bh, cm->mi_rows - mi_row);
462

Michael Bebenita's avatar
Michael Bebenita committed
463
464
465
#if CONFIG_ACCOUNTING
  aom_accounting_set_context(&pbi->accounting, mi_col, mi_row);
#endif
466
  set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis);
467
468
469
#if CONFIG_EXT_PARTITION_TYPES
  xd->mi[0]->mbmi.partition = partition;
#endif
Yaowu Xu's avatar
Yaowu Xu committed
470
  av1_read_mode_info(pbi, xd, mi_row, mi_col, r, x_mis, y_mis);
Jingning Han's avatar
Jingning Han committed
471
472
473
474
  if (bsize >= BLOCK_8X8 && (cm->subsampling_x || cm->subsampling_y)) {
    const BLOCK_SIZE uv_subsize =
        ss_size_lookup[bsize][cm->subsampling_x][cm->subsampling_y];
    if (uv_subsize == BLOCK_INVALID)
Yaowu Xu's avatar
Yaowu Xu committed
475
      aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
476
                         "Invalid block size.");
Jingning Han's avatar
Jingning Han committed
477
478
  }

479
480
  int reader_corrupted_flag = aom_reader_has_error(r);
  aom_merge_corrupted_flag(&xd->corrupted, reader_corrupted_flag);
481
482
483
484
485
486
487
488
489
490
491
492
}

static void decode_token_and_recon_block(AV1Decoder *const pbi,
                                         MACROBLOCKD *const xd, int mi_row,
                                         int mi_col, aom_reader *r,
                                         BLOCK_SIZE bsize) {
  AV1_COMMON *const cm = &pbi->common;
  const int bw = mi_size_wide[bsize];
  const int bh = mi_size_high[bsize];
  const int x_mis = AOMMIN(bw, cm->mi_cols - mi_col);
  const int y_mis = AOMMIN(bh, cm->mi_rows - mi_row);

493
494
  set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis);
  MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
495
#if CONFIG_CFL
496
497
498
  CFL_CTX *const cfl = xd->cfl;
  cfl->is_chroma_reference = is_chroma_reference(
      mi_row, mi_col, bsize, cfl->subsampling_x, cfl->subsampling_y);
499
#endif  // CONFIG_CFL
500

501
502
503
  if (cm->delta_q_present_flag) {
    int i;
    for (i = 0; i < MAX_SEGMENTS; i++) {
Fangwen Fu's avatar
Fangwen Fu committed
504
#if CONFIG_EXT_DELTA_Q
505
506
      const int current_qindex =
          av1_get_qindex(&cm->seg, i, xd->current_qindex);
Fangwen Fu's avatar
Fangwen Fu committed
507
#else
508
509
510
511
512
513
514
515
516
517
518
519
      const int current_qindex = xd->current_qindex;
#endif  // CONFIG_EXT_DELTA_Q
      int j;
      for (j = 0; j < MAX_MB_PLANE; ++j) {
        const int dc_delta_q = j == 0 ? cm->y_dc_delta_q : cm->uv_dc_delta_q;
        const int ac_delta_q = j == 0 ? 0 : cm->uv_ac_delta_q;

        xd->plane[j].seg_dequant[i][0] =
            av1_dc_quant(current_qindex, dc_delta_q, cm->bit_depth);
        xd->plane[j].seg_dequant[i][1] =
            av1_ac_quant(current_qindex, ac_delta_q, cm->bit_depth);
      }
520
521
    }
  }
522
  if (mbmi->skip) av1_reset_skip_context(xd, mi_row, mi_col, bsize);
523

524
525
  if (!is_inter_block(mbmi)) {
    int plane;
526

527
528
    for (plane = 0; plane <= 1; ++plane) {
      if (mbmi->palette_mode_info.palette_size[plane])
Yaowu Xu's avatar
Yaowu Xu committed
529
        av1_decode_palette_tokens(xd, plane, r);
Jingning Han's avatar
Jingning Han committed
530
    }
531

532
533
    for (plane = 0; plane < MAX_MB_PLANE; ++plane) {
      const struct macroblockd_plane *const pd = &xd->plane[plane];
534
      const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
535
536
      const int stepr = tx_size_high_unit[tx_size];
      const int stepc = tx_size_wide_unit[tx_size];
537
538
      const BLOCK_SIZE plane_bsize =
          AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
539
      int row, col;
540
541
      const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
      const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
542
543
      if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x,
                               pd->subsampling_y))
544
        continue;
545
546
547
548
549
550
551
552
553
554
      int blk_row, blk_col;
      const BLOCK_SIZE max_unit_bsize = get_plane_block_size(BLOCK_64X64, pd);
      int mu_blocks_wide =
          block_size_wide[max_unit_bsize] >> tx_size_wide_log2[0];
      int mu_blocks_high =
          block_size_high[max_unit_bsize] >> tx_size_high_log2[0];
      mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);
      mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);

      for (row = 0; row < max_blocks_high; row += mu_blocks_high) {
555
        const int unit_height = AOMMIN(mu_blocks_high + row, max_blocks_high);
556
557
558
559
560
561
562
563
564
        for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) {
          const int unit_width = AOMMIN(mu_blocks_wide + col, max_blocks_wide);

          for (blk_row = row; blk_row < unit_height; blk_row += stepr)
            for (blk_col = col; blk_col < unit_width; blk_col += stepc)
              predict_and_reconstruct_intra_block(cm, xd, r, mbmi, plane,
                                                  blk_row, blk_col, tx_size);
        }
      }
565
566
    }
  } else {
567
568
    int ref;

569
#if CONFIG_COMPOUND_SINGLEREF
570
571
572
    for (ref = 0; ref < 1 + is_inter_anyref_comp_mode(mbmi->mode); ++ref)
#else
    for (ref = 0; ref < 1 + has_second_ref(mbmi); ++ref)
573
#endif  // CONFIG_COMPOUND_SINGLEREF
574
    {
575
      const MV_REFERENCE_FRAME frame =
576
#if CONFIG_COMPOUND_SINGLEREF
577
578
          has_second_ref(mbmi) ? mbmi->ref_frame[ref] : mbmi->ref_frame[0];
#else
579
          mbmi->ref_frame[ref];
580
#endif  // CONFIG_COMPOUND_SINGLEREF
Alex Converse's avatar
Alex Converse committed
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
      if (frame < LAST_FRAME) {
#if CONFIG_INTRABC
        assert(is_intrabc_block(mbmi));
        assert(frame == INTRA_FRAME);
        assert(ref == 0);
#else
        assert(0);
#endif  // CONFIG_INTRABC
      } else {
        RefBuffer *ref_buf = &cm->frame_refs[frame - LAST_FRAME];

        xd->block_refs[ref] = ref_buf;
        if ((!av1_is_valid_scale(&ref_buf->sf)))
          aom_internal_error(xd->error_info, AOM_CODEC_UNSUP_BITSTREAM,
                             "Reference frame has invalid dimensions");
        av1_setup_pre_planes(xd, ref, ref_buf->buf, mi_row, mi_col,
                             &ref_buf->sf);
      }
599
    }
600

601
    av1_build_inter_predictors_sb(cm, xd, mi_row, mi_col, NULL, bsize);
602

Yue Chen's avatar
Yue Chen committed
603
    if (mbmi->motion_mode == OBMC_CAUSAL) {
Yue Chen's avatar
Yue Chen committed
604
605
606
#if CONFIG_NCOBMC
      av1_build_ncobmc_inter_predictors_sb(cm, xd, mi_row, mi_col);
#else
607
      av1_build_obmc_inter_predictors_sb(cm, xd, mi_row, mi_col);
Yue Chen's avatar
Yue Chen committed
608
#endif
609
610
611
612
613
614
    }
    // Reconstruction
    if (!mbmi->skip) {
      int eobtotal = 0;
      int plane;

Jingning Han's avatar
Jingning Han committed
615
616
      for (plane = 0; plane < MAX_MB_PLANE; ++plane) {
        const struct macroblockd_plane *const pd = &xd->plane[plane];
617
618
        const BLOCK_SIZE plane_bsize =
            AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
619
620
        const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
        const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
621
        int row, col;
622

623
624
        if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x,
                                 pd->subsampling_y))
625
626
          continue;

627
628
629
630
631
632
633
634
635
        const BLOCK_SIZE max_unit_bsize = get_plane_block_size(BLOCK_64X64, pd);
        int mu_blocks_wide =
            block_size_wide[max_unit_bsize] >> tx_size_wide_log2[0];
        int mu_blocks_high =
            block_size_high[max_unit_bsize] >> tx_size_high_log2[0];

        mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);
        mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);

636
637
        const TX_SIZE max_tx_size = get_vartx_max_txsize(
            mbmi, plane_bsize, pd->subsampling_x || pd->subsampling_y);
638
639
        const int bh_var_tx = tx_size_high_unit[max_tx_size];
        const int bw_var_tx = tx_size_wide_unit[max_tx_size];
640
641
642
        int block = 0;
        int step =
            tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658

        for (row = 0; row < max_blocks_high; row += mu_blocks_high) {
          for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) {
            int blk_row, blk_col;
            const int unit_height =
                AOMMIN(mu_blocks_high + row, max_blocks_high);
            const int unit_width =
                AOMMIN(mu_blocks_wide + col, max_blocks_wide);
            for (blk_row = row; blk_row < unit_height; blk_row += bh_var_tx) {
              for (blk_col = col; blk_col < unit_width; blk_col += bw_var_tx) {
                decode_reconstruct_tx(cm, xd, r, mbmi, plane, plane_bsize,
                                      blk_row, blk_col, block, max_tx_size,
                                      &eobtotal);
                block += step;
              }
            }
659
660
          }
        }
661
      }
Jingning Han's avatar
Jingning Han committed
662
663
    }
  }
664
#if CONFIG_CFL
665
666
667
668
669
  if (mbmi->uv_mode != UV_CFL_PRED) {
    if (!cfl->is_chroma_reference && is_inter_block(mbmi)) {
      cfl_store_block(xd, mbmi->sb_type, mbmi->tx_size);
    }
  }
670
#endif  // CONFIG_CFL
Jingning Han's avatar
Jingning Han committed
671

672
673
  int reader_corrupted_flag = aom_reader_has_error(r);
  aom_merge_corrupted_flag(&xd->corrupted, reader_corrupted_flag);
Jingning Han's avatar
Jingning Han committed
674
675
}

676
#if NC_MODE_INFO
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
static void detoken_and_recon_sb(AV1Decoder *const pbi, MACROBLOCKD *const xd,
                                 int mi_row, int mi_col, aom_reader *r,
                                 BLOCK_SIZE bsize) {
  AV1_COMMON *const cm = &pbi->common;
  const int hbs = mi_size_wide[bsize] >> 1;
#if CONFIG_EXT_PARTITION_TYPES
  BLOCK_SIZE bsize2 = get_subsize(bsize, PARTITION_SPLIT);
#endif
  PARTITION_TYPE partition;
  BLOCK_SIZE subsize;
  const int has_rows = (mi_row + hbs) < cm->mi_rows;
  const int has_cols = (mi_col + hbs) < cm->mi_cols;

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

  partition = get_partition(cm, mi_row, mi_col, bsize);
  subsize = subsize_lookup[partition][bsize];

695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
  switch (partition) {
    case PARTITION_NONE:
      decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, bsize);
      break;
    case PARTITION_HORZ:
      decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, subsize);
      if (has_rows)
        decode_token_and_recon_block(pbi, xd, mi_row + hbs, mi_col, r, subsize);
      break;
    case PARTITION_VERT:
      decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, subsize);
      if (has_cols)
        decode_token_and_recon_block(pbi, xd, mi_row, mi_col + hbs, r, subsize);
      break;
    case PARTITION_SPLIT:
      detoken_and_recon_sb(pbi, xd, mi_row, mi_col, r, subsize);
      detoken_and_recon_sb(pbi, xd, mi_row, mi_col + hbs, r, subsize);
      detoken_and_recon_sb(pbi, xd, mi_row + hbs, mi_col, r, subsize);
      detoken_and_recon_sb(pbi, xd, mi_row + hbs, mi_col + hbs, r, subsize);
      break;
715
#if CONFIG_EXT_PARTITION_TYPES
716
717
718
#if CONFIG_EXT_PARTITION_TYPES_AB
#error NC_MODE_INFO+MOTION_VAR not yet supported for new HORZ/VERT_AB partitions
#endif
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
    case PARTITION_HORZ_A:
      decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, bsize2);
      decode_token_and_recon_block(pbi, xd, mi_row, mi_col + hbs, r, bsize2);
      decode_token_and_recon_block(pbi, xd, mi_row + hbs, mi_col, r, subsize);
      break;
    case PARTITION_HORZ_B:
      decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, subsize);
      decode_token_and_recon_block(pbi, xd, mi_row + hbs, mi_col, r, bsize2);
      decode_token_and_recon_block(pbi, xd, mi_row + hbs, mi_col + hbs, r,
                                   bsize2);
      break;
    case PARTITION_VERT_A:
      decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, bsize2);
      decode_token_and_recon_block(pbi, xd, mi_row + hbs, mi_col, r, bsize2);
      decode_token_and_recon_block(pbi, xd, mi_row, mi_col + hbs, r, subsize);
      break;
    case PARTITION_VERT_B:
      decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, subsize);
      decode_token_and_recon_block(pbi, xd, mi_row, mi_col + hbs, r, bsize2);
      decode_token_and_recon_block(pbi, xd, mi_row + hbs, mi_col + hbs, r,
                                   bsize2);
      break;
741
#endif
742
    default: assert(0 && "Invalid partition type");
743
744
745
746
  }
}
#endif

747
748
749
750
751
752
static void decode_block(AV1Decoder *const pbi, MACROBLOCKD *const xd,
                         int mi_row, int mi_col, aom_reader *r,
#if CONFIG_EXT_PARTITION_TYPES
                         PARTITION_TYPE partition,
#endif  // CONFIG_EXT_PARTITION_TYPES
                         BLOCK_SIZE bsize) {
753
  decode_mbmi_block(pbi, xd, mi_row, mi_col, r,
754
755
756
757
#if CONFIG_EXT_PARTITION_TYPES
                    partition,
#endif
                    bsize);
758

759
#if !(NC_MODE_INFO)
760
  decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, bsize);
761
#endif
762
763
}

Yaowu Xu's avatar
Yaowu Xu committed
764
765
static PARTITION_TYPE read_partition(AV1_COMMON *cm, MACROBLOCKD *xd,
                                     int mi_row, int mi_col, aom_reader *r,
766
                                     int has_rows, int has_cols,
767
                                     BLOCK_SIZE bsize) {
768
769
770
771
#if CONFIG_UNPOISON_PARTITION_CTX
  const int ctx =
      partition_plane_context(xd, mi_row, mi_col, has_rows, has_cols, bsize);
#else
772
  const int ctx = partition_plane_context(xd, mi_row, mi_col, bsize);
773
#endif
Jingning Han's avatar
Jingning Han committed
774
  PARTITION_TYPE p;
775
776
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  (void)cm;
Jingning Han's avatar
Jingning Han committed
777

Jingning Han's avatar
Jingning Han committed
778
779
  aom_cdf_prob *partition_cdf = (ctx >= 0) ? ec_ctx->partition_cdf[ctx] : NULL;

780
  if (has_rows && has_cols) {
781
#if CONFIG_EXT_PARTITION_TYPES
782
783
784
785
    const int num_partition_types =
        (mi_width_log2_lookup[bsize] > mi_width_log2_lookup[BLOCK_8X8])
            ? EXT_PARTITION_TYPES
            : PARTITION_TYPES;
786
#else
787
    const int num_partition_types = PARTITION_TYPES;
788
#endif  // CONFIG_EXT_PARTITION_TYPES
789
790
    p = (PARTITION_TYPE)aom_read_symbol(r, partition_cdf, num_partition_types,
                                        ACCT_STR);
791
  } else if (!has_rows && has_cols) {
792
793
794
795
796
797
    assert(bsize > BLOCK_8X8);
    aom_cdf_prob cdf[2];
    partition_gather_vert_alike(cdf, partition_cdf);
    assert(cdf[1] == AOM_ICDF(CDF_PROB_TOP));
    p = aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_HORZ;
    // gather cols
798
  } else if (has_rows && !has_cols) {
799
800
801
802
803
    assert(bsize > BLOCK_8X8);
    aom_cdf_prob cdf[2];
    partition_gather_horz_alike(cdf, partition_cdf);
    assert(cdf[1] == AOM_ICDF(CDF_PROB_TOP));
    p = aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_VERT;
804
  } else {
Jingning Han's avatar
Jingning Han committed
805
    p = PARTITION_SPLIT;
806
  }
Jingning Han's avatar
Jingning Han committed
807
808
809
810
811

  return p;
}

// TODO(slavarnway): eliminate bsize and subsize in future commits
Yaowu Xu's avatar
Yaowu Xu committed
812
813
static void decode_partition(AV1Decoder *const pbi, MACROBLOCKD *const xd,
                             int mi_row, int mi_col, aom_reader *r,
814
                             BLOCK_SIZE bsize) {
Yaowu Xu's avatar
Yaowu Xu committed
815
  AV1_COMMON *const cm = &pbi->common;
816
  const int num_8x8_wh = mi_size_wide[bsize];
Jingning Han's avatar
Jingning Han committed
817
  const int hbs = num_8x8_wh >> 1;
818
819
820
#if CONFIG_EXT_PARTITION_TYPES && CONFIG_EXT_PARTITION_TYPES_AB
  const int qbs = num_8x8_wh >> 2;
#endif
Jingning Han's avatar
Jingning Han committed
821
822
  PARTITION_TYPE partition;
  BLOCK_SIZE subsize;
823
#if CONFIG_EXT_PARTITION_TYPES
824
825
  const int quarter_step = num_8x8_wh / 4;
  int i;
826
827
828
#if !CONFIG_EXT_PARTITION_TYPES_AB
  BLOCK_SIZE bsize2 = get_subsize(bsize, PARTITION_SPLIT);
#endif
829
#endif
Jingning Han's avatar
Jingning Han committed
830
831
832
  const int has_rows = (mi_row + hbs) < cm->mi_rows;
  const int has_cols = (mi_col + hbs) < cm->mi_cols;

833
  if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols) return;
Jingning Han's avatar
Jingning Han committed
834

835
836
837
  partition = (bsize < BLOCK_8X8) ? PARTITION_NONE
                                  : read_partition(cm, xd, mi_row, mi_col, r,
                                                   has_rows, has_cols, bsize);
Jingning Han's avatar
Jingning Han committed
838
  subsize = subsize_lookup[partition][bsize];  // get_subsize(bsize, partition);
839

840
841
842
843
844
845
846
847
848
  // Check the bitstream is conformant: if there is subsampling on the
  // chroma planes, subsize must subsample to a valid block size.
  const struct macroblockd_plane *const pd_u = &xd->plane[1];
  if (get_plane_block_size(subsize, pd_u) == BLOCK_INVALID) {
    aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
                       "Block size %dx%d invalid with this subsampling mode",
                       block_size_wide[subsize], block_size_high[subsize]);
  }

849
850
851
852
853
854
855
856
857
858
859
860
#define DEC_BLOCK_STX_ARG
#if CONFIG_EXT_PARTITION_TYPES
#define DEC_BLOCK_EPT_ARG partition,
#else
#define DEC_BLOCK_EPT_ARG
#endif
#define DEC_BLOCK(db_r, db_c, db_subsize)                   \
  decode_block(pbi, xd, DEC_BLOCK_STX_ARG(db_r), (db_c), r, \
               DEC_BLOCK_EPT_ARG(db_subsize))
#define DEC_PARTITION(db_r, db_c, db_subsize) \
  decode_partition(pbi, xd, DEC_BLOCK_STX_ARG(db_r), (db_c), r, (db_subsize))

861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
  switch (partition) {
    case PARTITION_NONE: DEC_BLOCK(mi_row, mi_col, subsize); break;
    case PARTITION_HORZ:
      DEC_BLOCK(mi_row, mi_col, subsize);
      if (has_rows) DEC_BLOCK(mi_row + hbs, mi_col, subsize);
      break;
    case PARTITION_VERT:
      DEC_BLOCK(mi_row, mi_col, subsize);
      if (has_cols) DEC_BLOCK(mi_row, mi_col + hbs, subsize);
      break;
    case PARTITION_SPLIT:
      DEC_PARTITION(mi_row, mi_col, subsize);
      DEC_PARTITION(mi_row, mi_col + hbs, subsize);
      DEC_PARTITION(mi_row + hbs, mi_col, subsize);
      DEC_PARTITION(mi_row + hbs, mi_col + hbs, subsize);
      break;
877
#if CONFIG_EXT_PARTITION_TYPES
878
#if CONFIG_EXT_PARTITION_TYPES_AB
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
    case PARTITION_HORZ_A:
      DEC_BLOCK(mi_row, mi_col, get_subsize(bsize, PARTITION_HORZ_4));
      DEC_BLOCK(mi_row + qbs, mi_col, get_subsize(bsize, PARTITION_HORZ_4));
      DEC_BLOCK(mi_row + hbs, mi_col, subsize);
      break;
    case PARTITION_HORZ_B:
      DEC_BLOCK(mi_row, mi_col, subsize);
      DEC_BLOCK(mi_row + hbs, mi_col, get_subsize(bsize, PARTITION_HORZ_4));
      if (mi_row + 3 * qbs < cm->mi_rows)
        DEC_BLOCK(mi_row + 3 * qbs, mi_col,
                  get_subsize(bsize, PARTITION_HORZ_4));
      break;
    case PARTITION_VERT_A:
      DEC_BLOCK(mi_row, mi_col, get_subsize(bsize, PARTITION_VERT_4));
      DEC_BLOCK(mi_row, mi_col + qbs, get_subsize(bsize, PARTITION_VERT_4));
      DEC_BLOCK(mi_row, mi_col + hbs, subsize);
      break;
    case PARTITION_VERT_B:
      DEC_BLOCK(mi_row, mi_col, subsize);
      DEC_BLOCK(mi_row, mi_col + hbs, get_subsize(bsize, PARTITION_VERT_4));
      if (mi_col + 3 * qbs < cm->mi_cols)
        DEC_BLOCK(mi_row, mi_col + 3 * qbs,
                  get_subsize(bsize, PARTITION_VERT_4));
      break;
903
#else
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
    case PARTITION_HORZ_A:
      DEC_BLOCK(mi_row, mi_col, bsize2);
      DEC_BLOCK(mi_row, mi_col + hbs, bsize2);
      DEC_BLOCK(mi_row + hbs, mi_col, subsize);
      break;
    case PARTITION_HORZ_B:
      DEC_BLOCK(mi_row, mi_col, subsize);
      DEC_BLOCK(mi_row + hbs, mi_col, bsize2);
      DEC_BLOCK(mi_row + hbs, mi_col + hbs, bsize2);
      break;
    case PARTITION_VERT_A:
      DEC_BLOCK(mi_row, mi_col, bsize2);
      DEC_BLOCK(mi_row + hbs, mi_col, bsize2);
      DEC_BLOCK(mi_row, mi_col + hbs, subsize);
      break;
    case PARTITION_VERT_B:
      DEC_BLOCK(mi_row, mi_col, subsize);
      DEC_BLOCK(mi_row, mi_col + hbs, bsize2);
      DEC_BLOCK(mi_row + hbs, mi_col + hbs, bsize2);
      break;
924
#endif
925
926
927
928
929
930
931
932
933
934
935
936
937
938
    case PARTITION_HORZ_4:
      for (i = 0; i < 4; ++i) {
        int this_mi_row = mi_row + i * quarter_step;
        if (i > 0 && this_mi_row >= cm->mi_rows) break;
        DEC_BLOCK(this_mi_row, mi_col, subsize);
      }
      break;
    case PARTITION_VERT_4:
      for (i = 0; i < 4; ++i) {
        int this_mi_col = mi_col + i * quarter_step;
        if (i > 0 && this_mi_col >= cm->mi_cols) break;
        DEC_BLOCK(mi_row, this_mi_col, subsize);
      }
      break;
939
#endif  // CONFIG_EXT_PARTITION_TYPES
940
    default: assert(0 && "Invalid partition type");
Jingning Han's avatar
Jingning Han committed
941
942
  }

943
944
945
946
947
#undef DEC_PARTITION
#undef DEC_BLOCK
#undef DEC_BLOCK_EPT_ARG
#undef DEC_BLOCK_STX_ARG

948
#if CONFIG_EXT_PARTITION_TYPES
949
  update_ext_partition_context(xd, mi_row, mi_col, subsize, bsize, partition);
950
#else
Jingning Han's avatar
Jingning Han committed
951
952
953
  // update partition context
  if (bsize >= BLOCK_8X8 &&
      (bsize == BLOCK_8X8 || partition != PARTITION_SPLIT))
954
    update_partition_context(xd, mi_row, mi_col, subsize, bsize);
955
#endif  // CONFIG_EXT_PARTITION_TYPES
956

957
958
#if CONFIG_LPF_SB
  if (bsize == cm->sb_size) {
959
960
961
    int filt_lvl;
    if (mi_row