Coverage Report

Created: 2022-08-24 06:11

/src/aom/av1/decoder/obu.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright (c) 2017, 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
14
#include "config/aom_config.h"
15
#include "config/aom_scale_rtcd.h"
16
17
#include "aom/aom_codec.h"
18
#include "aom_dsp/bitreader_buffer.h"
19
#include "aom_ports/mem_ops.h"
20
21
#include "av1/common/common.h"
22
#include "av1/common/obu_util.h"
23
#include "av1/common/timing.h"
24
#include "av1/decoder/decoder.h"
25
#include "av1/decoder/decodeframe.h"
26
#include "av1/decoder/obu.h"
27
28
aom_codec_err_t aom_get_num_layers_from_operating_point_idc(
29
    int operating_point_idc, unsigned int *number_spatial_layers,
30
0
    unsigned int *number_temporal_layers) {
31
  // derive number of spatial/temporal layers from operating_point_idc
32
33
0
  if (!number_spatial_layers || !number_temporal_layers)
34
0
    return AOM_CODEC_INVALID_PARAM;
35
36
0
  if (operating_point_idc == 0) {
37
0
    *number_temporal_layers = 1;
38
0
    *number_spatial_layers = 1;
39
0
  } else {
40
0
    *number_spatial_layers = 0;
41
0
    *number_temporal_layers = 0;
42
0
    for (int j = 0; j < MAX_NUM_SPATIAL_LAYERS; j++) {
43
0
      *number_spatial_layers +=
44
0
          (operating_point_idc >> (j + MAX_NUM_TEMPORAL_LAYERS)) & 0x1;
45
0
    }
46
0
    for (int j = 0; j < MAX_NUM_TEMPORAL_LAYERS; j++) {
47
0
      *number_temporal_layers += (operating_point_idc >> j) & 0x1;
48
0
    }
49
0
  }
50
51
0
  return AOM_CODEC_OK;
52
0
}
53
54
static int is_obu_in_current_operating_point(AV1Decoder *pbi,
55
0
                                             const ObuHeader *obu_header) {
56
0
  if (!pbi->current_operating_point || !obu_header->has_extension) {
57
0
    return 1;
58
0
  }
59
60
0
  if ((pbi->current_operating_point >> obu_header->temporal_layer_id) & 0x1 &&
61
0
      (pbi->current_operating_point >> (obu_header->spatial_layer_id + 8)) &
62
0
          0x1) {
63
0
    return 1;
64
0
  }
65
0
  return 0;
66
0
}
67
68
static int byte_alignment(AV1_COMMON *const cm,
69
0
                          struct aom_read_bit_buffer *const rb) {
70
0
  while (rb->bit_offset & 7) {
71
0
    if (aom_rb_read_bit(rb)) {
72
0
      cm->error->error_code = AOM_CODEC_CORRUPT_FRAME;
73
0
      return -1;
74
0
    }
75
0
  }
76
0
  return 0;
77
0
}
78
79
0
static uint32_t read_temporal_delimiter_obu() { return 0; }
80
81
// Returns a boolean that indicates success.
82
static int read_bitstream_level(AV1_LEVEL *seq_level_idx,
83
0
                                struct aom_read_bit_buffer *rb) {
84
0
  *seq_level_idx = aom_rb_read_literal(rb, LEVEL_BITS);
85
0
  if (!is_valid_seq_level_idx(*seq_level_idx)) return 0;
86
0
  return 1;
87
0
}
88
89
// Returns whether two sequence headers are consistent with each other.
90
// Note that the 'op_params' field is not compared per Section 7.5 in the spec:
91
//   Within a particular coded video sequence, the contents of
92
//   sequence_header_obu must be bit-identical each time the sequence header
93
//   appears except for the contents of operating_parameters_info.
94
static int are_seq_headers_consistent(const SequenceHeader *seq_params_old,
95
0
                                      const SequenceHeader *seq_params_new) {
96
0
  return !memcmp(seq_params_old, seq_params_new,
97
0
                 offsetof(SequenceHeader, op_params));
98
0
}
99
100
// On success, sets pbi->sequence_header_ready to 1 and returns the number of
101
// bytes read from 'rb'.
102
// On failure, sets pbi->common.error.error_code and returns 0.
103
static uint32_t read_sequence_header_obu(AV1Decoder *pbi,
104
0
                                         struct aom_read_bit_buffer *rb) {
105
0
  AV1_COMMON *const cm = &pbi->common;
106
0
  const uint32_t saved_bit_offset = rb->bit_offset;
107
108
  // Verify rb has been configured to report errors.
109
0
  assert(rb->error_handler);
110
111
  // Use a local variable to store the information as we decode. At the end,
112
  // if no errors have occurred, cm->seq_params is updated.
113
0
  SequenceHeader sh = *cm->seq_params;
114
0
  SequenceHeader *const seq_params = &sh;
115
116
0
  seq_params->profile = av1_read_profile(rb);
117
0
  if (seq_params->profile > CONFIG_MAX_DECODE_PROFILE) {
118
0
    pbi->error.error_code = AOM_CODEC_UNSUP_BITSTREAM;
119
0
    return 0;
120
0
  }
121
122
  // Still picture or not
123
0
  seq_params->still_picture = aom_rb_read_bit(rb);
124
0
  seq_params->reduced_still_picture_hdr = aom_rb_read_bit(rb);
125
  // Video must have reduced_still_picture_hdr = 0
126
0
  if (!seq_params->still_picture && seq_params->reduced_still_picture_hdr) {
127
0
    pbi->error.error_code = AOM_CODEC_UNSUP_BITSTREAM;
128
0
    return 0;
129
0
  }
130
131
0
  if (seq_params->reduced_still_picture_hdr) {
132
0
    seq_params->timing_info_present = 0;
133
0
    seq_params->decoder_model_info_present_flag = 0;
134
0
    seq_params->display_model_info_present_flag = 0;
135
0
    seq_params->operating_points_cnt_minus_1 = 0;
136
0
    seq_params->operating_point_idc[0] = 0;
137
0
    if (!read_bitstream_level(&seq_params->seq_level_idx[0], rb)) {
138
0
      pbi->error.error_code = AOM_CODEC_UNSUP_BITSTREAM;
139
0
      return 0;
140
0
    }
141
0
    seq_params->tier[0] = 0;
142
0
    seq_params->op_params[0].decoder_model_param_present_flag = 0;
143
0
    seq_params->op_params[0].display_model_param_present_flag = 0;
144
0
  } else {
145
0
    seq_params->timing_info_present = aom_rb_read_bit(rb);
146
0
    if (seq_params->timing_info_present) {
147
0
      av1_read_timing_info_header(&seq_params->timing_info, &pbi->error, rb);
148
149
0
      seq_params->decoder_model_info_present_flag = aom_rb_read_bit(rb);
150
0
      if (seq_params->decoder_model_info_present_flag)
151
0
        av1_read_decoder_model_info(&seq_params->decoder_model_info, rb);
152
0
    } else {
153
0
      seq_params->decoder_model_info_present_flag = 0;
154
0
    }
155
0
    seq_params->display_model_info_present_flag = aom_rb_read_bit(rb);
156
0
    seq_params->operating_points_cnt_minus_1 =
157
0
        aom_rb_read_literal(rb, OP_POINTS_CNT_MINUS_1_BITS);
158
0
    for (int i = 0; i < seq_params->operating_points_cnt_minus_1 + 1; i++) {
159
0
      seq_params->operating_point_idc[i] =
160
0
          aom_rb_read_literal(rb, OP_POINTS_IDC_BITS);
161
0
      if (!read_bitstream_level(&seq_params->seq_level_idx[i], rb)) {
162
0
        pbi->error.error_code = AOM_CODEC_UNSUP_BITSTREAM;
163
0
        return 0;
164
0
      }
165
      // This is the seq_level_idx[i] > 7 check in the spec. seq_level_idx 7
166
      // is equivalent to level 3.3.
167
0
      if (seq_params->seq_level_idx[i] >= SEQ_LEVEL_4_0)
168
0
        seq_params->tier[i] = aom_rb_read_bit(rb);
169
0
      else
170
0
        seq_params->tier[i] = 0;
171
0
      if (seq_params->decoder_model_info_present_flag) {
172
0
        seq_params->op_params[i].decoder_model_param_present_flag =
173
0
            aom_rb_read_bit(rb);
174
0
        if (seq_params->op_params[i].decoder_model_param_present_flag)
175
0
          av1_read_op_parameters_info(&seq_params->op_params[i],
176
0
                                      seq_params->decoder_model_info
177
0
                                          .encoder_decoder_buffer_delay_length,
178
0
                                      rb);
179
0
      } else {
180
0
        seq_params->op_params[i].decoder_model_param_present_flag = 0;
181
0
      }
182
0
      if (seq_params->timing_info_present &&
183
0
          (seq_params->timing_info.equal_picture_interval ||
184
0
           seq_params->op_params[i].decoder_model_param_present_flag)) {
185
0
        seq_params->op_params[i].bitrate = av1_max_level_bitrate(
186
0
            seq_params->profile, seq_params->seq_level_idx[i],
187
0
            seq_params->tier[i]);
188
        // Level with seq_level_idx = 31 returns a high "dummy" bitrate to pass
189
        // the check
190
0
        if (seq_params->op_params[i].bitrate == 0)
191
0
          aom_internal_error(&pbi->error, AOM_CODEC_UNSUP_BITSTREAM,
192
0
                             "AV1 does not support this combination of "
193
0
                             "profile, level, and tier.");
194
        // Buffer size in bits/s is bitrate in bits/s * 1 s
195
0
        seq_params->op_params[i].buffer_size = seq_params->op_params[i].bitrate;
196
0
      }
197
0
      if (seq_params->timing_info_present &&
198
0
          seq_params->timing_info.equal_picture_interval &&
199
0
          !seq_params->op_params[i].decoder_model_param_present_flag) {
200
        // When the decoder_model_parameters are not sent for this op, set
201
        // the default ones that can be used with the resource availability mode
202
0
        seq_params->op_params[i].decoder_buffer_delay = 70000;
203
0
        seq_params->op_params[i].encoder_buffer_delay = 20000;
204
0
        seq_params->op_params[i].low_delay_mode_flag = 0;
205
0
      }
206
207
0
      if (seq_params->display_model_info_present_flag) {
208
0
        seq_params->op_params[i].display_model_param_present_flag =
209
0
            aom_rb_read_bit(rb);
210
0
        if (seq_params->op_params[i].display_model_param_present_flag) {
211
0
          seq_params->op_params[i].initial_display_delay =
212
0
              aom_rb_read_literal(rb, 4) + 1;
213
0
          if (seq_params->op_params[i].initial_display_delay > 10)
214
0
            aom_internal_error(
215
0
                &pbi->error, AOM_CODEC_UNSUP_BITSTREAM,
216
0
                "AV1 does not support more than 10 decoded frames delay");
217
0
        } else {
218
0
          seq_params->op_params[i].initial_display_delay = 10;
219
0
        }
220
0
      } else {
221
0
        seq_params->op_params[i].display_model_param_present_flag = 0;
222
0
        seq_params->op_params[i].initial_display_delay = 10;
223
0
      }
224
0
    }
225
0
  }
226
  // This decoder supports all levels.  Choose operating point provided by
227
  // external means
228
0
  int operating_point = pbi->operating_point;
229
0
  if (operating_point < 0 ||
230
0
      operating_point > seq_params->operating_points_cnt_minus_1)
231
0
    operating_point = 0;
232
0
  pbi->current_operating_point =
233
0
      seq_params->operating_point_idc[operating_point];
234
0
  if (aom_get_num_layers_from_operating_point_idc(
235
0
          pbi->current_operating_point, &pbi->number_spatial_layers,
236
0
          &pbi->number_temporal_layers) != AOM_CODEC_OK) {
237
0
    pbi->error.error_code = AOM_CODEC_ERROR;
238
0
    return 0;
239
0
  }
240
241
0
  av1_read_sequence_header(cm, rb, seq_params);
242
243
0
  av1_read_color_config(rb, pbi->allow_lowbitdepth, seq_params, &pbi->error);
244
0
  if (!(seq_params->subsampling_x == 0 && seq_params->subsampling_y == 0) &&
245
0
      !(seq_params->subsampling_x == 1 && seq_params->subsampling_y == 1) &&
246
0
      !(seq_params->subsampling_x == 1 && seq_params->subsampling_y == 0)) {
247
0
    aom_internal_error(&pbi->error, AOM_CODEC_UNSUP_BITSTREAM,
248
0
                       "Only 4:4:4, 4:2:2 and 4:2:0 are currently supported, "
249
0
                       "%d %d subsampling is not supported.\n",
250
0
                       seq_params->subsampling_x, seq_params->subsampling_y);
251
0
  }
252
253
0
  seq_params->film_grain_params_present = aom_rb_read_bit(rb);
254
255
0
  if (av1_check_trailing_bits(pbi, rb) != 0) {
256
    // pbi->error.error_code is already set.
257
0
    return 0;
258
0
  }
259
260
  // If a sequence header has been decoded before, we check if the new
261
  // one is consistent with the old one.
262
0
  if (pbi->sequence_header_ready) {
263
0
    if (!are_seq_headers_consistent(cm->seq_params, seq_params))
264
0
      pbi->sequence_header_changed = 1;
265
0
  }
266
267
0
  *cm->seq_params = *seq_params;
268
0
  pbi->sequence_header_ready = 1;
269
270
0
  return ((rb->bit_offset - saved_bit_offset + 7) >> 3);
271
0
}
272
273
// On success, returns the frame header size. On failure, calls
274
// aom_internal_error and does not return. If show existing frame,
275
// also marks the data processing to end after the frame header.
276
static uint32_t read_frame_header_obu(AV1Decoder *pbi,
277
                                      struct aom_read_bit_buffer *rb,
278
                                      const uint8_t *data,
279
                                      const uint8_t **p_data_end,
280
0
                                      int trailing_bits_present) {
281
0
  const uint32_t hdr_size =
282
0
      av1_decode_frame_headers_and_setup(pbi, rb, trailing_bits_present);
283
0
  const AV1_COMMON *cm = &pbi->common;
284
0
  if (cm->show_existing_frame) {
285
0
    *p_data_end = data + hdr_size;
286
0
  }
287
0
  return hdr_size;
288
0
}
289
290
// On success, returns the tile group header size. On failure, calls
291
// aom_internal_error() and returns -1.
292
static int32_t read_tile_group_header(AV1Decoder *pbi,
293
                                      struct aom_read_bit_buffer *rb,
294
                                      int *start_tile, int *end_tile,
295
0
                                      int tile_start_implicit) {
296
0
  AV1_COMMON *const cm = &pbi->common;
297
0
  CommonTileParams *const tiles = &cm->tiles;
298
0
  uint32_t saved_bit_offset = rb->bit_offset;
299
0
  int tile_start_and_end_present_flag = 0;
300
0
  const int num_tiles = tiles->rows * tiles->cols;
301
302
0
  if (!tiles->large_scale && num_tiles > 1) {
303
0
    tile_start_and_end_present_flag = aom_rb_read_bit(rb);
304
0
    if (tile_start_implicit && tile_start_and_end_present_flag) {
305
0
      aom_internal_error(
306
0
          &pbi->error, AOM_CODEC_UNSUP_BITSTREAM,
307
0
          "For OBU_FRAME type obu tile_start_and_end_present_flag must be 0");
308
0
      return -1;
309
0
    }
310
0
  }
311
0
  if (tiles->large_scale || num_tiles == 1 ||
312
0
      !tile_start_and_end_present_flag) {
313
0
    *start_tile = 0;
314
0
    *end_tile = num_tiles - 1;
315
0
  } else {
316
0
    int tile_bits = tiles->log2_rows + tiles->log2_cols;
317
0
    *start_tile = aom_rb_read_literal(rb, tile_bits);
318
0
    *end_tile = aom_rb_read_literal(rb, tile_bits);
319
0
  }
320
0
  if (*start_tile != pbi->next_start_tile) {
321
0
    aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
322
0
                       "tg_start (%d) must be equal to %d", *start_tile,
323
0
                       pbi->next_start_tile);
324
0
    return -1;
325
0
  }
326
0
  if (*start_tile > *end_tile) {
327
0
    aom_internal_error(
328
0
        &pbi->error, AOM_CODEC_CORRUPT_FRAME,
329
0
        "tg_end (%d) must be greater than or equal to tg_start (%d)", *end_tile,
330
0
        *start_tile);
331
0
    return -1;
332
0
  }
333
0
  if (*end_tile >= num_tiles) {
334
0
    aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
335
0
                       "tg_end (%d) must be less than NumTiles (%d)", *end_tile,
336
0
                       num_tiles);
337
0
    return -1;
338
0
  }
339
0
  pbi->next_start_tile = (*end_tile == num_tiles - 1) ? 0 : *end_tile + 1;
340
341
0
  return ((rb->bit_offset - saved_bit_offset + 7) >> 3);
342
0
}
343
344
// On success, returns the tile group OBU size. On failure, sets
345
// pbi->common.error.error_code and returns 0.
346
static uint32_t read_one_tile_group_obu(
347
    AV1Decoder *pbi, struct aom_read_bit_buffer *rb, int is_first_tg,
348
    const uint8_t *data, const uint8_t *data_end, const uint8_t **p_data_end,
349
0
    int *is_last_tg, int tile_start_implicit) {
350
0
  AV1_COMMON *const cm = &pbi->common;
351
0
  int start_tile, end_tile;
352
0
  int32_t header_size, tg_payload_size;
353
354
0
  assert((rb->bit_offset & 7) == 0);
355
0
  assert(rb->bit_buffer + aom_rb_bytes_read(rb) == data);
356
357
0
  header_size = read_tile_group_header(pbi, rb, &start_tile, &end_tile,
358
0
                                       tile_start_implicit);
359
0
  if (header_size == -1 || byte_alignment(cm, rb)) return 0;
360
0
  data += header_size;
361
0
  av1_decode_tg_tiles_and_wrapup(pbi, data, data_end, p_data_end, start_tile,
362
0
                                 end_tile, is_first_tg);
363
364
0
  tg_payload_size = (uint32_t)(*p_data_end - data);
365
366
0
  *is_last_tg = end_tile == cm->tiles.rows * cm->tiles.cols - 1;
367
0
  return header_size + tg_payload_size;
368
0
}
369
370
0
static void alloc_tile_list_buffer(AV1Decoder *pbi) {
371
  // The resolution of the output frame is read out from the bitstream. The data
372
  // are stored in the order of Y plane, U plane and V plane. As an example, for
373
  // image format 4:2:0, the output frame of U plane and V plane is 1/4 of the
374
  // output frame.
375
0
  AV1_COMMON *const cm = &pbi->common;
376
0
  int tile_width, tile_height;
377
0
  av1_get_uniform_tile_size(cm, &tile_width, &tile_height);
378
0
  const int tile_width_in_pixels = tile_width * MI_SIZE;
379
0
  const int tile_height_in_pixels = tile_height * MI_SIZE;
380
0
  const int output_frame_width =
381
0
      (pbi->output_frame_width_in_tiles_minus_1 + 1) * tile_width_in_pixels;
382
0
  const int output_frame_height =
383
0
      (pbi->output_frame_height_in_tiles_minus_1 + 1) * tile_height_in_pixels;
384
  // The output frame is used to store the decoded tile list. The decoded tile
385
  // list has to fit into 1 output frame.
386
0
  assert((pbi->tile_count_minus_1 + 1) <=
387
0
         (pbi->output_frame_width_in_tiles_minus_1 + 1) *
388
0
             (pbi->output_frame_height_in_tiles_minus_1 + 1));
389
390
  // Allocate the tile list output buffer.
391
  // Note: if cm->seq_params->use_highbitdepth is 1 and
392
  // cm->seq_params->bit_depth is 8, we could allocate less memory, namely, 8
393
  // bits/pixel.
394
0
  if (aom_alloc_frame_buffer(&pbi->tile_list_outbuf, output_frame_width,
395
0
                             output_frame_height, cm->seq_params->subsampling_x,
396
0
                             cm->seq_params->subsampling_y,
397
0
                             (cm->seq_params->use_highbitdepth &&
398
0
                              (cm->seq_params->bit_depth > AOM_BITS_8)),
399
0
                             0, cm->features.byte_alignment))
400
0
    aom_internal_error(&pbi->error, AOM_CODEC_MEM_ERROR,
401
0
                       "Failed to allocate the tile list output buffer");
402
0
}
403
404
static void yv12_tile_copy(const YV12_BUFFER_CONFIG *src, int hstart1,
405
                           int hend1, int vstart1, int vend1,
406
                           YV12_BUFFER_CONFIG *dst, int hstart2, int vstart2,
407
0
                           int plane) {
408
0
  const int src_stride = (plane > 0) ? src->strides[1] : src->strides[0];
409
0
  const int dst_stride = (plane > 0) ? dst->strides[1] : dst->strides[0];
410
0
  int row, col;
411
412
0
  assert(src->flags & YV12_FLAG_HIGHBITDEPTH);
413
0
  assert(!(dst->flags & YV12_FLAG_HIGHBITDEPTH));
414
415
0
  const uint16_t *src16 =
416
0
      CONVERT_TO_SHORTPTR(src->buffers[plane] + vstart1 * src_stride + hstart1);
417
0
  uint8_t *dst8 = dst->buffers[plane] + vstart2 * dst_stride + hstart2;
418
419
0
  for (row = vstart1; row < vend1; ++row) {
420
0
    for (col = 0; col < (hend1 - hstart1); ++col) *dst8++ = (uint8_t)(*src16++);
421
0
    src16 += src_stride - (hend1 - hstart1);
422
0
    dst8 += dst_stride - (hend1 - hstart1);
423
0
  }
424
0
  return;
425
0
}
426
427
static void copy_decoded_tile_to_tile_list_buffer(AV1Decoder *pbi,
428
0
                                                  int tile_idx) {
429
0
  AV1_COMMON *const cm = &pbi->common;
430
0
  int tile_width, tile_height;
431
0
  av1_get_uniform_tile_size(cm, &tile_width, &tile_height);
432
0
  const int tile_width_in_pixels = tile_width * MI_SIZE;
433
0
  const int tile_height_in_pixels = tile_height * MI_SIZE;
434
0
  const int ssy = cm->seq_params->subsampling_y;
435
0
  const int ssx = cm->seq_params->subsampling_x;
436
0
  const int num_planes = av1_num_planes(cm);
437
438
0
  YV12_BUFFER_CONFIG *cur_frame = &cm->cur_frame->buf;
439
0
  const int tr = tile_idx / (pbi->output_frame_width_in_tiles_minus_1 + 1);
440
0
  const int tc = tile_idx % (pbi->output_frame_width_in_tiles_minus_1 + 1);
441
0
  int plane;
442
443
  // Copy decoded tile to the tile list output buffer.
444
0
  for (plane = 0; plane < num_planes; ++plane) {
445
0
    const int shift_x = plane > 0 ? ssx : 0;
446
0
    const int shift_y = plane > 0 ? ssy : 0;
447
0
    const int h = tile_height_in_pixels >> shift_y;
448
0
    const int w = tile_width_in_pixels >> shift_x;
449
450
    // src offset
451
0
    int vstart1 = pbi->dec_tile_row * h;
452
0
    int vend1 = vstart1 + h;
453
0
    int hstart1 = pbi->dec_tile_col * w;
454
0
    int hend1 = hstart1 + w;
455
    // dst offset
456
0
    int vstart2 = tr * h;
457
0
    int hstart2 = tc * w;
458
459
0
    if (cm->seq_params->use_highbitdepth &&
460
0
        cm->seq_params->bit_depth == AOM_BITS_8) {
461
0
      yv12_tile_copy(cur_frame, hstart1, hend1, vstart1, vend1,
462
0
                     &pbi->tile_list_outbuf, hstart2, vstart2, plane);
463
0
    } else {
464
0
      switch (plane) {
465
0
        case 0:
466
0
          aom_yv12_partial_copy_y(cur_frame, hstart1, hend1, vstart1, vend1,
467
0
                                  &pbi->tile_list_outbuf, hstart2, vstart2);
468
0
          break;
469
0
        case 1:
470
0
          aom_yv12_partial_copy_u(cur_frame, hstart1, hend1, vstart1, vend1,
471
0
                                  &pbi->tile_list_outbuf, hstart2, vstart2);
472
0
          break;
473
0
        case 2:
474
0
          aom_yv12_partial_copy_v(cur_frame, hstart1, hend1, vstart1, vend1,
475
0
                                  &pbi->tile_list_outbuf, hstart2, vstart2);
476
0
          break;
477
0
        default: assert(0);
478
0
      }
479
0
    }
480
0
  }
481
0
}
482
483
// Only called while large_scale_tile = 1.
484
//
485
// On success, returns the tile list OBU size. On failure, sets
486
// pbi->common.error.error_code and returns 0.
487
static uint32_t read_and_decode_one_tile_list(AV1Decoder *pbi,
488
                                              struct aom_read_bit_buffer *rb,
489
                                              const uint8_t *data,
490
                                              const uint8_t *data_end,
491
                                              const uint8_t **p_data_end,
492
0
                                              int *frame_decoding_finished) {
493
0
  AV1_COMMON *const cm = &pbi->common;
494
0
  uint32_t tile_list_payload_size = 0;
495
0
  const int num_tiles = cm->tiles.cols * cm->tiles.rows;
496
0
  const int start_tile = 0;
497
0
  const int end_tile = num_tiles - 1;
498
0
  int i = 0;
499
500
  // Process the tile list info.
501
0
  pbi->output_frame_width_in_tiles_minus_1 = aom_rb_read_literal(rb, 8);
502
0
  pbi->output_frame_height_in_tiles_minus_1 = aom_rb_read_literal(rb, 8);
503
0
  pbi->tile_count_minus_1 = aom_rb_read_literal(rb, 16);
504
0
  if (pbi->tile_count_minus_1 > MAX_TILES - 1) {
505
0
    pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
506
0
    return 0;
507
0
  }
508
509
  // Allocate output frame buffer for the tile list.
510
0
  alloc_tile_list_buffer(pbi);
511
512
0
  uint32_t tile_list_info_bytes = 4;
513
0
  tile_list_payload_size += tile_list_info_bytes;
514
0
  data += tile_list_info_bytes;
515
516
0
  int tile_idx = 0;
517
0
  for (i = 0; i <= pbi->tile_count_minus_1; i++) {
518
    // Process 1 tile.
519
    // Reset the bit reader.
520
0
    rb->bit_offset = 0;
521
0
    rb->bit_buffer = data;
522
523
    // Read out the tile info.
524
0
    uint32_t tile_info_bytes = 5;
525
    // Set reference for each tile.
526
0
    int ref_idx = aom_rb_read_literal(rb, 8);
527
0
    if (ref_idx >= MAX_EXTERNAL_REFERENCES) {
528
0
      pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
529
0
      return 0;
530
0
    }
531
0
    av1_set_reference_dec(cm, cm->remapped_ref_idx[0], 1,
532
0
                          &pbi->ext_refs.refs[ref_idx]);
533
534
0
    pbi->dec_tile_row = aom_rb_read_literal(rb, 8);
535
0
    pbi->dec_tile_col = aom_rb_read_literal(rb, 8);
536
0
    if (pbi->dec_tile_row < 0 || pbi->dec_tile_col < 0 ||
537
0
        pbi->dec_tile_row >= cm->tiles.rows ||
538
0
        pbi->dec_tile_col >= cm->tiles.cols) {
539
0
      pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
540
0
      return 0;
541
0
    }
542
543
0
    pbi->coded_tile_data_size = aom_rb_read_literal(rb, 16) + 1;
544
0
    data += tile_info_bytes;
545
0
    if ((size_t)(data_end - data) < pbi->coded_tile_data_size) {
546
0
      pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
547
0
      return 0;
548
0
    }
549
550
0
    av1_decode_tg_tiles_and_wrapup(pbi, data, data + pbi->coded_tile_data_size,
551
0
                                   p_data_end, start_tile, end_tile, 0);
552
0
    uint32_t tile_payload_size = (uint32_t)(*p_data_end - data);
553
554
0
    tile_list_payload_size += tile_info_bytes + tile_payload_size;
555
556
    // Update data ptr for next tile decoding.
557
0
    data = *p_data_end;
558
0
    assert(data <= data_end);
559
560
    // Copy the decoded tile to the tile list output buffer.
561
0
    copy_decoded_tile_to_tile_list_buffer(pbi, tile_idx);
562
0
    tile_idx++;
563
0
  }
564
565
0
  *frame_decoding_finished = 1;
566
0
  return tile_list_payload_size;
567
0
}
568
569
// Returns the last nonzero byte index in 'data'. If there is no nonzero byte in
570
// 'data', returns -1.
571
0
static int get_last_nonzero_byte_index(const uint8_t *data, size_t sz) {
572
  // Scan backward and return on the first nonzero byte.
573
0
  int i = (int)sz - 1;
574
0
  while (i >= 0 && data[i] == 0) {
575
0
    --i;
576
0
  }
577
0
  return i;
578
0
}
579
580
// Allocates metadata that was read and adds it to the decoders metadata array.
581
static void alloc_read_metadata(AV1Decoder *const pbi,
582
                                OBU_METADATA_TYPE metadata_type,
583
                                const uint8_t *data, size_t sz,
584
0
                                aom_metadata_insert_flags_t insert_flag) {
585
0
  if (!pbi->metadata) {
586
0
    pbi->metadata = aom_img_metadata_array_alloc(0);
587
0
    if (!pbi->metadata) {
588
0
      aom_internal_error(&pbi->error, AOM_CODEC_MEM_ERROR,
589
0
                         "Failed to allocate metadata array");
590
0
    }
591
0
  }
592
0
  aom_metadata_t *metadata =
593
0
      aom_img_metadata_alloc(metadata_type, data, sz, insert_flag);
594
0
  if (!metadata) {
595
0
    aom_internal_error(&pbi->error, AOM_CODEC_MEM_ERROR,
596
0
                       "Error allocating metadata");
597
0
  }
598
0
  aom_metadata_t **metadata_array =
599
0
      (aom_metadata_t **)realloc(pbi->metadata->metadata_array,
600
0
                                 (pbi->metadata->sz + 1) * sizeof(metadata));
601
0
  if (!metadata_array) {
602
0
    aom_img_metadata_free(metadata);
603
0
    aom_internal_error(&pbi->error, AOM_CODEC_MEM_ERROR,
604
0
                       "Error growing metadata array");
605
0
  }
606
0
  pbi->metadata->metadata_array = metadata_array;
607
0
  pbi->metadata->metadata_array[pbi->metadata->sz] = metadata;
608
0
  pbi->metadata->sz++;
609
0
}
610
611
// On failure, calls aom_internal_error() and does not return.
612
static void read_metadata_itut_t35(AV1Decoder *const pbi, const uint8_t *data,
613
0
                                   size_t sz) {
614
0
  if (sz == 0) {
615
0
    aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
616
0
                       "itu_t_t35_country_code is missing");
617
0
  }
618
0
  int country_code_size = 1;
619
0
  if (*data == 0xFF) {
620
0
    if (sz == 1) {
621
0
      aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
622
0
                         "itu_t_t35_country_code_extension_byte is missing");
623
0
    }
624
0
    ++country_code_size;
625
0
  }
626
0
  int end_index = get_last_nonzero_byte_index(data, sz);
627
0
  if (end_index < country_code_size) {
628
0
    aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
629
0
                       "No trailing bits found in ITU-T T.35 metadata OBU");
630
0
  }
631
  // itu_t_t35_payload_bytes is byte aligned. Section 6.7.2 of the spec says:
632
  //   itu_t_t35_payload_bytes shall be bytes containing data registered as
633
  //   specified in Recommendation ITU-T T.35.
634
  // Therefore the first trailing byte should be 0x80.
635
0
  if (data[end_index] != 0x80) {
636
0
    aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
637
0
                       "The last nonzero byte of the ITU-T T.35 metadata OBU "
638
0
                       "is 0x%02x, should be 0x80.",
639
0
                       data[end_index]);
640
0
  }
641
0
  alloc_read_metadata(pbi, OBU_METADATA_TYPE_ITUT_T35, data, end_index,
642
0
                      AOM_MIF_ANY_FRAME);
643
0
}
644
645
// On success, returns the number of bytes read from 'data'. On failure, calls
646
// aom_internal_error() and does not return.
647
static size_t read_metadata_hdr_cll(AV1Decoder *const pbi, const uint8_t *data,
648
0
                                    size_t sz) {
649
0
  const size_t kHdrCllPayloadSize = 4;
650
0
  if (sz < kHdrCllPayloadSize) {
651
0
    aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
652
0
                       "Incorrect HDR CLL metadata payload size");
653
0
  }
654
0
  alloc_read_metadata(pbi, OBU_METADATA_TYPE_HDR_CLL, data, kHdrCllPayloadSize,
655
0
                      AOM_MIF_ANY_FRAME);
656
0
  return kHdrCllPayloadSize;
657
0
}
658
659
// On success, returns the number of bytes read from 'data'. On failure, calls
660
// aom_internal_error() and does not return.
661
static size_t read_metadata_hdr_mdcv(AV1Decoder *const pbi, const uint8_t *data,
662
0
                                     size_t sz) {
663
0
  const size_t kMdcvPayloadSize = 24;
664
0
  if (sz < kMdcvPayloadSize) {
665
0
    aom_internal_error(&pbi->error, AOM_CODEC_CORRUPT_FRAME,
666
0
                       "Incorrect HDR MDCV metadata payload size");
667
0
  }
668
0
  alloc_read_metadata(pbi, OBU_METADATA_TYPE_HDR_MDCV, data, kMdcvPayloadSize,
669
0
                      AOM_MIF_ANY_FRAME);
670
0
  return kMdcvPayloadSize;
671
0
}
672
673
0
static void scalability_structure(struct aom_read_bit_buffer *rb) {
674
0
  const int spatial_layers_cnt_minus_1 = aom_rb_read_literal(rb, 2);
675
0
  const int spatial_layer_dimensions_present_flag = aom_rb_read_bit(rb);
676
0
  const int spatial_layer_description_present_flag = aom_rb_read_bit(rb);
677
0
  const int temporal_group_description_present_flag = aom_rb_read_bit(rb);
678
  // scalability_structure_reserved_3bits must be set to zero and be ignored by
679
  // decoders.
680
0
  aom_rb_read_literal(rb, 3);
681
682
0
  if (spatial_layer_dimensions_present_flag) {
683
0
    for (int i = 0; i <= spatial_layers_cnt_minus_1; i++) {
684
0
      aom_rb_read_literal(rb, 16);
685
0
      aom_rb_read_literal(rb, 16);
686
0
    }
687
0
  }
688
0
  if (spatial_layer_description_present_flag) {
689
0
    for (int i = 0; i <= spatial_layers_cnt_minus_1; i++) {
690
0
      aom_rb_read_literal(rb, 8);
691
0
    }
692
0
  }
693
0
  if (temporal_group_description_present_flag) {
694
0
    const int temporal_group_size = aom_rb_read_literal(rb, 8);
695
0
    for (int i = 0; i < temporal_group_size; i++) {
696
0
      aom_rb_read_literal(rb, 3);
697
0
      aom_rb_read_bit(rb);
698
0
      aom_rb_read_bit(rb);
699
0
      const int temporal_group_ref_cnt = aom_rb_read_literal(rb, 3);
700
0
      for (int j = 0; j < temporal_group_ref_cnt; j++) {
701
0
        aom_rb_read_literal(rb, 8);
702
0
      }
703
0
    }
704
0
  }
705
0
}
706
707
0
static void read_metadata_scalability(struct aom_read_bit_buffer *rb) {
708
0
  const int scalability_mode_idc = aom_rb_read_literal(rb, 8);
709
0
  if (scalability_mode_idc == SCALABILITY_SS) {
710
0
    scalability_structure(rb);
711
0
  }
712
0
}
713
714
0
static void read_metadata_timecode(struct aom_read_bit_buffer *rb) {
715
0
  aom_rb_read_literal(rb, 5);  // counting_type f(5)
716
0
  const int full_timestamp_flag =
717
0
      aom_rb_read_bit(rb);     // full_timestamp_flag f(1)
718
0
  aom_rb_read_bit(rb);         // discontinuity_flag (f1)
719
0
  aom_rb_read_bit(rb);         // cnt_dropped_flag f(1)
720
0
  aom_rb_read_literal(rb, 9);  // n_frames f(9)
721
0
  if (full_timestamp_flag) {
722
0
    aom_rb_read_literal(rb, 6);  // seconds_value f(6)
723
0
    aom_rb_read_literal(rb, 6);  // minutes_value f(6)
724
0
    aom_rb_read_literal(rb, 5);  // hours_value f(5)
725
0
  } else {
726
0
    const int seconds_flag = aom_rb_read_bit(rb);  // seconds_flag f(1)
727
0
    if (seconds_flag) {
728
0
      aom_rb_read_literal(rb, 6);                    // seconds_value f(6)
729
0
      const int minutes_flag = aom_rb_read_bit(rb);  // minutes_flag f(1)
730
0
      if (minutes_flag) {
731
0
        aom_rb_read_literal(rb, 6);                  // minutes_value f(6)
732
0
        const int hours_flag = aom_rb_read_bit(rb);  // hours_flag f(1)
733
0
        if (hours_flag) {
734
0
          aom_rb_read_literal(rb, 5);  // hours_value f(5)
735
0
        }
736
0
      }
737
0
    }
738
0
  }
739
  // time_offset_length f(5)
740
0
  const int time_offset_length = aom_rb_read_literal(rb, 5);
741
0
  if (time_offset_length) {
742
    // time_offset_value f(time_offset_length)
743
0
    aom_rb_read_literal(rb, time_offset_length);
744
0
  }
745
0
}
746
747
// Returns the last nonzero byte in 'data'. If there is no nonzero byte in
748
// 'data', returns 0.
749
//
750
// Call this function to check the following requirement in the spec:
751
//   This implies that when any payload data is present for this OBU type, at
752
//   least one byte of the payload data (including the trailing bit) shall not
753
//   be equal to 0.
754
0
static uint8_t get_last_nonzero_byte(const uint8_t *data, size_t sz) {
755
  // Scan backward and return on the first nonzero byte.
756
0
  size_t i = sz;
757
0
  while (i != 0) {
758
0
    --i;
759
0
    if (data[i] != 0) return data[i];
760
0
  }
761
0
  return 0;
762
0
}
763
764
// Checks the metadata for correct syntax but ignores the parsed metadata.
765
//
766
// On success, returns the number of bytes read from 'data'. On failure, sets
767
// pbi->common.error.error_code and returns 0, or calls aom_internal_error()
768
// and does not return.
769
0
static size_t read_metadata(AV1Decoder *pbi, const uint8_t *data, size_t sz) {
770
0
  size_t type_length;
771
0
  uint64_t type_value;
772
0
  if (aom_uleb_decode(data, sz, &type_value, &type_length) < 0) {
773
0
    pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
774
0
    return 0;
775
0
  }
776
0
  const OBU_METADATA_TYPE metadata_type = (OBU_METADATA_TYPE)type_value;
777
0
  if (metadata_type == 0 || metadata_type >= 6) {
778
    // If metadata_type is reserved for future use or a user private value,
779
    // ignore the entire OBU and just check trailing bits.
780
0
    if (get_last_nonzero_byte(data + type_length, sz - type_length) == 0) {
781
0
      pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
782
0
      return 0;
783
0
    }
784
0
    return sz;
785
0
  }
786
0
  if (metadata_type == OBU_METADATA_TYPE_ITUT_T35) {
787
    // read_metadata_itut_t35() checks trailing bits.
788
0
    read_metadata_itut_t35(pbi, data + type_length, sz - type_length);
789
0
    return sz;
790
0
  } else if (metadata_type == OBU_METADATA_TYPE_HDR_CLL) {
791
0
    size_t bytes_read =
792
0
        type_length +
793
0
        read_metadata_hdr_cll(pbi, data + type_length, sz - type_length);
794
0
    if (get_last_nonzero_byte(data + bytes_read, sz - bytes_read) != 0x80) {
795
0
      pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
796
0
      return 0;
797
0
    }
798
0
    return sz;
799
0
  } else if (metadata_type == OBU_METADATA_TYPE_HDR_MDCV) {
800
0
    size_t bytes_read =
801
0
        type_length +
802
0
        read_metadata_hdr_mdcv(pbi, data + type_length, sz - type_length);
803
0
    if (get_last_nonzero_byte(data + bytes_read, sz - bytes_read) != 0x80) {
804
0
      pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
805
0
      return 0;
806
0
    }
807
0
    return sz;
808
0
  }
809
810
0
  struct aom_read_bit_buffer rb;
811
0
  av1_init_read_bit_buffer(pbi, &rb, data + type_length, data + sz);
812
0
  if (metadata_type == OBU_METADATA_TYPE_SCALABILITY) {
813
0
    read_metadata_scalability(&rb);
814
0
  } else {
815
0
    assert(metadata_type == OBU_METADATA_TYPE_TIMECODE);
816
0
    read_metadata_timecode(&rb);
817
0
  }
818
0
  if (av1_check_trailing_bits(pbi, &rb) != 0) {
819
    // pbi->error.error_code is already set.
820
0
    return 0;
821
0
  }
822
0
  assert((rb.bit_offset & 7) == 0);
823
0
  return type_length + (rb.bit_offset >> 3);
824
0
}
825
826
// On success, returns 'sz'. On failure, sets pbi->common.error.error_code and
827
// returns 0.
828
static size_t read_padding(AV1_COMMON *const cm, const uint8_t *data,
829
0
                           size_t sz) {
830
  // The spec allows a padding OBU to be header-only (i.e., obu_size = 0). So
831
  // check trailing bits only if sz > 0.
832
0
  if (sz > 0) {
833
    // The payload of a padding OBU is byte aligned. Therefore the first
834
    // trailing byte should be 0x80. See https://crbug.com/aomedia/2393.
835
0
    const uint8_t last_nonzero_byte = get_last_nonzero_byte(data, sz);
836
0
    if (last_nonzero_byte != 0x80) {
837
0
      cm->error->error_code = AOM_CODEC_CORRUPT_FRAME;
838
0
      return 0;
839
0
    }
840
0
  }
841
0
  return sz;
842
0
}
843
844
// On success, returns a boolean that indicates whether the decoding of the
845
// current frame is finished. On failure, sets pbi->error.error_code and
846
// returns -1.
847
int aom_decode_frame_from_obus(struct AV1Decoder *pbi, const uint8_t *data,
848
                               const uint8_t *data_end,
849
0
                               const uint8_t **p_data_end) {
850
0
  AV1_COMMON *const cm = &pbi->common;
851
0
  int frame_decoding_finished = 0;
852
0
  int is_first_tg_obu_received = 1;
853
  // Whenever pbi->seen_frame_header is set to 1, frame_header is set to the
854
  // beginning of the frame_header_obu and frame_header_size is set to its
855
  // size. This allows us to check if a redundant frame_header_obu is a copy
856
  // of the previous frame_header_obu.
857
  //
858
  // Initialize frame_header to a dummy nonnull pointer, otherwise the Clang
859
  // Static Analyzer in clang 7.0.1 will falsely warn that a null pointer is
860
  // passed as an argument to a 'nonnull' parameter of memcmp(). The initial
861
  // value will not be used.
862
0
  const uint8_t *frame_header = data;
863
0
  uint32_t frame_header_size = 0;
864
0
  ObuHeader obu_header;
865
0
  memset(&obu_header, 0, sizeof(obu_header));
866
0
  pbi->seen_frame_header = 0;
867
0
  pbi->next_start_tile = 0;
868
0
  pbi->num_tile_groups = 0;
869
870
0
  if (data_end < data) {
871
0
    pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
872
0
    return -1;
873
0
  }
874
875
  // Reset pbi->camera_frame_header_ready to 0 if cm->tiles.large_scale = 0.
876
0
  if (!cm->tiles.large_scale) pbi->camera_frame_header_ready = 0;
877
878
  // decode frame as a series of OBUs
879
0
  while (!frame_decoding_finished && pbi->error.error_code == AOM_CODEC_OK) {
880
0
    struct aom_read_bit_buffer rb;
881
0
    size_t payload_size = 0;
882
0
    size_t decoded_payload_size = 0;
883
0
    size_t obu_payload_offset = 0;
884
0
    size_t bytes_read = 0;
885
0
    const size_t bytes_available = data_end - data;
886
887
0
    if (bytes_available == 0 && !pbi->seen_frame_header) {
888
0
      *p_data_end = data;
889
0
      pbi->error.error_code = AOM_CODEC_OK;
890
0
      break;
891
0
    }
892
893
0
    aom_codec_err_t status =
894
0
        aom_read_obu_header_and_size(data, bytes_available, pbi->is_annexb,
895
0
                                     &obu_header, &payload_size, &bytes_read);
896
897
0
    if (status != AOM_CODEC_OK) {
898
0
      pbi->error.error_code = status;
899
0
      return -1;
900
0
    }
901
902
    // Record obu size header information.
903
0
    pbi->obu_size_hdr.data = data + obu_header.size;
904
0
    pbi->obu_size_hdr.size = bytes_read - obu_header.size;
905
906
    // Note: aom_read_obu_header_and_size() takes care of checking that this
907
    // doesn't cause 'data' to advance past 'data_end'.
908
0
    data += bytes_read;
909
910
0
    if ((size_t)(data_end - data) < payload_size) {
911
0
      pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
912
0
      return -1;
913
0
    }
914
915
0
    cm->temporal_layer_id = obu_header.temporal_layer_id;
916
0
    cm->spatial_layer_id = obu_header.spatial_layer_id;
917
918
0
    if (obu_header.type != OBU_TEMPORAL_DELIMITER &&
919
0
        obu_header.type != OBU_SEQUENCE_HEADER) {
920
      // don't decode obu if it's not in current operating mode
921
0
      if (!is_obu_in_current_operating_point(pbi, &obu_header)) {
922
0
        data += payload_size;
923
0
        continue;
924
0
      }
925
0
    }
926
927
0
    av1_init_read_bit_buffer(pbi, &rb, data, data + payload_size);
928
929
0
    switch (obu_header.type) {
930
0
      case OBU_TEMPORAL_DELIMITER:
931
0
        decoded_payload_size = read_temporal_delimiter_obu();
932
0
        if (pbi->seen_frame_header) {
933
          // A new temporal unit has started, but the frame in the previous
934
          // temporal unit is incomplete.
935
0
          pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
936
0
          return -1;
937
0
        }
938
0
        break;
939
0
      case OBU_SEQUENCE_HEADER:
940
0
        decoded_payload_size = read_sequence_header_obu(pbi, &rb);
941
0
        if (pbi->error.error_code != AOM_CODEC_OK) return -1;
942
        // The sequence header should not change in the middle of a frame.
943
0
        if (pbi->sequence_header_changed && pbi->seen_frame_header) {
944
0
          pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
945
0
          return -1;
946
0
        }
947
0
        break;
948
0
      case OBU_FRAME_HEADER:
949
0
      case OBU_REDUNDANT_FRAME_HEADER:
950
0
      case OBU_FRAME:
951
0
        if (obu_header.type == OBU_REDUNDANT_FRAME_HEADER) {
952
0
          if (!pbi->seen_frame_header) {
953
0
            pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
954
0
            return -1;
955
0
          }
956
0
        } else {
957
          // OBU_FRAME_HEADER or OBU_FRAME.
958
0
          if (pbi->seen_frame_header) {
959
0
            pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
960
0
            return -1;
961
0
          }
962
0
        }
963
        // Only decode first frame header received
964
0
        if (!pbi->seen_frame_header ||
965
0
            (cm->tiles.large_scale && !pbi->camera_frame_header_ready)) {
966
0
          frame_header_size = read_frame_header_obu(
967
0
              pbi, &rb, data, p_data_end, obu_header.type != OBU_FRAME);
968
0
          frame_header = data;
969
0
          pbi->seen_frame_header = 1;
970
0
          if (!pbi->ext_tile_debug && cm->tiles.large_scale)
971
0
            pbi->camera_frame_header_ready = 1;
972
0
        } else {
973
          // Verify that the frame_header_obu is identical to the original
974
          // frame_header_obu.
975
0
          if (frame_header_size > payload_size ||
976
0
              memcmp(data, frame_header, frame_header_size) != 0) {
977
0
            pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
978
0
            return -1;
979
0
          }
980
0
          assert(rb.bit_offset == 0);
981
0
          rb.bit_offset = 8 * frame_header_size;
982
0
        }
983
984
0
        decoded_payload_size = frame_header_size;
985
0
        pbi->frame_header_size = frame_header_size;
986
0
        cm->cur_frame->temporal_id = obu_header.temporal_layer_id;
987
0
        cm->cur_frame->spatial_id = obu_header.spatial_layer_id;
988
989
0
        if (cm->show_existing_frame) {
990
0
          if (obu_header.type == OBU_FRAME) {
991
0
            pbi->error.error_code = AOM_CODEC_UNSUP_BITSTREAM;
992
0
            return -1;
993
0
          }
994
0
          frame_decoding_finished = 1;
995
0
          pbi->seen_frame_header = 0;
996
0
          break;
997
0
        }
998
999
        // In large scale tile coding, decode the common camera frame header
1000
        // before any tile list OBU.
1001
0
        if (!pbi->ext_tile_debug && pbi->camera_frame_header_ready) {
1002
0
          frame_decoding_finished = 1;
1003
          // Skip the rest of the frame data.
1004
0
          decoded_payload_size = payload_size;
1005
          // Update data_end.
1006
0
          *p_data_end = data_end;
1007
0
          break;
1008
0
        }
1009
1010
0
        if (obu_header.type != OBU_FRAME) break;
1011
0
        obu_payload_offset = frame_header_size;
1012
        // Byte align the reader before reading the tile group.
1013
        // byte_alignment() has set pbi->error.error_code if it returns -1.
1014
0
        if (byte_alignment(cm, &rb)) return -1;
1015
0
        AOM_FALLTHROUGH_INTENDED;  // fall through to read tile group.
1016
0
      case OBU_TILE_GROUP:
1017
0
        if (!pbi->seen_frame_header) {
1018
0
          pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
1019
0
          return -1;
1020
0
        }
1021
0
        if (obu_payload_offset > payload_size) {
1022
0
          pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
1023
0
          return -1;
1024
0
        }
1025
0
        decoded_payload_size += read_one_tile_group_obu(
1026
0
            pbi, &rb, is_first_tg_obu_received, data + obu_payload_offset,
1027
0
            data + payload_size, p_data_end, &frame_decoding_finished,
1028
0
            obu_header.type == OBU_FRAME);
1029
0
        if (pbi->error.error_code != AOM_CODEC_OK) return -1;
1030
0
        is_first_tg_obu_received = 0;
1031
0
        if (frame_decoding_finished) {
1032
0
          pbi->seen_frame_header = 0;
1033
0
          pbi->next_start_tile = 0;
1034
0
        }
1035
0
        pbi->num_tile_groups++;
1036
0
        break;
1037
0
      case OBU_METADATA:
1038
0
        decoded_payload_size = read_metadata(pbi, data, payload_size);
1039
0
        if (pbi->error.error_code != AOM_CODEC_OK) return -1;
1040
0
        break;
1041
0
      case OBU_TILE_LIST:
1042
0
        if (CONFIG_NORMAL_TILE_MODE) {
1043
0
          pbi->error.error_code = AOM_CODEC_UNSUP_BITSTREAM;
1044
0
          return -1;
1045
0
        }
1046
1047
        // This OBU type is purely for the large scale tile coding mode.
1048
        // The common camera frame header has to be already decoded.
1049
0
        if (!pbi->camera_frame_header_ready) {
1050
0
          pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
1051
0
          return -1;
1052
0
        }
1053
1054
0
        cm->tiles.large_scale = 1;
1055
0
        av1_set_single_tile_decoding_mode(cm);
1056
0
        decoded_payload_size =
1057
0
            read_and_decode_one_tile_list(pbi, &rb, data, data + payload_size,
1058
0
                                          p_data_end, &frame_decoding_finished);
1059
0
        if (pbi->error.error_code != AOM_CODEC_OK) return -1;
1060
0
        break;
1061
0
      case OBU_PADDING:
1062
0
        decoded_payload_size = read_padding(cm, data, payload_size);
1063
0
        if (pbi->error.error_code != AOM_CODEC_OK) return -1;
1064
0
        break;
1065
0
      default:
1066
        // Skip unrecognized OBUs
1067
0
        if (payload_size > 0 &&
1068
0
            get_last_nonzero_byte(data, payload_size) == 0) {
1069
0
          pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
1070
0
          return -1;
1071
0
        }
1072
0
        decoded_payload_size = payload_size;
1073
0
        break;
1074
0
    }
1075
1076
    // Check that the signalled OBU size matches the actual amount of data read
1077
0
    if (decoded_payload_size > payload_size) {
1078
0
      pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
1079
0
      return -1;
1080
0
    }
1081
1082
    // If there are extra padding bytes, they should all be zero
1083
0
    while (decoded_payload_size < payload_size) {
1084
0
      uint8_t padding_byte = data[decoded_payload_size++];
1085
0
      if (padding_byte != 0) {
1086
0
        pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;
1087
0
        return -1;
1088
0
      }
1089
0
    }
1090
1091
0
    data += payload_size;
1092
0
  }
1093
1094
0
  if (pbi->error.error_code != AOM_CODEC_OK) return -1;
1095
0
  return frame_decoding_finished;
1096
0
}