FFmpeg
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  */
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
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  */
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  */
112 
113  /*
114  * Each bit in general_profile_compatibility_flags may only be set if all
115  * the parameter sets set that bit.
116  */
118 
119  /*
120  * Each bit in general_constraint_indicator_flags may only be set if all
121  * the parameter sets set that bit.
122  */
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 {
1071  int ret = 0;
1072  uint8_t *buf, *end, *start = NULL;
1074 
1075  hvcc_init(&hvcc);
1076 
1077  if (size < 6) {
1078  /* We can't write a valid hvcC from the provided data */
1079  ret = AVERROR_INVALIDDATA;
1080  goto end;
1081  } else if (*data == 1) {
1082  /* Data is already hvcC-formatted */
1083  avio_write(pb, data, size);
1084  goto end;
1085  } else if (!(AV_RB24(data) == 1 || AV_RB32(data) == 1)) {
1086  /* Not a valid Annex B start code prefix */
1087  ret = AVERROR_INVALIDDATA;
1088  goto end;
1089  }
1090 
1091  ret = ff_avc_parse_nal_units_buf(data, &start, &size);
1092  if (ret < 0)
1093  goto end;
1094 
1095  buf = start;
1096  end = start + size;
1097 
1098  while (end - buf > 4) {
1099  uint32_t len = FFMIN(AV_RB32(buf), end - buf - 4);
1100  uint8_t type = (buf[4] >> 1) & 0x3f;
1101 
1102  buf += 4;
1103 
1104  switch (type) {
1105  case HEVC_NAL_VPS:
1106  case HEVC_NAL_SPS:
1107  case HEVC_NAL_PPS:
1108  case HEVC_NAL_SEI_PREFIX:
1109  case HEVC_NAL_SEI_SUFFIX:
1110  ret = hvcc_add_nal_unit(buf, len, ps_array_completeness, &hvcc);
1111  if (ret < 0)
1112  goto end;
1113  break;
1114  default:
1115  break;
1116  }
1117 
1118  buf += len;
1119  }
1120 
1121  ret = hvcc_write(pb, &hvcc);
1122 
1123 end:
1124  hvcc_close(&hvcc);
1125  av_free(start);
1126  return ret;
1127 }
static void skip_scaling_list_data(GetBitContext *gb)
Definition: hevc.c:400
static int hvcc_parse_vps(GetBitContext *gb, HEVCDecoderConfigurationRecord *hvcc)
Definition: hevc.c:363
#define NULL
Definition: coverity.c:32
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
Buffered I/O operations.
uint8_t tier_flag
Definition: hevc.c:65
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1421
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
uint8_t level_idc
Definition: hevc.c:69
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
HVCCNALUnitArray * array
Definition: hevc.c:60
uint8_t NAL_unit_type
Definition: hevc.c:35
uint16_t * nalUnitLength
Definition: hevc.c:37
GLint GLenum type
Definition: opengl_enc.c:104
static int hvcc_write(AVIOContext *pb, HEVCDecoderConfigurationRecord *hvcc)
Definition: hevc.c:803
uint64_t general_constraint_indicator_flags
Definition: hevc.c:47
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1376
uint32_t general_profile_compatibility_flags
Definition: hevc.c:46
uint8_t
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
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
const H265RawProfileTierLevel * ptl
Definition: h265_levels.c:170
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
bitstream reader API header.
ptrdiff_t size
Definition: opengl_enc.c:100
static void skip_sub_layer_ordering_info(GetBitContext *gb)
Definition: hevc.c:356
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:213
static int hvcc_parse_pps(GetBitContext *gb, HEVCDecoderConfigurationRecord *hvcc)
Definition: hevc.c:590
#define av_log(a,...)
uint32_t profile_compatibility_flags
Definition: hevc.c:67
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
static uint64_t get_bits64(GetBitContext *s, int n)
Read 0-64 bits.
Definition: get_bits.h:572
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
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 nal_unit_parse_header(GetBitContext *gb, uint8_t *nal_type)
Definition: hevc.c:647
#define FFMAX(a, b)
Definition: common.h:94
int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
Definition: avc.c:95
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:205
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
int ff_avc_parse_nal_units(AVIOContext *pb, const uint8_t *buf_in, int size)
Definition: avc.c:73
#define FFMIN(a, b)
Definition: common.h:96
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 void skip_timing_info(GetBitContext *gb)
Definition: hevc.c:269
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:270
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1451
static void hvcc_parse_vui(GetBitContext *gb, HEVCDecoderConfigurationRecord *hvcc, unsigned int max_sub_layers_minus1)
Definition: hevc.c:278
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:105
#define MAX_SPATIAL_SEGMENTATION
Definition: hevc.c:31
uint8_t profile_idc
Definition: hevc.c:66
static int get_se_golomb_long(GetBitContext *gb)
Definition: golomb.h:294
Libavcodec external API header.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:87
static void hvcc_close(HEVCDecoderConfigurationRecord *hvcc)
Definition: hevc.c:789
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:191
void * buf
Definition: avisynth_c.h:766
uint16_t numNalus
Definition: hevc.c:36
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
uint8_t ** nalUnit
Definition: hevc.c:38
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
int index
Definition: gxfenc.c:89
static void hvcc_parse_ptl(GetBitContext *gb, HEVCDecoderConfigurationRecord *hvcc, unsigned int max_sub_layers_minus1)
Definition: hevc.c:126
uint8_t array_completeness
Definition: hevc.c:34
uint8_t profile_space
Definition: hevc.c:64
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:473
static int hvcc_parse_sps(GetBitContext *gb, HEVCDecoderConfigurationRecord *hvcc)
Definition: hevc.c:486
static int skip_hrd_parameters(GetBitContext *gb, uint8_t cprms_present_flag, unsigned int max_sub_layers_minus1)
Definition: hevc.c:194
#define av_free(p)
int len
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:375
static int hvcc_add_nal_unit(uint8_t *nal_buf, uint32_t nal_size, int ps_array_completeness, HEVCDecoderConfigurationRecord *hvcc)
Definition: hevc.c:713
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:766
static int array[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:106
static void hvcc_init(HEVCDecoderConfigurationRecord *hvcc)
Definition: hevc.c:769
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
exp golomb vlc stuff
uint64_t constraint_indicator_flags
Definition: hevc.c:68
uint16_t min_spatial_segmentation_idc
Definition: hevc.c:49
static void hvcc_update_ptl(HEVCDecoderConfigurationRecord *hvcc, HVCCProfileTierLevel *ptl)
Definition: hevc.c:72