Shaka Packager SDK
Loading...
Searching...
No Matches
h265_parser.cc
1// Copyright 2016 Google LLC. All rights reserved.
2//
3// Use of this source code is governed by a BSD-style
4// license that can be found in the LICENSE file or at
5// https://developers.google.com/open-source/licenses/bsd
6
7#include <packager/media/codecs/h265_parser.h>
8
9#include <algorithm>
10#include <cmath>
11
12#include <absl/log/check.h>
13#include <absl/log/log.h>
14
15#include <packager/macros/compiler.h>
16#include <packager/macros/logging.h>
17#include <packager/media/codecs/nalu_reader.h>
18
19#define TRUE_OR_RETURN(a) \
20 do { \
21 if (!(a)) { \
22 DVLOG(1) << "Failure while processing " << #a; \
23 return kInvalidStream; \
24 } \
25 } while (0)
26
27#define OK_OR_RETURN(a) \
28 do { \
29 Result status = (a); \
30 if (status != kOk) \
31 return status; \
32 } while (false)
33
34#define READ_LONG_OR_RETURN(out) \
35 do { \
36 int _top_half, _bottom_half; \
37 if (!br->ReadBits(16, &_top_half)) { \
38 DVLOG(1) \
39 << "Error in stream: unexpected EOS while trying to read " #out; \
40 return kInvalidStream; \
41 } \
42 if (!br->ReadBits(16, &_bottom_half)) { \
43 DVLOG(1) \
44 << "Error in stream: unexpected EOS while trying to read " #out; \
45 return kInvalidStream; \
46 } \
47 *(out) = ((long)_top_half) << 16 | _bottom_half; \
48 } while (false)
49
50namespace shaka {
51namespace media {
52
53namespace {
54int GetNumPicTotalCurr(const H265SliceHeader& slice_header,
55 const H265Sps& sps,
56 const H265Vps& vps,
57 int nuh_layer_id,
58 int nuh_temporal_id) {
59 int num_pic_total_curr = 0;
60 const H265ReferencePictureSet& ref_pic_set =
61 slice_header.short_term_ref_pic_set_sps_flag
62 ? sps.st_ref_pic_sets[slice_header.short_term_ref_pic_set_idx]
63 : slice_header.st_ref_pic_set;
64
65 for (int i = 0; i < ref_pic_set.num_negative_pics; i++) {
66 if (ref_pic_set.used_by_curr_pic_s0[i])
67 num_pic_total_curr++;
68 }
69 for (int i = 0; i < ref_pic_set.num_positive_pics; i++) {
70 if (ref_pic_set.used_by_curr_pic_s1[i])
71 num_pic_total_curr++;
72 }
73
74 num_pic_total_curr += slice_header.used_by_curr_pic_lt;
75
76 int num_active_ref_layer_pics = 0;
77 if (nuh_layer_id > 0) {
78 int num_ref_layer_pics = 0;
79 for (int i = 0; i < vps.num_direct_ref_layers[nuh_layer_id]; i++) {
80 int ref_layer_idx =
81 vps.layer_id_in_vps[vps.id_direct_ref_layers[nuh_layer_id][i]];
82 if (vps.sub_layers_vps_max_minus1[ref_layer_idx] >= nuh_temporal_id &&
83 (nuh_temporal_id == 0 ||
84 vps.max_tid_il_ref_pics_plus1[ref_layer_idx]
85 [vps.layer_id_in_vps[nuh_layer_id]] >
86 nuh_temporal_id)) {
87 num_ref_layer_pics++;
88 }
89 }
90 if (num_ref_layer_pics > 0) {
91 if (vps.default_ref_layers_active_flag) {
92 num_active_ref_layer_pics = num_ref_layer_pics;
93 } else if (!slice_header.inter_layer_pred_enabled_flag) {
94 num_active_ref_layer_pics = 0;
95 } else if (vps.max_one_active_ref_layer_flag ||
96 vps.num_direct_ref_layers[nuh_layer_id] == 1) {
97 num_active_ref_layer_pics = 1;
98 } else {
99 LOG(ERROR)
100 << "For stereo views, num_direct_ref_layers is expected to be 1.";
101 }
102 }
103 }
104 return num_pic_total_curr + num_active_ref_layer_pics;
105}
106
107void GetAspectRatioInfo(const H265Sps& sps,
108 uint32_t* pixel_width,
109 uint32_t* pixel_height) {
110 // The default value is 0; so if this is not in the SPS, it will correctly
111 // assume unspecified.
112 int aspect_ratio_idc = sps.vui_parameters.aspect_ratio_idc;
113
114 // Table E.1
115 switch (aspect_ratio_idc) {
116 case 1:
117 *pixel_width = 1;
118 *pixel_height = 1;
119 break;
120 case 2:
121 *pixel_width = 12;
122 *pixel_height = 11;
123 break;
124 case 3:
125 *pixel_width = 10;
126 *pixel_height = 11;
127 break;
128 case 4:
129 *pixel_width = 16;
130 *pixel_height = 11;
131 break;
132 case 5:
133 *pixel_width = 40;
134 *pixel_height = 33;
135 break;
136 case 6:
137 *pixel_width = 24;
138 *pixel_height = 11;
139 break;
140 case 7:
141 *pixel_width = 20;
142 *pixel_height = 11;
143 break;
144 case 8:
145 *pixel_width = 32;
146 *pixel_height = 11;
147 break;
148 case 9:
149 *pixel_width = 80;
150 *pixel_height = 33;
151 break;
152 case 10:
153 *pixel_width = 18;
154 *pixel_height = 11;
155 break;
156 case 11:
157 *pixel_width = 15;
158 *pixel_height = 11;
159 break;
160 case 12:
161 *pixel_width = 64;
162 *pixel_height = 33;
163 break;
164 case 13:
165 *pixel_width = 160;
166 *pixel_height = 99;
167 break;
168 case 14:
169 *pixel_width = 4;
170 *pixel_height = 3;
171 break;
172 case 15:
173 *pixel_width = 3;
174 *pixel_height = 2;
175 break;
176 case 16:
177 *pixel_width = 2;
178 *pixel_height = 1;
179 break;
180
181 case 255:
182 *pixel_width = sps.vui_parameters.sar_width;
183 *pixel_height = sps.vui_parameters.sar_height;
184 break;
185
186 default:
187 // Section E.3.1 specifies that other values should be interpreted as 0.
188 LOG(WARNING) << "Unknown aspect_ratio_idc " << aspect_ratio_idc;
189 FALLTHROUGH_INTENDED;
190 case 0:
191 // Unlike the spec, assume 1:1 if not specified.
192 *pixel_width = 1;
193 *pixel_height = 1;
194 break;
195 }
196}
197} // namespace
198
199bool ExtractResolutionFromSps(const H265Sps& sps,
200 uint32_t* coded_width,
201 uint32_t* coded_height,
202 uint32_t* pixel_width,
203 uint32_t* pixel_height) {
204 int crop_x = 0;
205 int crop_y = 0;
206 if (sps.conformance_window_flag) {
207 int sub_width_c = 0;
208 int sub_height_c = 0;
209
210 // Table 6-1
211 switch (sps.chroma_format_idc) {
212 case 0: // Monochrome
213 sub_width_c = 1;
214 sub_height_c = 1;
215 break;
216 case 1: // 4:2:0
217 sub_width_c = 2;
218 sub_height_c = 2;
219 break;
220 case 2: // 4:2:2
221 sub_width_c = 2;
222 sub_height_c = 1;
223 break;
224 case 3: // 4:4:4
225 sub_width_c = 1;
226 sub_height_c = 1;
227 break;
228 default:
229 LOG(ERROR) << "Unexpected chroma_format_idc " << sps.chroma_format_idc;
230 return false;
231 }
232
233 // Formula D-28, D-29
234 crop_x =
235 sub_width_c * (sps.conf_win_right_offset + sps.conf_win_left_offset);
236 crop_y =
237 sub_height_c * (sps.conf_win_bottom_offset + sps.conf_win_top_offset);
238 }
239
240 // Formula D-28, D-29
241 *coded_width = sps.pic_width_in_luma_samples - crop_x;
242 *coded_height = sps.pic_height_in_luma_samples - crop_y;
243 GetAspectRatioInfo(sps, pixel_width, pixel_height);
244 return true;
245}
246
247H265Pps::H265Pps() {}
248H265Pps::~H265Pps() {}
249
250H265Sps::H265Sps() {}
251H265Sps::~H265Sps() {}
252
253H265Vps::H265Vps() {}
254H265Vps::~H265Vps() {}
255
256int H265Sps::GetPicSizeInCtbsY() const {
257 int min_cb_log2_size_y = log2_min_luma_coding_block_size_minus3 + 3;
258 int ctb_log2_size_y =
259 min_cb_log2_size_y + log2_diff_max_min_luma_coding_block_size;
260 int ctb_size_y = 1 << ctb_log2_size_y;
261
262 // Round-up division.
263 int pic_width_in_ctbs_y = (pic_width_in_luma_samples - 1) / ctb_size_y + 1;
264 int pic_height_in_ctbs_y = (pic_height_in_luma_samples - 1) / ctb_size_y + 1;
265 return pic_width_in_ctbs_y * pic_height_in_ctbs_y;
266}
267
268int H265Sps::GetChromaArrayType() const {
269 if (!separate_colour_plane_flag)
270 return chroma_format_idc;
271 else
272 return 0;
273}
274
275H265ReferencePictureListModifications::H265ReferencePictureListModifications() {
276}
277H265ReferencePictureListModifications::
278 ~H265ReferencePictureListModifications() {}
279
280H265SliceHeader::H265SliceHeader() {}
281H265SliceHeader::~H265SliceHeader() {}
282
283H265Parser::H265Parser() {}
284H265Parser::~H265Parser() {}
285
286H265Parser::Result H265Parser::ParseSliceHeader(const Nalu& nalu,
287 H265SliceHeader* slice_header) {
288 DCHECK(nalu.is_video_slice());
289 *slice_header = H265SliceHeader();
290
291 // Parses whole element.
292 H26xBitReader reader;
293 reader.Initialize(nalu.data() + nalu.header_size(), nalu.payload_size());
294 H26xBitReader* br = &reader;
295
296 TRUE_OR_RETURN(br->ReadBool(&slice_header->first_slice_segment_in_pic_flag));
297 if (nalu.type() >= Nalu::H265_BLA_W_LP &&
298 nalu.type() <= Nalu::H265_RSV_IRAP_VCL23) {
299 TRUE_OR_RETURN(br->ReadBool(&slice_header->no_output_of_prior_pics_flag));
300 }
301
302 TRUE_OR_RETURN(br->ReadUE(&slice_header->pic_parameter_set_id));
303 const H265Pps* pps = GetPps(slice_header->pic_parameter_set_id);
304 TRUE_OR_RETURN(pps);
305
306 const H265Sps* sps = GetSps(pps->seq_parameter_set_id);
307 TRUE_OR_RETURN(sps);
308
309 const H265Vps* vps = GetVps(sps->video_parameter_set_id);
310 const int nuh_layer_id = nalu.nuh_layer_id();
311 if (nuh_layer_id > 0) {
312 TRUE_OR_RETURN(vps);
313 }
314
315 if (!slice_header->first_slice_segment_in_pic_flag) {
316 if (pps->dependent_slice_segments_enabled_flag) {
317 TRUE_OR_RETURN(br->ReadBool(&slice_header->dependent_slice_segment_flag));
318 }
319 const int bit_length = ceil(log2(sps->GetPicSizeInCtbsY()));
320 TRUE_OR_RETURN(br->ReadBits(bit_length, &slice_header->segment_address));
321 }
322
323 if (!slice_header->dependent_slice_segment_flag) {
324 TRUE_OR_RETURN(br->SkipBits(pps->num_extra_slice_header_bits));
325 TRUE_OR_RETURN(br->ReadUE(&slice_header->slice_type));
326 if (pps->output_flag_present_flag) {
327 TRUE_OR_RETURN(br->ReadBool(&slice_header->pic_output_flag));
328 }
329 if (sps->separate_colour_plane_flag) {
330 TRUE_OR_RETURN(br->ReadBits(2, &slice_header->colour_plane_id));
331 }
332
333 if ((nuh_layer_id > 0 &&
334 !vps->poc_lsb_not_present_flag[vps->layer_id_in_vps[nuh_layer_id]]) ||
335 (nalu.type() != Nalu::H265_IDR_W_RADL &&
336 nalu.type() != Nalu::H265_IDR_N_LP)) {
337 TRUE_OR_RETURN(br->ReadBits(sps->log2_max_pic_order_cnt_lsb_minus4 + 4,
338 &slice_header->slice_pic_order_cnt_lsb));
339 }
340
341 if (nalu.type() != Nalu::H265_IDR_W_RADL &&
342 nalu.type() != Nalu::H265_IDR_N_LP) {
343 TRUE_OR_RETURN(
344 br->ReadBool(&slice_header->short_term_ref_pic_set_sps_flag));
345 if (!slice_header->short_term_ref_pic_set_sps_flag) {
346 OK_OR_RETURN(ParseReferencePictureSet(
347 sps->num_short_term_ref_pic_sets, sps->num_short_term_ref_pic_sets,
348 sps->st_ref_pic_sets, br, &slice_header->st_ref_pic_set));
349 } else if (sps->num_short_term_ref_pic_sets > 1) {
350 TRUE_OR_RETURN(
351 br->ReadBits(ceil(log2(sps->num_short_term_ref_pic_sets)),
352 &slice_header->short_term_ref_pic_set_idx));
353 TRUE_OR_RETURN(slice_header->short_term_ref_pic_set_idx <
354 sps->num_short_term_ref_pic_sets);
355 }
356
357 if (sps->long_term_ref_pic_present_flag) {
358 if (sps->num_long_term_ref_pics > 0) {
359 TRUE_OR_RETURN(br->ReadUE(&slice_header->num_long_term_sps));
360 }
361 TRUE_OR_RETURN(br->ReadUE(&slice_header->num_long_term_pics));
362
363 const int pic_count =
364 slice_header->num_long_term_sps + slice_header->num_long_term_pics;
365 slice_header->long_term_pics_info.resize(pic_count);
366 for (int i = 0; i < pic_count; i++) {
367 if (i < slice_header->num_long_term_sps) {
368 int lt_idx_sps = 0;
369 if (sps->num_long_term_ref_pics > 1) {
370 TRUE_OR_RETURN(br->ReadBits(
371 ceil(log2(sps->num_long_term_ref_pics)), &lt_idx_sps));
372 }
373 if (sps->used_by_curr_pic_lt_flag[lt_idx_sps])
374 slice_header->used_by_curr_pic_lt++;
375 } else {
376 TRUE_OR_RETURN(br->SkipBits(sps->log2_max_pic_order_cnt_lsb_minus4 +
377 4)); // poc_lsb_lt
378 bool used_by_curr_pic_lt_flag;
379 TRUE_OR_RETURN(br->ReadBool(&used_by_curr_pic_lt_flag));
380 if (used_by_curr_pic_lt_flag)
381 slice_header->used_by_curr_pic_lt++;
382 }
383 TRUE_OR_RETURN(br->ReadBool(&slice_header->long_term_pics_info[i]
384 .delta_poc_msb_present_flag));
385 if (slice_header->long_term_pics_info[i].delta_poc_msb_present_flag) {
386 TRUE_OR_RETURN(br->ReadUE(
387 &slice_header->long_term_pics_info[i].delta_poc_msb_cycle_lt));
388 }
389 }
390 }
391
392 if (sps->temporal_mvp_enabled_flag) {
393 TRUE_OR_RETURN(
394 br->ReadBool(&slice_header->slice_temporal_mvp_enabled_flag));
395 }
396 }
397
398 if (nuh_layer_id > 0 && !vps->default_ref_layers_active_flag &&
399 vps->num_direct_ref_layers[nuh_layer_id] > 0) {
400 TRUE_OR_RETURN(
401 br->ReadBool(&slice_header->inter_layer_pred_enabled_flag));
402 if (slice_header->inter_layer_pred_enabled_flag &&
403 vps->num_direct_ref_layers[nuh_layer_id] > 1) {
404 NOTIMPLEMENTED()
405 << "For stereo video, num_direct_ref_layers is expected to be 1.";
406 return kUnsupportedStream;
407 }
408 }
409
410 if (sps->sample_adaptive_offset_enabled_flag) {
411 TRUE_OR_RETURN(br->ReadBool(&slice_header->slice_sao_luma_flag));
412 if (sps->GetChromaArrayType() != 0) {
413 TRUE_OR_RETURN(br->ReadBool(&slice_header->slice_sao_chroma_flag));
414 }
415 }
416
417 slice_header->num_ref_idx_l0_active_minus1 =
418 pps->num_ref_idx_l0_default_active_minus1;
419 slice_header->num_ref_idx_l1_active_minus1 =
420 pps->num_ref_idx_l1_default_active_minus1;
421 if (slice_header->slice_type == kPSlice ||
422 slice_header->slice_type == kBSlice) {
423 TRUE_OR_RETURN(
424 br->ReadBool(&slice_header->num_ref_idx_active_override_flag));
425 if (slice_header->num_ref_idx_active_override_flag) {
426 TRUE_OR_RETURN(br->ReadUE(&slice_header->num_ref_idx_l0_active_minus1));
427 if (slice_header->slice_type == kBSlice) {
428 TRUE_OR_RETURN(
429 br->ReadUE(&slice_header->num_ref_idx_l1_active_minus1));
430 }
431 }
432
433 const int num_pic_total_curr = GetNumPicTotalCurr(
434 *slice_header, *sps, *vps, nuh_layer_id, nalu.nuh_temporal_id());
435 if (pps->lists_modification_present_flag && num_pic_total_curr > 1) {
436 OK_OR_RETURN(SkipReferencePictureListModification(
437 *slice_header, *pps, num_pic_total_curr, br));
438 }
439
440 if (slice_header->slice_type == kBSlice) {
441 TRUE_OR_RETURN(br->ReadBool(&slice_header->mvd_l1_zero_flag));
442 }
443 if (pps->cabac_init_present_flag) {
444 TRUE_OR_RETURN(br->ReadBool(&slice_header->cabac_init_flag));
445 }
446 if (slice_header->slice_temporal_mvp_enabled_flag) {
447 if (slice_header->slice_type == kBSlice) {
448 TRUE_OR_RETURN(br->ReadBool(&slice_header->collocated_from_l0));
449 }
450 bool l0_greater_than_0 = slice_header->num_ref_idx_l0_active_minus1 > 0;
451 bool l1_greater_than_0 = slice_header->num_ref_idx_l1_active_minus1 > 0;
452 if (slice_header->collocated_from_l0 ? l0_greater_than_0
453 : l1_greater_than_0) {
454 TRUE_OR_RETURN(br->ReadUE(&slice_header->collocated_ref_idx));
455 }
456 }
457
458 if ((pps->weighted_pred_flag && slice_header->slice_type == kPSlice) ||
459 (pps->weighted_bipred_flag && slice_header->slice_type == kBSlice)) {
460 OK_OR_RETURN(SkipPredictionWeightTable(
461 slice_header->slice_type == kBSlice, *sps, *slice_header, br));
462 }
463 TRUE_OR_RETURN(br->ReadUE(&slice_header->five_minus_max_num_merge_cand));
464 }
465
466 TRUE_OR_RETURN(br->ReadSE(&slice_header->slice_qp_delta));
467 if (pps->slice_chroma_qp_offsets_present_flag) {
468 TRUE_OR_RETURN(br->ReadSE(&slice_header->slice_cb_qp_offset));
469 TRUE_OR_RETURN(br->ReadSE(&slice_header->slice_cr_qp_offset));
470 }
471
472 if (pps->chroma_qp_offset_list_enabled_flag) {
473 TRUE_OR_RETURN(
474 br->ReadBool(&slice_header->cu_chroma_qp_offset_enabled_flag));
475 }
476 if (pps->deblocking_filter_override_enabled_flag) {
477 TRUE_OR_RETURN(
478 br->ReadBool(&slice_header->deblocking_filter_override_flag));
479 }
480 if (slice_header->deblocking_filter_override_flag) {
481 TRUE_OR_RETURN(
482 br->ReadBool(&slice_header->slice_deblocking_filter_disabled_flag));
483 if (!slice_header->slice_deblocking_filter_disabled_flag) {
484 TRUE_OR_RETURN(br->ReadSE(&slice_header->slice_beta_offset_div2));
485 TRUE_OR_RETURN(br->ReadSE(&slice_header->slice_tc_offset_div2));
486 }
487 }
488 if (pps->loop_filter_across_slices_enabled_flag &&
489 (slice_header->slice_sao_luma_flag ||
490 slice_header->slice_sao_chroma_flag ||
491 !slice_header->slice_deblocking_filter_disabled_flag)) {
492 TRUE_OR_RETURN(br->ReadBool(
493 &slice_header->slice_loop_filter_across_slices_enabled_flag));
494 }
495 }
496
497 if (pps->tiles_enabled_flag || pps->entropy_coding_sync_enabled_flag) {
498 TRUE_OR_RETURN(br->ReadUE(&slice_header->num_entry_point_offsets));
499 if (slice_header->num_entry_point_offsets > 0) {
500 TRUE_OR_RETURN(br->ReadUE(&slice_header->offset_len_minus1));
501 slice_header->entry_point_offset_minus1.resize(
502 slice_header->num_entry_point_offsets);
503 for (int i = 0; i < slice_header->num_entry_point_offsets; i++) {
504 TRUE_OR_RETURN(
505 br->ReadBits(slice_header->offset_len_minus1 + 1,
506 &slice_header->entry_point_offset_minus1[i]));
507 }
508 }
509 }
510
511 if (pps->slice_segment_header_extension_present_flag) {
512 int extension_length;
513 TRUE_OR_RETURN(br->ReadUE(&extension_length));
514 TRUE_OR_RETURN(br->SkipBits(extension_length * 8));
515 }
516
517 OK_OR_RETURN(ByteAlignment(br));
518
519 slice_header->header_bit_size = nalu.payload_size() * 8 - br->NumBitsLeft();
520 return kOk;
521}
522
523H265Parser::Result H265Parser::ParsePps(const Nalu& nalu, int* pps_id) {
524 DCHECK_EQ(Nalu::H265_PPS, nalu.type());
525
526 // Reads most of the element, not reading the extension data.
527 H26xBitReader reader;
528 reader.Initialize(nalu.data() + nalu.header_size(), nalu.payload_size());
529 H26xBitReader* br = &reader;
530
531 *pps_id = -1;
532 std::unique_ptr<H265Pps> pps(new H265Pps);
533
534 TRUE_OR_RETURN(br->ReadUE(&pps->pic_parameter_set_id));
535 TRUE_OR_RETURN(br->ReadUE(&pps->seq_parameter_set_id));
536
537 TRUE_OR_RETURN(br->ReadBool(&pps->dependent_slice_segments_enabled_flag));
538 TRUE_OR_RETURN(br->ReadBool(&pps->output_flag_present_flag));
539 TRUE_OR_RETURN(br->ReadBits(3, &pps->num_extra_slice_header_bits));
540 TRUE_OR_RETURN(br->ReadBool(&pps->sign_data_hiding_enabled_flag));
541 TRUE_OR_RETURN(br->ReadBool(&pps->cabac_init_present_flag));
542
543 TRUE_OR_RETURN(br->ReadUE(&pps->num_ref_idx_l0_default_active_minus1));
544 TRUE_OR_RETURN(br->ReadUE(&pps->num_ref_idx_l1_default_active_minus1));
545 TRUE_OR_RETURN(br->ReadSE(&pps->init_qp_minus26));
546 TRUE_OR_RETURN(br->ReadBool(&pps->constrained_intra_pred_flag));
547 TRUE_OR_RETURN(br->ReadBool(&pps->transform_skip_enabled_flag));
548
549 TRUE_OR_RETURN(br->ReadBool(&pps->cu_qp_delta_enabled_flag));
550 if (pps->cu_qp_delta_enabled_flag)
551 TRUE_OR_RETURN(br->ReadUE(&pps->diff_cu_qp_delta_depth));
552 TRUE_OR_RETURN(br->ReadSE(&pps->cb_qp_offset));
553 TRUE_OR_RETURN(br->ReadSE(&pps->cr_qp_offset));
554
555 TRUE_OR_RETURN(br->ReadBool(&pps->slice_chroma_qp_offsets_present_flag));
556 TRUE_OR_RETURN(br->ReadBool(&pps->weighted_pred_flag));
557 TRUE_OR_RETURN(br->ReadBool(&pps->weighted_bipred_flag));
558 TRUE_OR_RETURN(br->ReadBool(&pps->transquant_bypass_enabled_flag));
559 TRUE_OR_RETURN(br->ReadBool(&pps->tiles_enabled_flag));
560 TRUE_OR_RETURN(br->ReadBool(&pps->entropy_coding_sync_enabled_flag));
561
562 if (pps->tiles_enabled_flag) {
563 TRUE_OR_RETURN(br->ReadUE(&pps->num_tile_columns_minus1));
564 TRUE_OR_RETURN(br->ReadUE(&pps->num_tile_rows_minus1));
565 TRUE_OR_RETURN(br->ReadBool(&pps->uniform_spacing_flag));
566 if (!pps->uniform_spacing_flag) {
567 pps->column_width_minus1.resize(pps->num_tile_columns_minus1);
568 for (int i = 0; i < pps->num_tile_columns_minus1; i++) {
569 TRUE_OR_RETURN(br->ReadUE(&pps->column_width_minus1[i]));
570 }
571 pps->row_height_minus1.resize(pps->num_tile_rows_minus1);
572 for (int i = 0; i < pps->num_tile_rows_minus1; i++) {
573 TRUE_OR_RETURN(br->ReadUE(&pps->row_height_minus1[i]));
574 }
575 }
576 TRUE_OR_RETURN(br->ReadBool(&pps->loop_filter_across_tiles_enabled_flag));
577 }
578
579 TRUE_OR_RETURN(br->ReadBool(&pps->loop_filter_across_slices_enabled_flag));
580 TRUE_OR_RETURN(br->ReadBool(&pps->deblocking_filter_control_present_flag));
581 if (pps->deblocking_filter_control_present_flag) {
582 TRUE_OR_RETURN(br->ReadBool(&pps->deblocking_filter_override_enabled_flag));
583 TRUE_OR_RETURN(br->ReadBool(&pps->deblocking_filter_disabled_flag));
584 if (!pps->deblocking_filter_disabled_flag) {
585 TRUE_OR_RETURN(br->ReadSE(&pps->beta_offset_div2));
586 TRUE_OR_RETURN(br->ReadSE(&pps->tc_offset_div2));
587 }
588 }
589
590 TRUE_OR_RETURN(br->ReadBool(&pps->scaling_list_data_present_flag));
591 if (pps->scaling_list_data_present_flag) {
592 OK_OR_RETURN(SkipScalingListData(br));
593 }
594
595 TRUE_OR_RETURN(br->ReadBool(&pps->lists_modification_present_flag));
596 TRUE_OR_RETURN(br->ReadUE(&pps->log2_parallel_merge_level_minus2));
597
598 TRUE_OR_RETURN(
599 br->ReadBool(&pps->slice_segment_header_extension_present_flag));
600
601 bool pps_extension_present_flag;
602 bool pps_range_extension_flag = false;
603 TRUE_OR_RETURN(br->ReadBool(&pps_extension_present_flag));
604 if (pps_extension_present_flag) {
605 TRUE_OR_RETURN(br->ReadBool(&pps_range_extension_flag));
606 // pps_multilayer_extension_flag, pps_3d_extension_flag, pps_extension_5bits
607 TRUE_OR_RETURN(br->SkipBits(1 + 1 + 5));
608 }
609
610 if (pps_range_extension_flag) {
611 if (pps->transform_skip_enabled_flag) {
612 // log2_max_transform_skip_block_size_minus2
613 int ignored;
614 TRUE_OR_RETURN(br->ReadUE(&ignored));
615 }
616
617 TRUE_OR_RETURN(br->SkipBits(1)); // cross_component_prediction_enabled_flag
618 TRUE_OR_RETURN(br->ReadBool(&pps->chroma_qp_offset_list_enabled_flag));
619 // Incomplete
620 }
621
622 // Ignore remaining extension data.
623
624 // This will replace any existing PPS instance.
625 *pps_id = pps->pic_parameter_set_id;
626 active_ppses_[*pps_id] = std::move(pps);
627
628 return kOk;
629}
630
631H265Parser::Result H265Parser::ParseSps(const Nalu& nalu, int* sps_id) {
632 DCHECK_EQ(Nalu::H265_SPS, nalu.type());
633
634 // Reads most of the element, not reading the extension data.
635 H26xBitReader reader;
636 reader.Initialize(nalu.data() + nalu.header_size(), nalu.payload_size());
637 H26xBitReader* br = &reader;
638
639 *sps_id = -1;
640
641 std::unique_ptr<H265Sps> sps(new H265Sps);
642
643 TRUE_OR_RETURN(br->ReadBits(4, &sps->video_parameter_set_id));
644 TRUE_OR_RETURN(br->ReadBits(3, &sps->max_sub_layers_minus1));
645 const bool multi_layer_ext_sps_flag =
646 nalu.nuh_layer_id() != 0 && sps->max_sub_layers_minus1 == 7;
647
648 const H265Vps* vps = active_vpses_[sps->video_parameter_set_id].get();
649
650 int layer_id_in_vps = 0;
651 if (vps != nullptr && vps->vps_max_layers_minus1 > 0) {
652 layer_id_in_vps = vps->layer_id_in_vps[nalu.nuh_layer_id()];
653 }
654 if (!multi_layer_ext_sps_flag) {
655 TRUE_OR_RETURN(br->ReadBool(&sps->temporal_id_nesting_flag));
656
657 OK_OR_RETURN(ReadProfileTierLevel(true, sps->max_sub_layers_minus1, br,
658 nullptr,
659 sps->general_profile_tier_level_data));
660 } else {
661 // VPS is needed in this case.
662 TRUE_OR_RETURN(vps != nullptr);
663
664 // Get profile/tier/level from the VPS.
665 // Assume the last (output) layer set is the target output layer set.
666 const int profile_tier_level_idx =
667 vps->profile_tier_level_idx[vps->vps_num_layer_sets_minus1]
668 [layer_id_in_vps];
669 TRUE_OR_RETURN(profile_tier_level_idx < vps->num_profile_tier_levels);
670 memcpy(sps->general_profile_tier_level_data,
671 vps->general_profile_tier_level_data[profile_tier_level_idx],
672 12 * sizeof(sps->general_profile_tier_level_data[0]));
673 }
674
675 TRUE_OR_RETURN(br->ReadUE(&sps->seq_parameter_set_id));
676
677 if (multi_layer_ext_sps_flag) {
678 int sps_rep_format_idx = 0;
679 bool update_rep_format_flag;
680 TRUE_OR_RETURN(br->ReadBool(&update_rep_format_flag));
681 if (update_rep_format_flag) {
682 TRUE_OR_RETURN(br->ReadBits(8, &sps_rep_format_idx));
683 // Currently only one rep_format() is supported in the VPS
684 TRUE_OR_RETURN(sps_rep_format_idx == 0);
685 }
686 const H265RepFormat* rep_format = &vps->rep_format[sps_rep_format_idx];
687 sps->chroma_format_idc = rep_format->chroma_format_vps_idc;
688 sps->separate_colour_plane_flag =
689 rep_format->separate_colour_plane_vps_flag;
690 sps->pic_width_in_luma_samples = rep_format->pic_width_vps_in_luma_samples;
691 sps->pic_height_in_luma_samples =
692 rep_format->pic_height_vps_in_luma_samples;
693 sps->conf_win_left_offset = rep_format->conf_win_vps_left_offset;
694 sps->conf_win_right_offset = rep_format->conf_win_vps_right_offset;
695 sps->conf_win_top_offset = rep_format->conf_win_vps_top_offset;
696 sps->conf_win_bottom_offset = rep_format->conf_win_vps_bottom_offset;
697 sps->bit_depth_luma_minus8 = rep_format->bit_depth_vps_luma_minus8;
698 sps->bit_depth_chroma_minus8 = rep_format->bit_depth_vps_chroma_minus8;
699 } else {
700 TRUE_OR_RETURN(br->ReadUE(&sps->chroma_format_idc));
701 if (sps->chroma_format_idc == 3) {
702 TRUE_OR_RETURN(br->ReadBool(&sps->separate_colour_plane_flag));
703 }
704 TRUE_OR_RETURN(br->ReadUE(&sps->pic_width_in_luma_samples));
705 TRUE_OR_RETURN(br->ReadUE(&sps->pic_height_in_luma_samples));
706
707 TRUE_OR_RETURN(br->ReadBool(&sps->conformance_window_flag));
708 if (sps->conformance_window_flag) {
709 TRUE_OR_RETURN(br->ReadUE(&sps->conf_win_left_offset));
710 TRUE_OR_RETURN(br->ReadUE(&sps->conf_win_right_offset));
711 TRUE_OR_RETURN(br->ReadUE(&sps->conf_win_top_offset));
712 TRUE_OR_RETURN(br->ReadUE(&sps->conf_win_bottom_offset));
713 }
714
715 TRUE_OR_RETURN(br->ReadUE(&sps->bit_depth_luma_minus8));
716 TRUE_OR_RETURN(br->ReadUE(&sps->bit_depth_chroma_minus8));
717 }
718 TRUE_OR_RETURN(br->ReadUE(&sps->log2_max_pic_order_cnt_lsb_minus4));
719
720 if (!multi_layer_ext_sps_flag) {
721 TRUE_OR_RETURN(br->ReadBool(&sps->sub_layer_ordering_info_present_flag));
722 int start = sps->sub_layer_ordering_info_present_flag
723 ? 0
724 : sps->max_sub_layers_minus1;
725 for (int i = start; i <= sps->max_sub_layers_minus1; i++) {
726 TRUE_OR_RETURN(br->ReadUE(&sps->max_dec_pic_buffering_minus1[i]));
727 TRUE_OR_RETURN(br->ReadUE(&sps->max_num_reorder_pics[i]));
728 TRUE_OR_RETURN(br->ReadUE(&sps->max_latency_increase_plus1[i]));
729 }
730 }
731 TRUE_OR_RETURN(br->ReadUE(&sps->log2_min_luma_coding_block_size_minus3));
732 TRUE_OR_RETURN(br->ReadUE(&sps->log2_diff_max_min_luma_coding_block_size));
733 TRUE_OR_RETURN(br->ReadUE(&sps->log2_min_luma_transform_block_size_minus2));
734 TRUE_OR_RETURN(br->ReadUE(&sps->log2_diff_max_min_luma_transform_block_size));
735 TRUE_OR_RETURN(br->ReadUE(&sps->max_transform_hierarchy_depth_inter));
736 TRUE_OR_RETURN(br->ReadUE(&sps->max_transform_hierarchy_depth_intra));
737
738 TRUE_OR_RETURN(br->ReadBool(&sps->scaling_list_enabled_flag));
739 if (sps->scaling_list_enabled_flag) {
740 bool sps_infer_scaling_list_flag = false;
741 if (multi_layer_ext_sps_flag) {
742 TRUE_OR_RETURN(br->ReadBool(&sps_infer_scaling_list_flag));
743 }
744 if (sps_infer_scaling_list_flag) {
745 TRUE_OR_RETURN(br->SkipBits(6)); // sps_scaling_list_ref_layer_id
746 } else {
747 TRUE_OR_RETURN(br->ReadBool(&sps->scaling_list_data_present_flag));
748 if (sps->scaling_list_data_present_flag) {
749 OK_OR_RETURN(SkipScalingListData(br));
750 }
751 }
752 }
753
754 TRUE_OR_RETURN(br->ReadBool(&sps->amp_enabled_flag));
755 TRUE_OR_RETURN(br->ReadBool(&sps->sample_adaptive_offset_enabled_flag));
756 TRUE_OR_RETURN(br->ReadBool(&sps->pcm_enabled_flag));
757 if (sps->pcm_enabled_flag) {
758 TRUE_OR_RETURN(br->ReadBits(4, &sps->pcm_sample_bit_depth_luma_minus1));
759 TRUE_OR_RETURN(br->ReadBits(4, &sps->pcm_sample_bit_depth_chroma_minus1));
760 TRUE_OR_RETURN(
761 br->ReadUE(&sps->log2_min_pcm_luma_coding_block_size_minus3));
762 TRUE_OR_RETURN(
763 br->ReadUE(&sps->log2_diff_max_min_pcm_luma_coding_block_size));
764 TRUE_OR_RETURN(br->ReadBool(&sps->pcm_loop_filter_disabled_flag));
765 }
766
767 TRUE_OR_RETURN(br->ReadUE(&sps->num_short_term_ref_pic_sets));
768 sps->st_ref_pic_sets.resize(sps->num_short_term_ref_pic_sets);
769 for (int i = 0; i < sps->num_short_term_ref_pic_sets; i++) {
770 OK_OR_RETURN(ParseReferencePictureSet(sps->num_short_term_ref_pic_sets, i,
771 sps->st_ref_pic_sets, br,
772 &sps->st_ref_pic_sets[i]));
773 }
774
775 TRUE_OR_RETURN(br->ReadBool(&sps->long_term_ref_pic_present_flag));
776 if (sps->long_term_ref_pic_present_flag) {
777 TRUE_OR_RETURN(br->ReadUE(&sps->num_long_term_ref_pics));
778 sps->lt_ref_pic_poc_lsb.resize(sps->num_long_term_ref_pics);
779 sps->used_by_curr_pic_lt_flag.resize(sps->num_long_term_ref_pics);
780 for (int i = 0; i < sps->num_long_term_ref_pics; i++) {
781 TRUE_OR_RETURN(br->ReadBits(sps->log2_max_pic_order_cnt_lsb_minus4 + 4,
782 &sps->lt_ref_pic_poc_lsb[i]));
783 bool temp;
784 TRUE_OR_RETURN(br->ReadBool(&temp));
785 sps->used_by_curr_pic_lt_flag[i] = temp;
786 }
787 }
788
789 TRUE_OR_RETURN(br->ReadBool(&sps->temporal_mvp_enabled_flag));
790 TRUE_OR_RETURN(br->ReadBool(&sps->strong_intra_smoothing_enabled_flag));
791
792 TRUE_OR_RETURN(br->ReadBool(&sps->vui_parameters_present));
793 if (sps->vui_parameters_present) {
794 OK_OR_RETURN(ParseVuiParameters(sps->max_sub_layers_minus1, br,
795 &sps->vui_parameters));
796 }
797
798 // Ignore remaining extension data.
799
800 // This will replace any existing SPS instance.
801 *sps_id = sps->seq_parameter_set_id;
802 active_spses_[*sps_id] = std::move(sps);
803
804 return kOk;
805}
806
807H265Parser::Result H265Parser::ParseVps(const Nalu& nalu, int* vps_id) {
808 DCHECK_EQ(Nalu::H265_VPS, nalu.type());
809
810 // Reads only the data needed.
811 H26xBitReader reader;
812 reader.Initialize(nalu.data() + nalu.header_size(), nalu.payload_size());
813 H26xBitReader* br = &reader;
814
815 bool temp_bool;
816 int temp_int;
817
818 std::unique_ptr<H265Vps> vps(new H265Vps);
819
820 *vps_id = -1;
821 TRUE_OR_RETURN(br->ReadBits(4, &vps->vps_video_parameter_set_id));
822
823 TRUE_OR_RETURN(br->ReadBool(&vps->vps_base_layer_internal_flag));
824 TRUE_OR_RETURN(br->ReadBool(&vps->vps_base_layer_available_flag));
825
826 TRUE_OR_RETURN(br->ReadBits(6, &vps->vps_max_layers_minus1));
827 TRUE_OR_RETURN(vps->vps_max_layers_minus1 + 1 <= kMaxLayers);
828
829 TRUE_OR_RETURN(br->ReadBits(3, &vps->vps_max_sub_layers_minus1));
830
831 // vps_temporal_id_nesting_flag, vps_reserved_0xffff_16bits
832 TRUE_OR_RETURN(br->SkipBits(17));
833
834 OK_OR_RETURN(
835 ReadProfileTierLevel(true, vps->vps_max_sub_layers_minus1, br, nullptr,
836 vps.get()->general_profile_tier_level_data[0]));
837 vps->num_profile_tier_levels = 1;
838
839 // vps_sub_layer_ordering_info_present_flag
840 TRUE_OR_RETURN(br->ReadBool(&temp_bool));
841 int start = temp_bool ? 0 : vps->vps_max_sub_layers_minus1;
842 for (int i = start; i <= vps->vps_max_sub_layers_minus1; i++) {
843 // vps_max_dec_pic_buffering_minus1[i], vps_max_num_reorder_pics[i],
844 // vps_max_latency_increase_plus1[i]
845 TRUE_OR_RETURN(br->ReadUE(&temp_int));
846 TRUE_OR_RETURN(br->ReadUE(&temp_int));
847 TRUE_OR_RETURN(br->ReadUE(&temp_int));
848 }
849
850 TRUE_OR_RETURN(br->ReadBits(6, &vps->vps_max_layer_id));
851 TRUE_OR_RETURN(br->ReadUE(&vps->vps_num_layer_sets_minus1));
852
853 if ((vps->vps_max_layers_minus1 < 1 || vps->vps_num_layer_sets_minus1 < 1) ||
854 (!vps->vps_base_layer_internal_flag ||
855 !vps->vps_base_layer_internal_flag) ||
856 (vps->vps_max_layer_id < vps->vps_max_layers_minus1)) {
857 // 1. Must have more than 1 layer set for stereo video.
858 // 2. The base layer must included within the bitstream.
859 // 3. Must have enough layer ID range to support the number of layers.
860
861 // If any one of the above conditions fails, assume just a single layer
862 // video.
863 vps->vps_max_layers_minus1 = 0;
864 *vps_id = vps->vps_video_parameter_set_id;
865 active_vpses_[*vps_id] = std::move(vps);
866 return kOk;
867 }
868
869 // Define each layer set information: list of layer IDs, etc.
870 int layer_set_layer_id_list[kMaxLayerSets][kMaxLayerIdPlus1];
871 int num_layers_in_id_list[kMaxLayerSets];
872 int layer_set_max_layer_id[kMaxLayerSets];
873 // The first layer set is comprised of only the base layer.
874 layer_set_layer_id_list[0][0] = 0;
875 num_layers_in_id_list[0] = 1;
876 layer_set_max_layer_id[0] = 0;
877 // Define other layer sets.
878 for (int i = 1; i <= vps->vps_num_layer_sets_minus1; i++) {
879 int n = 0;
880 for (int j = 0; j <= vps->vps_max_layer_id; j++) {
881 bool layer_id_included_flag;
882 TRUE_OR_RETURN(br->ReadBool(&layer_id_included_flag));
883 if (layer_id_included_flag) {
884 layer_set_layer_id_list[i][n++] = j;
885 layer_set_max_layer_id[i] = j;
886 }
887 }
888 num_layers_in_id_list[i] = n;
889 }
890
891 TRUE_OR_RETURN(br->ReadBool(&temp_bool)); // vps_timing_info_present_flag
892 if (temp_bool) {
893 TRUE_OR_RETURN(br->SkipBits(64)); // vps_num_units_in_tick, vps_time_scale
894 TRUE_OR_RETURN(
895 br->ReadBool(&temp_bool)); // vps_poc_proportional_to_timing_flag
896 if (temp_bool) {
897 TRUE_OR_RETURN(
898 br->ReadUE(&temp_int)); // vps_num_ticks_poc_diff_one_minus1
899 }
900 TRUE_OR_RETURN(br->ReadUE(&temp_int)); // vps_num_hrd_parameters
901 for (int i = 0; i < temp_int; i++) {
902 int hrd_layer_set_idx;
903 TRUE_OR_RETURN(br->ReadUE(&hrd_layer_set_idx));
904
905 bool common_inf_present_flag = true;
906 if (i != 0) {
907 TRUE_OR_RETURN(br->ReadBool(&common_inf_present_flag));
908 }
909 OK_OR_RETURN(SkipHrdParameters(common_inf_present_flag,
910 vps->vps_max_sub_layers_minus1, br));
911 }
912 }
913
914 // For stereo video, vps_extension() needs to be parsed.
915 TRUE_OR_RETURN(br->ReadBool(&temp_bool)); // vps_extension_flag
916 if (!temp_bool) {
917 // If no vps_extension(), then fallback to single layer HEVC.
918 vps->vps_max_layers_minus1 = 0;
919 *vps_id = vps->vps_video_parameter_set_id;
920 active_vpses_[*vps_id] = std::move(vps);
921 return kOk;
922 }
923
924 OK_OR_RETURN(ByteAlignment(br));
925
926 OK_OR_RETURN(
927 ReadProfileTierLevel(false, vps->vps_max_sub_layers_minus1, br,
928 vps.get()->general_profile_tier_level_data[0],
929 vps.get()->general_profile_tier_level_data[1]));
930
931 bool splitting_flag;
932 bool scalability_mask_flag[16];
933 int num_scalability_types = 0;
934 TRUE_OR_RETURN(br->ReadBool(&splitting_flag));
935 for (int i = 0; i < 16; i++) {
936 TRUE_OR_RETURN(br->ReadBool(&scalability_mask_flag[i]));
937 if (scalability_mask_flag[i]) {
938 num_scalability_types++;
939 }
940 }
941
942 // As listed in Table F.1 of the spec, num_scalability_types indicates the
943 // number of different scalability dimensions. If there is no scalability
944 // dimension, then we simply have a single-layer HEVC. Currently, only 2
945 // view multi-view coding is supported; in other cases, simply fallback to
946 // single-layer HEVC.
947 if (num_scalability_types == 0 ||
948 num_scalability_types > kMaxScalabilityTypes ||
949 !scalability_mask_flag[1]) {
950 vps->vps_max_sub_layers_minus1 = 0;
951 *vps_id = vps->vps_video_parameter_set_id;
952 active_vpses_[*vps_id] = std::move(vps);
953 return kOk;
954 }
955
956 vps->scalability_type = H265Vps::kMultiview;
957
958 int dimension_id_len_minus1[kMaxScalabilityTypes];
959 for (int i = 0; i < num_scalability_types - (splitting_flag ? 1 : 0); i++) {
960 TRUE_OR_RETURN(br->ReadBits(3, &dimension_id_len_minus1[i]));
961 }
962
963 int dim_bit_offset[kMaxScalabilityTypes + 1];
964 dim_bit_offset[0] = 0;
965 if (splitting_flag) {
966 for (int i = 1; i < num_scalability_types; i++) {
967 for (int j = 0; j < i; j++) {
968 dim_bit_offset[i] += dimension_id_len_minus1[j] + 1;
969 }
970 }
971 dim_bit_offset[num_scalability_types] = 6;
972 }
973
974 int dimension_id[kMaxLayers][kMaxScalabilityTypes];
975 for (int j = 0; j < num_scalability_types; j++) {
976 dimension_id[0][j] = 0;
977 }
978
979 // Get layer_id_in_nuh that maps the layer ID used in this VPS to the NAL
980 // unit header's parsed layer ID - nuh_layer_id.
981 int layer_id_in_nuh[kMaxLayers];
982 layer_id_in_nuh[0] = 0;
983
984 TRUE_OR_RETURN(br->ReadBool(&temp_bool)); // vps_nuh_layer_id_present_flag
985 for (int i = 1; i <= vps->vps_max_layers_minus1; i++) {
986 if (temp_bool) {
987 TRUE_OR_RETURN(br->ReadBits(6, &layer_id_in_nuh[i]));
988 } else {
989 layer_id_in_nuh[i] = i;
990 }
991 if (!splitting_flag) {
992 for (int j = 0; j < num_scalability_types; j++) {
993 TRUE_OR_RETURN(
994 br->ReadBits(dimension_id_len_minus1[j] + 1, &dimension_id[i][j]));
995 }
996 } else {
997 for (int j = 0; j < num_scalability_types; j++) {
998 dimension_id[i][j] =
999 (layer_id_in_nuh[i] & ((1 << dim_bit_offset[j + 1]) - 1)) >>
1000 dim_bit_offset[j];
1001 }
1002 }
1003 }
1004
1005 // Derive view_order_idx[] and num_views following (F-3) in
1006 // Subsection F.7.4.3.1.1 of the standard.
1007 int view_order_idx[kMaxLayerIdPlus1];
1008 vps->num_views = 1;
1009 for (int i = 0; i <= vps->vps_max_layers_minus1; i++) {
1010 view_order_idx[layer_id_in_nuh[i]] = -1;
1011 for (int sm_idx = 0, j = 0; sm_idx < 16; sm_idx++) {
1012 if (scalability_mask_flag[sm_idx]) {
1013 if (sm_idx == 1) { // multiview
1014 // Note that view_order_idx is expected to be an index as it is used
1015 // to access view_id_val[]; however, dimension_id[i][j] is not
1016 // expected to follow the index constraint. It is up to the encoder
1017 // to ensure that the dimension_id[i][j] is consistent with the use
1018 // of view_order_idx.
1019 view_order_idx[layer_id_in_nuh[i]] = dimension_id[i][j];
1020 }
1021 j++;
1022 }
1023 }
1024 if (i > 0) {
1025 bool new_view = true;
1026 for (int j = 0; j < i; j++) {
1027 if (view_order_idx[layer_id_in_nuh[i]] ==
1028 view_order_idx[layer_id_in_nuh[j]]) {
1029 new_view = false;
1030 break;
1031 }
1032 }
1033 if (new_view) {
1034 vps->num_views++;
1035 }
1036 }
1037 }
1038
1039 int view_id_len;
1040 TRUE_OR_RETURN(br->ReadBits(4, &view_id_len));
1041 if (vps->num_views != kNumViews || view_id_len == 0) {
1042 NOTIMPLEMENTED() << "Only multiview extension with 2 views is supported.";
1043 return kUnsupportedStream;
1044 }
1045
1046 int view_id_val[kNumViews];
1047 for (int i = 0; i < vps->num_views; i++) {
1048 TRUE_OR_RETURN(br->ReadBits(view_id_len, &view_id_val[i]));
1049 }
1050
1051 for (int i = 0; i <= vps->vps_max_layers_minus1; i++) {
1052 vps->layer_id_in_vps[layer_id_in_nuh[i]] = i;
1053 }
1054 for (int i = 0; i <= vps->vps_max_layer_id; i++) {
1055 int view_id_val_idx = std::min(view_order_idx[i], vps->num_views - 1);
1056 vps->view_id[vps->layer_id_in_vps[i]] =
1057 view_id_val_idx >= 0 ? view_id_val[view_id_val_idx] : kInvalidId;
1058 }
1059
1060 // Derive H.265 layer dependency structure following (F-4) in
1061 // Subsection F.7.4.3.1.1 of the standard.
1062 bool direct_dependency_flag[kMaxLayers][kMaxLayers];
1063 bool dependency_flag[kMaxLayers][kMaxLayers];
1064 for (int i = 1; i <= vps->vps_max_layers_minus1; i++) {
1065 for (int j = 0; j < i; j++) {
1066 TRUE_OR_RETURN(br->ReadBool(&direct_dependency_flag[i][j]));
1067 dependency_flag[i][j] = direct_dependency_flag[i][j];
1068 }
1069 }
1070 for (int i = 1; i <= vps->vps_max_layers_minus1; i++) {
1071 for (int j = 0; j < vps->vps_max_layers_minus1; j++) {
1072 for (int k = 0; k < i; k++) {
1073 if (dependency_flag[i][k] && dependency_flag[k][j]) {
1074 dependency_flag[i][j] = true;
1075 break;
1076 }
1077 }
1078 }
1079 }
1080
1081 // Derive num_direct_ref_layers following (F-5) in Subsection F.7.4.3.1.1.
1082 for (int i = 1; i <= vps->vps_max_layers_minus1; i++) {
1083 int d = 0;
1084 for (int j = 0; j < i; j++) {
1085 if (direct_dependency_flag[i][j]) {
1086 vps->id_direct_ref_layers[layer_id_in_nuh[i]][d++] = layer_id_in_nuh[j];
1087 }
1088 }
1089 vps->num_direct_ref_layers[layer_id_in_nuh[i]] = d;
1090 }
1091 // Derive num_independent_layers following (F-6) in Subsection F.7.4.3.1.1.
1092 int num_independent_layers = 0;
1093 for (int i = 0; i <= vps->vps_max_layers_minus1; i++) {
1094 if (vps->num_direct_ref_layers[layer_id_in_nuh[i]] == 0) {
1095 num_independent_layers++;
1096 }
1097 }
1098
1099 if (num_independent_layers > 1) {
1100 NOTIMPLEMENTED() << "Only single independent layer is supported.";
1101 return kUnsupportedStream;
1102 }
1103
1104 // Since num_independent_layers <= 1, no need to parse num_add_layer_sets or
1105 // highest_layer_idx_plus1.
1106
1107 TRUE_OR_RETURN(
1108 br->ReadBool(&temp_bool)); // vps_sub_layers_max_minus1_present_flag
1109 if (temp_bool) {
1110 for (int i = 0; i <= vps->vps_max_layers_minus1; i++) {
1111 TRUE_OR_RETURN(br->ReadBits(3, &vps->sub_layers_vps_max_minus1[i]));
1112 }
1113 } else {
1114 for (int i = 0; i <= vps->vps_max_layers_minus1; i++) {
1115 vps->sub_layers_vps_max_minus1[i] = vps->vps_max_sub_layers_minus1;
1116 }
1117 }
1118
1119 TRUE_OR_RETURN(br->ReadBool(&temp_bool)); // max_tid_ref_present_flag
1120 if (temp_bool) {
1121 for (int i = 0; i <= vps->vps_max_layers_minus1; i++) {
1122 for (int j = i + 1; j <= vps->vps_max_layers_minus1; j++) {
1123 if (direct_dependency_flag[j][i]) {
1124 TRUE_OR_RETURN(
1125 br->ReadBits(3, &vps->max_tid_il_ref_pics_plus1[i][j]));
1126 } else {
1127 vps->max_tid_il_ref_pics_plus1[i][j] = 7;
1128 }
1129 }
1130 }
1131 } else {
1132 for (int i = 0; i <= vps->vps_max_layers_minus1; i++) {
1133 for (int j = i + 1; j <= vps->vps_max_layers_minus1; j++) {
1134 vps->max_tid_il_ref_pics_plus1[i][j] = 7;
1135 }
1136 }
1137 }
1138
1139 TRUE_OR_RETURN(br->ReadBool(&vps->default_ref_layers_active_flag));
1140
1141 // Get profile_tier_level()s needed for non-base layer.
1142 TRUE_OR_RETURN(br->ReadUE(&temp_int)); // vps_num_profile_tier_level_minus1
1143 vps->num_profile_tier_levels = temp_int + 1;
1144 if (vps->num_profile_tier_levels > kMaxNumProfileTierLevels) {
1145 NOTIMPLEMENTED()
1146 << "Only up to " << kMaxNumProfileTierLevels
1147 << " profile_tier_levels are supported in the L-HEVC case.";
1148 return kUnsupportedStream;
1149 }
1150 // Note that vps_base_layer_internal_flag is always true, so i starts from 2
1151 if (vps->num_profile_tier_levels > 2) {
1152 for (int i = 2; i < vps->num_profile_tier_levels; i++) {
1153 TRUE_OR_RETURN(br->ReadBool(&temp_bool)); // vps_profile_present_flag[i]
1154 OK_OR_RETURN(ReadProfileTierLevel(
1155 temp_bool, vps->vps_max_sub_layers_minus1, br,
1156 vps.get()->general_profile_tier_level_data[i - 1],
1157 vps.get()->general_profile_tier_level_data[i]));
1158 }
1159 }
1160
1161 TRUE_OR_RETURN(br->ReadUE(&temp_int)); // num_add_olss
1162 if (temp_int > 0) {
1163 NOTIMPLEMENTED() << "No additional output layer sets are supported.";
1164 return kUnsupportedStream;
1165 }
1166 int num_output_layer_sets = vps->vps_num_layer_sets_minus1 + 1 + temp_int;
1167
1168 int default_output_layer_idc;
1169 TRUE_OR_RETURN(br->ReadBits(2, &default_output_layer_idc));
1170
1171 bool output_layer_flag[kMaxOuputLayerSets][kMaxLayerIdPlus1];
1172 int num_output_layers_in_output_layer_set[kMaxOuputLayerSets];
1173 int ols_highest_output_layer_id[kMaxOuputLayerSets];
1174 for (int i = 0; i <= vps->vps_num_layer_sets_minus1; i++) {
1175 num_output_layers_in_output_layer_set[i] = 0;
1176 ols_highest_output_layer_id[i] = layer_set_max_layer_id[i];
1177 if (default_output_layer_idc == 0) {
1178 for (int j = 0; j < num_layers_in_id_list[i]; j++) {
1179 output_layer_flag[i][j] = true;
1180 }
1181 num_output_layers_in_output_layer_set[i] = num_layers_in_id_list[i];
1182 } else if (default_output_layer_idc == 1) {
1183 for (int j = 0; j < num_layers_in_id_list[i]; j++) {
1184 output_layer_flag[i][j] =
1185 layer_set_layer_id_list[i][j] == layer_set_max_layer_id[i];
1186 }
1187 num_output_layers_in_output_layer_set[i] = 1;
1188 } else {
1189 output_layer_flag[0][0] = true;
1190 num_output_layers_in_output_layer_set[0] = 1;
1191 }
1192 }
1193
1194 // Below simplified as num_output_layer_sets == vps_num_layer_sets_minus1+1.
1195 for (int i = 1; i < num_output_layer_sets; i++) {
1196 if (default_output_layer_idc == 2) {
1197 for (int j = 0; j < num_layers_in_id_list[i]; j++) {
1198 TRUE_OR_RETURN(br->ReadBool(&output_layer_flag[i][j]));
1199 if (output_layer_flag[i][j]) {
1200 num_output_layers_in_output_layer_set[i] += 1;
1201 ols_highest_output_layer_id[i] = layer_set_layer_id_list[i][j];
1202 }
1203 }
1204 }
1205
1206 for (int j = 0; j < num_layers_in_id_list[i]; j++) {
1207 if (vps->num_profile_tier_levels > 1) {
1208 bool necessary_layer_flag = output_layer_flag[i][j];
1209 int bit_len = ceil(log2(vps->num_profile_tier_levels));
1210 if (!necessary_layer_flag) {
1211 int curr_layer_id_in_vps =
1212 vps->layer_id_in_vps[layer_set_layer_id_list[i][j]];
1213 for (int k = 0; k < j; k++) {
1214 int ref_layer_id_in_vps =
1215 vps->layer_id_in_vps[layer_set_layer_id_list[i][k]];
1216 if (dependency_flag[curr_layer_id_in_vps][ref_layer_id_in_vps]) {
1217 necessary_layer_flag = true;
1218 break;
1219 }
1220 }
1221 }
1222 if (necessary_layer_flag) {
1223 TRUE_OR_RETURN(
1224 br->ReadBits(bit_len, &vps->profile_tier_level_idx[i][j]));
1225 }
1226 }
1227 }
1228 if (num_output_layers_in_output_layer_set[i] == 1 &&
1229 vps->num_direct_ref_layers[ols_highest_output_layer_id[i]] > 0) {
1230 TRUE_OR_RETURN(br->SkipBits(1)); // alt_output_layer_flag[i]
1231 }
1232 }
1233
1234 TRUE_OR_RETURN(br->ReadUE(&temp_int)); // vps_num_rep_formats_minus1
1235 vps->num_rep_formats = temp_int + 1;
1236 if (vps->num_rep_formats > kMaxNumRepFromats) {
1237 NOTIMPLEMENTED() << "Only up to " << kMaxNumRepFromats
1238 << " rep_formats are supported.";
1239 return kUnsupportedStream;
1240 }
1241
1242 for (int i = 0; i < vps->num_rep_formats; i++) {
1243 // Parse rep_format().
1244 H265RepFormat* rep_format = &vps->rep_format[i];
1245 TRUE_OR_RETURN(
1246 br->ReadBits(16, &rep_format->pic_width_vps_in_luma_samples));
1247 TRUE_OR_RETURN(
1248 br->ReadBits(16, &rep_format->pic_height_vps_in_luma_samples));
1249 TRUE_OR_RETURN(
1250 br->ReadBool(&temp_bool)); // chroma_and_bit_depth_vps_present_flag
1251 if (temp_bool) {
1252 TRUE_OR_RETURN(br->ReadBits(2, &rep_format->chroma_format_vps_idc));
1253 if (rep_format->chroma_format_vps_idc == 3) {
1254 TRUE_OR_RETURN(
1255 br->ReadBool(&rep_format->separate_colour_plane_vps_flag));
1256 }
1257 TRUE_OR_RETURN(br->ReadBits(4, &rep_format->bit_depth_vps_luma_minus8));
1258 TRUE_OR_RETURN(br->ReadBits(4, &rep_format->bit_depth_vps_luma_minus8));
1259 }
1260 TRUE_OR_RETURN(br->ReadBool(&temp_bool)); // conformance_window_vps_flag
1261 if (temp_bool) {
1262 TRUE_OR_RETURN(br->ReadUE(&rep_format->conf_win_vps_left_offset));
1263 TRUE_OR_RETURN(br->ReadUE(&rep_format->conf_win_vps_right_offset));
1264 TRUE_OR_RETURN(br->ReadUE(&rep_format->conf_win_vps_top_offset));
1265 TRUE_OR_RETURN(br->ReadUE(&rep_format->conf_win_vps_bottom_offset));
1266 }
1267 }
1268
1269 // Since kMaxNumRepFromats and vps_num_rep_formats_minus1 == 0, no need to
1270 // parse rep_format_idx_present_flag. Since rep_format_idx_present_flag is
1271 // inferred to be 0, no need to parse vps_rep_format_idx[i].
1272
1273 TRUE_OR_RETURN(br->ReadBool(&vps->max_one_active_ref_layer_flag));
1274 // For stereo views, the secondary view only depends on the primary view, so
1275 // at most 1 ref layer is needed!
1276 TRUE_OR_RETURN(vps->max_one_active_ref_layer_flag);
1277
1278 TRUE_OR_RETURN(br->ReadBool(&temp_bool)); // vps_poc_lsb_aligned_flag
1279
1280 for (int i = 1; i <= vps->vps_max_layers_minus1; i++) {
1281 if (vps->num_direct_ref_layers[layer_id_in_nuh[i]] == 0) {
1282 TRUE_OR_RETURN(br->ReadBool(&vps->poc_lsb_not_present_flag[i]));
1283 } else {
1284 vps->poc_lsb_not_present_flag[i] = false;
1285 }
1286 }
1287
1288 // Ignore remaining data.
1289
1290 *vps_id = vps->vps_video_parameter_set_id;
1291
1292 active_vpses_[*vps_id] = std::move(vps);
1293
1294 return kOk;
1295}
1296
1297const H265Pps* H265Parser::GetPps(int pps_id) {
1298 return active_ppses_[pps_id].get();
1299}
1300
1301const H265Sps* H265Parser::GetSps(int sps_id) {
1302 return active_spses_[sps_id].get();
1303}
1304
1305const H265Vps* H265Parser::GetVps(int vps_id) {
1306 return active_vpses_[vps_id].get();
1307}
1308
1309H265Parser::Result H265Parser::ParseVuiParameters(int max_num_sub_layers_minus1,
1310 H26xBitReader* br,
1311 H265VuiParameters* vui) {
1312 // Reads whole element but ignores most of it.
1313 int ignored;
1314
1315 TRUE_OR_RETURN(br->ReadBool(&vui->aspect_ratio_info_present_flag));
1316 if (vui->aspect_ratio_info_present_flag) {
1317 TRUE_OR_RETURN(br->ReadBits(8, &vui->aspect_ratio_idc));
1318 if (vui->aspect_ratio_idc == H265VuiParameters::kExtendedSar) {
1319 TRUE_OR_RETURN(br->ReadBits(16, &vui->sar_width));
1320 TRUE_OR_RETURN(br->ReadBits(16, &vui->sar_height));
1321 }
1322 }
1323
1324 bool overscan_info_present_flag;
1325 TRUE_OR_RETURN(br->ReadBool(&overscan_info_present_flag));
1326 if (overscan_info_present_flag) {
1327 TRUE_OR_RETURN(br->SkipBits(1)); // overscan_appropriate_flag
1328 }
1329
1330 bool video_signal_type_present_flag;
1331 TRUE_OR_RETURN(br->ReadBool(&video_signal_type_present_flag));
1332 if (video_signal_type_present_flag) {
1333 TRUE_OR_RETURN(br->SkipBits(3)); // video_format
1334 TRUE_OR_RETURN(br->SkipBits(1)); // video_full_range_flag
1335
1336 bool colour_description_present_flag;
1337 TRUE_OR_RETURN(br->ReadBool(&colour_description_present_flag));
1338 if (colour_description_present_flag) {
1339 TRUE_OR_RETURN(
1340 br->ReadBits(8, &vui->color_primaries)); // color_primaries
1341 TRUE_OR_RETURN(br->ReadBits(8, &vui->transfer_characteristics));
1342 TRUE_OR_RETURN(
1343 br->ReadBits(8, &vui->matrix_coefficients)); // matrix_coeffs
1344 }
1345 }
1346
1347 bool chroma_loc_info_present_flag;
1348 TRUE_OR_RETURN(br->ReadBool(&chroma_loc_info_present_flag));
1349 if (chroma_loc_info_present_flag) {
1350 // chroma_sample_log_type_top_field, chroma_sample_log_type_bottom_field
1351 TRUE_OR_RETURN(br->ReadUE(&ignored));
1352 TRUE_OR_RETURN(br->ReadUE(&ignored));
1353 }
1354
1355 // neutral_chroma_indication_flag, field_seq_flag,
1356 // frame_field_info_present_flag.
1357 TRUE_OR_RETURN(br->SkipBits(3));
1358
1359 bool default_display_window_flag;
1360 TRUE_OR_RETURN(br->ReadBool(&default_display_window_flag));
1361 if (default_display_window_flag) {
1362 TRUE_OR_RETURN(br->ReadUE(&ignored)); // def_disp_win_left_offset
1363 TRUE_OR_RETURN(br->ReadUE(&ignored)); // def_disp_win_right_offset
1364 TRUE_OR_RETURN(br->ReadUE(&ignored)); // def_disp_win_top_offset
1365 TRUE_OR_RETURN(br->ReadUE(&ignored)); // def_disp_win_bottom_offset
1366 }
1367
1368 TRUE_OR_RETURN(br->ReadBool(&vui->vui_timing_info_present_flag));
1369 if (vui->vui_timing_info_present_flag) {
1370 READ_LONG_OR_RETURN(&vui->vui_num_units_in_tick);
1371 READ_LONG_OR_RETURN(&vui->vui_time_scale);
1372
1373 bool vui_poc_proportional_to_timing_flag;
1374 TRUE_OR_RETURN(br->ReadBool(&vui_poc_proportional_to_timing_flag));
1375 if (vui_poc_proportional_to_timing_flag) {
1376 // vui_num_ticks_poc_diff_one_minus1
1377 TRUE_OR_RETURN(br->ReadUE(&ignored));
1378 }
1379
1380 bool vui_hdr_parameters_present_flag;
1381 TRUE_OR_RETURN(br->ReadBool(&vui_hdr_parameters_present_flag));
1382 if (vui_hdr_parameters_present_flag) {
1383 OK_OR_RETURN(SkipHrdParameters(true, max_num_sub_layers_minus1, br));
1384 }
1385 }
1386
1387 TRUE_OR_RETURN(br->ReadBool(&vui->bitstream_restriction_flag));
1388 if (vui->bitstream_restriction_flag) {
1389 // tiles_fixed_structure_flag, motion_vectors_over_pic_boundaries_flag,
1390 // restricted_ref_pic_lists_flag.
1391 TRUE_OR_RETURN(br->SkipBits(3));
1392
1393 TRUE_OR_RETURN(br->ReadUE(&vui->min_spatial_segmentation_idc));
1394 TRUE_OR_RETURN(br->ReadUE(&ignored)); // max_bytes_per_pic_denom
1395 TRUE_OR_RETURN(br->ReadUE(&ignored)); // max_bits_per_min_cu_denum
1396 TRUE_OR_RETURN(br->ReadUE(&ignored)); // log2_max_mv_length_horizontal
1397 TRUE_OR_RETURN(br->ReadUE(&ignored)); // log2_max_mv_length_vertical
1398 }
1399
1400 return kOk;
1401}
1402
1403H265Parser::Result H265Parser::ParseReferencePictureSet(
1404 int num_short_term_ref_pic_sets,
1405 int st_rps_idx,
1406 const std::vector<H265ReferencePictureSet>& ref_pic_sets,
1407 H26xBitReader* br,
1408 H265ReferencePictureSet* out_ref_pic_set) {
1409 // Parses and processess a short-term reference picture set. This needs to
1410 // be done since the size of this element may be dependent on previous
1411 // reference picture sets.
1412
1413 bool inter_ref_pic_set_prediction = false;
1414 if (st_rps_idx != 0) {
1415 TRUE_OR_RETURN(br->ReadBool(&inter_ref_pic_set_prediction));
1416 }
1417
1418 if (inter_ref_pic_set_prediction) {
1419 int delta_idx = 1;
1420 if (st_rps_idx == num_short_term_ref_pic_sets) {
1421 TRUE_OR_RETURN(br->ReadUE(&delta_idx));
1422 delta_idx++;
1423 TRUE_OR_RETURN(delta_idx <= st_rps_idx);
1424 }
1425
1426 int ref_rps_idx = st_rps_idx - delta_idx;
1427 DCHECK_LE(0, ref_rps_idx);
1428 DCHECK_LT(ref_rps_idx, st_rps_idx);
1429
1430 bool delta_rps_sign;
1431 int abs_delta_rps_minus1;
1432 TRUE_OR_RETURN(br->ReadBool(&delta_rps_sign));
1433 TRUE_OR_RETURN(br->ReadUE(&abs_delta_rps_minus1));
1434 int delta_rps =
1435 delta_rps_sign ? -(abs_delta_rps_minus1 + 1) : abs_delta_rps_minus1 + 1;
1436
1437 int ref_num_delta_pocs = ref_pic_sets[ref_rps_idx].num_delta_pocs;
1438 std::vector<bool> used_by_curr_pic(ref_num_delta_pocs + 1);
1439 std::vector<bool> use_delta(ref_num_delta_pocs + 1);
1440 for (int j = 0; j <= ref_num_delta_pocs; j++) {
1441 bool temp;
1442 TRUE_OR_RETURN(br->ReadBool(&temp));
1443 used_by_curr_pic[j] = temp;
1444
1445 if (!used_by_curr_pic[j]) {
1446 TRUE_OR_RETURN(br->ReadBool(&temp));
1447 use_delta[j] = temp;
1448 } else {
1449 use_delta[j] = true;
1450 }
1451 }
1452
1453 int ref_num_positive_pics = ref_pic_sets[ref_rps_idx].num_positive_pics;
1454 int ref_num_negative_pics = ref_pic_sets[ref_rps_idx].num_negative_pics;
1455 int i;
1456
1457 // Update list 0.
1458 {
1459 i = 0;
1460 for (int j = ref_num_positive_pics - 1; j >= 0; j--) {
1461 int d_poc = ref_pic_sets[ref_rps_idx].delta_poc_s1[j] + delta_rps;
1462 if (d_poc < 0 && use_delta[ref_num_negative_pics + j]) {
1463 out_ref_pic_set->delta_poc_s0[i] = d_poc;
1464 out_ref_pic_set->used_by_curr_pic_s0[i] =
1465 used_by_curr_pic[ref_num_negative_pics + j];
1466 i++;
1467 }
1468 }
1469 if (delta_rps < 0 && use_delta[ref_num_delta_pocs]) {
1470 out_ref_pic_set->delta_poc_s0[i] = delta_rps;
1471 out_ref_pic_set->used_by_curr_pic_s0[i] =
1472 used_by_curr_pic[ref_num_delta_pocs];
1473 i++;
1474 }
1475 for (int j = 0; j < ref_num_negative_pics; j++) {
1476 int d_poc = ref_pic_sets[ref_rps_idx].delta_poc_s0[j] + delta_rps;
1477 if (d_poc < 0 && use_delta[j]) {
1478 out_ref_pic_set->delta_poc_s0[i] = d_poc;
1479 out_ref_pic_set->used_by_curr_pic_s0[i] = used_by_curr_pic[j];
1480 i++;
1481 }
1482 }
1483 out_ref_pic_set->num_negative_pics = i;
1484 }
1485
1486 // Update list 1.
1487 {
1488 i = 0;
1489 for (int j = ref_num_negative_pics - 1; j >= 0; j--) {
1490 int d_poc = ref_pic_sets[ref_rps_idx].delta_poc_s0[j] + delta_rps;
1491 if (d_poc > 0 && use_delta[j]) {
1492 out_ref_pic_set->delta_poc_s1[i] = d_poc;
1493 out_ref_pic_set->used_by_curr_pic_s1[i] = used_by_curr_pic[j];
1494 i++;
1495 }
1496 }
1497 if (delta_rps > 0 && use_delta[ref_num_delta_pocs]) {
1498 out_ref_pic_set->delta_poc_s1[i] = delta_rps;
1499 out_ref_pic_set->used_by_curr_pic_s1[i] =
1500 used_by_curr_pic[ref_num_delta_pocs];
1501 i++;
1502 }
1503 for (int j = 0; j < ref_num_positive_pics; j++) {
1504 int d_poc = ref_pic_sets[ref_rps_idx].delta_poc_s1[j] + delta_rps;
1505 if (d_poc > 0 && use_delta[ref_num_negative_pics + j]) {
1506 out_ref_pic_set->delta_poc_s1[i] = d_poc;
1507 out_ref_pic_set->used_by_curr_pic_s1[i] =
1508 used_by_curr_pic[ref_num_negative_pics + j];
1509 i++;
1510 }
1511 }
1512 out_ref_pic_set->num_positive_pics = i;
1513 }
1514 } else {
1515 TRUE_OR_RETURN(br->ReadUE(&out_ref_pic_set->num_negative_pics));
1516 TRUE_OR_RETURN(out_ref_pic_set->num_negative_pics <= kMaxRefPicSetCount);
1517 TRUE_OR_RETURN(br->ReadUE(&out_ref_pic_set->num_positive_pics));
1518 TRUE_OR_RETURN(out_ref_pic_set->num_positive_pics <= kMaxRefPicSetCount);
1519
1520 int prev_poc = 0;
1521 for (int i = 0; i < out_ref_pic_set->num_negative_pics; i++) {
1522 int delta_poc_s0_minus1;
1523 TRUE_OR_RETURN(br->ReadUE(&delta_poc_s0_minus1));
1524 out_ref_pic_set->delta_poc_s0[i] = prev_poc - (delta_poc_s0_minus1 + 1);
1525 prev_poc = out_ref_pic_set->delta_poc_s0[i];
1526
1527 TRUE_OR_RETURN(br->ReadBool(&out_ref_pic_set->used_by_curr_pic_s0[i]));
1528 }
1529
1530 prev_poc = 0;
1531 for (int i = 0; i < out_ref_pic_set->num_positive_pics; i++) {
1532 int delta_poc_s1_minus1;
1533 TRUE_OR_RETURN(br->ReadUE(&delta_poc_s1_minus1));
1534 out_ref_pic_set->delta_poc_s1[i] = prev_poc + delta_poc_s1_minus1 + 1;
1535 prev_poc = out_ref_pic_set->delta_poc_s1[i];
1536
1537 TRUE_OR_RETURN(br->ReadBool(&out_ref_pic_set->used_by_curr_pic_s1[i]));
1538 }
1539 }
1540
1541 out_ref_pic_set->num_delta_pocs =
1542 out_ref_pic_set->num_positive_pics + out_ref_pic_set->num_negative_pics;
1543 return kOk;
1544}
1545
1546H265Parser::Result H265Parser::SkipReferencePictureListModification(
1547 const H265SliceHeader& slice_header,
1548 const H265Pps&,
1549 int num_pic_total_curr,
1550 H26xBitReader* br) {
1551 // Reads whole element but ignores it all.
1552
1553 bool ref_pic_list_modification_flag_l0;
1554 TRUE_OR_RETURN(br->ReadBool(&ref_pic_list_modification_flag_l0));
1555 if (ref_pic_list_modification_flag_l0) {
1556 for (int i = 0; i <= slice_header.num_ref_idx_l0_active_minus1; i++) {
1557 TRUE_OR_RETURN(br->SkipBits(ceil(log2(num_pic_total_curr))));
1558 }
1559 }
1560
1561 if (slice_header.slice_type == kBSlice) {
1562 bool ref_pic_list_modification_flag_l1;
1563 TRUE_OR_RETURN(br->ReadBool(&ref_pic_list_modification_flag_l1));
1564 if (ref_pic_list_modification_flag_l1) {
1565 for (int i = 0; i <= slice_header.num_ref_idx_l1_active_minus1; i++) {
1566 TRUE_OR_RETURN(br->SkipBits(ceil(log2(num_pic_total_curr))));
1567 }
1568 }
1569 }
1570
1571 return kOk;
1572}
1573
1574H265Parser::Result H265Parser::SkipPredictionWeightTablePart(
1575 int num_ref_idx_minus1,
1576 int chroma_array_type,
1577 H26xBitReader* br) {
1578 // Reads whole element, ignores it.
1579 int ignored;
1580 std::vector<bool> luma_weight_flag(num_ref_idx_minus1 + 1);
1581 std::vector<bool> chroma_weight_flag(num_ref_idx_minus1 + 1);
1582
1583 for (int i = 0; i <= num_ref_idx_minus1; i++) {
1584 bool temp;
1585 TRUE_OR_RETURN(br->ReadBool(&temp));
1586 luma_weight_flag[i] = temp;
1587 }
1588 if (chroma_array_type != 0) {
1589 for (int i = 0; i <= num_ref_idx_minus1; i++) {
1590 bool temp;
1591 TRUE_OR_RETURN(br->ReadBool(&temp));
1592 chroma_weight_flag[i] = temp;
1593 }
1594 }
1595 for (int i = 0; i <= num_ref_idx_minus1; i++) {
1596 if (luma_weight_flag[i]) {
1597 TRUE_OR_RETURN(br->ReadSE(&ignored)); // delta_luma_weight_l#
1598 TRUE_OR_RETURN(br->ReadSE(&ignored)); // luma_offset_l#
1599 }
1600 if (chroma_weight_flag[i]) {
1601 for (int j = 0; j < 2; j++) {
1602 TRUE_OR_RETURN(br->ReadSE(&ignored)); // delta_chroma_weight_l#
1603 TRUE_OR_RETURN(br->ReadSE(&ignored)); // delta_chroma_offset_l#
1604 }
1605 }
1606 }
1607
1608 return kOk;
1609}
1610
1611H265Parser::Result H265Parser::SkipPredictionWeightTable(
1612 bool is_b_slice,
1613 const H265Sps& sps,
1614 const H265SliceHeader& slice_header,
1615 H26xBitReader* br) {
1616 // Reads whole element, ignores it.
1617 int ignored;
1618 int chroma_array_type = sps.GetChromaArrayType();
1619
1620 TRUE_OR_RETURN(br->ReadUE(&ignored)); // luma_log2_weight_denom
1621 if (chroma_array_type != 0) {
1622 TRUE_OR_RETURN(br->ReadSE(&ignored)); // delta_chroma_log2_weight_denom
1623 }
1624 OK_OR_RETURN(SkipPredictionWeightTablePart(
1625 slice_header.num_ref_idx_l0_active_minus1, chroma_array_type, br));
1626 if (is_b_slice) {
1627 OK_OR_RETURN(SkipPredictionWeightTablePart(
1628 slice_header.num_ref_idx_l1_active_minus1, chroma_array_type, br));
1629 }
1630
1631 return kOk;
1632}
1633
1634H265Parser::Result H265Parser::ReadProfileTierLevel(
1635 bool profile_present,
1636 int max_num_sub_layers_minus1,
1637 H26xBitReader* br,
1638 int* prev_data,
1639 int* general_profile_tier_level_data) {
1640 // Reads whole element, ignores it.
1641
1642 if (profile_present) {
1643 // 11 bytes of general_profile_tier flags:
1644 // general_profile_space, general_tier_flag, general_profile_idc
1645 // general_profile_compativility_flag
1646 // general_progressive_source_flag
1647 // general_interlaced_source_flag
1648 // general_non_packed_constraint_flag
1649 // general_frame_only_constraint_flag
1650 // 44-bits of other flags
1651 for (int i = 0; i < 11; i++)
1652 TRUE_OR_RETURN(br->ReadBits(8, &general_profile_tier_level_data[i]));
1653 } else if (prev_data != nullptr) {
1654 memcpy(general_profile_tier_level_data, prev_data,
1655 kGeneralProfileTierLevelBytes *
1656 sizeof(general_profile_tier_level_data[0]));
1657 }
1658 // general_level_idc
1659 TRUE_OR_RETURN(br->ReadBits(8, &general_profile_tier_level_data[11]));
1660
1661 std::vector<bool> sub_layer_profile_present(max_num_sub_layers_minus1);
1662 std::vector<bool> sub_layer_level_present(max_num_sub_layers_minus1);
1663 for (int i = 0; i < max_num_sub_layers_minus1; i++) {
1664 bool profile, level;
1665 TRUE_OR_RETURN(br->ReadBool(&profile));
1666 TRUE_OR_RETURN(br->ReadBool(&level));
1667 sub_layer_profile_present[i] = profile;
1668 sub_layer_level_present[i] = level;
1669 }
1670
1671 if (max_num_sub_layers_minus1 > 0) {
1672 for (int i = max_num_sub_layers_minus1; i < 8; i++)
1673 TRUE_OR_RETURN(br->SkipBits(2)); // reserved_zero_2bits
1674 }
1675
1676 for (int i = 0; i < max_num_sub_layers_minus1; i++) {
1677 if (sub_layer_profile_present[i]) {
1678 // sub_layer_profile_space, sub_layer_tier_flag, sub_layer_profile_idc
1679 // sub_layer_profile_compatibility
1680 // sub_layer_reserved_zero_43bits
1681 // sub_layer_reserved_zero_bit
1682 TRUE_OR_RETURN(br->SkipBits(2 + 1 + 5 + 32 + 4 + 43 + 1));
1683 }
1684 if (sub_layer_level_present[i]) {
1685 TRUE_OR_RETURN(br->SkipBits(8));
1686 }
1687 }
1688
1689 return kOk;
1690}
1691
1692H265Parser::Result H265Parser::SkipScalingListData(H26xBitReader* br) {
1693 // Reads whole element, ignores it.
1694 int ignored;
1695 for (int size_id = 0; size_id < 4; size_id++) {
1696 for (int matrix_id = 0; matrix_id < 6;
1697 matrix_id += ((size_id == 3) ? 3 : 1)) {
1698 bool scaling_list_pred_mode;
1699 TRUE_OR_RETURN(br->ReadBool(&scaling_list_pred_mode));
1700 if (!scaling_list_pred_mode) {
1701 // scaling_list_pred_matrix_id_delta
1702 TRUE_OR_RETURN(br->ReadUE(&ignored));
1703 } else {
1704 int coefNum = std::min(64, (1 << (4 + (size_id << 1))));
1705 if (size_id > 1) {
1706 TRUE_OR_RETURN(br->ReadSE(&ignored)); // scaling_list_dc_coef_minus8
1707 }
1708
1709 for (int i = 0; i < coefNum; i++) {
1710 TRUE_OR_RETURN(br->ReadSE(&ignored)); // scaling_list_delta_coef
1711 }
1712 }
1713 }
1714 }
1715
1716 return kOk;
1717}
1718
1719H265Parser::Result H265Parser::SkipHrdParameters(bool common_inf_present_flag,
1720 int max_num_sub_layers_minus1,
1721 H26xBitReader* br) {
1722 int ignored;
1723 bool nal_hdr_parameters_present_flag = false;
1724 bool vcl_hdr_parameters_present_flag = false;
1725 bool sub_pic_hdr_params_present_flag = false;
1726 if (common_inf_present_flag) {
1727 TRUE_OR_RETURN(br->ReadBool(&nal_hdr_parameters_present_flag));
1728 TRUE_OR_RETURN(br->ReadBool(&vcl_hdr_parameters_present_flag));
1729 if (nal_hdr_parameters_present_flag || vcl_hdr_parameters_present_flag) {
1730 TRUE_OR_RETURN(br->ReadBool(&sub_pic_hdr_params_present_flag));
1731 if (sub_pic_hdr_params_present_flag) {
1732 // tick_divisor_minus2, du_cpb_removal_delay_increment_length_minus1,
1733 // sub_pic_cpb_params_in_pic_timing_sei_flag
1734 // dpb_output_delay_du_length_minus1
1735 TRUE_OR_RETURN(br->SkipBits(8 + 5 + 1 + 5));
1736 }
1737
1738 // bit_rate_scale, cpb_size_scale
1739 TRUE_OR_RETURN(br->SkipBits(4 + 4));
1740 if (sub_pic_hdr_params_present_flag)
1741 TRUE_OR_RETURN(br->SkipBits(4)); // cpb_size_du_scale
1742
1743 // initial_cpb_removal_delay_length_minus1,
1744 // au_cpb_removal_delay_length_minus1, dpb_output_delay_length_minus1
1745 TRUE_OR_RETURN(br->SkipBits(5 + 5 + 5));
1746 }
1747 }
1748
1749 for (int i = 0; i <= max_num_sub_layers_minus1; i++) {
1750 bool fixed_pic_rate_general_flag;
1751 bool fixed_pic_rate_within_cvs_flag = true;
1752 bool low_delay_hdr_flag = false;
1753 int cpb_cnt_minus1 = 0;
1754 TRUE_OR_RETURN(br->ReadBool(&fixed_pic_rate_general_flag));
1755 if (!fixed_pic_rate_general_flag)
1756 TRUE_OR_RETURN(br->ReadBool(&fixed_pic_rate_within_cvs_flag));
1757 if (fixed_pic_rate_within_cvs_flag)
1758 TRUE_OR_RETURN(br->ReadUE(&ignored)); // elemental_duration_ic_tc_minus1
1759 else
1760 TRUE_OR_RETURN(br->ReadBool(&low_delay_hdr_flag));
1761 if (!low_delay_hdr_flag)
1762 TRUE_OR_RETURN(br->ReadUE(&cpb_cnt_minus1));
1763
1764 if (nal_hdr_parameters_present_flag) {
1765 OK_OR_RETURN(SkipSubLayerHrdParameters(
1766 cpb_cnt_minus1, sub_pic_hdr_params_present_flag, br));
1767 }
1768 if (vcl_hdr_parameters_present_flag) {
1769 OK_OR_RETURN(SkipSubLayerHrdParameters(
1770 cpb_cnt_minus1, sub_pic_hdr_params_present_flag, br));
1771 }
1772 }
1773
1774 return kOk;
1775}
1776
1777H265Parser::Result H265Parser::SkipSubLayerHrdParameters(
1778 int cpb_cnt_minus1,
1779 bool sub_pic_hdr_params_present_flag,
1780 H26xBitReader* br) {
1781 int ignored;
1782 for (int i = 0; i <= cpb_cnt_minus1; i++) {
1783 TRUE_OR_RETURN(br->ReadUE(&ignored)); // bit_rate_value_minus1
1784 TRUE_OR_RETURN(br->ReadUE(&ignored)); // cpb_size_value_minus1
1785 if (sub_pic_hdr_params_present_flag) {
1786 TRUE_OR_RETURN(br->ReadUE(&ignored)); // cpb_size_du_value_minus1
1787 TRUE_OR_RETURN(br->ReadUE(&ignored)); // bit_rate_du_value_minus1
1788 }
1789
1790 TRUE_OR_RETURN(br->SkipBits(1)); // cbr_flag
1791 }
1792
1793 return kOk;
1794}
1795
1796H265Parser::Result H265Parser::ByteAlignment(H26xBitReader* br) {
1797 TRUE_OR_RETURN(br->SkipBits(1));
1798 TRUE_OR_RETURN(br->SkipBits(br->NumBitsLeft() % 8));
1799 return kOk;
1800}
1801
1802} // namespace media
1803} // namespace shaka
shaka::media::H265Parser::ParseSps
Result ParseSps(const Nalu &nalu, int *sps_id)
Definition h265_parser.cc:631
shaka::media::H265Parser::ParsePps
Result ParsePps(const Nalu &nalu, int *pps_id)
Definition h265_parser.cc:523
shaka::media::H265Parser::GetVps
const H265Vps * GetVps(int vps_id)
Definition h265_parser.cc:1305
shaka::media::H265Parser::ParseVps
Result ParseVps(const Nalu &nalu, int *vps_id)
Definition h265_parser.cc:807
shaka::media::H265Parser::GetSps
const H265Sps * GetSps(int sps_id)
Definition h265_parser.cc:1301
shaka::media::H265Parser::ParseSliceHeader
Result ParseSliceHeader(const Nalu &nalu, H265SliceHeader *slice_header)
Definition h265_parser.cc:286
shaka::media::H265Parser::GetPps
const H265Pps * GetPps(int pps_id)
Definition h265_parser.cc:1297
shaka::media::Nalu::is_video_slice
bool is_video_slice() const
Slice data partition NALs are not considered as slice NALs.
Definition nalu_reader.h:116
shaka::media::Nalu::header_size
uint64_t header_size() const
The size of the header, e.g. 1 for H.264.
Definition nalu_reader.h:99
shaka::media::Nalu::data
const uint8_t * data() const
This is the pointer to the Nalu data, pointing to the header.
Definition nalu_reader.h:96
shaka::media::Nalu::payload_size
uint64_t payload_size() const
Size of this Nalu minus header_size().
Definition nalu_reader.h:101
shaka
All the methods that are virtual are virtual for mocking.
Definition crypto_flags.cc:70
Generated on Fri Mar 20 2026 16:55:06 for Shaka Packager SDK by doxygen 1.9.8