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