/* * Copyright (c) 2014 Tim Walker * * This file is part of FFmpeg. * * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "libavcodec/get_bits.h" #include "libavcodec/golomb.h" #include "libavcodec/hevc/hevc.h" #include "libavutil/intreadwrite.h" #include "libavutil/mem.h" #include "avc.h" #include "avio.h" #include "avio_internal.h" #include "hevc.h" #include "nal.h" #define MAX_SPATIAL_SEGMENTATION 4096 // max. value of u(12) field enum { VPS_INDEX, SPS_INDEX, PPS_INDEX, SEI_PREFIX_INDEX, SEI_SUFFIX_INDEX, NB_ARRAYS }; #define FLAG_ARRAY_COMPLETENESS (1 << 0) #define FLAG_IS_NALFF (1 << 1) #define FLAG_IS_LHVC (1 << 2) typedef struct HVCCNALUnit { uint8_t nuh_layer_id; uint8_t parameter_set_id; uint16_t nalUnitLength; const uint8_t *nalUnit; // VPS uint8_t vps_max_sub_layers_minus1; } HVCCNALUnit; typedef struct HVCCNALUnitArray { uint8_t array_completeness; uint8_t NAL_unit_type; uint16_t numNalus; HVCCNALUnit *nal; } HVCCNALUnitArray; typedef struct HEVCDecoderConfigurationRecord { uint8_t configurationVersion; uint8_t general_profile_space; uint8_t general_tier_flag; uint8_t general_profile_idc; uint32_t general_profile_compatibility_flags; uint64_t general_constraint_indicator_flags; uint8_t general_level_idc; uint16_t min_spatial_segmentation_idc; uint8_t parallelismType; uint8_t chromaFormat; uint8_t bitDepthLumaMinus8; uint8_t bitDepthChromaMinus8; uint16_t avgFrameRate; uint8_t constantFrameRate; uint8_t numTemporalLayers; uint8_t temporalIdNested; uint8_t lengthSizeMinusOne; uint8_t numOfArrays; HVCCNALUnitArray arrays[NB_ARRAYS]; uint8_t alpha_layer_nuh_id; } HEVCDecoderConfigurationRecord; typedef struct HVCCProfileTierLevel { uint8_t profile_space; uint8_t tier_flag; uint8_t profile_idc; uint32_t profile_compatibility_flags; uint64_t constraint_indicator_flags; uint8_t level_idc; } HVCCProfileTierLevel; static void hvcc_update_ptl(HEVCDecoderConfigurationRecord *hvcc, HVCCProfileTierLevel *ptl) { /* * The value of general_profile_space in all the parameter sets must be * identical. */ hvcc->general_profile_space = ptl->profile_space; /* * The level indication general_level_idc must indicate a level of * capability equal to or greater than the highest level indicated for the * highest tier in all the parameter sets. */ if (hvcc->general_tier_flag < ptl->tier_flag) hvcc->general_level_idc = ptl->level_idc; else hvcc->general_level_idc = FFMAX(hvcc->general_level_idc, ptl->level_idc); /* * The tier indication general_tier_flag must indicate a tier equal to or * greater than the highest tier indicated in all the parameter sets. */ hvcc->general_tier_flag = FFMAX(hvcc->general_tier_flag, ptl->tier_flag); /* * The profile indication general_profile_idc must indicate a profile to * which the stream associated with this configuration record conforms. * * If the sequence parameter sets are marked with different profiles, then * the stream may need examination to determine which profile, if any, the * entire stream conforms to. If the entire stream is not examined, or the * examination reveals that there is no profile to which the entire stream * conforms, then the entire stream must be split into two or more * sub-streams with separate configuration records in which these rules can * be met. * * Note: set the profile to the highest value for the sake of simplicity. */ hvcc->general_profile_idc = FFMAX(hvcc->general_profile_idc, ptl->profile_idc); /* * Each bit in general_profile_compatibility_flags may only be set if all * the parameter sets set that bit. */ hvcc->general_profile_compatibility_flags &= ptl->profile_compatibility_flags; /* * Each bit in general_constraint_indicator_flags may only be set if all * the parameter sets set that bit. */ hvcc->general_constraint_indicator_flags &= ptl->constraint_indicator_flags; } static void hvcc_parse_ptl(GetBitContext *gb, HEVCDecoderConfigurationRecord *hvcc, int profile_present_flag, unsigned int max_sub_layers_minus1) { unsigned int i; HVCCProfileTierLevel general_ptl; uint8_t sub_layer_profile_present_flag[HEVC_MAX_SUB_LAYERS]; uint8_t sub_layer_level_present_flag[HEVC_MAX_SUB_LAYERS]; if (profile_present_flag) { general_ptl.profile_space = get_bits(gb, 2); general_ptl.tier_flag = get_bits1(gb); general_ptl.profile_idc = get_bits(gb, 5); general_ptl.profile_compatibility_flags = get_bits_long(gb, 32); general_ptl.constraint_indicator_flags = get_bits64(gb, 48); general_ptl.level_idc = get_bits(gb, 8); hvcc_update_ptl(hvcc, &general_ptl); } else skip_bits(gb, 8); // general_level_idc for (i = 0; i < max_sub_layers_minus1; i++) { sub_layer_profile_present_flag[i] = get_bits1(gb); sub_layer_level_present_flag[i] = get_bits1(gb); } if (max_sub_layers_minus1 > 0) for (i = max_sub_layers_minus1; i < 8; i++) skip_bits(gb, 2); // reserved_zero_2bits[i] for (i = 0; i < max_sub_layers_minus1; i++) { if (sub_layer_profile_present_flag[i]) { /* * sub_layer_profile_space[i] u(2) * sub_layer_tier_flag[i] u(1) * sub_layer_profile_idc[i] u(5) * sub_layer_profile_compatibility_flag[i][0..31] u(32) * sub_layer_progressive_source_flag[i] u(1) * sub_layer_interlaced_source_flag[i] u(1) * sub_layer_non_packed_constraint_flag[i] u(1) * sub_layer_frame_only_constraint_flag[i] u(1) * sub_layer_reserved_zero_44bits[i] u(44) */ skip_bits_long(gb, 32); skip_bits_long(gb, 32); skip_bits (gb, 24); } if (sub_layer_level_present_flag[i]) skip_bits(gb, 8); } } static void skip_sub_layer_hrd_parameters(GetBitContext *gb, unsigned int cpb_cnt_minus1, uint8_t sub_pic_hrd_params_present_flag) { unsigned int i; for (i = 0; i <= cpb_cnt_minus1; i++) { get_ue_golomb_long(gb); // bit_rate_value_minus1 get_ue_golomb_long(gb); // cpb_size_value_minus1 if (sub_pic_hrd_params_present_flag) { get_ue_golomb_long(gb); // cpb_size_du_value_minus1 get_ue_golomb_long(gb); // bit_rate_du_value_minus1 } skip_bits1(gb); // cbr_flag } } static int skip_hrd_parameters(GetBitContext *gb, uint8_t cprms_present_flag, unsigned int max_sub_layers_minus1) { unsigned int i; uint8_t sub_pic_hrd_params_present_flag = 0; uint8_t nal_hrd_parameters_present_flag = 0; uint8_t vcl_hrd_parameters_present_flag = 0; if (cprms_present_flag) { nal_hrd_parameters_present_flag = get_bits1(gb); vcl_hrd_parameters_present_flag = get_bits1(gb); if (nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag) { sub_pic_hrd_params_present_flag = get_bits1(gb); if (sub_pic_hrd_params_present_flag) /* * tick_divisor_minus2 u(8) * du_cpb_removal_delay_increment_length_minus1 u(5) * sub_pic_cpb_params_in_pic_timing_sei_flag u(1) * dpb_output_delay_du_length_minus1 u(5) */ skip_bits(gb, 19); /* * bit_rate_scale u(4) * cpb_size_scale u(4) */ skip_bits(gb, 8); if (sub_pic_hrd_params_present_flag) skip_bits(gb, 4); // cpb_size_du_scale /* * initial_cpb_removal_delay_length_minus1 u(5) * au_cpb_removal_delay_length_minus1 u(5) * dpb_output_delay_length_minus1 u(5) */ skip_bits(gb, 15); } } for (i = 0; i <= max_sub_layers_minus1; i++) { unsigned int cpb_cnt_minus1 = 0; uint8_t low_delay_hrd_flag = 0; uint8_t fixed_pic_rate_within_cvs_flag = 0; uint8_t fixed_pic_rate_general_flag = get_bits1(gb); if (!fixed_pic_rate_general_flag) fixed_pic_rate_within_cvs_flag = get_bits1(gb); if (fixed_pic_rate_within_cvs_flag) get_ue_golomb_long(gb); // elemental_duration_in_tc_minus1 else low_delay_hrd_flag = get_bits1(gb); if (!low_delay_hrd_flag) { cpb_cnt_minus1 = get_ue_golomb_long(gb); if (cpb_cnt_minus1 > 31) return AVERROR_INVALIDDATA; } if (nal_hrd_parameters_present_flag) skip_sub_layer_hrd_parameters(gb, cpb_cnt_minus1, sub_pic_hrd_params_present_flag); if (vcl_hrd_parameters_present_flag) skip_sub_layer_hrd_parameters(gb, cpb_cnt_minus1, sub_pic_hrd_params_present_flag); } return 0; } static void skip_timing_info(GetBitContext *gb) { skip_bits_long(gb, 32); // num_units_in_tick skip_bits_long(gb, 32); // time_scale if (get_bits1(gb)) // poc_proportional_to_timing_flag get_ue_golomb_long(gb); // num_ticks_poc_diff_one_minus1 } static void hvcc_parse_vui(GetBitContext *gb, HEVCDecoderConfigurationRecord *hvcc, unsigned int max_sub_layers_minus1) { unsigned int min_spatial_segmentation_idc; if (get_bits1(gb)) // aspect_ratio_info_present_flag if (get_bits(gb, 8) == 255) // aspect_ratio_idc skip_bits_long(gb, 32); // sar_width u(16), sar_height u(16) if (get_bits1(gb)) // overscan_info_present_flag skip_bits1(gb); // overscan_appropriate_flag if (get_bits1(gb)) { // video_signal_type_present_flag skip_bits(gb, 4); // video_format u(3), video_full_range_flag u(1) if (get_bits1(gb)) // colour_description_present_flag /* * colour_primaries u(8) * transfer_characteristics u(8) * matrix_coeffs u(8) */ skip_bits(gb, 24); } if (get_bits1(gb)) { // chroma_loc_info_present_flag get_ue_golomb_long(gb); // chroma_sample_loc_type_top_field get_ue_golomb_long(gb); // chroma_sample_loc_type_bottom_field } /* * neutral_chroma_indication_flag u(1) * field_seq_flag u(1) * frame_field_info_present_flag u(1) */ skip_bits(gb, 3); if (get_bits1(gb)) { // default_display_window_flag get_ue_golomb_long(gb); // def_disp_win_left_offset get_ue_golomb_long(gb); // def_disp_win_right_offset get_ue_golomb_long(gb); // def_disp_win_top_offset get_ue_golomb_long(gb); // def_disp_win_bottom_offset } if (get_bits1(gb)) { // vui_timing_info_present_flag skip_timing_info(gb); if (get_bits1(gb)) // vui_hrd_parameters_present_flag skip_hrd_parameters(gb, 1, max_sub_layers_minus1); } if (get_bits1(gb)) { // bitstream_restriction_flag /* * tiles_fixed_structure_flag u(1) * motion_vectors_over_pic_boundaries_flag u(1) * restricted_ref_pic_lists_flag u(1) */ skip_bits(gb, 3); min_spatial_segmentation_idc = get_ue_golomb_long(gb); /* * unsigned int(12) min_spatial_segmentation_idc; * * The min_spatial_segmentation_idc indication must indicate a level of * spatial segmentation equal to or less than the lowest level of * spatial segmentation indicated in all the parameter sets. */ hvcc->min_spatial_segmentation_idc = FFMIN(hvcc->min_spatial_segmentation_idc, min_spatial_segmentation_idc); get_ue_golomb_long(gb); // max_bytes_per_pic_denom get_ue_golomb_long(gb); // max_bits_per_min_cu_denom get_ue_golomb_long(gb); // log2_max_mv_length_horizontal get_ue_golomb_long(gb); // log2_max_mv_length_vertical } } static void skip_sub_layer_ordering_info(GetBitContext *gb) { get_ue_golomb_long(gb); // max_dec_pic_buffering_minus1 get_ue_golomb_long(gb); // max_num_reorder_pics get_ue_golomb_long(gb); // max_latency_increase_plus1 } static int hvcc_parse_vps_extension(GetBitContext *gb, HVCCNALUnit *nal, HEVCDecoderConfigurationRecord *hvcc, uint8_t vps_max_layers_minus1, uint8_t vps_base_layer_internal_flag) { uint8_t num_scalability_types = 0; uint8_t max_layers_minus_1 = FFMIN(62, vps_max_layers_minus1); uint8_t splitting_flag, vps_nuh_layer_id_present_flag; uint8_t scalability_mask_flag[16] = { 0 }; uint8_t dimension_id_len[16] = { 0 }; uint8_t layer_id_in_nuh[64] = { 0 }; int i, j; if (vps_max_layers_minus1 > 0 && vps_base_layer_internal_flag) hvcc_parse_ptl(gb, hvcc, 0, nal->vps_max_sub_layers_minus1); splitting_flag = get_bits(gb, 1); for (i = 0; i < 16; i++) if (get_bits(gb, 1)) scalability_mask_flag[num_scalability_types++] = i; for (j = 0; j < (num_scalability_types - splitting_flag); j++) dimension_id_len[j] = get_bits(gb, 3) + 1; vps_nuh_layer_id_present_flag = get_bits(gb, 1); for (i = 1; i <= max_layers_minus_1; i++) { if (vps_nuh_layer_id_present_flag) layer_id_in_nuh[i] = get_bits(gb, 6); else layer_id_in_nuh[i] = i; if (!splitting_flag) { for (j = 0; j < num_scalability_types; j++) { int dimension_id = get_bits(gb, dimension_id_len[j]); if (dimension_id == 1 /* AUX_ALPHA */ && scalability_mask_flag[j] == 3 /* AuxId */) hvcc->alpha_layer_nuh_id = layer_id_in_nuh[i]; } } } if (splitting_flag) { uint8_t dim_bit_offset[17] = { 0 }; dim_bit_offset[0] = 0; for (j = 1; j < num_scalability_types; j++) dim_bit_offset[j] = dim_bit_offset[j-1] + dimension_id_len[j-1]; dim_bit_offset[num_scalability_types] = 6; if (num_scalability_types > 0 && dim_bit_offset[num_scalability_types - 1] >= 6) return -1; // invalid bitstream for (i = 1; i <= max_layers_minus_1; i++) { for (j = 0; j < num_scalability_types; j++) { int dimension_id = (layer_id_in_nuh[i] & ((1 << dim_bit_offset[j+1]) - 1)) >> dim_bit_offset[j]; if (dimension_id == 1 /* AUX_ALPHA */ && scalability_mask_flag[j] == 3 /* AuxId */) hvcc->alpha_layer_nuh_id = layer_id_in_nuh[i]; } } } return 0; } static int hvcc_parse_vps(GetBitContext *gb, HVCCNALUnit *nal, HEVCDecoderConfigurationRecord *hvcc) { uint8_t vps_base_layer_internal_flag, vps_max_layers_minus1; uint8_t vps_sub_layer_ordering_info_present_flag, vps_max_layer_id; int vps_num_layer_sets_minus1; int i; nal->parameter_set_id = get_bits(gb, 4); vps_base_layer_internal_flag = get_bits(gb, 1); skip_bits(gb, 1); // vps_base_layer_available_flag vps_max_layers_minus1 = get_bits(gb, 6); nal->vps_max_sub_layers_minus1 = get_bits(gb, 3); /* * numTemporalLayers greater than 1 indicates that the stream to which this * configuration record applies is temporally scalable and the contained * number of temporal layers (also referred to as temporal sub-layer or * sub-layer in ISO/IEC 23008-2) is equal to numTemporalLayers. Value 1 * indicates that the stream is not temporally scalable. Value 0 indicates * that it is unknown whether the stream is temporally scalable. */ hvcc->numTemporalLayers = FFMAX(hvcc->numTemporalLayers, nal->vps_max_sub_layers_minus1 + 1); /* * vps_temporal_id_nesting_flag u(1) * vps_reserved_0xffff_16bits u(16) */ skip_bits(gb, 17); hvcc_parse_ptl(gb, hvcc, 1, nal->vps_max_sub_layers_minus1); vps_sub_layer_ordering_info_present_flag = get_bits(gb, 1); for (i = (vps_sub_layer_ordering_info_present_flag ? 0 : nal->vps_max_sub_layers_minus1); i <= nal->vps_max_sub_layers_minus1; i++) { get_ue_golomb(gb); // vps_max_dec_pic_buffering_minus1 get_ue_golomb(gb); // vps_max_num_reorder_pics get_ue_golomb(gb); // vps_max_latency_increase_plus1 } vps_max_layer_id = get_bits(gb, 6); vps_num_layer_sets_minus1 = get_ue_golomb(gb); skip_bits_long(gb, (vps_max_layer_id + 1) * vps_num_layer_sets_minus1); // layer_id_included_flag[i][j] if (get_bits(gb, 1)) { // vps_timing_info_present_flag int vps_num_hrd_parameters; skip_bits_long(gb, 64); // vps_num_units_in_tick, vps_time_scale if (get_bits(gb, 1)) // vps_poc_proportional_to_timing_flag get_ue_golomb(gb); // vps_num_ticks_poc_diff_one_minus1 vps_num_hrd_parameters = get_ue_golomb(gb); // vps_num_hrd_parameters for (i = 0; i < vps_num_hrd_parameters; i++) { int cprms_present_flag; get_ue_golomb(gb); // hrd_layer_set_idx[i] if (i > 0) cprms_present_flag = get_bits(gb, 1); else cprms_present_flag = 1; skip_hrd_parameters(gb, cprms_present_flag, nal->vps_max_sub_layers_minus1); } } if (get_bits(gb, 1)) { // vps_extension_flag align_get_bits(gb); if (hvcc_parse_vps_extension(gb, nal, hvcc, vps_max_layers_minus1, vps_base_layer_internal_flag) < 0) return 0; } /* nothing useful for hvcC past this point */ return 0; } static void skip_scaling_list_data(GetBitContext *gb) { int i, j, k, num_coeffs; for (i = 0; i < 4; i++) for (j = 0; j < (i == 3 ? 2 : 6); j++) if (!get_bits1(gb)) // scaling_list_pred_mode_flag[i][j] get_ue_golomb_long(gb); // scaling_list_pred_matrix_id_delta[i][j] else { num_coeffs = FFMIN(64, 1 << (4 + (i << 1))); if (i > 1) get_se_golomb_long(gb); // scaling_list_dc_coef_minus8[i-2][j] for (k = 0; k < num_coeffs; k++) get_se_golomb_long(gb); // scaling_list_delta_coef } } static int parse_rps(GetBitContext *gb, unsigned int rps_idx, unsigned int num_rps, unsigned int num_delta_pocs[HEVC_MAX_SHORT_TERM_REF_PIC_SETS]) { unsigned int i; if (rps_idx && get_bits1(gb)) { // inter_ref_pic_set_prediction_flag /* this should only happen for slice headers, and this isn't one */ if (rps_idx >= num_rps) return AVERROR_INVALIDDATA; skip_bits1 (gb); // delta_rps_sign get_ue_golomb_long(gb); // abs_delta_rps_minus1 num_delta_pocs[rps_idx] = 0; /* * From libavcodec/hevc_ps.c: * * if (is_slice_header) { * //foo * } else * rps_ridx = &sps->st_rps[rps - sps->st_rps - 1]; * * where: * rps: &sps->st_rps[rps_idx] * sps->st_rps: &sps->st_rps[0] * is_slice_header: rps_idx == num_rps * * thus: * if (num_rps != rps_idx) * rps_ridx = &sps->st_rps[rps_idx - 1]; * * NumDeltaPocs[RefRpsIdx]: num_delta_pocs[rps_idx - 1] */ for (i = 0; i <= num_delta_pocs[rps_idx - 1]; i++) { uint8_t use_delta_flag = 0; uint8_t used_by_curr_pic_flag = get_bits1(gb); if (!used_by_curr_pic_flag) use_delta_flag = get_bits1(gb); if (used_by_curr_pic_flag || use_delta_flag) num_delta_pocs[rps_idx]++; } } else { unsigned int num_negative_pics = get_ue_golomb_long(gb); unsigned int num_positive_pics = get_ue_golomb_long(gb); if ((num_positive_pics + (uint64_t)num_negative_pics) * 2 > get_bits_left(gb)) return AVERROR_INVALIDDATA; num_delta_pocs[rps_idx] = num_negative_pics + num_positive_pics; for (i = 0; i < num_negative_pics; i++) { get_ue_golomb_long(gb); // delta_poc_s0_minus1[rps_idx] skip_bits1 (gb); // used_by_curr_pic_s0_flag[rps_idx] } for (i = 0; i < num_positive_pics; i++) { get_ue_golomb_long(gb); // delta_poc_s1_minus1[rps_idx] skip_bits1 (gb); // used_by_curr_pic_s1_flag[rps_idx] } } return 0; } static int hvcc_parse_sps(GetBitContext *gb, HVCCNALUnit *nal, HEVCDecoderConfigurationRecord *hvcc) { unsigned int i, sps_max_sub_layers_minus1, log2_max_pic_order_cnt_lsb_minus4; unsigned int num_short_term_ref_pic_sets, num_delta_pocs[HEVC_MAX_SHORT_TERM_REF_PIC_SETS]; unsigned int sps_ext_or_max_sub_layers_minus1, multi_layer_ext_sps_flag; unsigned int sps_video_parameter_set_id = get_bits(gb, 4); if (nal->nuh_layer_id == 0) { sps_ext_or_max_sub_layers_minus1 = 0; sps_max_sub_layers_minus1 = get_bits(gb, 3); } else { sps_ext_or_max_sub_layers_minus1 = get_bits(gb, 3); if (sps_ext_or_max_sub_layers_minus1 == 7) { const HVCCNALUnitArray *array = &hvcc->arrays[VPS_INDEX]; const HVCCNALUnit *vps = NULL; for (i = 0; i < array->numNalus; i++) if (sps_video_parameter_set_id == array->nal[i].parameter_set_id) { vps = &array->nal[i]; break; } if (!vps) return AVERROR_INVALIDDATA; sps_max_sub_layers_minus1 = vps->vps_max_sub_layers_minus1; } else sps_max_sub_layers_minus1 = sps_ext_or_max_sub_layers_minus1; } multi_layer_ext_sps_flag = nal->nuh_layer_id && sps_ext_or_max_sub_layers_minus1 == 7; /* * numTemporalLayers greater than 1 indicates that the stream to which this * configuration record applies is temporally scalable and the contained * number of temporal layers (also referred to as temporal sub-layer or * sub-layer in ISO/IEC 23008-2) is equal to numTemporalLayers. Value 1 * indicates that the stream is not temporally scalable. Value 0 indicates * that it is unknown whether the stream is temporally scalable. */ hvcc->numTemporalLayers = FFMAX(hvcc->numTemporalLayers, sps_max_sub_layers_minus1 + 1); if (!multi_layer_ext_sps_flag) { hvcc->temporalIdNested = get_bits1(gb); hvcc_parse_ptl(gb, hvcc, 1, sps_max_sub_layers_minus1); } nal->parameter_set_id = get_ue_golomb_long(gb); if (multi_layer_ext_sps_flag) { if (get_bits1(gb)) // update_rep_format_flag skip_bits(gb, 8); // sps_rep_format_idx } else { hvcc->chromaFormat = get_ue_golomb_long(gb); if (hvcc->chromaFormat == 3) skip_bits1(gb); // separate_colour_plane_flag get_ue_golomb_long(gb); // pic_width_in_luma_samples get_ue_golomb_long(gb); // pic_height_in_luma_samples if (get_bits1(gb)) { // conformance_window_flag get_ue_golomb_long(gb); // conf_win_left_offset get_ue_golomb_long(gb); // conf_win_right_offset get_ue_golomb_long(gb); // conf_win_top_offset get_ue_golomb_long(gb); // conf_win_bottom_offset } hvcc->bitDepthLumaMinus8 = get_ue_golomb_long(gb); hvcc->bitDepthChromaMinus8 = get_ue_golomb_long(gb); } log2_max_pic_order_cnt_lsb_minus4 = get_ue_golomb_long(gb); if (!multi_layer_ext_sps_flag) { /* sps_sub_layer_ordering_info_present_flag */ i = get_bits1(gb) ? 0 : sps_max_sub_layers_minus1; for (; i <= sps_max_sub_layers_minus1; i++) skip_sub_layer_ordering_info(gb); } get_ue_golomb_long(gb); // log2_min_luma_coding_block_size_minus3 get_ue_golomb_long(gb); // log2_diff_max_min_luma_coding_block_size get_ue_golomb_long(gb); // log2_min_transform_block_size_minus2 get_ue_golomb_long(gb); // log2_diff_max_min_transform_block_size get_ue_golomb_long(gb); // max_transform_hierarchy_depth_inter get_ue_golomb_long(gb); // max_transform_hierarchy_depth_intra if (get_bits1(gb)) { // scaling_list_enabled_flag int sps_infer_scaling_list_flag = 0; if (multi_layer_ext_sps_flag) sps_infer_scaling_list_flag = get_bits1(gb); if (sps_infer_scaling_list_flag) skip_bits(gb, 6); // sps_scaling_list_ref_layer_id else if (get_bits1(gb)) // sps_scaling_list_data_present_flag skip_scaling_list_data(gb); } skip_bits1(gb); // amp_enabled_flag skip_bits1(gb); // sample_adaptive_offset_enabled_flag if (get_bits1(gb)) { // pcm_enabled_flag skip_bits (gb, 4); // pcm_sample_bit_depth_luma_minus1 skip_bits (gb, 4); // pcm_sample_bit_depth_chroma_minus1 get_ue_golomb_long(gb); // log2_min_pcm_luma_coding_block_size_minus3 get_ue_golomb_long(gb); // log2_diff_max_min_pcm_luma_coding_block_size skip_bits1 (gb); // pcm_loop_filter_disabled_flag } num_short_term_ref_pic_sets = get_ue_golomb_long(gb); if (num_short_term_ref_pic_sets > HEVC_MAX_SHORT_TERM_REF_PIC_SETS) return AVERROR_INVALIDDATA; for (i = 0; i < num_short_term_ref_pic_sets; i++) { int ret = parse_rps(gb, i, num_short_term_ref_pic_sets, num_delta_pocs); if (ret < 0) return ret; } if (get_bits1(gb)) { // long_term_ref_pics_present_flag unsigned num_long_term_ref_pics_sps = get_ue_golomb_long(gb); if (num_long_term_ref_pics_sps > 31U) return AVERROR_INVALIDDATA; for (i = 0; i < num_long_term_ref_pics_sps; i++) { // num_long_term_ref_pics_sps int len = FFMIN(log2_max_pic_order_cnt_lsb_minus4 + 4, 16); skip_bits (gb, len); // lt_ref_pic_poc_lsb_sps[i] skip_bits1(gb); // used_by_curr_pic_lt_sps_flag[i] } } skip_bits1(gb); // sps_temporal_mvp_enabled_flag skip_bits1(gb); // strong_intra_smoothing_enabled_flag if (get_bits1(gb)) // vui_parameters_present_flag hvcc_parse_vui(gb, hvcc, sps_max_sub_layers_minus1); /* nothing useful for hvcC past this point */ return 0; } static int hvcc_parse_pps(GetBitContext *gb, HVCCNALUnit *nal, HEVCDecoderConfigurationRecord *hvcc) { uint8_t tiles_enabled_flag, entropy_coding_sync_enabled_flag; nal->parameter_set_id = get_ue_golomb_long(gb); // pps_pic_parameter_set_id get_ue_golomb_long(gb); // pps_seq_parameter_set_id /* * dependent_slice_segments_enabled_flag u(1) * output_flag_present_flag u(1) * num_extra_slice_header_bits u(3) * sign_data_hiding_enabled_flag u(1) * cabac_init_present_flag u(1) */ skip_bits(gb, 7); get_ue_golomb_long(gb); // num_ref_idx_l0_default_active_minus1 get_ue_golomb_long(gb); // num_ref_idx_l1_default_active_minus1 get_se_golomb_long(gb); // init_qp_minus26 /* * constrained_intra_pred_flag u(1) * transform_skip_enabled_flag u(1) */ skip_bits(gb, 2); if (get_bits1(gb)) // cu_qp_delta_enabled_flag get_ue_golomb_long(gb); // diff_cu_qp_delta_depth get_se_golomb_long(gb); // pps_cb_qp_offset get_se_golomb_long(gb); // pps_cr_qp_offset /* * pps_slice_chroma_qp_offsets_present_flag u(1) * weighted_pred_flag u(1) * weighted_bipred_flag u(1) * transquant_bypass_enabled_flag u(1) */ skip_bits(gb, 4); tiles_enabled_flag = get_bits1(gb); entropy_coding_sync_enabled_flag = get_bits1(gb); if (entropy_coding_sync_enabled_flag && tiles_enabled_flag) hvcc->parallelismType = 0; // mixed-type parallel decoding else if (entropy_coding_sync_enabled_flag) hvcc->parallelismType = 3; // wavefront-based parallel decoding else if (tiles_enabled_flag) hvcc->parallelismType = 2; // tile-based parallel decoding else hvcc->parallelismType = 1; // slice-based parallel decoding /* nothing useful for hvcC past this point */ return 0; } static void nal_unit_parse_header(GetBitContext *gb, uint8_t *nal_type, uint8_t *nuh_layer_id) { skip_bits1(gb); // forbidden_zero_bit *nal_type = get_bits(gb, 6); *nuh_layer_id = get_bits(gb, 6); /* * nuh_temporal_id_plus1 u(3) */ skip_bits(gb, 3); } static int hvcc_array_add_nal_unit(const uint8_t *nal_buf, uint32_t nal_size, HVCCNALUnitArray *array) { HVCCNALUnit *nal; int ret; uint16_t numNalus = array->numNalus; ret = av_reallocp_array(&array->nal, numNalus + 1, sizeof(*array->nal)); if (ret < 0) return ret; nal = &array->nal[numNalus]; nal->nalUnit = nal_buf; nal->nalUnitLength = nal_size; array->numNalus++; return 0; } static int hvcc_add_nal_unit(const uint8_t *nal_buf, uint32_t nal_size, HEVCDecoderConfigurationRecord *hvcc, int flags, unsigned array_idx) { int ret = 0; int is_nalff = !!(flags & FLAG_IS_NALFF); int is_lhvc = !!(flags & FLAG_IS_LHVC); int ps_array_completeness = !!(flags & FLAG_ARRAY_COMPLETENESS); HVCCNALUnitArray *const array = &hvcc->arrays[array_idx]; HVCCNALUnit *nal; GetBitContext gbc; uint8_t nal_type, nuh_layer_id; uint8_t *rbsp_buf; uint32_t rbsp_size; rbsp_buf = ff_nal_unit_extract_rbsp(nal_buf, nal_size, &rbsp_size, 2); if (!rbsp_buf) { ret = AVERROR(ENOMEM); goto end; } ret = init_get_bits8(&gbc, rbsp_buf, rbsp_size); if (ret < 0) goto end; nal_unit_parse_header(&gbc, &nal_type, &nuh_layer_id); if (!is_lhvc && nuh_layer_id > 0 && nuh_layer_id != hvcc->alpha_layer_nuh_id) goto end; /* * Note: only 'declarative' SEI messages are allowed in * hvcC. Perhaps the SEI playload type should be checked * and non-declarative SEI messages discarded? */ ret = hvcc_array_add_nal_unit(nal_buf, nal_size, array); if (ret < 0) goto end; if (array->numNalus == 1) { hvcc->numOfArrays++; array->NAL_unit_type = nal_type; /* * When the sample entry name is ‘hvc1’, the default and mandatory value of * array_completeness is 1 for arrays of all types of parameter sets, and 0 * for all other arrays. When the sample entry name is ‘hev1’, the default * value of array_completeness is 0 for all arrays. */ if (nal_type == HEVC_NAL_VPS || nal_type == HEVC_NAL_SPS || nal_type == HEVC_NAL_PPS) array->array_completeness = ps_array_completeness; } nal = &array->nal[array->numNalus-1]; nal->nuh_layer_id = nuh_layer_id; /* Don't parse parameter sets. We already have the needed information*/ if (is_nalff) goto end; if (nal_type == HEVC_NAL_VPS) ret = hvcc_parse_vps(&gbc, nal, hvcc); else if (nal_type == HEVC_NAL_SPS) ret = hvcc_parse_sps(&gbc, nal, hvcc); else if (nal_type == HEVC_NAL_PPS) ret = hvcc_parse_pps(&gbc, nal, hvcc); if (ret < 0) goto end; end: av_free(rbsp_buf); return ret; } static void hvcc_init(HEVCDecoderConfigurationRecord *hvcc) { memset(hvcc, 0, sizeof(HEVCDecoderConfigurationRecord)); hvcc->configurationVersion = 1; hvcc->lengthSizeMinusOne = 3; // 4 bytes /* * The following fields have all their valid bits set by default, * the ProfileTierLevel parsing code will unset them when needed. */ hvcc->general_profile_compatibility_flags = 0xffffffff; hvcc->general_constraint_indicator_flags = 0xffffffffffff; /* * Initialize this field with an invalid value which can be used to detect * whether we didn't see any VUI (in which case it should be reset to zero). */ hvcc->min_spatial_segmentation_idc = MAX_SPATIAL_SEGMENTATION + 1; } static void hvcc_close(HEVCDecoderConfigurationRecord *hvcc) { for (unsigned i = 0; i < FF_ARRAY_ELEMS(hvcc->arrays); i++) { HVCCNALUnitArray *const array = &hvcc->arrays[i]; array->numNalus = 0; av_freep(&array->nal); } } static int hvcc_write(void *logctx, AVIOContext *pb, HEVCDecoderConfigurationRecord *hvcc, int flags) { uint16_t numNalus[NB_ARRAYS] = { 0 }; int is_lhvc = !!(flags & FLAG_IS_LHVC); int numOfArrays = 0; /* * We only support writing HEVCDecoderConfigurationRecord version 1. */ hvcc->configurationVersion = 1; /* * If min_spatial_segmentation_idc is invalid, reset to 0 (unspecified). */ if (hvcc->min_spatial_segmentation_idc > MAX_SPATIAL_SEGMENTATION) hvcc->min_spatial_segmentation_idc = 0; /* * parallelismType indicates the type of parallelism that is used to meet * the restrictions imposed by min_spatial_segmentation_idc when the value * of min_spatial_segmentation_idc is greater than 0. */ if (!hvcc->min_spatial_segmentation_idc) hvcc->parallelismType = 0; /* * It's unclear how to properly compute these fields, so * let's always set them to values meaning 'unspecified'. */ hvcc->avgFrameRate = 0; /* * lhvC doesn't store this field. It instead reserves the bits, setting them * to '11'b. */ hvcc->constantFrameRate = is_lhvc * 0x3; /* * Skip all NALUs with nuh_layer_id == 0 if writing lhvC. We do it here and * not before parsing them as some parameter sets with nuh_layer_id > 0 * may reference base layer parameters sets. */ for (unsigned i = 0; i < FF_ARRAY_ELEMS(hvcc->arrays); i++) { const HVCCNALUnitArray *const array = &hvcc->arrays[i]; if (array->numNalus == 0) continue; for (unsigned j = 0; j < array->numNalus; j++) numNalus[i] += !is_lhvc || (array->nal[j].nuh_layer_id != 0); numOfArrays += (numNalus[i] > 0); } av_log(logctx, AV_LOG_TRACE, "%s\n", is_lhvc ? "lhvC" : "hvcC"); av_log(logctx, AV_LOG_TRACE, "configurationVersion: %"PRIu8"\n", hvcc->configurationVersion); if (!is_lhvc) { av_log(logctx, AV_LOG_TRACE, "general_profile_space: %"PRIu8"\n", hvcc->general_profile_space); av_log(logctx, AV_LOG_TRACE, "general_tier_flag: %"PRIu8"\n", hvcc->general_tier_flag); av_log(logctx, AV_LOG_TRACE, "general_profile_idc: %"PRIu8"\n", hvcc->general_profile_idc); av_log(logctx, AV_LOG_TRACE, "general_profile_compatibility_flags: 0x%08"PRIx32"\n", hvcc->general_profile_compatibility_flags); av_log(logctx, AV_LOG_TRACE, "general_constraint_indicator_flags: 0x%012"PRIx64"\n", hvcc->general_constraint_indicator_flags); av_log(logctx, AV_LOG_TRACE, "general_level_idc: %"PRIu8"\n", hvcc->general_level_idc); } av_log(logctx, AV_LOG_TRACE, "min_spatial_segmentation_idc: %"PRIu16"\n", hvcc->min_spatial_segmentation_idc); av_log(logctx, AV_LOG_TRACE, "parallelismType: %"PRIu8"\n", hvcc->parallelismType); if (!is_lhvc) { av_log(logctx, AV_LOG_TRACE, "chromaFormat: %"PRIu8"\n", hvcc->chromaFormat); av_log(logctx, AV_LOG_TRACE, "bitDepthLumaMinus8: %"PRIu8"\n", hvcc->bitDepthLumaMinus8); av_log(logctx, AV_LOG_TRACE, "bitDepthChromaMinus8: %"PRIu8"\n", hvcc->bitDepthChromaMinus8); av_log(logctx, AV_LOG_TRACE, "avgFrameRate: %"PRIu16"\n", hvcc->avgFrameRate); av_log(logctx, AV_LOG_TRACE, "constantFrameRate: %"PRIu8"\n", hvcc->constantFrameRate); } av_log(logctx, AV_LOG_TRACE, "numTemporalLayers: %"PRIu8"\n", hvcc->numTemporalLayers); av_log(logctx, AV_LOG_TRACE, "temporalIdNested: %"PRIu8"\n", hvcc->temporalIdNested); av_log(logctx, AV_LOG_TRACE, "lengthSizeMinusOne: %"PRIu8"\n", hvcc->lengthSizeMinusOne); av_log(logctx, AV_LOG_TRACE, "numOfArrays: %"PRIu8"\n", numOfArrays); for (unsigned i = 0, j = 0; i < FF_ARRAY_ELEMS(hvcc->arrays); i++) { const HVCCNALUnitArray *const array = &hvcc->arrays[i]; if (numNalus[i] == 0) continue; av_log(logctx, AV_LOG_TRACE, "array_completeness[%u]: %"PRIu8"\n", j, array->array_completeness); av_log(logctx, AV_LOG_TRACE, "NAL_unit_type[%u]: %"PRIu8"\n", j, array->NAL_unit_type); av_log(logctx, AV_LOG_TRACE, "numNalus[%u]: %"PRIu16"\n", j, numNalus[i]); for (unsigned k = 0; k < array->numNalus; k++) { if (is_lhvc && array->nal[k].nuh_layer_id == 0) continue; av_log(logctx, AV_LOG_TRACE, "nuh_layer_id[%u][%u]: %"PRIu8"\n", j, k, array->nal[k].nuh_layer_id); av_log(logctx, AV_LOG_TRACE, "nalUnitLength[%u][%u]: %"PRIu16"\n", j, k, array->nal[k].nalUnitLength); } j++; } /* * We need at least one of each: VPS, SPS and PPS. */ if ((flags & FLAG_ARRAY_COMPLETENESS) && (!numNalus[VPS_INDEX] || numNalus[VPS_INDEX] > HEVC_MAX_VPS_COUNT) && !is_lhvc) return AVERROR_INVALIDDATA; if ((flags & FLAG_ARRAY_COMPLETENESS) && (!numNalus[SPS_INDEX] || numNalus[SPS_INDEX] > HEVC_MAX_SPS_COUNT || !numNalus[PPS_INDEX] || numNalus[PPS_INDEX] > HEVC_MAX_PPS_COUNT)) return AVERROR_INVALIDDATA; /* unsigned int(8) configurationVersion = 1; */ avio_w8(pb, hvcc->configurationVersion); if (!is_lhvc) { /* * unsigned int(2) general_profile_space; * unsigned int(1) general_tier_flag; * unsigned int(5) general_profile_idc; */ avio_w8(pb, hvcc->general_profile_space << 6 | hvcc->general_tier_flag << 5 | hvcc->general_profile_idc); /* unsigned int(32) general_profile_compatibility_flags; */ avio_wb32(pb, hvcc->general_profile_compatibility_flags); /* unsigned int(48) general_constraint_indicator_flags; */ avio_wb32(pb, hvcc->general_constraint_indicator_flags >> 16); avio_wb16(pb, hvcc->general_constraint_indicator_flags); /* unsigned int(8) general_level_idc; */ avio_w8(pb, hvcc->general_level_idc); } /* * bit(4) reserved = '1111'b; * unsigned int(12) min_spatial_segmentation_idc; */ avio_wb16(pb, hvcc->min_spatial_segmentation_idc | 0xf000); /* * bit(6) reserved = '111111'b; * unsigned int(2) parallelismType; */ avio_w8(pb, hvcc->parallelismType | 0xfc); if (!is_lhvc) { /* * bit(6) reserved = '111111'b; * unsigned int(2) chromaFormat; */ avio_w8(pb, hvcc->chromaFormat | 0xfc); /* * bit(5) reserved = '11111'b; * unsigned int(3) bitDepthLumaMinus8; */ avio_w8(pb, hvcc->bitDepthLumaMinus8 | 0xf8); /* * bit(5) reserved = '11111'b; * unsigned int(3) bitDepthChromaMinus8; */ avio_w8(pb, hvcc->bitDepthChromaMinus8 | 0xf8); /* bit(16) avgFrameRate; */ avio_wb16(pb, hvcc->avgFrameRate); } /* * if (!is_lhvc) * bit(2) constantFrameRate; * else * bit(2) reserved = '11'b; * bit(3) numTemporalLayers; * bit(1) temporalIdNested; * unsigned int(2) lengthSizeMinusOne; */ avio_w8(pb, hvcc->constantFrameRate << 6 | hvcc->numTemporalLayers << 3 | hvcc->temporalIdNested << 2 | hvcc->lengthSizeMinusOne); /* unsigned int(8) numOfArrays; */ avio_w8(pb, numOfArrays); for (unsigned i = 0; i < FF_ARRAY_ELEMS(hvcc->arrays); i++) { const HVCCNALUnitArray *const array = &hvcc->arrays[i]; if (!numNalus[i]) continue; /* * bit(1) array_completeness; * unsigned int(1) reserved = 0; * unsigned int(6) NAL_unit_type; */ avio_w8(pb, array->array_completeness << 7 | array->NAL_unit_type & 0x3f); /* unsigned int(16) numNalus; */ avio_wb16(pb, numNalus[i]); for (unsigned j = 0; j < array->numNalus; j++) { HVCCNALUnit *nal = &array->nal[j]; if (is_lhvc && nal->nuh_layer_id == 0) continue; /* unsigned int(16) nalUnitLength; */ avio_wb16(pb, nal->nalUnitLength); /* bit(8*nalUnitLength) nalUnit; */ avio_write(pb, nal->nalUnit, nal->nalUnitLength); } } return 0; } int ff_hevc_annexb2mp4(AVIOContext *pb, const uint8_t *buf_in, int size, int filter_ps, int *ps_count) { int num_ps = 0, ret = 0; uint8_t *buf, *end, *start = NULL; if (!filter_ps) { ret = ff_nal_parse_units(pb, buf_in, size); goto end; } ret = ff_nal_parse_units_buf(buf_in, &start, &size); if (ret < 0) goto end; ret = 0; buf = start; end = start + size; while (end - buf > 4) { uint32_t len = FFMIN(AV_RB32(buf), end - buf - 4); uint8_t type = (buf[4] >> 1) & 0x3f; buf += 4; switch (type) { case HEVC_NAL_VPS: case HEVC_NAL_SPS: case HEVC_NAL_PPS: num_ps++; break; default: ret += 4 + len; avio_wb32(pb, len); avio_write(pb, buf, len); break; } buf += len; } end: av_free(start); if (ps_count) *ps_count = num_ps; return ret; } int ff_hevc_annexb2mp4_buf(const uint8_t *buf_in, uint8_t **buf_out, int *size, int filter_ps, int *ps_count) { AVIOContext *pb; int ret; ret = avio_open_dyn_buf(&pb); if (ret < 0) return ret; ret = ff_hevc_annexb2mp4(pb, buf_in, *size, filter_ps, ps_count); if (ret < 0) { ffio_free_dyn_buf(&pb); return ret; } *size = avio_close_dyn_buf(pb, buf_out); return 0; } static int hvcc_parse_nal_unit(const uint8_t *buf, uint32_t len, int type, HEVCDecoderConfigurationRecord *hvcc, int flags) { for (unsigned i = 0; i < FF_ARRAY_ELEMS(hvcc->arrays); i++) { static const uint8_t array_idx_to_type[] = { HEVC_NAL_VPS, HEVC_NAL_SPS, HEVC_NAL_PPS, HEVC_NAL_SEI_PREFIX, HEVC_NAL_SEI_SUFFIX }; if (type == array_idx_to_type[i]) { int ret = hvcc_add_nal_unit(buf, len, hvcc, flags, i); if (ret < 0) return ret; break; } } return 0; } static int write_configuration_record(void *logctx, AVIOContext *pb, const uint8_t *data, int size, int flags) { HEVCDecoderConfigurationRecord hvcc; uint8_t *buf, *end, *start = NULL; int ret; if (size < 6) { /* We can't write a valid hvcC from the provided data */ return AVERROR_INVALIDDATA; } else if (*data == 1) { /* Data is already hvcC-formatted. Parse the arrays to skip any NALU with nuh_layer_id > 0 */ GetBitContext gbc; int num_arrays; if (size < 23) return AVERROR_INVALIDDATA; ret = init_get_bits8(&gbc, data, size); if (ret < 0) return ret; hvcc_init(&hvcc); skip_bits(&gbc, 8); // hvcc.configurationVersion hvcc.general_profile_space = get_bits(&gbc, 2); hvcc.general_tier_flag = get_bits1(&gbc); hvcc.general_profile_idc = get_bits(&gbc, 5); hvcc.general_profile_compatibility_flags = get_bits_long(&gbc, 32); hvcc.general_constraint_indicator_flags = get_bits64(&gbc, 48); hvcc.general_level_idc = get_bits(&gbc, 8); skip_bits(&gbc, 4); // reserved hvcc.min_spatial_segmentation_idc = get_bits(&gbc, 12); skip_bits(&gbc, 6); // reserved hvcc.parallelismType = get_bits(&gbc, 2); skip_bits(&gbc, 6); // reserved hvcc.chromaFormat = get_bits(&gbc, 2); skip_bits(&gbc, 5); // reserved hvcc.bitDepthLumaMinus8 = get_bits(&gbc, 3); skip_bits(&gbc, 5); // reserved hvcc.bitDepthChromaMinus8 = get_bits(&gbc, 3); hvcc.avgFrameRate = get_bits(&gbc, 16); hvcc.constantFrameRate = get_bits(&gbc, 2); hvcc.numTemporalLayers = get_bits(&gbc, 3); hvcc.temporalIdNested = get_bits1(&gbc); hvcc.lengthSizeMinusOne = get_bits(&gbc, 2); flags |= FLAG_IS_NALFF; num_arrays = get_bits(&gbc, 8); for (int i = 0; i < num_arrays; i++) { int type, num_nalus; skip_bits(&gbc, 2); type = get_bits(&gbc, 6); num_nalus = get_bits(&gbc, 16); for (int j = 0; j < num_nalus; j++) { int len = get_bits(&gbc, 16); if (len > (get_bits_left(&gbc) / 8)) goto end; ret = hvcc_parse_nal_unit(data + get_bits_count(&gbc) / 8, len, type, &hvcc, flags); if (ret < 0) goto end; skip_bits_long(&gbc, len * 8); } } ret = hvcc_write(logctx, pb, &hvcc, flags); goto end; } else if (!(AV_RB24(data) == 1 || AV_RB32(data) == 1)) { /* Not a valid Annex B start code prefix */ return AVERROR_INVALIDDATA; } ret = ff_nal_parse_units_buf(data, &start, &size); if (ret < 0) return ret; hvcc_init(&hvcc); buf = start; end = start + size; while (end - buf > 4) { uint32_t len = FFMIN(AV_RB32(buf), end - buf - 4); uint8_t type = (buf[4] >> 1) & 0x3f; buf += 4; ret = hvcc_parse_nal_unit(buf, len, type, &hvcc, flags); if (ret < 0) goto end; buf += len; } ret = hvcc_write(logctx, pb, &hvcc, flags); end: hvcc_close(&hvcc); av_free(start); return ret; } int ff_isom_write_hvcc(AVIOContext *pb, const uint8_t *data, int size, int ps_array_completeness, void *logctx) { return write_configuration_record(logctx, pb, data, size, !!ps_array_completeness * FLAG_ARRAY_COMPLETENESS); } int ff_isom_write_lhvc(AVIOContext *pb, const uint8_t *data, int size, int ps_array_completeness, void *logctx) { return write_configuration_record(logctx, pb, data, size, (!!ps_array_completeness * FLAG_ARRAY_COMPLETENESS) | FLAG_IS_LHVC); }