Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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