/*
 *
 * Copyright 2015 Rockchip Electronics Co. LTD
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 * @file        h265d_parser.h
 * @brief
 * @author      csy(csy@rock-chips.com)

 * @version     1.0.0
 * @history
 *   2015.7.15 : Create
 */


#ifndef __H265D_PARSER_H__
#define __H265D_PARSER_H__

#include <limits.h>
#include <string.h>

#include "mpp_debug.h"
#include "mpp_bitread.h"
#include "mpp_buf_slot.h"
#include "mpp_mem_pool.h"

#include "hal_dec_task.h"
#include "h265d_codec.h"
#include "h265_syntax.h"
#include "h2645d_sei.h"

extern RK_U32 h265d_debug;

#define H265D_DBG_FUNCTION          (0x00000001)
#define H265D_DBG_VPS               (0x00000002)
#define H265D_DBG_SPS               (0x00000004)
#define H265D_DBG_PPS               (0x00000008)
#define H265D_DBG_SLICE_HDR         (0x00000010)
#define H265D_DBG_SEI               (0x00000020)
#define H265D_DBG_GLOBAL            (0x00000040)
#define H265D_DBG_REF               (0x00000080)
#define H265D_DBG_TIME              (0x00000100)


#define h265d_dbg(flag, fmt, ...) _mpp_dbg(h265d_debug, flag, fmt, ## __VA_ARGS__)

#define MAX_FRAME_SIZE 2048000

typedef struct ShortTermRPS {
    RK_U32 num_negative_pics;
    RK_S32 num_delta_pocs;
    RK_S32 rps_idx_num_delta_pocs;
    RK_S32 delta_poc[32];
    RK_U8  used[32];
} ShortTermRPS;

typedef struct LongTermRPS {
    RK_S32  poc[32];
    RK_U8   used[32];
    RK_U8   nb_refs;
} LongTermRPS;

typedef struct RefPicList {
    struct HEVCFrame *ref[MAX_REFS];
    RK_S32 list[MAX_REFS];
    RK_S32 isLongTerm[MAX_REFS];
    RK_S32 nb_refs;
} RefPicList;

typedef struct RefPicListTab {
    RefPicList refPicList[2];
} RefPicListTab;

typedef struct HEVCWindow {
    RK_S32 left_offset;
    RK_S32 right_offset;
    RK_S32 top_offset;
    RK_S32 bottom_offset;
} HEVCWindow;

typedef struct VUI {
    MppRational_t sar;

    RK_S32 overscan_info_present_flag;
    RK_S32 overscan_appropriate_flag;

    RK_S32 video_signal_type_present_flag;
    RK_S32 video_format;
    RK_S32 video_full_range_flag;
    RK_S32 colour_description_present_flag;
    RK_U8  colour_primaries;
    RK_U8  transfer_characteristic;
    RK_U8  matrix_coeffs;

    RK_S32 chroma_loc_info_present_flag;
    RK_S32 chroma_sample_loc_type_top_field;
    RK_S32 chroma_sample_loc_type_bottom_field;
    RK_S32 neutra_chroma_indication_flag;

    RK_S32 field_seq_flag;
    RK_S32 frame_field_info_present_flag;

    RK_S32 default_display_window_flag;
    HEVCWindow def_disp_win;

    RK_S32 vui_timing_info_present_flag;
    RK_U32 vui_num_units_in_tick;
    RK_U32 vui_time_scale;
    RK_S32 vui_poc_proportional_to_timing_flag;
    RK_S32 vui_num_ticks_poc_diff_one_minus1;
    RK_S32 vui_hrd_parameters_present_flag;

    RK_S32 bitstream_restriction_flag;
    RK_S32 tiles_fixed_structure_flag;
    RK_S32 motion_vectors_over_pic_boundaries_flag;
    RK_S32 restricted_ref_pic_lists_flag;
    RK_S32 min_spatial_segmentation_idc;
    RK_S32 max_bytes_per_pic_denom;
    RK_S32 max_bits_per_min_cu_denom;
    RK_S32 log2_max_mv_length_horizontal;
    RK_S32 log2_max_mv_length_vertical;
} VUI;

/* ProfileTierLevel */
typedef struct PTLCommon {
    RK_U8 profile_space;
    RK_U8 tier_flag;
    RK_U8 profile_idc;
    RK_U8 profile_compatibility_flag[32];
    RK_U8 level_idc;

    RK_U8 progressive_source_flag;
    RK_U8 interlaced_source_flag;
    RK_U8 non_packed_constraint_flag;
    RK_U8 frame_only_constraint_flag;

    RK_S32 bit_depth_constraint;
    H265ChromaFmt chroma_format_constraint;
    RK_U8 intra_constraint_flag;
    RK_U8 one_picture_only_constraint_flag;
    RK_U8 lower_bitrate_constraint_flag;
} PTLCommon;

typedef struct PTL {
    PTLCommon general_ptl;
    PTLCommon sub_layer_ptl[MAX_SUB_LAYERS];

    RK_U8  sub_layer_profile_present_flag[MAX_SUB_LAYERS];
    RK_U8  sub_layer_level_present_flag[MAX_SUB_LAYERS];

    RK_S32 sub_layer_profile_space[MAX_SUB_LAYERS];
    RK_U8  sub_layer_tier_flag[MAX_SUB_LAYERS];
    RK_S32 sub_layer_profile_idc[MAX_SUB_LAYERS];
    RK_U8  sub_layer_profile_compatibility_flags[MAX_SUB_LAYERS][32];
    RK_S32 sub_layer_level_idc[MAX_SUB_LAYERS];
} PTL;

typedef struct HEVCVPS {
    RK_U8  vps_temporal_id_nesting_flag;
    RK_S32 vps_max_layers;
    RK_S32 vps_max_sub_layers; ///< vps_max_temporal_layers_minus1 + 1

    PTL     ptl;
    RK_S32 vps_sub_layer_ordering_info_present_flag;
    RK_U32 vps_max_dec_pic_buffering[MAX_SUB_LAYERS];
    RK_U32 vps_num_reorder_pics[MAX_SUB_LAYERS];
    RK_U32 vps_max_latency_increase[MAX_SUB_LAYERS];
    RK_S32 vps_max_layer_id;
    RK_S32 vps_num_layer_sets; ///< vps_num_layer_sets_minus1 + 1
    RK_U8  vps_timing_info_present_flag;
    RK_U32 vps_num_units_in_tick;
    RK_U32 vps_time_scale;
    RK_U8  vps_poc_proportional_to_timing_flag;
    RK_S32 vps_num_ticks_poc_diff_one; ///< vps_num_ticks_poc_diff_one_minus1 + 1
    RK_S32 vps_num_hrd_parameters;

    RK_S32 vps_extension_flag;

} HEVCVPS;

typedef struct ScalingList {
    /* This is a little wasteful, since sizeID 0 only needs 8 coeffs,
     * and size ID 3 only has 2 arrays, not 6. */
    RK_U8 sl[4][6][64];
    RK_U8 sl_dc[2][6];
} ScalingList;

typedef struct HEVCSPS {
    RK_U32 vps_id;
    RK_U32 sps_id;
    RK_S32 chroma_format_idc;
    RK_U8 separate_colour_plane_flag;

    ///< output (i.e. cropped) values
    RK_S32 output_width, output_height;
    HEVCWindow output_window;

    HEVCWindow pic_conf_win;

    RK_S32 bit_depth;
    RK_S32 bit_depth_chroma;///<- zrh add
    RK_S32 pixel_shift;
    RK_S32 pix_fmt;

    RK_U32 log2_max_poc_lsb;
    RK_S32 pcm_enabled_flag;

    RK_S32 max_sub_layers;
    struct {
        int max_dec_pic_buffering;
        int num_reorder_pics;
        int max_latency_increase;
    } temporal_layer[MAX_SUB_LAYERS];

    VUI vui;
    PTL ptl;

    RK_U8 scaling_list_enable_flag;
    ScalingList scaling_list;

    RK_U32 nb_st_rps;
    ShortTermRPS st_rps[MAX_SHORT_TERM_RPS_COUNT];

    RK_U8 amp_enabled_flag;
    RK_U8 sao_enabled;

    RK_U8 long_term_ref_pics_present_flag;
    RK_U16 lt_ref_pic_poc_lsb_sps[32];
    RK_U8 used_by_curr_pic_lt_sps_flag[32];
    RK_U8 num_long_term_ref_pics_sps;

    struct {
        RK_U8  bit_depth;
        RK_U8  bit_depth_chroma;
        RK_U32 log2_min_pcm_cb_size;
        RK_U32 log2_max_pcm_cb_size;
        RK_U8  loop_filter_disable_flag;
    } pcm;
    RK_U8 sps_temporal_mvp_enabled_flag;
    RK_U8 sps_strong_intra_smoothing_enable_flag;

    RK_U32 log2_min_cb_size;
    RK_U32 log2_diff_max_min_coding_block_size;
    RK_U32 log2_min_tb_size;
    RK_U32 log2_max_trafo_size;
    RK_S32 log2_ctb_size;
    RK_U32 log2_min_pu_size;

    RK_S32 max_transform_hierarchy_depth_inter;
    RK_S32 max_transform_hierarchy_depth_intra;

    // SPS extension
    RK_S32 sps_extension_flag;
    RK_S32 sps_range_extension_flag;
    RK_S32 transform_skip_rotation_enabled_flag;
    RK_S32 transform_skip_context_enabled_flag;
    RK_S32 implicit_rdpcm_enabled_flag;
    RK_S32 explicit_rdpcm_enabled_flag;
    RK_S32 extended_precision_processing_flag;
    RK_S32 intra_smoothing_disabled_flag;
    RK_S32 high_precision_offsets_enabled_flag;
    RK_S32 persistent_rice_adaptation_enabled_flag;
    RK_S32 cabac_bypass_alignment_enabled_flag;

    ///< coded frame dimension in various units
    RK_S32 width;
    RK_S32 height;
    RK_S32 ctb_width;
    RK_S32 ctb_height;
    RK_S32 ctb_size;
    RK_S32 min_cb_width;
    RK_S32 min_cb_height;
    RK_S32 min_tb_width;
    RK_S32 min_tb_height;
    RK_S32 min_pu_width;
    RK_S32 min_pu_height;

    RK_S32 hshift[3];
    RK_S32 vshift[3];

    RK_S32 qp_bd_offset;
#ifdef SCALED_REF_LAYER_OFFSETS
    HEVCWindow      scaled_ref_layer_window;
#endif
#ifdef REF_IDX_MFM
    RK_S32 set_mfm_enabled_flag;
#endif
} HEVCSPS;

typedef struct HevcPpsBufInfo_t {
    RK_U32 *column_width;       ///< ColumnWidth
    RK_U32 *row_height;         ///< RowHeight

    RK_S32 column_width_size;
    RK_S32 row_height_size;
} HevcPpsBufInfo;

typedef struct HEVCPPS {
    RK_U32 sps_id;
    RK_U32 pps_id;

    RK_U8 sign_data_hiding_flag;

    RK_U8 cabac_init_present_flag;

    RK_S32 num_ref_idx_l0_default_active; ///< num_ref_idx_l0_default_active_minus1 + 1
    RK_S32 num_ref_idx_l1_default_active; ///< num_ref_idx_l1_default_active_minus1 + 1
    RK_S32 pic_init_qp_minus26;

    RK_U8 constrained_intra_pred_flag;
    RK_U8 transform_skip_enabled_flag;

    RK_U8 cu_qp_delta_enabled_flag;
    RK_S32 diff_cu_qp_delta_depth;

    RK_S32 cb_qp_offset;
    RK_S32 cr_qp_offset;
    RK_U8 pic_slice_level_chroma_qp_offsets_present_flag;
    RK_U8 weighted_pred_flag;
    RK_U8 weighted_bipred_flag;
    RK_U8 output_flag_present_flag;
    RK_U8 transquant_bypass_enable_flag;

    RK_U8 dependent_slice_segments_enabled_flag;
    RK_U8 tiles_enabled_flag;
    RK_U8 entropy_coding_sync_enabled_flag;

    RK_S32 num_tile_columns;   ///< num_tile_columns_minus1 + 1
    RK_S32 num_tile_rows;      ///< num_tile_rows_minus1 + 1
    RK_U8 uniform_spacing_flag;
    RK_U8 loop_filter_across_tiles_enabled_flag;

    RK_U8 seq_loop_filter_across_slices_enabled_flag;

    RK_U8 deblocking_filter_control_present_flag;
    RK_U8 deblocking_filter_override_enabled_flag;
    RK_U8 disable_dbf;
    RK_S32 beta_offset;    ///< beta_offset_div2 * 2
    RK_S32 tc_offset;      ///< tc_offset_div2 * 2

    RK_U8 scaling_list_data_present_flag;
    ScalingList scaling_list;

    RK_U8 lists_modification_present_flag;
    RK_S32 log2_parallel_merge_level; ///< log2_parallel_merge_level_minus2 + 2
    RK_S32 num_extra_slice_header_bits;
    RK_U8 slice_header_extension_present_flag;

    // PPS extension
    RK_U8 pps_extension_flag;
    RK_U8 pps_range_extensions_flag;
    RK_U8 log2_max_transform_skip_block_size;
    RK_U8 cross_component_prediction_enabled_flag;
    RK_U8 chroma_qp_offset_list_enabled_flag;
    RK_U8 diff_cu_chroma_qp_offset_depth;
    RK_U8 chroma_qp_offset_list_len_minus1;
    RK_S8 cb_qp_offset_list[6];
    RK_S8 cr_qp_offset_list[6];
    RK_U8 log2_sao_offset_scale_luma;
    RK_U8 log2_sao_offset_scale_chroma;

    // Inferred parameters
    HevcPpsBufInfo bufs;
} HEVCPPS;

typedef struct SliceHeader {
    RK_U32 pps_id;

    ///< address (in raster order) of the first block in the current slice segment
    RK_U32   slice_segment_addr;
    ///< address (in raster order) of the first block in the current slice
    RK_U32   slice_addr;

    SliceType slice_type;

    RK_S32 pic_order_cnt_lsb;

    RK_U8 first_slice_in_pic_flag;
    RK_U8 dependent_slice_segment_flag;
    RK_U8 pic_output_flag;
    RK_U8 colour_plane_id;

    ///< RPS coded in the slice header itself is stored here
    int short_term_ref_pic_set_sps_flag;
    int short_term_ref_pic_set_size;
    ShortTermRPS slice_rps;
    const ShortTermRPS *short_term_rps;
    LongTermRPS long_term_rps;
    RK_U32 list_entry_lx[2][32];

    RK_U8 rpl_modification_flag[2];
    RK_U8 no_output_of_prior_pics_flag;
    RK_U8 slice_temporal_mvp_enabled_flag;

    RK_U32 nb_refs[2];

    RK_U8 slice_sample_adaptive_offset_flag[3];
    RK_U8 mvd_l1_zero_flag;

    RK_U8 cabac_init_flag;
    RK_U8 disable_deblocking_filter_flag; ///< slice_header_disable_deblocking_filter_flag
    RK_U8 slice_loop_filter_across_slices_enabled_flag;
    RK_U8 collocated_list;

    RK_U32 collocated_ref_idx;

    RK_S32 slice_qp_delta;
    RK_S32 slice_cb_qp_offset;
    RK_S32 slice_cr_qp_offset;

    RK_S32 beta_offset;    ///< beta_offset_div2 * 2
    RK_S32 tc_offset;      ///< tc_offset_div2 * 2

    RK_U32 max_num_merge_cand; ///< 5 - 5_minus_max_num_merge_cand

    RK_S32 *entry_point_offset;
    RK_S32 * offset;
    RK_S32 * size;
    RK_S32 num_entry_point_offsets;

    RK_S8 slice_qp;

    RK_U8 luma_log2_weight_denom;
    RK_S16 chroma_log2_weight_denom;

    RK_S16 luma_weight_l0[16];
    RK_S16 chroma_weight_l0[16][2];
    RK_S16 chroma_weight_l1[16][2];
    RK_S16 luma_weight_l1[16];

    RK_S16 luma_offset_l0[16];
    RK_S16 chroma_offset_l0[16][2];

    RK_S16 luma_offset_l1[16];
    RK_S16 chroma_offset_l1[16][2];

#ifdef REF_IDX_FRAMEWORK
    RK_S32 inter_layer_pred_enabled_flag;
#endif

#ifdef JCTVC_M0458_INTERLAYER_RPS_SIG
    RK_S32     active_num_ILR_ref_idx;        //< Active inter-layer reference pictures
    RK_S32     inter_layer_pred_layer_idc[MAX_VPS_LAYER_ID_PLUS1];
#endif

    RK_S32 slice_ctb_addr_rs;
} SliceHeader;

typedef struct CurrentFameInf {
    HEVCVPS vps[MAX_VPS_COUNT];
    HEVCSPS sps[MAX_SPS_COUNT];
    HEVCPPS pps[MAX_PPS_COUNT];
    SliceHeader sh;
} CurrentFameInf_t;

typedef struct DBParams {
    RK_S32 beta_offset;
    RK_S32 tc_offset;
} DBParams;

#define HEVC_FRAME_FLAG_OUTPUT    (1 << 0)
#define HEVC_FRAME_FLAG_SHORT_REF (1 << 1)
#define HEVC_FRAME_FLAG_LONG_REF  (1 << 2)

typedef struct HEVCFrame {
    MppFrame   frame;
    RefPicList *refPicList;
    RK_S32 ctb_count;
    RK_S32 poc;
    struct HEVCFrame *collocated_ref;

    HEVCWindow window;

    /**
     * A sequence counter, so that old frames are output first
     * after a POC reset
     */
    RK_U16 sequence;

    /**
     * A combination of HEVC_FRAME_FLAG_*
     */
    RK_U8 flags;
    RK_S32 slot_index;
    RK_U8  error_flag;
} HEVCFrame;

typedef struct HEVCNAL {
    RK_U8 *rbsp_buffer;
    RK_S32 rbsp_buffer_size;
    RK_S32 size;
    const RK_U8 *data;
} HEVCNAL;

typedef struct HEVCLocalContext {
    BitReadCtx_t gb;
} HEVCLocalContext;


typedef struct REF_PIC_DEC_INFO {
    RK_U8          dpb_index;
    RK_U8          is_long_term;
} REF_PIC_DEC_INFO;

typedef struct HEVCSEIAlternativeTransfer {
    RK_S32 present;
    RK_S32 preferred_transfer_characteristics;
} HEVCSEIAlternativeTransfer;

typedef struct HEVCContext {
    H265dContext_t *h265dctx;

    HEVCLocalContext    *HEVClc;

    MppFrame frame;

    const HEVCVPS *vps;
    const HEVCSPS *sps;
    const HEVCPPS *pps;
    RK_U8 *vps_list[MAX_VPS_COUNT];
    RK_U8 *sps_list[MAX_SPS_COUNT];
    RK_U8 *pps_list[MAX_PPS_COUNT];

    MppMemPool vps_pool;
    MppMemPool sps_pool;

    SliceHeader sh;

    ///< candidate references for the current frame
    RefPicList rps[5];

    enum NALUnitType nal_unit_type;
    RK_S32 temporal_id;  ///< temporal_id_plus1 - 1
    HEVCFrame *ref;
    HEVCFrame DPB[MAX_DPB_SIZE];
    RK_S32 poc;
    RK_S32 pocTid0;
    RK_S32 slice_idx; ///< number of the slice being currently decoded
    RK_S32 eos;       ///< current packet contains an EOS/EOB NAL
    RK_S32 max_ra;

    RK_S32 is_decoded;


    /** used on BE to byteswap the lines for checksumming */
    RK_U8  *checksum_buf;
    RK_S32      checksum_buf_size;

    /**
     * Sequence counters for decoded and output frames, so that old
     * frames are output first after a POC reset
     */
    RK_U16 seq_decode;
    RK_U16 seq_output;

    RK_S32 wpp_err;
    RK_S32 skipped_bytes;

    RK_U8 *data;

    HEVCNAL *nals;
    RK_S32 nb_nals;
    RK_S32 nals_allocated;
    // type of the first VCL NAL of the current frame
    enum NALUnitType first_nal_type;

    RK_U8 context_initialized;
    RK_U8 is_nalff;       ///< this flag is != 0 if bitstream is encapsulated
    ///< as a format defined in 14496-15
    RK_S32 temporal_layer_id;
    RK_S32 decoder_id;
    RK_S32 apply_defdispwin;

    RK_S32 active_seq_parameter_set_id;

    RK_S32 nal_length_size;    ///< Number of bytes used for nal length (1, 2 or 4)
    RK_S32 nuh_layer_id;

    /** frame packing arrangement variables */
    RK_S32 sei_frame_packing_present;
    RK_S32 frame_packing_arrangement_type;
    RK_S32 content_interpretation_type;
    RK_S32 quincunx_subsampling;

    RK_S32 picture_struct;

    /** 1 if the independent slice segment header was successfully parsed */
    RK_U8 slice_initialized;

    RK_S32     decode_checksum_sei;


    RK_U8     scaling_list[81][1360];
    RK_U8     scaling_list_listen[81];
    RK_U8     sps_list_of_updated[MAX_SPS_COUNT];///< zrh add
    RK_U8     pps_list_of_updated[MAX_PPS_COUNT];///< zrh add

    RK_S32    rps_used[16];
    RK_S32    nb_rps_used;
    REF_PIC_DEC_INFO rps_pic_info[600][2][15];      // zrh add
    RK_U8     lowdelay_flag[600];
    RK_U8     rps_bit_offset[600];
    RK_U8     rps_bit_offset_st[600];
    RK_U8     slice_nb_rps_poc[600];

    RK_S32    frame_size;

    RK_S32    framestrid;

    RK_U32    nb_frame;

    RK_U8     output_frame_idx;

    RK_U32    got_frame;
    RK_U32    extra_has_frame;

    MppFrameMasteringDisplayMetadata mastering_display;
    MppFrameContentLightMetadata content_light;
    MppFrameHdrDynamicMeta *hdr_dynamic_meta;
    HEVCSEIAlternativeTransfer alternative_transfer;

    MppBufSlots slots;

    MppBufSlots packet_slots;
    HalDecTask *task;

    MppPacket input_packet;
    void *hal_pic_private;

    RK_S64 pts;
    RK_S64 dts;
    RK_U8  has_get_eos;
    RK_U8  miss_ref_flag;
    RK_U8  pre_pps_id;
    RK_U8  ps_need_upate;
    RK_U8  sps_need_upate;
    RK_U8  rps_need_upate;

    /*temporary storage for slice_cut_param*/
    RK_U32  start_bit;
    RK_U32  end_bit;
    void   *pre_pps_data;
    RK_S32  pps_len;
    RK_S32  pps_buf_size;
    RK_S32  first_i_fast_play;

    /* hdr info */
    RK_U32  is_hdr;
    RK_U32  hdr_dynamic;

    RK_U32  deny_flag;
    RecoveryPoint recovery;
} HEVCContext;

RK_S32 mpp_hevc_decode_short_term_rps(HEVCContext *s, ShortTermRPS *rps,
                                      const HEVCSPS *sps, RK_S32 is_slice_header);
RK_S32 mpp_hevc_decode_nal_vps(HEVCContext *s);
RK_S32 mpp_hevc_decode_nal_sps(HEVCContext *s);
RK_S32 mpp_hevc_decode_nal_pps(HEVCContext *s);
RK_S32 mpp_hevc_decode_nal_sei(HEVCContext *s);

RK_S32 mpp_hevc_extract_rbsp(HEVCContext *s, const RK_U8 *src, RK_S32 length,
                             HEVCNAL *nal);


/**
 * Mark all frames in DPB as unused for reference.
 */
void mpp_hevc_clear_refs(HEVCContext *s);

/**
 * Drop all frames currently in DPB.
 */
void mpp_hevc_flush_dpb(HEVCContext *s);

/**
 * Compute POC of the current frame and return it.
 */
int mpp_hevc_compute_poc(HEVCContext *s, RK_S32 poc_lsb);


/**
 * Construct the reference picture sets for the current frame.
 */
RK_S32 mpp_hevc_frame_rps(HEVCContext *s);

/**
 * Construct the reference picture list(s) for the current slice.
 */
RK_S32 mpp_hevc_slice_rpl(HEVCContext *s);

/**
 * Get the number of candidate references for the current frame.
 */
RK_S32 mpp_hevc_frame_nb_refs(HEVCContext *s);
RK_S32 mpp_hevc_set_new_ref(HEVCContext *s, MppFrame *frame, RK_S32 poc);

/**
 * Find next frame in output order and put a reference to it in frame.
 * @return 1 if a frame was output, 0 otherwise
 */
void mpp_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, RK_S32 flags);

void mpp_hevc_pps_free(RK_U8 *data);

void mpp_hevc_fill_dynamic_meta(HEVCContext *s, const RK_U8 *data, RK_U32 size, RK_U32 hdr_fmt);

#endif /* __H265D_PAESER_H__ */
