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