Coverage Report

Created: 2025-06-13 07:07

/src/aom/av1/decoder/decodeframe.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved.
3
 *
4
 * This source code is subject to the terms of the BSD 2 Clause License and
5
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6
 * was not distributed with this source code in the LICENSE file, you can
7
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8
 * Media Patent License 1.0 was not distributed with this source code in the
9
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10
 */
11
12
#include <assert.h>
13
#include <stdbool.h>
14
#include <stddef.h>
15
16
#include "config/aom_config.h"
17
#include "config/aom_scale_rtcd.h"
18
19
#include "aom/aom_codec.h"
20
#include "aom/aom_image.h"
21
#include "aom/internal/aom_codec_internal.h"
22
#include "aom_dsp/aom_dsp_common.h"
23
#include "aom_dsp/binary_codes_reader.h"
24
#include "aom_dsp/bitreader.h"
25
#include "aom_dsp/bitreader_buffer.h"
26
#include "aom_dsp/txfm_common.h"
27
#include "aom_mem/aom_mem.h"
28
#include "aom_ports/aom_timer.h"
29
#include "aom_ports/mem.h"
30
#include "aom_ports/mem_ops.h"
31
#include "aom_scale/yv12config.h"
32
#include "aom_util/aom_pthread.h"
33
#include "aom_util/aom_thread.h"
34
35
#if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
36
#include "aom_util/debug_util.h"
37
#endif  // CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
38
39
#include "av1/common/alloccommon.h"
40
#include "av1/common/av1_common_int.h"
41
#include "av1/common/blockd.h"
42
#include "av1/common/cdef.h"
43
#include "av1/common/cfl.h"
44
#include "av1/common/common_data.h"
45
#include "av1/common/common.h"
46
#include "av1/common/entropy.h"
47
#include "av1/common/entropymode.h"
48
#include "av1/common/entropymv.h"
49
#include "av1/common/enums.h"
50
#include "av1/common/frame_buffers.h"
51
#include "av1/common/idct.h"
52
#include "av1/common/mv.h"
53
#include "av1/common/mvref_common.h"
54
#include "av1/common/obmc.h"
55
#include "av1/common/pred_common.h"
56
#include "av1/common/quant_common.h"
57
#include "av1/common/reconinter.h"
58
#include "av1/common/reconintra.h"
59
#include "av1/common/resize.h"
60
#include "av1/common/restoration.h"
61
#include "av1/common/scale.h"
62
#include "av1/common/seg_common.h"
63
#include "av1/common/thread_common.h"
64
#include "av1/common/tile_common.h"
65
#include "av1/common/warped_motion.h"
66
67
#include "av1/decoder/decodeframe.h"
68
#include "av1/decoder/decodemv.h"
69
#include "av1/decoder/decoder.h"
70
#include "av1/decoder/decodetxb.h"
71
#include "av1/decoder/detokenize.h"
72
#if CONFIG_INSPECTION
73
#include "av1/decoder/inspection.h"
74
#endif
75
76
#define ACCT_STR __func__
77
78
83.6k
#define AOM_MIN_THREADS_PER_TILE 1
79
134k
#define AOM_MAX_THREADS_PER_TILE 2
80
81
// This is needed by ext_tile related unit tests.
82
#define EXT_TILE_DEBUG 1
83
#define MC_TEMP_BUF_PELS                       \
84
225k
  (((MAX_SB_SIZE)*2 + (AOM_INTERP_EXTEND)*2) * \
85
225k
   ((MAX_SB_SIZE)*2 + (AOM_INTERP_EXTEND)*2))
86
87
// Checks that the remaining bits start with a 1 and ends with 0s.
88
// It consumes an additional byte, if already byte aligned before the check.
89
83.7k
int av1_check_trailing_bits(AV1Decoder *pbi, struct aom_read_bit_buffer *rb) {
90
  // bit_offset is set to 0 (mod 8) when the reader is already byte aligned
91
83.7k
  int bits_before_alignment = 8 - rb->bit_offset % 8;
92
83.7k
  int trailing = aom_rb_read_literal(rb, bits_before_alignment);
93
83.7k
  if (trailing != (1 << (bits_before_alignment - 1))) {
94
6.63k
    pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
95
6.63k
    return -1;
96
6.63k
  }
97
77.1k
  return 0;
98
83.7k
}
99
100
// Use only_chroma = 1 to only set the chroma planes
101
static inline void set_planes_to_neutral_grey(
102
    const SequenceHeader *const seq_params, const YV12_BUFFER_CONFIG *const buf,
103
286k
    int only_chroma) {
104
286k
  if (seq_params->use_highbitdepth) {
105
102k
    const int val = 1 << (seq_params->bit_depth - 1);
106
400k
    for (int plane = only_chroma; plane < MAX_MB_PLANE; plane++) {
107
298k
      const int is_uv = plane > 0;
108
298k
      uint16_t *const base = CONVERT_TO_SHORTPTR(buf->buffers[plane]);
109
      // Set the first row to neutral grey. Then copy the first row to all
110
      // subsequent rows.
111
298k
      if (buf->crop_heights[is_uv] > 0) {
112
298k
        aom_memset16(base, val, buf->crop_widths[is_uv]);
113
122M
        for (int row_idx = 1; row_idx < buf->crop_heights[is_uv]; row_idx++) {
114
121M
          memcpy(&base[row_idx * buf->strides[is_uv]], base,
115
121M
                 sizeof(*base) * buf->crop_widths[is_uv]);
116
121M
        }
117
298k
      }
118
298k
    }
119
184k
  } else {
120
735k
    for (int plane = only_chroma; plane < MAX_MB_PLANE; plane++) {
121
551k
      const int is_uv = plane > 0;
122
65.4M
      for (int row_idx = 0; row_idx < buf->crop_heights[is_uv]; row_idx++) {
123
64.8M
        memset(&buf->buffers[plane][row_idx * buf->strides[is_uv]], 1 << 7,
124
64.8M
               buf->crop_widths[is_uv]);
125
64.8M
      }
126
551k
    }
127
184k
  }
128
286k
}
129
130
static inline void loop_restoration_read_sb_coeffs(const AV1_COMMON *const cm,
131
                                                   MACROBLOCKD *xd,
132
                                                   aom_reader *const r,
133
                                                   int plane, int runit_idx);
134
135
196k
static int read_is_valid(const uint8_t *start, size_t len, const uint8_t *end) {
136
196k
  return len != 0 && len <= (size_t)(end - start);
137
196k
}
138
139
static TX_MODE read_tx_mode(struct aom_read_bit_buffer *rb,
140
181k
                            int coded_lossless) {
141
181k
  if (coded_lossless) return ONLY_4X4;
142
146k
  return aom_rb_read_bit(rb) ? TX_MODE_SELECT : TX_MODE_LARGEST;
143
181k
}
144
145
static REFERENCE_MODE read_frame_reference_mode(
146
181k
    const AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
147
181k
  if (frame_is_intra_only(cm)) {
148
135k
    return SINGLE_REFERENCE;
149
135k
  } else {
150
46.0k
    return aom_rb_read_bit(rb) ? REFERENCE_MODE_SELECT : SINGLE_REFERENCE;
151
46.0k
  }
152
181k
}
153
154
static inline void inverse_transform_block(DecoderCodingBlock *dcb, int plane,
155
                                           const TX_TYPE tx_type,
156
                                           const TX_SIZE tx_size, uint8_t *dst,
157
19.3M
                                           int stride, int reduced_tx_set) {
158
19.3M
  tran_low_t *const dqcoeff = dcb->dqcoeff_block[plane] + dcb->cb_offset[plane];
159
19.3M
  eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];
160
19.3M
  uint16_t scan_line = eob_data->max_scan_line;
161
19.3M
  uint16_t eob = eob_data->eob;
162
19.3M
  av1_inverse_transform_block(&dcb->xd, dqcoeff, plane, tx_type, tx_size, dst,
163
19.3M
                              stride, eob, reduced_tx_set);
164
19.3M
  memset(dqcoeff, 0, (scan_line + 1) * sizeof(dqcoeff[0]));
165
19.3M
}
166
167
static inline void read_coeffs_tx_intra_block(
168
    const AV1_COMMON *const cm, DecoderCodingBlock *dcb, aom_reader *const r,
169
120M
    const int plane, const int row, const int col, const TX_SIZE tx_size) {
170
120M
  MB_MODE_INFO *mbmi = dcb->xd.mi[0];
171
120M
  if (!mbmi->skip_txfm) {
172
#if TXCOEFF_TIMER
173
    struct aom_usec_timer timer;
174
    aom_usec_timer_start(&timer);
175
#endif
176
25.4M
    av1_read_coeffs_txb(cm, dcb, r, plane, row, col, tx_size);
177
#if TXCOEFF_TIMER
178
    aom_usec_timer_mark(&timer);
179
    const int64_t elapsed_time = aom_usec_timer_elapsed(&timer);
180
    cm->txcoeff_timer += elapsed_time;
181
    ++cm->txb_count;
182
#endif
183
25.4M
  }
184
120M
}
185
186
static inline void decode_block_void(const AV1_COMMON *const cm,
187
                                     DecoderCodingBlock *dcb,
188
                                     aom_reader *const r, const int plane,
189
                                     const int row, const int col,
190
172M
                                     const TX_SIZE tx_size) {
191
172M
  (void)cm;
192
172M
  (void)dcb;
193
172M
  (void)r;
194
172M
  (void)plane;
195
172M
  (void)row;
196
172M
  (void)col;
197
172M
  (void)tx_size;
198
172M
}
199
200
static inline void predict_inter_block_void(AV1_COMMON *const cm,
201
                                            DecoderCodingBlock *dcb,
202
3.69M
                                            BLOCK_SIZE bsize) {
203
3.69M
  (void)cm;
204
3.69M
  (void)dcb;
205
3.69M
  (void)bsize;
206
3.69M
}
207
208
static inline void cfl_store_inter_block_void(AV1_COMMON *const cm,
209
3.68M
                                              MACROBLOCKD *const xd) {
210
3.68M
  (void)cm;
211
3.68M
  (void)xd;
212
3.68M
}
213
214
static inline void predict_and_reconstruct_intra_block(
215
    const AV1_COMMON *const cm, DecoderCodingBlock *dcb, aom_reader *const r,
216
112M
    const int plane, const int row, const int col, const TX_SIZE tx_size) {
217
112M
  (void)r;
218
112M
  MACROBLOCKD *const xd = &dcb->xd;
219
112M
  MB_MODE_INFO *mbmi = xd->mi[0];
220
112M
  PLANE_TYPE plane_type = get_plane_type(plane);
221
222
112M
  av1_predict_intra_block_facade(cm, xd, plane, col, row, tx_size);
223
224
112M
  if (!mbmi->skip_txfm) {
225
20.2M
    eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];
226
20.2M
    if (eob_data->eob) {
227
10.1M
      const bool reduced_tx_set_used = cm->features.reduced_tx_set_used;
228
      // tx_type was read out in av1_read_coeffs_txb.
229
10.1M
      const TX_TYPE tx_type = av1_get_tx_type(xd, plane_type, row, col, tx_size,
230
10.1M
                                              reduced_tx_set_used);
231
10.1M
      struct macroblockd_plane *const pd = &xd->plane[plane];
232
10.1M
      uint8_t *dst = &pd->dst.buf[(row * pd->dst.stride + col) << MI_SIZE_LOG2];
233
10.1M
      inverse_transform_block(dcb, plane, tx_type, tx_size, dst, pd->dst.stride,
234
10.1M
                              reduced_tx_set_used);
235
10.1M
    }
236
20.2M
  }
237
112M
  if (plane == AOM_PLANE_Y && store_cfl_required(cm, xd)) {
238
2.28M
    cfl_store_tx(xd, row, col, tx_size, mbmi->bsize);
239
2.28M
  }
240
112M
}
241
242
static inline void inverse_transform_inter_block(
243
    const AV1_COMMON *const cm, DecoderCodingBlock *dcb, aom_reader *const r,
244
    const int plane, const int blk_row, const int blk_col,
245
9.18M
    const TX_SIZE tx_size) {
246
9.18M
  (void)r;
247
9.18M
  MACROBLOCKD *const xd = &dcb->xd;
248
9.18M
  PLANE_TYPE plane_type = get_plane_type(plane);
249
9.18M
  const struct macroblockd_plane *const pd = &xd->plane[plane];
250
9.18M
  const bool reduced_tx_set_used = cm->features.reduced_tx_set_used;
251
  // tx_type was read out in av1_read_coeffs_txb.
252
9.18M
  const TX_TYPE tx_type = av1_get_tx_type(xd, plane_type, blk_row, blk_col,
253
9.18M
                                          tx_size, reduced_tx_set_used);
254
255
9.18M
  uint8_t *dst =
256
9.18M
      &pd->dst.buf[(blk_row * pd->dst.stride + blk_col) << MI_SIZE_LOG2];
257
9.18M
  inverse_transform_block(dcb, plane, tx_type, tx_size, dst, pd->dst.stride,
258
9.18M
                          reduced_tx_set_used);
259
#if CONFIG_MISMATCH_DEBUG
260
  int pixel_c, pixel_r;
261
  BLOCK_SIZE bsize = txsize_to_bsize[tx_size];
262
  int blk_w = block_size_wide[bsize];
263
  int blk_h = block_size_high[bsize];
264
  const int mi_row = -xd->mb_to_top_edge >> (3 + MI_SIZE_LOG2);
265
  const int mi_col = -xd->mb_to_left_edge >> (3 + MI_SIZE_LOG2);
266
  mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, blk_col, blk_row,
267
                  pd->subsampling_x, pd->subsampling_y);
268
  mismatch_check_block_tx(dst, pd->dst.stride, cm->current_frame.order_hint,
269
                          plane, pixel_c, pixel_r, blk_w, blk_h,
270
                          xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH);
271
#endif
272
9.18M
}
273
274
static inline void set_cb_buffer_offsets(DecoderCodingBlock *dcb,
275
204M
                                         TX_SIZE tx_size, int plane) {
276
204M
  dcb->cb_offset[plane] += tx_size_wide[tx_size] * tx_size_high[tx_size];
277
204M
  dcb->txb_offset[plane] =
278
204M
      dcb->cb_offset[plane] / (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
279
204M
}
280
281
static inline void decode_reconstruct_tx(AV1_COMMON *cm, ThreadData *const td,
282
                                         aom_reader *r,
283
                                         MB_MODE_INFO *const mbmi, int plane,
284
                                         BLOCK_SIZE plane_bsize, int blk_row,
285
                                         int blk_col, int block,
286
18.8M
                                         TX_SIZE tx_size, int *eob_total) {
287
18.8M
  DecoderCodingBlock *const dcb = &td->dcb;
288
18.8M
  MACROBLOCKD *const xd = &dcb->xd;
289
18.8M
  const struct macroblockd_plane *const pd = &xd->plane[plane];
290
18.8M
  const TX_SIZE plane_tx_size =
291
18.8M
      plane ? av1_get_max_uv_txsize(mbmi->bsize, pd->subsampling_x,
292
10.6M
                                    pd->subsampling_y)
293
18.8M
            : mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row,
294
8.22M
                                                         blk_col)];
295
  // Scale to match transform block unit.
296
18.8M
  const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
297
18.8M
  const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
298
299
18.9M
  if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
300
301
18.8M
  if (tx_size == plane_tx_size || plane) {
302
18.3M
    td->read_coeffs_tx_inter_block_visit(cm, dcb, r, plane, blk_row, blk_col,
303
18.3M
                                         tx_size);
304
305
18.3M
    td->inverse_tx_inter_block_visit(cm, dcb, r, plane, blk_row, blk_col,
306
18.3M
                                     tx_size);
307
18.3M
    eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];
308
18.3M
    *eob_total += eob_data->eob;
309
18.3M
    set_cb_buffer_offsets(dcb, tx_size, plane);
310
18.3M
  } else {
311
576k
    const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
312
576k
    assert(IMPLIES(tx_size <= TX_4X4, sub_txs == tx_size));
313
612k
    assert(IMPLIES(tx_size > TX_4X4, sub_txs < tx_size));
314
612k
    const int bsw = tx_size_wide_unit[sub_txs];
315
612k
    const int bsh = tx_size_high_unit[sub_txs];
316
612k
    const int sub_step = bsw * bsh;
317
612k
    const int row_end =
318
612k
        AOMMIN(tx_size_high_unit[tx_size], max_blocks_high - blk_row);
319
612k
    const int col_end =
320
612k
        AOMMIN(tx_size_wide_unit[tx_size], max_blocks_wide - blk_col);
321
322
612k
    assert(bsw > 0 && bsh > 0);
323
324
1.66M
    for (int row = 0; row < row_end; row += bsh) {
325
1.04M
      const int offsetr = blk_row + row;
326
2.86M
      for (int col = 0; col < col_end; col += bsw) {
327
1.81M
        const int offsetc = blk_col + col;
328
329
1.81M
        decode_reconstruct_tx(cm, td, r, mbmi, plane, plane_bsize, offsetr,
330
1.81M
                              offsetc, block, sub_txs, eob_total);
331
1.81M
        block += sub_step;
332
1.81M
      }
333
1.04M
    }
334
612k
  }
335
18.8M
}
336
337
static inline void set_offsets(AV1_COMMON *const cm, MACROBLOCKD *const xd,
338
                               BLOCK_SIZE bsize, int mi_row, int mi_col, int bw,
339
15.6M
                               int bh, int x_mis, int y_mis) {
340
15.6M
  const int num_planes = av1_num_planes(cm);
341
15.6M
  const CommonModeInfoParams *const mi_params = &cm->mi_params;
342
15.6M
  const TileInfo *const tile = &xd->tile;
343
344
15.6M
  set_mi_offsets(mi_params, xd, mi_row, mi_col);
345
15.6M
  xd->mi[0]->bsize = bsize;
346
#if CONFIG_RD_DEBUG
347
  xd->mi[0]->mi_row = mi_row;
348
  xd->mi[0]->mi_col = mi_col;
349
#endif
350
351
15.6M
  assert(x_mis && y_mis);
352
78.0M
  for (int x = 1; x < x_mis; ++x) xd->mi[x] = xd->mi[0];
353
15.6M
  int idx = mi_params->mi_stride;
354
73.1M
  for (int y = 1; y < y_mis; ++y) {
355
57.4M
    memcpy(&xd->mi[idx], &xd->mi[0], x_mis * sizeof(xd->mi[0]));
356
57.4M
    idx += mi_params->mi_stride;
357
57.4M
  }
358
359
15.6M
  set_plane_n4(xd, bw, bh, num_planes);
360
15.6M
  set_entropy_context(xd, mi_row, mi_col, num_planes);
361
362
  // Distance of Mb to the various image edges. These are specified to 8th pel
363
  // as they are always compared to values that are in 1/8th pel units
364
15.6M
  set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, mi_params->mi_rows,
365
15.6M
                 mi_params->mi_cols);
366
367
15.6M
  av1_setup_dst_planes(xd->plane, bsize, &cm->cur_frame->buf, mi_row, mi_col, 0,
368
15.6M
                       num_planes);
369
15.6M
}
370
371
static inline void decode_mbmi_block(AV1Decoder *const pbi,
372
                                     DecoderCodingBlock *dcb, int mi_row,
373
                                     int mi_col, aom_reader *r,
374
                                     PARTITION_TYPE partition,
375
15.6M
                                     BLOCK_SIZE bsize) {
376
15.6M
  AV1_COMMON *const cm = &pbi->common;
377
15.6M
  const SequenceHeader *const seq_params = cm->seq_params;
378
15.6M
  const int bw = mi_size_wide[bsize];
379
15.6M
  const int bh = mi_size_high[bsize];
380
15.6M
  const int x_mis = AOMMIN(bw, cm->mi_params.mi_cols - mi_col);
381
15.6M
  const int y_mis = AOMMIN(bh, cm->mi_params.mi_rows - mi_row);
382
15.6M
  MACROBLOCKD *const xd = &dcb->xd;
383
384
#if CONFIG_ACCOUNTING
385
  aom_accounting_set_context(&pbi->accounting, mi_col, mi_row);
386
#endif
387
15.6M
  set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis);
388
15.6M
  xd->mi[0]->partition = partition;
389
15.6M
  av1_read_mode_info(pbi, dcb, r, x_mis, y_mis);
390
15.6M
  if (bsize >= BLOCK_8X8 &&
391
15.6M
      (seq_params->subsampling_x || seq_params->subsampling_y)) {
392
8.82M
    const BLOCK_SIZE uv_subsize =
393
8.82M
        av1_ss_size_lookup[bsize][seq_params->subsampling_x]
394
8.82M
                          [seq_params->subsampling_y];
395
8.82M
    if (uv_subsize == BLOCK_INVALID)
396
0
      aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
397
0
                         "Invalid block size.");
398
8.82M
  }
399
15.6M
}
400
401
typedef struct PadBlock {
402
  int x0;
403
  int x1;
404
  int y0;
405
  int y1;
406
} PadBlock;
407
408
#if CONFIG_AV1_HIGHBITDEPTH
409
static inline void highbd_build_mc_border(const uint8_t *src8, int src_stride,
410
                                          uint8_t *dst8, int dst_stride, int x,
411
                                          int y, int b_w, int b_h, int w,
412
1.16M
                                          int h) {
413
  // Get a pointer to the start of the real data for this row.
414
1.16M
  const uint16_t *src = CONVERT_TO_SHORTPTR(src8);
415
1.16M
  uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
416
1.16M
  const uint16_t *ref_row = src - x - y * src_stride;
417
418
1.16M
  if (y >= h)
419
150k
    ref_row += (h - 1) * src_stride;
420
1.01M
  else if (y > 0)
421
598k
    ref_row += y * src_stride;
422
423
22.8M
  do {
424
22.8M
    int right = 0, copy;
425
22.8M
    int left = x < 0 ? -x : 0;
426
427
22.8M
    if (left > b_w) left = b_w;
428
429
22.8M
    if (x + b_w > w) right = x + b_w - w;
430
431
22.8M
    if (right > b_w) right = b_w;
432
433
22.8M
    copy = b_w - left - right;
434
435
22.8M
    if (left) aom_memset16(dst, ref_row[0], left);
436
437
22.8M
    if (copy) memcpy(dst + left, ref_row + x + left, copy * sizeof(uint16_t));
438
439
22.8M
    if (right) aom_memset16(dst + left + copy, ref_row[w - 1], right);
440
441
22.8M
    dst += dst_stride;
442
22.8M
    ++y;
443
444
22.8M
    if (y > 0 && y < h) ref_row += src_stride;
445
22.8M
  } while (--b_h);
446
1.16M
}
447
#endif  // CONFIG_AV1_HIGHBITDEPTH
448
449
static inline void build_mc_border(const uint8_t *src, int src_stride,
450
                                   uint8_t *dst, int dst_stride, int x, int y,
451
1.45M
                                   int b_w, int b_h, int w, int h) {
452
  // Get a pointer to the start of the real data for this row.
453
1.45M
  const uint8_t *ref_row = src - x - y * src_stride;
454
455
1.45M
  if (y >= h)
456
370k
    ref_row += (h - 1) * src_stride;
457
1.08M
  else if (y > 0)
458
583k
    ref_row += y * src_stride;
459
460
26.0M
  do {
461
26.0M
    int right = 0, copy;
462
26.0M
    int left = x < 0 ? -x : 0;
463
464
26.0M
    if (left > b_w) left = b_w;
465
466
26.0M
    if (x + b_w > w) right = x + b_w - w;
467
468
26.0M
    if (right > b_w) right = b_w;
469
470
26.0M
    copy = b_w - left - right;
471
472
26.0M
    if (left) memset(dst, ref_row[0], left);
473
474
26.0M
    if (copy) memcpy(dst + left, ref_row + x + left, copy);
475
476
26.0M
    if (right) memset(dst + left + copy, ref_row[w - 1], right);
477
478
26.0M
    dst += dst_stride;
479
26.0M
    ++y;
480
481
26.0M
    if (y > 0 && y < h) ref_row += src_stride;
482
26.0M
  } while (--b_h);
483
1.45M
}
484
485
static inline int update_extend_mc_border_params(
486
    const struct scale_factors *const sf, struct buf_2d *const pre_buf,
487
    MV32 scaled_mv, PadBlock *block, int subpel_x_mv, int subpel_y_mv,
488
17.0M
    int do_warp, int is_intrabc, int *x_pad, int *y_pad) {
489
17.0M
  const int is_scaled = av1_is_scaled(sf);
490
  // Get reference width and height.
491
17.0M
  int frame_width = pre_buf->width;
492
17.0M
  int frame_height = pre_buf->height;
493
494
  // Do border extension if there is motion or
495
  // width/height is not a multiple of 8 pixels.
496
17.0M
  if ((!is_intrabc) && (!do_warp) &&
497
17.0M
      (is_scaled || scaled_mv.col || scaled_mv.row || (frame_width & 0x7) ||
498
16.3M
       (frame_height & 0x7))) {
499
13.8M
    if (subpel_x_mv || (sf->x_step_q4 != SUBPEL_SHIFTS)) {
500
13.8M
      block->x0 -= AOM_INTERP_EXTEND - 1;
501
13.8M
      block->x1 += AOM_INTERP_EXTEND;
502
13.8M
      *x_pad = 1;
503
13.8M
    }
504
505
13.8M
    if (subpel_y_mv || (sf->y_step_q4 != SUBPEL_SHIFTS)) {
506
13.8M
      block->y0 -= AOM_INTERP_EXTEND - 1;
507
13.8M
      block->y1 += AOM_INTERP_EXTEND;
508
13.8M
      *y_pad = 1;
509
13.8M
    }
510
511
    // Skip border extension if block is inside the frame.
512
13.8M
    if (block->x0 < 0 || block->x1 > frame_width - 1 || block->y0 < 0 ||
513
13.8M
        block->y1 > frame_height - 1) {
514
2.62M
      return 1;
515
2.62M
    }
516
13.8M
  }
517
14.3M
  return 0;
518
17.0M
}
519
520
static inline void extend_mc_border(const struct scale_factors *const sf,
521
                                    struct buf_2d *const pre_buf,
522
                                    MV32 scaled_mv, PadBlock block,
523
                                    int subpel_x_mv, int subpel_y_mv,
524
                                    int do_warp, int is_intrabc, int highbd,
525
                                    uint8_t *mc_buf, uint8_t **pre,
526
17.0M
                                    int *src_stride) {
527
17.0M
  int x_pad = 0, y_pad = 0;
528
17.0M
  if (update_extend_mc_border_params(sf, pre_buf, scaled_mv, &block,
529
17.0M
                                     subpel_x_mv, subpel_y_mv, do_warp,
530
17.0M
                                     is_intrabc, &x_pad, &y_pad)) {
531
    // Get reference block pointer.
532
2.62M
    const uint8_t *const buf_ptr =
533
2.62M
        pre_buf->buf0 + block.y0 * pre_buf->stride + block.x0;
534
2.62M
    int buf_stride = pre_buf->stride;
535
2.62M
    const int b_w = block.x1 - block.x0;
536
2.62M
    const int b_h = block.y1 - block.y0;
537
538
2.62M
#if CONFIG_AV1_HIGHBITDEPTH
539
    // Extend the border.
540
2.62M
    if (highbd) {
541
1.16M
      highbd_build_mc_border(buf_ptr, buf_stride, mc_buf, b_w, block.x0,
542
1.16M
                             block.y0, b_w, b_h, pre_buf->width,
543
1.16M
                             pre_buf->height);
544
1.45M
    } else {
545
1.45M
      build_mc_border(buf_ptr, buf_stride, mc_buf, b_w, block.x0, block.y0, b_w,
546
1.45M
                      b_h, pre_buf->width, pre_buf->height);
547
1.45M
    }
548
#else
549
    (void)highbd;
550
    build_mc_border(buf_ptr, buf_stride, mc_buf, b_w, block.x0, block.y0, b_w,
551
                    b_h, pre_buf->width, pre_buf->height);
552
#endif
553
2.62M
    *src_stride = b_w;
554
2.62M
    *pre = mc_buf + y_pad * (AOM_INTERP_EXTEND - 1) * b_w +
555
2.62M
           x_pad * (AOM_INTERP_EXTEND - 1);
556
2.62M
  }
557
17.0M
}
558
559
static inline void dec_calc_subpel_params(
560
    const MV *const src_mv, InterPredParams *const inter_pred_params,
561
    const MACROBLOCKD *const xd, int mi_x, int mi_y, uint8_t **pre,
562
    SubpelParams *subpel_params, int *src_stride, PadBlock *block,
563
17.0M
    MV32 *scaled_mv, int *subpel_x_mv, int *subpel_y_mv) {
564
17.0M
  const struct scale_factors *sf = inter_pred_params->scale_factors;
565
17.0M
  struct buf_2d *pre_buf = &inter_pred_params->ref_frame_buf;
566
17.0M
  const int bw = inter_pred_params->block_width;
567
17.0M
  const int bh = inter_pred_params->block_height;
568
17.0M
  const int is_scaled = av1_is_scaled(sf);
569
17.0M
  if (is_scaled) {
570
2.31M
    int ssx = inter_pred_params->subsampling_x;
571
2.31M
    int ssy = inter_pred_params->subsampling_y;
572
2.31M
    int orig_pos_y = inter_pred_params->pix_row << SUBPEL_BITS;
573
2.31M
    orig_pos_y += src_mv->row * (1 << (1 - ssy));
574
2.31M
    int orig_pos_x = inter_pred_params->pix_col << SUBPEL_BITS;
575
2.31M
    orig_pos_x += src_mv->col * (1 << (1 - ssx));
576
2.31M
    int pos_y = av1_scaled_y(orig_pos_y, sf);
577
2.31M
    int pos_x = av1_scaled_x(orig_pos_x, sf);
578
2.31M
    pos_x += SCALE_EXTRA_OFF;
579
2.31M
    pos_y += SCALE_EXTRA_OFF;
580
581
2.31M
    const int top = -AOM_LEFT_TOP_MARGIN_SCALED(ssy);
582
2.31M
    const int left = -AOM_LEFT_TOP_MARGIN_SCALED(ssx);
583
2.31M
    const int bottom = (pre_buf->height + AOM_INTERP_EXTEND)
584
2.31M
                       << SCALE_SUBPEL_BITS;
585
2.31M
    const int right = (pre_buf->width + AOM_INTERP_EXTEND) << SCALE_SUBPEL_BITS;
586
2.31M
    pos_y = clamp(pos_y, top, bottom);
587
2.31M
    pos_x = clamp(pos_x, left, right);
588
589
2.31M
    subpel_params->subpel_x = pos_x & SCALE_SUBPEL_MASK;
590
2.31M
    subpel_params->subpel_y = pos_y & SCALE_SUBPEL_MASK;
591
2.31M
    subpel_params->xs = sf->x_step_q4;
592
2.31M
    subpel_params->ys = sf->y_step_q4;
593
594
    // Get reference block top left coordinate.
595
2.31M
    block->x0 = pos_x >> SCALE_SUBPEL_BITS;
596
2.31M
    block->y0 = pos_y >> SCALE_SUBPEL_BITS;
597
598
    // Get reference block bottom right coordinate.
599
2.31M
    block->x1 =
600
2.31M
        ((pos_x + (bw - 1) * subpel_params->xs) >> SCALE_SUBPEL_BITS) + 1;
601
2.31M
    block->y1 =
602
2.31M
        ((pos_y + (bh - 1) * subpel_params->ys) >> SCALE_SUBPEL_BITS) + 1;
603
604
2.31M
    MV temp_mv;
605
2.31M
    temp_mv = clamp_mv_to_umv_border_sb(xd, src_mv, bw, bh,
606
2.31M
                                        inter_pred_params->subsampling_x,
607
2.31M
                                        inter_pred_params->subsampling_y);
608
2.31M
    *scaled_mv = av1_scale_mv(&temp_mv, mi_x, mi_y, sf);
609
2.31M
    scaled_mv->row += SCALE_EXTRA_OFF;
610
2.31M
    scaled_mv->col += SCALE_EXTRA_OFF;
611
612
2.31M
    *subpel_x_mv = scaled_mv->col & SCALE_SUBPEL_MASK;
613
2.31M
    *subpel_y_mv = scaled_mv->row & SCALE_SUBPEL_MASK;
614
14.7M
  } else {
615
    // Get block position in current frame.
616
14.7M
    int pos_x = inter_pred_params->pix_col << SUBPEL_BITS;
617
14.7M
    int pos_y = inter_pred_params->pix_row << SUBPEL_BITS;
618
619
14.7M
    const MV mv_q4 = clamp_mv_to_umv_border_sb(
620
14.7M
        xd, src_mv, bw, bh, inter_pred_params->subsampling_x,
621
14.7M
        inter_pred_params->subsampling_y);
622
14.7M
    subpel_params->xs = subpel_params->ys = SCALE_SUBPEL_SHIFTS;
623
14.7M
    subpel_params->subpel_x = (mv_q4.col & SUBPEL_MASK) << SCALE_EXTRA_BITS;
624
14.7M
    subpel_params->subpel_y = (mv_q4.row & SUBPEL_MASK) << SCALE_EXTRA_BITS;
625
626
    // Get reference block top left coordinate.
627
14.7M
    pos_x += mv_q4.col;
628
14.7M
    pos_y += mv_q4.row;
629
14.7M
    block->x0 = pos_x >> SUBPEL_BITS;
630
14.7M
    block->y0 = pos_y >> SUBPEL_BITS;
631
632
    // Get reference block bottom right coordinate.
633
14.7M
    block->x1 = (pos_x >> SUBPEL_BITS) + (bw - 1) + 1;
634
14.7M
    block->y1 = (pos_y >> SUBPEL_BITS) + (bh - 1) + 1;
635
636
14.7M
    scaled_mv->row = mv_q4.row;
637
14.7M
    scaled_mv->col = mv_q4.col;
638
14.7M
    *subpel_x_mv = scaled_mv->col & SUBPEL_MASK;
639
14.7M
    *subpel_y_mv = scaled_mv->row & SUBPEL_MASK;
640
14.7M
  }
641
17.0M
  *pre = pre_buf->buf0 + block->y0 * pre_buf->stride + block->x0;
642
17.0M
  *src_stride = pre_buf->stride;
643
17.0M
}
644
645
static inline void dec_calc_subpel_params_and_extend(
646
    const MV *const src_mv, InterPredParams *const inter_pred_params,
647
    MACROBLOCKD *const xd, int mi_x, int mi_y, int ref, uint8_t **mc_buf,
648
17.0M
    uint8_t **pre, SubpelParams *subpel_params, int *src_stride) {
649
17.0M
  PadBlock block;
650
17.0M
  MV32 scaled_mv;
651
17.0M
  int subpel_x_mv, subpel_y_mv;
652
17.0M
  dec_calc_subpel_params(src_mv, inter_pred_params, xd, mi_x, mi_y, pre,
653
17.0M
                         subpel_params, src_stride, &block, &scaled_mv,
654
17.0M
                         &subpel_x_mv, &subpel_y_mv);
655
17.0M
  extend_mc_border(
656
17.0M
      inter_pred_params->scale_factors, &inter_pred_params->ref_frame_buf,
657
17.0M
      scaled_mv, block, subpel_x_mv, subpel_y_mv,
658
17.0M
      inter_pred_params->mode == WARP_PRED, inter_pred_params->is_intrabc,
659
17.0M
      inter_pred_params->use_hbd_buf, mc_buf[ref], pre, src_stride);
660
17.0M
}
661
662
#define IS_DEC 1
663
#include "av1/common/reconinter_template.inc"
664
#undef IS_DEC
665
666
static void dec_build_inter_predictors(const AV1_COMMON *cm,
667
                                       DecoderCodingBlock *dcb, int plane,
668
                                       const MB_MODE_INFO *mi,
669
                                       int build_for_obmc, int bw, int bh,
670
14.0M
                                       int mi_x, int mi_y) {
671
14.0M
  build_inter_predictors(cm, &dcb->xd, plane, mi, build_for_obmc, bw, bh, mi_x,
672
14.0M
                         mi_y, dcb->mc_buf);
673
14.0M
}
674
675
static inline void dec_build_inter_predictor(const AV1_COMMON *cm,
676
                                             DecoderCodingBlock *dcb,
677
                                             int mi_row, int mi_col,
678
4.23M
                                             BLOCK_SIZE bsize) {
679
4.23M
  MACROBLOCKD *const xd = &dcb->xd;
680
4.23M
  const int num_planes = av1_num_planes(cm);
681
15.4M
  for (int plane = 0; plane < num_planes; ++plane) {
682
11.9M
    if (plane && !xd->is_chroma_ref) break;
683
11.1M
    const int mi_x = mi_col * MI_SIZE;
684
11.1M
    const int mi_y = mi_row * MI_SIZE;
685
11.1M
    dec_build_inter_predictors(cm, dcb, plane, xd->mi[0], 0,
686
11.1M
                               xd->plane[plane].width, xd->plane[plane].height,
687
11.1M
                               mi_x, mi_y);
688
11.1M
    if (is_interintra_pred(xd->mi[0])) {
689
958k
      BUFFER_SET ctx = { { xd->plane[0].dst.buf, xd->plane[1].dst.buf,
690
958k
                           xd->plane[2].dst.buf },
691
958k
                         { xd->plane[0].dst.stride, xd->plane[1].dst.stride,
692
958k
                           xd->plane[2].dst.stride } };
693
958k
      av1_build_interintra_predictor(cm, xd, xd->plane[plane].dst.buf,
694
958k
                                     xd->plane[plane].dst.stride, &ctx, plane,
695
958k
                                     bsize);
696
958k
    }
697
11.1M
  }
698
4.23M
}
699
700
static inline void dec_build_prediction_by_above_pred(
701
    MACROBLOCKD *const xd, int rel_mi_row, int rel_mi_col, uint8_t op_mi_size,
702
627k
    int dir, MB_MODE_INFO *above_mbmi, void *fun_ctxt, const int num_planes) {
703
627k
  struct build_prediction_ctxt *ctxt = (struct build_prediction_ctxt *)fun_ctxt;
704
627k
  const int above_mi_col = xd->mi_col + rel_mi_col;
705
627k
  int mi_x, mi_y;
706
627k
  MB_MODE_INFO backup_mbmi = *above_mbmi;
707
708
627k
  (void)rel_mi_row;
709
627k
  (void)dir;
710
711
627k
  av1_setup_build_prediction_by_above_pred(xd, rel_mi_col, op_mi_size,
712
627k
                                           &backup_mbmi, ctxt, num_planes);
713
627k
  mi_x = above_mi_col << MI_SIZE_LOG2;
714
627k
  mi_y = xd->mi_row << MI_SIZE_LOG2;
715
716
627k
  const BLOCK_SIZE bsize = xd->mi[0]->bsize;
717
718
2.50M
  for (int j = 0; j < num_planes; ++j) {
719
1.87M
    const struct macroblockd_plane *pd = &xd->plane[j];
720
1.87M
    int bw = (op_mi_size * MI_SIZE) >> pd->subsampling_x;
721
1.87M
    int bh = clamp(block_size_high[bsize] >> (pd->subsampling_y + 1), 4,
722
1.87M
                   block_size_high[BLOCK_64X64] >> (pd->subsampling_y + 1));
723
724
1.87M
    if (av1_skip_u4x4_pred_in_obmc(bsize, pd, 0)) continue;
725
1.02M
    dec_build_inter_predictors(ctxt->cm, (DecoderCodingBlock *)ctxt->dcb, j,
726
1.02M
                               &backup_mbmi, 1, bw, bh, mi_x, mi_y);
727
1.02M
  }
728
627k
}
729
730
static inline void dec_build_prediction_by_above_preds(
731
    const AV1_COMMON *cm, DecoderCodingBlock *dcb,
732
    uint8_t *tmp_buf[MAX_MB_PLANE], int tmp_width[MAX_MB_PLANE],
733
633k
    int tmp_height[MAX_MB_PLANE], int tmp_stride[MAX_MB_PLANE]) {
734
633k
  MACROBLOCKD *const xd = &dcb->xd;
735
633k
  if (!xd->up_available) return;
736
737
  // Adjust mb_to_bottom_edge to have the correct value for the OBMC
738
  // prediction block. This is half the height of the original block,
739
  // except for 128-wide blocks, where we only use a height of 32.
740
624k
  const int this_height = xd->height * MI_SIZE;
741
624k
  const int pred_height = AOMMIN(this_height / 2, 32);
742
624k
  xd->mb_to_bottom_edge += GET_MV_SUBPEL(this_height - pred_height);
743
624k
  struct build_prediction_ctxt ctxt = {
744
624k
    cm, tmp_buf, tmp_width, tmp_height, tmp_stride, xd->mb_to_right_edge, dcb
745
624k
  };
746
624k
  const BLOCK_SIZE bsize = xd->mi[0]->bsize;
747
624k
  foreach_overlappable_nb_above(cm, xd,
748
624k
                                max_neighbor_obmc[mi_size_wide_log2[bsize]],
749
624k
                                dec_build_prediction_by_above_pred, &ctxt);
750
751
624k
  xd->mb_to_left_edge = -GET_MV_SUBPEL(xd->mi_col * MI_SIZE);
752
624k
  xd->mb_to_right_edge = ctxt.mb_to_far_edge;
753
624k
  xd->mb_to_bottom_edge -= GET_MV_SUBPEL(this_height - pred_height);
754
624k
}
755
756
static inline void dec_build_prediction_by_left_pred(
757
    MACROBLOCKD *const xd, int rel_mi_row, int rel_mi_col, uint8_t op_mi_size,
758
622k
    int dir, MB_MODE_INFO *left_mbmi, void *fun_ctxt, const int num_planes) {
759
622k
  struct build_prediction_ctxt *ctxt = (struct build_prediction_ctxt *)fun_ctxt;
760
622k
  const int left_mi_row = xd->mi_row + rel_mi_row;
761
622k
  int mi_x, mi_y;
762
622k
  MB_MODE_INFO backup_mbmi = *left_mbmi;
763
764
622k
  (void)rel_mi_col;
765
622k
  (void)dir;
766
767
622k
  av1_setup_build_prediction_by_left_pred(xd, rel_mi_row, op_mi_size,
768
622k
                                          &backup_mbmi, ctxt, num_planes);
769
622k
  mi_x = xd->mi_col << MI_SIZE_LOG2;
770
622k
  mi_y = left_mi_row << MI_SIZE_LOG2;
771
622k
  const BLOCK_SIZE bsize = xd->mi[0]->bsize;
772
773
2.48M
  for (int j = 0; j < num_planes; ++j) {
774
1.86M
    const struct macroblockd_plane *pd = &xd->plane[j];
775
1.86M
    int bw = clamp(block_size_wide[bsize] >> (pd->subsampling_x + 1), 4,
776
1.86M
                   block_size_wide[BLOCK_64X64] >> (pd->subsampling_x + 1));
777
1.86M
    int bh = (op_mi_size << MI_SIZE_LOG2) >> pd->subsampling_y;
778
779
1.86M
    if (av1_skip_u4x4_pred_in_obmc(bsize, pd, 1)) continue;
780
1.86M
    dec_build_inter_predictors(ctxt->cm, (DecoderCodingBlock *)ctxt->dcb, j,
781
1.86M
                               &backup_mbmi, 1, bw, bh, mi_x, mi_y);
782
1.86M
  }
783
622k
}
784
785
static inline void dec_build_prediction_by_left_preds(
786
    const AV1_COMMON *cm, DecoderCodingBlock *dcb,
787
    uint8_t *tmp_buf[MAX_MB_PLANE], int tmp_width[MAX_MB_PLANE],
788
633k
    int tmp_height[MAX_MB_PLANE], int tmp_stride[MAX_MB_PLANE]) {
789
633k
  MACROBLOCKD *const xd = &dcb->xd;
790
633k
  if (!xd->left_available) return;
791
792
  // Adjust mb_to_right_edge to have the correct value for the OBMC
793
  // prediction block. This is half the width of the original block,
794
  // except for 128-wide blocks, where we only use a width of 32.
795
627k
  const int this_width = xd->width * MI_SIZE;
796
627k
  const int pred_width = AOMMIN(this_width / 2, 32);
797
627k
  xd->mb_to_right_edge += GET_MV_SUBPEL(this_width - pred_width);
798
799
627k
  struct build_prediction_ctxt ctxt = {
800
627k
    cm, tmp_buf, tmp_width, tmp_height, tmp_stride, xd->mb_to_bottom_edge, dcb
801
627k
  };
802
627k
  const BLOCK_SIZE bsize = xd->mi[0]->bsize;
803
627k
  foreach_overlappable_nb_left(cm, xd,
804
627k
                               max_neighbor_obmc[mi_size_high_log2[bsize]],
805
627k
                               dec_build_prediction_by_left_pred, &ctxt);
806
807
627k
  xd->mb_to_top_edge = -GET_MV_SUBPEL(xd->mi_row * MI_SIZE);
808
627k
  xd->mb_to_right_edge -= GET_MV_SUBPEL(this_width - pred_width);
809
627k
  xd->mb_to_bottom_edge = ctxt.mb_to_far_edge;
810
627k
}
811
812
static inline void dec_build_obmc_inter_predictors_sb(const AV1_COMMON *cm,
813
633k
                                                      DecoderCodingBlock *dcb) {
814
633k
  const int num_planes = av1_num_planes(cm);
815
633k
  uint8_t *dst_buf1[MAX_MB_PLANE], *dst_buf2[MAX_MB_PLANE];
816
633k
  int dst_stride1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
817
633k
  int dst_stride2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
818
633k
  int dst_width1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
819
633k
  int dst_width2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
820
633k
  int dst_height1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
821
633k
  int dst_height2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
822
823
633k
  MACROBLOCKD *const xd = &dcb->xd;
824
633k
  av1_setup_obmc_dst_bufs(xd, dst_buf1, dst_buf2);
825
826
633k
  dec_build_prediction_by_above_preds(cm, dcb, dst_buf1, dst_width1,
827
633k
                                      dst_height1, dst_stride1);
828
633k
  dec_build_prediction_by_left_preds(cm, dcb, dst_buf2, dst_width2, dst_height2,
829
633k
                                     dst_stride2);
830
633k
  const int mi_row = xd->mi_row;
831
633k
  const int mi_col = xd->mi_col;
832
633k
  av1_setup_dst_planes(xd->plane, xd->mi[0]->bsize, &cm->cur_frame->buf, mi_row,
833
633k
                       mi_col, 0, num_planes);
834
633k
  av1_build_obmc_inter_prediction(cm, xd, dst_buf1, dst_stride1, dst_buf2,
835
633k
                                  dst_stride2);
836
633k
}
837
838
static inline void cfl_store_inter_block(AV1_COMMON *const cm,
839
4.24M
                                         MACROBLOCKD *const xd) {
840
4.24M
  MB_MODE_INFO *mbmi = xd->mi[0];
841
4.24M
  if (store_cfl_required(cm, xd)) {
842
745k
    cfl_store_block(xd, mbmi->bsize, mbmi->tx_size);
843
745k
  }
844
4.24M
}
845
846
static inline void predict_inter_block(AV1_COMMON *const cm,
847
                                       DecoderCodingBlock *dcb,
848
4.23M
                                       BLOCK_SIZE bsize) {
849
4.23M
  MACROBLOCKD *const xd = &dcb->xd;
850
4.23M
  MB_MODE_INFO *mbmi = xd->mi[0];
851
4.23M
  const int num_planes = av1_num_planes(cm);
852
4.23M
  const int mi_row = xd->mi_row;
853
4.23M
  const int mi_col = xd->mi_col;
854
9.04M
  for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) {
855
4.80M
    const MV_REFERENCE_FRAME frame = mbmi->ref_frame[ref];
856
4.80M
    if (frame < LAST_FRAME) {
857
52.5k
      assert(is_intrabc_block(mbmi));
858
52.5k
      assert(frame == INTRA_FRAME);
859
52.5k
      assert(ref == 0);
860
4.75M
    } else {
861
4.75M
      const RefCntBuffer *ref_buf = get_ref_frame_buf(cm, frame);
862
4.75M
      const struct scale_factors *ref_scale_factors =
863
4.75M
          get_ref_scale_factors_const(cm, frame);
864
865
4.75M
      xd->block_ref_scale_factors[ref] = ref_scale_factors;
866
4.75M
      av1_setup_pre_planes(xd, ref, &ref_buf->buf, mi_row, mi_col,
867
4.75M
                           ref_scale_factors, num_planes);
868
4.75M
    }
869
4.80M
  }
870
871
4.23M
  dec_build_inter_predictor(cm, dcb, mi_row, mi_col, bsize);
872
4.23M
  if (mbmi->motion_mode == OBMC_CAUSAL) {
873
633k
    dec_build_obmc_inter_predictors_sb(cm, dcb);
874
633k
  }
875
#if CONFIG_MISMATCH_DEBUG
876
  for (int plane = 0; plane < num_planes; ++plane) {
877
    const struct macroblockd_plane *pd = &xd->plane[plane];
878
    int pixel_c, pixel_r;
879
    mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, 0, 0, pd->subsampling_x,
880
                    pd->subsampling_y);
881
    if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x,
882
                             pd->subsampling_y))
883
      continue;
884
    mismatch_check_block_pre(pd->dst.buf, pd->dst.stride,
885
                             cm->current_frame.order_hint, plane, pixel_c,
886
                             pixel_r, pd->width, pd->height,
887
                             xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH);
888
  }
889
#endif
890
4.23M
}
891
892
static inline void set_color_index_map_offset(MACROBLOCKD *const xd, int plane,
893
162k
                                              aom_reader *r) {
894
162k
  (void)r;
895
162k
  Av1ColorMapParam params;
896
162k
  const MB_MODE_INFO *const mbmi = xd->mi[0];
897
162k
  av1_get_block_dimensions(mbmi->bsize, plane, xd, &params.plane_width,
898
162k
                           &params.plane_height, NULL, NULL);
899
162k
  xd->color_index_map_offset[plane] += params.plane_width * params.plane_height;
900
162k
}
901
902
static inline void decode_token_recon_block(AV1Decoder *const pbi,
903
                                            ThreadData *const td, aom_reader *r,
904
22.8M
                                            BLOCK_SIZE bsize) {
905
22.8M
  AV1_COMMON *const cm = &pbi->common;
906
22.8M
  DecoderCodingBlock *const dcb = &td->dcb;
907
22.8M
  MACROBLOCKD *const xd = &dcb->xd;
908
22.8M
  const int num_planes = av1_num_planes(cm);
909
22.8M
  MB_MODE_INFO *mbmi = xd->mi[0];
910
911
22.8M
  if (!is_inter_block(mbmi)) {
912
14.8M
    int row, col;
913
14.8M
    assert(bsize == get_plane_block_size(bsize, xd->plane[0].subsampling_x,
914
14.8M
                                         xd->plane[0].subsampling_y));
915
14.8M
    const int max_blocks_wide = max_block_wide(xd, bsize, 0);
916
14.8M
    const int max_blocks_high = max_block_high(xd, bsize, 0);
917
14.8M
    const BLOCK_SIZE max_unit_bsize = BLOCK_64X64;
918
14.8M
    int mu_blocks_wide = mi_size_wide[max_unit_bsize];
919
14.8M
    int mu_blocks_high = mi_size_high[max_unit_bsize];
920
14.8M
    mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);
921
14.8M
    mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);
922
923
29.9M
    for (row = 0; row < max_blocks_high; row += mu_blocks_high) {
924
30.7M
      for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) {
925
58.8M
        for (int plane = 0; plane < num_planes; ++plane) {
926
44.0M
          if (plane && !xd->is_chroma_ref) break;
927
43.1M
          const struct macroblockd_plane *const pd = &xd->plane[plane];
928
43.1M
          const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
929
43.1M
          const int stepr = tx_size_high_unit[tx_size];
930
43.1M
          const int stepc = tx_size_wide_unit[tx_size];
931
932
43.1M
          const int unit_height = ROUND_POWER_OF_TWO(
933
43.1M
              AOMMIN(mu_blocks_high + row, max_blocks_high), pd->subsampling_y);
934
43.1M
          const int unit_width = ROUND_POWER_OF_TWO(
935
43.1M
              AOMMIN(mu_blocks_wide + col, max_blocks_wide), pd->subsampling_x);
936
937
99.7M
          for (int blk_row = row >> pd->subsampling_y; blk_row < unit_height;
938
56.6M
               blk_row += stepr) {
939
242M
            for (int blk_col = col >> pd->subsampling_x; blk_col < unit_width;
940
185M
                 blk_col += stepc) {
941
185M
              td->read_coeffs_tx_intra_block_visit(cm, dcb, r, plane, blk_row,
942
185M
                                                   blk_col, tx_size);
943
185M
              td->predict_and_recon_intra_block_visit(
944
185M
                  cm, dcb, r, plane, blk_row, blk_col, tx_size);
945
185M
              set_cb_buffer_offsets(dcb, tx_size, plane);
946
185M
            }
947
56.6M
          }
948
43.1M
        }
949
15.6M
      }
950
15.0M
    }
951
14.8M
  } else {
952
7.92M
    td->predict_inter_block_visit(cm, dcb, bsize);
953
    // Reconstruction
954
7.92M
    if (!mbmi->skip_txfm) {
955
6.07M
      int eobtotal = 0;
956
957
6.07M
      const int max_blocks_wide = max_block_wide(xd, bsize, 0);
958
6.07M
      const int max_blocks_high = max_block_high(xd, bsize, 0);
959
6.07M
      int row, col;
960
961
6.07M
      const BLOCK_SIZE max_unit_bsize = BLOCK_64X64;
962
6.07M
      assert(max_unit_bsize ==
963
6.07M
             get_plane_block_size(BLOCK_64X64, xd->plane[0].subsampling_x,
964
6.07M
                                  xd->plane[0].subsampling_y));
965
6.06M
      int mu_blocks_wide = mi_size_wide[max_unit_bsize];
966
6.06M
      int mu_blocks_high = mi_size_high[max_unit_bsize];
967
968
6.06M
      mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);
969
6.06M
      mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);
970
971
12.1M
      for (row = 0; row < max_blocks_high; row += mu_blocks_high) {
972
12.2M
        for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) {
973
22.3M
          for (int plane = 0; plane < num_planes; ++plane) {
974
17.2M
            if (plane && !xd->is_chroma_ref) break;
975
16.1M
            const struct macroblockd_plane *const pd = &xd->plane[plane];
976
16.1M
            const int ss_x = pd->subsampling_x;
977
16.1M
            const int ss_y = pd->subsampling_y;
978
16.1M
            const BLOCK_SIZE plane_bsize =
979
16.1M
                get_plane_block_size(bsize, ss_x, ss_y);
980
16.1M
            const TX_SIZE max_tx_size =
981
16.1M
                get_vartx_max_txsize(xd, plane_bsize, plane);
982
16.1M
            const int bh_var_tx = tx_size_high_unit[max_tx_size];
983
16.1M
            const int bw_var_tx = tx_size_wide_unit[max_tx_size];
984
16.1M
            int block = 0;
985
16.1M
            int step =
986
16.1M
                tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
987
16.1M
            int blk_row, blk_col;
988
16.1M
            const int unit_height = ROUND_POWER_OF_TWO(
989
16.1M
                AOMMIN(mu_blocks_high + row, max_blocks_high), ss_y);
990
16.1M
            const int unit_width = ROUND_POWER_OF_TWO(
991
16.1M
                AOMMIN(mu_blocks_wide + col, max_blocks_wide), ss_x);
992
993
32.3M
            for (blk_row = row >> ss_y; blk_row < unit_height;
994
16.2M
                 blk_row += bh_var_tx) {
995
33.3M
              for (blk_col = col >> ss_x; blk_col < unit_width;
996
17.0M
                   blk_col += bw_var_tx) {
997
17.0M
                decode_reconstruct_tx(cm, td, r, mbmi, plane, plane_bsize,
998
17.0M
                                      blk_row, blk_col, block, max_tx_size,
999
17.0M
                                      &eobtotal);
1000
17.0M
                block += step;
1001
17.0M
              }
1002
16.2M
            }
1003
16.1M
          }
1004
6.15M
        }
1005
6.09M
      }
1006
6.06M
    }
1007
7.90M
    td->cfl_store_inter_block_visit(cm, xd);
1008
7.90M
  }
1009
1010
22.8M
  av1_visit_palette(pbi, xd, r, set_color_index_map_offset);
1011
22.8M
}
1012
1013
static inline void set_inter_tx_size(MB_MODE_INFO *mbmi, int stride_log2,
1014
                                     int tx_w_log2, int tx_h_log2, int min_txs,
1015
                                     int split_size, int txs, int blk_row,
1016
1.42M
                                     int blk_col) {
1017
3.37M
  for (int idy = 0; idy < tx_size_high_unit[split_size];
1018
1.94M
       idy += tx_size_high_unit[min_txs]) {
1019
4.85M
    for (int idx = 0; idx < tx_size_wide_unit[split_size];
1020
2.90M
         idx += tx_size_wide_unit[min_txs]) {
1021
2.90M
      const int index = (((blk_row + idy) >> tx_h_log2) << stride_log2) +
1022
2.90M
                        ((blk_col + idx) >> tx_w_log2);
1023
2.90M
      mbmi->inter_tx_size[index] = txs;
1024
2.90M
    }
1025
1.94M
  }
1026
1.42M
}
1027
1028
static inline void read_tx_size_vartx(MACROBLOCKD *xd, MB_MODE_INFO *mbmi,
1029
                                      TX_SIZE tx_size, int depth, int blk_row,
1030
1.68M
                                      int blk_col, aom_reader *r) {
1031
1.68M
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
1032
1.68M
  int is_split = 0;
1033
1.68M
  const BLOCK_SIZE bsize = mbmi->bsize;
1034
1.68M
  const int max_blocks_high = max_block_high(xd, bsize, 0);
1035
1.68M
  const int max_blocks_wide = max_block_wide(xd, bsize, 0);
1036
1.68M
  if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
1037
1.68M
  assert(tx_size > TX_4X4);
1038
1.68M
  TX_SIZE txs = max_txsize_rect_lookup[bsize];
1039
3.36M
  for (int level = 0; level < MAX_VARTX_DEPTH - 1; ++level)
1040
1.68M
    txs = sub_tx_size_map[txs];
1041
1.68M
  const int tx_w_log2 = tx_size_wide_log2[txs] - MI_SIZE_LOG2;
1042
1.68M
  const int tx_h_log2 = tx_size_high_log2[txs] - MI_SIZE_LOG2;
1043
1.68M
  const int bw_log2 = mi_size_wide_log2[bsize];
1044
1.68M
  const int stride_log2 = bw_log2 - tx_w_log2;
1045
1046
1.68M
  if (depth == MAX_VARTX_DEPTH) {
1047
187k
    set_inter_tx_size(mbmi, stride_log2, tx_w_log2, tx_h_log2, txs, tx_size,
1048
187k
                      tx_size, blk_row, blk_col);
1049
187k
    mbmi->tx_size = tx_size;
1050
187k
    txfm_partition_update(xd->above_txfm_context + blk_col,
1051
187k
                          xd->left_txfm_context + blk_row, tx_size, tx_size);
1052
187k
    return;
1053
187k
  }
1054
1055
1.49M
  const int ctx = txfm_partition_context(xd->above_txfm_context + blk_col,
1056
1.49M
                                         xd->left_txfm_context + blk_row,
1057
1.49M
                                         mbmi->bsize, tx_size);
1058
1.49M
  is_split = aom_read_symbol(r, ec_ctx->txfm_partition_cdf[ctx], 2, ACCT_STR);
1059
1060
1.49M
  if (is_split) {
1061
383k
    const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
1062
383k
    const int bsw = tx_size_wide_unit[sub_txs];
1063
383k
    const int bsh = tx_size_high_unit[sub_txs];
1064
1065
383k
    if (sub_txs == TX_4X4) {
1066
128k
      set_inter_tx_size(mbmi, stride_log2, tx_w_log2, tx_h_log2, txs, tx_size,
1067
128k
                        sub_txs, blk_row, blk_col);
1068
128k
      mbmi->tx_size = sub_txs;
1069
128k
      txfm_partition_update(xd->above_txfm_context + blk_col,
1070
128k
                            xd->left_txfm_context + blk_row, sub_txs, tx_size);
1071
128k
      return;
1072
128k
    }
1073
1074
254k
    assert(bsw > 0 && bsh > 0);
1075
679k
    for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) {
1076
1.12M
      for (int col = 0; col < tx_size_wide_unit[tx_size]; col += bsw) {
1077
702k
        int offsetr = blk_row + row;
1078
702k
        int offsetc = blk_col + col;
1079
702k
        read_tx_size_vartx(xd, mbmi, sub_txs, depth + 1, offsetr, offsetc, r);
1080
702k
      }
1081
424k
    }
1082
1.11M
  } else {
1083
1.11M
    set_inter_tx_size(mbmi, stride_log2, tx_w_log2, tx_h_log2, txs, tx_size,
1084
1.11M
                      tx_size, blk_row, blk_col);
1085
1.11M
    mbmi->tx_size = tx_size;
1086
1.11M
    txfm_partition_update(xd->above_txfm_context + blk_col,
1087
1.11M
                          xd->left_txfm_context + blk_row, tx_size, tx_size);
1088
1.11M
  }
1089
1.49M
}
1090
1091
static TX_SIZE read_selected_tx_size(const MACROBLOCKD *const xd,
1092
1.63M
                                     aom_reader *r) {
1093
  // TODO(debargha): Clean up the logic here. This function should only
1094
  // be called for intra.
1095
1.63M
  const BLOCK_SIZE bsize = xd->mi[0]->bsize;
1096
1.63M
  const int32_t tx_size_cat = bsize_to_tx_size_cat(bsize);
1097
1.63M
  const int max_depths = bsize_to_max_depth(bsize);
1098
1.63M
  const int ctx = get_tx_size_context(xd);
1099
1.63M
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
1100
1.63M
  const int depth = aom_read_symbol(r, ec_ctx->tx_size_cdf[tx_size_cat][ctx],
1101
1.63M
                                    max_depths + 1, ACCT_STR);
1102
1.63M
  assert(depth >= 0 && depth <= max_depths);
1103
1.63M
  const TX_SIZE tx_size = depth_to_tx_size(depth, bsize);
1104
1.63M
  return tx_size;
1105
1.63M
}
1106
1107
static TX_SIZE read_tx_size(const MACROBLOCKD *const xd, TX_MODE tx_mode,
1108
                            int is_inter, int allow_select_inter,
1109
14.6M
                            aom_reader *r) {
1110
14.6M
  const BLOCK_SIZE bsize = xd->mi[0]->bsize;
1111
14.6M
  if (xd->lossless[xd->mi[0]->segment_id]) return TX_4X4;
1112
1113
14.5M
  if (block_signals_txsize(bsize)) {
1114
13.7M
    if ((!is_inter || allow_select_inter) && tx_mode == TX_MODE_SELECT) {
1115
1.63M
      const TX_SIZE coded_tx_size = read_selected_tx_size(xd, r);
1116
1.63M
      return coded_tx_size;
1117
12.1M
    } else {
1118
12.1M
      return tx_size_from_tx_mode(bsize, tx_mode);
1119
12.1M
    }
1120
13.7M
  } else {
1121
747k
    assert(IMPLIES(tx_mode == ONLY_4X4, bsize == BLOCK_4X4));
1122
748k
    return max_txsize_rect_lookup[bsize];
1123
747k
  }
1124
14.5M
}
1125
1126
static inline void parse_decode_block(AV1Decoder *const pbi,
1127
                                      ThreadData *const td, int mi_row,
1128
                                      int mi_col, aom_reader *r,
1129
                                      PARTITION_TYPE partition,
1130
15.6M
                                      BLOCK_SIZE bsize) {
1131
15.6M
  DecoderCodingBlock *const dcb = &td->dcb;
1132
15.6M
  MACROBLOCKD *const xd = &dcb->xd;
1133
15.6M
  decode_mbmi_block(pbi, dcb, mi_row, mi_col, r, partition, bsize);
1134
1135
15.6M
  av1_visit_palette(pbi, xd, r, av1_decode_palette_tokens);
1136
1137
15.6M
  AV1_COMMON *cm = &pbi->common;
1138
15.6M
  const int num_planes = av1_num_planes(cm);
1139
15.6M
  MB_MODE_INFO *mbmi = xd->mi[0];
1140
15.6M
  int inter_block_tx = is_inter_block(mbmi) || is_intrabc_block(mbmi);
1141
15.6M
  if (cm->features.tx_mode == TX_MODE_SELECT && block_signals_txsize(bsize) &&
1142
15.6M
      !mbmi->skip_txfm && inter_block_tx && !xd->lossless[mbmi->segment_id]) {
1143
952k
    const TX_SIZE max_tx_size = max_txsize_rect_lookup[bsize];
1144
952k
    const int bh = tx_size_high_unit[max_tx_size];
1145
952k
    const int bw = tx_size_wide_unit[max_tx_size];
1146
952k
    const int width = mi_size_wide[bsize];
1147
952k
    const int height = mi_size_high[bsize];
1148
1149
1.91M
    for (int idy = 0; idy < height; idy += bh)
1150
1.94M
      for (int idx = 0; idx < width; idx += bw)
1151
983k
        read_tx_size_vartx(xd, mbmi, max_tx_size, 0, idy, idx, r);
1152
14.6M
  } else {
1153
14.6M
    mbmi->tx_size = read_tx_size(xd, cm->features.tx_mode, inter_block_tx,
1154
14.6M
                                 !mbmi->skip_txfm, r);
1155
14.6M
    if (inter_block_tx)
1156
3.65M
      memset(mbmi->inter_tx_size, mbmi->tx_size, sizeof(mbmi->inter_tx_size));
1157
14.6M
    set_txfm_ctxs(mbmi->tx_size, xd->width, xd->height,
1158
14.6M
                  mbmi->skip_txfm && is_inter_block(mbmi), xd);
1159
14.6M
  }
1160
1161
15.6M
  if (cm->delta_q_info.delta_q_present_flag) {
1162
19.4M
    for (int i = 0; i < MAX_SEGMENTS; i++) {
1163
17.3M
      const int current_qindex =
1164
17.3M
          av1_get_qindex(&cm->seg, i, xd->current_base_qindex);
1165
17.3M
      const CommonQuantParams *const quant_params = &cm->quant_params;
1166
63.4M
      for (int j = 0; j < num_planes; ++j) {
1167
46.0M
        const int dc_delta_q = j == 0 ? quant_params->y_dc_delta_q
1168
46.0M
                                      : (j == 1 ? quant_params->u_dc_delta_q
1169
28.7M
                                                : quant_params->v_dc_delta_q);
1170
46.0M
        const int ac_delta_q = j == 0 ? 0
1171
46.0M
                                      : (j == 1 ? quant_params->u_ac_delta_q
1172
28.7M
                                                : quant_params->v_ac_delta_q);
1173
46.0M
        xd->plane[j].seg_dequant_QTX[i][0] = av1_dc_quant_QTX(
1174
46.0M
            current_qindex, dc_delta_q, cm->seq_params->bit_depth);
1175
46.0M
        xd->plane[j].seg_dequant_QTX[i][1] = av1_ac_quant_QTX(
1176
46.0M
            current_qindex, ac_delta_q, cm->seq_params->bit_depth);
1177
46.0M
      }
1178
17.3M
    }
1179
2.16M
  }
1180
15.6M
  if (mbmi->skip_txfm) av1_reset_entropy_context(xd, bsize, num_planes);
1181
1182
15.6M
  decode_token_recon_block(pbi, td, r, bsize);
1183
15.6M
}
1184
1185
static inline void set_offsets_for_pred_and_recon(AV1Decoder *const pbi,
1186
                                                  ThreadData *const td,
1187
                                                  int mi_row, int mi_col,
1188
7.24M
                                                  BLOCK_SIZE bsize) {
1189
7.24M
  AV1_COMMON *const cm = &pbi->common;
1190
7.24M
  const CommonModeInfoParams *const mi_params = &cm->mi_params;
1191
7.24M
  DecoderCodingBlock *const dcb = &td->dcb;
1192
7.24M
  MACROBLOCKD *const xd = &dcb->xd;
1193
7.24M
  const int bw = mi_size_wide[bsize];
1194
7.24M
  const int bh = mi_size_high[bsize];
1195
7.24M
  const int num_planes = av1_num_planes(cm);
1196
1197
7.24M
  const int offset = mi_row * mi_params->mi_stride + mi_col;
1198
7.24M
  const TileInfo *const tile = &xd->tile;
1199
1200
7.24M
  xd->mi = mi_params->mi_grid_base + offset;
1201
7.24M
  xd->tx_type_map =
1202
7.24M
      &mi_params->tx_type_map[mi_row * mi_params->mi_stride + mi_col];
1203
7.24M
  xd->tx_type_map_stride = mi_params->mi_stride;
1204
1205
7.24M
  set_plane_n4(xd, bw, bh, num_planes);
1206
1207
  // Distance of Mb to the various image edges. These are specified to 8th pel
1208
  // as they are always compared to values that are in 1/8th pel units
1209
7.24M
  set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, mi_params->mi_rows,
1210
7.24M
                 mi_params->mi_cols);
1211
1212
7.24M
  av1_setup_dst_planes(xd->plane, bsize, &cm->cur_frame->buf, mi_row, mi_col, 0,
1213
7.24M
                       num_planes);
1214
7.24M
}
1215
1216
static inline void decode_block(AV1Decoder *const pbi, ThreadData *const td,
1217
                                int mi_row, int mi_col, aom_reader *r,
1218
7.24M
                                PARTITION_TYPE partition, BLOCK_SIZE bsize) {
1219
7.24M
  (void)partition;
1220
7.24M
  set_offsets_for_pred_and_recon(pbi, td, mi_row, mi_col, bsize);
1221
7.24M
  decode_token_recon_block(pbi, td, r, bsize);
1222
7.24M
}
1223
1224
static PARTITION_TYPE read_partition(MACROBLOCKD *xd, int mi_row, int mi_col,
1225
                                     aom_reader *r, int has_rows, int has_cols,
1226
10.5M
                                     BLOCK_SIZE bsize) {
1227
10.5M
  const int ctx = partition_plane_context(xd, mi_row, mi_col, bsize);
1228
10.5M
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
1229
1230
10.5M
  if (!has_rows && !has_cols) return PARTITION_SPLIT;
1231
1232
10.4M
  assert(ctx >= 0);
1233
10.4M
  aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[ctx];
1234
10.4M
  if (has_rows && has_cols) {
1235
10.1M
    return (PARTITION_TYPE)aom_read_symbol(
1236
10.1M
        r, partition_cdf, partition_cdf_length(bsize), ACCT_STR);
1237
10.1M
  } else if (!has_rows && has_cols) {
1238
119k
    assert(bsize > BLOCK_8X8);
1239
119k
    aom_cdf_prob cdf[2];
1240
119k
    partition_gather_vert_alike(cdf, partition_cdf, bsize);
1241
119k
    assert(cdf[1] == AOM_ICDF(CDF_PROB_TOP));
1242
119k
    return aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_HORZ;
1243
202k
  } else {
1244
202k
    assert(has_rows && !has_cols);
1245
203k
    assert(bsize > BLOCK_8X8);
1246
203k
    aom_cdf_prob cdf[2];
1247
203k
    partition_gather_horz_alike(cdf, partition_cdf, bsize);
1248
203k
    assert(cdf[1] == AOM_ICDF(CDF_PROB_TOP));
1249
203k
    return aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_VERT;
1250
203k
  }
1251
10.4M
}
1252
1253
// TODO(slavarnway): eliminate bsize and subsize in future commits
1254
static inline void decode_partition(AV1Decoder *const pbi, ThreadData *const td,
1255
                                    int mi_row, int mi_col, aom_reader *reader,
1256
17.3M
                                    BLOCK_SIZE bsize, int parse_decode_flag) {
1257
17.3M
  assert(bsize < BLOCK_SIZES_ALL);
1258
17.3M
  AV1_COMMON *const cm = &pbi->common;
1259
17.3M
  DecoderCodingBlock *const dcb = &td->dcb;
1260
17.3M
  MACROBLOCKD *const xd = &dcb->xd;
1261
17.3M
  const int bw = mi_size_wide[bsize];
1262
17.3M
  const int hbs = bw >> 1;
1263
17.3M
  PARTITION_TYPE partition;
1264
17.3M
  BLOCK_SIZE subsize;
1265
17.3M
  const int quarter_step = bw / 4;
1266
17.3M
  BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT);
1267
17.3M
  const int has_rows = (mi_row + hbs) < cm->mi_params.mi_rows;
1268
17.3M
  const int has_cols = (mi_col + hbs) < cm->mi_params.mi_cols;
1269
1270
17.3M
  if (mi_row >= cm->mi_params.mi_rows || mi_col >= cm->mi_params.mi_cols)
1271
750k
    return;
1272
1273
  // parse_decode_flag takes the following values :
1274
  // 01 - do parse only
1275
  // 10 - do decode only
1276
  // 11 - do parse and decode
1277
16.5M
  static const block_visitor_fn_t block_visit[4] = { NULL, parse_decode_block,
1278
16.5M
                                                     decode_block,
1279
16.5M
                                                     parse_decode_block };
1280
1281
16.5M
  if (parse_decode_flag & 1) {
1282
11.3M
    const int num_planes = av1_num_planes(cm);
1283
44.3M
    for (int plane = 0; plane < num_planes; ++plane) {
1284
32.9M
      int rcol0, rcol1, rrow0, rrow1;
1285
1286
      // Skip some unnecessary work if loop restoration is disabled
1287
32.9M
      if (cm->rst_info[plane].frame_restoration_type == RESTORE_NONE) continue;
1288
1289
17.3M
      if (av1_loop_restoration_corners_in_sb(cm, plane, mi_row, mi_col, bsize,
1290
17.3M
                                             &rcol0, &rcol1, &rrow0, &rrow1)) {
1291
252k
        const int rstride = cm->rst_info[plane].horz_units;
1292
504k
        for (int rrow = rrow0; rrow < rrow1; ++rrow) {
1293
507k
          for (int rcol = rcol0; rcol < rcol1; ++rcol) {
1294
255k
            const int runit_idx = rcol + rrow * rstride;
1295
255k
            loop_restoration_read_sb_coeffs(cm, xd, reader, plane, runit_idx);
1296
255k
          }
1297
252k
        }
1298
252k
      }
1299
17.3M
    }
1300
1301
11.3M
    partition = (bsize < BLOCK_8X8) ? PARTITION_NONE
1302
11.3M
                                    : read_partition(xd, mi_row, mi_col, reader,
1303
10.5M
                                                     has_rows, has_cols, bsize);
1304
11.3M
  } else {
1305
5.25M
    partition = get_partition(cm, mi_row, mi_col, bsize);
1306
5.25M
  }
1307
16.5M
  subsize = get_partition_subsize(bsize, partition);
1308
16.5M
  if (subsize == BLOCK_INVALID) {
1309
    // When an internal error occurs ensure that xd->mi_row is set appropriately
1310
    // w.r.t. current tile, which is used to signal processing of current row is
1311
    // done.
1312
0
    xd->mi_row = mi_row;
1313
0
    aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
1314
0
                       "Partition is invalid for block size %dx%d",
1315
0
                       block_size_wide[bsize], block_size_high[bsize]);
1316
0
  }
1317
  // Check the bitstream is conformant: if there is subsampling on the
1318
  // chroma planes, subsize must subsample to a valid block size.
1319
16.5M
  const struct macroblockd_plane *const pd_u = &xd->plane[1];
1320
16.5M
  if (get_plane_block_size(subsize, pd_u->subsampling_x, pd_u->subsampling_y) ==
1321
16.5M
      BLOCK_INVALID) {
1322
    // When an internal error occurs ensure that xd->mi_row is set appropriately
1323
    // w.r.t. current tile, which is used to signal processing of current row is
1324
    // done.
1325
1.02k
    xd->mi_row = mi_row;
1326
1.02k
    aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
1327
1.02k
                       "Block size %dx%d invalid with this subsampling mode",
1328
1.02k
                       block_size_wide[subsize], block_size_high[subsize]);
1329
1.02k
  }
1330
1331
16.5M
#define DEC_BLOCK_STX_ARG
1332
22.8M
#define DEC_BLOCK_EPT_ARG partition,
1333
16.5M
#define DEC_BLOCK(db_r, db_c, db_subsize)                                  \
1334
22.8M
  block_visit[parse_decode_flag](pbi, td, DEC_BLOCK_STX_ARG(db_r), (db_c), \
1335
22.8M
                                 reader, DEC_BLOCK_EPT_ARG(db_subsize))
1336
16.5M
#define DEC_PARTITION(db_r, db_c, db_subsize)                        \
1337
16.5M
  decode_partition(pbi, td, DEC_BLOCK_STX_ARG(db_r), (db_c), reader, \
1338
15.7M
                   (db_subsize), parse_decode_flag)
1339
1340
16.5M
  switch (partition) {
1341
6.73M
    case PARTITION_NONE: DEC_BLOCK(mi_row, mi_col, subsize); break;
1342
1.83M
    case PARTITION_HORZ:
1343
1.83M
      DEC_BLOCK(mi_row, mi_col, subsize);
1344
1.83M
      if (has_rows) DEC_BLOCK(mi_row + hbs, mi_col, subsize);
1345
1.83M
      break;
1346
1.23M
    case PARTITION_VERT:
1347
1.23M
      DEC_BLOCK(mi_row, mi_col, subsize);
1348
1.23M
      if (has_cols) DEC_BLOCK(mi_row, mi_col + hbs, subsize);
1349
1.23M
      break;
1350
3.94M
    case PARTITION_SPLIT:
1351
3.94M
      DEC_PARTITION(mi_row, mi_col, subsize);
1352
3.94M
      DEC_PARTITION(mi_row, mi_col + hbs, subsize);
1353
3.94M
      DEC_PARTITION(mi_row + hbs, mi_col, subsize);
1354
3.94M
      DEC_PARTITION(mi_row + hbs, mi_col + hbs, subsize);
1355
3.94M
      break;
1356
363k
    case PARTITION_HORZ_A:
1357
363k
      DEC_BLOCK(mi_row, mi_col, bsize2);
1358
363k
      DEC_BLOCK(mi_row, mi_col + hbs, bsize2);
1359
363k
      DEC_BLOCK(mi_row + hbs, mi_col, subsize);
1360
363k
      break;
1361
325k
    case PARTITION_HORZ_B:
1362
325k
      DEC_BLOCK(mi_row, mi_col, subsize);
1363
325k
      DEC_BLOCK(mi_row + hbs, mi_col, bsize2);
1364
325k
      DEC_BLOCK(mi_row + hbs, mi_col + hbs, bsize2);
1365
325k
      break;
1366
221k
    case PARTITION_VERT_A:
1367
221k
      DEC_BLOCK(mi_row, mi_col, bsize2);
1368
221k
      DEC_BLOCK(mi_row + hbs, mi_col, bsize2);
1369
221k
      DEC_BLOCK(mi_row, mi_col + hbs, subsize);
1370
221k
      break;
1371
254k
    case PARTITION_VERT_B:
1372
254k
      DEC_BLOCK(mi_row, mi_col, subsize);
1373
254k
      DEC_BLOCK(mi_row, mi_col + hbs, bsize2);
1374
254k
      DEC_BLOCK(mi_row + hbs, mi_col + hbs, bsize2);
1375
254k
      break;
1376
1.08M
    case PARTITION_HORZ_4:
1377
5.43M
      for (int i = 0; i < 4; ++i) {
1378
4.35M
        int this_mi_row = mi_row + i * quarter_step;
1379
4.35M
        if (i > 0 && this_mi_row >= cm->mi_params.mi_rows) break;
1380
4.34M
        DEC_BLOCK(this_mi_row, mi_col, subsize);
1381
4.34M
      }
1382
1.08M
      break;
1383
601k
    case PARTITION_VERT_4:
1384
2.99M
      for (int i = 0; i < 4; ++i) {
1385
2.40M
        int this_mi_col = mi_col + i * quarter_step;
1386
2.40M
        if (i > 0 && this_mi_col >= cm->mi_params.mi_cols) break;
1387
2.39M
        DEC_BLOCK(mi_row, this_mi_col, subsize);
1388
2.39M
      }
1389
601k
      break;
1390
0
    default: assert(0 && "Invalid partition type");
1391
16.5M
  }
1392
1393
16.5M
#undef DEC_PARTITION
1394
16.5M
#undef DEC_BLOCK
1395
16.5M
#undef DEC_BLOCK_EPT_ARG
1396
16.5M
#undef DEC_BLOCK_STX_ARG
1397
1398
16.5M
  if (parse_decode_flag & 1)
1399
11.3M
    update_ext_partition_context(xd, mi_row, mi_col, subsize, bsize, partition);
1400
16.5M
}
1401
1402
static inline void setup_bool_decoder(
1403
    MACROBLOCKD *const xd, const uint8_t *data, const uint8_t *data_end,
1404
    const size_t read_size, struct aom_internal_error_info *error_info,
1405
163k
    aom_reader *r, uint8_t allow_update_cdf) {
1406
  // Validate the calculated partition length. If the buffer
1407
  // described by the partition can't be fully read, then restrict
1408
  // it to the portion that can be (for EC mode) or throw an error.
1409
163k
  if (!read_is_valid(data, read_size, data_end)) {
1410
    // When internal error occurs ensure that xd->mi_row is set appropriately
1411
    // w.r.t. current tile, which is used to signal processing of current row is
1412
    // done in row-mt decoding.
1413
654
    xd->mi_row = xd->tile.mi_row_start;
1414
1415
654
    aom_internal_error(error_info, AOM_CODEC_CORRUPT_FRAME,
1416
654
                       "Truncated packet or corrupt tile length");
1417
654
  }
1418
163k
  if (aom_reader_init(r, data, read_size)) {
1419
    // When internal error occurs ensure that xd->mi_row is set appropriately
1420
    // w.r.t. current tile, which is used to signal processing of current row is
1421
    // done in row-mt decoding.
1422
0
    xd->mi_row = xd->tile.mi_row_start;
1423
1424
0
    aom_internal_error(error_info, AOM_CODEC_MEM_ERROR,
1425
0
                       "Failed to allocate bool decoder %d", 1);
1426
0
  }
1427
1428
163k
  r->allow_update_cdf = allow_update_cdf;
1429
163k
}
1430
1431
static inline void setup_segmentation(AV1_COMMON *const cm,
1432
188k
                                      struct aom_read_bit_buffer *rb) {
1433
188k
  struct segmentation *const seg = &cm->seg;
1434
1435
188k
  seg->update_map = 0;
1436
188k
  seg->update_data = 0;
1437
188k
  seg->temporal_update = 0;
1438
1439
188k
  seg->enabled = aom_rb_read_bit(rb);
1440
188k
  if (!seg->enabled) {
1441
163k
    if (cm->cur_frame->seg_map) {
1442
163k
      memset(cm->cur_frame->seg_map, 0,
1443
163k
             (cm->cur_frame->mi_rows * cm->cur_frame->mi_cols));
1444
163k
    }
1445
1446
163k
    memset(seg, 0, sizeof(*seg));
1447
163k
    segfeatures_copy(&cm->cur_frame->seg, seg);
1448
163k
    return;
1449
163k
  }
1450
24.9k
  if (cm->seg.enabled && cm->prev_frame &&
1451
24.9k
      (cm->mi_params.mi_rows == cm->prev_frame->mi_rows) &&
1452
24.9k
      (cm->mi_params.mi_cols == cm->prev_frame->mi_cols)) {
1453
7.62k
    cm->last_frame_seg_map = cm->prev_frame->seg_map;
1454
17.3k
  } else {
1455
17.3k
    cm->last_frame_seg_map = NULL;
1456
17.3k
  }
1457
  // Read update flags
1458
24.9k
  if (cm->features.primary_ref_frame == PRIMARY_REF_NONE) {
1459
    // These frames can't use previous frames, so must signal map + features
1460
15.5k
    seg->update_map = 1;
1461
15.5k
    seg->temporal_update = 0;
1462
15.5k
    seg->update_data = 1;
1463
15.5k
  } else {
1464
9.38k
    seg->update_map = aom_rb_read_bit(rb);
1465
9.38k
    if (seg->update_map) {
1466
5.91k
      seg->temporal_update = aom_rb_read_bit(rb);
1467
5.91k
    } else {
1468
3.46k
      seg->temporal_update = 0;
1469
3.46k
    }
1470
9.38k
    seg->update_data = aom_rb_read_bit(rb);
1471
9.38k
  }
1472
1473
  // Segmentation data update
1474
24.9k
  if (seg->update_data) {
1475
18.4k
    av1_clearall_segfeatures(seg);
1476
1477
161k
    for (int i = 0; i < MAX_SEGMENTS; i++) {
1478
1.27M
      for (int j = 0; j < SEG_LVL_MAX; j++) {
1479
1.13M
        int data = 0;
1480
1.13M
        const int feature_enabled = aom_rb_read_bit(rb);
1481
1.13M
        if (feature_enabled) {
1482
278k
          av1_enable_segfeature(seg, i, j);
1483
1484
278k
          const int data_max = av1_seg_feature_data_max(j);
1485
278k
          const int data_min = -data_max;
1486
278k
          const int ubits = get_unsigned_bits(data_max);
1487
1488
278k
          if (av1_is_segfeature_signed(j)) {
1489
167k
            data = aom_rb_read_inv_signed_literal(rb, ubits);
1490
167k
          } else {
1491
111k
            data = aom_rb_read_literal(rb, ubits);
1492
111k
          }
1493
1494
278k
          data = clamp(data, data_min, data_max);
1495
278k
        }
1496
1.13M
        av1_set_segdata(seg, i, j, data);
1497
1.13M
      }
1498
142k
    }
1499
18.4k
    av1_calculate_segdata(seg);
1500
18.4k
  } else if (cm->prev_frame) {
1501
6.51k
    segfeatures_copy(seg, &cm->prev_frame->seg);
1502
6.51k
  }
1503
24.9k
  segfeatures_copy(&cm->cur_frame->seg, seg);
1504
24.9k
}
1505
1506
static inline void decode_restoration_mode(AV1_COMMON *cm,
1507
81.8k
                                           struct aom_read_bit_buffer *rb) {
1508
81.8k
  assert(!cm->features.all_lossless);
1509
81.8k
  const int num_planes = av1_num_planes(cm);
1510
81.8k
  if (cm->features.allow_intrabc) return;
1511
72.4k
  int all_none = 1, chroma_none = 1;
1512
272k
  for (int p = 0; p < num_planes; ++p) {
1513
200k
    RestorationInfo *rsi = &cm->rst_info[p];
1514
200k
    if (aom_rb_read_bit(rb)) {
1515
50.4k
      rsi->frame_restoration_type =
1516
50.4k
          aom_rb_read_bit(rb) ? RESTORE_SGRPROJ : RESTORE_WIENER;
1517
149k
    } else {
1518
149k
      rsi->frame_restoration_type =
1519
149k
          aom_rb_read_bit(rb) ? RESTORE_SWITCHABLE : RESTORE_NONE;
1520
149k
    }
1521
200k
    if (rsi->frame_restoration_type != RESTORE_NONE) {
1522
65.3k
      all_none = 0;
1523
65.3k
      chroma_none &= p == 0;
1524
65.3k
    }
1525
200k
  }
1526
72.4k
  if (!all_none) {
1527
32.9k
    assert(cm->seq_params->sb_size == BLOCK_64X64 ||
1528
32.9k
           cm->seq_params->sb_size == BLOCK_128X128);
1529
32.9k
    const int sb_size = cm->seq_params->sb_size == BLOCK_128X128 ? 128 : 64;
1530
1531
121k
    for (int p = 0; p < num_planes; ++p)
1532
88.7k
      cm->rst_info[p].restoration_unit_size = sb_size;
1533
1534
32.9k
    RestorationInfo *rsi = &cm->rst_info[0];
1535
1536
32.9k
    if (sb_size == 64) {
1537
5.64k
      rsi->restoration_unit_size <<= aom_rb_read_bit(rb);
1538
5.64k
    }
1539
32.9k
    if (rsi->restoration_unit_size > 64) {
1540
29.4k
      rsi->restoration_unit_size <<= aom_rb_read_bit(rb);
1541
29.4k
    }
1542
39.5k
  } else {
1543
39.5k
    const int size = RESTORATION_UNITSIZE_MAX;
1544
151k
    for (int p = 0; p < num_planes; ++p)
1545
111k
      cm->rst_info[p].restoration_unit_size = size;
1546
39.5k
  }
1547
1548
72.4k
  if (num_planes > 1) {
1549
63.7k
    int s =
1550
63.7k
        AOMMIN(cm->seq_params->subsampling_x, cm->seq_params->subsampling_y);
1551
63.7k
    if (s && !chroma_none) {
1552
18.6k
      cm->rst_info[1].restoration_unit_size =
1553
18.6k
          cm->rst_info[0].restoration_unit_size >> (aom_rb_read_bit(rb) * s);
1554
45.0k
    } else {
1555
45.0k
      cm->rst_info[1].restoration_unit_size =
1556
45.0k
          cm->rst_info[0].restoration_unit_size;
1557
45.0k
    }
1558
63.7k
    cm->rst_info[2].restoration_unit_size =
1559
63.7k
        cm->rst_info[1].restoration_unit_size;
1560
63.7k
  }
1561
72.4k
}
1562
1563
static inline void read_wiener_filter(int wiener_win, WienerInfo *wiener_info,
1564
                                      WienerInfo *ref_wiener_info,
1565
43.5k
                                      aom_reader *rb) {
1566
43.5k
  memset(wiener_info->vfilter, 0, sizeof(wiener_info->vfilter));
1567
43.5k
  memset(wiener_info->hfilter, 0, sizeof(wiener_info->hfilter));
1568
1569
43.5k
  if (wiener_win == WIENER_WIN)
1570
19.4k
    wiener_info->vfilter[0] = wiener_info->vfilter[WIENER_WIN - 1] =
1571
19.4k
        aom_read_primitive_refsubexpfin(
1572
19.4k
            rb, WIENER_FILT_TAP0_MAXV - WIENER_FILT_TAP0_MINV + 1,
1573
19.4k
            WIENER_FILT_TAP0_SUBEXP_K,
1574
19.4k
            ref_wiener_info->vfilter[0] - WIENER_FILT_TAP0_MINV, ACCT_STR) +
1575
19.4k
        WIENER_FILT_TAP0_MINV;
1576
24.1k
  else
1577
24.1k
    wiener_info->vfilter[0] = wiener_info->vfilter[WIENER_WIN - 1] = 0;
1578
43.5k
  wiener_info->vfilter[1] = wiener_info->vfilter[WIENER_WIN - 2] =
1579
43.5k
      aom_read_primitive_refsubexpfin(
1580
43.5k
          rb, WIENER_FILT_TAP1_MAXV - WIENER_FILT_TAP1_MINV + 1,
1581
43.5k
          WIENER_FILT_TAP1_SUBEXP_K,
1582
43.5k
          ref_wiener_info->vfilter[1] - WIENER_FILT_TAP1_MINV, ACCT_STR) +
1583
43.5k
      WIENER_FILT_TAP1_MINV;
1584
43.5k
  wiener_info->vfilter[2] = wiener_info->vfilter[WIENER_WIN - 3] =
1585
43.5k
      aom_read_primitive_refsubexpfin(
1586
43.5k
          rb, WIENER_FILT_TAP2_MAXV - WIENER_FILT_TAP2_MINV + 1,
1587
43.5k
          WIENER_FILT_TAP2_SUBEXP_K,
1588
43.5k
          ref_wiener_info->vfilter[2] - WIENER_FILT_TAP2_MINV, ACCT_STR) +
1589
43.5k
      WIENER_FILT_TAP2_MINV;
1590
  // The central element has an implicit +WIENER_FILT_STEP
1591
43.5k
  wiener_info->vfilter[WIENER_HALFWIN] =
1592
43.5k
      -2 * (wiener_info->vfilter[0] + wiener_info->vfilter[1] +
1593
43.5k
            wiener_info->vfilter[2]);
1594
1595
43.5k
  if (wiener_win == WIENER_WIN)
1596
19.4k
    wiener_info->hfilter[0] = wiener_info->hfilter[WIENER_WIN - 1] =
1597
19.4k
        aom_read_primitive_refsubexpfin(
1598
19.4k
            rb, WIENER_FILT_TAP0_MAXV - WIENER_FILT_TAP0_MINV + 1,
1599
19.4k
            WIENER_FILT_TAP0_SUBEXP_K,
1600
19.4k
            ref_wiener_info->hfilter[0] - WIENER_FILT_TAP0_MINV, ACCT_STR) +
1601
19.4k
        WIENER_FILT_TAP0_MINV;
1602
24.1k
  else
1603
24.1k
    wiener_info->hfilter[0] = wiener_info->hfilter[WIENER_WIN - 1] = 0;
1604
43.5k
  wiener_info->hfilter[1] = wiener_info->hfilter[WIENER_WIN - 2] =
1605
43.5k
      aom_read_primitive_refsubexpfin(
1606
43.5k
          rb, WIENER_FILT_TAP1_MAXV - WIENER_FILT_TAP1_MINV + 1,
1607
43.5k
          WIENER_FILT_TAP1_SUBEXP_K,
1608
43.5k
          ref_wiener_info->hfilter[1] - WIENER_FILT_TAP1_MINV, ACCT_STR) +
1609
43.5k
      WIENER_FILT_TAP1_MINV;
1610
43.5k
  wiener_info->hfilter[2] = wiener_info->hfilter[WIENER_WIN - 3] =
1611
43.5k
      aom_read_primitive_refsubexpfin(
1612
43.5k
          rb, WIENER_FILT_TAP2_MAXV - WIENER_FILT_TAP2_MINV + 1,
1613
43.5k
          WIENER_FILT_TAP2_SUBEXP_K,
1614
43.5k
          ref_wiener_info->hfilter[2] - WIENER_FILT_TAP2_MINV, ACCT_STR) +
1615
43.5k
      WIENER_FILT_TAP2_MINV;
1616
  // The central element has an implicit +WIENER_FILT_STEP
1617
43.5k
  wiener_info->hfilter[WIENER_HALFWIN] =
1618
43.5k
      -2 * (wiener_info->hfilter[0] + wiener_info->hfilter[1] +
1619
43.5k
            wiener_info->hfilter[2]);
1620
43.5k
  *ref_wiener_info = *wiener_info;
1621
43.5k
}
1622
1623
static inline void read_sgrproj_filter(SgrprojInfo *sgrproj_info,
1624
                                       SgrprojInfo *ref_sgrproj_info,
1625
106k
                                       aom_reader *rb) {
1626
106k
  sgrproj_info->ep = aom_read_literal(rb, SGRPROJ_PARAMS_BITS, ACCT_STR);
1627
106k
  const sgr_params_type *params = &av1_sgr_params[sgrproj_info->ep];
1628
1629
106k
  if (params->r[0] == 0) {
1630
20.5k
    sgrproj_info->xqd[0] = 0;
1631
20.5k
    sgrproj_info->xqd[1] =
1632
20.5k
        aom_read_primitive_refsubexpfin(
1633
20.5k
            rb, SGRPROJ_PRJ_MAX1 - SGRPROJ_PRJ_MIN1 + 1, SGRPROJ_PRJ_SUBEXP_K,
1634
20.5k
            ref_sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1, ACCT_STR) +
1635
20.5k
        SGRPROJ_PRJ_MIN1;
1636
86.0k
  } else if (params->r[1] == 0) {
1637
20.9k
    sgrproj_info->xqd[0] =
1638
20.9k
        aom_read_primitive_refsubexpfin(
1639
20.9k
            rb, SGRPROJ_PRJ_MAX0 - SGRPROJ_PRJ_MIN0 + 1, SGRPROJ_PRJ_SUBEXP_K,
1640
20.9k
            ref_sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0, ACCT_STR) +
1641
20.9k
        SGRPROJ_PRJ_MIN0;
1642
20.9k
    sgrproj_info->xqd[1] = clamp((1 << SGRPROJ_PRJ_BITS) - sgrproj_info->xqd[0],
1643
20.9k
                                 SGRPROJ_PRJ_MIN1, SGRPROJ_PRJ_MAX1);
1644
65.0k
  } else {
1645
65.0k
    sgrproj_info->xqd[0] =
1646
65.0k
        aom_read_primitive_refsubexpfin(
1647
65.0k
            rb, SGRPROJ_PRJ_MAX0 - SGRPROJ_PRJ_MIN0 + 1, SGRPROJ_PRJ_SUBEXP_K,
1648
65.0k
            ref_sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0, ACCT_STR) +
1649
65.0k
        SGRPROJ_PRJ_MIN0;
1650
65.0k
    sgrproj_info->xqd[1] =
1651
65.0k
        aom_read_primitive_refsubexpfin(
1652
65.0k
            rb, SGRPROJ_PRJ_MAX1 - SGRPROJ_PRJ_MIN1 + 1, SGRPROJ_PRJ_SUBEXP_K,
1653
65.0k
            ref_sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1, ACCT_STR) +
1654
65.0k
        SGRPROJ_PRJ_MIN1;
1655
65.0k
  }
1656
1657
106k
  *ref_sgrproj_info = *sgrproj_info;
1658
106k
}
1659
1660
static inline void loop_restoration_read_sb_coeffs(const AV1_COMMON *const cm,
1661
                                                   MACROBLOCKD *xd,
1662
                                                   aom_reader *const r,
1663
255k
                                                   int plane, int runit_idx) {
1664
255k
  const RestorationInfo *rsi = &cm->rst_info[plane];
1665
255k
  RestorationUnitInfo *rui = &rsi->unit_info[runit_idx];
1666
255k
  assert(rsi->frame_restoration_type != RESTORE_NONE);
1667
1668
255k
  assert(!cm->features.all_lossless);
1669
1670
255k
  const int wiener_win = (plane > 0) ? WIENER_WIN_CHROMA : WIENER_WIN;
1671
255k
  WienerInfo *wiener_info = xd->wiener_info + plane;
1672
255k
  SgrprojInfo *sgrproj_info = xd->sgrproj_info + plane;
1673
1674
255k
  if (rsi->frame_restoration_type == RESTORE_SWITCHABLE) {
1675
75.9k
    rui->restoration_type =
1676
75.9k
        aom_read_symbol(r, xd->tile_ctx->switchable_restore_cdf,
1677
75.9k
                        RESTORE_SWITCHABLE_TYPES, ACCT_STR);
1678
75.9k
    switch (rui->restoration_type) {
1679
23.3k
      case RESTORE_WIENER:
1680
23.3k
        read_wiener_filter(wiener_win, &rui->wiener_info, wiener_info, r);
1681
23.3k
        break;
1682
25.1k
      case RESTORE_SGRPROJ:
1683
25.1k
        read_sgrproj_filter(&rui->sgrproj_info, sgrproj_info, r);
1684
25.1k
        break;
1685
27.4k
      default: assert(rui->restoration_type == RESTORE_NONE); break;
1686
75.9k
    }
1687
179k
  } else if (rsi->frame_restoration_type == RESTORE_WIENER) {
1688
44.6k
    if (aom_read_symbol(r, xd->tile_ctx->wiener_restore_cdf, 2, ACCT_STR)) {
1689
20.1k
      rui->restoration_type = RESTORE_WIENER;
1690
20.1k
      read_wiener_filter(wiener_win, &rui->wiener_info, wiener_info, r);
1691
24.5k
    } else {
1692
24.5k
      rui->restoration_type = RESTORE_NONE;
1693
24.5k
    }
1694
135k
  } else if (rsi->frame_restoration_type == RESTORE_SGRPROJ) {
1695
135k
    if (aom_read_symbol(r, xd->tile_ctx->sgrproj_restore_cdf, 2, ACCT_STR)) {
1696
81.6k
      rui->restoration_type = RESTORE_SGRPROJ;
1697
81.6k
      read_sgrproj_filter(&rui->sgrproj_info, sgrproj_info, r);
1698
81.6k
    } else {
1699
53.4k
      rui->restoration_type = RESTORE_NONE;
1700
53.4k
    }
1701
135k
  }
1702
255k
}
1703
1704
static inline void setup_loopfilter(AV1_COMMON *cm,
1705
186k
                                    struct aom_read_bit_buffer *rb) {
1706
186k
  const int num_planes = av1_num_planes(cm);
1707
186k
  struct loopfilter *lf = &cm->lf;
1708
1709
186k
  if (cm->features.allow_intrabc || cm->features.coded_lossless) {
1710
    // write default deltas to frame buffer
1711
79.2k
    av1_set_default_ref_deltas(cm->cur_frame->ref_deltas);
1712
79.2k
    av1_set_default_mode_deltas(cm->cur_frame->mode_deltas);
1713
79.2k
    return;
1714
79.2k
  }
1715
107k
  assert(!cm->features.coded_lossless);
1716
107k
  if (cm->prev_frame) {
1717
    // write deltas to frame buffer
1718
36.1k
    memcpy(lf->ref_deltas, cm->prev_frame->ref_deltas, REF_FRAMES);
1719
36.1k
    memcpy(lf->mode_deltas, cm->prev_frame->mode_deltas, MAX_MODE_LF_DELTAS);
1720
71.0k
  } else {
1721
71.0k
    av1_set_default_ref_deltas(lf->ref_deltas);
1722
71.0k
    av1_set_default_mode_deltas(lf->mode_deltas);
1723
71.0k
  }
1724
107k
  lf->filter_level[0] = aom_rb_read_literal(rb, 6);
1725
107k
  lf->filter_level[1] = aom_rb_read_literal(rb, 6);
1726
107k
  if (num_planes > 1) {
1727
89.6k
    if (lf->filter_level[0] || lf->filter_level[1]) {
1728
54.6k
      lf->filter_level_u = aom_rb_read_literal(rb, 6);
1729
54.6k
      lf->filter_level_v = aom_rb_read_literal(rb, 6);
1730
54.6k
    }
1731
89.6k
  }
1732
107k
  lf->sharpness_level = aom_rb_read_literal(rb, 3);
1733
1734
  // Read in loop filter deltas applied at the MB level based on mode or ref
1735
  // frame.
1736
107k
  lf->mode_ref_delta_update = 0;
1737
1738
107k
  lf->mode_ref_delta_enabled = aom_rb_read_bit(rb);
1739
107k
  if (lf->mode_ref_delta_enabled) {
1740
31.9k
    lf->mode_ref_delta_update = aom_rb_read_bit(rb);
1741
31.9k
    if (lf->mode_ref_delta_update) {
1742
137k
      for (int i = 0; i < REF_FRAMES; i++)
1743
122k
        if (aom_rb_read_bit(rb))
1744
48.9k
          lf->ref_deltas[i] = aom_rb_read_inv_signed_literal(rb, 6);
1745
1746
44.5k
      for (int i = 0; i < MAX_MODE_LF_DELTAS; i++)
1747
29.1k
        if (aom_rb_read_bit(rb))
1748
4.96k
          lf->mode_deltas[i] = aom_rb_read_inv_signed_literal(rb, 6);
1749
15.3k
    }
1750
31.9k
  }
1751
1752
  // write deltas to frame buffer
1753
107k
  memcpy(cm->cur_frame->ref_deltas, lf->ref_deltas, REF_FRAMES);
1754
107k
  memcpy(cm->cur_frame->mode_deltas, lf->mode_deltas, MAX_MODE_LF_DELTAS);
1755
107k
}
1756
1757
71.3k
static inline void setup_cdef(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
1758
71.3k
  const int num_planes = av1_num_planes(cm);
1759
71.3k
  CdefInfo *const cdef_info = &cm->cdef_info;
1760
1761
71.3k
  if (cm->features.allow_intrabc) return;
1762
62.7k
  cdef_info->cdef_damping = aom_rb_read_literal(rb, 2) + 3;
1763
62.7k
  cdef_info->cdef_bits = aom_rb_read_literal(rb, 2);
1764
62.7k
  cdef_info->nb_cdef_strengths = 1 << cdef_info->cdef_bits;
1765
169k
  for (int i = 0; i < cdef_info->nb_cdef_strengths; i++) {
1766
106k
    cdef_info->cdef_strengths[i] = aom_rb_read_literal(rb, CDEF_STRENGTH_BITS);
1767
106k
    cdef_info->cdef_uv_strengths[i] =
1768
106k
        num_planes > 1 ? aom_rb_read_literal(rb, CDEF_STRENGTH_BITS) : 0;
1769
106k
  }
1770
62.7k
}
1771
1772
500k
static inline int read_delta_q(struct aom_read_bit_buffer *rb) {
1773
500k
  return aom_rb_read_bit(rb) ? aom_rb_read_inv_signed_literal(rb, 6) : 0;
1774
500k
}
1775
1776
static inline void setup_quantization(CommonQuantParams *quant_params,
1777
                                      int num_planes, bool separate_uv_delta_q,
1778
188k
                                      struct aom_read_bit_buffer *rb) {
1779
188k
  quant_params->base_qindex = aom_rb_read_literal(rb, QINDEX_BITS);
1780
188k
  quant_params->y_dc_delta_q = read_delta_q(rb);
1781
188k
  if (num_planes > 1) {
1782
153k
    int diff_uv_delta = 0;
1783
153k
    if (separate_uv_delta_q) diff_uv_delta = aom_rb_read_bit(rb);
1784
153k
    quant_params->u_dc_delta_q = read_delta_q(rb);
1785
153k
    quant_params->u_ac_delta_q = read_delta_q(rb);
1786
153k
    if (diff_uv_delta) {
1787
2.51k
      quant_params->v_dc_delta_q = read_delta_q(rb);
1788
2.51k
      quant_params->v_ac_delta_q = read_delta_q(rb);
1789
150k
    } else {
1790
150k
      quant_params->v_dc_delta_q = quant_params->u_dc_delta_q;
1791
150k
      quant_params->v_ac_delta_q = quant_params->u_ac_delta_q;
1792
150k
    }
1793
153k
  } else {
1794
35.8k
    quant_params->u_dc_delta_q = 0;
1795
35.8k
    quant_params->u_ac_delta_q = 0;
1796
35.8k
    quant_params->v_dc_delta_q = 0;
1797
35.8k
    quant_params->v_ac_delta_q = 0;
1798
35.8k
  }
1799
188k
  quant_params->using_qmatrix = aom_rb_read_bit(rb);
1800
188k
  if (quant_params->using_qmatrix) {
1801
40.1k
    quant_params->qmatrix_level_y = aom_rb_read_literal(rb, QM_LEVEL_BITS);
1802
40.1k
    quant_params->qmatrix_level_u = aom_rb_read_literal(rb, QM_LEVEL_BITS);
1803
40.1k
    if (!separate_uv_delta_q)
1804
38.5k
      quant_params->qmatrix_level_v = quant_params->qmatrix_level_u;
1805
1.59k
    else
1806
1.59k
      quant_params->qmatrix_level_v = aom_rb_read_literal(rb, QM_LEVEL_BITS);
1807
148k
  } else {
1808
148k
    quant_params->qmatrix_level_y = 0;
1809
148k
    quant_params->qmatrix_level_u = 0;
1810
148k
    quant_params->qmatrix_level_v = 0;
1811
148k
  }
1812
188k
}
1813
1814
// Get global dequant matrix.
1815
static const qm_val_t *get_iqmatrix(const CommonQuantParams *quant_params,
1816
19.8M
                                    int qmlevel, int plane, TX_SIZE tx_size) {
1817
19.8M
  assert(quant_params->giqmatrix[qmlevel][plane][tx_size] != NULL ||
1818
19.8M
         qmlevel == NUM_QM_LEVELS - 1);
1819
19.8M
  return quant_params->giqmatrix[qmlevel][plane][tx_size];
1820
19.8M
}
1821
1822
// Build y/uv dequant values based on segmentation.
1823
static inline void setup_segmentation_dequant(AV1_COMMON *const cm,
1824
186k
                                              MACROBLOCKD *const xd) {
1825
186k
  const int bit_depth = cm->seq_params->bit_depth;
1826
  // When segmentation is disabled, only the first value is used.  The
1827
  // remaining are don't cares.
1828
186k
  const int max_segments = cm->seg.enabled ? MAX_SEGMENTS : 1;
1829
186k
  CommonQuantParams *const quant_params = &cm->quant_params;
1830
533k
  for (int i = 0; i < max_segments; ++i) {
1831
347k
    const int qindex = xd->qindex[i];
1832
347k
    quant_params->y_dequant_QTX[i][0] =
1833
347k
        av1_dc_quant_QTX(qindex, quant_params->y_dc_delta_q, bit_depth);
1834
347k
    quant_params->y_dequant_QTX[i][1] = av1_ac_quant_QTX(qindex, 0, bit_depth);
1835
347k
    quant_params->u_dequant_QTX[i][0] =
1836
347k
        av1_dc_quant_QTX(qindex, quant_params->u_dc_delta_q, bit_depth);
1837
347k
    quant_params->u_dequant_QTX[i][1] =
1838
347k
        av1_ac_quant_QTX(qindex, quant_params->u_ac_delta_q, bit_depth);
1839
347k
    quant_params->v_dequant_QTX[i][0] =
1840
347k
        av1_dc_quant_QTX(qindex, quant_params->v_dc_delta_q, bit_depth);
1841
347k
    quant_params->v_dequant_QTX[i][1] =
1842
347k
        av1_ac_quant_QTX(qindex, quant_params->v_ac_delta_q, bit_depth);
1843
347k
    const int use_qmatrix = av1_use_qmatrix(quant_params, xd, i);
1844
    // NB: depends on base index so there is only 1 set per frame
1845
    // No quant weighting when lossless or signalled not using QM
1846
347k
    const int qmlevel_y =
1847
347k
        use_qmatrix ? quant_params->qmatrix_level_y : NUM_QM_LEVELS - 1;
1848
6.95M
    for (int j = 0; j < TX_SIZES_ALL; ++j) {
1849
6.60M
      quant_params->y_iqmatrix[i][j] =
1850
6.60M
          get_iqmatrix(quant_params, qmlevel_y, AOM_PLANE_Y, j);
1851
6.60M
    }
1852
347k
    const int qmlevel_u =
1853
347k
        use_qmatrix ? quant_params->qmatrix_level_u : NUM_QM_LEVELS - 1;
1854
6.95M
    for (int j = 0; j < TX_SIZES_ALL; ++j) {
1855
6.60M
      quant_params->u_iqmatrix[i][j] =
1856
6.60M
          get_iqmatrix(quant_params, qmlevel_u, AOM_PLANE_U, j);
1857
6.60M
    }
1858
347k
    const int qmlevel_v =
1859
347k
        use_qmatrix ? quant_params->qmatrix_level_v : NUM_QM_LEVELS - 1;
1860
6.95M
    for (int j = 0; j < TX_SIZES_ALL; ++j) {
1861
6.60M
      quant_params->v_iqmatrix[i][j] =
1862
6.60M
          get_iqmatrix(quant_params, qmlevel_v, AOM_PLANE_V, j);
1863
6.60M
    }
1864
347k
  }
1865
186k
}
1866
1867
53.0k
static InterpFilter read_frame_interp_filter(struct aom_read_bit_buffer *rb) {
1868
53.0k
  return aom_rb_read_bit(rb) ? SWITCHABLE
1869
53.0k
                             : aom_rb_read_literal(rb, LOG_SWITCHABLE_FILTERS);
1870
53.0k
}
1871
1872
static void read_frame_size(struct aom_read_bit_buffer *rb, int num_bits_width,
1873
111k
                            int num_bits_height, int *width, int *height) {
1874
111k
  *width = aom_rb_read_literal(rb, num_bits_width) + 1;
1875
111k
  *height = aom_rb_read_literal(rb, num_bits_height) + 1;
1876
111k
}
1877
1878
static inline void setup_render_size(AV1_COMMON *cm,
1879
171k
                                     struct aom_read_bit_buffer *rb) {
1880
171k
  cm->render_width = cm->superres_upscaled_width;
1881
171k
  cm->render_height = cm->superres_upscaled_height;
1882
171k
  if (aom_rb_read_bit(rb))
1883
36.2k
    read_frame_size(rb, 16, 16, &cm->render_width, &cm->render_height);
1884
171k
}
1885
1886
// TODO(afergs): make "struct aom_read_bit_buffer *const rb"?
1887
static inline void setup_superres(AV1_COMMON *const cm,
1888
                                  struct aom_read_bit_buffer *rb, int *width,
1889
203k
                                  int *height) {
1890
203k
  cm->superres_upscaled_width = *width;
1891
203k
  cm->superres_upscaled_height = *height;
1892
1893
203k
  const SequenceHeader *const seq_params = cm->seq_params;
1894
203k
  if (!seq_params->enable_superres) return;
1895
1896
81.7k
  if (aom_rb_read_bit(rb)) {
1897
37.8k
    cm->superres_scale_denominator =
1898
37.8k
        (uint8_t)aom_rb_read_literal(rb, SUPERRES_SCALE_BITS);
1899
37.8k
    cm->superres_scale_denominator += SUPERRES_SCALE_DENOMINATOR_MIN;
1900
    // Don't edit cm->width or cm->height directly, or the buffers won't get
1901
    // resized correctly
1902
37.8k
    av1_calculate_scaled_superres_size(width, height,
1903
37.8k
                                       cm->superres_scale_denominator);
1904
43.9k
  } else {
1905
    // 1:1 scaling - ie. no scaling, scale not provided
1906
43.9k
    cm->superres_scale_denominator = SCALE_NUMERATOR;
1907
43.9k
  }
1908
81.7k
}
1909
1910
static inline void resize_context_buffers(AV1_COMMON *cm, int width,
1911
203k
                                          int height) {
1912
203k
#if CONFIG_SIZE_LIMIT
1913
203k
  if (width > DECODE_WIDTH_LIMIT || height > DECODE_HEIGHT_LIMIT)
1914
131
    aom_internal_error(cm->error, AOM_CODEC_CORRUPT_FRAME,
1915
131
                       "Dimensions of %dx%d beyond allowed size of %dx%d.",
1916
131
                       width, height, DECODE_WIDTH_LIMIT, DECODE_HEIGHT_LIMIT);
1917
203k
#endif
1918
203k
  if (cm->width != width || cm->height != height) {
1919
95.7k
    const int new_mi_rows = CEIL_POWER_OF_TWO(height, MI_SIZE_LOG2);
1920
95.7k
    const int new_mi_cols = CEIL_POWER_OF_TWO(width, MI_SIZE_LOG2);
1921
1922
    // Allocations in av1_alloc_context_buffers() depend on individual
1923
    // dimensions as well as the overall size.
1924
95.7k
    if (new_mi_cols > cm->mi_params.mi_cols ||
1925
95.7k
        new_mi_rows > cm->mi_params.mi_rows) {
1926
56.1k
      if (av1_alloc_context_buffers(cm, width, height, BLOCK_4X4)) {
1927
        // The cm->mi_* values have been cleared and any existing context
1928
        // buffers have been freed. Clear cm->width and cm->height to be
1929
        // consistent and to force a realloc next time.
1930
262
        cm->width = 0;
1931
262
        cm->height = 0;
1932
262
        aom_internal_error(cm->error, AOM_CODEC_MEM_ERROR,
1933
262
                           "Failed to allocate context buffers");
1934
262
      }
1935
56.1k
    } else {
1936
39.5k
      cm->mi_params.set_mb_mi(&cm->mi_params, width, height, BLOCK_4X4);
1937
39.5k
    }
1938
95.7k
    av1_init_mi_buffers(&cm->mi_params);
1939
95.7k
    cm->width = width;
1940
95.7k
    cm->height = height;
1941
95.7k
  }
1942
1943
203k
  ensure_mv_buffer(cm->cur_frame, cm);
1944
203k
  cm->cur_frame->width = cm->width;
1945
203k
  cm->cur_frame->height = cm->height;
1946
203k
}
1947
1948
197k
static inline void setup_buffer_pool(AV1_COMMON *cm) {
1949
197k
  BufferPool *const pool = cm->buffer_pool;
1950
197k
  const SequenceHeader *const seq_params = cm->seq_params;
1951
1952
197k
  lock_buffer_pool(pool);
1953
197k
  if (aom_realloc_frame_buffer(
1954
197k
          &cm->cur_frame->buf, cm->width, cm->height, seq_params->subsampling_x,
1955
197k
          seq_params->subsampling_y, seq_params->use_highbitdepth,
1956
197k
          AOM_DEC_BORDER_IN_PIXELS, cm->features.byte_alignment,
1957
197k
          &cm->cur_frame->raw_frame_buffer, pool->get_fb_cb, pool->cb_priv,
1958
197k
          false, 0)) {
1959
101
    unlock_buffer_pool(pool);
1960
101
    aom_internal_error(cm->error, AOM_CODEC_MEM_ERROR,
1961
101
                       "Failed to allocate frame buffer");
1962
101
  }
1963
197k
  unlock_buffer_pool(pool);
1964
1965
197k
  cm->cur_frame->buf.bit_depth = (unsigned int)seq_params->bit_depth;
1966
197k
  cm->cur_frame->buf.color_primaries = seq_params->color_primaries;
1967
197k
  cm->cur_frame->buf.transfer_characteristics =
1968
197k
      seq_params->transfer_characteristics;
1969
197k
  cm->cur_frame->buf.matrix_coefficients = seq_params->matrix_coefficients;
1970
197k
  cm->cur_frame->buf.monochrome = seq_params->monochrome;
1971
197k
  cm->cur_frame->buf.chroma_sample_position =
1972
197k
      seq_params->chroma_sample_position;
1973
197k
  cm->cur_frame->buf.color_range = seq_params->color_range;
1974
197k
  cm->cur_frame->buf.render_width = cm->render_width;
1975
197k
  cm->cur_frame->buf.render_height = cm->render_height;
1976
197k
}
1977
1978
static inline void setup_frame_size(AV1_COMMON *cm,
1979
                                    int frame_size_override_flag,
1980
168k
                                    struct aom_read_bit_buffer *rb) {
1981
168k
  const SequenceHeader *const seq_params = cm->seq_params;
1982
168k
  int width, height;
1983
1984
168k
  if (frame_size_override_flag) {
1985
68.8k
    int num_bits_width = seq_params->num_bits_width;
1986
68.8k
    int num_bits_height = seq_params->num_bits_height;
1987
68.8k
    read_frame_size(rb, num_bits_width, num_bits_height, &width, &height);
1988
68.8k
    if (width > seq_params->max_frame_width ||
1989
68.8k
        height > seq_params->max_frame_height) {
1990
2.94k
      aom_internal_error(cm->error, AOM_CODEC_CORRUPT_FRAME,
1991
2.94k
                         "Frame dimensions are larger than the maximum values");
1992
2.94k
    }
1993
99.1k
  } else {
1994
99.1k
    width = seq_params->max_frame_width;
1995
99.1k
    height = seq_params->max_frame_height;
1996
99.1k
  }
1997
1998
168k
  setup_superres(cm, rb, &width, &height);
1999
168k
  resize_context_buffers(cm, width, height);
2000
168k
  setup_render_size(cm, rb);
2001
168k
  setup_buffer_pool(cm);
2002
168k
}
2003
2004
static inline void setup_sb_size(SequenceHeader *seq_params,
2005
80.6k
                                 struct aom_read_bit_buffer *rb) {
2006
80.6k
  set_sb_size(seq_params, aom_rb_read_bit(rb) ? BLOCK_128X128 : BLOCK_64X64);
2007
80.6k
}
2008
2009
static inline int valid_ref_frame_img_fmt(aom_bit_depth_t ref_bit_depth,
2010
                                          int ref_xss, int ref_yss,
2011
                                          aom_bit_depth_t this_bit_depth,
2012
240k
                                          int this_xss, int this_yss) {
2013
240k
  return ref_bit_depth == this_bit_depth && ref_xss == this_xss &&
2014
240k
         ref_yss == this_yss;
2015
240k
}
2016
2017
static inline void setup_frame_size_with_refs(AV1_COMMON *cm,
2018
38.8k
                                              struct aom_read_bit_buffer *rb) {
2019
38.8k
  int width, height;
2020
38.8k
  int found = 0;
2021
38.8k
  int has_valid_ref_frame = 0;
2022
144k
  for (int i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
2023
138k
    if (aom_rb_read_bit(rb)) {
2024
32.4k
      const RefCntBuffer *const ref_buf = get_ref_frame_buf(cm, i);
2025
      // This will never be NULL in a normal stream, as streams are required to
2026
      // have a shown keyframe before any inter frames, which would refresh all
2027
      // the reference buffers. However, it might be null if we're starting in
2028
      // the middle of a stream, and static analysis will error if we don't do
2029
      // a null check here.
2030
32.4k
      if (ref_buf == NULL) {
2031
0
        aom_internal_error(cm->error, AOM_CODEC_CORRUPT_FRAME,
2032
0
                           "Invalid condition: invalid reference buffer");
2033
32.4k
      } else {
2034
32.4k
        const YV12_BUFFER_CONFIG *const buf = &ref_buf->buf;
2035
32.4k
        width = buf->y_crop_width;
2036
32.4k
        height = buf->y_crop_height;
2037
32.4k
        cm->render_width = buf->render_width;
2038
32.4k
        cm->render_height = buf->render_height;
2039
32.4k
        setup_superres(cm, rb, &width, &height);
2040
32.4k
        resize_context_buffers(cm, width, height);
2041
32.4k
        found = 1;
2042
32.4k
        break;
2043
32.4k
      }
2044
32.4k
    }
2045
138k
  }
2046
2047
38.8k
  const SequenceHeader *const seq_params = cm->seq_params;
2048
38.8k
  if (!found) {
2049
6.36k
    int num_bits_width = seq_params->num_bits_width;
2050
6.36k
    int num_bits_height = seq_params->num_bits_height;
2051
2052
6.36k
    read_frame_size(rb, num_bits_width, num_bits_height, &width, &height);
2053
6.36k
    setup_superres(cm, rb, &width, &height);
2054
6.36k
    resize_context_buffers(cm, width, height);
2055
6.36k
    setup_render_size(cm, rb);
2056
6.36k
  }
2057
2058
38.8k
  if (width <= 0 || height <= 0)
2059
0
    aom_internal_error(cm->error, AOM_CODEC_CORRUPT_FRAME,
2060
0
                       "Invalid frame size");
2061
2062
  // Check to make sure at least one of frames that this frame references
2063
  // has valid dimensions.
2064
310k
  for (int i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
2065
271k
    const RefCntBuffer *const ref_frame = get_ref_frame_buf(cm, i);
2066
271k
    has_valid_ref_frame |=
2067
271k
        valid_ref_frame_size(ref_frame->buf.y_crop_width,
2068
271k
                             ref_frame->buf.y_crop_height, width, height);
2069
271k
  }
2070
38.8k
  if (!has_valid_ref_frame)
2071
2.54k
    aom_internal_error(cm->error, AOM_CODEC_CORRUPT_FRAME,
2072
2.54k
                       "Referenced frame has invalid size");
2073
279k
  for (int i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
2074
240k
    const RefCntBuffer *const ref_frame = get_ref_frame_buf(cm, i);
2075
240k
    if (!valid_ref_frame_img_fmt(
2076
240k
            ref_frame->buf.bit_depth, ref_frame->buf.subsampling_x,
2077
240k
            ref_frame->buf.subsampling_y, seq_params->bit_depth,
2078
240k
            seq_params->subsampling_x, seq_params->subsampling_y))
2079
3.58k
      aom_internal_error(cm->error, AOM_CODEC_CORRUPT_FRAME,
2080
3.58k
                         "Referenced frame has incompatible color format");
2081
240k
  }
2082
38.8k
  setup_buffer_pool(cm);
2083
38.8k
}
2084
2085
// Same function as av1_read_uniform but reading from uncompresses header wb
2086
254k
static int rb_read_uniform(struct aom_read_bit_buffer *const rb, int n) {
2087
254k
  const int l = get_unsigned_bits(n);
2088
254k
  const int m = (1 << l) - n;
2089
254k
  const int v = aom_rb_read_literal(rb, l - 1);
2090
254k
  assert(l != 0);
2091
254k
  if (v < m)
2092
230k
    return v;
2093
23.2k
  else
2094
23.2k
    return (v << 1) - m + aom_rb_read_bit(rb);
2095
254k
}
2096
2097
static inline void read_tile_info_max_tile(
2098
190k
    AV1_COMMON *const cm, struct aom_read_bit_buffer *const rb) {
2099
190k
  const SequenceHeader *const seq_params = cm->seq_params;
2100
190k
  CommonTileParams *const tiles = &cm->tiles;
2101
190k
  int width_sb =
2102
190k
      CEIL_POWER_OF_TWO(cm->mi_params.mi_cols, seq_params->mib_size_log2);
2103
190k
  int height_sb =
2104
190k
      CEIL_POWER_OF_TWO(cm->mi_params.mi_rows, seq_params->mib_size_log2);
2105
2106
190k
  av1_get_tile_limits(cm);
2107
190k
  tiles->uniform_spacing = aom_rb_read_bit(rb);
2108
2109
  // Read tile columns
2110
190k
  if (tiles->uniform_spacing) {
2111
100k
    tiles->log2_cols = tiles->min_log2_cols;
2112
110k
    while (tiles->log2_cols < tiles->max_log2_cols) {
2113
74.3k
      if (!aom_rb_read_bit(rb)) {
2114
63.9k
        break;
2115
63.9k
      }
2116
10.4k
      tiles->log2_cols++;
2117
10.4k
    }
2118
100k
  } else {
2119
90.3k
    int i;
2120
90.3k
    int start_sb;
2121
214k
    for (i = 0, start_sb = 0; width_sb > 0 && i < MAX_TILE_COLS; i++) {
2122
123k
      const int size_sb =
2123
123k
          1 + rb_read_uniform(rb, AOMMIN(width_sb, tiles->max_width_sb));
2124
123k
      tiles->col_start_sb[i] = start_sb;
2125
123k
      start_sb += size_sb;
2126
123k
      width_sb -= size_sb;
2127
123k
    }
2128
90.3k
    tiles->cols = i;
2129
90.3k
    tiles->col_start_sb[i] = start_sb + width_sb;
2130
90.3k
  }
2131
190k
  av1_calculate_tile_cols(seq_params, cm->mi_params.mi_rows,
2132
190k
                          cm->mi_params.mi_cols, tiles);
2133
2134
  // Read tile rows
2135
190k
  if (tiles->uniform_spacing) {
2136
100k
    tiles->log2_rows = tiles->min_log2_rows;
2137
112k
    while (tiles->log2_rows < tiles->max_log2_rows) {
2138
74.2k
      if (!aom_rb_read_bit(rb)) {
2139
61.9k
        break;
2140
61.9k
      }
2141
12.2k
      tiles->log2_rows++;
2142
12.2k
    }
2143
100k
  } else {
2144
90.3k
    int i;
2145
90.3k
    int start_sb;
2146
220k
    for (i = 0, start_sb = 0; height_sb > 0 && i < MAX_TILE_ROWS; i++) {
2147
130k
      const int size_sb =
2148
130k
          1 + rb_read_uniform(rb, AOMMIN(height_sb, tiles->max_height_sb));
2149
130k
      tiles->row_start_sb[i] = start_sb;
2150
130k
      start_sb += size_sb;
2151
130k
      height_sb -= size_sb;
2152
130k
    }
2153
90.3k
    tiles->rows = i;
2154
90.3k
    tiles->row_start_sb[i] = start_sb + height_sb;
2155
90.3k
  }
2156
190k
  av1_calculate_tile_rows(seq_params, cm->mi_params.mi_rows, tiles);
2157
190k
}
2158
2159
22.1k
void av1_set_single_tile_decoding_mode(AV1_COMMON *const cm) {
2160
22.1k
  cm->tiles.single_tile_decoding = 0;
2161
22.1k
  if (cm->tiles.large_scale) {
2162
22.1k
    struct loopfilter *lf = &cm->lf;
2163
22.1k
    RestorationInfo *const rst_info = cm->rst_info;
2164
22.1k
    const CdefInfo *const cdef_info = &cm->cdef_info;
2165
2166
    // Figure out single_tile_decoding by loopfilter_level.
2167
22.1k
    const int no_loopfilter = !(lf->filter_level[0] || lf->filter_level[1]);
2168
22.1k
    const int no_cdef = cdef_info->cdef_bits == 0 &&
2169
22.1k
                        cdef_info->cdef_strengths[0] == 0 &&
2170
22.1k
                        cdef_info->cdef_uv_strengths[0] == 0;
2171
22.1k
    const int no_restoration =
2172
22.1k
        rst_info[0].frame_restoration_type == RESTORE_NONE &&
2173
22.1k
        rst_info[1].frame_restoration_type == RESTORE_NONE &&
2174
22.1k
        rst_info[2].frame_restoration_type == RESTORE_NONE;
2175
22.1k
    assert(IMPLIES(cm->features.coded_lossless, no_loopfilter && no_cdef));
2176
22.1k
    assert(IMPLIES(cm->features.all_lossless, no_restoration));
2177
22.1k
    cm->tiles.single_tile_decoding = no_loopfilter && no_cdef && no_restoration;
2178
22.1k
  }
2179
22.1k
}
2180
2181
static inline void read_tile_info(AV1Decoder *const pbi,
2182
190k
                                  struct aom_read_bit_buffer *const rb) {
2183
190k
  AV1_COMMON *const cm = &pbi->common;
2184
2185
190k
  read_tile_info_max_tile(cm, rb);
2186
2187
190k
  pbi->context_update_tile_id = 0;
2188
190k
  if (cm->tiles.rows * cm->tiles.cols > 1) {
2189
    // tile to use for cdf update
2190
25.0k
    pbi->context_update_tile_id =
2191
25.0k
        aom_rb_read_literal(rb, cm->tiles.log2_rows + cm->tiles.log2_cols);
2192
25.0k
    if (pbi->context_update_tile_id >= cm->tiles.rows * cm->tiles.cols) {
2193
1.11k
      aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
2194
1.11k
                         "Invalid context_update_tile_id");
2195
1.11k
    }
2196
    // tile size magnitude
2197
25.0k
    pbi->tile_size_bytes = aom_rb_read_literal(rb, 2) + 1;
2198
25.0k
  }
2199
190k
}
2200
2201
#if EXT_TILE_DEBUG
2202
static inline void read_ext_tile_info(AV1Decoder *const pbi,
2203
21.3k
                                      struct aom_read_bit_buffer *const rb) {
2204
21.3k
  AV1_COMMON *const cm = &pbi->common;
2205
2206
  // This information is stored as a separate byte.
2207
21.3k
  int mod = rb->bit_offset % CHAR_BIT;
2208
21.3k
  if (mod > 0) aom_rb_read_literal(rb, CHAR_BIT - mod);
2209
21.3k
  assert(rb->bit_offset % CHAR_BIT == 0);
2210
2211
21.3k
  if (cm->tiles.cols * cm->tiles.rows > 1) {
2212
    // Read the number of bytes used to store tile size
2213
7.28k
    pbi->tile_col_size_bytes = aom_rb_read_literal(rb, 2) + 1;
2214
7.28k
    pbi->tile_size_bytes = aom_rb_read_literal(rb, 2) + 1;
2215
7.28k
  }
2216
21.3k
}
2217
#endif  // EXT_TILE_DEBUG
2218
2219
37.3k
static size_t mem_get_varsize(const uint8_t *src, int sz) {
2220
37.3k
  switch (sz) {
2221
27.9k
    case 1: return src[0];
2222
7.03k
    case 2: return mem_get_le16(src);
2223
1.37k
    case 3: return mem_get_le24(src);
2224
1.04k
    case 4: return mem_get_le32(src);
2225
0
    default: assert(0 && "Invalid size"); return -1;
2226
37.3k
  }
2227
37.3k
}
2228
2229
#if EXT_TILE_DEBUG
2230
// Reads the next tile returning its size and adjusting '*data' accordingly
2231
// based on 'is_last'. On return, '*data' is updated to point to the end of the
2232
// raw tile buffer in the bit stream.
2233
static inline void get_ls_tile_buffer(
2234
    const uint8_t *const data_end, struct aom_internal_error_info *error_info,
2235
    const uint8_t **data, TileBufferDec (*const tile_buffers)[MAX_TILE_COLS],
2236
19.0k
    int tile_size_bytes, int col, int row, int tile_copy_mode) {
2237
19.0k
  size_t size;
2238
2239
19.0k
  size_t copy_size = 0;
2240
19.0k
  const uint8_t *copy_data = NULL;
2241
2242
19.0k
  if (!read_is_valid(*data, tile_size_bytes, data_end))
2243
526
    aom_internal_error(error_info, AOM_CODEC_CORRUPT_FRAME,
2244
526
                       "Truncated packet or corrupt tile length");
2245
19.0k
  size = mem_get_varsize(*data, tile_size_bytes);
2246
2247
  // If tile_copy_mode = 1, then the top bit of the tile header indicates copy
2248
  // mode.
2249
19.0k
  if (tile_copy_mode && (size >> (tile_size_bytes * 8 - 1)) == 1) {
2250
    // The remaining bits in the top byte signal the row offset
2251
12.9k
    int offset = (size >> (tile_size_bytes - 1) * 8) & 0x7f;
2252
12.9k
    if (offset > row) {
2253
452
      aom_internal_error(
2254
452
          error_info, AOM_CODEC_CORRUPT_FRAME,
2255
452
          "Invalid row offset in tile copy mode: row=%d offset=%d", row,
2256
452
          offset);
2257
452
    }
2258
2259
    // Currently, only use tiles in same column as reference tiles.
2260
12.9k
    copy_data = tile_buffers[row - offset][col].data;
2261
12.9k
    copy_size = tile_buffers[row - offset][col].size;
2262
12.9k
    size = 0;
2263
12.9k
  } else {
2264
6.12k
    size += AV1_MIN_TILE_SIZE_BYTES;
2265
6.12k
  }
2266
2267
19.0k
  *data += tile_size_bytes;
2268
2269
19.0k
  if (size > (size_t)(data_end - *data))
2270
392
    aom_internal_error(error_info, AOM_CODEC_CORRUPT_FRAME,
2271
392
                       "Truncated packet or corrupt tile size");
2272
2273
19.0k
  if (size > 0) {
2274
5.20k
    tile_buffers[row][col].data = *data;
2275
5.20k
    tile_buffers[row][col].size = size;
2276
13.8k
  } else {
2277
13.8k
    tile_buffers[row][col].data = copy_data;
2278
13.8k
    tile_buffers[row][col].size = copy_size;
2279
13.8k
  }
2280
2281
19.0k
  *data += size;
2282
19.0k
}
2283
2284
// Returns the end of the last tile buffer
2285
// (tile_buffers[cm->tiles.rows - 1][cm->tiles.cols - 1]).
2286
static const uint8_t *get_ls_tile_buffers(
2287
    AV1Decoder *pbi, const uint8_t *data, const uint8_t *data_end,
2288
20.8k
    TileBufferDec (*const tile_buffers)[MAX_TILE_COLS]) {
2289
20.8k
  AV1_COMMON *const cm = &pbi->common;
2290
20.8k
  const int tile_cols = cm->tiles.cols;
2291
20.8k
  const int tile_rows = cm->tiles.rows;
2292
20.8k
  const int have_tiles = tile_cols * tile_rows > 1;
2293
20.8k
  const uint8_t *raw_data_end;  // The end of the last tile buffer
2294
2295
20.8k
  if (!have_tiles) {
2296
14.0k
    const size_t tile_size = data_end - data;
2297
14.0k
    tile_buffers[0][0].data = data;
2298
14.0k
    tile_buffers[0][0].size = tile_size;
2299
14.0k
    raw_data_end = NULL;
2300
14.0k
  } else {
2301
    // We locate only the tile buffers that are required, which are the ones
2302
    // specified by pbi->dec_tile_col and pbi->dec_tile_row. Also, we always
2303
    // need the last (bottom right) tile buffer, as we need to know where the
2304
    // end of the compressed frame buffer is for proper superframe decoding.
2305
2306
6.79k
    const uint8_t *tile_col_data_end[MAX_TILE_COLS] = { NULL };
2307
6.79k
    const uint8_t *const data_start = data;
2308
2309
6.79k
    const int dec_tile_row = AOMMIN(pbi->dec_tile_row, tile_rows);
2310
6.79k
    const int single_row = pbi->dec_tile_row >= 0;
2311
6.79k
    const int tile_rows_start = single_row ? dec_tile_row : 0;
2312
6.79k
    const int tile_rows_end = single_row ? tile_rows_start + 1 : tile_rows;
2313
6.79k
    const int dec_tile_col = AOMMIN(pbi->dec_tile_col, tile_cols);
2314
6.79k
    const int single_col = pbi->dec_tile_col >= 0;
2315
6.79k
    const int tile_cols_start = single_col ? dec_tile_col : 0;
2316
6.79k
    const int tile_cols_end = single_col ? tile_cols_start + 1 : tile_cols;
2317
2318
6.79k
    const int tile_col_size_bytes = pbi->tile_col_size_bytes;
2319
6.79k
    const int tile_size_bytes = pbi->tile_size_bytes;
2320
6.79k
    int tile_width, tile_height;
2321
6.79k
    if (!av1_get_uniform_tile_size(cm, &tile_width, &tile_height)) {
2322
1.11k
      aom_internal_error(
2323
1.11k
          &pbi->error, AOM_CODEC_CORRUPT_FRAME,
2324
1.11k
          "Not all the tiles in the tile list have the same size.");
2325
1.11k
    }
2326
6.79k
    const int tile_copy_mode =
2327
6.79k
        ((AOMMAX(tile_width, tile_height) << MI_SIZE_LOG2) <= 256) ? 1 : 0;
2328
    // Read tile column sizes for all columns (we need the last tile buffer)
2329
13.4k
    for (int c = 0; c < tile_cols; ++c) {
2330
6.63k
      const int is_last = c == tile_cols - 1;
2331
6.63k
      size_t tile_col_size;
2332
2333
6.63k
      if (!is_last) {
2334
4.59k
        if (tile_col_size_bytes > data_end - data) {
2335
67
          aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
2336
67
                             "Not enough data to read tile_col_size");
2337
67
        }
2338
4.59k
        tile_col_size = mem_get_varsize(data, tile_col_size_bytes);
2339
4.59k
        data += tile_col_size_bytes;
2340
4.59k
        if (tile_col_size > (size_t)(data_end - data)) {
2341
3.57k
          aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
2342
3.57k
                             "tile_col_data_end[%d] is out of bound", c);
2343
3.57k
        }
2344
4.59k
        tile_col_data_end[c] = data + tile_col_size;
2345
4.59k
      } else {
2346
2.04k
        tile_col_size = data_end - data;
2347
2.04k
        tile_col_data_end[c] = data_end;
2348
2.04k
      }
2349
6.63k
      data += tile_col_size;
2350
6.63k
    }
2351
2352
6.79k
    data = data_start;
2353
2354
    // Read the required tile sizes.
2355
8.85k
    for (int c = tile_cols_start; c < tile_cols_end; ++c) {
2356
2.05k
      const int is_last = c == tile_cols - 1;
2357
2358
2.05k
      if (c > 0) data = tile_col_data_end[c - 1];
2359
2360
2.05k
      if (!is_last) data += tile_col_size_bytes;
2361
2362
      // Get the whole of the last column, otherwise stop at the required tile.
2363
21.1k
      for (int r = 0; r < (is_last ? tile_rows : tile_rows_end); ++r) {
2364
19.0k
        get_ls_tile_buffer(tile_col_data_end[c], &pbi->error, &data,
2365
19.0k
                           tile_buffers, tile_size_bytes, c, r, tile_copy_mode);
2366
19.0k
      }
2367
2.05k
    }
2368
2369
    // If we have not read the last column, then read it to get the last tile.
2370
6.79k
    if (tile_cols_end != tile_cols) {
2371
0
      const int c = tile_cols - 1;
2372
2373
0
      data = tile_col_data_end[c - 1];
2374
2375
0
      for (int r = 0; r < tile_rows; ++r) {
2376
0
        get_ls_tile_buffer(tile_col_data_end[c], &pbi->error, &data,
2377
0
                           tile_buffers, tile_size_bytes, c, r, tile_copy_mode);
2378
0
      }
2379
0
    }
2380
6.79k
    raw_data_end = data;
2381
6.79k
  }
2382
20.8k
  return raw_data_end;
2383
20.8k
}
2384
#endif  // EXT_TILE_DEBUG
2385
2386
static const uint8_t *get_ls_single_tile_buffer(
2387
    AV1Decoder *pbi, const uint8_t *data,
2388
0
    TileBufferDec (*const tile_buffers)[MAX_TILE_COLS]) {
2389
0
  assert(pbi->dec_tile_row >= 0 && pbi->dec_tile_col >= 0);
2390
0
  tile_buffers[pbi->dec_tile_row][pbi->dec_tile_col].data = data;
2391
0
  tile_buffers[pbi->dec_tile_row][pbi->dec_tile_col].size =
2392
0
      (size_t)pbi->coded_tile_data_size;
2393
0
  return data + pbi->coded_tile_data_size;
2394
0
}
2395
2396
// Reads the next tile returning its size and adjusting '*data' accordingly
2397
// based on 'is_last'.
2398
static inline void get_tile_buffer(const uint8_t *const data_end,
2399
                                   const int tile_size_bytes, int is_last,
2400
                                   struct aom_internal_error_info *error_info,
2401
                                   const uint8_t **data,
2402
143k
                                   TileBufferDec *const buf) {
2403
143k
  size_t size;
2404
2405
143k
  if (!is_last) {
2406
14.6k
    if (!read_is_valid(*data, tile_size_bytes, data_end))
2407
387
      aom_internal_error(error_info, AOM_CODEC_CORRUPT_FRAME,
2408
387
                         "Not enough data to read tile size");
2409
2410
14.6k
    size = mem_get_varsize(*data, tile_size_bytes) + AV1_MIN_TILE_SIZE_BYTES;
2411
14.6k
    *data += tile_size_bytes;
2412
2413
14.6k
    if (size > (size_t)(data_end - *data))
2414
2.65k
      aom_internal_error(error_info, AOM_CODEC_CORRUPT_FRAME,
2415
2.65k
                         "Truncated packet or corrupt tile size");
2416
128k
  } else {
2417
128k
    size = data_end - *data;
2418
128k
  }
2419
2420
143k
  buf->data = *data;
2421
143k
  buf->size = size;
2422
2423
143k
  *data += size;
2424
143k
}
2425
2426
static inline void get_tile_buffers(
2427
    AV1Decoder *pbi, const uint8_t *data, const uint8_t *data_end,
2428
    TileBufferDec (*const tile_buffers)[MAX_TILE_COLS], int start_tile,
2429
131k
    int end_tile) {
2430
131k
  AV1_COMMON *const cm = &pbi->common;
2431
131k
  const int tile_cols = cm->tiles.cols;
2432
131k
  const int tile_rows = cm->tiles.rows;
2433
131k
  int tc = 0;
2434
2435
266k
  for (int r = 0; r < tile_rows; ++r) {
2436
277k
    for (int c = 0; c < tile_cols; ++c, ++tc) {
2437
143k
      TileBufferDec *const buf = &tile_buffers[r][c];
2438
2439
143k
      const int is_last = (tc == end_tile);
2440
143k
      const size_t hdr_offset = 0;
2441
2442
143k
      if (tc < start_tile || tc > end_tile) continue;
2443
2444
143k
      if (data + hdr_offset >= data_end)
2445
225
        aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
2446
225
                           "Data ended before all tiles were read.");
2447
143k
      data += hdr_offset;
2448
143k
      get_tile_buffer(data_end, pbi->tile_size_bytes, is_last, &pbi->error,
2449
143k
                      &data, buf);
2450
143k
    }
2451
134k
  }
2452
131k
}
2453
2454
static inline void set_cb_buffer(AV1Decoder *pbi, DecoderCodingBlock *dcb,
2455
                                 CB_BUFFER *cb_buffer_base,
2456
1.61M
                                 const int num_planes, int mi_row, int mi_col) {
2457
1.61M
  AV1_COMMON *const cm = &pbi->common;
2458
1.61M
  int mib_size_log2 = cm->seq_params->mib_size_log2;
2459
1.61M
  int stride = (cm->mi_params.mi_cols >> mib_size_log2) + 1;
2460
1.61M
  int offset = (mi_row >> mib_size_log2) * stride + (mi_col >> mib_size_log2);
2461
1.61M
  CB_BUFFER *cb_buffer = cb_buffer_base + offset;
2462
2463
6.19M
  for (int plane = 0; plane < num_planes; ++plane) {
2464
4.57M
    dcb->dqcoeff_block[plane] = cb_buffer->dqcoeff[plane];
2465
4.57M
    dcb->eob_data[plane] = cb_buffer->eob_data[plane];
2466
4.57M
    dcb->cb_offset[plane] = 0;
2467
4.57M
    dcb->txb_offset[plane] = 0;
2468
4.57M
  }
2469
1.61M
  MACROBLOCKD *const xd = &dcb->xd;
2470
1.61M
  xd->plane[0].color_index_map = cb_buffer->color_index_map[0];
2471
1.61M
  xd->plane[1].color_index_map = cb_buffer->color_index_map[1];
2472
1.61M
  xd->color_index_map_offset[0] = 0;
2473
1.61M
  xd->color_index_map_offset[1] = 0;
2474
1.61M
}
2475
2476
14.5k
static inline void decoder_alloc_tile_data(AV1Decoder *pbi, const int n_tiles) {
2477
14.5k
  AV1_COMMON *const cm = &pbi->common;
2478
14.5k
  aom_free(pbi->tile_data);
2479
14.5k
  pbi->allocated_tiles = 0;
2480
14.5k
  CHECK_MEM_ERROR(cm, pbi->tile_data,
2481
14.5k
                  aom_memalign(32, n_tiles * sizeof(*pbi->tile_data)));
2482
14.5k
  pbi->allocated_tiles = n_tiles;
2483
50.4k
  for (int i = 0; i < n_tiles; i++) {
2484
35.8k
    TileDataDec *const tile_data = pbi->tile_data + i;
2485
35.8k
    av1_zero(tile_data->dec_row_mt_sync);
2486
35.8k
  }
2487
14.5k
  pbi->allocated_row_mt_sync_rows = 0;
2488
14.5k
}
2489
2490
// Set up nsync by width.
2491
27.5k
static inline int get_sync_range(int width) {
2492
// nsync numbers are picked by testing.
2493
#if 0
2494
  if (width < 640)
2495
    return 1;
2496
  else if (width <= 1280)
2497
    return 2;
2498
  else if (width <= 4096)
2499
    return 4;
2500
  else
2501
    return 8;
2502
#else
2503
27.5k
  (void)width;
2504
27.5k
#endif
2505
27.5k
  return 1;
2506
27.5k
}
2507
2508
// Allocate memory for decoder row synchronization
2509
static inline void dec_row_mt_alloc(AV1DecRowMTSync *dec_row_mt_sync,
2510
27.5k
                                    AV1_COMMON *cm, int rows) {
2511
27.5k
  dec_row_mt_sync->allocated_sb_rows = rows;
2512
27.5k
#if CONFIG_MULTITHREAD
2513
27.5k
  {
2514
27.5k
    int i;
2515
2516
27.5k
    CHECK_MEM_ERROR(cm, dec_row_mt_sync->mutex_,
2517
27.5k
                    aom_malloc(sizeof(*(dec_row_mt_sync->mutex_)) * rows));
2518
27.5k
    if (dec_row_mt_sync->mutex_) {
2519
80.1k
      for (i = 0; i < rows; ++i) {
2520
52.6k
        pthread_mutex_init(&dec_row_mt_sync->mutex_[i], NULL);
2521
52.6k
      }
2522
27.5k
    }
2523
2524
27.5k
    CHECK_MEM_ERROR(cm, dec_row_mt_sync->cond_,
2525
27.5k
                    aom_malloc(sizeof(*(dec_row_mt_sync->cond_)) * rows));
2526
27.5k
    if (dec_row_mt_sync->cond_) {
2527
80.1k
      for (i = 0; i < rows; ++i) {
2528
52.6k
        pthread_cond_init(&dec_row_mt_sync->cond_[i], NULL);
2529
52.6k
      }
2530
27.5k
    }
2531
27.5k
  }
2532
27.5k
#endif  // CONFIG_MULTITHREAD
2533
2534
27.5k
  CHECK_MEM_ERROR(cm, dec_row_mt_sync->cur_sb_col,
2535
27.5k
                  aom_malloc(sizeof(*(dec_row_mt_sync->cur_sb_col)) * rows));
2536
2537
  // Set up nsync.
2538
27.5k
  dec_row_mt_sync->sync_range = get_sync_range(cm->width);
2539
27.5k
}
2540
2541
// Deallocate decoder row synchronization related mutex and data
2542
62.3k
void av1_dec_row_mt_dealloc(AV1DecRowMTSync *dec_row_mt_sync) {
2543
62.3k
  if (dec_row_mt_sync != NULL) {
2544
62.3k
#if CONFIG_MULTITHREAD
2545
62.3k
    int i;
2546
62.3k
    if (dec_row_mt_sync->mutex_ != NULL) {
2547
80.1k
      for (i = 0; i < dec_row_mt_sync->allocated_sb_rows; ++i) {
2548
52.6k
        pthread_mutex_destroy(&dec_row_mt_sync->mutex_[i]);
2549
52.6k
      }
2550
27.5k
      aom_free(dec_row_mt_sync->mutex_);
2551
27.5k
    }
2552
62.3k
    if (dec_row_mt_sync->cond_ != NULL) {
2553
80.1k
      for (i = 0; i < dec_row_mt_sync->allocated_sb_rows; ++i) {
2554
52.6k
        pthread_cond_destroy(&dec_row_mt_sync->cond_[i]);
2555
52.6k
      }
2556
27.5k
      aom_free(dec_row_mt_sync->cond_);
2557
27.5k
    }
2558
62.3k
#endif  // CONFIG_MULTITHREAD
2559
62.3k
    aom_free(dec_row_mt_sync->cur_sb_col);
2560
2561
    // clear the structure as the source of this call may be a resize in which
2562
    // case this call will be followed by an _alloc() which may fail.
2563
62.3k
    av1_zero(*dec_row_mt_sync);
2564
62.3k
  }
2565
62.3k
}
2566
2567
static inline void sync_read(AV1DecRowMTSync *const dec_row_mt_sync, int r,
2568
451k
                             int c) {
2569
451k
#if CONFIG_MULTITHREAD
2570
451k
  const int nsync = dec_row_mt_sync->sync_range;
2571
2572
451k
  if (r && !(c & (nsync - 1))) {
2573
297k
    pthread_mutex_t *const mutex = &dec_row_mt_sync->mutex_[r - 1];
2574
297k
    pthread_mutex_lock(mutex);
2575
2576
378k
    while (c > dec_row_mt_sync->cur_sb_col[r - 1] - nsync -
2577
378k
                   dec_row_mt_sync->intrabc_extra_top_right_sb_delay) {
2578
80.5k
      pthread_cond_wait(&dec_row_mt_sync->cond_[r - 1], mutex);
2579
80.5k
    }
2580
297k
    pthread_mutex_unlock(mutex);
2581
297k
  }
2582
#else
2583
  (void)dec_row_mt_sync;
2584
  (void)r;
2585
  (void)c;
2586
#endif  // CONFIG_MULTITHREAD
2587
451k
}
2588
2589
static inline void sync_write(AV1DecRowMTSync *const dec_row_mt_sync, int r,
2590
454k
                              int c, const int sb_cols) {
2591
454k
#if CONFIG_MULTITHREAD
2592
454k
  const int nsync = dec_row_mt_sync->sync_range;
2593
454k
  int cur;
2594
454k
  int sig = 1;
2595
2596
454k
  if (c < sb_cols - 1) {
2597
326k
    cur = c;
2598
326k
    if (c % nsync) sig = 0;
2599
326k
  } else {
2600
128k
    cur = sb_cols + nsync + dec_row_mt_sync->intrabc_extra_top_right_sb_delay;
2601
128k
  }
2602
2603
454k
  if (sig) {
2604
454k
    pthread_mutex_lock(&dec_row_mt_sync->mutex_[r]);
2605
2606
454k
    dec_row_mt_sync->cur_sb_col[r] = cur;
2607
2608
454k
    pthread_cond_signal(&dec_row_mt_sync->cond_[r]);
2609
454k
    pthread_mutex_unlock(&dec_row_mt_sync->mutex_[r]);
2610
454k
  }
2611
#else
2612
  (void)dec_row_mt_sync;
2613
  (void)r;
2614
  (void)c;
2615
  (void)sb_cols;
2616
#endif  // CONFIG_MULTITHREAD
2617
454k
}
2618
2619
static inline void signal_decoding_done_for_erroneous_row(
2620
2.12k
    AV1Decoder *const pbi, const MACROBLOCKD *const xd) {
2621
2.12k
  AV1_COMMON *const cm = &pbi->common;
2622
2.12k
  const TileInfo *const tile = &xd->tile;
2623
2.12k
  const int sb_row_in_tile =
2624
2.12k
      ((xd->mi_row - tile->mi_row_start) >> cm->seq_params->mib_size_log2);
2625
2.12k
  const int sb_cols_in_tile = av1_get_sb_cols_in_tile(cm, tile);
2626
2.12k
  TileDataDec *const tile_data =
2627
2.12k
      pbi->tile_data + tile->tile_row * cm->tiles.cols + tile->tile_col;
2628
2.12k
  AV1DecRowMTSync *dec_row_mt_sync = &tile_data->dec_row_mt_sync;
2629
2630
2.12k
  sync_write(dec_row_mt_sync, sb_row_in_tile, sb_cols_in_tile - 1,
2631
2.12k
             sb_cols_in_tile);
2632
2.12k
}
2633
2634
static inline void decode_tile_sb_row(AV1Decoder *pbi, ThreadData *const td,
2635
                                      const TileInfo *tile_info,
2636
125k
                                      const int mi_row) {
2637
125k
  AV1_COMMON *const cm = &pbi->common;
2638
125k
  const int num_planes = av1_num_planes(cm);
2639
125k
  TileDataDec *const tile_data = pbi->tile_data +
2640
125k
                                 tile_info->tile_row * cm->tiles.cols +
2641
125k
                                 tile_info->tile_col;
2642
125k
  const int sb_cols_in_tile = av1_get_sb_cols_in_tile(cm, tile_info);
2643
125k
  const int sb_row_in_tile =
2644
125k
      (mi_row - tile_info->mi_row_start) >> cm->seq_params->mib_size_log2;
2645
125k
  int sb_col_in_tile = 0;
2646
125k
  int row_mt_exit = 0;
2647
2648
577k
  for (int mi_col = tile_info->mi_col_start; mi_col < tile_info->mi_col_end;
2649
452k
       mi_col += cm->seq_params->mib_size, sb_col_in_tile++) {
2650
452k
    set_cb_buffer(pbi, &td->dcb, pbi->cb_buffer_base, num_planes, mi_row,
2651
452k
                  mi_col);
2652
2653
452k
    sync_read(&tile_data->dec_row_mt_sync, sb_row_in_tile, sb_col_in_tile);
2654
2655
452k
#if CONFIG_MULTITHREAD
2656
452k
    pthread_mutex_lock(pbi->row_mt_mutex_);
2657
452k
#endif
2658
452k
    row_mt_exit = pbi->frame_row_mt_info.row_mt_exit;
2659
452k
#if CONFIG_MULTITHREAD
2660
452k
    pthread_mutex_unlock(pbi->row_mt_mutex_);
2661
452k
#endif
2662
2663
452k
    if (!row_mt_exit) {
2664
      // Decoding of the super-block
2665
450k
      decode_partition(pbi, td, mi_row, mi_col, td->bit_reader,
2666
450k
                       cm->seq_params->sb_size, 0x2);
2667
450k
    }
2668
2669
452k
    sync_write(&tile_data->dec_row_mt_sync, sb_row_in_tile, sb_col_in_tile,
2670
452k
               sb_cols_in_tile);
2671
452k
  }
2672
125k
}
2673
2674
103k
static int check_trailing_bits_after_symbol_coder(aom_reader *r) {
2675
103k
  if (aom_reader_has_overflowed(r)) return -1;
2676
2677
103k
  uint32_t nb_bits = aom_reader_tell(r);
2678
103k
  uint32_t nb_bytes = (nb_bits + 7) >> 3;
2679
103k
  const uint8_t *p = aom_reader_find_begin(r) + nb_bytes;
2680
2681
  // aom_reader_tell() returns 1 for a newly initialized decoder, and the
2682
  // return value only increases as values are decoded. So nb_bits > 0, and
2683
  // thus p > p_begin. Therefore accessing p[-1] is safe.
2684
103k
  uint8_t last_byte = p[-1];
2685
103k
  uint8_t pattern = 128 >> ((nb_bits - 1) & 7);
2686
103k
  if ((last_byte & (2 * pattern - 1)) != pattern) return -1;
2687
2688
  // Make sure that all padding bytes are zero as required by the spec.
2689
96.5k
  const uint8_t *p_end = aom_reader_find_end(r);
2690
149k
  while (p < p_end) {
2691
54.0k
    if (*p != 0) return -1;
2692
52.7k
    p++;
2693
52.7k
  }
2694
95.2k
  return 0;
2695
96.5k
}
2696
2697
static inline void set_decode_func_pointers(ThreadData *td,
2698
301k
                                            int parse_decode_flag) {
2699
301k
  td->read_coeffs_tx_intra_block_visit = decode_block_void;
2700
301k
  td->predict_and_recon_intra_block_visit = decode_block_void;
2701
301k
  td->read_coeffs_tx_inter_block_visit = decode_block_void;
2702
301k
  td->inverse_tx_inter_block_visit = decode_block_void;
2703
301k
  td->predict_inter_block_visit = predict_inter_block_void;
2704
301k
  td->cfl_store_inter_block_visit = cfl_store_inter_block_void;
2705
2706
301k
  if (parse_decode_flag & 0x1) {
2707
200k
    td->read_coeffs_tx_intra_block_visit = read_coeffs_tx_intra_block;
2708
200k
    td->read_coeffs_tx_inter_block_visit = av1_read_coeffs_txb;
2709
200k
  }
2710
301k
  if (parse_decode_flag & 0x2) {
2711
177k
    td->predict_and_recon_intra_block_visit =
2712
177k
        predict_and_reconstruct_intra_block;
2713
177k
    td->inverse_tx_inter_block_visit = inverse_transform_inter_block;
2714
177k
    td->predict_inter_block_visit = predict_inter_block;
2715
177k
    td->cfl_store_inter_block_visit = cfl_store_inter_block;
2716
177k
  }
2717
301k
}
2718
2719
static inline void decode_tile(AV1Decoder *pbi, ThreadData *const td,
2720
75.4k
                               int tile_row, int tile_col) {
2721
75.4k
  TileInfo tile_info;
2722
2723
75.4k
  AV1_COMMON *const cm = &pbi->common;
2724
75.4k
  const int num_planes = av1_num_planes(cm);
2725
2726
75.4k
  av1_tile_set_row(&tile_info, cm, tile_row);
2727
75.4k
  av1_tile_set_col(&tile_info, cm, tile_col);
2728
75.4k
  DecoderCodingBlock *const dcb = &td->dcb;
2729
75.4k
  MACROBLOCKD *const xd = &dcb->xd;
2730
2731
75.4k
  av1_zero_above_context(cm, xd, tile_info.mi_col_start, tile_info.mi_col_end,
2732
75.4k
                         tile_row);
2733
75.4k
  av1_reset_loop_filter_delta(xd, num_planes);
2734
75.4k
  av1_reset_loop_restoration(xd, num_planes);
2735
2736
183k
  for (int mi_row = tile_info.mi_row_start; mi_row < tile_info.mi_row_end;
2737
142k
       mi_row += cm->seq_params->mib_size) {
2738
142k
    av1_zero_left_context(xd);
2739
2740
780k
    for (int mi_col = tile_info.mi_col_start; mi_col < tile_info.mi_col_end;
2741
672k
         mi_col += cm->seq_params->mib_size) {
2742
672k
      set_cb_buffer(pbi, dcb, &td->cb_buffer_base, num_planes, 0, 0);
2743
2744
      // Bit-stream parsing and decoding of the superblock
2745
672k
      decode_partition(pbi, td, mi_row, mi_col, td->bit_reader,
2746
672k
                       cm->seq_params->sb_size, 0x3);
2747
2748
672k
      if (aom_reader_has_overflowed(td->bit_reader)) {
2749
33.9k
        aom_merge_corrupted_flag(&dcb->corrupted, 1);
2750
33.9k
        return;
2751
33.9k
      }
2752
672k
    }
2753
142k
  }
2754
2755
41.4k
  int corrupted =
2756
41.4k
      (check_trailing_bits_after_symbol_coder(td->bit_reader)) ? 1 : 0;
2757
41.4k
  aom_merge_corrupted_flag(&dcb->corrupted, corrupted);
2758
41.4k
}
2759
2760
static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data,
2761
                                   const uint8_t *data_end, int start_tile,
2762
79.6k
                                   int end_tile) {
2763
79.6k
  AV1_COMMON *const cm = &pbi->common;
2764
79.6k
  ThreadData *const td = &pbi->td;
2765
79.6k
  CommonTileParams *const tiles = &cm->tiles;
2766
79.6k
  const int tile_cols = tiles->cols;
2767
79.6k
  const int tile_rows = tiles->rows;
2768
79.6k
  const int n_tiles = tile_cols * tile_rows;
2769
79.6k
  TileBufferDec(*const tile_buffers)[MAX_TILE_COLS] = pbi->tile_buffers;
2770
79.6k
  const int dec_tile_row = AOMMIN(pbi->dec_tile_row, tile_rows);
2771
79.6k
  const int single_row = pbi->dec_tile_row >= 0;
2772
79.6k
  const int dec_tile_col = AOMMIN(pbi->dec_tile_col, tile_cols);
2773
79.6k
  const int single_col = pbi->dec_tile_col >= 0;
2774
79.6k
  int tile_rows_start;
2775
79.6k
  int tile_rows_end;
2776
79.6k
  int tile_cols_start;
2777
79.6k
  int tile_cols_end;
2778
79.6k
  int inv_col_order;
2779
79.6k
  int inv_row_order;
2780
79.6k
  int tile_row, tile_col;
2781
79.6k
  uint8_t allow_update_cdf;
2782
79.6k
  const uint8_t *raw_data_end = NULL;
2783
2784
79.6k
  if (tiles->large_scale) {
2785
12.9k
    tile_rows_start = single_row ? dec_tile_row : 0;
2786
12.9k
    tile_rows_end = single_row ? dec_tile_row + 1 : tile_rows;
2787
12.9k
    tile_cols_start = single_col ? dec_tile_col : 0;
2788
12.9k
    tile_cols_end = single_col ? tile_cols_start + 1 : tile_cols;
2789
12.9k
    inv_col_order = pbi->inv_tile_order && !single_col;
2790
12.9k
    inv_row_order = pbi->inv_tile_order && !single_row;
2791
12.9k
    allow_update_cdf = 0;
2792
66.7k
  } else {
2793
66.7k
    tile_rows_start = 0;
2794
66.7k
    tile_rows_end = tile_rows;
2795
66.7k
    tile_cols_start = 0;
2796
66.7k
    tile_cols_end = tile_cols;
2797
66.7k
    inv_col_order = pbi->inv_tile_order;
2798
66.7k
    inv_row_order = pbi->inv_tile_order;
2799
66.7k
    allow_update_cdf = 1;
2800
66.7k
  }
2801
2802
  // No tiles to decode.
2803
79.6k
  if (tile_rows_end <= tile_rows_start || tile_cols_end <= tile_cols_start ||
2804
      // First tile is larger than end_tile.
2805
79.6k
      tile_rows_start * tiles->cols + tile_cols_start > end_tile ||
2806
      // Last tile is smaller than start_tile.
2807
79.6k
      (tile_rows_end - 1) * tiles->cols + tile_cols_end - 1 < start_tile)
2808
0
    return data;
2809
2810
79.6k
  allow_update_cdf = allow_update_cdf && !cm->features.disable_cdf_update;
2811
2812
79.6k
  assert(tile_rows <= MAX_TILE_ROWS);
2813
79.6k
  assert(tile_cols <= MAX_TILE_COLS);
2814
2815
79.6k
#if EXT_TILE_DEBUG
2816
79.6k
  if (tiles->large_scale && !pbi->ext_tile_debug)
2817
0
    raw_data_end = get_ls_single_tile_buffer(pbi, data, tile_buffers);
2818
79.6k
  else if (tiles->large_scale && pbi->ext_tile_debug)
2819
12.9k
    raw_data_end = get_ls_tile_buffers(pbi, data, data_end, tile_buffers);
2820
66.7k
  else
2821
66.7k
#endif  // EXT_TILE_DEBUG
2822
66.7k
    get_tile_buffers(pbi, data, data_end, tile_buffers, start_tile, end_tile);
2823
2824
79.6k
  if (pbi->tile_data == NULL || n_tiles != pbi->allocated_tiles) {
2825
10.4k
    decoder_alloc_tile_data(pbi, n_tiles);
2826
10.4k
  }
2827
79.6k
  if (pbi->dcb.xd.seg_mask == NULL)
2828
79.6k
    CHECK_MEM_ERROR(cm, pbi->dcb.xd.seg_mask,
2829
79.6k
                    (uint8_t *)aom_memalign(
2830
79.6k
                        16, 2 * MAX_SB_SQUARE * sizeof(*pbi->dcb.xd.seg_mask)));
2831
#if CONFIG_ACCOUNTING
2832
  if (pbi->acct_enabled) {
2833
    aom_accounting_reset(&pbi->accounting);
2834
  }
2835
#endif
2836
2837
79.6k
  set_decode_func_pointers(&pbi->td, 0x3);
2838
2839
  // Load all tile information into thread_data.
2840
79.6k
  td->dcb = pbi->dcb;
2841
2842
79.6k
  td->dcb.corrupted = 0;
2843
79.6k
  td->dcb.mc_buf[0] = td->mc_buf[0];
2844
79.6k
  td->dcb.mc_buf[1] = td->mc_buf[1];
2845
79.6k
  td->dcb.xd.tmp_conv_dst = td->tmp_conv_dst;
2846
230k
  for (int j = 0; j < 2; ++j) {
2847
150k
    td->dcb.xd.tmp_obmc_bufs[j] = td->tmp_obmc_bufs[j];
2848
150k
  }
2849
2850
155k
  for (tile_row = tile_rows_start; tile_row < tile_rows_end; ++tile_row) {
2851
75.4k
    const int row = inv_row_order ? tile_rows - 1 - tile_row : tile_row;
2852
2853
151k
    for (tile_col = tile_cols_start; tile_col < tile_cols_end; ++tile_col) {
2854
75.6k
      const int col = inv_col_order ? tile_cols - 1 - tile_col : tile_col;
2855
75.6k
      TileDataDec *const tile_data = pbi->tile_data + row * tiles->cols + col;
2856
75.6k
      const TileBufferDec *const tile_bs_buf = &tile_buffers[row][col];
2857
2858
75.6k
      if (row * tiles->cols + col < start_tile ||
2859
75.6k
          row * tiles->cols + col > end_tile)
2860
33
        continue;
2861
2862
75.6k
      td->bit_reader = &tile_data->bit_reader;
2863
75.6k
      av1_zero(td->cb_buffer_base.dqcoeff);
2864
75.6k
      av1_tile_init(&td->dcb.xd.tile, cm, row, col);
2865
75.6k
      td->dcb.xd.current_base_qindex = cm->quant_params.base_qindex;
2866
75.6k
      setup_bool_decoder(&td->dcb.xd, tile_bs_buf->data, data_end,
2867
75.6k
                         tile_bs_buf->size, &pbi->error, td->bit_reader,
2868
75.6k
                         allow_update_cdf);
2869
#if CONFIG_ACCOUNTING
2870
      if (pbi->acct_enabled) {
2871
        td->bit_reader->accounting = &pbi->accounting;
2872
        td->bit_reader->accounting->last_tell_frac =
2873
            aom_reader_tell_frac(td->bit_reader);
2874
      } else {
2875
        td->bit_reader->accounting = NULL;
2876
      }
2877
#endif
2878
75.6k
      av1_init_macroblockd(cm, &td->dcb.xd);
2879
75.6k
      av1_init_above_context(&cm->above_contexts, av1_num_planes(cm), row,
2880
75.6k
                             &td->dcb.xd);
2881
2882
      // Initialise the tile context from the frame context
2883
75.6k
      tile_data->tctx = *cm->fc;
2884
75.6k
      td->dcb.xd.tile_ctx = &tile_data->tctx;
2885
2886
      // decode tile
2887
75.6k
      decode_tile(pbi, td, row, col);
2888
75.6k
      aom_merge_corrupted_flag(&pbi->dcb.corrupted, td->dcb.corrupted);
2889
75.6k
      if (pbi->dcb.corrupted)
2890
37.0k
        aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
2891
37.0k
                           "Failed to decode tile data");
2892
75.6k
    }
2893
75.4k
  }
2894
2895
79.6k
  if (tiles->large_scale) {
2896
4.82k
    if (n_tiles == 1) {
2897
      // Find the end of the single tile buffer
2898
4.81k
      return aom_reader_find_end(&pbi->tile_data->bit_reader);
2899
4.81k
    }
2900
    // Return the end of the last tile buffer
2901
2
    return raw_data_end;
2902
4.82k
  }
2903
74.8k
  TileDataDec *const tile_data = pbi->tile_data + end_tile;
2904
2905
74.8k
  return aom_reader_find_end(&tile_data->bit_reader);
2906
79.6k
}
2907
2908
189k
static TileJobsDec *get_dec_job_info(AV1DecTileMT *tile_mt_info) {
2909
189k
  TileJobsDec *cur_job_info = NULL;
2910
189k
#if CONFIG_MULTITHREAD
2911
189k
  pthread_mutex_lock(tile_mt_info->job_mutex);
2912
2913
189k
  if (tile_mt_info->jobs_dequeued < tile_mt_info->jobs_enqueued) {
2914
87.6k
    cur_job_info = tile_mt_info->job_queue + tile_mt_info->jobs_dequeued;
2915
87.6k
    tile_mt_info->jobs_dequeued++;
2916
87.6k
  }
2917
2918
189k
  pthread_mutex_unlock(tile_mt_info->job_mutex);
2919
#else
2920
  (void)tile_mt_info;
2921
#endif
2922
189k
  return cur_job_info;
2923
189k
}
2924
2925
static inline void tile_worker_hook_init(AV1Decoder *const pbi,
2926
                                         DecWorkerData *const thread_data,
2927
                                         const TileBufferDec *const tile_buffer,
2928
                                         TileDataDec *const tile_data,
2929
87.6k
                                         uint8_t allow_update_cdf) {
2930
87.6k
  AV1_COMMON *cm = &pbi->common;
2931
87.6k
  ThreadData *const td = thread_data->td;
2932
87.6k
  int tile_row = tile_data->tile_info.tile_row;
2933
87.6k
  int tile_col = tile_data->tile_info.tile_col;
2934
2935
87.6k
  td->bit_reader = &tile_data->bit_reader;
2936
87.6k
  av1_zero(td->cb_buffer_base.dqcoeff);
2937
2938
87.6k
  MACROBLOCKD *const xd = &td->dcb.xd;
2939
87.6k
  av1_tile_init(&xd->tile, cm, tile_row, tile_col);
2940
87.6k
  xd->current_base_qindex = cm->quant_params.base_qindex;
2941
2942
87.6k
  setup_bool_decoder(xd, tile_buffer->data, thread_data->data_end,
2943
87.6k
                     tile_buffer->size, &thread_data->error_info,
2944
87.6k
                     td->bit_reader, allow_update_cdf);
2945
#if CONFIG_ACCOUNTING
2946
  if (pbi->acct_enabled) {
2947
    td->bit_reader->accounting = &pbi->accounting;
2948
    td->bit_reader->accounting->last_tell_frac =
2949
        aom_reader_tell_frac(td->bit_reader);
2950
  } else {
2951
    td->bit_reader->accounting = NULL;
2952
  }
2953
#endif
2954
87.6k
  av1_init_macroblockd(cm, xd);
2955
87.6k
  xd->error_info = &thread_data->error_info;
2956
87.6k
  av1_init_above_context(&cm->above_contexts, av1_num_planes(cm), tile_row, xd);
2957
2958
  // Initialise the tile context from the frame context
2959
87.6k
  tile_data->tctx = *cm->fc;
2960
87.6k
  xd->tile_ctx = &tile_data->tctx;
2961
#if CONFIG_ACCOUNTING
2962
  if (pbi->acct_enabled) {
2963
    tile_data->bit_reader.accounting->last_tell_frac =
2964
        aom_reader_tell_frac(&tile_data->bit_reader);
2965
  }
2966
#endif
2967
87.6k
}
2968
2969
0
static int tile_worker_hook(void *arg1, void *arg2) {
2970
0
  DecWorkerData *const thread_data = (DecWorkerData *)arg1;
2971
0
  AV1Decoder *const pbi = (AV1Decoder *)arg2;
2972
0
  AV1_COMMON *cm = &pbi->common;
2973
0
  ThreadData *const td = thread_data->td;
2974
0
  uint8_t allow_update_cdf;
2975
2976
  // The jmp_buf is valid only for the duration of the function that calls
2977
  // setjmp(). Therefore, this function must reset the 'setjmp' field to 0
2978
  // before it returns.
2979
0
  if (setjmp(thread_data->error_info.jmp)) {
2980
0
    thread_data->error_info.setjmp = 0;
2981
0
    thread_data->td->dcb.corrupted = 1;
2982
0
    return 0;
2983
0
  }
2984
0
  thread_data->error_info.setjmp = 1;
2985
2986
0
  allow_update_cdf = cm->tiles.large_scale ? 0 : 1;
2987
0
  allow_update_cdf = allow_update_cdf && !cm->features.disable_cdf_update;
2988
2989
0
  set_decode_func_pointers(td, 0x3);
2990
2991
0
  assert(cm->tiles.cols > 0);
2992
0
  while (!td->dcb.corrupted) {
2993
0
    TileJobsDec *cur_job_info = get_dec_job_info(&pbi->tile_mt_info);
2994
2995
0
    if (cur_job_info != NULL) {
2996
0
      const TileBufferDec *const tile_buffer = cur_job_info->tile_buffer;
2997
0
      TileDataDec *const tile_data = cur_job_info->tile_data;
2998
0
      tile_worker_hook_init(pbi, thread_data, tile_buffer, tile_data,
2999
0
                            allow_update_cdf);
3000
      // decode tile
3001
0
      int tile_row = tile_data->tile_info.tile_row;
3002
0
      int tile_col = tile_data->tile_info.tile_col;
3003
0
      decode_tile(pbi, td, tile_row, tile_col);
3004
0
    } else {
3005
0
      break;
3006
0
    }
3007
0
  }
3008
0
  thread_data->error_info.setjmp = 0;
3009
0
  return !td->dcb.corrupted;
3010
0
}
3011
3012
static inline int get_max_row_mt_workers_per_tile(AV1_COMMON *cm,
3013
218k
                                                  const TileInfo *tile) {
3014
  // NOTE: Currently value of max workers is calculated based
3015
  // on the parse and decode time. As per the theoretical estimate
3016
  // when percentage of parse time is equal to percentage of decode
3017
  // time, number of workers needed to parse + decode a tile can not
3018
  // exceed more than 2.
3019
  // TODO(any): Modify this value if parsing is optimized in future.
3020
218k
  int sb_rows = av1_get_sb_rows_in_tile(cm, tile);
3021
218k
  int max_workers =
3022
218k
      sb_rows == 1 ? AOM_MIN_THREADS_PER_TILE : AOM_MAX_THREADS_PER_TILE;
3023
218k
  return max_workers;
3024
218k
}
3025
3026
// The caller must hold pbi->row_mt_mutex_ when calling this function.
3027
// Returns 1 if either the next job is stored in *next_job_info or 1 is stored
3028
// in *end_of_frame.
3029
// NOTE: The caller waits on pbi->row_mt_cond_ if this function returns 0.
3030
// The return value of this function depends on the following variables:
3031
// - frame_row_mt_info->mi_rows_parse_done
3032
// - frame_row_mt_info->mi_rows_decode_started
3033
// - frame_row_mt_info->row_mt_exit
3034
// Therefore we may need to signal or broadcast pbi->row_mt_cond_ if any of
3035
// these variables is modified.
3036
static int get_next_job_info(AV1Decoder *const pbi,
3037
                             AV1DecRowMTJobInfo *next_job_info,
3038
262k
                             int *end_of_frame) {
3039
262k
  AV1_COMMON *cm = &pbi->common;
3040
262k
  TileDataDec *tile_data;
3041
262k
  AV1DecRowMTSync *dec_row_mt_sync;
3042
262k
  AV1DecRowMTInfo *frame_row_mt_info = &pbi->frame_row_mt_info;
3043
262k
  const int tile_rows_start = frame_row_mt_info->tile_rows_start;
3044
262k
  const int tile_rows_end = frame_row_mt_info->tile_rows_end;
3045
262k
  const int tile_cols_start = frame_row_mt_info->tile_cols_start;
3046
262k
  const int tile_cols_end = frame_row_mt_info->tile_cols_end;
3047
262k
  const int start_tile = frame_row_mt_info->start_tile;
3048
262k
  const int end_tile = frame_row_mt_info->end_tile;
3049
262k
  const int sb_mi_size = mi_size_wide[cm->seq_params->sb_size];
3050
262k
  int num_mis_to_decode, num_threads_working;
3051
262k
  int num_mis_waiting_for_decode;
3052
262k
  int min_threads_working = INT_MAX;
3053
262k
  int max_mis_to_decode = 0;
3054
262k
  int tile_row_idx, tile_col_idx;
3055
262k
  int tile_row = -1;
3056
262k
  int tile_col = -1;
3057
3058
262k
  memset(next_job_info, 0, sizeof(*next_job_info));
3059
3060
  // Frame decode is completed or error is encountered.
3061
262k
  *end_of_frame = (frame_row_mt_info->mi_rows_decode_started ==
3062
262k
                   frame_row_mt_info->mi_rows_to_decode) ||
3063
262k
                  (frame_row_mt_info->row_mt_exit == 1);
3064
262k
  if (*end_of_frame) {
3065
101k
    return 1;
3066
101k
  }
3067
3068
  // Decoding cannot start as bit-stream parsing is not complete.
3069
161k
  assert(frame_row_mt_info->mi_rows_parse_done >=
3070
161k
         frame_row_mt_info->mi_rows_decode_started);
3071
161k
  if (frame_row_mt_info->mi_rows_parse_done ==
3072
161k
      frame_row_mt_info->mi_rows_decode_started)
3073
35.1k
    return 0;
3074
3075
  // Choose the tile to decode.
3076
259k
  for (tile_row_idx = tile_rows_start; tile_row_idx < tile_rows_end;
3077
133k
       ++tile_row_idx) {
3078
301k
    for (tile_col_idx = tile_cols_start; tile_col_idx < tile_cols_end;
3079
167k
         ++tile_col_idx) {
3080
167k
      if (tile_row_idx * cm->tiles.cols + tile_col_idx < start_tile ||
3081
167k
          tile_row_idx * cm->tiles.cols + tile_col_idx > end_tile)
3082
196
        continue;
3083
3084
167k
      tile_data = pbi->tile_data + tile_row_idx * cm->tiles.cols + tile_col_idx;
3085
167k
      dec_row_mt_sync = &tile_data->dec_row_mt_sync;
3086
3087
167k
      num_threads_working = dec_row_mt_sync->num_threads_working;
3088
167k
      num_mis_waiting_for_decode = (dec_row_mt_sync->mi_rows_parse_done -
3089
167k
                                    dec_row_mt_sync->mi_rows_decode_started) *
3090
167k
                                   dec_row_mt_sync->mi_cols;
3091
167k
      num_mis_to_decode =
3092
167k
          (dec_row_mt_sync->mi_rows - dec_row_mt_sync->mi_rows_decode_started) *
3093
167k
          dec_row_mt_sync->mi_cols;
3094
3095
167k
      assert(num_mis_to_decode >= num_mis_waiting_for_decode);
3096
3097
      // Pick the tile which has minimum number of threads working on it.
3098
167k
      if (num_mis_waiting_for_decode > 0) {
3099
130k
        if (num_threads_working < min_threads_working) {
3100
126k
          min_threads_working = num_threads_working;
3101
126k
          max_mis_to_decode = 0;
3102
126k
        }
3103
130k
        if (num_threads_working == min_threads_working &&
3104
130k
            num_mis_to_decode > max_mis_to_decode &&
3105
130k
            num_threads_working <
3106
126k
                get_max_row_mt_workers_per_tile(cm, &tile_data->tile_info)) {
3107
126k
          max_mis_to_decode = num_mis_to_decode;
3108
126k
          tile_row = tile_row_idx;
3109
126k
          tile_col = tile_col_idx;
3110
126k
        }
3111
130k
      }
3112
167k
    }
3113
133k
  }
3114
  // No job found to process
3115
126k
  if (tile_row == -1 || tile_col == -1) return 0;
3116
3117
125k
  tile_data = pbi->tile_data + tile_row * cm->tiles.cols + tile_col;
3118
125k
  dec_row_mt_sync = &tile_data->dec_row_mt_sync;
3119
3120
125k
  next_job_info->tile_row = tile_row;
3121
125k
  next_job_info->tile_col = tile_col;
3122
125k
  next_job_info->mi_row = dec_row_mt_sync->mi_rows_decode_started +
3123
125k
                          tile_data->tile_info.mi_row_start;
3124
3125
125k
  dec_row_mt_sync->num_threads_working++;
3126
125k
  dec_row_mt_sync->mi_rows_decode_started += sb_mi_size;
3127
125k
  frame_row_mt_info->mi_rows_decode_started += sb_mi_size;
3128
125k
  assert(frame_row_mt_info->mi_rows_parse_done >=
3129
125k
         frame_row_mt_info->mi_rows_decode_started);
3130
125k
#if CONFIG_MULTITHREAD
3131
125k
  if (frame_row_mt_info->mi_rows_decode_started ==
3132
125k
      frame_row_mt_info->mi_rows_to_decode) {
3133
60.3k
    pthread_cond_broadcast(pbi->row_mt_cond_);
3134
60.3k
  }
3135
125k
#endif
3136
3137
125k
  return 1;
3138
125k
}
3139
3140
static inline void signal_parse_sb_row_done(AV1Decoder *const pbi,
3141
                                            TileDataDec *const tile_data,
3142
133k
                                            const int sb_mi_size) {
3143
133k
  AV1DecRowMTInfo *frame_row_mt_info = &pbi->frame_row_mt_info;
3144
133k
#if CONFIG_MULTITHREAD
3145
133k
  pthread_mutex_lock(pbi->row_mt_mutex_);
3146
133k
#endif
3147
133k
  assert(frame_row_mt_info->mi_rows_parse_done >=
3148
133k
         frame_row_mt_info->mi_rows_decode_started);
3149
133k
  tile_data->dec_row_mt_sync.mi_rows_parse_done += sb_mi_size;
3150
133k
  frame_row_mt_info->mi_rows_parse_done += sb_mi_size;
3151
133k
#if CONFIG_MULTITHREAD
3152
  // A new decode job is available. Wake up one worker thread to handle the
3153
  // new decode job.
3154
  // NOTE: This assumes we bump mi_rows_parse_done and mi_rows_decode_started
3155
  // by the same increment (sb_mi_size).
3156
133k
  pthread_cond_signal(pbi->row_mt_cond_);
3157
133k
  pthread_mutex_unlock(pbi->row_mt_mutex_);
3158
133k
#endif
3159
133k
}
3160
3161
// This function is very similar to decode_tile(). It would be good to figure
3162
// out how to share code.
3163
static inline void parse_tile_row_mt(AV1Decoder *pbi, ThreadData *const td,
3164
87.2k
                                     TileDataDec *const tile_data) {
3165
87.2k
  AV1_COMMON *const cm = &pbi->common;
3166
87.2k
  const int sb_mi_size = mi_size_wide[cm->seq_params->sb_size];
3167
87.2k
  const int num_planes = av1_num_planes(cm);
3168
87.2k
  const TileInfo *const tile_info = &tile_data->tile_info;
3169
87.2k
  int tile_row = tile_info->tile_row;
3170
87.2k
  DecoderCodingBlock *const dcb = &td->dcb;
3171
87.2k
  MACROBLOCKD *const xd = &dcb->xd;
3172
3173
87.2k
  av1_zero_above_context(cm, xd, tile_info->mi_col_start, tile_info->mi_col_end,
3174
87.2k
                         tile_row);
3175
87.2k
  av1_reset_loop_filter_delta(xd, num_planes);
3176
87.2k
  av1_reset_loop_restoration(xd, num_planes);
3177
3178
222k
  for (int mi_row = tile_info->mi_row_start; mi_row < tile_info->mi_row_end;
3179
151k
       mi_row += cm->seq_params->mib_size) {
3180
151k
    av1_zero_left_context(xd);
3181
3182
627k
    for (int mi_col = tile_info->mi_col_start; mi_col < tile_info->mi_col_end;
3183
492k
         mi_col += cm->seq_params->mib_size) {
3184
492k
      set_cb_buffer(pbi, dcb, pbi->cb_buffer_base, num_planes, mi_row, mi_col);
3185
3186
      // Bit-stream parsing of the superblock
3187
492k
      decode_partition(pbi, td, mi_row, mi_col, td->bit_reader,
3188
492k
                       cm->seq_params->sb_size, 0x1);
3189
3190
492k
      if (aom_reader_has_overflowed(td->bit_reader)) {
3191
15.9k
        aom_merge_corrupted_flag(&dcb->corrupted, 1);
3192
15.9k
        return;
3193
15.9k
      }
3194
492k
    }
3195
135k
    signal_parse_sb_row_done(pbi, tile_data, sb_mi_size);
3196
135k
  }
3197
3198
71.2k
  int corrupted =
3199
71.2k
      (check_trailing_bits_after_symbol_coder(td->bit_reader)) ? 1 : 0;
3200
71.2k
  aom_merge_corrupted_flag(&dcb->corrupted, corrupted);
3201
71.2k
}
3202
3203
125k
static int row_mt_worker_hook(void *arg1, void *arg2) {
3204
125k
  DecWorkerData *const thread_data = (DecWorkerData *)arg1;
3205
125k
  AV1Decoder *const pbi = (AV1Decoder *)arg2;
3206
125k
  ThreadData *const td = thread_data->td;
3207
125k
  uint8_t allow_update_cdf;
3208
125k
  AV1DecRowMTInfo *frame_row_mt_info = &pbi->frame_row_mt_info;
3209
125k
  td->dcb.corrupted = 0;
3210
3211
  // The jmp_buf is valid only for the duration of the function that calls
3212
  // setjmp(). Therefore, this function must reset the 'setjmp' field to 0
3213
  // before it returns.
3214
125k
  if (setjmp(thread_data->error_info.jmp)) {
3215
2.12k
    thread_data->error_info.setjmp = 0;
3216
2.12k
    thread_data->td->dcb.corrupted = 1;
3217
2.12k
#if CONFIG_MULTITHREAD
3218
2.12k
    pthread_mutex_lock(pbi->row_mt_mutex_);
3219
2.12k
#endif
3220
2.12k
    frame_row_mt_info->row_mt_exit = 1;
3221
2.12k
#if CONFIG_MULTITHREAD
3222
2.12k
    pthread_cond_broadcast(pbi->row_mt_cond_);
3223
2.12k
    pthread_mutex_unlock(pbi->row_mt_mutex_);
3224
2.12k
#endif
3225
    // If any SB row (erroneous row) processed by a thread encounters an
3226
    // internal error, there is a need to indicate other threads that decoding
3227
    // of the erroneous row is complete. This ensures that other threads which
3228
    // wait upon the completion of SB's present in erroneous row are not waiting
3229
    // indefinitely.
3230
2.12k
    signal_decoding_done_for_erroneous_row(pbi, &thread_data->td->dcb.xd);
3231
2.12k
    return 0;
3232
2.12k
  }
3233
123k
  thread_data->error_info.setjmp = 1;
3234
3235
123k
  AV1_COMMON *cm = &pbi->common;
3236
123k
  allow_update_cdf = cm->tiles.large_scale ? 0 : 1;
3237
123k
  allow_update_cdf = allow_update_cdf && !cm->features.disable_cdf_update;
3238
3239
123k
  set_decode_func_pointers(td, 0x1);
3240
3241
123k
  assert(cm->tiles.cols > 0);
3242
212k
  while (!td->dcb.corrupted) {
3243
189k
    TileJobsDec *cur_job_info = get_dec_job_info(&pbi->tile_mt_info);
3244
3245
189k
    if (cur_job_info != NULL) {
3246
87.6k
      const TileBufferDec *const tile_buffer = cur_job_info->tile_buffer;
3247
87.6k
      TileDataDec *const tile_data = cur_job_info->tile_data;
3248
87.6k
      tile_worker_hook_init(pbi, thread_data, tile_buffer, tile_data,
3249
87.6k
                            allow_update_cdf);
3250
87.6k
#if CONFIG_MULTITHREAD
3251
87.6k
      pthread_mutex_lock(pbi->row_mt_mutex_);
3252
87.6k
#endif
3253
87.6k
      tile_data->dec_row_mt_sync.num_threads_working++;
3254
87.6k
#if CONFIG_MULTITHREAD
3255
87.6k
      pthread_mutex_unlock(pbi->row_mt_mutex_);
3256
87.6k
#endif
3257
      // decode tile
3258
87.6k
      parse_tile_row_mt(pbi, td, tile_data);
3259
87.6k
#if CONFIG_MULTITHREAD
3260
87.6k
      pthread_mutex_lock(pbi->row_mt_mutex_);
3261
87.6k
#endif
3262
87.6k
      tile_data->dec_row_mt_sync.num_threads_working--;
3263
87.6k
#if CONFIG_MULTITHREAD
3264
87.6k
      pthread_mutex_unlock(pbi->row_mt_mutex_);
3265
87.6k
#endif
3266
101k
    } else {
3267
101k
      break;
3268
101k
    }
3269
189k
  }
3270
3271
124k
  if (td->dcb.corrupted) {
3272
21.3k
    thread_data->error_info.setjmp = 0;
3273
21.3k
#if CONFIG_MULTITHREAD
3274
21.3k
    pthread_mutex_lock(pbi->row_mt_mutex_);
3275
21.3k
#endif
3276
21.3k
    frame_row_mt_info->row_mt_exit = 1;
3277
21.3k
#if CONFIG_MULTITHREAD
3278
21.3k
    pthread_cond_broadcast(pbi->row_mt_cond_);
3279
21.3k
    pthread_mutex_unlock(pbi->row_mt_mutex_);
3280
21.3k
#endif
3281
21.3k
    return 0;
3282
21.3k
  }
3283
3284
103k
  set_decode_func_pointers(td, 0x2);
3285
3286
229k
  while (1) {
3287
227k
    AV1DecRowMTJobInfo next_job_info;
3288
227k
    int end_of_frame = 0;
3289
3290
227k
#if CONFIG_MULTITHREAD
3291
227k
    pthread_mutex_lock(pbi->row_mt_mutex_);
3292
227k
#endif
3293
262k
    while (!get_next_job_info(pbi, &next_job_info, &end_of_frame)) {
3294
35.2k
#if CONFIG_MULTITHREAD
3295
35.2k
      pthread_cond_wait(pbi->row_mt_cond_, pbi->row_mt_mutex_);
3296
35.2k
#endif
3297
35.2k
    }
3298
227k
#if CONFIG_MULTITHREAD
3299
227k
    pthread_mutex_unlock(pbi->row_mt_mutex_);
3300
227k
#endif
3301
3302
227k
    if (end_of_frame) break;
3303
3304
125k
    int tile_row = next_job_info.tile_row;
3305
125k
    int tile_col = next_job_info.tile_col;
3306
125k
    int mi_row = next_job_info.mi_row;
3307
3308
125k
    TileDataDec *tile_data =
3309
125k
        pbi->tile_data + tile_row * cm->tiles.cols + tile_col;
3310
125k
    AV1DecRowMTSync *dec_row_mt_sync = &tile_data->dec_row_mt_sync;
3311
3312
125k
    av1_tile_init(&td->dcb.xd.tile, cm, tile_row, tile_col);
3313
125k
    av1_init_macroblockd(cm, &td->dcb.xd);
3314
125k
    td->dcb.xd.error_info = &thread_data->error_info;
3315
3316
125k
    decode_tile_sb_row(pbi, td, &tile_data->tile_info, mi_row);
3317
3318
125k
#if CONFIG_MULTITHREAD
3319
125k
    pthread_mutex_lock(pbi->row_mt_mutex_);
3320
125k
#endif
3321
125k
    dec_row_mt_sync->num_threads_working--;
3322
125k
#if CONFIG_MULTITHREAD
3323
125k
    pthread_mutex_unlock(pbi->row_mt_mutex_);
3324
125k
#endif
3325
125k
  }
3326
103k
  thread_data->error_info.setjmp = 0;
3327
103k
  return !td->dcb.corrupted;
3328
124k
}
3329
3330
// sorts in descending order
3331
77.3k
static int compare_tile_buffers(const void *a, const void *b) {
3332
77.3k
  const TileJobsDec *const buf1 = (const TileJobsDec *)a;
3333
77.3k
  const TileJobsDec *const buf2 = (const TileJobsDec *)b;
3334
77.3k
  return (((int)buf2->tile_buffer->size) - ((int)buf1->tile_buffer->size));
3335
77.3k
}
3336
3337
static inline void enqueue_tile_jobs(AV1Decoder *pbi, AV1_COMMON *cm,
3338
                                     int tile_rows_start, int tile_rows_end,
3339
                                     int tile_cols_start, int tile_cols_end,
3340
68.0k
                                     int start_tile, int end_tile) {
3341
68.0k
  AV1DecTileMT *tile_mt_info = &pbi->tile_mt_info;
3342
68.0k
  TileJobsDec *tile_job_queue = tile_mt_info->job_queue;
3343
68.0k
  tile_mt_info->jobs_enqueued = 0;
3344
68.0k
  tile_mt_info->jobs_dequeued = 0;
3345
3346
153k
  for (int row = tile_rows_start; row < tile_rows_end; row++) {
3347
176k
    for (int col = tile_cols_start; col < tile_cols_end; col++) {
3348
91.6k
      if (row * cm->tiles.cols + col < start_tile ||
3349
91.6k
          row * cm->tiles.cols + col > end_tile)
3350
169
        continue;
3351
91.5k
      tile_job_queue->tile_buffer = &pbi->tile_buffers[row][col];
3352
91.5k
      tile_job_queue->tile_data = pbi->tile_data + row * cm->tiles.cols + col;
3353
91.5k
      tile_job_queue++;
3354
91.5k
      tile_mt_info->jobs_enqueued++;
3355
91.5k
    }
3356
85.2k
  }
3357
68.0k
}
3358
3359
static inline void alloc_dec_jobs(AV1DecTileMT *tile_mt_info, AV1_COMMON *cm,
3360
4.12k
                                  int tile_rows, int tile_cols) {
3361
4.12k
  tile_mt_info->alloc_tile_rows = tile_rows;
3362
4.12k
  tile_mt_info->alloc_tile_cols = tile_cols;
3363
4.12k
  int num_tiles = tile_rows * tile_cols;
3364
4.12k
#if CONFIG_MULTITHREAD
3365
4.12k
  {
3366
4.12k
    CHECK_MEM_ERROR(cm, tile_mt_info->job_mutex,
3367
4.12k
                    aom_malloc(sizeof(*tile_mt_info->job_mutex) * num_tiles));
3368
3369
28.0k
    for (int i = 0; i < num_tiles; i++) {
3370
23.9k
      pthread_mutex_init(&tile_mt_info->job_mutex[i], NULL);
3371
23.9k
    }
3372
4.12k
  }
3373
4.12k
#endif
3374
4.12k
  CHECK_MEM_ERROR(cm, tile_mt_info->job_queue,
3375
4.12k
                  aom_malloc(sizeof(*tile_mt_info->job_queue) * num_tiles));
3376
4.12k
}
3377
3378
313k
void av1_free_mc_tmp_buf(ThreadData *thread_data) {
3379
313k
  int ref;
3380
939k
  for (ref = 0; ref < 2; ref++) {
3381
626k
    if (thread_data->mc_buf_use_highbd)
3382
170k
      aom_free(CONVERT_TO_SHORTPTR(thread_data->mc_buf[ref]));
3383
455k
    else
3384
455k
      aom_free(thread_data->mc_buf[ref]);
3385
626k
    thread_data->mc_buf[ref] = NULL;
3386
626k
  }
3387
313k
  thread_data->mc_buf_size = 0;
3388
313k
  thread_data->mc_buf_use_highbd = 0;
3389
3390
313k
  aom_free(thread_data->tmp_conv_dst);
3391
313k
  thread_data->tmp_conv_dst = NULL;
3392
313k
  aom_free(thread_data->seg_mask);
3393
313k
  thread_data->seg_mask = NULL;
3394
939k
  for (int i = 0; i < 2; ++i) {
3395
626k
    aom_free(thread_data->tmp_obmc_bufs[i]);
3396
626k
    thread_data->tmp_obmc_bufs[i] = NULL;
3397
626k
  }
3398
313k
}
3399
3400
static inline void allocate_mc_tmp_buf(AV1_COMMON *const cm,
3401
                                       ThreadData *thread_data, int buf_size,
3402
171k
                                       int use_highbd) {
3403
513k
  for (int ref = 0; ref < 2; ref++) {
3404
    // The mc_buf/hbd_mc_buf must be zeroed to fix a intermittent valgrind error
3405
    // 'Conditional jump or move depends on uninitialised value' from the loop
3406
    // filter. Uninitialized reads in convolve function (e.g. horiz_4tap path in
3407
    // av1_convolve_2d_sr_avx2()) from mc_buf/hbd_mc_buf are seen to be the
3408
    // potential reason for this issue.
3409
342k
    if (use_highbd) {
3410
170k
      uint16_t *hbd_mc_buf;
3411
170k
      CHECK_MEM_ERROR(cm, hbd_mc_buf, (uint16_t *)aom_memalign(16, buf_size));
3412
170k
      memset(hbd_mc_buf, 0, buf_size);
3413
170k
      thread_data->mc_buf[ref] = CONVERT_TO_BYTEPTR(hbd_mc_buf);
3414
171k
    } else {
3415
171k
      CHECK_MEM_ERROR(cm, thread_data->mc_buf[ref],
3416
171k
                      (uint8_t *)aom_memalign(16, buf_size));
3417
171k
      memset(thread_data->mc_buf[ref], 0, buf_size);
3418
171k
    }
3419
342k
  }
3420
171k
  thread_data->mc_buf_size = buf_size;
3421
171k
  thread_data->mc_buf_use_highbd = use_highbd;
3422
3423
171k
  CHECK_MEM_ERROR(cm, thread_data->tmp_conv_dst,
3424
171k
                  aom_memalign(32, MAX_SB_SIZE * MAX_SB_SIZE *
3425
171k
                                       sizeof(*thread_data->tmp_conv_dst)));
3426
171k
  CHECK_MEM_ERROR(cm, thread_data->seg_mask,
3427
171k
                  (uint8_t *)aom_memalign(
3428
171k
                      16, 2 * MAX_SB_SQUARE * sizeof(*thread_data->seg_mask)));
3429
3430
513k
  for (int i = 0; i < 2; ++i) {
3431
342k
    CHECK_MEM_ERROR(
3432
342k
        cm, thread_data->tmp_obmc_bufs[i],
3433
342k
        aom_memalign(16, 2 * MAX_MB_PLANE * MAX_SB_SQUARE *
3434
342k
                             sizeof(*thread_data->tmp_obmc_bufs[i])));
3435
342k
  }
3436
171k
}
3437
3438
static inline void reset_dec_workers(AV1Decoder *pbi, AVxWorkerHook worker_hook,
3439
68.0k
                                     int num_workers) {
3440
68.0k
  const AVxWorkerInterface *const winterface = aom_get_worker_interface();
3441
3442
  // Reset tile decoding hook
3443
193k
  for (int worker_idx = 0; worker_idx < num_workers; ++worker_idx) {
3444
125k
    AVxWorker *const worker = &pbi->tile_workers[worker_idx];
3445
125k
    DecWorkerData *const thread_data = pbi->thread_data + worker_idx;
3446
125k
    thread_data->td->dcb = pbi->dcb;
3447
125k
    thread_data->td->dcb.corrupted = 0;
3448
125k
    thread_data->td->dcb.mc_buf[0] = thread_data->td->mc_buf[0];
3449
125k
    thread_data->td->dcb.mc_buf[1] = thread_data->td->mc_buf[1];
3450
125k
    thread_data->td->dcb.xd.tmp_conv_dst = thread_data->td->tmp_conv_dst;
3451
125k
    if (worker_idx)
3452
57.1k
      thread_data->td->dcb.xd.seg_mask = thread_data->td->seg_mask;
3453
375k
    for (int j = 0; j < 2; ++j) {
3454
250k
      thread_data->td->dcb.xd.tmp_obmc_bufs[j] =
3455
250k
          thread_data->td->tmp_obmc_bufs[j];
3456
250k
    }
3457
125k
    winterface->sync(worker);
3458
3459
125k
    worker->hook = worker_hook;
3460
125k
    worker->data1 = thread_data;
3461
125k
    worker->data2 = pbi;
3462
125k
  }
3463
#if CONFIG_ACCOUNTING
3464
  if (pbi->acct_enabled) {
3465
    aom_accounting_reset(&pbi->accounting);
3466
  }
3467
#endif
3468
68.0k
}
3469
3470
static inline void launch_dec_workers(AV1Decoder *pbi, const uint8_t *data_end,
3471
68.0k
                                      int num_workers) {
3472
68.0k
  const AVxWorkerInterface *const winterface = aom_get_worker_interface();
3473
3474
193k
  for (int worker_idx = num_workers - 1; worker_idx >= 0; --worker_idx) {
3475
125k
    AVxWorker *const worker = &pbi->tile_workers[worker_idx];
3476
125k
    DecWorkerData *const thread_data = (DecWorkerData *)worker->data1;
3477
3478
125k
    thread_data->data_end = data_end;
3479
3480
125k
    worker->had_error = 0;
3481
125k
    if (worker_idx == 0) {
3482
68.0k
      winterface->execute(worker);
3483
68.0k
    } else {
3484
57.1k
      winterface->launch(worker);
3485
57.1k
    }
3486
125k
  }
3487
68.0k
}
3488
3489
68.0k
static inline void sync_dec_workers(AV1Decoder *pbi, int num_workers) {
3490
68.0k
  const AVxWorkerInterface *const winterface = aom_get_worker_interface();
3491
68.0k
  int corrupted = 0;
3492
3493
193k
  for (int worker_idx = num_workers; worker_idx > 0; --worker_idx) {
3494
125k
    AVxWorker *const worker = &pbi->tile_workers[worker_idx - 1];
3495
125k
    aom_merge_corrupted_flag(&corrupted, !winterface->sync(worker));
3496
125k
  }
3497
3498
68.0k
  pbi->dcb.corrupted = corrupted;
3499
68.0k
}
3500
3501
73.1k
static inline void decode_mt_init(AV1Decoder *pbi) {
3502
73.1k
  AV1_COMMON *const cm = &pbi->common;
3503
73.1k
  const AVxWorkerInterface *const winterface = aom_get_worker_interface();
3504
73.1k
  int worker_idx;
3505
3506
  // Create workers and thread_data
3507
73.1k
  if (pbi->num_workers == 0) {
3508
3.52k
    const int num_threads = pbi->max_threads;
3509
3.52k
    CHECK_MEM_ERROR(cm, pbi->tile_workers,
3510
3.52k
                    aom_malloc(num_threads * sizeof(*pbi->tile_workers)));
3511
3.52k
    CHECK_MEM_ERROR(cm, pbi->thread_data,
3512
3.52k
                    aom_calloc(num_threads, sizeof(*pbi->thread_data)));
3513
3514
133k
    for (worker_idx = 0; worker_idx < num_threads; ++worker_idx) {
3515
129k
      AVxWorker *const worker = &pbi->tile_workers[worker_idx];
3516
129k
      DecWorkerData *const thread_data = pbi->thread_data + worker_idx;
3517
3518
129k
      winterface->init(worker);
3519
129k
      worker->thread_name = "aom tile worker";
3520
129k
      if (worker_idx != 0 && !winterface->reset(worker)) {
3521
0
        aom_internal_error(&pbi->error, AOM_CODEC_ERROR,
3522
0
                           "Tile decoder thread creation failed");
3523
0
      }
3524
129k
      ++pbi->num_workers;
3525
3526
129k
      if (worker_idx != 0) {
3527
        // Allocate thread data.
3528
125k
        CHECK_MEM_ERROR(cm, thread_data->td,
3529
125k
                        aom_memalign(32, sizeof(*thread_data->td)));
3530
125k
        av1_zero(*thread_data->td);
3531
125k
      } else {
3532
        // Main thread acts as a worker and uses the thread data in pbi
3533
3.52k
        thread_data->td = &pbi->td;
3534
3.52k
      }
3535
129k
      thread_data->error_info.error_code = AOM_CODEC_OK;
3536
129k
      thread_data->error_info.setjmp = 0;
3537
129k
    }
3538
3.52k
  }
3539
73.1k
  const int use_highbd = cm->seq_params->use_highbitdepth;
3540
73.1k
  const int buf_size = MC_TEMP_BUF_PELS << use_highbd;
3541
2.95M
  for (worker_idx = 1; worker_idx < pbi->max_threads; ++worker_idx) {
3542
2.88M
    DecWorkerData *const thread_data = pbi->thread_data + worker_idx;
3543
2.88M
    if (thread_data->td->mc_buf_size != buf_size) {
3544
153k
      av1_free_mc_tmp_buf(thread_data->td);
3545
153k
      allocate_mc_tmp_buf(cm, thread_data->td, buf_size, use_highbd);
3546
153k
    }
3547
2.88M
  }
3548
73.1k
}
3549
3550
static inline void tile_mt_queue(AV1Decoder *pbi, int tile_cols, int tile_rows,
3551
                                 int tile_rows_start, int tile_rows_end,
3552
                                 int tile_cols_start, int tile_cols_end,
3553
68.0k
                                 int start_tile, int end_tile) {
3554
68.0k
  AV1_COMMON *const cm = &pbi->common;
3555
68.0k
  if (pbi->tile_mt_info.alloc_tile_cols != tile_cols ||
3556
68.0k
      pbi->tile_mt_info.alloc_tile_rows != tile_rows) {
3557
4.12k
    av1_dealloc_dec_jobs(&pbi->tile_mt_info);
3558
4.12k
    alloc_dec_jobs(&pbi->tile_mt_info, cm, tile_rows, tile_cols);
3559
4.12k
  }
3560
68.0k
  enqueue_tile_jobs(pbi, cm, tile_rows_start, tile_rows_end, tile_cols_start,
3561
68.0k
                    tile_cols_end, start_tile, end_tile);
3562
68.0k
  qsort(pbi->tile_mt_info.job_queue, pbi->tile_mt_info.jobs_enqueued,
3563
68.0k
        sizeof(pbi->tile_mt_info.job_queue[0]), compare_tile_buffers);
3564
68.0k
}
3565
3566
static const uint8_t *decode_tiles_mt(AV1Decoder *pbi, const uint8_t *data,
3567
                                      const uint8_t *data_end, int start_tile,
3568
0
                                      int end_tile) {
3569
0
  AV1_COMMON *const cm = &pbi->common;
3570
0
  CommonTileParams *const tiles = &cm->tiles;
3571
0
  const int tile_cols = tiles->cols;
3572
0
  const int tile_rows = tiles->rows;
3573
0
  const int n_tiles = tile_cols * tile_rows;
3574
0
  TileBufferDec(*const tile_buffers)[MAX_TILE_COLS] = pbi->tile_buffers;
3575
0
  const int dec_tile_row = AOMMIN(pbi->dec_tile_row, tile_rows);
3576
0
  const int single_row = pbi->dec_tile_row >= 0;
3577
0
  const int dec_tile_col = AOMMIN(pbi->dec_tile_col, tile_cols);
3578
0
  const int single_col = pbi->dec_tile_col >= 0;
3579
0
  int tile_rows_start;
3580
0
  int tile_rows_end;
3581
0
  int tile_cols_start;
3582
0
  int tile_cols_end;
3583
0
  int tile_count_tg;
3584
0
  int num_workers;
3585
0
  const uint8_t *raw_data_end = NULL;
3586
3587
0
  if (tiles->large_scale) {
3588
0
    tile_rows_start = single_row ? dec_tile_row : 0;
3589
0
    tile_rows_end = single_row ? dec_tile_row + 1 : tile_rows;
3590
0
    tile_cols_start = single_col ? dec_tile_col : 0;
3591
0
    tile_cols_end = single_col ? tile_cols_start + 1 : tile_cols;
3592
0
  } else {
3593
0
    tile_rows_start = 0;
3594
0
    tile_rows_end = tile_rows;
3595
0
    tile_cols_start = 0;
3596
0
    tile_cols_end = tile_cols;
3597
0
  }
3598
0
  tile_count_tg = end_tile - start_tile + 1;
3599
0
  num_workers = AOMMIN(pbi->max_threads, tile_count_tg);
3600
3601
  // No tiles to decode.
3602
0
  if (tile_rows_end <= tile_rows_start || tile_cols_end <= tile_cols_start ||
3603
      // First tile is larger than end_tile.
3604
0
      tile_rows_start * tile_cols + tile_cols_start > end_tile ||
3605
      // Last tile is smaller than start_tile.
3606
0
      (tile_rows_end - 1) * tile_cols + tile_cols_end - 1 < start_tile)
3607
0
    return data;
3608
3609
0
  assert(tile_rows <= MAX_TILE_ROWS);
3610
0
  assert(tile_cols <= MAX_TILE_COLS);
3611
0
  assert(tile_count_tg > 0);
3612
0
  assert(num_workers > 0);
3613
0
  assert(start_tile <= end_tile);
3614
0
  assert(start_tile >= 0 && end_tile < n_tiles);
3615
3616
0
  decode_mt_init(pbi);
3617
3618
  // get tile size in tile group
3619
0
#if EXT_TILE_DEBUG
3620
0
  if (tiles->large_scale) assert(pbi->ext_tile_debug == 1);
3621
0
  if (tiles->large_scale)
3622
0
    raw_data_end = get_ls_tile_buffers(pbi, data, data_end, tile_buffers);
3623
0
  else
3624
0
#endif  // EXT_TILE_DEBUG
3625
0
    get_tile_buffers(pbi, data, data_end, tile_buffers, start_tile, end_tile);
3626
3627
0
  if (pbi->tile_data == NULL || n_tiles != pbi->allocated_tiles) {
3628
0
    decoder_alloc_tile_data(pbi, n_tiles);
3629
0
  }
3630
0
  if (pbi->dcb.xd.seg_mask == NULL)
3631
0
    CHECK_MEM_ERROR(cm, pbi->dcb.xd.seg_mask,
3632
0
                    (uint8_t *)aom_memalign(
3633
0
                        16, 2 * MAX_SB_SQUARE * sizeof(*pbi->dcb.xd.seg_mask)));
3634
3635
0
  for (int row = 0; row < tile_rows; row++) {
3636
0
    for (int col = 0; col < tile_cols; col++) {
3637
0
      TileDataDec *tile_data = pbi->tile_data + row * tiles->cols + col;
3638
0
      av1_tile_init(&tile_data->tile_info, cm, row, col);
3639
0
    }
3640
0
  }
3641
3642
0
  tile_mt_queue(pbi, tile_cols, tile_rows, tile_rows_start, tile_rows_end,
3643
0
                tile_cols_start, tile_cols_end, start_tile, end_tile);
3644
3645
0
  reset_dec_workers(pbi, tile_worker_hook, num_workers);
3646
0
  launch_dec_workers(pbi, data_end, num_workers);
3647
0
  sync_dec_workers(pbi, num_workers);
3648
3649
0
  if (pbi->dcb.corrupted)
3650
0
    aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
3651
0
                       "Failed to decode tile data");
3652
3653
0
  if (tiles->large_scale) {
3654
0
    if (n_tiles == 1) {
3655
      // Find the end of the single tile buffer
3656
0
      return aom_reader_find_end(&pbi->tile_data->bit_reader);
3657
0
    }
3658
    // Return the end of the last tile buffer
3659
0
    return raw_data_end;
3660
0
  }
3661
0
  TileDataDec *const tile_data = pbi->tile_data + end_tile;
3662
3663
0
  return aom_reader_find_end(&tile_data->bit_reader);
3664
0
}
3665
3666
68.0k
static inline void dec_alloc_cb_buf(AV1Decoder *pbi) {
3667
68.0k
  AV1_COMMON *const cm = &pbi->common;
3668
68.0k
  int size = ((cm->mi_params.mi_rows >> cm->seq_params->mib_size_log2) + 1) *
3669
68.0k
             ((cm->mi_params.mi_cols >> cm->seq_params->mib_size_log2) + 1);
3670
3671
68.0k
  if (pbi->cb_buffer_alloc_size < size) {
3672
4.30k
    av1_dec_free_cb_buf(pbi);
3673
4.30k
    CHECK_MEM_ERROR(cm, pbi->cb_buffer_base,
3674
4.30k
                    aom_memalign(32, sizeof(*pbi->cb_buffer_base) * size));
3675
4.30k
    memset(pbi->cb_buffer_base, 0, sizeof(*pbi->cb_buffer_base) * size);
3676
4.30k
    pbi->cb_buffer_alloc_size = size;
3677
4.30k
  }
3678
68.0k
}
3679
3680
static inline void row_mt_frame_init(AV1Decoder *pbi, int tile_rows_start,
3681
                                     int tile_rows_end, int tile_cols_start,
3682
                                     int tile_cols_end, int start_tile,
3683
68.0k
                                     int end_tile, int max_sb_rows) {
3684
68.0k
  AV1_COMMON *const cm = &pbi->common;
3685
68.0k
  AV1DecRowMTInfo *frame_row_mt_info = &pbi->frame_row_mt_info;
3686
3687
68.0k
  frame_row_mt_info->tile_rows_start = tile_rows_start;
3688
68.0k
  frame_row_mt_info->tile_rows_end = tile_rows_end;
3689
68.0k
  frame_row_mt_info->tile_cols_start = tile_cols_start;
3690
68.0k
  frame_row_mt_info->tile_cols_end = tile_cols_end;
3691
68.0k
  frame_row_mt_info->start_tile = start_tile;
3692
68.0k
  frame_row_mt_info->end_tile = end_tile;
3693
68.0k
  frame_row_mt_info->mi_rows_to_decode = 0;
3694
68.0k
  frame_row_mt_info->mi_rows_parse_done = 0;
3695
68.0k
  frame_row_mt_info->mi_rows_decode_started = 0;
3696
68.0k
  frame_row_mt_info->row_mt_exit = 0;
3697
3698
153k
  for (int tile_row = tile_rows_start; tile_row < tile_rows_end; ++tile_row) {
3699
176k
    for (int tile_col = tile_cols_start; tile_col < tile_cols_end; ++tile_col) {
3700
91.6k
      if (tile_row * cm->tiles.cols + tile_col < start_tile ||
3701
91.6k
          tile_row * cm->tiles.cols + tile_col > end_tile)
3702
169
        continue;
3703
3704
91.5k
      TileDataDec *const tile_data =
3705
91.5k
          pbi->tile_data + tile_row * cm->tiles.cols + tile_col;
3706
91.5k
      const TileInfo *const tile_info = &tile_data->tile_info;
3707
3708
91.5k
      tile_data->dec_row_mt_sync.mi_rows_parse_done = 0;
3709
91.5k
      tile_data->dec_row_mt_sync.mi_rows_decode_started = 0;
3710
91.5k
      tile_data->dec_row_mt_sync.num_threads_working = 0;
3711
91.5k
      tile_data->dec_row_mt_sync.mi_rows =
3712
91.5k
          ALIGN_POWER_OF_TWO(tile_info->mi_row_end - tile_info->mi_row_start,
3713
91.5k
                             cm->seq_params->mib_size_log2);
3714
91.5k
      tile_data->dec_row_mt_sync.mi_cols =
3715
91.5k
          ALIGN_POWER_OF_TWO(tile_info->mi_col_end - tile_info->mi_col_start,
3716
91.5k
                             cm->seq_params->mib_size_log2);
3717
91.5k
      tile_data->dec_row_mt_sync.intrabc_extra_top_right_sb_delay =
3718
91.5k
          av1_get_intrabc_extra_top_right_sb_delay(cm);
3719
3720
91.5k
      frame_row_mt_info->mi_rows_to_decode +=
3721
91.5k
          tile_data->dec_row_mt_sync.mi_rows;
3722
3723
      // Initialize cur_sb_col to -1 for all SB rows.
3724
91.5k
      memset(tile_data->dec_row_mt_sync.cur_sb_col, -1,
3725
91.5k
             sizeof(*tile_data->dec_row_mt_sync.cur_sb_col) * max_sb_rows);
3726
91.5k
    }
3727
85.2k
  }
3728
3729
68.0k
#if CONFIG_MULTITHREAD
3730
68.0k
  if (pbi->row_mt_mutex_ == NULL) {
3731
3.32k
    CHECK_MEM_ERROR(cm, pbi->row_mt_mutex_,
3732
3.32k
                    aom_malloc(sizeof(*(pbi->row_mt_mutex_))));
3733
3.32k
    if (pbi->row_mt_mutex_) {
3734
3.32k
      pthread_mutex_init(pbi->row_mt_mutex_, NULL);
3735
3.32k
    }
3736
3.32k
  }
3737
3738
68.0k
  if (pbi->row_mt_cond_ == NULL) {
3739
3.32k
    CHECK_MEM_ERROR(cm, pbi->row_mt_cond_,
3740
3.32k
                    aom_malloc(sizeof(*(pbi->row_mt_cond_))));
3741
3.32k
    if (pbi->row_mt_cond_) {
3742
3.32k
      pthread_cond_init(pbi->row_mt_cond_, NULL);
3743
3.32k
    }
3744
3.32k
  }
3745
68.0k
#endif
3746
68.0k
}
3747
3748
static const uint8_t *decode_tiles_row_mt(AV1Decoder *pbi, const uint8_t *data,
3749
                                          const uint8_t *data_end,
3750
73.1k
                                          int start_tile, int end_tile) {
3751
73.1k
  AV1_COMMON *const cm = &pbi->common;
3752
73.1k
  CommonTileParams *const tiles = &cm->tiles;
3753
73.1k
  const int tile_cols = tiles->cols;
3754
73.1k
  const int tile_rows = tiles->rows;
3755
73.1k
  const int n_tiles = tile_cols * tile_rows;
3756
73.1k
  TileBufferDec(*const tile_buffers)[MAX_TILE_COLS] = pbi->tile_buffers;
3757
73.1k
  const int dec_tile_row = AOMMIN(pbi->dec_tile_row, tile_rows);
3758
73.1k
  const int single_row = pbi->dec_tile_row >= 0;
3759
73.1k
  const int dec_tile_col = AOMMIN(pbi->dec_tile_col, tile_cols);
3760
73.1k
  const int single_col = pbi->dec_tile_col >= 0;
3761
73.1k
  int tile_rows_start;
3762
73.1k
  int tile_rows_end;
3763
73.1k
  int tile_cols_start;
3764
73.1k
  int tile_cols_end;
3765
73.1k
  int tile_count_tg;
3766
73.1k
  int num_workers = 0;
3767
73.1k
  int max_threads;
3768
73.1k
  const uint8_t *raw_data_end = NULL;
3769
73.1k
  int max_sb_rows = 0;
3770
3771
73.1k
  if (tiles->large_scale) {
3772
7.91k
    tile_rows_start = single_row ? dec_tile_row : 0;
3773
7.91k
    tile_rows_end = single_row ? dec_tile_row + 1 : tile_rows;
3774
7.91k
    tile_cols_start = single_col ? dec_tile_col : 0;
3775
7.91k
    tile_cols_end = single_col ? tile_cols_start + 1 : tile_cols;
3776
65.2k
  } else {
3777
65.2k
    tile_rows_start = 0;
3778
65.2k
    tile_rows_end = tile_rows;
3779
65.2k
    tile_cols_start = 0;
3780
65.2k
    tile_cols_end = tile_cols;
3781
65.2k
  }
3782
73.1k
  tile_count_tg = end_tile - start_tile + 1;
3783
73.1k
  max_threads = pbi->max_threads;
3784
3785
  // No tiles to decode.
3786
73.1k
  if (tile_rows_end <= tile_rows_start || tile_cols_end <= tile_cols_start ||
3787
      // First tile is larger than end_tile.
3788
73.1k
      tile_rows_start * tile_cols + tile_cols_start > end_tile ||
3789
      // Last tile is smaller than start_tile.
3790
73.1k
      (tile_rows_end - 1) * tile_cols + tile_cols_end - 1 < start_tile)
3791
0
    return data;
3792
3793
73.1k
  assert(tile_rows <= MAX_TILE_ROWS);
3794
73.1k
  assert(tile_cols <= MAX_TILE_COLS);
3795
73.1k
  assert(tile_count_tg > 0);
3796
73.1k
  assert(max_threads > 0);
3797
73.1k
  assert(start_tile <= end_tile);
3798
73.1k
  assert(start_tile >= 0 && end_tile < n_tiles);
3799
3800
73.1k
  (void)tile_count_tg;
3801
3802
73.1k
  decode_mt_init(pbi);
3803
3804
  // get tile size in tile group
3805
73.1k
#if EXT_TILE_DEBUG
3806
73.1k
  if (tiles->large_scale) assert(pbi->ext_tile_debug == 1);
3807
73.1k
  if (tiles->large_scale)
3808
7.91k
    raw_data_end = get_ls_tile_buffers(pbi, data, data_end, tile_buffers);
3809
65.2k
  else
3810
65.2k
#endif  // EXT_TILE_DEBUG
3811
65.2k
    get_tile_buffers(pbi, data, data_end, tile_buffers, start_tile, end_tile);
3812
3813
73.1k
  if (pbi->tile_data == NULL || n_tiles != pbi->allocated_tiles) {
3814
4.12k
    if (pbi->tile_data != NULL) {
3815
3.95k
      for (int i = 0; i < pbi->allocated_tiles; i++) {
3816
3.15k
        TileDataDec *const tile_data = pbi->tile_data + i;
3817
3.15k
        av1_dec_row_mt_dealloc(&tile_data->dec_row_mt_sync);
3818
3.15k
      }
3819
798
    }
3820
4.12k
    decoder_alloc_tile_data(pbi, n_tiles);
3821
4.12k
  }
3822
73.1k
  if (pbi->dcb.xd.seg_mask == NULL)
3823
73.1k
    CHECK_MEM_ERROR(cm, pbi->dcb.xd.seg_mask,
3824
73.1k
                    (uint8_t *)aom_memalign(
3825
73.1k
                        16, 2 * MAX_SB_SQUARE * sizeof(*pbi->dcb.xd.seg_mask)));
3826
3827
158k
  for (int row = 0; row < tile_rows; row++) {
3828
176k
    for (int col = 0; col < tile_cols; col++) {
3829
91.6k
      TileDataDec *tile_data = pbi->tile_data + row * tiles->cols + col;
3830
91.6k
      av1_tile_init(&tile_data->tile_info, cm, row, col);
3831
3832
91.6k
      max_sb_rows = AOMMAX(max_sb_rows,
3833
91.6k
                           av1_get_sb_rows_in_tile(cm, &tile_data->tile_info));
3834
91.6k
      num_workers += get_max_row_mt_workers_per_tile(cm, &tile_data->tile_info);
3835
91.6k
    }
3836
85.2k
  }
3837
73.1k
  num_workers = AOMMIN(num_workers, max_threads);
3838
3839
73.1k
  if (pbi->allocated_row_mt_sync_rows != max_sb_rows) {
3840
35.2k
    for (int i = 0; i < n_tiles; ++i) {
3841
27.5k
      TileDataDec *const tile_data = pbi->tile_data + i;
3842
27.5k
      av1_dec_row_mt_dealloc(&tile_data->dec_row_mt_sync);
3843
27.5k
      dec_row_mt_alloc(&tile_data->dec_row_mt_sync, cm, max_sb_rows);
3844
27.5k
    }
3845
7.72k
    pbi->allocated_row_mt_sync_rows = max_sb_rows;
3846
7.72k
  }
3847
3848
73.1k
  tile_mt_queue(pbi, tile_cols, tile_rows, tile_rows_start, tile_rows_end,
3849
73.1k
                tile_cols_start, tile_cols_end, start_tile, end_tile);
3850
3851
73.1k
  dec_alloc_cb_buf(pbi);
3852
3853
73.1k
  row_mt_frame_init(pbi, tile_rows_start, tile_rows_end, tile_cols_start,
3854
73.1k
                    tile_cols_end, start_tile, end_tile, max_sb_rows);
3855
3856
73.1k
  reset_dec_workers(pbi, row_mt_worker_hook, num_workers);
3857
73.1k
  launch_dec_workers(pbi, data_end, num_workers);
3858
73.1k
  sync_dec_workers(pbi, num_workers);
3859
3860
73.1k
  if (pbi->dcb.corrupted)
3861
7.70k
    aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
3862
7.70k
                       "Failed to decode tile data");
3863
3864
73.1k
  if (tiles->large_scale) {
3865
3.25k
    if (n_tiles == 1) {
3866
      // Find the end of the single tile buffer
3867
3.24k
      return aom_reader_find_end(&pbi->tile_data->bit_reader);
3868
3.24k
    }
3869
    // Return the end of the last tile buffer
3870
8
    return raw_data_end;
3871
3.25k
  }
3872
69.8k
  TileDataDec *const tile_data = pbi->tile_data + end_tile;
3873
3874
69.8k
  return aom_reader_find_end(&tile_data->bit_reader);
3875
73.1k
}
3876
3877
14.6k
static inline void error_handler(void *data) {
3878
14.6k
  AV1_COMMON *const cm = (AV1_COMMON *)data;
3879
14.6k
  aom_internal_error(cm->error, AOM_CODEC_CORRUPT_FRAME, "Truncated packet");
3880
14.6k
}
3881
3882
// Reads the high_bitdepth and twelve_bit fields in color_config() and sets
3883
// seq_params->bit_depth based on the values of those fields and
3884
// seq_params->profile. Reports errors by calling rb->error_handler() or
3885
// aom_internal_error().
3886
static inline void read_bitdepth(struct aom_read_bit_buffer *rb,
3887
                                 SequenceHeader *seq_params,
3888
80.5k
                                 struct aom_internal_error_info *error_info) {
3889
80.5k
  const int high_bitdepth = aom_rb_read_bit(rb);
3890
80.5k
  if (seq_params->profile == PROFILE_2 && high_bitdepth) {
3891
30.7k
    const int twelve_bit = aom_rb_read_bit(rb);
3892
30.7k
    seq_params->bit_depth = twelve_bit ? AOM_BITS_12 : AOM_BITS_10;
3893
49.8k
  } else if (seq_params->profile <= PROFILE_2) {
3894
49.5k
    seq_params->bit_depth = high_bitdepth ? AOM_BITS_10 : AOM_BITS_8;
3895
49.5k
  } else {
3896
218
    aom_internal_error(error_info, AOM_CODEC_UNSUP_BITSTREAM,
3897
218
                       "Unsupported profile/bit-depth combination");
3898
218
  }
3899
#if !CONFIG_AV1_HIGHBITDEPTH
3900
  if (seq_params->bit_depth > AOM_BITS_8) {
3901
    aom_internal_error(error_info, AOM_CODEC_UNSUP_BITSTREAM,
3902
                       "Bit-depth %d not supported", seq_params->bit_depth);
3903
  }
3904
#endif
3905
80.5k
}
3906
3907
static void read_film_grain_params(AV1_COMMON *cm,
3908
72.0k
                                   struct aom_read_bit_buffer *rb) {
3909
72.0k
  aom_film_grain_t *pars = &cm->film_grain_params;
3910
72.0k
  const SequenceHeader *const seq_params = cm->seq_params;
3911
3912
72.0k
  pars->apply_grain = aom_rb_read_bit(rb);
3913
72.0k
  if (!pars->apply_grain) {
3914
47.6k
    memset(pars, 0, sizeof(*pars));
3915
47.6k
    return;
3916
47.6k
  }
3917
3918
24.3k
  pars->random_seed = aom_rb_read_literal(rb, 16);
3919
24.3k
  if (cm->current_frame.frame_type == INTER_FRAME)
3920
1.72k
    pars->update_parameters = aom_rb_read_bit(rb);
3921
22.6k
  else
3922
22.6k
    pars->update_parameters = 1;
3923
3924
24.3k
  pars->bit_depth = seq_params->bit_depth;
3925
3926
24.3k
  if (!pars->update_parameters) {
3927
    // inherit parameters from a previous reference frame
3928
1.66k
    int film_grain_params_ref_idx = aom_rb_read_literal(rb, 3);
3929
    // Section 6.8.20: It is a requirement of bitstream conformance that
3930
    // film_grain_params_ref_idx is equal to ref_frame_idx[ j ] for some value
3931
    // of j in the range 0 to REFS_PER_FRAME - 1.
3932
1.66k
    int found = 0;
3933
10.3k
    for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
3934
9.46k
      if (film_grain_params_ref_idx == cm->remapped_ref_idx[i]) {
3935
726
        found = 1;
3936
726
        break;
3937
726
      }
3938
9.46k
    }
3939
1.66k
    if (!found) {
3940
935
      aom_internal_error(cm->error, AOM_CODEC_UNSUP_BITSTREAM,
3941
935
                         "Invalid film grain reference idx %d. ref_frame_idx = "
3942
935
                         "{%d, %d, %d, %d, %d, %d, %d}",
3943
935
                         film_grain_params_ref_idx, cm->remapped_ref_idx[0],
3944
935
                         cm->remapped_ref_idx[1], cm->remapped_ref_idx[2],
3945
935
                         cm->remapped_ref_idx[3], cm->remapped_ref_idx[4],
3946
935
                         cm->remapped_ref_idx[5], cm->remapped_ref_idx[6]);
3947
935
    }
3948
1.66k
    RefCntBuffer *const buf = cm->ref_frame_map[film_grain_params_ref_idx];
3949
1.66k
    if (buf == NULL) {
3950
0
      aom_internal_error(cm->error, AOM_CODEC_UNSUP_BITSTREAM,
3951
0
                         "Invalid Film grain reference idx");
3952
0
    }
3953
1.66k
    if (!buf->film_grain_params_present) {
3954
77
      aom_internal_error(cm->error, AOM_CODEC_UNSUP_BITSTREAM,
3955
77
                         "Film grain reference parameters not available");
3956
77
    }
3957
1.66k
    uint16_t random_seed = pars->random_seed;
3958
1.66k
    *pars = buf->film_grain_params;   // inherit paramaters
3959
1.66k
    pars->random_seed = random_seed;  // with new random seed
3960
1.66k
    return;
3961
1.66k
  }
3962
3963
  // Scaling functions parameters
3964
22.7k
  pars->num_y_points = aom_rb_read_literal(rb, 4);  // max 14
3965
22.7k
  if (pars->num_y_points > 14)
3966
169
    aom_internal_error(cm->error, AOM_CODEC_UNSUP_BITSTREAM,
3967
169
                       "Number of points for film grain luma scaling function "
3968
169
                       "exceeds the maximum value.");
3969
54.8k
  for (int i = 0; i < pars->num_y_points; i++) {
3970
32.0k
    pars->scaling_points_y[i][0] = aom_rb_read_literal(rb, 8);
3971
32.0k
    if (i && pars->scaling_points_y[i - 1][0] >= pars->scaling_points_y[i][0])
3972
950
      aom_internal_error(cm->error, AOM_CODEC_UNSUP_BITSTREAM,
3973
950
                         "First coordinate of the scaling function points "
3974
950
                         "shall be increasing.");
3975
32.0k
    pars->scaling_points_y[i][1] = aom_rb_read_literal(rb, 8);
3976
32.0k
  }
3977
3978
22.7k
  if (!seq_params->monochrome)
3979
20.8k
    pars->chroma_scaling_from_luma = aom_rb_read_bit(rb);
3980
1.84k
  else
3981
1.84k
    pars->chroma_scaling_from_luma = 0;
3982
3983
22.7k
  if (seq_params->monochrome || pars->chroma_scaling_from_luma ||
3984
22.7k
      ((seq_params->subsampling_x == 1) && (seq_params->subsampling_y == 1) &&
3985
12.4k
       (pars->num_y_points == 0))) {
3986
12.4k
    pars->num_cb_points = 0;
3987
12.4k
    pars->num_cr_points = 0;
3988
12.4k
  } else {
3989
10.3k
    pars->num_cb_points = aom_rb_read_literal(rb, 4);  // max 10
3990
10.3k
    if (pars->num_cb_points > 10)
3991
303
      aom_internal_error(cm->error, AOM_CODEC_UNSUP_BITSTREAM,
3992
303
                         "Number of points for film grain cb scaling function "
3993
303
                         "exceeds the maximum value.");
3994
16.2k
    for (int i = 0; i < pars->num_cb_points; i++) {
3995
5.91k
      pars->scaling_points_cb[i][0] = aom_rb_read_literal(rb, 8);
3996
5.91k
      if (i &&
3997
5.91k
          pars->scaling_points_cb[i - 1][0] >= pars->scaling_points_cb[i][0])
3998
296
        aom_internal_error(cm->error, AOM_CODEC_UNSUP_BITSTREAM,
3999
296
                           "First coordinate of the scaling function points "
4000
296
                           "shall be increasing.");
4001
5.91k
      pars->scaling_points_cb[i][1] = aom_rb_read_literal(rb, 8);
4002
5.91k
    }
4003
4004
10.3k
    pars->num_cr_points = aom_rb_read_literal(rb, 4);  // max 10
4005
10.3k
    if (pars->num_cr_points > 10)
4006
136
      aom_internal_error(cm->error, AOM_CODEC_UNSUP_BITSTREAM,
4007
136
                         "Number of points for film grain cr scaling function "
4008
136
                         "exceeds the maximum value.");
4009
28.4k
    for (int i = 0; i < pars->num_cr_points; i++) {
4010
18.1k
      pars->scaling_points_cr[i][0] = aom_rb_read_literal(rb, 8);
4011
18.1k
      if (i &&
4012
18.1k
          pars->scaling_points_cr[i - 1][0] >= pars->scaling_points_cr[i][0])
4013
457
        aom_internal_error(cm->error, AOM_CODEC_UNSUP_BITSTREAM,
4014
457
                           "First coordinate of the scaling function points "
4015
457
                           "shall be increasing.");
4016
18.1k
      pars->scaling_points_cr[i][1] = aom_rb_read_literal(rb, 8);
4017
18.1k
    }
4018
4019
10.3k
    if ((seq_params->subsampling_x == 1) && (seq_params->subsampling_y == 1) &&
4020
10.3k
        (((pars->num_cb_points == 0) && (pars->num_cr_points != 0)) ||
4021
1.60k
         ((pars->num_cb_points != 0) && (pars->num_cr_points == 0))))
4022
16
      aom_internal_error(cm->error, AOM_CODEC_UNSUP_BITSTREAM,
4023
16
                         "In YCbCr 4:2:0, film grain shall be applied "
4024
16
                         "to both chroma components or neither.");
4025
10.3k
  }
4026
4027
22.7k
  pars->scaling_shift = aom_rb_read_literal(rb, 2) + 8;  // 8 + value
4028
4029
  // AR coefficients
4030
  // Only sent if the corresponsing scaling function has
4031
  // more than 0 points
4032
4033
22.7k
  pars->ar_coeff_lag = aom_rb_read_literal(rb, 2);
4034
4035
22.7k
  int num_pos_luma = 2 * pars->ar_coeff_lag * (pars->ar_coeff_lag + 1);
4036
22.7k
  int num_pos_chroma = num_pos_luma;
4037
22.7k
  if (pars->num_y_points > 0) ++num_pos_chroma;
4038
4039
22.7k
  if (pars->num_y_points)
4040
48.0k
    for (int i = 0; i < num_pos_luma; i++)
4041
33.1k
      pars->ar_coeffs_y[i] = aom_rb_read_literal(rb, 8) - 128;
4042
4043
22.7k
  if (pars->num_cb_points || pars->chroma_scaling_from_luma)
4044
52.7k
    for (int i = 0; i < num_pos_chroma; i++)
4045
40.3k
      pars->ar_coeffs_cb[i] = aom_rb_read_literal(rb, 8) - 128;
4046
4047
22.7k
  if (pars->num_cr_points || pars->chroma_scaling_from_luma)
4048
55.9k
    for (int i = 0; i < num_pos_chroma; i++)
4049
40.8k
      pars->ar_coeffs_cr[i] = aom_rb_read_literal(rb, 8) - 128;
4050
4051
22.7k
  pars->ar_coeff_shift = aom_rb_read_literal(rb, 2) + 6;  // 6 + value
4052
4053
22.7k
  pars->grain_scale_shift = aom_rb_read_literal(rb, 2);
4054
4055
22.7k
  if (pars->num_cb_points) {
4056
2.25k
    pars->cb_mult = aom_rb_read_literal(rb, 8);
4057
2.25k
    pars->cb_luma_mult = aom_rb_read_literal(rb, 8);
4058
2.25k
    pars->cb_offset = aom_rb_read_literal(rb, 9);
4059
2.25k
  }
4060
4061
22.7k
  if (pars->num_cr_points) {
4062
5.34k
    pars->cr_mult = aom_rb_read_literal(rb, 8);
4063
5.34k
    pars->cr_luma_mult = aom_rb_read_literal(rb, 8);
4064
5.34k
    pars->cr_offset = aom_rb_read_literal(rb, 9);
4065
5.34k
  }
4066
4067
22.7k
  pars->overlap_flag = aom_rb_read_bit(rb);
4068
4069
22.7k
  pars->clip_to_restricted_range = aom_rb_read_bit(rb);
4070
22.7k
}
4071
4072
static inline void read_film_grain(AV1_COMMON *cm,
4073
180k
                                   struct aom_read_bit_buffer *rb) {
4074
180k
  if (cm->seq_params->film_grain_params_present &&
4075
180k
      (cm->show_frame || cm->showable_frame)) {
4076
72.0k
    read_film_grain_params(cm, rb);
4077
108k
  } else {
4078
108k
    memset(&cm->film_grain_params, 0, sizeof(cm->film_grain_params));
4079
108k
  }
4080
180k
  cm->film_grain_params.bit_depth = cm->seq_params->bit_depth;
4081
180k
  cm->cur_frame->film_grain_params = cm->film_grain_params;
4082
180k
}
4083
4084
void av1_read_color_config(struct aom_read_bit_buffer *rb,
4085
                           int allow_lowbitdepth, SequenceHeader *seq_params,
4086
80.5k
                           struct aom_internal_error_info *error_info) {
4087
80.5k
  read_bitdepth(rb, seq_params, error_info);
4088
4089
80.5k
  seq_params->use_highbitdepth =
4090
80.5k
      seq_params->bit_depth > AOM_BITS_8 || !allow_lowbitdepth;
4091
  // monochrome bit (not needed for PROFILE_1)
4092
80.5k
  const int is_monochrome =
4093
80.5k
      seq_params->profile != PROFILE_1 ? aom_rb_read_bit(rb) : 0;
4094
80.5k
  seq_params->monochrome = is_monochrome;
4095
80.5k
  int color_description_present_flag = aom_rb_read_bit(rb);
4096
80.5k
  if (color_description_present_flag) {
4097
3.65k
    seq_params->color_primaries = aom_rb_read_literal(rb, 8);
4098
3.65k
    seq_params->transfer_characteristics = aom_rb_read_literal(rb, 8);
4099
3.65k
    seq_params->matrix_coefficients = aom_rb_read_literal(rb, 8);
4100
76.9k
  } else {
4101
76.9k
    seq_params->color_primaries = AOM_CICP_CP_UNSPECIFIED;
4102
76.9k
    seq_params->transfer_characteristics = AOM_CICP_TC_UNSPECIFIED;
4103
76.9k
    seq_params->matrix_coefficients = AOM_CICP_MC_UNSPECIFIED;
4104
76.9k
  }
4105
80.5k
  if (is_monochrome) {
4106
    // [16,235] (including xvycc) vs [0,255] range
4107
16.0k
    seq_params->color_range = aom_rb_read_bit(rb);
4108
16.0k
    seq_params->subsampling_y = seq_params->subsampling_x = 1;
4109
16.0k
    seq_params->chroma_sample_position = AOM_CSP_UNKNOWN;
4110
16.0k
    seq_params->separate_uv_delta_q = 0;
4111
16.0k
    return;
4112
16.0k
  }
4113
64.5k
  if (seq_params->color_primaries == AOM_CICP_CP_BT_709 &&
4114
64.5k
      seq_params->transfer_characteristics == AOM_CICP_TC_SRGB &&
4115
64.5k
      seq_params->matrix_coefficients == AOM_CICP_MC_IDENTITY) {
4116
2
    seq_params->subsampling_y = seq_params->subsampling_x = 0;
4117
2
    seq_params->color_range = 1;  // assume full color-range
4118
2
    if (!(seq_params->profile == PROFILE_1 ||
4119
2
          (seq_params->profile == PROFILE_2 &&
4120
2
           seq_params->bit_depth == AOM_BITS_12))) {
4121
2
      aom_internal_error(
4122
2
          error_info, AOM_CODEC_UNSUP_BITSTREAM,
4123
2
          "sRGB colorspace not compatible with specified profile");
4124
2
    }
4125
64.5k
  } else {
4126
    // [16,235] (including xvycc) vs [0,255] range
4127
64.5k
    seq_params->color_range = aom_rb_read_bit(rb);
4128
64.5k
    if (seq_params->profile == PROFILE_0) {
4129
      // 420 only
4130
27.4k
      seq_params->subsampling_x = seq_params->subsampling_y = 1;
4131
37.0k
    } else if (seq_params->profile == PROFILE_1) {
4132
      // 444 only
4133
12.0k
      seq_params->subsampling_x = seq_params->subsampling_y = 0;
4134
24.9k
    } else {
4135
24.9k
      assert(seq_params->profile == PROFILE_2);
4136
23.5k
      if (seq_params->bit_depth == AOM_BITS_12) {
4137
19.0k
        seq_params->subsampling_x = aom_rb_read_bit(rb);
4138
19.0k
        if (seq_params->subsampling_x)
4139
1.67k
          seq_params->subsampling_y = aom_rb_read_bit(rb);  // 422 or 420
4140
17.3k
        else
4141
17.3k
          seq_params->subsampling_y = 0;  // 444
4142
19.0k
      } else {
4143
        // 422
4144
4.58k
        seq_params->subsampling_x = 1;
4145
4.58k
        seq_params->subsampling_y = 0;
4146
4.58k
      }
4147
23.5k
    }
4148
63.1k
    if (seq_params->matrix_coefficients == AOM_CICP_MC_IDENTITY &&
4149
63.1k
        (seq_params->subsampling_x || seq_params->subsampling_y)) {
4150
10
      aom_internal_error(
4151
10
          error_info, AOM_CODEC_UNSUP_BITSTREAM,
4152
10
          "Identity CICP Matrix incompatible with non 4:4:4 color sampling");
4153
10
    }
4154
63.1k
    if (seq_params->subsampling_x && seq_params->subsampling_y) {
4155
27.8k
      seq_params->chroma_sample_position = aom_rb_read_literal(rb, 2);
4156
27.8k
    }
4157
63.1k
  }
4158
63.1k
  seq_params->separate_uv_delta_q = aom_rb_read_bit(rb);
4159
63.1k
}
4160
4161
void av1_read_timing_info_header(aom_timing_info_t *timing_info,
4162
                                 struct aom_internal_error_info *error,
4163
3.66k
                                 struct aom_read_bit_buffer *rb) {
4164
3.66k
  timing_info->num_units_in_display_tick =
4165
3.66k
      aom_rb_read_unsigned_literal(rb,
4166
3.66k
                                   32);  // Number of units in a display tick
4167
3.66k
  timing_info->time_scale = aom_rb_read_unsigned_literal(rb, 32);  // Time scale
4168
3.66k
  if (timing_info->num_units_in_display_tick == 0 ||
4169
3.66k
      timing_info->time_scale == 0) {
4170
196
    aom_internal_error(
4171
196
        error, AOM_CODEC_UNSUP_BITSTREAM,
4172
196
        "num_units_in_display_tick and time_scale must be greater than 0.");
4173
196
  }
4174
3.66k
  timing_info->equal_picture_interval =
4175
3.66k
      aom_rb_read_bit(rb);  // Equal picture interval bit
4176
3.66k
  if (timing_info->equal_picture_interval) {
4177
2.15k
    const uint32_t num_ticks_per_picture_minus_1 = aom_rb_read_uvlc(rb);
4178
2.15k
    if (num_ticks_per_picture_minus_1 == UINT32_MAX) {
4179
28
      aom_internal_error(
4180
28
          error, AOM_CODEC_UNSUP_BITSTREAM,
4181
28
          "num_ticks_per_picture_minus_1 cannot be (1 << 32) - 1.");
4182
28
    }
4183
2.15k
    timing_info->num_ticks_per_picture = num_ticks_per_picture_minus_1 + 1;
4184
2.15k
  }
4185
3.66k
}
4186
4187
void av1_read_decoder_model_info(aom_dec_model_info_t *decoder_model_info,
4188
1.09k
                                 struct aom_read_bit_buffer *rb) {
4189
1.09k
  decoder_model_info->encoder_decoder_buffer_delay_length =
4190
1.09k
      aom_rb_read_literal(rb, 5) + 1;
4191
1.09k
  decoder_model_info->num_units_in_decoding_tick =
4192
1.09k
      aom_rb_read_unsigned_literal(rb,
4193
1.09k
                                   32);  // Number of units in a decoding tick
4194
1.09k
  decoder_model_info->buffer_removal_time_length =
4195
1.09k
      aom_rb_read_literal(rb, 5) + 1;
4196
1.09k
  decoder_model_info->frame_presentation_time_length =
4197
1.09k
      aom_rb_read_literal(rb, 5) + 1;
4198
1.09k
}
4199
4200
void av1_read_op_parameters_info(aom_dec_model_op_parameters_t *op_params,
4201
                                 int buffer_delay_length,
4202
2.06k
                                 struct aom_read_bit_buffer *rb) {
4203
2.06k
  op_params->decoder_buffer_delay =
4204
2.06k
      aom_rb_read_unsigned_literal(rb, buffer_delay_length);
4205
2.06k
  op_params->encoder_buffer_delay =
4206
2.06k
      aom_rb_read_unsigned_literal(rb, buffer_delay_length);
4207
2.06k
  op_params->low_delay_mode_flag = aom_rb_read_bit(rb);
4208
2.06k
}
4209
4210
static inline void read_temporal_point_info(AV1_COMMON *const cm,
4211
2.18k
                                            struct aom_read_bit_buffer *rb) {
4212
2.18k
  cm->frame_presentation_time = aom_rb_read_unsigned_literal(
4213
2.18k
      rb, cm->seq_params->decoder_model_info.frame_presentation_time_length);
4214
2.18k
}
4215
4216
void av1_read_sequence_header(AV1_COMMON *cm, struct aom_read_bit_buffer *rb,
4217
81.2k
                              SequenceHeader *seq_params) {
4218
81.2k
  const int num_bits_width = aom_rb_read_literal(rb, 4) + 1;
4219
81.2k
  const int num_bits_height = aom_rb_read_literal(rb, 4) + 1;
4220
81.2k
  const int max_frame_width = aom_rb_read_literal(rb, num_bits_width) + 1;
4221
81.2k
  const int max_frame_height = aom_rb_read_literal(rb, num_bits_height) + 1;
4222
4223
81.2k
  seq_params->num_bits_width = num_bits_width;
4224
81.2k
  seq_params->num_bits_height = num_bits_height;
4225
81.2k
  seq_params->max_frame_width = max_frame_width;
4226
81.2k
  seq_params->max_frame_height = max_frame_height;
4227
4228
81.2k
  if (seq_params->reduced_still_picture_hdr) {
4229
17.6k
    seq_params->frame_id_numbers_present_flag = 0;
4230
63.6k
  } else {
4231
63.6k
    seq_params->frame_id_numbers_present_flag = aom_rb_read_bit(rb);
4232
63.6k
  }
4233
81.2k
  if (seq_params->frame_id_numbers_present_flag) {
4234
    // We must always have delta_frame_id_length < frame_id_length,
4235
    // in order for a frame to be referenced with a unique delta.
4236
    // Avoid wasting bits by using a coding that enforces this restriction.
4237
17.9k
    seq_params->delta_frame_id_length = aom_rb_read_literal(rb, 4) + 2;
4238
17.9k
    seq_params->frame_id_length =
4239
17.9k
        aom_rb_read_literal(rb, 3) + seq_params->delta_frame_id_length + 1;
4240
17.9k
    if (seq_params->frame_id_length > 16)
4241
452
      aom_internal_error(cm->error, AOM_CODEC_CORRUPT_FRAME,
4242
452
                         "Invalid frame_id_length");
4243
17.9k
  }
4244
4245
81.2k
  setup_sb_size(seq_params, rb);
4246
4247
81.2k
  seq_params->enable_filter_intra = aom_rb_read_bit(rb);
4248
81.2k
  seq_params->enable_intra_edge_filter = aom_rb_read_bit(rb);
4249
4250
81.2k
  if (seq_params->reduced_still_picture_hdr) {
4251
17.6k
    seq_params->enable_interintra_compound = 0;
4252
17.6k
    seq_params->enable_masked_compound = 0;
4253
17.6k
    seq_params->enable_warped_motion = 0;
4254
17.6k
    seq_params->enable_dual_filter = 0;
4255
17.6k
    seq_params->order_hint_info.enable_order_hint = 0;
4256
17.6k
    seq_params->order_hint_info.enable_dist_wtd_comp = 0;
4257
17.6k
    seq_params->order_hint_info.enable_ref_frame_mvs = 0;
4258
17.6k
    seq_params->force_screen_content_tools = 2;  // SELECT_SCREEN_CONTENT_TOOLS
4259
17.6k
    seq_params->force_integer_mv = 2;            // SELECT_INTEGER_MV
4260
17.6k
    seq_params->order_hint_info.order_hint_bits_minus_1 = -1;
4261
63.6k
  } else {
4262
63.6k
    seq_params->enable_interintra_compound = aom_rb_read_bit(rb);
4263
63.6k
    seq_params->enable_masked_compound = aom_rb_read_bit(rb);
4264
63.6k
    seq_params->enable_warped_motion = aom_rb_read_bit(rb);
4265
63.6k
    seq_params->enable_dual_filter = aom_rb_read_bit(rb);
4266
4267
63.6k
    seq_params->order_hint_info.enable_order_hint = aom_rb_read_bit(rb);
4268
63.6k
    seq_params->order_hint_info.enable_dist_wtd_comp =
4269
63.6k
        seq_params->order_hint_info.enable_order_hint ? aom_rb_read_bit(rb) : 0;
4270
63.6k
    seq_params->order_hint_info.enable_ref_frame_mvs =
4271
63.6k
        seq_params->order_hint_info.enable_order_hint ? aom_rb_read_bit(rb) : 0;
4272
4273
63.6k
    if (aom_rb_read_bit(rb)) {
4274
40.2k
      seq_params->force_screen_content_tools =
4275
40.2k
          2;  // SELECT_SCREEN_CONTENT_TOOLS
4276
40.2k
    } else {
4277
23.3k
      seq_params->force_screen_content_tools = aom_rb_read_bit(rb);
4278
23.3k
    }
4279
4280
63.6k
    if (seq_params->force_screen_content_tools > 0) {
4281
58.2k
      if (aom_rb_read_bit(rb)) {
4282
46.3k
        seq_params->force_integer_mv = 2;  // SELECT_INTEGER_MV
4283
46.3k
      } else {
4284
11.9k
        seq_params->force_integer_mv = aom_rb_read_bit(rb);
4285
11.9k
      }
4286
58.2k
    } else {
4287
5.36k
      seq_params->force_integer_mv = 2;  // SELECT_INTEGER_MV
4288
5.36k
    }
4289
63.6k
    seq_params->order_hint_info.order_hint_bits_minus_1 =
4290
63.6k
        seq_params->order_hint_info.enable_order_hint
4291
63.6k
            ? aom_rb_read_literal(rb, 3)
4292
63.6k
            : -1;
4293
63.6k
  }
4294
4295
81.2k
  seq_params->enable_superres = aom_rb_read_bit(rb);
4296
81.2k
  seq_params->enable_cdef = aom_rb_read_bit(rb);
4297
81.2k
  seq_params->enable_restoration = aom_rb_read_bit(rb);
4298
81.2k
}
4299
4300
static int read_global_motion_params(WarpedMotionParams *params,
4301
                                     const WarpedMotionParams *ref_params,
4302
                                     struct aom_read_bit_buffer *rb,
4303
318k
                                     int allow_hp) {
4304
318k
  TransformationType type = aom_rb_read_bit(rb);
4305
318k
  if (type != IDENTITY) {
4306
27.8k
    if (aom_rb_read_bit(rb))
4307
18.4k
      type = ROTZOOM;
4308
9.41k
    else
4309
9.41k
      type = aom_rb_read_bit(rb) ? TRANSLATION : AFFINE;
4310
27.8k
  }
4311
4312
318k
  *params = default_warp_params;
4313
318k
  params->wmtype = type;
4314
4315
318k
  if (type >= ROTZOOM) {
4316
24.5k
    params->wmmat[2] = aom_rb_read_signed_primitive_refsubexpfin(
4317
24.5k
                           rb, GM_ALPHA_MAX + 1, SUBEXPFIN_K,
4318
24.5k
                           (ref_params->wmmat[2] >> GM_ALPHA_PREC_DIFF) -
4319
24.5k
                               (1 << GM_ALPHA_PREC_BITS)) *
4320
24.5k
                           GM_ALPHA_DECODE_FACTOR +
4321
24.5k
                       (1 << WARPEDMODEL_PREC_BITS);
4322
24.5k
    params->wmmat[3] = aom_rb_read_signed_primitive_refsubexpfin(
4323
24.5k
                           rb, GM_ALPHA_MAX + 1, SUBEXPFIN_K,
4324
24.5k
                           (ref_params->wmmat[3] >> GM_ALPHA_PREC_DIFF)) *
4325
24.5k
                       GM_ALPHA_DECODE_FACTOR;
4326
24.5k
  }
4327
4328
318k
  if (type >= AFFINE) {
4329
6.02k
    params->wmmat[4] = aom_rb_read_signed_primitive_refsubexpfin(
4330
6.02k
                           rb, GM_ALPHA_MAX + 1, SUBEXPFIN_K,
4331
6.02k
                           (ref_params->wmmat[4] >> GM_ALPHA_PREC_DIFF)) *
4332
6.02k
                       GM_ALPHA_DECODE_FACTOR;
4333
6.02k
    params->wmmat[5] = aom_rb_read_signed_primitive_refsubexpfin(
4334
6.02k
                           rb, GM_ALPHA_MAX + 1, SUBEXPFIN_K,
4335
6.02k
                           (ref_params->wmmat[5] >> GM_ALPHA_PREC_DIFF) -
4336
6.02k
                               (1 << GM_ALPHA_PREC_BITS)) *
4337
6.02k
                           GM_ALPHA_DECODE_FACTOR +
4338
6.02k
                       (1 << WARPEDMODEL_PREC_BITS);
4339
312k
  } else {
4340
312k
    params->wmmat[4] = -params->wmmat[3];
4341
312k
    params->wmmat[5] = params->wmmat[2];
4342
312k
  }
4343
4344
318k
  if (type >= TRANSLATION) {
4345
27.6k
    const int trans_bits = (type == TRANSLATION)
4346
27.6k
                               ? GM_ABS_TRANS_ONLY_BITS - !allow_hp
4347
27.6k
                               : GM_ABS_TRANS_BITS;
4348
27.6k
    const int trans_dec_factor =
4349
27.6k
        (type == TRANSLATION) ? GM_TRANS_ONLY_DECODE_FACTOR * (1 << !allow_hp)
4350
27.6k
                              : GM_TRANS_DECODE_FACTOR;
4351
27.6k
    const int trans_prec_diff = (type == TRANSLATION)
4352
27.6k
                                    ? GM_TRANS_ONLY_PREC_DIFF + !allow_hp
4353
27.6k
                                    : GM_TRANS_PREC_DIFF;
4354
27.6k
    params->wmmat[0] = aom_rb_read_signed_primitive_refsubexpfin(
4355
27.6k
                           rb, (1 << trans_bits) + 1, SUBEXPFIN_K,
4356
27.6k
                           (ref_params->wmmat[0] >> trans_prec_diff)) *
4357
27.6k
                       trans_dec_factor;
4358
27.6k
    params->wmmat[1] = aom_rb_read_signed_primitive_refsubexpfin(
4359
27.6k
                           rb, (1 << trans_bits) + 1, SUBEXPFIN_K,
4360
27.6k
                           (ref_params->wmmat[1] >> trans_prec_diff)) *
4361
27.6k
                       trans_dec_factor;
4362
27.6k
  }
4363
4364
318k
  int good_shear_params = av1_get_shear_params(params);
4365
318k
  if (!good_shear_params) return 0;
4366
4367
308k
  return 1;
4368
318k
}
4369
4370
static inline void read_global_motion(AV1_COMMON *cm,
4371
46.0k
                                      struct aom_read_bit_buffer *rb) {
4372
364k
  for (int frame = LAST_FRAME; frame <= ALTREF_FRAME; ++frame) {
4373
318k
    const WarpedMotionParams *ref_params =
4374
318k
        cm->prev_frame ? &cm->prev_frame->global_motion[frame]
4375
318k
                       : &default_warp_params;
4376
318k
    int good_params =
4377
318k
        read_global_motion_params(&cm->global_motion[frame], ref_params, rb,
4378
318k
                                  cm->features.allow_high_precision_mv);
4379
318k
    if (!good_params) {
4380
#if WARPED_MOTION_DEBUG
4381
      printf("Warning: unexpected global motion shear params from aomenc\n");
4382
#endif
4383
9.88k
      cm->global_motion[frame].invalid = 1;
4384
9.88k
    }
4385
4386
    // TODO(sarahparker, debargha): The logic in the commented out code below
4387
    // does not work currently and causes mismatches when resize is on. Fix it
4388
    // before turning the optimization back on.
4389
    /*
4390
    YV12_BUFFER_CONFIG *ref_buf = get_ref_frame(cm, frame);
4391
    if (cm->width == ref_buf->y_crop_width &&
4392
        cm->height == ref_buf->y_crop_height) {
4393
      read_global_motion_params(&cm->global_motion[frame],
4394
                                &cm->prev_frame->global_motion[frame], rb,
4395
                                cm->features.allow_high_precision_mv);
4396
    } else {
4397
      cm->global_motion[frame] = default_warp_params;
4398
    }
4399
    */
4400
    /*
4401
    printf("Dec Ref %d [%d/%d]: %d %d %d %d\n",
4402
           frame, cm->current_frame.frame_number, cm->show_frame,
4403
           cm->global_motion[frame].wmmat[0],
4404
           cm->global_motion[frame].wmmat[1],
4405
           cm->global_motion[frame].wmmat[2],
4406
           cm->global_motion[frame].wmmat[3]);
4407
           */
4408
318k
  }
4409
46.0k
  memcpy(cm->cur_frame->global_motion, cm->global_motion,
4410
46.0k
         REF_FRAMES * sizeof(WarpedMotionParams));
4411
46.0k
}
4412
4413
// Release the references to the frame buffers in cm->ref_frame_map and reset
4414
// all elements of cm->ref_frame_map to NULL.
4415
140k
static inline void reset_ref_frame_map(AV1_COMMON *const cm) {
4416
140k
  BufferPool *const pool = cm->buffer_pool;
4417
4418
1.26M
  for (int i = 0; i < REF_FRAMES; i++) {
4419
1.12M
    decrease_ref_count(cm->ref_frame_map[i], pool);
4420
1.12M
    cm->ref_frame_map[i] = NULL;
4421
1.12M
  }
4422
140k
}
4423
4424
// If the refresh_frame_flags bitmask is set, update reference frame id values
4425
// and mark frames as valid for reference.
4426
202k
static inline void update_ref_frame_id(AV1Decoder *const pbi) {
4427
202k
  AV1_COMMON *const cm = &pbi->common;
4428
202k
  int refresh_frame_flags = cm->current_frame.refresh_frame_flags;
4429
1.82M
  for (int i = 0; i < REF_FRAMES; i++) {
4430
1.62M
    if ((refresh_frame_flags >> i) & 1) {
4431
842k
      cm->ref_frame_id[i] = cm->current_frame_id;
4432
842k
      pbi->valid_for_referencing[i] = 1;
4433
842k
    }
4434
1.62M
  }
4435
202k
}
4436
4437
static inline void show_existing_frame_reset(AV1Decoder *const pbi,
4438
176
                                             int existing_frame_idx) {
4439
176
  AV1_COMMON *const cm = &pbi->common;
4440
4441
176
  assert(cm->show_existing_frame);
4442
4443
176
  cm->current_frame.frame_type = KEY_FRAME;
4444
4445
176
  cm->current_frame.refresh_frame_flags = (1 << REF_FRAMES) - 1;
4446
4447
1.40k
  for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
4448
1.23k
    cm->remapped_ref_idx[i] = INVALID_IDX;
4449
1.23k
  }
4450
4451
176
  if (pbi->need_resync) {
4452
105
    reset_ref_frame_map(cm);
4453
105
    pbi->need_resync = 0;
4454
105
  }
4455
4456
  // Note that the displayed frame must be valid for referencing in order to
4457
  // have been selected.
4458
176
  cm->current_frame_id = cm->ref_frame_id[existing_frame_idx];
4459
176
  update_ref_frame_id(pbi);
4460
4461
176
  cm->features.refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED;
4462
176
}
4463
4464
27.5k
static inline void reset_frame_buffers(AV1_COMMON *cm) {
4465
27.5k
  RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs;
4466
27.5k
  int i;
4467
4468
27.5k
  lock_buffer_pool(cm->buffer_pool);
4469
27.5k
  reset_ref_frame_map(cm);
4470
27.5k
  assert(cm->cur_frame->ref_count == 1);
4471
468k
  for (i = 0; i < cm->buffer_pool->num_frame_bufs; ++i) {
4472
    // Reset all unreferenced frame buffers. We can also reset cm->cur_frame
4473
    // because we are the sole owner of cm->cur_frame.
4474
441k
    if (frame_bufs[i].ref_count > 0 && &frame_bufs[i] != cm->cur_frame) {
4475
5.04k
      continue;
4476
5.04k
    }
4477
436k
    frame_bufs[i].order_hint = 0;
4478
436k
    av1_zero(frame_bufs[i].ref_order_hints);
4479
436k
  }
4480
27.5k
  av1_zero_unused_internal_frame_buffers(&cm->buffer_pool->int_frame_buffers);
4481
27.5k
  unlock_buffer_pool(cm->buffer_pool);
4482
27.5k
}
4483
4484
// On success, returns 0. On failure, calls aom_internal_error and does not
4485
// return.
4486
static int read_uncompressed_header(AV1Decoder *pbi,
4487
251k
                                    struct aom_read_bit_buffer *rb) {
4488
251k
  AV1_COMMON *const cm = &pbi->common;
4489
251k
  const SequenceHeader *const seq_params = cm->seq_params;
4490
251k
  CurrentFrame *const current_frame = &cm->current_frame;
4491
251k
  FeatureFlags *const features = &cm->features;
4492
251k
  MACROBLOCKD *const xd = &pbi->dcb.xd;
4493
251k
  BufferPool *const pool = cm->buffer_pool;
4494
251k
  RefCntBuffer *const frame_bufs = pool->frame_bufs;
4495
251k
  aom_s_frame_info *sframe_info = &pbi->sframe_info;
4496
251k
  sframe_info->is_s_frame = 0;
4497
251k
  sframe_info->is_s_frame_at_altref = 0;
4498
4499
251k
  if (!pbi->sequence_header_ready) {
4500
817
    aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
4501
817
                       "No sequence header");
4502
817
  }
4503
4504
251k
  if (seq_params->reduced_still_picture_hdr) {
4505
37.3k
    cm->show_existing_frame = 0;
4506
37.3k
    cm->show_frame = 1;
4507
37.3k
    current_frame->frame_type = KEY_FRAME;
4508
37.3k
    if (pbi->sequence_header_changed) {
4509
      // This is the start of a new coded video sequence.
4510
6.01k
      pbi->sequence_header_changed = 0;
4511
6.01k
      pbi->decoding_first_frame = 1;
4512
6.01k
      reset_frame_buffers(cm);
4513
6.01k
    }
4514
37.3k
    features->error_resilient_mode = 1;
4515
214k
  } else {
4516
214k
    cm->show_existing_frame = aom_rb_read_bit(rb);
4517
214k
    pbi->reset_decoder_state = 0;
4518
4519
214k
    if (cm->show_existing_frame) {
4520
11.7k
      if (pbi->sequence_header_changed) {
4521
563
        aom_internal_error(
4522
563
            &pbi->error, AOM_CODEC_CORRUPT_FRAME,
4523
563
            "New sequence header starts with a show_existing_frame.");
4524
563
      }
4525
      // Show an existing frame directly.
4526
11.7k
      const int existing_frame_idx = aom_rb_read_literal(rb, 3);
4527
11.7k
      RefCntBuffer *const frame_to_show = cm->ref_frame_map[existing_frame_idx];
4528
11.7k
      if (frame_to_show == NULL) {
4529
6.09k
        aom_internal_error(&pbi->error, AOM_CODEC_UNSUP_BITSTREAM,
4530
6.09k
                           "Buffer does not contain a decoded frame");
4531
6.09k
      }
4532
11.7k
      if (seq_params->decoder_model_info_present_flag &&
4533
11.7k
          seq_params->timing_info.equal_picture_interval == 0) {
4534
111
        read_temporal_point_info(cm, rb);
4535
111
      }
4536
11.7k
      if (seq_params->frame_id_numbers_present_flag) {
4537
4.23k
        int frame_id_length = seq_params->frame_id_length;
4538
4.23k
        int display_frame_id = aom_rb_read_literal(rb, frame_id_length);
4539
        /* Compare display_frame_id with ref_frame_id and check valid for
4540
         * referencing */
4541
4.23k
        if (display_frame_id != cm->ref_frame_id[existing_frame_idx] ||
4542
4.23k
            pbi->valid_for_referencing[existing_frame_idx] == 0)
4543
3.47k
          aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
4544
3.47k
                             "Reference buffer frame ID mismatch");
4545
4.23k
      }
4546
11.7k
      lock_buffer_pool(pool);
4547
11.7k
      assert(frame_to_show->ref_count > 0);
4548
      // cm->cur_frame should be the buffer referenced by the return value
4549
      // of the get_free_fb() call in assign_cur_frame_new_fb() (called by
4550
      // av1_receive_compressed_data()), so the ref_count should be 1.
4551
1.60k
      assert(cm->cur_frame->ref_count == 1);
4552
      // assign_frame_buffer_p() decrements ref_count directly rather than
4553
      // call decrease_ref_count(). If cm->cur_frame->raw_frame_buffer has
4554
      // already been allocated, it will not be released by
4555
      // assign_frame_buffer_p()!
4556
1.60k
      assert(!cm->cur_frame->raw_frame_buffer.data);
4557
1.60k
      assign_frame_buffer_p(&cm->cur_frame, frame_to_show);
4558
1.60k
      pbi->reset_decoder_state = frame_to_show->frame_type == KEY_FRAME;
4559
1.60k
      unlock_buffer_pool(pool);
4560
4561
1.60k
      cm->lf.filter_level[0] = 0;
4562
1.60k
      cm->lf.filter_level[1] = 0;
4563
1.60k
      cm->show_frame = 1;
4564
1.60k
      current_frame->order_hint = frame_to_show->order_hint;
4565
4566
      // Section 6.8.2: It is a requirement of bitstream conformance that when
4567
      // show_existing_frame is used to show a previous frame, that the value
4568
      // of showable_frame for the previous frame was equal to 1.
4569
1.60k
      if (!frame_to_show->showable_frame) {
4570
793
        aom_internal_error(&pbi->error, AOM_CODEC_UNSUP_BITSTREAM,
4571
793
                           "Buffer does not contain a showable frame");
4572
793
      }
4573
      // Section 6.8.2: It is a requirement of bitstream conformance that when
4574
      // show_existing_frame is used to show a previous frame with
4575
      // RefFrameType[ frame_to_show_map_idx ] equal to KEY_FRAME, that the
4576
      // frame is output via the show_existing_frame mechanism at most once.
4577
1.60k
      if (pbi->reset_decoder_state) frame_to_show->showable_frame = 0;
4578
4579
1.60k
      cm->film_grain_params = frame_to_show->film_grain_params;
4580
4581
1.60k
      if (pbi->reset_decoder_state) {
4582
176
        show_existing_frame_reset(pbi, existing_frame_idx);
4583
1.42k
      } else {
4584
1.42k
        current_frame->refresh_frame_flags = 0;
4585
1.42k
      }
4586
4587
1.60k
      return 0;
4588
1.60k
    }
4589
4590
202k
    current_frame->frame_type = (FRAME_TYPE)aom_rb_read_literal(rb, 2);
4591
202k
    if (pbi->sequence_header_changed) {
4592
24.3k
      if (current_frame->frame_type == KEY_FRAME) {
4593
        // This is the start of a new coded video sequence.
4594
21.5k
        pbi->sequence_header_changed = 0;
4595
21.5k
        pbi->decoding_first_frame = 1;
4596
21.5k
        reset_frame_buffers(cm);
4597
21.5k
      } else {
4598
2.74k
        aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
4599
2.74k
                           "Sequence header has changed without a keyframe.");
4600
2.74k
      }
4601
24.3k
    }
4602
4603
202k
    cm->show_frame = aom_rb_read_bit(rb);
4604
202k
    if (cm->show_frame == 0) pbi->is_arf_frame_present = 1;
4605
202k
    if (cm->show_frame == 0 && cm->current_frame.frame_type == KEY_FRAME)
4606
48.6k
      pbi->is_fwd_kf_present = 1;
4607
202k
    if (cm->current_frame.frame_type == S_FRAME) {
4608
167
      sframe_info->is_s_frame = 1;
4609
167
      sframe_info->is_s_frame_at_altref = cm->show_frame ? 0 : 1;
4610
167
    }
4611
202k
    if (seq_params->still_picture &&
4612
202k
        (current_frame->frame_type != KEY_FRAME || !cm->show_frame)) {
4613
320
      aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
4614
320
                         "Still pictures must be coded as shown keyframes");
4615
320
    }
4616
202k
    cm->showable_frame = current_frame->frame_type != KEY_FRAME;
4617
202k
    if (cm->show_frame) {
4618
129k
      if (seq_params->decoder_model_info_present_flag &&
4619
129k
          seq_params->timing_info.equal_picture_interval == 0)
4620
2.07k
        read_temporal_point_info(cm, rb);
4621
129k
    } else {
4622
      // See if this frame can be used as show_existing_frame in future
4623
73.1k
      cm->showable_frame = aom_rb_read_bit(rb);
4624
73.1k
    }
4625
202k
    cm->cur_frame->showable_frame = cm->showable_frame;
4626
202k
    features->error_resilient_mode =
4627
202k
        frame_is_sframe(cm) ||
4628
202k
                (current_frame->frame_type == KEY_FRAME && cm->show_frame)
4629
202k
            ? 1
4630
202k
            : aom_rb_read_bit(rb);
4631
202k
  }
4632
4633
240k
  if (current_frame->frame_type == KEY_FRAME && cm->show_frame) {
4634
    /* All frames need to be marked as not valid for referencing */
4635
589k
    for (int i = 0; i < REF_FRAMES; i++) {
4636
523k
      pbi->valid_for_referencing[i] = 0;
4637
523k
    }
4638
65.4k
  }
4639
240k
  features->disable_cdf_update = aom_rb_read_bit(rb);
4640
240k
  if (seq_params->force_screen_content_tools == 2) {
4641
176k
    features->allow_screen_content_tools = aom_rb_read_bit(rb);
4642
176k
  } else {
4643
64.0k
    features->allow_screen_content_tools =
4644
64.0k
        seq_params->force_screen_content_tools;
4645
64.0k
  }
4646
4647
240k
  if (features->allow_screen_content_tools) {
4648
119k
    if (seq_params->force_integer_mv == 2) {
4649
87.4k
      features->cur_frame_force_integer_mv = aom_rb_read_bit(rb);
4650
87.4k
    } else {
4651
31.8k
      features->cur_frame_force_integer_mv = seq_params->force_integer_mv;
4652
31.8k
    }
4653
120k
  } else {
4654
120k
    features->cur_frame_force_integer_mv = 0;
4655
120k
  }
4656
4657
240k
  int frame_size_override_flag = 0;
4658
240k
  features->allow_intrabc = 0;
4659
240k
  features->primary_ref_frame = PRIMARY_REF_NONE;
4660
4661
240k
  if (!seq_params->reduced_still_picture_hdr) {
4662
198k
    if (seq_params->frame_id_numbers_present_flag) {
4663
34.9k
      int frame_id_length = seq_params->frame_id_length;
4664
34.9k
      int diff_len = seq_params->delta_frame_id_length;
4665
34.9k
      int prev_frame_id = 0;
4666
34.9k
      int have_prev_frame_id =
4667
34.9k
          !pbi->decoding_first_frame &&
4668
34.9k
          !(current_frame->frame_type == KEY_FRAME && cm->show_frame);
4669
34.9k
      if (have_prev_frame_id) {
4670
7.05k
        prev_frame_id = cm->current_frame_id;
4671
7.05k
      }
4672
34.9k
      cm->current_frame_id = aom_rb_read_literal(rb, frame_id_length);
4673
4674
34.9k
      if (have_prev_frame_id) {
4675
7.05k
        int diff_frame_id;
4676
7.05k
        if (cm->current_frame_id > prev_frame_id) {
4677
2.67k
          diff_frame_id = cm->current_frame_id - prev_frame_id;
4678
4.37k
        } else {
4679
4.37k
          diff_frame_id =
4680
4.37k
              (1 << frame_id_length) + cm->current_frame_id - prev_frame_id;
4681
4.37k
        }
4682
        /* Check current_frame_id for conformance */
4683
7.05k
        if (prev_frame_id == cm->current_frame_id ||
4684
7.05k
            diff_frame_id >= (1 << (frame_id_length - 1))) {
4685
4.30k
          aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
4686
4.30k
                             "Invalid value of current_frame_id");
4687
4.30k
        }
4688
7.05k
      }
4689
      /* Check if some frames need to be marked as not valid for referencing */
4690
279k
      for (int i = 0; i < REF_FRAMES; i++) {
4691
244k
        if (cm->current_frame_id - (1 << diff_len) > 0) {
4692
123k
          if (cm->ref_frame_id[i] > cm->current_frame_id ||
4693
123k
              cm->ref_frame_id[i] < cm->current_frame_id - (1 << diff_len))
4694
83.7k
            pbi->valid_for_referencing[i] = 0;
4695
123k
        } else {
4696
121k
          if (cm->ref_frame_id[i] > cm->current_frame_id &&
4697
121k
              cm->ref_frame_id[i] < (1 << frame_id_length) +
4698
50.5k
                                        cm->current_frame_id - (1 << diff_len))
4699
40.9k
            pbi->valid_for_referencing[i] = 0;
4700
121k
        }
4701
244k
      }
4702
34.9k
    }
4703
4704
198k
    frame_size_override_flag = frame_is_sframe(cm) ? 1 : aom_rb_read_bit(rb);
4705
4706
198k
    current_frame->order_hint = aom_rb_read_literal(
4707
198k
        rb, seq_params->order_hint_info.order_hint_bits_minus_1 + 1);
4708
4709
198k
    if (seq_params->order_hint_info.enable_order_hint)
4710
171k
      current_frame->frame_number = current_frame->order_hint;
4711
4712
198k
    if (!features->error_resilient_mode && !frame_is_intra_only(cm)) {
4713
72.7k
      features->primary_ref_frame = aom_rb_read_literal(rb, PRIMARY_REF_BITS);
4714
72.7k
    }
4715
198k
  }
4716
4717
240k
  if (seq_params->decoder_model_info_present_flag) {
4718
19.9k
    pbi->buffer_removal_time_present = aom_rb_read_bit(rb);
4719
19.9k
    if (pbi->buffer_removal_time_present) {
4720
4.05k
      for (int op_num = 0;
4721
21.3k
           op_num < seq_params->operating_points_cnt_minus_1 + 1; op_num++) {
4722
17.2k
        if (seq_params->op_params[op_num].decoder_model_param_present_flag) {
4723
7.03k
          if (seq_params->operating_point_idc[op_num] == 0 ||
4724
7.03k
              (((seq_params->operating_point_idc[op_num] >>
4725
6.85k
                 cm->temporal_layer_id) &
4726
6.85k
                0x1) &&
4727
6.85k
               ((seq_params->operating_point_idc[op_num] >>
4728
3.65k
                 (cm->spatial_layer_id + 8)) &
4729
3.65k
                0x1))) {
4730
2.43k
            cm->buffer_removal_times[op_num] = aom_rb_read_unsigned_literal(
4731
2.43k
                rb, seq_params->decoder_model_info.buffer_removal_time_length);
4732
4.59k
          } else {
4733
4.59k
            cm->buffer_removal_times[op_num] = 0;
4734
4.59k
          }
4735
10.2k
        } else {
4736
10.2k
          cm->buffer_removal_times[op_num] = 0;
4737
10.2k
        }
4738
17.2k
      }
4739
4.05k
    }
4740
19.9k
  }
4741
240k
  if (current_frame->frame_type == KEY_FRAME) {
4742
113k
    if (!cm->show_frame) {  // unshown keyframe (forward keyframe)
4743
47.6k
      current_frame->refresh_frame_flags = aom_rb_read_literal(rb, REF_FRAMES);
4744
65.4k
    } else {  // shown keyframe
4745
65.4k
      current_frame->refresh_frame_flags = (1 << REF_FRAMES) - 1;
4746
65.4k
    }
4747
4748
904k
    for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
4749
791k
      cm->remapped_ref_idx[i] = INVALID_IDX;
4750
791k
    }
4751
113k
    if (pbi->need_resync) {
4752
85.3k
      reset_ref_frame_map(cm);
4753
85.3k
      pbi->need_resync = 0;
4754
85.3k
    }
4755
127k
  } else {
4756
127k
    if (current_frame->frame_type == INTRA_ONLY_FRAME) {
4757
35.8k
      current_frame->refresh_frame_flags = aom_rb_read_literal(rb, REF_FRAMES);
4758
35.8k
      if (current_frame->refresh_frame_flags == 0xFF) {
4759
815
        aom_internal_error(&pbi->error, AOM_CODEC_UNSUP_BITSTREAM,
4760
815
                           "Intra only frames cannot have refresh flags 0xFF");
4761
815
      }
4762
35.8k
      if (pbi->need_resync) {
4763
27.8k
        reset_ref_frame_map(cm);
4764
27.8k
        pbi->need_resync = 0;
4765
27.8k
      }
4766
91.3k
    } else if (pbi->need_resync != 1) { /* Skip if need resync */
4767
60.4k
      current_frame->refresh_frame_flags =
4768
60.4k
          frame_is_sframe(cm) ? 0xFF : aom_rb_read_literal(rb, REF_FRAMES);
4769
60.4k
    }
4770
127k
  }
4771
4772
240k
  if (!frame_is_intra_only(cm) || current_frame->refresh_frame_flags != 0xFF) {
4773
    // Read all ref frame order hints if error_resilient_mode == 1
4774
165k
    if (features->error_resilient_mode &&
4775
165k
        seq_params->order_hint_info.enable_order_hint) {
4776
364k
      for (int ref_idx = 0; ref_idx < REF_FRAMES; ref_idx++) {
4777
        // Read order hint from bit stream
4778
323k
        unsigned int order_hint = aom_rb_read_literal(
4779
323k
            rb, seq_params->order_hint_info.order_hint_bits_minus_1 + 1);
4780
        // Get buffer
4781
323k
        RefCntBuffer *buf = cm->ref_frame_map[ref_idx];
4782
323k
        if (buf == NULL || order_hint != buf->order_hint) {
4783
277k
          if (buf != NULL) {
4784
73.4k
            lock_buffer_pool(pool);
4785
73.4k
            decrease_ref_count(buf, pool);
4786
73.4k
            unlock_buffer_pool(pool);
4787
73.4k
            cm->ref_frame_map[ref_idx] = NULL;
4788
73.4k
          }
4789
          // If no corresponding buffer exists, allocate a new buffer with all
4790
          // pixels set to neutral grey.
4791
277k
          int buf_idx = get_free_fb(cm);
4792
277k
          if (buf_idx == INVALID_IDX) {
4793
0
            aom_internal_error(&pbi->error, AOM_CODEC_MEM_ERROR,
4794
0
                               "Unable to find free frame buffer");
4795
0
          }
4796
277k
          buf = &frame_bufs[buf_idx];
4797
277k
          lock_buffer_pool(pool);
4798
277k
#if CONFIG_SIZE_LIMIT
4799
277k
          if (seq_params->max_frame_width > DECODE_WIDTH_LIMIT ||
4800
277k
              seq_params->max_frame_height > DECODE_HEIGHT_LIMIT) {
4801
145
            decrease_ref_count(buf, pool);
4802
145
            unlock_buffer_pool(pool);
4803
145
            aom_internal_error(
4804
145
                cm->error, AOM_CODEC_CORRUPT_FRAME,
4805
145
                "Dimensions of %dx%d beyond allowed size of %dx%d.",
4806
145
                seq_params->max_frame_width, seq_params->max_frame_height,
4807
145
                DECODE_WIDTH_LIMIT, DECODE_HEIGHT_LIMIT);
4808
145
          }
4809
277k
#endif
4810
277k
          if (aom_realloc_frame_buffer(
4811
277k
                  &buf->buf, seq_params->max_frame_width,
4812
277k
                  seq_params->max_frame_height, seq_params->subsampling_x,
4813
277k
                  seq_params->subsampling_y, seq_params->use_highbitdepth,
4814
277k
                  AOM_BORDER_IN_PIXELS, features->byte_alignment,
4815
277k
                  &buf->raw_frame_buffer, pool->get_fb_cb, pool->cb_priv, false,
4816
277k
                  0)) {
4817
322
            decrease_ref_count(buf, pool);
4818
322
            unlock_buffer_pool(pool);
4819
322
            aom_internal_error(&pbi->error, AOM_CODEC_MEM_ERROR,
4820
322
                               "Failed to allocate frame buffer");
4821
322
          }
4822
277k
          unlock_buffer_pool(pool);
4823
          // According to the specification, valid bitstreams are required to
4824
          // never use missing reference frames so the filling process for
4825
          // missing frames is not normatively defined and RefValid for missing
4826
          // frames is set to 0.
4827
4828
          // To make libaom more robust when the bitstream has been corrupted
4829
          // by the loss of some frames of data, this code adds a neutral grey
4830
          // buffer in place of missing frames, i.e.
4831
          //
4832
277k
          set_planes_to_neutral_grey(seq_params, &buf->buf, 0);
4833
          //
4834
          // and allows the frames to be used for referencing, i.e.
4835
          //
4836
277k
          pbi->valid_for_referencing[ref_idx] = 1;
4837
          //
4838
          // Please note such behavior is not normative and other decoders may
4839
          // use a different approach.
4840
277k
          cm->ref_frame_map[ref_idx] = buf;
4841
277k
          buf->order_hint = order_hint;
4842
277k
        }
4843
323k
      }
4844
40.8k
    }
4845
165k
  }
4846
4847
240k
  if (current_frame->frame_type == KEY_FRAME) {
4848
113k
    setup_frame_size(cm, frame_size_override_flag, rb);
4849
4850
113k
    if (features->allow_screen_content_tools && !av1_superres_scaled(cm))
4851
56.8k
      features->allow_intrabc = aom_rb_read_bit(rb);
4852
113k
    features->allow_ref_frame_mvs = 0;
4853
113k
    cm->prev_frame = NULL;
4854
127k
  } else {
4855
127k
    features->allow_ref_frame_mvs = 0;
4856
4857
127k
    if (current_frame->frame_type == INTRA_ONLY_FRAME) {
4858
34.5k
      cm->cur_frame->film_grain_params_present =
4859
34.5k
          seq_params->film_grain_params_present;
4860
34.5k
      setup_frame_size(cm, frame_size_override_flag, rb);
4861
34.5k
      if (features->allow_screen_content_tools && !av1_superres_scaled(cm))
4862
27.4k
        features->allow_intrabc = aom_rb_read_bit(rb);
4863
4864
92.6k
    } else if (pbi->need_resync != 1) { /* Skip if need resync */
4865
60.4k
      int frame_refs_short_signaling = 0;
4866
      // Frame refs short signaling is off when error resilient mode is on.
4867
60.4k
      if (seq_params->order_hint_info.enable_order_hint)
4868
59.9k
        frame_refs_short_signaling = aom_rb_read_bit(rb);
4869
4870
60.4k
      if (frame_refs_short_signaling) {
4871
        // == LAST_FRAME ==
4872
25.6k
        const int lst_ref = aom_rb_read_literal(rb, REF_FRAMES_LOG2);
4873
25.6k
        const RefCntBuffer *const lst_buf = cm->ref_frame_map[lst_ref];
4874
4875
        // == GOLDEN_FRAME ==
4876
25.6k
        const int gld_ref = aom_rb_read_literal(rb, REF_FRAMES_LOG2);
4877
25.6k
        const RefCntBuffer *const gld_buf = cm->ref_frame_map[gld_ref];
4878
4879
        // Most of the time, streams start with a keyframe. In that case,
4880
        // ref_frame_map will have been filled in at that point and will not
4881
        // contain any NULLs. However, streams are explicitly allowed to start
4882
        // with an intra-only frame, so long as they don't then signal a
4883
        // reference to a slot that hasn't been set yet. That's what we are
4884
        // checking here.
4885
25.6k
        if (lst_buf == NULL)
4886
86
          aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
4887
86
                             "Inter frame requests nonexistent reference");
4888
25.6k
        if (gld_buf == NULL)
4889
23
          aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
4890
23
                             "Inter frame requests nonexistent reference");
4891
4892
25.6k
        av1_set_frame_refs(cm, cm->remapped_ref_idx, lst_ref, gld_ref);
4893
25.6k
      }
4894
4895
475k
      for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
4896
415k
        int ref = 0;
4897
415k
        if (!frame_refs_short_signaling) {
4898
240k
          ref = aom_rb_read_literal(rb, REF_FRAMES_LOG2);
4899
4900
          // Most of the time, streams start with a keyframe. In that case,
4901
          // ref_frame_map will have been filled in at that point and will not
4902
          // contain any NULLs. However, streams are explicitly allowed to start
4903
          // with an intra-only frame, so long as they don't then signal a
4904
          // reference to a slot that hasn't been set yet. That's what we are
4905
          // checking here.
4906
240k
          if (cm->ref_frame_map[ref] == NULL)
4907
460
            aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
4908
460
                               "Inter frame requests nonexistent reference");
4909
240k
          cm->remapped_ref_idx[i] = ref;
4910
240k
        } else {
4911
175k
          ref = cm->remapped_ref_idx[i];
4912
175k
        }
4913
        // Check valid for referencing
4914
415k
        if (pbi->valid_for_referencing[ref] == 0)
4915
62
          aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
4916
62
                             "Reference frame not valid for referencing");
4917
4918
415k
        cm->ref_frame_sign_bias[LAST_FRAME + i] = 0;
4919
4920
415k
        if (seq_params->frame_id_numbers_present_flag) {
4921
119
          int frame_id_length = seq_params->frame_id_length;
4922
119
          int diff_len = seq_params->delta_frame_id_length;
4923
119
          int delta_frame_id_minus_1 = aom_rb_read_literal(rb, diff_len);
4924
119
          int ref_frame_id =
4925
119
              ((cm->current_frame_id - (delta_frame_id_minus_1 + 1) +
4926
119
                (1 << frame_id_length)) %
4927
119
               (1 << frame_id_length));
4928
          // Compare values derived from delta_frame_id_minus_1 and
4929
          // refresh_frame_flags.
4930
119
          if (ref_frame_id != cm->ref_frame_id[ref])
4931
105
            aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
4932
105
                               "Reference buffer frame ID mismatch");
4933
119
        }
4934
415k
      }
4935
4936
60.4k
      if (!features->error_resilient_mode && frame_size_override_flag) {
4937
38.8k
        setup_frame_size_with_refs(cm, rb);
4938
38.8k
      } else {
4939
21.5k
        setup_frame_size(cm, frame_size_override_flag, rb);
4940
21.5k
      }
4941
4942
60.4k
      if (features->cur_frame_force_integer_mv) {
4943
7.42k
        features->allow_high_precision_mv = 0;
4944
52.9k
      } else {
4945
52.9k
        features->allow_high_precision_mv = aom_rb_read_bit(rb);
4946
52.9k
      }
4947
60.4k
      features->interp_filter = read_frame_interp_filter(rb);
4948
60.4k
      features->switchable_motion_mode = aom_rb_read_bit(rb);
4949
60.4k
    }
4950
4951
127k
    cm->prev_frame = get_primary_ref_frame_buf(cm);
4952
127k
    if (features->primary_ref_frame != PRIMARY_REF_NONE &&
4953
127k
        get_primary_ref_frame_buf(cm) == NULL) {
4954
10.1k
      aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
4955
10.1k
                         "Reference frame containing this frame's initial "
4956
10.1k
                         "frame context is unavailable.");
4957
10.1k
    }
4958
4959
127k
    if (!(current_frame->frame_type == INTRA_ONLY_FRAME) &&
4960
127k
        pbi->need_resync != 1) {
4961
53.0k
      if (frame_might_allow_ref_frame_mvs(cm))
4962
44.8k
        features->allow_ref_frame_mvs = aom_rb_read_bit(rb);
4963
8.19k
      else
4964
8.19k
        features->allow_ref_frame_mvs = 0;
4965
4966
396k
      for (int i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
4967
342k
        const RefCntBuffer *const ref_buf = get_ref_frame_buf(cm, i);
4968
342k
        struct scale_factors *const ref_scale_factors =
4969
342k
            get_ref_scale_factors(cm, i);
4970
342k
        av1_setup_scale_factors_for_frame(
4971
342k
            ref_scale_factors, ref_buf->buf.y_crop_width,
4972
342k
            ref_buf->buf.y_crop_height, cm->width, cm->height);
4973
342k
        if ((!av1_is_valid_scale(ref_scale_factors)))
4974
6.81k
          aom_internal_error(&pbi->error, AOM_CODEC_UNSUP_BITSTREAM,
4975
6.81k
                             "Reference frame has invalid dimensions");
4976
342k
      }
4977
53.0k
    }
4978
127k
  }
4979
4980
240k
  av1_setup_frame_buf_refs(cm);
4981
4982
240k
  av1_setup_frame_sign_bias(cm);
4983
4984
240k
  cm->cur_frame->frame_type = current_frame->frame_type;
4985
4986
240k
  update_ref_frame_id(pbi);
4987
4988
240k
  const int might_bwd_adapt = !(seq_params->reduced_still_picture_hdr) &&
4989
240k
                              !(features->disable_cdf_update);
4990
240k
  if (might_bwd_adapt) {
4991
136k
    features->refresh_frame_context = aom_rb_read_bit(rb)
4992
136k
                                          ? REFRESH_FRAME_CONTEXT_DISABLED
4993
136k
                                          : REFRESH_FRAME_CONTEXT_BACKWARD;
4994
136k
  } else {
4995
103k
    features->refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED;
4996
103k
  }
4997
4998
240k
  cm->cur_frame->buf.bit_depth = seq_params->bit_depth;
4999
240k
  cm->cur_frame->buf.color_primaries = seq_params->color_primaries;
5000
240k
  cm->cur_frame->buf.transfer_characteristics =
5001
240k
      seq_params->transfer_characteristics;
5002
240k
  cm->cur_frame->buf.matrix_coefficients = seq_params->matrix_coefficients;
5003
240k
  cm->cur_frame->buf.monochrome = seq_params->monochrome;
5004
240k
  cm->cur_frame->buf.chroma_sample_position =
5005
240k
      seq_params->chroma_sample_position;
5006
240k
  cm->cur_frame->buf.color_range = seq_params->color_range;
5007
240k
  cm->cur_frame->buf.render_width = cm->render_width;
5008
240k
  cm->cur_frame->buf.render_height = cm->render_height;
5009
5010
240k
  if (pbi->need_resync) {
5011
12.3k
    aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
5012
12.3k
                       "Keyframe / intra-only frame required to reset decoder"
5013
12.3k
                       " state");
5014
12.3k
  }
5015
5016
240k
  if (features->allow_intrabc) {
5017
    // Set parameters corresponding to no filtering.
5018
44.6k
    struct loopfilter *lf = &cm->lf;
5019
44.6k
    lf->filter_level[0] = 0;
5020
44.6k
    lf->filter_level[1] = 0;
5021
44.6k
    cm->cdef_info.cdef_bits = 0;
5022
44.6k
    cm->cdef_info.cdef_strengths[0] = 0;
5023
44.6k
    cm->cdef_info.nb_cdef_strengths = 1;
5024
44.6k
    cm->cdef_info.cdef_uv_strengths[0] = 0;
5025
44.6k
    cm->rst_info[0].frame_restoration_type = RESTORE_NONE;
5026
44.6k
    cm->rst_info[1].frame_restoration_type = RESTORE_NONE;
5027
44.6k
    cm->rst_info[2].frame_restoration_type = RESTORE_NONE;
5028
44.6k
  }
5029
5030
240k
  read_tile_info(pbi, rb);
5031
240k
  if (!av1_is_min_tile_width_satisfied(cm)) {
5032
107
    aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
5033
107
                       "Minimum tile width requirement not satisfied");
5034
107
  }
5035
5036
240k
  CommonQuantParams *const quant_params = &cm->quant_params;
5037
240k
  setup_quantization(quant_params, av1_num_planes(cm),
5038
240k
                     cm->seq_params->separate_uv_delta_q, rb);
5039
240k
  xd->bd = (int)seq_params->bit_depth;
5040
5041
240k
  CommonContexts *const above_contexts = &cm->above_contexts;
5042
240k
  if (above_contexts->num_planes < av1_num_planes(cm) ||
5043
240k
      above_contexts->num_mi_cols < cm->mi_params.mi_cols ||
5044
240k
      above_contexts->num_tile_rows < cm->tiles.rows) {
5045
19.2k
    av1_free_above_context_buffers(above_contexts);
5046
19.2k
    if (av1_alloc_above_context_buffers(above_contexts, cm->tiles.rows,
5047
19.2k
                                        cm->mi_params.mi_cols,
5048
19.2k
                                        av1_num_planes(cm))) {
5049
0
      aom_internal_error(&pbi->error, AOM_CODEC_MEM_ERROR,
5050
0
                         "Failed to allocate context buffers");
5051
0
    }
5052
19.2k
  }
5053
5054
240k
  if (features->primary_ref_frame == PRIMARY_REF_NONE) {
5055
150k
    av1_setup_past_independence(cm);
5056
150k
  }
5057
5058
240k
  setup_segmentation(cm, rb);
5059
5060
240k
  cm->delta_q_info.delta_q_res = 1;
5061
240k
  cm->delta_q_info.delta_lf_res = 1;
5062
240k
  cm->delta_q_info.delta_lf_present_flag = 0;
5063
240k
  cm->delta_q_info.delta_lf_multi = 0;
5064
240k
  cm->delta_q_info.delta_q_present_flag =
5065
240k
      quant_params->base_qindex > 0 ? aom_rb_read_bit(rb) : 0;
5066
240k
  if (cm->delta_q_info.delta_q_present_flag) {
5067
20.3k
    xd->current_base_qindex = quant_params->base_qindex;
5068
20.3k
    cm->delta_q_info.delta_q_res = 1 << aom_rb_read_literal(rb, 2);
5069
20.3k
    if (!features->allow_intrabc)
5070
16.5k
      cm->delta_q_info.delta_lf_present_flag = aom_rb_read_bit(rb);
5071
20.3k
    if (cm->delta_q_info.delta_lf_present_flag) {
5072
6.98k
      cm->delta_q_info.delta_lf_res = 1 << aom_rb_read_literal(rb, 2);
5073
6.98k
      cm->delta_q_info.delta_lf_multi = aom_rb_read_bit(rb);
5074
6.98k
      av1_reset_loop_filter_delta(xd, av1_num_planes(cm));
5075
6.98k
    }
5076
20.3k
  }
5077
5078
240k
  xd->cur_frame_force_integer_mv = features->cur_frame_force_integer_mv;
5079
5080
1.73M
  for (int i = 0; i < MAX_SEGMENTS; ++i) {
5081
1.49M
    const int qindex = av1_get_qindex(&cm->seg, i, quant_params->base_qindex);
5082
1.49M
    xd->lossless[i] =
5083
1.49M
        qindex == 0 && quant_params->y_dc_delta_q == 0 &&
5084
1.49M
        quant_params->u_dc_delta_q == 0 && quant_params->u_ac_delta_q == 0 &&
5085
1.49M
        quant_params->v_dc_delta_q == 0 && quant_params->v_ac_delta_q == 0;
5086
1.49M
    xd->qindex[i] = qindex;
5087
1.49M
  }
5088
240k
  features->coded_lossless = is_coded_lossless(cm, xd);
5089
240k
  features->all_lossless = features->coded_lossless && !av1_superres_scaled(cm);
5090
240k
  setup_segmentation_dequant(cm, xd);
5091
240k
  if (features->coded_lossless) {
5092
35.8k
    cm->lf.filter_level[0] = 0;
5093
35.8k
    cm->lf.filter_level[1] = 0;
5094
35.8k
  }
5095
240k
  if (features->coded_lossless || !seq_params->enable_cdef) {
5096
114k
    cm->cdef_info.cdef_bits = 0;
5097
114k
    cm->cdef_info.cdef_strengths[0] = 0;
5098
114k
    cm->cdef_info.cdef_uv_strengths[0] = 0;
5099
114k
  }
5100
240k
  if (features->all_lossless || !seq_params->enable_restoration) {
5101
101k
    cm->rst_info[0].frame_restoration_type = RESTORE_NONE;
5102
101k
    cm->rst_info[1].frame_restoration_type = RESTORE_NONE;
5103
101k
    cm->rst_info[2].frame_restoration_type = RESTORE_NONE;
5104
101k
  }
5105
240k
  setup_loopfilter(cm, rb);
5106
5107
240k
  if (!features->coded_lossless && seq_params->enable_cdef) {
5108
71.3k
    setup_cdef(cm, rb);
5109
71.3k
  }
5110
240k
  if (!features->all_lossless && seq_params->enable_restoration) {
5111
81.8k
    decode_restoration_mode(cm, rb);
5112
81.8k
  }
5113
5114
240k
  features->tx_mode = read_tx_mode(rb, features->coded_lossless);
5115
240k
  current_frame->reference_mode = read_frame_reference_mode(cm, rb);
5116
5117
240k
  av1_setup_skip_mode_allowed(cm);
5118
240k
  current_frame->skip_mode_info.skip_mode_flag =
5119
240k
      current_frame->skip_mode_info.skip_mode_allowed ? aom_rb_read_bit(rb) : 0;
5120
5121
240k
  if (frame_might_allow_warped_motion(cm))
5122
32.4k
    features->allow_warped_motion = aom_rb_read_bit(rb);
5123
207k
  else
5124
207k
    features->allow_warped_motion = 0;
5125
5126
240k
  features->reduced_tx_set_used = aom_rb_read_bit(rb);
5127
5128
240k
  if (features->allow_ref_frame_mvs && !frame_might_allow_ref_frame_mvs(cm)) {
5129
0
    aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
5130
0
                       "Frame wrongly requests reference frame MVs");
5131
0
  }
5132
5133
240k
  if (!frame_is_intra_only(cm)) read_global_motion(cm, rb);
5134
5135
240k
  cm->cur_frame->film_grain_params_present =
5136
240k
      seq_params->film_grain_params_present;
5137
240k
  read_film_grain(cm, rb);
5138
5139
240k
#if EXT_TILE_DEBUG
5140
240k
  if (pbi->ext_tile_debug && cm->tiles.large_scale) {
5141
21.3k
    read_ext_tile_info(pbi, rb);
5142
21.3k
    av1_set_single_tile_decoding_mode(cm);
5143
21.3k
  }
5144
240k
#endif  // EXT_TILE_DEBUG
5145
240k
  return 0;
5146
251k
}
5147
5148
struct aom_read_bit_buffer *av1_init_read_bit_buffer(
5149
    AV1Decoder *pbi, struct aom_read_bit_buffer *rb, const uint8_t *data,
5150
503k
    const uint8_t *data_end) {
5151
503k
  rb->bit_offset = 0;
5152
503k
  rb->error_handler = error_handler;
5153
503k
  rb->error_handler_data = &pbi->common;
5154
503k
  rb->bit_buffer = data;
5155
503k
  rb->bit_buffer_end = data_end;
5156
503k
  return rb;
5157
503k
}
5158
5159
207k
BITSTREAM_PROFILE av1_read_profile(struct aom_read_bit_buffer *rb) {
5160
207k
  int profile = aom_rb_read_literal(rb, PROFILE_BITS);
5161
207k
  return (BITSTREAM_PROFILE)profile;
5162
207k
}
5163
5164
30.8k
static inline void superres_post_decode(AV1Decoder *pbi) {
5165
30.8k
  AV1_COMMON *const cm = &pbi->common;
5166
30.8k
  BufferPool *const pool = cm->buffer_pool;
5167
5168
30.8k
  if (!av1_superres_scaled(cm)) return;
5169
9.88k
  assert(!cm->features.all_lossless);
5170
5171
9.88k
  av1_superres_upscale(cm, pool, 0);
5172
9.88k
}
5173
5174
uint32_t av1_decode_frame_headers_and_setup(AV1Decoder *pbi,
5175
                                            struct aom_read_bit_buffer *rb,
5176
251k
                                            int trailing_bits_present) {
5177
251k
  AV1_COMMON *const cm = &pbi->common;
5178
251k
  const int num_planes = av1_num_planes(cm);
5179
251k
  MACROBLOCKD *const xd = &pbi->dcb.xd;
5180
5181
#if CONFIG_BITSTREAM_DEBUG
5182
  if (cm->seq_params->order_hint_info.enable_order_hint) {
5183
    aom_bitstream_queue_set_frame_read(cm->current_frame.order_hint * 2 +
5184
                                       cm->show_frame);
5185
  } else {
5186
    // This is currently used in RTC encoding. cm->show_frame is always 1.
5187
    assert(cm->show_frame);
5188
    aom_bitstream_queue_set_frame_read(cm->current_frame.frame_number);
5189
  }
5190
#endif
5191
#if CONFIG_MISMATCH_DEBUG
5192
  mismatch_move_frame_idx_r();
5193
#endif
5194
5195
2.01M
  for (int i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
5196
1.76M
    cm->global_motion[i] = default_warp_params;
5197
1.76M
    cm->cur_frame->global_motion[i] = default_warp_params;
5198
1.76M
  }
5199
251k
  xd->global_motion = cm->global_motion;
5200
5201
251k
  read_uncompressed_header(pbi, rb);
5202
5203
251k
  if (trailing_bits_present) av1_check_trailing_bits(pbi, rb);
5204
5205
251k
  if (!cm->tiles.single_tile_decoding &&
5206
251k
      (pbi->dec_tile_row >= 0 || pbi->dec_tile_col >= 0)) {
5207
0
    pbi->dec_tile_row = -1;
5208
0
    pbi->dec_tile_col = -1;
5209
0
  }
5210
5211
251k
  const uint32_t uncomp_hdr_size =
5212
251k
      (uint32_t)aom_rb_bytes_read(rb);  // Size of the uncompressed header
5213
251k
  YV12_BUFFER_CONFIG *new_fb = &cm->cur_frame->buf;
5214
251k
  xd->cur_buf = new_fb;
5215
251k
  if (av1_allow_intrabc(cm)) {
5216
42.1k
    av1_setup_scale_factors_for_frame(
5217
42.1k
        &cm->sf_identity, xd->cur_buf->y_crop_width, xd->cur_buf->y_crop_height,
5218
42.1k
        xd->cur_buf->y_crop_width, xd->cur_buf->y_crop_height);
5219
42.1k
  }
5220
5221
  // Showing a frame directly.
5222
251k
  if (cm->show_existing_frame) {
5223
807
    if (pbi->reset_decoder_state) {
5224
      // Use the default frame context values.
5225
176
      *cm->fc = *cm->default_frame_context;
5226
176
      if (!cm->fc->initialized)
5227
0
        aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
5228
0
                           "Uninitialized entropy context.");
5229
176
    }
5230
807
    return uncomp_hdr_size;
5231
807
  }
5232
5233
251k
  cm->mi_params.setup_mi(&cm->mi_params);
5234
5235
251k
  av1_calculate_ref_frame_side(cm);
5236
251k
  if (cm->features.allow_ref_frame_mvs) av1_setup_motion_field(cm);
5237
5238
251k
  av1_setup_block_planes(xd, cm->seq_params->subsampling_x,
5239
251k
                         cm->seq_params->subsampling_y, num_planes);
5240
251k
  if (cm->features.primary_ref_frame == PRIMARY_REF_NONE) {
5241
    // use the default frame context values
5242
140k
    *cm->fc = *cm->default_frame_context;
5243
140k
  } else {
5244
111k
    *cm->fc = get_primary_ref_frame_buf(cm)->frame_context;
5245
111k
  }
5246
251k
  if (!cm->fc->initialized)
5247
26
    aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
5248
26
                       "Uninitialized entropy context.");
5249
5250
251k
  pbi->dcb.corrupted = 0;
5251
251k
  return uncomp_hdr_size;
5252
251k
}
5253
5254
// Once-per-frame initialization
5255
152k
static inline void setup_frame_info(AV1Decoder *pbi) {
5256
152k
  AV1_COMMON *const cm = &pbi->common;
5257
5258
152k
  if (cm->rst_info[0].frame_restoration_type != RESTORE_NONE ||
5259
152k
      cm->rst_info[1].frame_restoration_type != RESTORE_NONE ||
5260
152k
      cm->rst_info[2].frame_restoration_type != RESTORE_NONE) {
5261
30.2k
    av1_alloc_restoration_buffers(cm, /*is_sgr_enabled =*/true);
5262
111k
    for (int p = 0; p < av1_num_planes(cm); p++) {
5263
81.7k
      av1_alloc_restoration_struct(cm, &cm->rst_info[p], p > 0);
5264
81.7k
    }
5265
30.2k
  }
5266
5267
152k
  const int use_highbd = cm->seq_params->use_highbitdepth;
5268
152k
  const int buf_size = MC_TEMP_BUF_PELS << use_highbd;
5269
152k
  if (pbi->td.mc_buf_size != buf_size) {
5270
17.0k
    av1_free_mc_tmp_buf(&pbi->td);
5271
17.0k
    allocate_mc_tmp_buf(cm, &pbi->td, buf_size, use_highbd);
5272
17.0k
  }
5273
152k
}
5274
5275
void av1_decode_tg_tiles_and_wrapup(AV1Decoder *pbi, const uint8_t *data,
5276
                                    const uint8_t *data_end,
5277
                                    const uint8_t **p_data_end, int start_tile,
5278
152k
                                    int end_tile, int initialize_flag) {
5279
152k
  AV1_COMMON *const cm = &pbi->common;
5280
152k
  CommonTileParams *const tiles = &cm->tiles;
5281
152k
  MACROBLOCKD *const xd = &pbi->dcb.xd;
5282
152k
  const int tile_count_tg = end_tile - start_tile + 1;
5283
5284
152k
  xd->error_info = cm->error;
5285
152k
  if (initialize_flag) setup_frame_info(pbi);
5286
152k
  const int num_planes = av1_num_planes(cm);
5287
5288
152k
  if (pbi->max_threads > 1 && !(tiles->large_scale && !pbi->ext_tile_debug) &&
5289
152k
      pbi->row_mt)
5290
73.1k
    *p_data_end =
5291
73.1k
        decode_tiles_row_mt(pbi, data, data_end, start_tile, end_tile);
5292
79.6k
  else if (pbi->max_threads > 1 && tile_count_tg > 1 &&
5293
79.6k
           !(tiles->large_scale && !pbi->ext_tile_debug))
5294
0
    *p_data_end = decode_tiles_mt(pbi, data, data_end, start_tile, end_tile);
5295
79.6k
  else
5296
79.6k
    *p_data_end = decode_tiles(pbi, data, data_end, start_tile, end_tile);
5297
5298
  // If the bit stream is monochrome, set the U and V buffers to a constant.
5299
152k
  if (num_planes < 3) {
5300
10.1k
    set_planes_to_neutral_grey(cm->seq_params, xd->cur_buf, 1);
5301
10.1k
  }
5302
5303
152k
  if (end_tile != tiles->rows * tiles->cols - 1) {
5304
5
    return;
5305
5
  }
5306
5307
152k
  av1_alloc_cdef_buffers(cm, &pbi->cdef_worker, &pbi->cdef_sync,
5308
152k
                         pbi->num_workers, 1);
5309
152k
  av1_alloc_cdef_sync(cm, &pbi->cdef_sync, pbi->num_workers);
5310
5311
152k
  if (!cm->features.allow_intrabc && !tiles->single_tile_decoding) {
5312
77.7k
    if (cm->lf.filter_level[0] || cm->lf.filter_level[1]) {
5313
30.0k
      av1_loop_filter_frame_mt(&cm->cur_frame->buf, cm, &pbi->dcb.xd, 0,
5314
30.0k
                               num_planes, 0, pbi->tile_workers,
5315
30.0k
                               pbi->num_workers, &pbi->lf_row_sync, 0);
5316
30.0k
    }
5317
5318
77.7k
    const int do_cdef =
5319
77.7k
        !pbi->skip_loop_filter && !cm->features.coded_lossless &&
5320
77.7k
        (cm->cdef_info.cdef_bits || cm->cdef_info.cdef_strengths[0] ||
5321
59.6k
         cm->cdef_info.cdef_uv_strengths[0]);
5322
77.7k
    const int do_superres = av1_superres_scaled(cm);
5323
77.7k
    const int optimized_loop_restoration = !do_cdef && !do_superres;
5324
77.7k
    const int do_loop_restoration =
5325
77.7k
        cm->rst_info[0].frame_restoration_type != RESTORE_NONE ||
5326
77.7k
        cm->rst_info[1].frame_restoration_type != RESTORE_NONE ||
5327
77.7k
        cm->rst_info[2].frame_restoration_type != RESTORE_NONE;
5328
    // Frame border extension is not required in the decoder
5329
    // as it happens in extend_mc_border().
5330
77.7k
    int do_extend_border_mt = 0;
5331
77.7k
    if (!optimized_loop_restoration) {
5332
30.8k
      if (do_loop_restoration)
5333
19.4k
        av1_loop_restoration_save_boundary_lines(&pbi->common.cur_frame->buf,
5334
19.4k
                                                 cm, 0);
5335
5336
30.8k
      if (do_cdef) {
5337
25.3k
        if (pbi->num_workers > 1) {
5338
19.3k
          av1_cdef_frame_mt(cm, &pbi->dcb.xd, pbi->cdef_worker,
5339
19.3k
                            pbi->tile_workers, &pbi->cdef_sync,
5340
19.3k
                            pbi->num_workers, av1_cdef_init_fb_row_mt,
5341
19.3k
                            do_extend_border_mt);
5342
19.3k
        } else {
5343
6.00k
          av1_cdef_frame(&pbi->common.cur_frame->buf, cm, &pbi->dcb.xd,
5344
6.00k
                         av1_cdef_init_fb_row);
5345
6.00k
        }
5346
25.3k
      }
5347
5348
30.8k
      superres_post_decode(pbi);
5349
5350
30.8k
      if (do_loop_restoration) {
5351
19.4k
        av1_loop_restoration_save_boundary_lines(&pbi->common.cur_frame->buf,
5352
19.4k
                                                 cm, 1);
5353
19.4k
        if (pbi->num_workers > 1) {
5354
14.7k
          av1_loop_restoration_filter_frame_mt(
5355
14.7k
              (YV12_BUFFER_CONFIG *)xd->cur_buf, cm, optimized_loop_restoration,
5356
14.7k
              pbi->tile_workers, pbi->num_workers, &pbi->lr_row_sync,
5357
14.7k
              &pbi->lr_ctxt, do_extend_border_mt);
5358
14.7k
        } else {
5359
4.63k
          av1_loop_restoration_filter_frame((YV12_BUFFER_CONFIG *)xd->cur_buf,
5360
4.63k
                                            cm, optimized_loop_restoration,
5361
4.63k
                                            &pbi->lr_ctxt);
5362
4.63k
        }
5363
19.4k
      }
5364
46.9k
    } else {
5365
      // In no cdef and no superres case. Provide an optimized version of
5366
      // loop_restoration_filter.
5367
46.9k
      if (do_loop_restoration) {
5368
2.68k
        if (pbi->num_workers > 1) {
5369
910
          av1_loop_restoration_filter_frame_mt(
5370
910
              (YV12_BUFFER_CONFIG *)xd->cur_buf, cm, optimized_loop_restoration,
5371
910
              pbi->tile_workers, pbi->num_workers, &pbi->lr_row_sync,
5372
910
              &pbi->lr_ctxt, do_extend_border_mt);
5373
1.77k
        } else {
5374
1.77k
          av1_loop_restoration_filter_frame((YV12_BUFFER_CONFIG *)xd->cur_buf,
5375
1.77k
                                            cm, optimized_loop_restoration,
5376
1.77k
                                            &pbi->lr_ctxt);
5377
1.77k
        }
5378
2.68k
      }
5379
46.9k
    }
5380
77.7k
  }
5381
5382
152k
  if (!pbi->dcb.corrupted) {
5383
91.1k
    if (cm->features.refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD) {
5384
27.5k
      assert(pbi->context_update_tile_id < pbi->allocated_tiles);
5385
27.5k
      *cm->fc = pbi->tile_data[pbi->context_update_tile_id].tctx;
5386
27.5k
      av1_reset_cdf_symbol_counters(cm->fc);
5387
27.5k
    }
5388
91.1k
  } else {
5389
61.6k
    aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
5390
61.6k
                       "Decode failed. Frame data is corrupted.");
5391
61.6k
  }
5392
5393
#if CONFIG_INSPECTION
5394
  if (pbi->inspect_cb != NULL) {
5395
    (*pbi->inspect_cb)(pbi, pbi->inspect_ctx);
5396
  }
5397
#endif
5398
5399
  // Non frame parallel update frame context here.
5400
152k
  if (!tiles->large_scale) {
5401
83.0k
    cm->cur_frame->frame_context = *cm->fc;
5402
83.0k
  }
5403
5404
152k
  if (cm->show_frame && !cm->seq_params->order_hint_info.enable_order_hint) {
5405
9.72k
    ++cm->current_frame.frame_number;
5406
9.72k
  }
5407
152k
}