decodeframe.c 130 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
#include "aom_ports/aom_timer.h"
27
28
#include "aom_ports/mem.h"
#include "aom_ports/mem_ops.h"
Yaowu Xu's avatar
Yaowu Xu committed
29
30
#include "aom_scale/aom_scale.h"
#include "aom_util/aom_thread.h"
Jingning Han's avatar
Jingning Han committed
31

Angie Chiang's avatar
Angie Chiang committed
32
#if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
33
#include "aom_util/debug_util.h"
Angie Chiang's avatar
Angie Chiang committed
34
#endif  // CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
35

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

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

Yue Chen's avatar
Yue Chen committed
67
68
#include "av1/common/warped_motion.h"

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

72
73
74
75
#if CONFIG_CFL
#include "av1/common/cfl.h"
#endif

76
77
78
79
#if CONFIG_STRIPED_LOOP_RESTORATION && !CONFIG_LOOP_RESTORATION
#error "striped_loop_restoration requires loop_restoration"
#endif

80
81
82
83
84
85
86
#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

87
88
89
90
91
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
92
static void setup_compound_reference_mode(AV1_COMMON *cm) {
93
  cm->comp_fwd_ref[0] = LAST_FRAME;
94
95
96
97
  cm->comp_fwd_ref[1] = LAST2_FRAME;
  cm->comp_fwd_ref[2] = LAST3_FRAME;
  cm->comp_fwd_ref[3] = GOLDEN_FRAME;

98
  cm->comp_bwd_ref[0] = BWDREF_FRAME;
Zoe Liu's avatar
Zoe Liu committed
99
100
  cm->comp_bwd_ref[1] = ALTREF2_FRAME;
  cm->comp_bwd_ref[2] = ALTREF_FRAME;
Jingning Han's avatar
Jingning Han committed
101
102
103
104
105
106
}

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

107
108
109
110
111
112
#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;
  return aom_rb_read_bit(rb) ? TX_MODE_SELECT : TX_MODE_LARGEST;
}
#else
113
114
static TX_MODE read_tx_mode(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
  if (cm->all_lossless) return ONLY_4X4;
115
#if CONFIG_TX64X64
Urvang Joshi's avatar
Urvang Joshi committed
116
117
  TX_MODE tx_mode =
      aom_rb_read_bit(rb) ? TX_MODE_SELECT : aom_rb_read_literal(rb, 2);
118
119
120
  if (tx_mode == ALLOW_32X32) tx_mode += aom_rb_read_bit(rb);
  return tx_mode;
#else
Yaowu Xu's avatar
Yaowu Xu committed
121
  return aom_rb_read_bit(rb) ? TX_MODE_SELECT : aom_rb_read_literal(rb, 2);
122
#endif  // CONFIG_TX64X64
123
}
124
#endif  // CONFIG_SIMPLIFY_TX_MODE
Jingning Han's avatar
Jingning Han committed
125

126
static REFERENCE_MODE read_frame_reference_mode(
Yaowu Xu's avatar
Yaowu Xu committed
127
    const AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
128
  if (av1_is_compound_reference_allowed(cm)) {
Zoe Liu's avatar
Zoe Liu committed
129
130
131
#if CONFIG_REF_ADAPT
    return aom_rb_read_bit(rb) ? REFERENCE_MODE_SELECT : SINGLE_REFERENCE;
#else
Yaowu Xu's avatar
Yaowu Xu committed
132
    return aom_rb_read_bit(rb)
133
               ? REFERENCE_MODE_SELECT
Yaowu Xu's avatar
Yaowu Xu committed
134
               : (aom_rb_read_bit(rb) ? COMPOUND_REFERENCE : SINGLE_REFERENCE);
Zoe Liu's avatar
Zoe Liu committed
135
#endif  // CONFIG_REF_ADAPT
136
137
138
139
  } else {
    return SINGLE_REFERENCE;
  }
}
Jingning Han's avatar
Jingning Han committed
140

141
static void inverse_transform_block(MACROBLOCKD *xd, int plane,
142
                                    const TX_TYPE tx_type,
143
                                    const TX_SIZE tx_size, uint8_t *dst,
144
145
                                    int stride, int16_t scan_line, int eob,
                                    int reduced_tx_set) {
Jingning Han's avatar
Jingning Han committed
146
  struct macroblockd_plane *const pd = &xd->plane[plane];
147
  tran_low_t *const dqcoeff = pd->dqcoeff;
Sebastien Alaiwan's avatar
Sebastien Alaiwan committed
148
149
  av1_inverse_transform_block(xd, dqcoeff, plane, tx_type, tx_size, dst, stride,
                              eob, reduced_tx_set);
150
  memset(dqcoeff, 0, (scan_line + 1) * sizeof(dqcoeff[0]));
Jingning Han's avatar
Jingning Han committed
151
152
}

153
154
155
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) {
156
  PLANE_TYPE plane_type = get_plane_type(plane);
Luc Trudeau's avatar
Luc Trudeau committed
157
  av1_predict_intra_block_facade(cm, xd, plane, col, row, tx_size);
Jingning Han's avatar
Jingning Han committed
158
159

  if (!mbmi->skip) {
160
    struct macroblockd_plane *const pd = &xd->plane[plane];
161
162
163
164
#if TXCOEFF_TIMER
    struct aom_usec_timer timer;
    aom_usec_timer_start(&timer);
#endif
Angie Chiang's avatar
Angie Chiang committed
165
166
#if CONFIG_LV_MAP
    int16_t max_scan_line = 0;
167
    int eob;
Luc Trudeau's avatar
Luc Trudeau committed
168
    av1_read_coeffs_txb_facade(cm, xd, r, row, col, plane, tx_size,
169
                               &max_scan_line, &eob);
170
    // tx_type will be read out in av1_read_coeffs_txb_facade
Luc Trudeau's avatar
Luc Trudeau committed
171
    const TX_TYPE tx_type = av1_get_tx_type(plane_type, xd, row, col, tx_size);
Angie Chiang's avatar
Angie Chiang committed
172
#else   // CONFIG_LV_MAP
Luc Trudeau's avatar
Luc Trudeau committed
173
    const TX_TYPE tx_type = av1_get_tx_type(plane_type, xd, row, col, tx_size);
Angie Chiang's avatar
Angie Chiang committed
174
    const SCAN_ORDER *scan_order = get_scan(cm, tx_size, tx_type, mbmi);
175
176
    int16_t max_scan_line = 0;
    const int eob =
177
        av1_decode_block_tokens(cm, xd, plane, scan_order, col, row, tx_size,
178
                                tx_type, &max_scan_line, r, mbmi->segment_id);
Angie Chiang's avatar
Angie Chiang committed
179
#endif  // CONFIG_LV_MAP
180
181
182
183
184
185
186

#if TXCOEFF_TIMER
    aom_usec_timer_mark(&timer);
    const int64_t elapsed_time = aom_usec_timer_elapsed(&timer);
    cm->txcoeff_timer += elapsed_time;
    ++cm->txb_count;
#endif
187
188
189
    if (eob) {
      uint8_t *dst =
          &pd->dst.buf[(row * pd->dst.stride + col) << tx_size_wide_log2[0]];
190
      inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride,
191
                              max_scan_line, eob, cm->reduced_tx_set_used);
192
    }
Jingning Han's avatar
Jingning Han committed
193
  }
194
#if CONFIG_CFL
195
  if (plane == AOM_PLANE_Y && xd->cfl.store_y && is_cfl_allowed(mbmi)) {
196
    cfl_store_tx(xd, row, col, tx_size, mbmi->sb_type);
197
  }
Sebastien Alaiwan's avatar
Sebastien Alaiwan committed
198
#endif  // CONFIG_CFL
Jingning Han's avatar
Jingning Han committed
199
200
}

Angie Chiang's avatar
Angie Chiang committed
201
202
static void decode_reconstruct_tx(AV1_COMMON *cm, MACROBLOCKD *const xd,
                                  aom_reader *r, MB_MODE_INFO *const mbmi,
203
                                  int plane, BLOCK_SIZE plane_bsize,
204
                                  int blk_row, int blk_col, int block,
Angie Chiang's avatar
Angie Chiang committed
205
206
207
208
                                  TX_SIZE tx_size, int *eob_total, int mi_row,
                                  int mi_col) {
  (void)mi_row;
  (void)mi_col;
209
  const struct macroblockd_plane *const pd = &xd->plane[plane];
210
211
  const int tx_row = blk_row >> (1 - pd->subsampling_y);
  const int tx_col = blk_col >> (1 - pd->subsampling_x);
212
  const TX_SIZE plane_tx_size =
213
      plane ? av1_get_uv_tx_size(mbmi, pd->subsampling_x, pd->subsampling_y)
214
            : mbmi->inter_tx_size[tx_row][tx_col];
215
  // Scale to match transform block unit.
216
217
  const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
  const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
218

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

221
  if (tx_size == plane_tx_size || plane) {
222
    PLANE_TYPE plane_type = get_plane_type(plane);
223
224
225
226
#if TXCOEFF_TIMER
    struct aom_usec_timer timer;
    aom_usec_timer_start(&timer);
#endif
Angie Chiang's avatar
Angie Chiang committed
227
228
#if CONFIG_LV_MAP
    int16_t max_scan_line = 0;
229
    int eob;
Luc Trudeau's avatar
Luc Trudeau committed
230
231
    av1_read_coeffs_txb_facade(cm, xd, r, blk_row, blk_col, plane, tx_size,
                               &max_scan_line, &eob);
232
    // tx_type will be read out in av1_read_coeffs_txb_facade
hui su's avatar
hui su committed
233
    const TX_TYPE tx_type =
Luc Trudeau's avatar
Luc Trudeau committed
234
        av1_get_tx_type(plane_type, xd, blk_row, blk_col, tx_size);
Angie Chiang's avatar
Angie Chiang committed
235
#else   // CONFIG_LV_MAP
hui su's avatar
hui su committed
236
    const TX_TYPE tx_type =
Luc Trudeau's avatar
Luc Trudeau committed
237
        av1_get_tx_type(plane_type, xd, blk_row, blk_col, tx_size);
238
    const SCAN_ORDER *sc = get_scan(cm, tx_size, tx_type, mbmi);
239
    int16_t max_scan_line = 0;
240
241
242
    const int eob =
        av1_decode_block_tokens(cm, xd, plane, sc, blk_col, blk_row, tx_size,
                                tx_type, &max_scan_line, r, mbmi->segment_id);
Angie Chiang's avatar
Angie Chiang committed
243
#endif  // CONFIG_LV_MAP
244
245
246
247
248
249
250
251

#if TXCOEFF_TIMER
    aom_usec_timer_mark(&timer);
    const int64_t elapsed_time = aom_usec_timer_elapsed(&timer);
    cm->txcoeff_timer += elapsed_time;
    ++cm->txb_count;
#endif

Angie Chiang's avatar
Angie Chiang committed
252
    uint8_t *dst =
253
        &pd->dst
Angie Chiang's avatar
Angie Chiang committed
254
255
256
257
258
             .buf[(blk_row * pd->dst.stride + blk_col) << tx_size_wide_log2[0]];
    inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride,
                            max_scan_line, eob, cm->reduced_tx_set_used);
#if CONFIG_MISMATCH_DEBUG
    int pixel_c, pixel_r;
259
260
    int blk_w = block_size_wide[bsize];
    int blk_h = block_size_high[bsize];
Angie Chiang's avatar
Angie Chiang committed
261
262
263
264
265
    mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, blk_col, blk_row,
                    pd->subsampling_x, pd->subsampling_y);
    mismatch_check_block_tx(dst, pd->dst.stride, plane, pixel_c, pixel_r, blk_w,
                            blk_h);
#endif
266
267
    *eob_total += eob;
  } else {
268
    const TX_SIZE sub_txs = sub_tx_size_map[1][tx_size];
269
270
    assert(IMPLIES(tx_size <= TX_4X4, sub_txs == tx_size));
    assert(IMPLIES(tx_size > TX_4X4, sub_txs < tx_size));
271
272
273
    const int bsw = tx_size_wide_unit[sub_txs];
    const int bsh = tx_size_high_unit[sub_txs];
    const int sub_step = bsw * bsh;
274

275
    assert(bsw > 0 && bsh > 0);
276

277
278
279
280
    for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) {
      for (int col = 0; col < tx_size_wide_unit[tx_size]; col += bsw) {
        const int offsetr = blk_row + row;
        const int offsetc = blk_col + col;
281

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

284
        decode_reconstruct_tx(cm, xd, r, mbmi, plane, plane_bsize, offsetr,
Angie Chiang's avatar
Angie Chiang committed
285
286
                              offsetc, block, sub_txs, eob_total, mi_row,
                              mi_col);
287
288
        block += sub_step;
      }
289
290
291
    }
  }
}
Jingning Han's avatar
Jingning Han committed
292

293
294
295
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
296
297
298
299
300
301
302
303
  const int offset = mi_row * cm->mi_stride + mi_col;
  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;
304
305
306
#if CONFIG_RD_DEBUG
  xd->mi[0]->mbmi.mi_row = mi_row;
  xd->mi[0]->mbmi.mi_col = mi_col;
307
308
#endif
#if CONFIG_CFL
309
310
  xd->cfl.mi_row = mi_row;
  xd->cfl.mi_col = mi_col;
311
#endif
312
313

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

Jingning Han's avatar
Jingning Han committed
321
  set_plane_n4(xd, bw, bh);
Jingning Han's avatar
Jingning Han committed
322
323
  set_skip_context(xd, mi_row, mi_col);

324
325
326
  // 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,
327
#if CONFIG_DEPENDENT_HORZTILES
328
329
330
                 cm->dependent_horz_tiles,
#endif  // CONFIG_DEPENDENT_HORZTILES
                 cm->mi_rows, cm->mi_cols);
Jingning Han's avatar
Jingning Han committed
331

332
333
  av1_setup_dst_planes(xd->plane, bsize, get_frame_new_buffer(cm), mi_row,
                       mi_col);
Jingning Han's avatar
Jingning Han committed
334
335
}

336
337
static void decode_mbmi_block(AV1Decoder *const pbi, MACROBLOCKD *const xd,
                              int mi_row, int mi_col, aom_reader *r,
338
#if CONFIG_EXT_PARTITION_TYPES
339
                              PARTITION_TYPE partition,
340
#endif  // CONFIG_EXT_PARTITION_TYPES
341
                              BLOCK_SIZE bsize) {
Yaowu Xu's avatar
Yaowu Xu committed
342
  AV1_COMMON *const cm = &pbi->common;
343
344
  const int bw = mi_size_wide[bsize];
  const int bh = mi_size_high[bsize];
Yaowu Xu's avatar
Yaowu Xu committed
345
346
  const int x_mis = AOMMIN(bw, cm->mi_cols - mi_col);
  const int y_mis = AOMMIN(bh, cm->mi_rows - mi_row);
347

Michael Bebenita's avatar
Michael Bebenita committed
348
349
350
#if CONFIG_ACCOUNTING
  aom_accounting_set_context(&pbi->accounting, mi_col, mi_row);
#endif
351
  set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis);
352
353
354
#if CONFIG_EXT_PARTITION_TYPES
  xd->mi[0]->mbmi.partition = partition;
#endif
Yaowu Xu's avatar
Yaowu Xu committed
355
  av1_read_mode_info(pbi, xd, mi_row, mi_col, r, x_mis, y_mis);
Jingning Han's avatar
Jingning Han committed
356
357
358
359
  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
360
      aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
361
                         "Invalid block size.");
Jingning Han's avatar
Jingning Han committed
362
363
  }

364
365
  int reader_corrupted_flag = aom_reader_has_error(r);
  aom_merge_corrupted_flag(&xd->corrupted, reader_corrupted_flag);
366
367
368
369
370
371
372
373
374
375
376
377
}

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

378
379
  set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis);
  MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
380
#if CONFIG_CFL
381
  CFL_CTX *const cfl = &xd->cfl;
382
383
  cfl->is_chroma_reference = is_chroma_reference(
      mi_row, mi_col, bsize, cfl->subsampling_x, cfl->subsampling_y);
384
#endif  // CONFIG_CFL
385

386
  if (cm->delta_q_present_flag) {
387
    for (int i = 0; i < MAX_SEGMENTS; i++) {
Fangwen Fu's avatar
Fangwen Fu committed
388
#if CONFIG_EXT_DELTA_Q
389
390
      const int current_qindex =
          av1_get_qindex(&cm->seg, i, xd->current_qindex);
Fangwen Fu's avatar
Fangwen Fu committed
391
#else
392
393
      const int current_qindex = xd->current_qindex;
#endif  // CONFIG_EXT_DELTA_Q
394
      for (int j = 0; j < av1_num_planes(cm); ++j) {
395
396
397
398
399
        const int dc_delta_q =
            j == 0 ? cm->y_dc_delta_q
                   : (j == 1 ? cm->u_dc_delta_q : cm->v_dc_delta_q);
        const int ac_delta_q =
            j == 0 ? 0 : (j == 1 ? cm->u_ac_delta_q : cm->v_ac_delta_q);
400
401
402
403
        xd->plane[j].seg_dequant_QTX[i][0] =
            av1_dc_quant_QTX(current_qindex, dc_delta_q, cm->bit_depth);
        xd->plane[j].seg_dequant_QTX[i][1] =
            av1_ac_quant_QTX(current_qindex, ac_delta_q, cm->bit_depth);
404
      }
405
406
    }
  }
407
  if (mbmi->skip) av1_reset_skip_context(xd, mi_row, mi_col, bsize);
408

409
  if (!is_inter_block(mbmi)) {
410
411
    const int num_planes = av1_num_planes(cm);
    for (int plane = 0; plane < AOMMIN(2, num_planes); ++plane) {
412
      if (mbmi->palette_mode_info.palette_size[plane])
Yaowu Xu's avatar
Yaowu Xu committed
413
        av1_decode_palette_tokens(xd, plane, r);
Jingning Han's avatar
Jingning Han committed
414
    }
415

416
    for (int plane = 0; plane < num_planes; ++plane) {
417
      const struct macroblockd_plane *const pd = &xd->plane[plane];
418
      const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
419
420
      const int stepr = tx_size_high_unit[tx_size];
      const int stepc = tx_size_wide_unit[tx_size];
421
      const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
422
      int row, col;
423
424
      const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
      const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
425
426
      if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x,
                               pd->subsampling_y))
427
        continue;
428
429
430
431
432
433
434
435
436
437
      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) {
438
        const int unit_height = AOMMIN(mu_blocks_high + row, max_blocks_high);
439
440
441
442
443
444
445
446
447
        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);
        }
      }
448
449
    }
  } else {
450
    for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) {
451
      const MV_REFERENCE_FRAME frame = mbmi->ref_frame[ref];
Alex Converse's avatar
Alex Converse committed
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
      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);
      }
470
    }
471

472
    av1_build_inter_predictors_sb(cm, xd, mi_row, mi_col, NULL, bsize);
473

Yue Chen's avatar
Yue Chen committed
474
    if (mbmi->motion_mode == OBMC_CAUSAL) {
475
      av1_build_obmc_inter_predictors_sb(cm, xd, mi_row, mi_col);
476
    }
Angie Chiang's avatar
Angie Chiang committed
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491

#if CONFIG_MISMATCH_DEBUG
    for (int plane = 0; plane < 3; ++plane) {
      const struct macroblockd_plane *pd = &xd->plane[plane];
      int pixel_c, pixel_r;
      mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, 0, 0,
                      pd->subsampling_x, pd->subsampling_y);
      if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x,
                               pd->subsampling_y))
        continue;
      mismatch_check_block_pre(pd->dst.buf, pd->dst.stride, plane, pixel_c,
                               pixel_r, pd->width, pd->height);
    }
#endif

492
493
494
    // Reconstruction
    if (!mbmi->skip) {
      int eobtotal = 0;
495
      for (int plane = 0; plane < av1_num_planes(cm); ++plane) {
Jingning Han's avatar
Jingning Han committed
496
        const struct macroblockd_plane *const pd = &xd->plane[plane];
497
498
499
500
501
        if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x,
                                 pd->subsampling_y))
          continue;
        const BLOCK_SIZE bsizec =
            scale_chroma_bsize(bsize, pd->subsampling_x, pd->subsampling_y);
502
        const BLOCK_SIZE plane_bsize = get_plane_block_size(bsizec, pd);
503
504
        const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
        const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
505
        int row, col;
506

507
508
509
510
511
512
513
514
515
        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);

516
        TX_SIZE max_tx_size = get_vartx_max_txsize(
517
            xd, plane_bsize, pd->subsampling_x || pd->subsampling_y);
518
519
        const int bh_var_tx = tx_size_high_unit[max_tx_size];
        const int bw_var_tx = tx_size_wide_unit[max_tx_size];
520
521
522
        int block = 0;
        int step =
            tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
523
524
525
526
527
528
529
530
531
532
533
534

        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,
Angie Chiang's avatar
Angie Chiang committed
535
                                      &eobtotal, mi_row, mi_col);
536
537
538
                block += step;
              }
            }
539
540
          }
        }
541
      }
Jingning Han's avatar
Jingning Han committed
542
543
    }
  }
544
#if CONFIG_CFL
545
  if (mbmi->uv_mode != UV_CFL_PRED) {
546
    if (!cfl->is_chroma_reference && is_inter_block(mbmi) &&
547
        is_cfl_allowed(mbmi)) {
548
549
550
      cfl_store_block(xd, mbmi->sb_type, mbmi->tx_size);
    }
  }
551
#endif  // CONFIG_CFL
Jingning Han's avatar
Jingning Han committed
552

553
554
  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
555
556
}

557
558
559
560
561
562
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) {
563
  decode_mbmi_block(pbi, xd, mi_row, mi_col, r,
564
565
566
567
#if CONFIG_EXT_PARTITION_TYPES
                    partition,
#endif
                    bsize);
568

569
  decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, bsize);
570
571
}

572
573
static PARTITION_TYPE read_partition(MACROBLOCKD *xd, int mi_row, int mi_col,
                                     aom_reader *r, int has_rows, int has_cols,
574
575
                                     BLOCK_SIZE bsize) {
  const int ctx = partition_plane_context(xd, mi_row, mi_col, bsize);
576
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
Jingning Han's avatar
Jingning Han committed
577

578
  if (!has_rows && !has_cols) return PARTITION_SPLIT;
Jingning Han's avatar
Jingning Han committed
579

580
581
  assert(ctx >= 0);
  aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[ctx];
582
  if (has_rows && has_cols) {
583
584
    return (PARTITION_TYPE)aom_read_symbol(
        r, partition_cdf, partition_cdf_length(bsize), ACCT_STR);
585
  } else if (!has_rows && has_cols) {
586
587
    assert(bsize > BLOCK_8X8);
    aom_cdf_prob cdf[2];
588
    partition_gather_vert_alike(cdf, partition_cdf, bsize);
589
    assert(cdf[1] == AOM_ICDF(CDF_PROB_TOP));
590
591
592
    return aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_HORZ;
  } else {
    assert(has_rows && !has_cols);
593
594
    assert(bsize > BLOCK_8X8);
    aom_cdf_prob cdf[2];
595
    partition_gather_horz_alike(cdf, partition_cdf, bsize);
596
    assert(cdf[1] == AOM_ICDF(CDF_PROB_TOP));
597
    return aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_VERT;
598
  }
Jingning Han's avatar
Jingning Han committed
599
600
601
}

// TODO(slavarnway): eliminate bsize and subsize in future commits
Yaowu Xu's avatar
Yaowu Xu committed
602
603
static void decode_partition(AV1Decoder *const pbi, MACROBLOCKD *const xd,
                             int mi_row, int mi_col, aom_reader *r,
604
                             BLOCK_SIZE bsize) {
Yaowu Xu's avatar
Yaowu Xu committed
605
  AV1_COMMON *const cm = &pbi->common;
606
  const int num_8x8_wh = mi_size_wide[bsize];
Jingning Han's avatar
Jingning Han committed
607
608
609
  const int hbs = num_8x8_wh >> 1;
  PARTITION_TYPE partition;
  BLOCK_SIZE subsize;
610
#if CONFIG_EXT_PARTITION_TYPES
611
  const int quarter_step = num_8x8_wh / 4;
612
  BLOCK_SIZE bsize2 = get_subsize(bsize, PARTITION_SPLIT);
613
#endif
Jingning Han's avatar
Jingning Han committed
614
615
616
  const int has_rows = (mi_row + hbs) < cm->mi_rows;
  const int has_cols = (mi_col + hbs) < cm->mi_cols;

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

619
  partition = (bsize < BLOCK_8X8) ? PARTITION_NONE
620
                                  : read_partition(xd, mi_row, mi_col, r,
621
                                                   has_rows, has_cols, bsize);
Jingning Han's avatar
Jingning Han committed
622
  subsize = subsize_lookup[partition][bsize];  // get_subsize(bsize, partition);
623

624
625
626
627
628
629
630
631
632
  // 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]);
  }

633
634
635
636
637
638
639
640
641
642
643
644
#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))

645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
  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;
661
#if CONFIG_EXT_PARTITION_TYPES
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
    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;
    case PARTITION_HORZ_4:
683
      for (int i = 0; i < 4; ++i) {
684
685
686
687
688
689
        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:
690
      for (int i = 0; i < 4; ++i) {
691
692
693
694
695
        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;
696
#endif  // CONFIG_EXT_PARTITION_TYPES
697
    default: assert(0 && "Invalid partition type");
Jingning Han's avatar
Jingning Han committed
698
699
  }

700
701
702
703
704
#undef DEC_PARTITION
#undef DEC_BLOCK
#undef DEC_BLOCK_EPT_ARG
#undef DEC_BLOCK_STX_ARG

705
#if CONFIG_EXT_PARTITION_TYPES
706
  update_ext_partition_context(xd, mi_row, mi_col, subsize, bsize, partition);
707
#else
Jingning Han's avatar
Jingning Han committed
708
709
710
  // update partition context
  if (bsize >= BLOCK_8X8 &&
      (bsize == BLOCK_8X8 || partition != PARTITION_SPLIT))
711
    update_partition_context(xd, mi_row, mi_col, subsize, bsize);
712
#endif  // CONFIG_EXT_PARTITION_TYPES
713

714
#if CONFIG_LOOP_RESTORATION
715
  for (int plane = 0; plane < av1_num_planes(cm); ++plane) {
716
    int rcol0, rcol1, rrow0, rrow1, tile_tl_idx;
717
718
    if (av1_loop_restoration_corners_in_sb(cm, plane, mi_row, mi_col, bsize,
                                           &rcol0, &rcol1, &rrow0, &rrow1,
719
720
                                           &tile_tl_idx)) {
      const int rstride = cm->rst_info[plane].horz_units_per_tile;
721
722
      for (int rrow = rrow0; rrow < rrow1; ++rrow) {
        for (int rcol = rcol0; rcol < rcol1; ++rcol) {
723
          const int rtile_idx = tile_tl_idx + rcol + rrow * rstride;
724
725
726
727
728
729
          loop_restoration_read_sb_coeffs(cm, xd, r, plane, rtile_idx);
        }
      }
    }
  }
#endif
Jingning Han's avatar
Jingning Han committed
730
731
}

732
static void setup_bool_decoder(const uint8_t *data, const uint8_t *data_end,
Alex Converse's avatar
Alex Converse committed
733
                               const size_t read_size,
Yaowu Xu's avatar
Yaowu Xu committed
734
                               struct aom_internal_error_info *error_info,
735
                               aom_reader *r, uint8_t allow_update_cdf) {
Alex Converse's avatar
Alex Converse committed
736
737
738
739
  // Validate the calculated partition length. If the buffer
  // described by the partition can't be fully read, then restrict
  // it to the portion that can be (for EC mode) or throw an error.
  if (!read_is_valid(data, read_size, data_end))
Yaowu Xu's avatar
Yaowu Xu committed
740
    aom_internal_error(error_info, AOM_CODEC_CORRUPT_FRAME,
Alex Converse's avatar
Alex Converse committed
741
742
                       "Truncated packet or corrupt tile length");

743
  if (aom_reader_init(r, data, read_size))
Yaowu Xu's avatar
Yaowu Xu committed
744
    aom_internal_error(error_info, AOM_CODEC_MEM_ERROR,
Alex Converse's avatar
Alex Converse committed
745
                       "Failed to allocate bool decoder %d", 1);
746
747

  r->allow_update_cdf = allow_update_cdf;
Alex Converse's avatar
Alex Converse committed
748
}
Jingning Han's avatar
Jingning Han committed
749

Yaowu Xu's avatar
Yaowu Xu committed
750
751
static void setup_segmentation(AV1_COMMON *const cm,
                               struct aom_read_bit_buffer *rb) {
752
  struct segmentation *const seg = &cm->seg;
Jingning Han's avatar
Jingning Han committed
753
754
755

  seg->update_map = 0;
  seg->update_data = 0;
756
  seg->temporal_update = 0;
Jingning Han's avatar
Jingning Han committed
757

Yaowu Xu's avatar
Yaowu Xu committed
758
  seg->enabled = aom_rb_read_bit(rb);
759
  if (!seg->enabled) return;
Jingning Han's avatar
Jingning Han committed
760
761

  // Segmentation map update
762
763
764
  if (frame_is_intra_only(cm) || cm->error_resilient_mode) {
    seg->update_map = 1;
  } else {
Yaowu Xu's avatar
Yaowu Xu committed
765
    seg->update_map = aom_rb_read_bit(rb);
766
  }
Jingning Han's avatar
Jingning Han committed
767
  if (seg->update_map) {
768
769
770
    if (frame_is_intra_only(cm) || cm->error_resilient_mode) {
      seg->temporal_update = 0;
    } else {
Yaowu Xu's avatar
Yaowu Xu committed
771
      seg->temporal_update = aom_rb_read_bit(rb);
772
    }
Jingning Han's avatar
Jingning Han committed
773
774
  }

775
776
777
778
#if CONFIG_SPATIAL_SEGMENTATION
  cm->preskip_segid = 0;
#endif

Jingning Han's avatar
Jingning Han committed
779
  // Segmentation data update
Yaowu Xu's avatar
Yaowu Xu committed
780
  seg->update_data = aom_rb_read_bit(rb);
Jingning Han's avatar
Jingning Han committed
781
  if (seg->update_data) {
Yaowu Xu's avatar
Yaowu Xu committed
782
    av1_clearall_segfeatures(seg);
Jingning Han's avatar
Jingning Han committed
783

784
785
    for (int i = 0; i < MAX_SEGMENTS; i++) {
      for (int j = 0; j < SEG_LVL_MAX; j++) {
Jingning Han's avatar
Jingning Han committed
786
        int data = 0;
Yaowu Xu's avatar
Yaowu Xu committed
787
        const int feature_enabled = aom_rb_read_bit(rb);
Jingning Han's avatar
Jingning Han committed
788
        if (feature_enabled) {
789
790
791
792
#if CONFIG_SPATIAL_SEGMENTATION
          cm->preskip_segid |= j >= SEG_LVL_REF_FRAME;
          cm->last_active_segid = i;
#endif
Yaowu Xu's avatar
Yaowu Xu committed
793
          av1_enable_segfeature(seg, i, j);
794
795
796
797
798
799
800
801
802
803
804
805

          const int data_max = av1_seg_feature_data_max(j);
          const int data_min = -data_max;
          const int ubits = get_unsigned_bits(data_max);

          if (av1_is_segfeature_signed(j)) {
            data = aom_rb_read_inv_signed_literal(rb, ubits);
          } else {
            data = aom_rb_read_literal(rb, ubits);
          }

          data = clamp(data, data_min, data_max);
Jingning Han's avatar
Jingning Han committed
806
        }
Yaowu Xu's avatar
Yaowu Xu committed
807
        av1_set_segdata(seg, i, j, data);
Jingning Han's avatar
Jingning Han committed
808
809
810
811
812
      }
    }
  }
}

813
#if CONFIG_LOOP_RESTORATION
814
815
static void decode_restoration_mode(AV1_COMMON *cm,
                                    struct aom_read_bit_buffer *rb) {
816
817
818
#if CONFIG_INTRABC
  if (cm->allow_intrabc && NO_FILTER_FOR_IBC) return;
#endif  // CONFIG_INTRABC
819
820
  int all_none = 1, chroma_none = 1;
  for (int p = 0; p < av1_num_planes(cm); ++p) {
821
    RestorationInfo *rsi = &cm->rst_info[p];
822
823
824
825
    if (aom_rb_read_bit(rb)) {
      rsi->frame_restoration_type =
          aom_rb_read_bit(rb) ? RESTORE_SGRPROJ : RESTORE_WIENER;
    } else {
826
827
      rsi->frame_restoration_type =
          aom_rb_read_bit(rb) ? RESTORE_SWITCHABLE : RESTORE_NONE;
828
    }
829
830
831
832
    if (rsi->frame_restoration_type != RESTORE_NONE) {
      all_none = 0;
      chroma_none &= p == 0;
    }
833
  }
834
  if (!all_none) {
835
836
837
838
839
    const int qsize = RESTORATION_TILESIZE_MAX >> 2;
    for (int p = 0; p < MAX_MB_PLANE; ++p)
      cm->rst_info[p].restoration_unit_size = qsize;

    RestorationInfo *rsi = &cm->rst_info[0];
840
    rsi->restoration_unit_size <<= aom_rb_read_bit(rb);
841
    if (rsi->restoration_unit_size != qsize) {
842
      rsi->restoration_unit_size <<= aom_rb_read_bit(rb);
843
    }
844
845
846
847
  } else {
    const int size = RESTORATION_TILESIZE_MAX;
    for (int p = 0; p < MAX_MB_PLANE; ++p)
      cm->rst_info[p].restoration_unit_size = size;
848
  }
849

850
851
852
853
854
855
856
857
858
859
860
  if (av1_num_planes(cm) > 1) {
    int s = AOMMIN(cm->subsampling_x, cm->subsampling_y);
    if (s && !chroma_none) {
      cm->rst_info[1].restoration_unit_size =
          cm->rst_info[0].restoration_unit_size >> (aom_rb_read_bit(rb) * s);
    } else {
      cm->rst_info[1].restoration_unit_size =
          cm->rst_info[0].restoration_unit_size;
    }
    cm->rst_info[2].restoration_unit_size =
        cm->rst_info[1].restoration_unit_size;
861
  }
862
863
}

864
static void read_wiener_filter(int wiener_win, WienerInfo *wiener_info,
865
                               WienerInfo *ref_wiener_info, aom_reader *rb) {
866
867
868
  memset(wiener_info->vfilter, 0, sizeof(wiener_info->vfilter));
  memset(wiener_info->hfilter, 0, sizeof(wiener_info->hfilter));

869
870
871
872
873
874
875
876
877
  if (wiener_win == WIENER_WIN)
    wiener_info->vfilter[0] = wiener_info->vfilter[WIENER_WIN - 1] =
        aom_read_primitive_refsubexpfin(
            rb, WIENER_FILT_TAP0_MAXV - WIENER_FILT_TAP0_MINV + 1,
            WIENER_FILT_TAP0_SUBEXP_K,
            ref_wiener_info->vfilter[0] - WIENER_FILT_TAP0_MINV, ACCT_STR) +
        WIENER_FILT_TAP0_MINV;
  else
    wiener_info->vfilter[0] = wiener_info->vfilter[WIENER_WIN - 1] = 0;
878
  wiener_info->vfilter[1] = wiener_info->vfilter[WIENER_WIN - 2] =
879
880
881
      aom_read_primitive_refsubexpfin(
          rb, WIENER_FILT_TAP1_MAXV - WIENER_FILT_TAP1_MINV + 1,
          WIENER_FILT_TAP1_SUBEXP_K,
882
          ref_wiener_info->vfilter[1] - WIENER_FILT_TAP1_MINV, ACCT_STR) +
883
      WIENER_FILT_TAP1_MINV;
884
  wiener_info->vfilter[2] = wiener_info->vfilter[WIENER_WIN - 3] =
885
886
887
      aom_read_primitive_refsubexpfin(
          rb, WIENER_FILT_TAP2_MAXV - WIENER_FILT_TAP2_MINV + 1,
          WIENER_FILT_TAP2_SUBEXP_K,
888
          ref_wiener_info->vfilter[2] - WIENER_FILT_TAP2_MINV, ACCT_STR) +
889
      WIENER_FILT_TAP2_MINV;
890
  // The central element has an implicit +WIENER_FILT_STEP
891
  wiener_info->vfilter[WIENER_HALFWIN] =
892
893
894
      -2 * (wiener_info->vfilter[0] + wiener_info->vfilter[1] +
            wiener_info->vfilter[2]);

895
896
897
898
899
900
901
902
903
  if (wiener_win == WIENER_WIN)
    wiener_info->hfilter[0] = wiener_info->hfilter[WIENER_WIN - 1] =
        aom_read_primitive_refsubexpfin(
            rb, WIENER_FILT_TAP0_MAXV - WIENER_FILT_TAP0_MINV + 1,
            WIENER_FILT_TAP0_SUBEXP_K,
            ref_wiener_info->hfilter[0] - WIENER_FILT_TAP0_MINV, ACCT_STR) +
        WIENER_FILT_TAP0_MINV;
  else
    wiener_info->hfilter[0] = wiener_info->hfilter[WIENER_WIN - 1] = 0;
904
  wiener_info->hfilter[1] = wiener_info->hfilter[WIENER_WIN - 2] =
905
906
907
      aom_read_primitive_refsubexpfin(
          rb, WIENER_FILT_TAP1_MAXV - WIENER_FILT_TAP1_MINV + 1,
          WIENER_FILT_TAP1_SUBEXP_K,
908
          ref_wiener_info->hfilter[1] - WIENER_FILT_TAP1_MINV, ACCT_STR) +
909
      WIENER_FILT_TAP1_MINV;
910
  wiener_info->hfilter[2] = wiener_info->hfilter[WIENER_WIN - 3] =