Shaka Packager SDK
h265_parser.cc
1 // Copyright 2016 Google Inc. 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 <math.h>
10 #include <algorithm>
11 
12 #include "packager/base/logging.h"
13 #include "packager/media/base/macros.h"
14 #include "packager/media/codecs/nalu_reader.h"
15 
16 #define TRUE_OR_RETURN(a) \
17  do { \
18  if (!(a)) { \
19  DVLOG(1) << "Failure while processing " << #a; \
20  return kInvalidStream; \
21  } \
22  } while (0)
23 
24 #define OK_OR_RETURN(a) \
25  do { \
26  Result status = (a); \
27  if (status != kOk) \
28  return status; \
29  } while (false)
30 
31 namespace shaka {
32 namespace media {
33 
34 namespace {
35 int GetNumPicTotalCurr(const H265SliceHeader& slice_header,
36  const H265Sps& sps) {
37  int num_pic_total_curr = 0;
38  const H265ReferencePictureSet& ref_pic_set =
39  slice_header.short_term_ref_pic_set_sps_flag
40  ? sps.st_ref_pic_sets[slice_header.short_term_ref_pic_set_idx]
41  : slice_header.st_ref_pic_set;
42 
43  for (int i = 0; i < ref_pic_set.num_negative_pics; i++) {
44  if (ref_pic_set.used_by_curr_pic_s0[i])
45  num_pic_total_curr++;
46  }
47  for (int i = 0; i < ref_pic_set.num_positive_pics; i++) {
48  if (ref_pic_set.used_by_curr_pic_s1[i])
49  num_pic_total_curr++;
50  }
51 
52  return num_pic_total_curr + slice_header.used_by_curr_pic_lt;
53 }
54 
55 void GetAspectRatioInfo(const H265Sps& sps,
56  uint32_t* pixel_width,
57  uint32_t* pixel_height) {
58  // The default value is 0; so if this is not in the SPS, it will correctly
59  // assume unspecified.
60  int aspect_ratio_idc = sps.vui_parameters.aspect_ratio_idc;
61 
62  // Table E.1
63  switch (aspect_ratio_idc) {
64  case 1: *pixel_width = 1; *pixel_height = 1; break;
65  case 2: *pixel_width = 12; *pixel_height = 11; break;
66  case 3: *pixel_width = 10; *pixel_height = 11; break;
67  case 4: *pixel_width = 16; *pixel_height = 11; break;
68  case 5: *pixel_width = 40; *pixel_height = 33; break;
69  case 6: *pixel_width = 24; *pixel_height = 11; break;
70  case 7: *pixel_width = 20; *pixel_height = 11; break;
71  case 8: *pixel_width = 32; *pixel_height = 11; break;
72  case 9: *pixel_width = 80; *pixel_height = 33; break;
73  case 10: *pixel_width = 18; *pixel_height = 11; break;
74  case 11: *pixel_width = 15; *pixel_height = 11; break;
75  case 12: *pixel_width = 64; *pixel_height = 33; break;
76  case 13: *pixel_width = 160; *pixel_height = 99; break;
77  case 14: *pixel_width = 4; *pixel_height = 3; break;
78  case 15: *pixel_width = 3; *pixel_height = 2; break;
79  case 16: *pixel_width = 2; *pixel_height = 1; break;
80 
81  case 255:
82  *pixel_width = sps.vui_parameters.sar_width;
83  *pixel_height = sps.vui_parameters.sar_height;
84  break;
85 
86  default:
87  // Section E.3.1 specifies that other values should be interpreted as 0.
88  LOG(WARNING) << "Unknown aspect_ratio_idc " << aspect_ratio_idc;
89  FALLTHROUGH_INTENDED;
90  case 0:
91  // Unlike the spec, assume 1:1 if not specified.
92  *pixel_width = 1;
93  *pixel_height = 1;
94  break;
95  }
96 }
97 } // namespace
98 
99 bool ExtractResolutionFromSps(const H265Sps& sps,
100  uint32_t* coded_width,
101  uint32_t* coded_height,
102  uint32_t* pixel_width,
103  uint32_t* pixel_height) {
104  int crop_x = 0;
105  int crop_y = 0;
106  if (sps.conformance_window_flag) {
107  int sub_width_c = 0;
108  int sub_height_c = 0;
109 
110  // Table 6-1
111  switch (sps.chroma_format_idc) {
112  case 0: // Monochrome
113  sub_width_c = 1;
114  sub_height_c = 1;
115  break;
116  case 1: // 4:2:0
117  sub_width_c = 2;
118  sub_height_c = 2;
119  break;
120  case 2: // 4:2:2
121  sub_width_c = 2;
122  sub_height_c = 1;
123  break;
124  case 3: // 4:4:4
125  sub_width_c = 1;
126  sub_height_c = 1;
127  break;
128  default:
129  LOG(ERROR) << "Unexpected chroma_format_idc " << sps.chroma_format_idc;
130  return false;
131  }
132 
133  // Formula D-28, D-29
134  crop_x =
135  sub_width_c * (sps.conf_win_right_offset + sps.conf_win_left_offset);
136  crop_y =
137  sub_height_c * (sps.conf_win_bottom_offset + sps.conf_win_top_offset);
138  }
139 
140  // Formula D-28, D-29
141  *coded_width = sps.pic_width_in_luma_samples - crop_x;
142  *coded_height = sps.pic_height_in_luma_samples - crop_y;
143  GetAspectRatioInfo(sps, pixel_width, pixel_height);
144  return true;
145 }
146 
147 H265Pps::H265Pps() {}
148 H265Pps::~H265Pps() {}
149 
150 H265Sps::H265Sps() {}
151 H265Sps::~H265Sps() {}
152 
153 int H265Sps::GetPicSizeInCtbsY() const {
154  int min_cb_log2_size_y = log2_min_luma_coding_block_size_minus3 + 3;
155  int ctb_log2_size_y =
156  min_cb_log2_size_y + log2_diff_max_min_luma_coding_block_size;
157  int ctb_size_y = 1 << ctb_log2_size_y;
158 
159  // Round-up division.
160  int pic_width_in_ctbs_y = (pic_width_in_luma_samples - 1) / ctb_size_y + 1;
161  int pic_height_in_ctbs_y = (pic_height_in_luma_samples - 1) / ctb_size_y + 1;
162  return pic_width_in_ctbs_y * pic_height_in_ctbs_y;
163 }
164 
165 int H265Sps::GetChromaArrayType() const {
166  if (!separate_colour_plane_flag)
167  return chroma_format_idc;
168  else
169  return 0;
170 }
171 
172 H265ReferencePictureListModifications::H265ReferencePictureListModifications() {
173 }
174 H265ReferencePictureListModifications::
175  ~H265ReferencePictureListModifications() {}
176 
177 H265SliceHeader::H265SliceHeader() {}
178 H265SliceHeader::~H265SliceHeader() {}
179 
180 H265Parser::H265Parser() {}
181 H265Parser::~H265Parser() {}
182 
183 H265Parser::Result H265Parser::ParseSliceHeader(const Nalu& nalu,
184  H265SliceHeader* slice_header) {
185  DCHECK(nalu.is_video_slice());
186  *slice_header = H265SliceHeader();
187 
188  // Parses whole element.
189  H26xBitReader reader;
190  reader.Initialize(nalu.data() + nalu.header_size(), nalu.payload_size());
191  H26xBitReader* br = &reader;
192 
193  TRUE_OR_RETURN(br->ReadBool(&slice_header->first_slice_segment_in_pic_flag));
194  if (nalu.type() >= Nalu::H265_BLA_W_LP &&
195  nalu.type() <= Nalu::H265_RSV_IRAP_VCL23) {
196  TRUE_OR_RETURN(br->ReadBool(&slice_header->no_output_of_prior_pics_flag));
197  }
198 
199  TRUE_OR_RETURN(br->ReadUE(&slice_header->pic_parameter_set_id));
200  const H265Pps* pps = GetPps(slice_header->pic_parameter_set_id);
201  TRUE_OR_RETURN(pps);
202 
203  const H265Sps* sps = GetSps(pps->seq_parameter_set_id);
204  TRUE_OR_RETURN(sps);
205 
206  if (!slice_header->first_slice_segment_in_pic_flag) {
207  if (pps->dependent_slice_segments_enabled_flag) {
208  TRUE_OR_RETURN(br->ReadBool(&slice_header->dependent_slice_segment_flag));
209  }
210  const int bit_length = ceil(log2(sps->GetPicSizeInCtbsY()));
211  TRUE_OR_RETURN(br->ReadBits(bit_length, &slice_header->segment_address));
212  }
213 
214  if (!slice_header->dependent_slice_segment_flag) {
215  TRUE_OR_RETURN(br->SkipBits(pps->num_extra_slice_header_bits));
216  TRUE_OR_RETURN(br->ReadUE(&slice_header->slice_type));
217  if (pps->output_flag_present_flag) {
218  TRUE_OR_RETURN(br->ReadBool(&slice_header->pic_output_flag));
219  }
220  if (sps->separate_colour_plane_flag) {
221  TRUE_OR_RETURN(br->ReadBits(2, &slice_header->colour_plane_id));
222  }
223 
224  if (nalu.type() != Nalu::H265_IDR_W_RADL &&
225  nalu.type() != Nalu::H265_IDR_N_LP) {
226  TRUE_OR_RETURN(br->ReadBits(sps->log2_max_pic_order_cnt_lsb_minus4 + 4,
227  &slice_header->slice_pic_order_cnt_lsb));
228 
229  TRUE_OR_RETURN(
230  br->ReadBool(&slice_header->short_term_ref_pic_set_sps_flag));
231  if (!slice_header->short_term_ref_pic_set_sps_flag) {
232  OK_OR_RETURN(ParseReferencePictureSet(
233  sps->num_short_term_ref_pic_sets, sps->num_short_term_ref_pic_sets,
234  sps->st_ref_pic_sets, br, &slice_header->st_ref_pic_set));
235  } else if (sps->num_short_term_ref_pic_sets > 1) {
236  TRUE_OR_RETURN(
237  br->ReadBits(ceil(log2(sps->num_short_term_ref_pic_sets)),
238  &slice_header->short_term_ref_pic_set_idx));
239  }
240 
241  if (sps->long_term_ref_pic_present_flag) {
242  if (sps->num_long_term_ref_pics > 0) {
243  TRUE_OR_RETURN(br->ReadUE(&slice_header->num_long_term_sps));
244  }
245  TRUE_OR_RETURN(br->ReadUE(&slice_header->num_long_term_pics));
246 
247  const int pic_count =
248  slice_header->num_long_term_sps + slice_header->num_long_term_pics;
249  slice_header->long_term_pics_info.resize(pic_count);
250  for (int i = 0; i < pic_count; i++) {
251  if (i < slice_header->num_long_term_sps) {
252  int lt_idx_sps = 0;
253  if (sps->num_long_term_ref_pics > 1) {
254  TRUE_OR_RETURN(br->ReadBits(
255  ceil(log2(sps->num_long_term_ref_pics)), &lt_idx_sps));
256  }
257  if (sps->used_by_curr_pic_lt_flag[lt_idx_sps])
258  slice_header->used_by_curr_pic_lt++;
259  } else {
260  TRUE_OR_RETURN(br->SkipBits(sps->log2_max_pic_order_cnt_lsb_minus4 +
261  4)); // poc_lsb_lt
262  bool used_by_curr_pic_lt_flag;
263  TRUE_OR_RETURN(br->ReadBool(&used_by_curr_pic_lt_flag));
264  if (used_by_curr_pic_lt_flag)
265  slice_header->used_by_curr_pic_lt++;
266  }
267  TRUE_OR_RETURN(br->ReadBool(&slice_header->long_term_pics_info[i]
268  .delta_poc_msb_present_flag));
269  if (slice_header->long_term_pics_info[i].delta_poc_msb_present_flag) {
270  TRUE_OR_RETURN(br->ReadUE(
271  &slice_header->long_term_pics_info[i].delta_poc_msb_cycle_lt));
272  }
273  }
274  }
275 
276  if (sps->temporal_mvp_enabled_flag) {
277  TRUE_OR_RETURN(
278  br->ReadBool(&slice_header->slice_temporal_mvp_enabled_flag));
279  }
280  }
281 
282  if (nalu.nuh_layer_id() != 0) {
283  NOTIMPLEMENTED() << "Multi-layer streams are not supported.";
284  return kUnsupportedStream;
285  }
286 
287  if (sps->sample_adaptive_offset_enabled_flag) {
288  TRUE_OR_RETURN(br->ReadBool(&slice_header->slice_sao_luma_flag));
289  if (sps->GetChromaArrayType() != 0) {
290  TRUE_OR_RETURN(br->ReadBool(&slice_header->slice_sao_chroma_flag));
291  }
292  }
293 
294  slice_header->num_ref_idx_l0_active_minus1 =
295  pps->num_ref_idx_l0_default_active_minus1;
296  slice_header->num_ref_idx_l1_active_minus1 =
297  pps->num_ref_idx_l1_default_active_minus1;
298  if (slice_header->slice_type == kPSlice ||
299  slice_header->slice_type == kBSlice) {
300  TRUE_OR_RETURN(
301  br->ReadBool(&slice_header->num_ref_idx_active_override_flag));
302  if (slice_header->num_ref_idx_active_override_flag) {
303  TRUE_OR_RETURN(br->ReadUE(&slice_header->num_ref_idx_l0_active_minus1));
304  if (slice_header->slice_type == kBSlice) {
305  TRUE_OR_RETURN(
306  br->ReadUE(&slice_header->num_ref_idx_l1_active_minus1));
307  }
308  }
309 
310  const int num_pic_total_curr = GetNumPicTotalCurr(*slice_header, *sps);
311  if (pps->lists_modification_present_flag && num_pic_total_curr > 1) {
312  OK_OR_RETURN(SkipReferencePictureListModification(
313  *slice_header, *pps, num_pic_total_curr, br));
314  }
315 
316  if (slice_header->slice_type == kBSlice) {
317  TRUE_OR_RETURN(br->ReadBool(&slice_header->mvd_l1_zero_flag));
318  }
319  if (pps->cabac_init_present_flag) {
320  TRUE_OR_RETURN(br->ReadBool(&slice_header->cabac_init_flag));
321  }
322  if (slice_header->slice_temporal_mvp_enabled_flag) {
323  if (slice_header->slice_type == kBSlice) {
324  TRUE_OR_RETURN(br->ReadBool(&slice_header->collocated_from_l0));
325  }
326  bool l0_greater_than_0 = slice_header->num_ref_idx_l0_active_minus1 > 0;
327  bool l1_greater_than_0 = slice_header->num_ref_idx_l1_active_minus1 > 0;
328  if (slice_header->collocated_from_l0 ? l0_greater_than_0
329  : l1_greater_than_0) {
330  TRUE_OR_RETURN(br->ReadUE(&slice_header->collocated_ref_idx));
331  }
332  }
333 
334  if ((pps->weighted_pred_flag && slice_header->slice_type == kPSlice) ||
335  (pps->weighted_bipred_flag && slice_header->slice_type == kBSlice)) {
336  OK_OR_RETURN(SkipPredictionWeightTable(
337  slice_header->slice_type == kBSlice, *sps, *slice_header, br));
338  }
339  TRUE_OR_RETURN(br->ReadUE(&slice_header->five_minus_max_num_merge_cand));
340  }
341 
342  TRUE_OR_RETURN(br->ReadSE(&slice_header->slice_qp_delta));
343  if (pps->slice_chroma_qp_offsets_present_flag) {
344  TRUE_OR_RETURN(br->ReadSE(&slice_header->slice_cb_qp_offset));
345  TRUE_OR_RETURN(br->ReadSE(&slice_header->slice_cr_qp_offset));
346  }
347 
348  if (pps->chroma_qp_offset_list_enabled_flag) {
349  TRUE_OR_RETURN(
350  br->ReadBool(&slice_header->cu_chroma_qp_offset_enabled_flag));
351  }
352  if (pps->deblocking_filter_override_enabled_flag) {
353  TRUE_OR_RETURN(
354  br->ReadBool(&slice_header->deblocking_filter_override_flag));
355  }
356  if (slice_header->deblocking_filter_override_flag) {
357  TRUE_OR_RETURN(
358  br->ReadBool(&slice_header->slice_deblocking_filter_disabled_flag));
359  if (!slice_header->slice_deblocking_filter_disabled_flag) {
360  TRUE_OR_RETURN(br->ReadSE(&slice_header->slice_beta_offset_div2));
361  TRUE_OR_RETURN(br->ReadSE(&slice_header->slice_tc_offset_div2));
362  }
363  }
364  if (pps->loop_filter_across_slices_enabled_flag &&
365  (slice_header->slice_sao_luma_flag ||
366  slice_header->slice_sao_chroma_flag ||
367  !slice_header->slice_deblocking_filter_disabled_flag)) {
368  TRUE_OR_RETURN(br->ReadBool(
369  &slice_header->slice_loop_filter_across_slices_enabled_flag));
370  }
371  }
372 
373  if (pps->tiles_enabled_flag || pps->entropy_coding_sync_enabled_flag) {
374  TRUE_OR_RETURN(br->ReadUE(&slice_header->num_entry_point_offsets));
375  if (slice_header->num_entry_point_offsets > 0) {
376  TRUE_OR_RETURN(br->ReadUE(&slice_header->offset_len_minus1));
377  slice_header->entry_point_offset_minus1.resize(
378  slice_header->num_entry_point_offsets);
379  for (int i = 0; i < slice_header->num_entry_point_offsets; i++) {
380  TRUE_OR_RETURN(
381  br->ReadBits(slice_header->offset_len_minus1 + 1,
382  &slice_header->entry_point_offset_minus1[i]));
383  }
384  }
385  }
386 
387  if (pps->slice_segment_header_extension_present_flag) {
388  int extension_length;
389  TRUE_OR_RETURN(br->ReadUE(&extension_length));
390  TRUE_OR_RETURN(br->SkipBits(extension_length * 8));
391  }
392 
393  slice_header->header_bit_size = nalu.payload_size() * 8 - br->NumBitsLeft();
394  return kOk;
395 }
396 
397 H265Parser::Result H265Parser::ParsePps(const Nalu& nalu, int* pps_id) {
398  DCHECK_EQ(Nalu::H265_PPS, nalu.type());
399 
400  // Reads most of the element, not reading the extension data.
401  H26xBitReader reader;
402  reader.Initialize(nalu.data() + nalu.header_size(), nalu.payload_size());
403  H26xBitReader* br = &reader;
404 
405  *pps_id = -1;
406  std::unique_ptr<H265Pps> pps(new H265Pps);
407 
408  TRUE_OR_RETURN(br->ReadUE(&pps->pic_parameter_set_id));
409  TRUE_OR_RETURN(br->ReadUE(&pps->seq_parameter_set_id));
410 
411  TRUE_OR_RETURN(br->ReadBool(&pps->dependent_slice_segments_enabled_flag));
412  TRUE_OR_RETURN(br->ReadBool(&pps->output_flag_present_flag));
413  TRUE_OR_RETURN(br->ReadBits(3, &pps->num_extra_slice_header_bits));
414  TRUE_OR_RETURN(br->ReadBool(&pps->sign_data_hiding_enabled_flag));
415  TRUE_OR_RETURN(br->ReadBool(&pps->cabac_init_present_flag));
416 
417  TRUE_OR_RETURN(br->ReadUE(&pps->num_ref_idx_l0_default_active_minus1));
418  TRUE_OR_RETURN(br->ReadUE(&pps->num_ref_idx_l1_default_active_minus1));
419  TRUE_OR_RETURN(br->ReadSE(&pps->init_qp_minus26));
420  TRUE_OR_RETURN(br->ReadBool(&pps->constrained_intra_pred_flag));
421  TRUE_OR_RETURN(br->ReadBool(&pps->transform_skip_enabled_flag));
422 
423  TRUE_OR_RETURN(br->ReadBool(&pps->cu_qp_delta_enabled_flag));
424  if (pps->cu_qp_delta_enabled_flag)
425  TRUE_OR_RETURN(br->ReadUE(&pps->diff_cu_qp_delta_depth));
426  TRUE_OR_RETURN(br->ReadSE(&pps->cb_qp_offset));
427  TRUE_OR_RETURN(br->ReadSE(&pps->cr_qp_offset));
428 
429  TRUE_OR_RETURN(br->ReadBool(&pps->slice_chroma_qp_offsets_present_flag));
430  TRUE_OR_RETURN(br->ReadBool(&pps->weighted_pred_flag));
431  TRUE_OR_RETURN(br->ReadBool(&pps->weighted_bipred_flag));
432  TRUE_OR_RETURN(br->ReadBool(&pps->transquant_bypass_enabled_flag));
433  TRUE_OR_RETURN(br->ReadBool(&pps->tiles_enabled_flag));
434  TRUE_OR_RETURN(br->ReadBool(&pps->entropy_coding_sync_enabled_flag));
435 
436  if (pps->tiles_enabled_flag) {
437  TRUE_OR_RETURN(br->ReadUE(&pps->num_tile_columns_minus1));
438  TRUE_OR_RETURN(br->ReadUE(&pps->num_tile_rows_minus1));
439  TRUE_OR_RETURN(br->ReadBool(&pps->uniform_spacing_flag));
440  if (!pps->uniform_spacing_flag) {
441  pps->column_width_minus1.resize(pps->num_tile_columns_minus1);
442  for (int i = 0; i < pps->num_tile_columns_minus1; i++) {
443  TRUE_OR_RETURN(br->ReadUE(&pps->column_width_minus1[i]));
444  }
445  pps->row_height_minus1.resize(pps->num_tile_rows_minus1);
446  for (int i = 0; i < pps->num_tile_rows_minus1; i++) {
447  TRUE_OR_RETURN(br->ReadUE(&pps->row_height_minus1[i]));
448  }
449  }
450  TRUE_OR_RETURN(br->ReadBool(&pps->loop_filter_across_tiles_enabled_flag));
451  }
452 
453  TRUE_OR_RETURN(br->ReadBool(&pps->loop_filter_across_slices_enabled_flag));
454  TRUE_OR_RETURN(br->ReadBool(&pps->deblocking_filter_control_present_flag));
455  if (pps->deblocking_filter_control_present_flag) {
456  TRUE_OR_RETURN(br->ReadBool(&pps->deblocking_filter_override_enabled_flag));
457  TRUE_OR_RETURN(br->ReadBool(&pps->deblocking_filter_disabled_flag));
458  if (!pps->deblocking_filter_disabled_flag) {
459  TRUE_OR_RETURN(br->ReadSE(&pps->beta_offset_div2));
460  TRUE_OR_RETURN(br->ReadSE(&pps->tc_offset_div2));
461  }
462  }
463 
464  TRUE_OR_RETURN(br->ReadBool(&pps->scaling_list_data_present_flag));
465  if (pps->scaling_list_data_present_flag) {
466  OK_OR_RETURN(SkipScalingListData(br));
467  }
468 
469  TRUE_OR_RETURN(br->ReadBool(&pps->lists_modification_present_flag));
470  TRUE_OR_RETURN(br->ReadUE(&pps->log2_parallel_merge_level_minus2));
471 
472  TRUE_OR_RETURN(
473  br->ReadBool(&pps->slice_segment_header_extension_present_flag));
474 
475  bool pps_extension_present_flag;
476  bool pps_range_extension_flag = false;
477  TRUE_OR_RETURN(br->ReadBool(&pps_extension_present_flag));
478  if (pps_extension_present_flag) {
479  TRUE_OR_RETURN(br->ReadBool(&pps_range_extension_flag));
480  // pps_multilayer_extension_flag, pps_3d_extension_flag, pps_extension_5bits
481  TRUE_OR_RETURN(br->SkipBits(1 + 1 + 5));
482  }
483 
484  if (pps_range_extension_flag) {
485  if (pps->transform_skip_enabled_flag) {
486  // log2_max_transform_skip_block_size_minus2
487  int ignored;
488  TRUE_OR_RETURN(br->ReadUE(&ignored));
489  }
490 
491  TRUE_OR_RETURN(br->SkipBits(1)); // cross_component_prediction_enabled_flag
492  TRUE_OR_RETURN(br->ReadBool(&pps->chroma_qp_offset_list_enabled_flag));
493  // Incomplete
494  }
495 
496  // Ignore remaining extension data.
497 
498  // This will replace any existing PPS instance.
499  *pps_id = pps->pic_parameter_set_id;
500  active_ppses_[*pps_id] = std::move(pps);
501 
502  return kOk;
503 }
504 
505 H265Parser::Result H265Parser::ParseSps(const Nalu& nalu, int* sps_id) {
506  DCHECK_EQ(Nalu::H265_SPS, nalu.type());
507 
508  // Reads most of the element, not reading the extension data.
509  H26xBitReader reader;
510  reader.Initialize(nalu.data() + nalu.header_size(), nalu.payload_size());
511  H26xBitReader* br = &reader;
512 
513  *sps_id = -1;
514 
515  std::unique_ptr<H265Sps> sps(new H265Sps);
516 
517  TRUE_OR_RETURN(br->ReadBits(4, &sps->video_parameter_set_id));
518  TRUE_OR_RETURN(br->ReadBits(3, &sps->max_sub_layers_minus1));
519  TRUE_OR_RETURN(br->ReadBool(&sps->temporal_id_nesting_flag));
520 
521  OK_OR_RETURN(
522  ReadProfileTierLevel(true, sps->max_sub_layers_minus1, br, sps.get()));
523 
524  TRUE_OR_RETURN(br->ReadUE(&sps->seq_parameter_set_id));
525  TRUE_OR_RETURN(br->ReadUE(&sps->chroma_format_idc));
526  if (sps->chroma_format_idc == 3) {
527  TRUE_OR_RETURN(br->ReadBool(&sps->separate_colour_plane_flag));
528  }
529  TRUE_OR_RETURN(br->ReadUE(&sps->pic_width_in_luma_samples));
530  TRUE_OR_RETURN(br->ReadUE(&sps->pic_height_in_luma_samples));
531 
532  TRUE_OR_RETURN(br->ReadBool(&sps->conformance_window_flag));
533  if (sps->conformance_window_flag) {
534  TRUE_OR_RETURN(br->ReadUE(&sps->conf_win_left_offset));
535  TRUE_OR_RETURN(br->ReadUE(&sps->conf_win_right_offset));
536  TRUE_OR_RETURN(br->ReadUE(&sps->conf_win_top_offset));
537  TRUE_OR_RETURN(br->ReadUE(&sps->conf_win_bottom_offset));
538  }
539 
540  TRUE_OR_RETURN(br->ReadUE(&sps->bit_depth_luma_minus8));
541  TRUE_OR_RETURN(br->ReadUE(&sps->bit_depth_chroma_minus8));
542  TRUE_OR_RETURN(br->ReadUE(&sps->log2_max_pic_order_cnt_lsb_minus4));
543 
544  TRUE_OR_RETURN(br->ReadBool(&sps->sub_layer_ordering_info_present_flag));
545  int start = sps->sub_layer_ordering_info_present_flag
546  ? 0
547  : sps->max_sub_layers_minus1;
548  for (int i = start; i <= sps->max_sub_layers_minus1; i++) {
549  TRUE_OR_RETURN(br->ReadUE(&sps->max_dec_pic_buffering_minus1[i]));
550  TRUE_OR_RETURN(br->ReadUE(&sps->max_num_reorder_pics[i]));
551  TRUE_OR_RETURN(br->ReadUE(&sps->max_latency_increase_plus1[i]));
552  }
553 
554  TRUE_OR_RETURN(br->ReadUE(&sps->log2_min_luma_coding_block_size_minus3));
555  TRUE_OR_RETURN(br->ReadUE(&sps->log2_diff_max_min_luma_coding_block_size));
556  TRUE_OR_RETURN(br->ReadUE(&sps->log2_min_luma_transform_block_size_minus2));
557  TRUE_OR_RETURN(br->ReadUE(&sps->log2_diff_max_min_luma_transform_block_size));
558  TRUE_OR_RETURN(br->ReadUE(&sps->max_transform_hierarchy_depth_inter));
559  TRUE_OR_RETURN(br->ReadUE(&sps->max_transform_hierarchy_depth_intra));
560 
561  TRUE_OR_RETURN(br->ReadBool(&sps->scaling_list_enabled_flag));
562  if (sps->scaling_list_enabled_flag) {
563  TRUE_OR_RETURN(br->ReadBool(&sps->scaling_list_data_present_flag));
564  if (sps->scaling_list_data_present_flag) {
565  OK_OR_RETURN(SkipScalingListData(br));
566  }
567  }
568 
569  TRUE_OR_RETURN(br->ReadBool(&sps->amp_enabled_flag));
570  TRUE_OR_RETURN(br->ReadBool(&sps->sample_adaptive_offset_enabled_flag));
571  TRUE_OR_RETURN(br->ReadBool(&sps->pcm_enabled_flag));
572  if (sps->pcm_enabled_flag) {
573  TRUE_OR_RETURN(br->ReadBits(4, &sps->pcm_sample_bit_depth_luma_minus1));
574  TRUE_OR_RETURN(br->ReadBits(4, &sps->pcm_sample_bit_depth_chroma_minus1));
575  TRUE_OR_RETURN(
576  br->ReadUE(&sps->log2_min_pcm_luma_coding_block_size_minus3));
577  TRUE_OR_RETURN(
578  br->ReadUE(&sps->log2_diff_max_min_pcm_luma_coding_block_size));
579  TRUE_OR_RETURN(br->ReadBool(&sps->pcm_loop_filter_disabled_flag));
580  }
581 
582  TRUE_OR_RETURN(br->ReadUE(&sps->num_short_term_ref_pic_sets));
583  sps->st_ref_pic_sets.resize(sps->num_short_term_ref_pic_sets);
584  for (int i = 0; i < sps->num_short_term_ref_pic_sets; i++) {
585  OK_OR_RETURN(ParseReferencePictureSet(sps->num_short_term_ref_pic_sets, i,
586  sps->st_ref_pic_sets, br,
587  &sps->st_ref_pic_sets[i]));
588  }
589 
590  TRUE_OR_RETURN(br->ReadBool(&sps->long_term_ref_pic_present_flag));
591  if (sps->long_term_ref_pic_present_flag) {
592  TRUE_OR_RETURN(br->ReadUE(&sps->num_long_term_ref_pics));
593  sps->lt_ref_pic_poc_lsb.resize(sps->num_long_term_ref_pics);
594  sps->used_by_curr_pic_lt_flag.resize(sps->num_long_term_ref_pics);
595  for (int i = 0; i < sps->num_long_term_ref_pics; i++) {
596  TRUE_OR_RETURN(br->ReadBits(sps->log2_max_pic_order_cnt_lsb_minus4 + 4,
597  &sps->lt_ref_pic_poc_lsb[i]));
598  bool temp;
599  TRUE_OR_RETURN(br->ReadBool(&temp));
600  sps->used_by_curr_pic_lt_flag[i] = temp;
601  }
602  }
603 
604  TRUE_OR_RETURN(br->ReadBool(&sps->temporal_mvp_enabled_flag));
605  TRUE_OR_RETURN(br->ReadBool(&sps->strong_intra_smoothing_enabled_flag));
606 
607  TRUE_OR_RETURN(br->ReadBool(&sps->vui_parameters_present));
608  if (sps->vui_parameters_present) {
609  OK_OR_RETURN(ParseVuiParameters(sps->max_sub_layers_minus1, br,
610  &sps->vui_parameters));
611  }
612 
613  // Ignore remaining extension data.
614 
615  // This will replace any existing SPS instance.
616  *sps_id = sps->seq_parameter_set_id;
617  active_spses_[*sps_id] = std::move(sps);
618 
619  return kOk;
620 }
621 
622 const H265Pps* H265Parser::GetPps(int pps_id) {
623  return active_ppses_[pps_id].get();
624 }
625 
626 const H265Sps* H265Parser::GetSps(int sps_id) {
627  return active_spses_[sps_id].get();
628 }
629 
630 H265Parser::Result H265Parser::ParseVuiParameters(int max_num_sub_layers_minus1,
631  H26xBitReader* br,
632  H265VuiParameters* vui) {
633  // Reads whole element but ignores most of it.
634  int ignored;
635 
636  TRUE_OR_RETURN(br->ReadBool(&vui->aspect_ratio_info_present_flag));
637  if (vui->aspect_ratio_info_present_flag) {
638  TRUE_OR_RETURN(br->ReadBits(8, &vui->aspect_ratio_idc));
639  if (vui->aspect_ratio_idc == H265VuiParameters::kExtendedSar) {
640  TRUE_OR_RETURN(br->ReadBits(16, &vui->sar_width));
641  TRUE_OR_RETURN(br->ReadBits(16, &vui->sar_height));
642  }
643  }
644 
645  bool overscan_info_present_flag;
646  TRUE_OR_RETURN(br->ReadBool(&overscan_info_present_flag));
647  if (overscan_info_present_flag) {
648  TRUE_OR_RETURN(br->SkipBits(1)); // overscan_appropriate_flag
649  }
650 
651  bool video_signal_type_present_flag;
652  TRUE_OR_RETURN(br->ReadBool(&video_signal_type_present_flag));
653  if (video_signal_type_present_flag) {
654  TRUE_OR_RETURN(br->SkipBits(3)); // video_format
655  TRUE_OR_RETURN(br->SkipBits(1)); // video_full_range_flag
656 
657  bool colour_description_present_flag;
658  TRUE_OR_RETURN(br->ReadBool(&colour_description_present_flag));
659  if (colour_description_present_flag) {
660  // colour_primaries, transfer_characteristics, matrix_coeffs
661  TRUE_OR_RETURN(br->SkipBits(8 + 8 + 8));
662  }
663  }
664 
665  bool chroma_loc_info_present_flag;
666  TRUE_OR_RETURN(br->ReadBool(&chroma_loc_info_present_flag));
667  if (chroma_loc_info_present_flag) {
668  // chroma_sample_log_type_top_field, chroma_sample_log_type_bottom_field
669  TRUE_OR_RETURN(br->ReadUE(&ignored));
670  TRUE_OR_RETURN(br->ReadUE(&ignored));
671  }
672 
673  // neutral_chroma_indication_flag, field_seq_flag,
674  // frame_field_info_present_flag.
675  TRUE_OR_RETURN(br->SkipBits(3));
676 
677  bool default_display_window_flag;
678  TRUE_OR_RETURN(br->ReadBool(&default_display_window_flag));
679  if (default_display_window_flag) {
680  TRUE_OR_RETURN(br->ReadUE(&ignored)); // def_disp_win_left_offset
681  TRUE_OR_RETURN(br->ReadUE(&ignored)); // def_disp_win_right_offset
682  TRUE_OR_RETURN(br->ReadUE(&ignored)); // def_disp_win_top_offset
683  TRUE_OR_RETURN(br->ReadUE(&ignored)); // def_disp_win_bottom_offset
684  }
685 
686  bool vui_timing_info_present_flag;
687  TRUE_OR_RETURN(br->ReadBool(&vui_timing_info_present_flag));
688  if (vui_timing_info_present_flag) {
689  // vui_num_units_in_tick, vui_time_scale
690  TRUE_OR_RETURN(br->SkipBits(32 + 32));
691 
692  bool vui_poc_proportional_to_timing_flag;
693  TRUE_OR_RETURN(br->ReadBool(&vui_poc_proportional_to_timing_flag));
694  if (vui_poc_proportional_to_timing_flag) {
695  // vui_num_ticks_poc_diff_one_minus1
696  TRUE_OR_RETURN(br->ReadUE(&ignored));
697  }
698 
699  bool vui_hdr_parameters_present_flag;
700  TRUE_OR_RETURN(br->ReadBool(&vui_hdr_parameters_present_flag));
701  if (vui_hdr_parameters_present_flag) {
702  OK_OR_RETURN(SkipHrdParameters(max_num_sub_layers_minus1, br));
703  }
704  }
705 
706  TRUE_OR_RETURN(br->ReadBool(&vui->bitstream_restriction_flag));
707  if (vui->bitstream_restriction_flag) {
708  // tiles_fixed_structure_flag, motion_vectors_over_pic_boundaries_flag,
709  // restricted_ref_pic_lists_flag.
710  TRUE_OR_RETURN(br->SkipBits(3));
711 
712  TRUE_OR_RETURN(br->ReadUE(&vui->min_spatial_segmentation_idc));
713  TRUE_OR_RETURN(br->ReadUE(&ignored)); // max_bytes_per_pic_denom
714  TRUE_OR_RETURN(br->ReadUE(&ignored)); // max_bits_per_min_cu_denum
715  TRUE_OR_RETURN(br->ReadUE(&ignored)); // log2_max_mv_length_horizontal
716  TRUE_OR_RETURN(br->ReadUE(&ignored)); // log2_max_mv_length_vertical
717  }
718 
719  return kOk;
720 }
721 
722 H265Parser::Result H265Parser::ParseReferencePictureSet(
723  int num_short_term_ref_pic_sets,
724  int st_rps_idx,
725  const std::vector<H265ReferencePictureSet>& ref_pic_sets,
726  H26xBitReader* br,
727  H265ReferencePictureSet* out_ref_pic_set) {
728  // Parses and processess a short-term reference picture set. This needs to
729  // be done since the size of this element may be dependent on previous
730  // reference picture sets.
731 
732  bool inter_ref_pic_set_prediction = false;
733  if (st_rps_idx != 0) {
734  TRUE_OR_RETURN(br->ReadBool(&inter_ref_pic_set_prediction));
735  }
736 
737  if (inter_ref_pic_set_prediction) {
738  int delta_idx = 1;
739  if (st_rps_idx == num_short_term_ref_pic_sets) {
740  TRUE_OR_RETURN(br->ReadUE(&delta_idx));
741  delta_idx++;
742  TRUE_OR_RETURN(delta_idx <= st_rps_idx);
743  }
744 
745  int ref_rps_idx = st_rps_idx - delta_idx;
746  DCHECK_LE(0, ref_rps_idx);
747  DCHECK_LT(ref_rps_idx, st_rps_idx);
748 
749  bool delta_rps_sign;
750  int abs_delta_rps_minus1;
751  TRUE_OR_RETURN(br->ReadBool(&delta_rps_sign));
752  TRUE_OR_RETURN(br->ReadUE(&abs_delta_rps_minus1));
753  int delta_rps =
754  delta_rps_sign ? -(abs_delta_rps_minus1 + 1) : abs_delta_rps_minus1 + 1;
755 
756  int ref_num_delta_pocs = ref_pic_sets[ref_rps_idx].num_delta_pocs;
757  std::vector<bool> used_by_curr_pic(ref_num_delta_pocs + 1);
758  std::vector<bool> use_delta(ref_num_delta_pocs + 1);
759  for (int j = 0; j <= ref_num_delta_pocs; j++) {
760  bool temp;
761  TRUE_OR_RETURN(br->ReadBool(&temp));
762  used_by_curr_pic[j] = temp;
763 
764  if (!used_by_curr_pic[j]) {
765  TRUE_OR_RETURN(br->ReadBool(&temp));
766  use_delta[j] = temp;
767  } else {
768  use_delta[j] = true;
769  }
770  }
771 
772  int ref_num_positive_pics = ref_pic_sets[ref_rps_idx].num_positive_pics;
773  int ref_num_negative_pics = ref_pic_sets[ref_rps_idx].num_negative_pics;
774  int i;
775 
776  // Update list 0.
777  {
778  i = 0;
779  for (int j = ref_num_positive_pics - 1; j >= 0; j--) {
780  int d_poc = ref_pic_sets[ref_rps_idx].delta_poc_s1[j] + delta_rps;
781  if (d_poc < 0 && use_delta[ref_num_negative_pics + j]) {
782  out_ref_pic_set->delta_poc_s0[i] = d_poc;
783  out_ref_pic_set->used_by_curr_pic_s0[i] =
784  used_by_curr_pic[ref_num_negative_pics + j];
785  i++;
786  }
787  }
788  if (delta_rps < 0 && use_delta[ref_num_delta_pocs]) {
789  out_ref_pic_set->delta_poc_s0[i] = delta_rps;
790  out_ref_pic_set->used_by_curr_pic_s0[i] =
791  used_by_curr_pic[ref_num_delta_pocs];
792  i++;
793  }
794  for (int j = 0; j < ref_num_negative_pics; j++) {
795  int d_poc = ref_pic_sets[ref_rps_idx].delta_poc_s0[j] + delta_rps;
796  if (d_poc < 0 && use_delta[j]) {
797  out_ref_pic_set->delta_poc_s0[i] = d_poc;
798  out_ref_pic_set->used_by_curr_pic_s0[i] = used_by_curr_pic[j];
799  i++;
800  }
801  }
802  out_ref_pic_set->num_negative_pics = i;
803  }
804 
805  // Update list 1.
806  {
807  i = 0;
808  for (int j = ref_num_negative_pics - 1; j >= 0; j--) {
809  int d_poc = ref_pic_sets[ref_rps_idx].delta_poc_s0[j] + delta_rps;
810  if (d_poc > 0 && use_delta[j]) {
811  out_ref_pic_set->delta_poc_s1[i] = d_poc;
812  out_ref_pic_set->used_by_curr_pic_s1[i] = used_by_curr_pic[j];
813  i++;
814  }
815  }
816  if (delta_rps > 0 && use_delta[ref_num_delta_pocs]) {
817  out_ref_pic_set->delta_poc_s1[i] = delta_rps;
818  out_ref_pic_set->used_by_curr_pic_s1[i] =
819  used_by_curr_pic[ref_num_delta_pocs];
820  i++;
821  }
822  for (int j = 0; j < ref_num_positive_pics; j++) {
823  int d_poc = ref_pic_sets[ref_rps_idx].delta_poc_s1[j] + delta_rps;
824  if (d_poc > 0 && use_delta[ref_num_negative_pics + j]) {
825  out_ref_pic_set->delta_poc_s1[i] = d_poc;
826  out_ref_pic_set->used_by_curr_pic_s1[i] =
827  used_by_curr_pic[ref_num_negative_pics + j];
828  i++;
829  }
830  }
831  out_ref_pic_set->num_positive_pics = i;
832  }
833  } else {
834  TRUE_OR_RETURN(br->ReadUE(&out_ref_pic_set->num_negative_pics));
835  TRUE_OR_RETURN(br->ReadUE(&out_ref_pic_set->num_positive_pics));
836 
837  int prev_poc = 0;
838  for (int i = 0; i < out_ref_pic_set->num_negative_pics; i++) {
839  int delta_poc_s0_minus1;
840  TRUE_OR_RETURN(br->ReadUE(&delta_poc_s0_minus1));
841  out_ref_pic_set->delta_poc_s0[i] = prev_poc - (delta_poc_s0_minus1 + 1);
842  prev_poc = out_ref_pic_set->delta_poc_s0[i];
843 
844  TRUE_OR_RETURN(br->ReadBool(&out_ref_pic_set->used_by_curr_pic_s0[i]));
845  }
846 
847  prev_poc = 0;
848  for (int i = 0; i < out_ref_pic_set->num_positive_pics; i++) {
849  int delta_poc_s1_minus1;
850  TRUE_OR_RETURN(br->ReadUE(&delta_poc_s1_minus1));
851  out_ref_pic_set->delta_poc_s1[i] = prev_poc + delta_poc_s1_minus1 + 1;
852  prev_poc = out_ref_pic_set->delta_poc_s1[i];
853 
854  TRUE_OR_RETURN(br->ReadBool(&out_ref_pic_set->used_by_curr_pic_s1[i]));
855  }
856  }
857 
858  out_ref_pic_set->num_delta_pocs =
859  out_ref_pic_set->num_positive_pics + out_ref_pic_set->num_negative_pics;
860  return kOk;
861 }
862 
863 H265Parser::Result H265Parser::SkipReferencePictureListModification(
864  const H265SliceHeader& slice_header,
865  const H265Pps& pps,
866  int num_pic_total_curr,
867  H26xBitReader* br) {
868  // Reads whole element but ignores it all.
869 
870  bool ref_pic_list_modification_flag_l0;
871  TRUE_OR_RETURN(br->ReadBool(&ref_pic_list_modification_flag_l0));
872  if (ref_pic_list_modification_flag_l0) {
873  for (int i = 0; i <= pps.num_ref_idx_l0_default_active_minus1; i++) {
874  TRUE_OR_RETURN(br->SkipBits(ceil(log2(num_pic_total_curr))));
875  }
876  }
877 
878  if (slice_header.slice_type == kBSlice) {
879  bool ref_pic_list_modification_flag_l1;
880  TRUE_OR_RETURN(br->ReadBool(&ref_pic_list_modification_flag_l1));
881  if (ref_pic_list_modification_flag_l1) {
882  for (int i = 0; i <= pps.num_ref_idx_l1_default_active_minus1; i++) {
883  TRUE_OR_RETURN(br->SkipBits(ceil(log2(num_pic_total_curr))));
884  }
885  }
886  }
887 
888  return kOk;
889 }
890 
891 H265Parser::Result H265Parser::SkipPredictionWeightTablePart(
892  int num_ref_idx_minus1,
893  int chroma_array_type,
894  H26xBitReader* br) {
895  // Reads whole element, ignores it.
896  int ignored;
897  std::vector<bool> luma_weight_flag(num_ref_idx_minus1 + 1);
898  std::vector<bool> chroma_weight_flag(num_ref_idx_minus1 + 1);
899 
900  for (int i = 0; i <= num_ref_idx_minus1; i++) {
901  bool temp;
902  TRUE_OR_RETURN(br->ReadBool(&temp));
903  luma_weight_flag[i] = temp;
904  }
905  if (chroma_array_type != 0) {
906  for (int i = 0; i <= num_ref_idx_minus1; i++) {
907  bool temp;
908  TRUE_OR_RETURN(br->ReadBool(&temp));
909  chroma_weight_flag[i] = temp;
910  }
911  }
912  for (int i = 0; i <= num_ref_idx_minus1; i++) {
913  if (luma_weight_flag[i]) {
914  TRUE_OR_RETURN(br->ReadSE(&ignored)); // delta_luma_weight_l#
915  TRUE_OR_RETURN(br->ReadSE(&ignored)); // luma_offset_l#
916  }
917  if (chroma_weight_flag[i]) {
918  for (int j = 0; j < 2; j++) {
919  TRUE_OR_RETURN(br->ReadSE(&ignored)); // delta_chroma_weight_l#
920  TRUE_OR_RETURN(br->ReadSE(&ignored)); // delta_chroma_offset_l#
921  }
922  }
923  }
924 
925  return kOk;
926 }
927 
928 H265Parser::Result H265Parser::SkipPredictionWeightTable(
929  bool is_b_slice,
930  const H265Sps& sps,
931  const H265SliceHeader& slice_header,
932  H26xBitReader* br) {
933  // Reads whole element, ignores it.
934  int ignored;
935  int chroma_array_type = sps.GetChromaArrayType();
936 
937  TRUE_OR_RETURN(br->ReadUE(&ignored)); // luma_log2_weight_denom
938  if (chroma_array_type != 0) {
939  TRUE_OR_RETURN(br->ReadSE(&ignored)); // delta_chroma_log2_weight_denom
940  }
941  OK_OR_RETURN(SkipPredictionWeightTablePart(
942  slice_header.num_ref_idx_l0_active_minus1, chroma_array_type, br));
943  if (is_b_slice) {
944  OK_OR_RETURN(SkipPredictionWeightTablePart(
945  slice_header.num_ref_idx_l1_active_minus1, chroma_array_type, br));
946  }
947 
948  return kOk;
949 }
950 
951 H265Parser::Result H265Parser::ReadProfileTierLevel(
952  bool profile_present,
953  int max_num_sub_layers_minus1,
954  H26xBitReader* br,
955  H265Sps* sps) {
956  // Reads whole element, ignores it.
957 
958  if (profile_present) {
959  // 11 bytes of general_profile_tier flags:
960  // general_profile_space, general_tier_flag, general_profile_idc
961  // general_profile_compativility_flag
962  // general_progressive_source_flag
963  // general_interlaced_source_flag
964  // general_non_packed_constraint_flag
965  // general_frame_only_constraint_flag
966  // 44-bits of other flags
967  for (int i = 0; i < 11; i++)
968  TRUE_OR_RETURN(br->ReadBits(8, &sps->general_profile_tier_level_data[i]));
969  }
970  // general_level_idc
971  TRUE_OR_RETURN(br->ReadBits(8, &sps->general_profile_tier_level_data[11]));
972 
973  std::vector<bool> sub_layer_profile_present(max_num_sub_layers_minus1);
974  std::vector<bool> sub_layer_level_present(max_num_sub_layers_minus1);
975  for (int i = 0; i < max_num_sub_layers_minus1; i++) {
976  bool profile, level;
977  TRUE_OR_RETURN(br->ReadBool(&profile));
978  TRUE_OR_RETURN(br->ReadBool(&level));
979  sub_layer_profile_present[i] = profile;
980  sub_layer_level_present[i] = level;
981  }
982 
983  if (max_num_sub_layers_minus1 > 0) {
984  for (int i = max_num_sub_layers_minus1; i < 8; i++)
985  TRUE_OR_RETURN(br->SkipBits(2)); // reserved_zero_2bits
986  }
987 
988  for (int i = 0; i < max_num_sub_layers_minus1; i++) {
989  if (sub_layer_profile_present[i]) {
990  // sub_layer_profile_space, sub_layer_tier_flag, sub_layer_profile_idc
991  // sub_layer_profile_compatibility
992  // sub_layer_reserved_zero_43bits
993  // sub_layer_reserved_zero_bit
994  TRUE_OR_RETURN(br->SkipBits(2 + 1 + 5 + 32 + 4 + 43 + 1));
995  }
996  if (sub_layer_level_present[i]) {
997  TRUE_OR_RETURN(br->SkipBits(8));
998  }
999  }
1000 
1001  return kOk;
1002 }
1003 
1004 H265Parser::Result H265Parser::SkipScalingListData(H26xBitReader* br) {
1005  // Reads whole element, ignores it.
1006  int ignored;
1007  for (int size_id = 0; size_id < 4; size_id++) {
1008  for (int matrix_id = 0; matrix_id < 6;
1009  matrix_id += ((size_id == 3) ? 3 : 1)) {
1010  bool scaling_list_pred_mode;
1011  TRUE_OR_RETURN(br->ReadBool(&scaling_list_pred_mode));
1012  if (!scaling_list_pred_mode) {
1013  // scaling_list_pred_matrix_id_delta
1014  TRUE_OR_RETURN(br->ReadUE(&ignored));
1015  } else {
1016  int coefNum = std::min(64, (1 << (4 + (size_id << 1))));
1017  if (size_id > 1) {
1018  TRUE_OR_RETURN(br->ReadSE(&ignored)); // scaling_list_dc_coef_minus8
1019  }
1020 
1021  for (int i = 0; i < coefNum; i++) {
1022  TRUE_OR_RETURN(br->ReadSE(&ignored)); // scaling_list_delta_coef
1023  }
1024  }
1025  }
1026  }
1027 
1028  return kOk;
1029 }
1030 
1031 H265Parser::Result H265Parser::SkipHrdParameters(int max_num_sub_layers_minus1,
1032  H26xBitReader* br) {
1033  // common_inf_present_flag is always 1 when parsing vui_parameters.
1034  const bool common_inf_present_flag = true;
1035 
1036  int ignored;
1037  bool nal_hdr_parameters_present_flag;
1038  bool vcl_hdr_parameters_present_flag;
1039  bool sub_pic_hdr_params_present_flag = false;
1040  if (common_inf_present_flag) {
1041  TRUE_OR_RETURN(br->ReadBool(&nal_hdr_parameters_present_flag));
1042  TRUE_OR_RETURN(br->ReadBool(&vcl_hdr_parameters_present_flag));
1043  if (nal_hdr_parameters_present_flag || vcl_hdr_parameters_present_flag) {
1044  TRUE_OR_RETURN(br->ReadBool(&sub_pic_hdr_params_present_flag));
1045  if (sub_pic_hdr_params_present_flag) {
1046  // tick_divisor_minus2, du_cpb_removal_delay_increment_length_minus1,
1047  // sub_pic_cpb_params_in_pic_timing_sei_flag
1048  // dpb_output_delay_du_length_minus1
1049  TRUE_OR_RETURN(br->SkipBits(8 + 5 + 1 + 5));
1050  }
1051 
1052  // bit_rate_scale, cpb_size_scale
1053  TRUE_OR_RETURN(br->SkipBits(4 + 4));
1054  if (sub_pic_hdr_params_present_flag)
1055  TRUE_OR_RETURN(br->SkipBits(4)); // cpb_size_du_scale
1056 
1057  // initial_cpb_removal_delay_length_minus1,
1058  // au_cpb_removal_delay_length_minus1, dpb_output_delay_length_minus1
1059  TRUE_OR_RETURN(br->SkipBits(5 + 5 + 5));
1060  }
1061  }
1062 
1063  for (int i = 0; i <= max_num_sub_layers_minus1; i++) {
1064  bool fixed_pic_rate_general_flag;
1065  bool fixed_pic_rate_within_cvs_flag = true;
1066  bool low_delay_hdr_flag = false;
1067  int cpb_cnt_minus1 = 0;
1068  TRUE_OR_RETURN(br->ReadBool(&fixed_pic_rate_general_flag));
1069  if (!fixed_pic_rate_general_flag)
1070  TRUE_OR_RETURN(br->ReadBool(&fixed_pic_rate_within_cvs_flag));
1071  if (fixed_pic_rate_within_cvs_flag)
1072  TRUE_OR_RETURN(br->ReadUE(&ignored)); // elemental_duration_ic_tc_minus1
1073  else
1074  TRUE_OR_RETURN(br->ReadBool(&low_delay_hdr_flag));
1075  if (!low_delay_hdr_flag)
1076  TRUE_OR_RETURN(br->ReadUE(&cpb_cnt_minus1));
1077 
1078  if (nal_hdr_parameters_present_flag) {
1079  OK_OR_RETURN(SkipSubLayerHrdParameters(
1080  cpb_cnt_minus1, sub_pic_hdr_params_present_flag, br));
1081  }
1082  if (vcl_hdr_parameters_present_flag) {
1083  OK_OR_RETURN(SkipSubLayerHrdParameters(
1084  cpb_cnt_minus1, sub_pic_hdr_params_present_flag, br));
1085  }
1086  }
1087 
1088  return kOk;
1089 }
1090 
1091 H265Parser::Result H265Parser::SkipSubLayerHrdParameters(
1092  int cpb_cnt_minus1,
1093  bool sub_pic_hdr_params_present_flag,
1094  H26xBitReader* br) {
1095  int ignored;
1096  for (int i = 0; i <= cpb_cnt_minus1; i++) {
1097  TRUE_OR_RETURN(br->ReadUE(&ignored)); // bit_rate_value_minus1
1098  TRUE_OR_RETURN(br->ReadUE(&ignored)); // cpb_size_value_minus1
1099  if (sub_pic_hdr_params_present_flag) {
1100  TRUE_OR_RETURN(br->ReadUE(&ignored)); // cpb_size_du_value_minus1
1101  TRUE_OR_RETURN(br->ReadUE(&ignored)); // bit_rate_du_value_minus1
1102  }
1103 
1104  TRUE_OR_RETURN(br->SkipBits(1)); // cbr_flag
1105  }
1106 
1107  return kOk;
1108 }
1109 
1110 } // namespace media
1111 } // namespace shaka
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::H265Parser::ParseSliceHeader
Result ParseSliceHeader(const Nalu &nalu, H265SliceHeader *slice_header)
Definition: h265_parser.cc:183
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::H265Parser::ParsePps
Result ParsePps(const Nalu &nalu, int *pps_id)
Definition: h265_parser.cc:397
shaka
All the methods that are virtual are virtual for mocking.
Definition: gflags_hex_bytes.cc:11
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::H265Parser::GetSps
const H265Sps * GetSps(int sps_id)
Definition: h265_parser.cc:626
shaka::media::H265Parser::GetPps
const H265Pps * GetPps(int pps_id)
Definition: h265_parser.cc:622
shaka::media::Nalu::type
int type() const
Definition: nalu_reader.h:113
shaka::media::H265Parser::ParseSps
Result ParseSps(const Nalu &nalu, int *sps_id)
Definition: h265_parser.cc:505
shaka::media::Nalu::payload_size
uint64_t payload_size() const
Size of this Nalu minus header_size().
Definition: nalu_reader.h:102
Generated on Sat Feb 10 2018 15:36:43 for Shaka Packager SDK by   doxygen 1.8.13