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