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