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} 1141