FFmpeg  4.4.5
hevc.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2014 Tim Walker <tdskywalker@gmail.com>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "libavcodec/avcodec.h"
22 #include "libavcodec/get_bits.h"
23 #include "libavcodec/golomb.h"
24 #include "libavcodec/hevc.h"
25 #include "libavutil/intreadwrite.h"
26 #include "avc.h"
27 #include "avio.h"
28 #include "avio_internal.h"
29 #include "hevc.h"
30 
31 #define MAX_SPATIAL_SEGMENTATION 4096 // max. value of u(12) field
32 
33 typedef struct HVCCNALUnitArray {
36  uint16_t numNalus;
37  uint16_t *nalUnitLength;
40 
54  uint16_t avgFrameRate;
62 
63 typedef struct HVCCProfileTierLevel {
71 
74 {
75  /*
76  * The value of general_profile_space in all the parameter sets must be
77  * identical.
78  */
79  hvcc->general_profile_space = ptl->profile_space;
80 
81  /*
82  * The level indication general_level_idc must indicate a level of
83  * capability equal to or greater than the highest level indicated for the
84  * highest tier in all the parameter sets.
85  */
86  if (hvcc->general_tier_flag < ptl->tier_flag)
87  hvcc->general_level_idc = ptl->level_idc;
88  else
89  hvcc->general_level_idc = FFMAX(hvcc->general_level_idc, ptl->level_idc);
90 
91  /*
92  * The tier indication general_tier_flag must indicate a tier equal to or
93  * greater than the highest tier indicated in all the parameter sets.
94  */
95  hvcc->general_tier_flag = FFMAX(hvcc->general_tier_flag, ptl->tier_flag);
96 
97  /*
98  * The profile indication general_profile_idc must indicate a profile to
99  * which the stream associated with this configuration record conforms.
100  *
101  * If the sequence parameter sets are marked with different profiles, then
102  * the stream may need examination to determine which profile, if any, the
103  * entire stream conforms to. If the entire stream is not examined, or the
104  * examination reveals that there is no profile to which the entire stream
105  * conforms, then the entire stream must be split into two or more
106  * sub-streams with separate configuration records in which these rules can
107  * be met.
108  *
109  * Note: set the profile to the highest value for the sake of simplicity.
110  */
111  hvcc->general_profile_idc = FFMAX(hvcc->general_profile_idc, ptl->profile_idc);
112 
113  /*
114  * Each bit in general_profile_compatibility_flags may only be set if all
115  * the parameter sets set that bit.
116  */
117  hvcc->general_profile_compatibility_flags &= ptl->profile_compatibility_flags;
118 
119  /*
120  * Each bit in general_constraint_indicator_flags may only be set if all
121  * the parameter sets set that bit.
122  */
123  hvcc->general_constraint_indicator_flags &= ptl->constraint_indicator_flags;
124 }
125 
128  unsigned int max_sub_layers_minus1)
129 {
130  unsigned int i;
131  HVCCProfileTierLevel general_ptl;
132  uint8_t sub_layer_profile_present_flag[HEVC_MAX_SUB_LAYERS];
133  uint8_t sub_layer_level_present_flag[HEVC_MAX_SUB_LAYERS];
134 
135  general_ptl.profile_space = get_bits(gb, 2);
136  general_ptl.tier_flag = get_bits1(gb);
137  general_ptl.profile_idc = get_bits(gb, 5);
138  general_ptl.profile_compatibility_flags = get_bits_long(gb, 32);
139  general_ptl.constraint_indicator_flags = get_bits64(gb, 48);
140  general_ptl.level_idc = get_bits(gb, 8);
141  hvcc_update_ptl(hvcc, &general_ptl);
142 
143  for (i = 0; i < max_sub_layers_minus1; i++) {
144  sub_layer_profile_present_flag[i] = get_bits1(gb);
145  sub_layer_level_present_flag[i] = get_bits1(gb);
146  }
147 
148  if (max_sub_layers_minus1 > 0)
149  for (i = max_sub_layers_minus1; i < 8; i++)
150  skip_bits(gb, 2); // reserved_zero_2bits[i]
151 
152  for (i = 0; i < max_sub_layers_minus1; i++) {
153  if (sub_layer_profile_present_flag[i]) {
154  /*
155  * sub_layer_profile_space[i] u(2)
156  * sub_layer_tier_flag[i] u(1)
157  * sub_layer_profile_idc[i] u(5)
158  * sub_layer_profile_compatibility_flag[i][0..31] u(32)
159  * sub_layer_progressive_source_flag[i] u(1)
160  * sub_layer_interlaced_source_flag[i] u(1)
161  * sub_layer_non_packed_constraint_flag[i] u(1)
162  * sub_layer_frame_only_constraint_flag[i] u(1)
163  * sub_layer_reserved_zero_44bits[i] u(44)
164  */
165  skip_bits_long(gb, 32);
166  skip_bits_long(gb, 32);
167  skip_bits (gb, 24);
168  }
169 
170  if (sub_layer_level_present_flag[i])
171  skip_bits(gb, 8);
172  }
173 }
174 
176  unsigned int cpb_cnt_minus1,
177  uint8_t sub_pic_hrd_params_present_flag)
178 {
179  unsigned int i;
180 
181  for (i = 0; i <= cpb_cnt_minus1; i++) {
182  get_ue_golomb_long(gb); // bit_rate_value_minus1
183  get_ue_golomb_long(gb); // cpb_size_value_minus1
184 
185  if (sub_pic_hrd_params_present_flag) {
186  get_ue_golomb_long(gb); // cpb_size_du_value_minus1
187  get_ue_golomb_long(gb); // bit_rate_du_value_minus1
188  }
189 
190  skip_bits1(gb); // cbr_flag
191  }
192 }
193 
194 static int skip_hrd_parameters(GetBitContext *gb, uint8_t cprms_present_flag,
195  unsigned int max_sub_layers_minus1)
196 {
197  unsigned int i;
198  uint8_t sub_pic_hrd_params_present_flag = 0;
199  uint8_t nal_hrd_parameters_present_flag = 0;
200  uint8_t vcl_hrd_parameters_present_flag = 0;
201 
202  if (cprms_present_flag) {
203  nal_hrd_parameters_present_flag = get_bits1(gb);
204  vcl_hrd_parameters_present_flag = get_bits1(gb);
205 
206  if (nal_hrd_parameters_present_flag ||
207  vcl_hrd_parameters_present_flag) {
208  sub_pic_hrd_params_present_flag = get_bits1(gb);
209 
210  if (sub_pic_hrd_params_present_flag)
211  /*
212  * tick_divisor_minus2 u(8)
213  * du_cpb_removal_delay_increment_length_minus1 u(5)
214  * sub_pic_cpb_params_in_pic_timing_sei_flag u(1)
215  * dpb_output_delay_du_length_minus1 u(5)
216  */
217  skip_bits(gb, 19);
218 
219  /*
220  * bit_rate_scale u(4)
221  * cpb_size_scale u(4)
222  */
223  skip_bits(gb, 8);
224 
225  if (sub_pic_hrd_params_present_flag)
226  skip_bits(gb, 4); // cpb_size_du_scale
227 
228  /*
229  * initial_cpb_removal_delay_length_minus1 u(5)
230  * au_cpb_removal_delay_length_minus1 u(5)
231  * dpb_output_delay_length_minus1 u(5)
232  */
233  skip_bits(gb, 15);
234  }
235  }
236 
237  for (i = 0; i <= max_sub_layers_minus1; i++) {
238  unsigned int cpb_cnt_minus1 = 0;
239  uint8_t low_delay_hrd_flag = 0;
240  uint8_t fixed_pic_rate_within_cvs_flag = 0;
241  uint8_t fixed_pic_rate_general_flag = get_bits1(gb);
242 
243  if (!fixed_pic_rate_general_flag)
244  fixed_pic_rate_within_cvs_flag = get_bits1(gb);
245 
246  if (fixed_pic_rate_within_cvs_flag)
247  get_ue_golomb_long(gb); // elemental_duration_in_tc_minus1
248  else
249  low_delay_hrd_flag = get_bits1(gb);
250 
251  if (!low_delay_hrd_flag) {
252  cpb_cnt_minus1 = get_ue_golomb_long(gb);
253  if (cpb_cnt_minus1 > 31)
254  return AVERROR_INVALIDDATA;
255  }
256 
257  if (nal_hrd_parameters_present_flag)
258  skip_sub_layer_hrd_parameters(gb, cpb_cnt_minus1,
259  sub_pic_hrd_params_present_flag);
260 
261  if (vcl_hrd_parameters_present_flag)
262  skip_sub_layer_hrd_parameters(gb, cpb_cnt_minus1,
263  sub_pic_hrd_params_present_flag);
264  }
265 
266  return 0;
267 }
268 
270 {
271  skip_bits_long(gb, 32); // num_units_in_tick
272  skip_bits_long(gb, 32); // time_scale
273 
274  if (get_bits1(gb)) // poc_proportional_to_timing_flag
275  get_ue_golomb_long(gb); // num_ticks_poc_diff_one_minus1
276 }
277 
280  unsigned int max_sub_layers_minus1)
281 {
282  unsigned int min_spatial_segmentation_idc;
283 
284  if (get_bits1(gb)) // aspect_ratio_info_present_flag
285  if (get_bits(gb, 8) == 255) // aspect_ratio_idc
286  skip_bits_long(gb, 32); // sar_width u(16), sar_height u(16)
287 
288  if (get_bits1(gb)) // overscan_info_present_flag
289  skip_bits1(gb); // overscan_appropriate_flag
290 
291  if (get_bits1(gb)) { // video_signal_type_present_flag
292  skip_bits(gb, 4); // video_format u(3), video_full_range_flag u(1)
293 
294  if (get_bits1(gb)) // colour_description_present_flag
295  /*
296  * colour_primaries u(8)
297  * transfer_characteristics u(8)
298  * matrix_coeffs u(8)
299  */
300  skip_bits(gb, 24);
301  }
302 
303  if (get_bits1(gb)) { // chroma_loc_info_present_flag
304  get_ue_golomb_long(gb); // chroma_sample_loc_type_top_field
305  get_ue_golomb_long(gb); // chroma_sample_loc_type_bottom_field
306  }
307 
308  /*
309  * neutral_chroma_indication_flag u(1)
310  * field_seq_flag u(1)
311  * frame_field_info_present_flag u(1)
312  */
313  skip_bits(gb, 3);
314 
315  if (get_bits1(gb)) { // default_display_window_flag
316  get_ue_golomb_long(gb); // def_disp_win_left_offset
317  get_ue_golomb_long(gb); // def_disp_win_right_offset
318  get_ue_golomb_long(gb); // def_disp_win_top_offset
319  get_ue_golomb_long(gb); // def_disp_win_bottom_offset
320  }
321 
322  if (get_bits1(gb)) { // vui_timing_info_present_flag
323  skip_timing_info(gb);
324 
325  if (get_bits1(gb)) // vui_hrd_parameters_present_flag
326  skip_hrd_parameters(gb, 1, max_sub_layers_minus1);
327  }
328 
329  if (get_bits1(gb)) { // bitstream_restriction_flag
330  /*
331  * tiles_fixed_structure_flag u(1)
332  * motion_vectors_over_pic_boundaries_flag u(1)
333  * restricted_ref_pic_lists_flag u(1)
334  */
335  skip_bits(gb, 3);
336 
337  min_spatial_segmentation_idc = get_ue_golomb_long(gb);
338 
339  /*
340  * unsigned int(12) min_spatial_segmentation_idc;
341  *
342  * The min_spatial_segmentation_idc indication must indicate a level of
343  * spatial segmentation equal to or less than the lowest level of
344  * spatial segmentation indicated in all the parameter sets.
345  */
347  min_spatial_segmentation_idc);
348 
349  get_ue_golomb_long(gb); // max_bytes_per_pic_denom
350  get_ue_golomb_long(gb); // max_bits_per_min_cu_denom
351  get_ue_golomb_long(gb); // log2_max_mv_length_horizontal
352  get_ue_golomb_long(gb); // log2_max_mv_length_vertical
353  }
354 }
355 
357 {
358  get_ue_golomb_long(gb); // max_dec_pic_buffering_minus1
359  get_ue_golomb_long(gb); // max_num_reorder_pics
360  get_ue_golomb_long(gb); // max_latency_increase_plus1
361 }
362 
365 {
366  unsigned int vps_max_sub_layers_minus1;
367 
368  /*
369  * vps_video_parameter_set_id u(4)
370  * vps_reserved_three_2bits u(2)
371  * vps_max_layers_minus1 u(6)
372  */
373  skip_bits(gb, 12);
374 
375  vps_max_sub_layers_minus1 = get_bits(gb, 3);
376 
377  /*
378  * numTemporalLayers greater than 1 indicates that the stream to which this
379  * configuration record applies is temporally scalable and the contained
380  * number of temporal layers (also referred to as temporal sub-layer or
381  * sub-layer in ISO/IEC 23008-2) is equal to numTemporalLayers. Value 1
382  * indicates that the stream is not temporally scalable. Value 0 indicates
383  * that it is unknown whether the stream is temporally scalable.
384  */
386  vps_max_sub_layers_minus1 + 1);
387 
388  /*
389  * vps_temporal_id_nesting_flag u(1)
390  * vps_reserved_0xffff_16bits u(16)
391  */
392  skip_bits(gb, 17);
393 
394  hvcc_parse_ptl(gb, hvcc, vps_max_sub_layers_minus1);
395 
396  /* nothing useful for hvcC past this point */
397  return 0;
398 }
399 
401 {
402  int i, j, k, num_coeffs;
403 
404  for (i = 0; i < 4; i++)
405  for (j = 0; j < (i == 3 ? 2 : 6); j++)
406  if (!get_bits1(gb)) // scaling_list_pred_mode_flag[i][j]
407  get_ue_golomb_long(gb); // scaling_list_pred_matrix_id_delta[i][j]
408  else {
409  num_coeffs = FFMIN(64, 1 << (4 + (i << 1)));
410 
411  if (i > 1)
412  get_se_golomb_long(gb); // scaling_list_dc_coef_minus8[i-2][j]
413 
414  for (k = 0; k < num_coeffs; k++)
415  get_se_golomb_long(gb); // scaling_list_delta_coef
416  }
417 }
418 
419 static int parse_rps(GetBitContext *gb, unsigned int rps_idx,
420  unsigned int num_rps,
421  unsigned int num_delta_pocs[HEVC_MAX_SHORT_TERM_REF_PIC_SETS])
422 {
423  unsigned int i;
424 
425  if (rps_idx && get_bits1(gb)) { // inter_ref_pic_set_prediction_flag
426  /* this should only happen for slice headers, and this isn't one */
427  if (rps_idx >= num_rps)
428  return AVERROR_INVALIDDATA;
429 
430  skip_bits1 (gb); // delta_rps_sign
431  get_ue_golomb_long(gb); // abs_delta_rps_minus1
432 
433  num_delta_pocs[rps_idx] = 0;
434 
435  /*
436  * From libavcodec/hevc_ps.c:
437  *
438  * if (is_slice_header) {
439  * //foo
440  * } else
441  * rps_ridx = &sps->st_rps[rps - sps->st_rps - 1];
442  *
443  * where:
444  * rps: &sps->st_rps[rps_idx]
445  * sps->st_rps: &sps->st_rps[0]
446  * is_slice_header: rps_idx == num_rps
447  *
448  * thus:
449  * if (num_rps != rps_idx)
450  * rps_ridx = &sps->st_rps[rps_idx - 1];
451  *
452  * NumDeltaPocs[RefRpsIdx]: num_delta_pocs[rps_idx - 1]
453  */
454  for (i = 0; i <= num_delta_pocs[rps_idx - 1]; i++) {
455  uint8_t use_delta_flag = 0;
456  uint8_t used_by_curr_pic_flag = get_bits1(gb);
457  if (!used_by_curr_pic_flag)
458  use_delta_flag = get_bits1(gb);
459 
460  if (used_by_curr_pic_flag || use_delta_flag)
461  num_delta_pocs[rps_idx]++;
462  }
463  } else {
464  unsigned int num_negative_pics = get_ue_golomb_long(gb);
465  unsigned int num_positive_pics = get_ue_golomb_long(gb);
466 
467  if ((num_positive_pics + (uint64_t)num_negative_pics) * 2 > get_bits_left(gb))
468  return AVERROR_INVALIDDATA;
469 
470  num_delta_pocs[rps_idx] = num_negative_pics + num_positive_pics;
471 
472  for (i = 0; i < num_negative_pics; i++) {
473  get_ue_golomb_long(gb); // delta_poc_s0_minus1[rps_idx]
474  skip_bits1 (gb); // used_by_curr_pic_s0_flag[rps_idx]
475  }
476 
477  for (i = 0; i < num_positive_pics; i++) {
478  get_ue_golomb_long(gb); // delta_poc_s1_minus1[rps_idx]
479  skip_bits1 (gb); // used_by_curr_pic_s1_flag[rps_idx]
480  }
481  }
482 
483  return 0;
484 }
485 
488 {
489  unsigned int i, sps_max_sub_layers_minus1, log2_max_pic_order_cnt_lsb_minus4;
490  unsigned int num_short_term_ref_pic_sets, num_delta_pocs[HEVC_MAX_SHORT_TERM_REF_PIC_SETS];
491 
492  skip_bits(gb, 4); // sps_video_parameter_set_id
493 
494  sps_max_sub_layers_minus1 = get_bits (gb, 3);
495 
496  /*
497  * numTemporalLayers greater than 1 indicates that the stream to which this
498  * configuration record applies is temporally scalable and the contained
499  * number of temporal layers (also referred to as temporal sub-layer or
500  * sub-layer in ISO/IEC 23008-2) is equal to numTemporalLayers. Value 1
501  * indicates that the stream is not temporally scalable. Value 0 indicates
502  * that it is unknown whether the stream is temporally scalable.
503  */
505  sps_max_sub_layers_minus1 + 1);
506 
507  hvcc->temporalIdNested = get_bits1(gb);
508 
509  hvcc_parse_ptl(gb, hvcc, sps_max_sub_layers_minus1);
510 
511  get_ue_golomb_long(gb); // sps_seq_parameter_set_id
512 
513  hvcc->chromaFormat = get_ue_golomb_long(gb);
514 
515  if (hvcc->chromaFormat == 3)
516  skip_bits1(gb); // separate_colour_plane_flag
517 
518  get_ue_golomb_long(gb); // pic_width_in_luma_samples
519  get_ue_golomb_long(gb); // pic_height_in_luma_samples
520 
521  if (get_bits1(gb)) { // conformance_window_flag
522  get_ue_golomb_long(gb); // conf_win_left_offset
523  get_ue_golomb_long(gb); // conf_win_right_offset
524  get_ue_golomb_long(gb); // conf_win_top_offset
525  get_ue_golomb_long(gb); // conf_win_bottom_offset
526  }
527 
530  log2_max_pic_order_cnt_lsb_minus4 = get_ue_golomb_long(gb);
531 
532  /* sps_sub_layer_ordering_info_present_flag */
533  i = get_bits1(gb) ? 0 : sps_max_sub_layers_minus1;
534  for (; i <= sps_max_sub_layers_minus1; i++)
536 
537  get_ue_golomb_long(gb); // log2_min_luma_coding_block_size_minus3
538  get_ue_golomb_long(gb); // log2_diff_max_min_luma_coding_block_size
539  get_ue_golomb_long(gb); // log2_min_transform_block_size_minus2
540  get_ue_golomb_long(gb); // log2_diff_max_min_transform_block_size
541  get_ue_golomb_long(gb); // max_transform_hierarchy_depth_inter
542  get_ue_golomb_long(gb); // max_transform_hierarchy_depth_intra
543 
544  if (get_bits1(gb) && // scaling_list_enabled_flag
545  get_bits1(gb)) // sps_scaling_list_data_present_flag
547 
548  skip_bits1(gb); // amp_enabled_flag
549  skip_bits1(gb); // sample_adaptive_offset_enabled_flag
550 
551  if (get_bits1(gb)) { // pcm_enabled_flag
552  skip_bits (gb, 4); // pcm_sample_bit_depth_luma_minus1
553  skip_bits (gb, 4); // pcm_sample_bit_depth_chroma_minus1
554  get_ue_golomb_long(gb); // log2_min_pcm_luma_coding_block_size_minus3
555  get_ue_golomb_long(gb); // log2_diff_max_min_pcm_luma_coding_block_size
556  skip_bits1 (gb); // pcm_loop_filter_disabled_flag
557  }
558 
559  num_short_term_ref_pic_sets = get_ue_golomb_long(gb);
560  if (num_short_term_ref_pic_sets > HEVC_MAX_SHORT_TERM_REF_PIC_SETS)
561  return AVERROR_INVALIDDATA;
562 
563  for (i = 0; i < num_short_term_ref_pic_sets; i++) {
564  int ret = parse_rps(gb, i, num_short_term_ref_pic_sets, num_delta_pocs);
565  if (ret < 0)
566  return ret;
567  }
568 
569  if (get_bits1(gb)) { // long_term_ref_pics_present_flag
570  unsigned num_long_term_ref_pics_sps = get_ue_golomb_long(gb);
571  if (num_long_term_ref_pics_sps > 31U)
572  return AVERROR_INVALIDDATA;
573  for (i = 0; i < num_long_term_ref_pics_sps; i++) { // num_long_term_ref_pics_sps
574  int len = FFMIN(log2_max_pic_order_cnt_lsb_minus4 + 4, 16);
575  skip_bits (gb, len); // lt_ref_pic_poc_lsb_sps[i]
576  skip_bits1(gb); // used_by_curr_pic_lt_sps_flag[i]
577  }
578  }
579 
580  skip_bits1(gb); // sps_temporal_mvp_enabled_flag
581  skip_bits1(gb); // strong_intra_smoothing_enabled_flag
582 
583  if (get_bits1(gb)) // vui_parameters_present_flag
584  hvcc_parse_vui(gb, hvcc, sps_max_sub_layers_minus1);
585 
586  /* nothing useful for hvcC past this point */
587  return 0;
588 }
589 
592 {
593  uint8_t tiles_enabled_flag, entropy_coding_sync_enabled_flag;
594 
595  get_ue_golomb_long(gb); // pps_pic_parameter_set_id
596  get_ue_golomb_long(gb); // pps_seq_parameter_set_id
597 
598  /*
599  * dependent_slice_segments_enabled_flag u(1)
600  * output_flag_present_flag u(1)
601  * num_extra_slice_header_bits u(3)
602  * sign_data_hiding_enabled_flag u(1)
603  * cabac_init_present_flag u(1)
604  */
605  skip_bits(gb, 7);
606 
607  get_ue_golomb_long(gb); // num_ref_idx_l0_default_active_minus1
608  get_ue_golomb_long(gb); // num_ref_idx_l1_default_active_minus1
609  get_se_golomb_long(gb); // init_qp_minus26
610 
611  /*
612  * constrained_intra_pred_flag u(1)
613  * transform_skip_enabled_flag u(1)
614  */
615  skip_bits(gb, 2);
616 
617  if (get_bits1(gb)) // cu_qp_delta_enabled_flag
618  get_ue_golomb_long(gb); // diff_cu_qp_delta_depth
619 
620  get_se_golomb_long(gb); // pps_cb_qp_offset
621  get_se_golomb_long(gb); // pps_cr_qp_offset
622 
623  /*
624  * pps_slice_chroma_qp_offsets_present_flag u(1)
625  * weighted_pred_flag u(1)
626  * weighted_bipred_flag u(1)
627  * transquant_bypass_enabled_flag u(1)
628  */
629  skip_bits(gb, 4);
630 
631  tiles_enabled_flag = get_bits1(gb);
632  entropy_coding_sync_enabled_flag = get_bits1(gb);
633 
634  if (entropy_coding_sync_enabled_flag && tiles_enabled_flag)
635  hvcc->parallelismType = 0; // mixed-type parallel decoding
636  else if (entropy_coding_sync_enabled_flag)
637  hvcc->parallelismType = 3; // wavefront-based parallel decoding
638  else if (tiles_enabled_flag)
639  hvcc->parallelismType = 2; // tile-based parallel decoding
640  else
641  hvcc->parallelismType = 1; // slice-based parallel decoding
642 
643  /* nothing useful for hvcC past this point */
644  return 0;
645 }
646 
647 static void nal_unit_parse_header(GetBitContext *gb, uint8_t *nal_type)
648 {
649  skip_bits1(gb); // forbidden_zero_bit
650 
651  *nal_type = get_bits(gb, 6);
652 
653  /*
654  * nuh_layer_id u(6)
655  * nuh_temporal_id_plus1 u(3)
656  */
657  skip_bits(gb, 9);
658 }
659 
660 static int hvcc_array_add_nal_unit(uint8_t *nal_buf, uint32_t nal_size,
661  uint8_t nal_type, int ps_array_completeness,
663 {
664  int ret;
665  uint8_t index;
666  uint16_t numNalus;
668 
669  for (index = 0; index < hvcc->numOfArrays; index++)
670  if (hvcc->array[index].NAL_unit_type == nal_type)
671  break;
672 
673  if (index >= hvcc->numOfArrays) {
674  uint8_t i;
675 
676  ret = av_reallocp_array(&hvcc->array, index + 1, sizeof(HVCCNALUnitArray));
677  if (ret < 0)
678  return ret;
679 
680  for (i = hvcc->numOfArrays; i <= index; i++)
681  memset(&hvcc->array[i], 0, sizeof(HVCCNALUnitArray));
682  hvcc->numOfArrays = index + 1;
683  }
684 
685  array = &hvcc->array[index];
686  numNalus = array->numNalus;
687 
688  ret = av_reallocp_array(&array->nalUnit, numNalus + 1, sizeof(uint8_t*));
689  if (ret < 0)
690  return ret;
691 
692  ret = av_reallocp_array(&array->nalUnitLength, numNalus + 1, sizeof(uint16_t));
693  if (ret < 0)
694  return ret;
695 
696  array->nalUnit [numNalus] = nal_buf;
697  array->nalUnitLength[numNalus] = nal_size;
698  array->NAL_unit_type = nal_type;
699  array->numNalus++;
700 
701  /*
702  * When the sample entry name is ‘hvc1’, the default and mandatory value of
703  * array_completeness is 1 for arrays of all types of parameter sets, and 0
704  * for all other arrays. When the sample entry name is ‘hev1’, the default
705  * value of array_completeness is 0 for all arrays.
706  */
707  if (nal_type == HEVC_NAL_VPS || nal_type == HEVC_NAL_SPS || nal_type == HEVC_NAL_PPS)
708  array->array_completeness = ps_array_completeness;
709 
710  return 0;
711 }
712 
713 static int hvcc_add_nal_unit(uint8_t *nal_buf, uint32_t nal_size,
714  int ps_array_completeness,
716 {
717  int ret = 0;
718  GetBitContext gbc;
719  uint8_t nal_type;
720  uint8_t *rbsp_buf;
721  uint32_t rbsp_size;
722 
723  rbsp_buf = ff_nal_unit_extract_rbsp(nal_buf, nal_size, &rbsp_size, 2);
724  if (!rbsp_buf) {
725  ret = AVERROR(ENOMEM);
726  goto end;
727  }
728 
729  ret = init_get_bits8(&gbc, rbsp_buf, rbsp_size);
730  if (ret < 0)
731  goto end;
732 
733  nal_unit_parse_header(&gbc, &nal_type);
734 
735  /*
736  * Note: only 'declarative' SEI messages are allowed in
737  * hvcC. Perhaps the SEI playload type should be checked
738  * and non-declarative SEI messages discarded?
739  */
740  switch (nal_type) {
741  case HEVC_NAL_VPS:
742  case HEVC_NAL_SPS:
743  case HEVC_NAL_PPS:
744  case HEVC_NAL_SEI_PREFIX:
745  case HEVC_NAL_SEI_SUFFIX:
746  ret = hvcc_array_add_nal_unit(nal_buf, nal_size, nal_type,
747  ps_array_completeness, hvcc);
748  if (ret < 0)
749  goto end;
750  else if (nal_type == HEVC_NAL_VPS)
751  ret = hvcc_parse_vps(&gbc, hvcc);
752  else if (nal_type == HEVC_NAL_SPS)
753  ret = hvcc_parse_sps(&gbc, hvcc);
754  else if (nal_type == HEVC_NAL_PPS)
755  ret = hvcc_parse_pps(&gbc, hvcc);
756  if (ret < 0)
757  goto end;
758  break;
759  default:
760  ret = AVERROR_INVALIDDATA;
761  goto end;
762  }
763 
764 end:
765  av_free(rbsp_buf);
766  return ret;
767 }
768 
770 {
771  memset(hvcc, 0, sizeof(HEVCDecoderConfigurationRecord));
772  hvcc->configurationVersion = 1;
773  hvcc->lengthSizeMinusOne = 3; // 4 bytes
774 
775  /*
776  * The following fields have all their valid bits set by default,
777  * the ProfileTierLevel parsing code will unset them when needed.
778  */
779  hvcc->general_profile_compatibility_flags = 0xffffffff;
780  hvcc->general_constraint_indicator_flags = 0xffffffffffff;
781 
782  /*
783  * Initialize this field with an invalid value which can be used to detect
784  * whether we didn't see any VUI (in which case it should be reset to zero).
785  */
787 }
788 
790 {
791  uint8_t i;
792 
793  for (i = 0; i < hvcc->numOfArrays; i++) {
794  hvcc->array[i].numNalus = 0;
795  av_freep(&hvcc->array[i].nalUnit);
796  av_freep(&hvcc->array[i].nalUnitLength);
797  }
798 
799  hvcc->numOfArrays = 0;
800  av_freep(&hvcc->array);
801 }
802 
804 {
805  uint8_t i;
806  uint16_t j, vps_count = 0, sps_count = 0, pps_count = 0;
807 
808  /*
809  * We only support writing HEVCDecoderConfigurationRecord version 1.
810  */
811  hvcc->configurationVersion = 1;
812 
813  /*
814  * If min_spatial_segmentation_idc is invalid, reset to 0 (unspecified).
815  */
818 
819  /*
820  * parallelismType indicates the type of parallelism that is used to meet
821  * the restrictions imposed by min_spatial_segmentation_idc when the value
822  * of min_spatial_segmentation_idc is greater than 0.
823  */
824  if (!hvcc->min_spatial_segmentation_idc)
825  hvcc->parallelismType = 0;
826 
827  /*
828  * It's unclear how to properly compute these fields, so
829  * let's always set them to values meaning 'unspecified'.
830  */
831  hvcc->avgFrameRate = 0;
832  hvcc->constantFrameRate = 0;
833 
834  av_log(NULL, AV_LOG_TRACE, "configurationVersion: %"PRIu8"\n",
835  hvcc->configurationVersion);
836  av_log(NULL, AV_LOG_TRACE, "general_profile_space: %"PRIu8"\n",
837  hvcc->general_profile_space);
838  av_log(NULL, AV_LOG_TRACE, "general_tier_flag: %"PRIu8"\n",
839  hvcc->general_tier_flag);
840  av_log(NULL, AV_LOG_TRACE, "general_profile_idc: %"PRIu8"\n",
841  hvcc->general_profile_idc);
842  av_log(NULL, AV_LOG_TRACE, "general_profile_compatibility_flags: 0x%08"PRIx32"\n",
844  av_log(NULL, AV_LOG_TRACE, "general_constraint_indicator_flags: 0x%012"PRIx64"\n",
846  av_log(NULL, AV_LOG_TRACE, "general_level_idc: %"PRIu8"\n",
847  hvcc->general_level_idc);
848  av_log(NULL, AV_LOG_TRACE, "min_spatial_segmentation_idc: %"PRIu16"\n",
850  av_log(NULL, AV_LOG_TRACE, "parallelismType: %"PRIu8"\n",
851  hvcc->parallelismType);
852  av_log(NULL, AV_LOG_TRACE, "chromaFormat: %"PRIu8"\n",
853  hvcc->chromaFormat);
854  av_log(NULL, AV_LOG_TRACE, "bitDepthLumaMinus8: %"PRIu8"\n",
855  hvcc->bitDepthLumaMinus8);
856  av_log(NULL, AV_LOG_TRACE, "bitDepthChromaMinus8: %"PRIu8"\n",
857  hvcc->bitDepthChromaMinus8);
858  av_log(NULL, AV_LOG_TRACE, "avgFrameRate: %"PRIu16"\n",
859  hvcc->avgFrameRate);
860  av_log(NULL, AV_LOG_TRACE, "constantFrameRate: %"PRIu8"\n",
861  hvcc->constantFrameRate);
862  av_log(NULL, AV_LOG_TRACE, "numTemporalLayers: %"PRIu8"\n",
863  hvcc->numTemporalLayers);
864  av_log(NULL, AV_LOG_TRACE, "temporalIdNested: %"PRIu8"\n",
865  hvcc->temporalIdNested);
866  av_log(NULL, AV_LOG_TRACE, "lengthSizeMinusOne: %"PRIu8"\n",
867  hvcc->lengthSizeMinusOne);
868  av_log(NULL, AV_LOG_TRACE, "numOfArrays: %"PRIu8"\n",
869  hvcc->numOfArrays);
870  for (i = 0; i < hvcc->numOfArrays; i++) {
871  av_log(NULL, AV_LOG_TRACE, "array_completeness[%"PRIu8"]: %"PRIu8"\n",
872  i, hvcc->array[i].array_completeness);
873  av_log(NULL, AV_LOG_TRACE, "NAL_unit_type[%"PRIu8"]: %"PRIu8"\n",
874  i, hvcc->array[i].NAL_unit_type);
875  av_log(NULL, AV_LOG_TRACE, "numNalus[%"PRIu8"]: %"PRIu16"\n",
876  i, hvcc->array[i].numNalus);
877  for (j = 0; j < hvcc->array[i].numNalus; j++)
879  "nalUnitLength[%"PRIu8"][%"PRIu16"]: %"PRIu16"\n",
880  i, j, hvcc->array[i].nalUnitLength[j]);
881  }
882 
883  /*
884  * We need at least one of each: VPS, SPS and PPS.
885  */
886  for (i = 0; i < hvcc->numOfArrays; i++)
887  switch (hvcc->array[i].NAL_unit_type) {
888  case HEVC_NAL_VPS:
889  vps_count += hvcc->array[i].numNalus;
890  break;
891  case HEVC_NAL_SPS:
892  sps_count += hvcc->array[i].numNalus;
893  break;
894  case HEVC_NAL_PPS:
895  pps_count += hvcc->array[i].numNalus;
896  break;
897  default:
898  break;
899  }
900  if (!vps_count || vps_count > HEVC_MAX_VPS_COUNT ||
901  !sps_count || sps_count > HEVC_MAX_SPS_COUNT ||
902  !pps_count || pps_count > HEVC_MAX_PPS_COUNT)
903  return AVERROR_INVALIDDATA;
904 
905  /* unsigned int(8) configurationVersion = 1; */
906  avio_w8(pb, hvcc->configurationVersion);
907 
908  /*
909  * unsigned int(2) general_profile_space;
910  * unsigned int(1) general_tier_flag;
911  * unsigned int(5) general_profile_idc;
912  */
913  avio_w8(pb, hvcc->general_profile_space << 6 |
914  hvcc->general_tier_flag << 5 |
915  hvcc->general_profile_idc);
916 
917  /* unsigned int(32) general_profile_compatibility_flags; */
919 
920  /* unsigned int(48) general_constraint_indicator_flags; */
923 
924  /* unsigned int(8) general_level_idc; */
925  avio_w8(pb, hvcc->general_level_idc);
926 
927  /*
928  * bit(4) reserved = ‘1111’b;
929  * unsigned int(12) min_spatial_segmentation_idc;
930  */
931  avio_wb16(pb, hvcc->min_spatial_segmentation_idc | 0xf000);
932 
933  /*
934  * bit(6) reserved = ‘111111’b;
935  * unsigned int(2) parallelismType;
936  */
937  avio_w8(pb, hvcc->parallelismType | 0xfc);
938 
939  /*
940  * bit(6) reserved = ‘111111’b;
941  * unsigned int(2) chromaFormat;
942  */
943  avio_w8(pb, hvcc->chromaFormat | 0xfc);
944 
945  /*
946  * bit(5) reserved = ‘11111’b;
947  * unsigned int(3) bitDepthLumaMinus8;
948  */
949  avio_w8(pb, hvcc->bitDepthLumaMinus8 | 0xf8);
950 
951  /*
952  * bit(5) reserved = ‘11111’b;
953  * unsigned int(3) bitDepthChromaMinus8;
954  */
955  avio_w8(pb, hvcc->bitDepthChromaMinus8 | 0xf8);
956 
957  /* bit(16) avgFrameRate; */
958  avio_wb16(pb, hvcc->avgFrameRate);
959 
960  /*
961  * bit(2) constantFrameRate;
962  * bit(3) numTemporalLayers;
963  * bit(1) temporalIdNested;
964  * unsigned int(2) lengthSizeMinusOne;
965  */
966  avio_w8(pb, hvcc->constantFrameRate << 6 |
967  hvcc->numTemporalLayers << 3 |
968  hvcc->temporalIdNested << 2 |
969  hvcc->lengthSizeMinusOne);
970 
971  /* unsigned int(8) numOfArrays; */
972  avio_w8(pb, hvcc->numOfArrays);
973 
974  for (i = 0; i < hvcc->numOfArrays; i++) {
975  /*
976  * bit(1) array_completeness;
977  * unsigned int(1) reserved = 0;
978  * unsigned int(6) NAL_unit_type;
979  */
980  avio_w8(pb, hvcc->array[i].array_completeness << 7 |
981  hvcc->array[i].NAL_unit_type & 0x3f);
982 
983  /* unsigned int(16) numNalus; */
984  avio_wb16(pb, hvcc->array[i].numNalus);
985 
986  for (j = 0; j < hvcc->array[i].numNalus; j++) {
987  /* unsigned int(16) nalUnitLength; */
988  avio_wb16(pb, hvcc->array[i].nalUnitLength[j]);
989 
990  /* bit(8*nalUnitLength) nalUnit; */
991  avio_write(pb, hvcc->array[i].nalUnit[j],
992  hvcc->array[i].nalUnitLength[j]);
993  }
994  }
995 
996  return 0;
997 }
998 
999 int ff_hevc_annexb2mp4(AVIOContext *pb, const uint8_t *buf_in,
1000  int size, int filter_ps, int *ps_count)
1001 {
1002  int num_ps = 0, ret = 0;
1003  uint8_t *buf, *end, *start = NULL;
1004 
1005  if (!filter_ps) {
1006  ret = ff_avc_parse_nal_units(pb, buf_in, size);
1007  goto end;
1008  }
1009 
1010  ret = ff_avc_parse_nal_units_buf(buf_in, &start, &size);
1011  if (ret < 0)
1012  goto end;
1013 
1014  ret = 0;
1015  buf = start;
1016  end = start + size;
1017 
1018  while (end - buf > 4) {
1019  uint32_t len = FFMIN(AV_RB32(buf), end - buf - 4);
1020  uint8_t type = (buf[4] >> 1) & 0x3f;
1021 
1022  buf += 4;
1023 
1024  switch (type) {
1025  case HEVC_NAL_VPS:
1026  case HEVC_NAL_SPS:
1027  case HEVC_NAL_PPS:
1028  num_ps++;
1029  break;
1030  default:
1031  ret += 4 + len;
1032  avio_wb32(pb, len);
1033  avio_write(pb, buf, len);
1034  break;
1035  }
1036 
1037  buf += len;
1038  }
1039 
1040 end:
1041  av_free(start);
1042  if (ps_count)
1043  *ps_count = num_ps;
1044  return ret;
1045 }
1046 
1047 int ff_hevc_annexb2mp4_buf(const uint8_t *buf_in, uint8_t **buf_out,
1048  int *size, int filter_ps, int *ps_count)
1049 {
1050  AVIOContext *pb;
1051  int ret;
1052 
1053  ret = avio_open_dyn_buf(&pb);
1054  if (ret < 0)
1055  return ret;
1056 
1057  ret = ff_hevc_annexb2mp4(pb, buf_in, *size, filter_ps, ps_count);
1058  if (ret < 0) {
1059  ffio_free_dyn_buf(&pb);
1060  return ret;
1061  }
1062 
1063  *size = avio_close_dyn_buf(pb, buf_out);
1064 
1065  return 0;
1066 }
1067 
1069  int size, int ps_array_completeness)
1070 {
1072  uint8_t *buf, *end, *start;
1073  int ret;
1074 
1075  if (size < 6) {
1076  /* We can't write a valid hvcC from the provided data */
1077  return AVERROR_INVALIDDATA;
1078  } else if (*data == 1) {
1079  /* Data is already hvcC-formatted */
1080  avio_write(pb, data, size);
1081  return 0;
1082  } else if (!(AV_RB24(data) == 1 || AV_RB32(data) == 1)) {
1083  /* Not a valid Annex B start code prefix */
1084  return AVERROR_INVALIDDATA;
1085  }
1086 
1087  ret = ff_avc_parse_nal_units_buf(data, &start, &size);
1088  if (ret < 0)
1089  return ret;
1090 
1091  hvcc_init(&hvcc);
1092 
1093  buf = start;
1094  end = start + size;
1095 
1096  while (end - buf > 4) {
1097  uint32_t len = FFMIN(AV_RB32(buf), end - buf - 4);
1098  uint8_t type = (buf[4] >> 1) & 0x3f;
1099 
1100  buf += 4;
1101 
1102  switch (type) {
1103  case HEVC_NAL_VPS:
1104  case HEVC_NAL_SPS:
1105  case HEVC_NAL_PPS:
1106  case HEVC_NAL_SEI_PREFIX:
1107  case HEVC_NAL_SEI_SUFFIX:
1108  ret = hvcc_add_nal_unit(buf, len, ps_array_completeness, &hvcc);
1109  if (ret < 0)
1110  goto end;
1111  break;
1112  default:
1113  break;
1114  }
1115 
1116  buf += len;
1117  }
1118 
1119  ret = hvcc_write(pb, &hvcc);
1120 
1121 end:
1122  hvcc_close(&hvcc);
1123  av_free(start);
1124  return ret;
1125 }
uint8_t
uint8_t * ff_nal_unit_extract_rbsp(const uint8_t *src, uint32_t src_len, uint32_t *dst_len, int header_len)
Definition: avc.c:269
int ff_avc_parse_nal_units(AVIOContext *pb, const uint8_t *buf_in, int size)
Definition: avc.c:73
int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
Definition: avc.c:95
Libavcodec external API header.
Buffered I/O operations.
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:203
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:383
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:461
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1427
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:225
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1382
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1457
#define AV_RB24
Definition: intreadwrite.h:64
#define AV_RB32
Definition: intreadwrite.h:130
#define FFMIN(a, b)
Definition: common.h:105
#define FFMAX(a, b)
Definition: common.h:103
#define NULL
Definition: coverity.c:32
bitstream reader API header.
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
static uint64_t get_bits64(GetBitContext *s, int n)
Read 0-64 bits.
Definition: get_bits.h:572
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
exp golomb vlc stuff
static int get_se_golomb_long(GetBitContext *gb)
Definition: golomb.h:296
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:106
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
Definition: mem.c:206
int index
Definition: gxfenc.c:89
const H265RawProfileTierLevel * ptl
Definition: h265_levels.c:170
#define MAX_SPATIAL_SEGMENTATION
Definition: hevc.c:31
static int hvcc_write(AVIOContext *pb, HEVCDecoderConfigurationRecord *hvcc)
Definition: hevc.c:803
static void hvcc_close(HEVCDecoderConfigurationRecord *hvcc)
Definition: hevc.c:789
static void skip_sub_layer_ordering_info(GetBitContext *gb)
Definition: hevc.c:356
int ff_hevc_annexb2mp4_buf(const uint8_t *buf_in, uint8_t **buf_out, int *size, int filter_ps, int *ps_count)
Writes Annex B formatted HEVC NAL units to a data buffer.
Definition: hevc.c:1047
int ff_hevc_annexb2mp4(AVIOContext *pb, const uint8_t *buf_in, int size, int filter_ps, int *ps_count)
Writes Annex B formatted HEVC NAL units to the provided AVIOContext.
Definition: hevc.c:999
static void hvcc_update_ptl(HEVCDecoderConfigurationRecord *hvcc, HVCCProfileTierLevel *ptl)
Definition: hevc.c:72
static int hvcc_array_add_nal_unit(uint8_t *nal_buf, uint32_t nal_size, uint8_t nal_type, int ps_array_completeness, HEVCDecoderConfigurationRecord *hvcc)
Definition: hevc.c:660
static int parse_rps(GetBitContext *gb, unsigned int rps_idx, unsigned int num_rps, unsigned int num_delta_pocs[HEVC_MAX_SHORT_TERM_REF_PIC_SETS])
Definition: hevc.c:419
static int hvcc_parse_vps(GetBitContext *gb, HEVCDecoderConfigurationRecord *hvcc)
Definition: hevc.c:363
static void skip_sub_layer_hrd_parameters(GetBitContext *gb, unsigned int cpb_cnt_minus1, uint8_t sub_pic_hrd_params_present_flag)
Definition: hevc.c:175
static int skip_hrd_parameters(GetBitContext *gb, uint8_t cprms_present_flag, unsigned int max_sub_layers_minus1)
Definition: hevc.c:194
static void nal_unit_parse_header(GetBitContext *gb, uint8_t *nal_type)
Definition: hevc.c:647
int ff_isom_write_hvcc(AVIOContext *pb, const uint8_t *data, int size, int ps_array_completeness)
Writes HEVC extradata (parameter sets, declarative SEI NAL units) to the provided AVIOContext.
Definition: hevc.c:1068
static void hvcc_parse_ptl(GetBitContext *gb, HEVCDecoderConfigurationRecord *hvcc, unsigned int max_sub_layers_minus1)
Definition: hevc.c:126
static void hvcc_parse_vui(GetBitContext *gb, HEVCDecoderConfigurationRecord *hvcc, unsigned int max_sub_layers_minus1)
Definition: hevc.c:278
static int hvcc_parse_pps(GetBitContext *gb, HEVCDecoderConfigurationRecord *hvcc)
Definition: hevc.c:590
static void skip_scaling_list_data(GetBitContext *gb)
Definition: hevc.c:400
static void skip_timing_info(GetBitContext *gb)
Definition: hevc.c:269
static int hvcc_parse_sps(GetBitContext *gb, HEVCDecoderConfigurationRecord *hvcc)
Definition: hevc.c:486
static void hvcc_init(HEVCDecoderConfigurationRecord *hvcc)
Definition: hevc.c:769
static int hvcc_add_nal_unit(uint8_t *nal_buf, uint32_t nal_size, int ps_array_completeness, HEVCDecoderConfigurationRecord *hvcc)
Definition: hevc.c:713
cl_device_type type
int i
Definition: input.c:407
@ HEVC_NAL_SEI_SUFFIX
Definition: hevc.h:69
@ HEVC_NAL_SEI_PREFIX
Definition: hevc.h:68
@ HEVC_NAL_PPS
Definition: hevc.h:63
@ HEVC_NAL_VPS
Definition: hevc.h:61
@ HEVC_NAL_SPS
Definition: hevc.h:62
@ HEVC_MAX_SPS_COUNT
Definition: hevc.h:112
@ HEVC_MAX_PPS_COUNT
Definition: hevc.h:114
@ HEVC_MAX_SUB_LAYERS
Definition: hevc.h:105
@ HEVC_MAX_VPS_COUNT
Definition: hevc.h:110
@ HEVC_MAX_SHORT_TERM_REF_PIC_SETS
Definition: hevc.h:122
internal header for HEVC (de)muxer utilities
const char data[16]
Definition: mxf.c:142
Bytestream IO Context.
Definition: avio.h:161
uint16_t min_spatial_segmentation_idc
Definition: hevc.c:49
HVCCNALUnitArray * array
Definition: hevc.c:60
uint64_t general_constraint_indicator_flags
Definition: hevc.c:47
uint32_t general_profile_compatibility_flags
Definition: hevc.c:46
uint16_t * nalUnitLength
Definition: hevc.c:37
uint8_t NAL_unit_type
Definition: hevc.c:35
uint8_t array_completeness
Definition: hevc.c:34
uint8_t ** nalUnit
Definition: hevc.c:38
uint16_t numNalus
Definition: hevc.c:36
uint8_t profile_space
Definition: hevc.c:64
uint8_t tier_flag
Definition: hevc.c:65
uint8_t level_idc
Definition: hevc.c:69
uint64_t constraint_indicator_flags
Definition: hevc.c:68
uint32_t profile_compatibility_flags
Definition: hevc.c:67
uint8_t profile_idc
Definition: hevc.c:66
#define av_free(p)
#define av_freep(p)
#define av_log(a,...)
static int array[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:106
int size
int len