/*
Copyright (c) 2023 - 2025 Advanced Micro Devices, Inc. All rights reserved.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/

#ifndef ROCDECAPI
#if defined(_WIN32)
#define ROCDECAPI __stdcall // for future: only linux is supported in this version
#else
#define ROCDECAPI
#endif
#endif

#pragma once
#include "hip/hip_runtime.h"

/*!
 * \file
 * \brief The AMD rocDecode Library.
 *
 * \defgroup group_amd_rocdecode rocDecode: AMD ROCm Decode API
 * \brief AMD The rocDecode is a toolkit to decode videos and images using a hardware-accelerated video decoder on AMD’s GPUs.
 */

#if defined(__cplusplus)
extern "C" {
#endif // __cplusplus

/*********************************************************************************/
//! HANDLE pf rocDecDecoder
//! Used in subsequent API calls after rocDecCreateDecoder
/*********************************************************************************/

typedef void *rocDecDecoderHandle;

/*********************************************************************************/
//! \enum rocDecStatus
//! \ingroup group_amd_rocdecode
//! rocDecoder return status enums
//! These enums are used in all API calls to rocDecoder
/*********************************************************************************/
typedef enum rocDecStatus_enum {
    ROCDEC_DEVICE_INVALID = -1,
    ROCDEC_CONTEXT_INVALID = -2,
    ROCDEC_RUNTIME_ERROR = -3,
    ROCDEC_OUTOF_MEMORY = -4,
    ROCDEC_INVALID_PARAMETER = -5,
    ROCDEC_NOT_IMPLEMENTED = -6,
    ROCDEC_NOT_INITIALIZED = -7,
    ROCDEC_NOT_SUPPORTED = -8,
    ROCDEC_SUCCESS = 0,
} rocDecStatus;

/*********************************************************************************/
//! \enum rocDecodeVideoCodec
//! \ingroup group_amd_rocdecode
//! Video codec enums
//! These enums are used in ROCDECODECREATEINFO and ROCDECODEVIDDECODECAPS structures
/*********************************************************************************/
typedef enum rocDecVideoCodec_enum {
    rocDecVideoCodec_MPEG1 = 0, /**<  MPEG1 */
    rocDecVideoCodec_MPEG2,     /**<  MPEG2 */
    rocDecVideoCodec_MPEG4,     /**<  MPEG4 */
    rocDecVideoCodec_AVC,       /**<  AVC/H264 */
    rocDecVideoCodec_HEVC,      /**<  HEVC */
    rocDecVideoCodec_AV1,       /**<  AV1 */
    rocDecVideoCodec_VP8,       /**<  VP8 */
    rocDecVideoCodec_VP9,       /**<  VP9 */
    rocDecVideoCodec_JPEG,      /**<  JPEG */
    rocDecVideoCodec_NumCodecs, /**<  Max codecs */
    // Uncompressed YUV
    rocDecVideoCodec_YUV420 = (('I' << 24) | ('Y' << 16) | ('U' << 8) | ('V')), /**< Y,U,V (4:2:0)      */
    rocDecVideoCodec_YV12 = (('Y' << 24) | ('V' << 16) | ('1' << 8) | ('2')),   /**< Y,V,U (4:2:0)      */
    rocDecVideoCodec_NV12 = (('N' << 24) | ('V' << 16) | ('1' << 8) | ('2')),   /**< Y,UV  (4:2:0)      */
    rocDecVideoCodec_YUYV = (('Y' << 24) | ('U' << 16) | ('Y' << 8) | ('V')),   /**< YUYV/YUY2 (4:2:2)  */
    rocDecVideoCodec_UYVY = (('U' << 24) | ('Y' << 16) | ('V' << 8) | ('Y'))    /**< UYVY (4:2:2)       */
} rocDecVideoCodec;

/*********************************************************************************/
//! \enum rocDecVideoSurfaceFormat
//! \ingroup group_amd_rocdecode
//! Video surface format enums used for output format of decoded output
//! These enums are used in RocDecoderCreateInfo structure
/*********************************************************************************/
typedef enum rocDecVideoSurfaceFormat_enum {
    rocDecVideoSurfaceFormat_NV12 = 0,         /**< Semi-Planar YUV [Y plane followed by interleaved UV plane] */
    rocDecVideoSurfaceFormat_P016 = 1,         /**< 16 bit Semi-Planar YUV [Y plane followed by interleaved UV plane].
                                                Can be used for 10 bit(6LSB bits 0), 12 bit (4LSB bits 0) */
    rocDecVideoSurfaceFormat_YUV444 = 2,       /**< Planar YUV [Y plane followed by U and V planes] */
    rocDecVideoSurfaceFormat_YUV444_16Bit = 3, /**< 16 bit Planar YUV [Y plane followed by U and V planes].
                                                Can be used for 10 bit(6LSB bits 0), 12 bit (4LSB bits 0) */
    rocDecVideoSurfaceFormat_YUV420 = 4,       /**< Planar YUV [Y plane followed by U and V planes in 4:2:0 format] */
    rocDecVideoSurfaceFormat_YUV420_16Bit = 5, /**< 16 bit Planar YUV [Y plane followed by U and V planes in 4:2:0 format].
                                                Can be used for 10 bit(LSB), 12 bit (LSB) */
    rocDecVideoSurfaceFormat_YUV422 = 6,       /**< Planar YUV [Y plane followed by U and V planes in 4:2:2 format] */
    rocDecVideoSurfaceFormat_YUV422_16Bit = 7, /**< 16 bit Planar YUV [Y plane followed by U and V planes in 4:2:2 format].
                                                Can be used for 10 bit(LSB), 12 bit (LSB) */
} rocDecVideoSurfaceFormat;

/**************************************************************************************************************/
//! \enum rocDecVideoChromaFormat
//! \ingroup group_amd_rocdecode
//! Chroma format enums
//! These enums are used in ROCDCODECREATEINFO and RocdecDecodeCaps structures
/**************************************************************************************************************/
typedef enum rocDecVideoChromaFormat_enum {
    rocDecVideoChromaFormat_Monochrome = 0, /**< MonoChrome */
    rocDecVideoChromaFormat_420,            /**< YUV 4:2:0  */
    rocDecVideoChromaFormat_422,            /**< YUV 4:2:2  */
    rocDecVideoChromaFormat_444             /**< YUV 4:4:4  */
} rocDecVideoChromaFormat;

/*************************************************************************/
//! \enum rocDecDecodeStatus
//! \ingroup group_amd_rocdecode
//! Decode status enums
//! These enums are used in RocdecGetDecodeStatus structure
/*************************************************************************/
typedef enum rocDecodeStatus_enum {
    rocDecodeStatus_Invalid = 0,    // Decode status is not valid
    rocDecodeStatus_InProgress = 1, // Decode is in progress
    rocDecodeStatus_Success = 2,    // Decode is completed without any errors
    // 3 to 7 enums are reserved for future use
    rocDecodeStatus_Error = 8,           // Decode is completed with an error (error is not concealed)
    rocDecodeStatus_Error_Concealed = 9, // Decode is completed with an error and error is concealed
    rocDecodeStatus_Displaying = 10,     // Decode is completed, displaying in progress
} rocDecDecodeStatus;

/**************************************************************************************************************/
//! \struct RocdecDecodeCaps;
//! \ingroup group_amd_rocdecode
//! This structure is used in rocDecGetDecoderCaps API
/**************************************************************************************************************/
typedef struct _RocdecDecodeCaps {
    uint8_t device_id;                     /**< IN: the device id for which query the decode capability 0 for the first device, 1 for the second device on the system, etc.*/
    rocDecVideoCodec codec_type;           /**< IN: rocDecVideoCodec_XXX */
    rocDecVideoChromaFormat chroma_format; /**< IN: rocDecVideoChromaFormat_XXX */
    uint32_t bit_depth_minus_8;            /**< IN: The Value "BitDepth minus 8" */
    uint32_t reserved_1[3];                /**< Reserved for future use - set to zero */
    uint8_t is_supported;                  /**< OUT: 1 if codec supported, 0 if not supported */
    uint8_t num_decoders;                  /**< OUT: Number of Decoders that can support IN params */
    uint16_t output_format_mask;           /**< OUT: each bit represents corresponding rocDecVideoSurfaceFormat enum */
    uint32_t max_width;                    /**< OUT: Max supported coded width in pixels */
    uint32_t max_height;                   /**< OUT: Max supported coded height in pixels */
    uint16_t min_width;                    /**< OUT: Min supported coded width in pixels */
    uint16_t min_height;                   /**< OUT: Min supported coded height in pixels */
    uint32_t reserved_2[6];                /**< Reserved for future use - set to zero */
} RocdecDecodeCaps;

/**************************************************************************************************************/
//! \struct RocDecoderCreateInfo
//! \ingroup group_amd_rocdecode
//! This structure is used in rocDecCreateDecoder API
/**************************************************************************************************************/
typedef struct _RocDecoderCreateInfo {
    uint8_t device_id;                     /**< IN: the device id for which a decoder should be created
                                                0 for the first device, 1 for the second device on the system, etc.*/
    uint32_t width;                        /**< IN: Coded sequence width in pixels */
    uint32_t height;                       /**< IN: Coded sequence height in pixels */
    uint32_t num_decode_surfaces;          /**< IN: Maximum number of internal decode surfaces */
    rocDecVideoCodec codec_type;           /**< IN: rocDecVideoCodec_XXX */
    rocDecVideoChromaFormat chroma_format; /**< IN: rocDecVideoChromaFormat_XXX */
    uint32_t bit_depth_minus_8;            /**< IN: The value "BitDepth minus 8" */
    uint32_t intra_decode_only;            /**< IN: Set 1 only if video has all intra frames (default value is 0). This will
                                                    optimize video memory for Intra frames only decoding. The support is limited
                                                    to specific codecs - AVC/H264, HEVC, VP9, the flag will be ignored for codecs which
                                                    are not supported. However decoding might fail if the flag is enabled in case
                                                    of supported codecs for regular bit streams having P and/or B frames. */
    uint32_t max_width;                    /**< IN: Coded sequence max width in pixels used with reconfigure Decoder */
    uint32_t max_height;                   /**< IN: Coded sequence max height in pixels used with reconfigure Decoder */
    struct {
        int16_t left;
        int16_t top;
        int16_t right;
        int16_t bottom;
    } display_rect;                         /**< IN: area of the frame that should be displayed */
    rocDecVideoSurfaceFormat output_format; /**< IN: rocDecVideoSurfaceFormat_XXX */
    uint32_t target_width;                  /**< IN: Post-processed output width (Should be aligned to 2) */
    uint32_t target_height;                 /**< IN: Post-processed output height (Should be aligned to 2) */
    uint32_t num_output_surfaces;           /**< IN: Maximum number of output surfaces simultaneously mapped */
    struct {
        int16_t left;
        int16_t top;
        int16_t right;
        int16_t bottom;
    } target_rect;          /**< IN: (for future use) target rectangle in the output frame (for aspect ratio conversion)
                                    if a null rectangle is specified, {0,0,target_width,target_height} will be used*/
    uint32_t reserved_2[4]; /**< Reserved for future use - set to zero */
} RocDecoderCreateInfo;

/*********************************************************************************************************/
//! \struct RocdecDecodeStatus
//! \ingroup group_amd_rocdecode
//! Struct for reporting decode status.
//! This structure is used in RocdecGetDecodeStatus API.
/*********************************************************************************************************/
typedef struct _RocdecDecodeStatus {
    rocDecDecodeStatus decode_status;
    uint32_t reserved[31];
    void *p_reserved[8];
} RocdecDecodeStatus;

/****************************************************/
//! \struct RocdecReconfigureDecoderInfo
//! \ingroup group_amd_rocdecode
//! Struct for decoder reset
//! This structure is used in rocDecReconfigureDecoder() API
/****************************************************/
typedef struct _RocdecReconfigureDecoderInfo {
    uint32_t width;               /**< IN: Coded sequence width in pixels, MUST be < = max_width defined at RocDecoderCreateInfo */
    uint32_t height;              /**< IN: Coded sequence height in pixels, MUST be < = max_height defined at RocDecoderCreateInfo */
    uint32_t target_width;        /**< IN: Post processed output width */
    uint32_t target_height;       /**< IN: Post Processed output height */
    uint32_t num_decode_surfaces; /**< IN: Maximum number of internal decode surfaces */
    uint32_t bit_depth_minus_8;   /**< IN: The Value "BitDepth minus 8" */
    uint32_t reserved_1[11];      /**< Reserved for future use. Set to Zero */
    struct {
        int16_t left;
        int16_t top;
        int16_t right;
        int16_t bottom;
    } display_rect; /**< IN: area of the frame that should be displayed */
    struct {
        int16_t left;
        int16_t top;
        int16_t right;
        int16_t bottom;
    } target_rect;           /**< IN: (for future use) target rectangle in the output frame (for aspect ratio conversion)
                                if a null rectangle is specified, {0,0,target_width,target_height} will be used */
    uint32_t reserved_2[11]; /**< Reserved for future use. Set to Zero */
} RocdecReconfigureDecoderInfo;

/*********************************************************/
//! \struct RocdecAvcPicture
//! \ingroup group_amd_rocdecode
//! AVC/H.264 Picture Entry
//! This structure is used in RocdecAvcPicParams structure
/*********************************************************/
typedef struct _RocdecAvcPicture {
    int pic_idx;                    /**< picture index of reference frame */
    uint32_t frame_idx;             /**< frame_num(int16_t-term) or LongTermFrameIdx(long-term) */
    uint32_t flags;                 /**< See below for definitions */
    int32_t top_field_order_cnt;    /**< field order count of top field */
    int32_t bottom_field_order_cnt; /**< field order count of bottom field */
    uint32_t reserved[4];
} RocdecAvcPicture;

/* flags in RocdecAvcPicture could be OR of the following */
#define RocdecAvcPicture_FLAGS_INVALID 0x00000001
#define RocdecAvcPicture_FLAGS_TOP_FIELD 0x00000002
#define RocdecAvcPicture_FLAGS_BOTTOM_FIELD 0x00000004
#define RocdecAvcPicture_FLAGS_SHORT_TERM_REFERENCE 0x00000008
#define RocdecAvcPicture_FLAGS_LONG_TERM_REFERENCE 0x00000010
#define RocdecAvcPicture_FLAGS_NON_EXISTING 0x00000020

/*********************************************************/
//! \struct RocdecHevcPicture
//! \ingroup group_amd_rocdecode
//! HEVC Picture Entry
//! This structure is used in RocdecHevcPicParams structure
/*********************************************************/
typedef struct _RocdecHevcPicture {
    int pic_idx; /**< reconstructed picture surface ID */
    /** \brief picture order count.
    //! \ingroup group_amd_rocdecode
        * in HEVC, POCs for top and bottom fields of same picture should
        * take different values.
        */
    int poc;
    uint32_t flags;       /**< See below for definitions */
    uint32_t reserved[4]; /**< reserved for future; must be zero */
} RocdecHevcPicture;

/* flags in RocdecHevcPicture could be OR of the following */
#define RocdecHevcPicture_INVALID 0x00000001
/** \brief indication of interlace scan picture.
 * should take same value for all the pictures in sequence.
 */
#define RocdecHevcPicture_FIELD_PIC 0x00000002
/** \brief polarity of the field picture.
 * top field takes even lines of buffer surface.
 * bottom field takes odd lines of buffer surface.
 */
#define RocdecHevcPicture_BOTTOM_FIELD 0x00000004
/** \brief Long term reference picture */
#define RocdecHevcPicture_LONG_TERM_REFERENCE 0x00000008
/**
 * RocdecHevcPicture_ST_CURR_BEFORE, RocdecHevcPicture_RPS_ST_CURR_AFTER
 * and RocdecHevcPicture_RPS_LT_CURR of any picture in ReferenceFrames[] should
 * be exclusive. No more than one of them can be set for any picture.
 * Sum of NumPocStCurrBefore, NumPocStCurrAfter and NumPocLtCurr
 * equals NumPocTotalCurr, which should be equal to or smaller than 8.
 * Application should provide valid values for both int16_t format and long format.
 * The pictures in DPB with any of these three flags turned on are referred by
 * the current picture.
 */
/** \brief RefPicSetStCurrBefore of HEVC spec variable
 * Number of ReferenceFrames[] entries with this bit set equals
 * NumPocStCurrBefore.
 */
#define RocdecHevcPicture_RPS_ST_CURR_BEFORE 0x00000010
/** \brief RefPicSetStCurrAfter of HEVC spec variable
 * Number of ReferenceFrames[] entries with this bit set equals
 * NumPocStCurrAfter.
 */
#define RocdecHevcPicture_RPS_ST_CURR_AFTER 0x00000020
/** \brief RefPicSetLtCurr of HEVC spec variable
 * Number of ReferenceFrames[] entries with this bit set equals
 * NumPocLtCurr.
 */
#define RocdecHevcPicture_RPS_LT_CURR 0x00000040

/***********************************************************/
//! \struct RocdecJPEGPicParams placeholder
//! \ingroup group_amd_rocdecode
//! JPEG picture parameters
//! This structure is used in RocdecPicParams structure
/***********************************************************/
typedef struct _RocdecJPEGPicParams {
    int reserved;
} RocdecJPEGPicParams;

/***********************************************************/
//! \struct RocdecMpeg2QMatrix
//! \ingroup group_amd_rocdecode
//! MPEG2 QMatrix
//! This structure is used in _RocdecMpeg2PicParams structure
/***********************************************************/
typedef struct _RocdecMpeg2QMatrix {
    int32_t load_intra_quantiser_matrix;
    int32_t load_non_intra_quantiser_matrix;
    int32_t load_chroma_intra_quantiser_matrix;
    int32_t load_chroma_non_intra_quantiser_matrix;
    uint8_t intra_quantiser_matrix[64];
    uint8_t non_intra_quantiser_matrix[64];
    uint8_t chroma_intra_quantiser_matrix[64];
    uint8_t chroma_non_intra_quantiser_matrix[64];
} RocdecMpeg2QMatrix;

/***********************************************************/
//! \struct RocdecMpeg2PicParams
//! \ingroup group_amd_rocdecode
//! MPEG2 picture parameters
//! This structure is used in RocdecMpeg2PicParams structure
/***********************************************************/
typedef struct _RocdecMpeg2PicParams {
    uint16_t horizontal_size;
    uint16_t vertical_size;
    uint32_t forward_reference_pic;      // surface_id for forward reference
    uint32_t backward_reference_picture; // surface_id for backward reference
    /* meanings of the following fields are the same as in the standard */
    int32_t picture_coding_type;
    int32_t f_code; /* pack all four fcode into this */
    union {
        struct {
            uint32_t intra_dc_precision : 2;
            uint32_t picture_structure : 2;
            uint32_t top_field_first : 1;
            uint32_t frame_pred_frame_dct : 1;
            uint32_t concealment_motion_vectors : 1;
            uint32_t q_scale_type : 1;
            uint32_t intra_vlc_format : 1;
            uint32_t alternate_scan : 1;
            uint32_t repeat_first_field : 1;
            uint32_t progressive_frame : 1;
            uint32_t is_first_field : 1; // indicate whether the current field is the first field for field picture
        } bits;
        uint32_t value;
    } picture_coding_extension;

    RocdecMpeg2QMatrix q_matrix;
    uint32_t reserved[4];
} RocdecMpeg2PicParams;

/***********************************************************/
//! \struct RocdecVc1PicParams placeholder
//! \ingroup group_amd_rocdecode
//! JPEG picture parameters
//! This structure is used in RocdecVc1PicParams structure
/***********************************************************/
typedef struct _RocdecVc1PicParams {
    int reserved;
} RocdecVc1PicParams;

/***********************************************************/
//! \struct RocdecAvcPicParams
//! \ingroup group_amd_rocdecode
//! AVC picture parameters
//! This structure is used in RocdecAvcPicParams structure
//! This structure is configured to be the same as VA-API VAPictureParameterBufferH264 structure
/***********************************************************/
typedef struct _RocdecAvcPicParams {
    RocdecAvcPicture curr_pic;
    RocdecAvcPicture ref_frames[16]; /* in DPB */
    uint16_t picture_width_in_mbs_minus1;
    uint16_t picture_height_in_mbs_minus1;
    uint8_t bit_depth_luma_minus8;
    uint8_t bit_depth_chroma_minus8;
    uint8_t num_ref_frames;
    union {
        struct {
            uint32_t chroma_format_idc : 2;
            uint32_t residual_colour_transform_flag : 1;
            uint32_t gaps_in_frame_num_value_allowed_flag : 1;
            uint32_t frame_mbs_only_flag : 1;
            uint32_t mb_adaptive_frame_field_flag : 1;
            uint32_t direct_8x8_inference_flag : 1;
            uint32_t MinLumaBiPredSize8x8 : 1; /* see A.3.3.2 */
            uint32_t log2_max_frame_num_minus4 : 4;
            uint32_t pic_order_cnt_type : 2;
            uint32_t log2_max_pic_order_cnt_lsb_minus4 : 4;
            uint32_t delta_pic_order_always_zero_flag : 1;
        } bits;
        uint32_t value;
    } seq_fields;

    // FMO/ASO
    uint8_t num_slice_groups_minus1;
    uint8_t slice_group_map_type;
    uint16_t slice_group_change_rate_minus1;
    int8_t pic_init_qp_minus26;
    int8_t pic_init_qs_minus26;
    int8_t chroma_qp_index_offset;
    int8_t second_chroma_qp_index_offset;
    union {
        struct {
            uint32_t entropy_coding_mode_flag : 1;
            uint32_t weighted_pred_flag : 1;
            uint32_t weighted_bipred_idc : 2;
            uint32_t transform_8x8_mode_flag : 1;
            uint32_t field_pic_flag : 1;
            uint32_t constrained_intra_pred_flag : 1;
            uint32_t pic_order_present_flag : 1;
            uint32_t deblocking_filter_control_present_flag : 1;
            uint32_t redundant_pic_cnt_present_flag : 1;
            uint32_t reference_pic_flag : 1; /* nal_ref_idc != 0 */
        } bits;
        uint32_t value;
    } pic_fields;
    uint16_t frame_num;

    uint32_t reserved[8];
} RocdecAvcPicParams;

/***********************************************************/
//! \struct RocdecAvcSliceParams
//! \ingroup group_amd_rocdecode
//! AVC slice parameter buffer
//! This structure is configured to be the same as VA-API VASliceParameterBufferH264 structure
/***********************************************************/
typedef struct _RocdecAvcSliceParams {
    uint32_t slice_data_size;   // slice size in bytes
    uint32_t slice_data_offset; // byte offset of the current slice in the slice data buffer
    uint32_t slice_data_flag;   /* see VA_SLICE_DATA_FLAG_XXX defintions */
    /**
     * \brief Bit offset from NAL Header Unit to the begining of slice_data().
     *
     * This bit offset is relative to and includes the NAL unit byte
     * and represents the number of bits parsed in the slice_header()
     * after the removal of any emulation prevention bytes in
     * there. However, the slice data buffer passed to the hardware is
     * the original bitstream, thus including any emulation prevention
     * bytes.
     */
    uint16_t slice_data_bit_offset;
    uint16_t first_mb_in_slice;
    uint8_t slice_type;
    uint8_t direct_spatial_mv_pred_flag;
    uint8_t num_ref_idx_l0_active_minus1;
    uint8_t num_ref_idx_l1_active_minus1;
    uint8_t cabac_init_idc;
    int8_t slice_qp_delta;
    uint8_t disable_deblocking_filter_idc;
    int8_t slice_alpha_c0_offset_div2;
    int8_t slice_beta_offset_div2;
    RocdecAvcPicture ref_pic_list_0[32]; // 8.2.4.2
    RocdecAvcPicture ref_pic_list_1[32]; // 8.2.4.2
    uint8_t luma_log2_weight_denom;
    uint8_t chroma_log2_weight_denom;
    uint8_t luma_weight_l0_flag;
    int16_t luma_weight_l0[32];
    int16_t luma_offset_l0[32];
    uint8_t chroma_weight_l0_flag;
    int16_t chroma_weight_l0[32][2];
    int16_t chroma_offset_l0[32][2];
    uint8_t luma_weight_l1_flag;
    int16_t luma_weight_l1[32];
    int16_t luma_offset_l1[32];
    uint8_t chroma_weight_l1_flag;
    int16_t chroma_weight_l1[32][2];
    int16_t chroma_offset_l1[32][2];
    uint32_t reserved[4];
} RocdecAvcSliceParams;

/***********************************************************/
//! \struct RocdecAvcIQMatrix
//! \ingroup group_amd_rocdecode
//! AVC Inverse Quantization Matrix
//! This structure is configured to be the same as VA-API VAIQMatrixBufferH264 structure
/***********************************************************/
typedef struct _RocdecAvcIQMatrix {
    /** \brief 4x4 scaling list, in raster scan order. */
    uint8_t scaling_list_4x4[6][16];
    /** \brief 8x8 scaling list, in raster scan order. */
    uint8_t scaling_list_8x8[2][64];
    /** \brief Reserved bytes for future use, must be zero */
    uint32_t reserved[4];
} RocdecAvcIQMatrix;

/***********************************************************/
//! \struct RocdecHevcPicParams
//! \ingroup group_amd_rocdecode
//! HEVC picture parameters
//! This structure is used in RocdecHevcPicParams structure
/***********************************************************/
typedef struct _RocdecHevcPicParams {
    RocdecHevcPicture curr_pic;
    RocdecHevcPicture ref_frames[15]; /* reference frame list in DPB */
    uint16_t picture_width_in_luma_samples;
    uint16_t picture_height_in_luma_samples;
    union {
        struct {
            /** following flags have same syntax and semantic as those in HEVC spec */
            uint32_t chroma_format_idc : 2;
            uint32_t separate_colour_plane_flag : 1;
            uint32_t pcm_enabled_flag : 1;
            uint32_t scaling_list_enabled_flag : 1;
            uint32_t transform_skip_enabled_flag : 1;
            uint32_t amp_enabled_flag : 1;
            uint32_t strong_intra_smoothing_enabled_flag : 1;
            uint32_t sign_data_hiding_enabled_flag : 1;
            uint32_t constrained_intra_pred_flag : 1;
            uint32_t cu_qp_delta_enabled_flag : 1;
            uint32_t weighted_pred_flag : 1;
            uint32_t weighted_bipred_flag : 1;
            uint32_t transquant_bypass_enabled_flag : 1;
            uint32_t tiles_enabled_flag : 1;
            uint32_t entropy_coding_sync_enabled_flag : 1;
            uint32_t pps_loop_filter_across_slices_enabled_flag : 1;
            uint32_t loop_filter_across_tiles_enabled_flag : 1;
            uint32_t pcm_loop_filter_disabled_flag : 1;
            /** set based on sps_max_num_reorder_pics of current temporal layer. */
            uint32_t no_pic_reordering_flag : 1;
            /** picture has no B slices */
            uint32_t no_bi_pred_flag : 1;
            uint32_t reserved_bits : 11;
        } bits;
        uint32_t value;
    } pic_fields;

    /** SPS fields: the following parameters have same syntax with those in HEVC spec */
    uint8_t sps_max_dec_pic_buffering_minus1; /**< IN: DPB size for current temporal layer */
    uint8_t bit_depth_luma_minus8;
    uint8_t bit_depth_chroma_minus8;
    uint8_t pcm_sample_bit_depth_luma_minus1;
    uint8_t pcm_sample_bit_depth_chroma_minus1;
    uint8_t log2_min_luma_coding_block_size_minus3;
    uint8_t log2_diff_max_min_luma_coding_block_size;
    uint8_t log2_min_luma_transform_block_size_minus2;
    uint8_t log2_diff_max_min_luma_transform_block_size;
    uint8_t log2_min_pcm_luma_coding_block_size_minus3;
    uint8_t log2_diff_max_min_pcm_luma_coding_block_size;
    uint8_t max_transform_hierarchy_depth_intra;
    uint8_t max_transform_hierarchy_depth_inter;
    int8_t init_qp_minus26;
    uint8_t diff_cu_qp_delta_depth;
    int8_t pps_cb_qp_offset;
    int8_t pps_cr_qp_offset;
    uint8_t log2_parallel_merge_level_minus2;
    uint8_t num_tile_columns_minus1;
    uint8_t num_tile_rows_minus1;
    /**
     * when uniform_spacing_flag equals 1, application should populate
     * column_width_minus[], and row_height_minus1[] with approperiate values.
     */
    uint16_t column_width_minus1[19];
    uint16_t row_height_minus1[21];

    union {
        struct {
            /** following parameters have same syntax with those in HEVC spec */
            uint32_t lists_modification_present_flag : 1;
            uint32_t long_term_ref_pics_present_flag : 1;
            uint32_t sps_temporal_mvp_enabled_flag : 1;
            uint32_t cabac_init_present_flag : 1;
            uint32_t output_flag_present_flag : 1;
            uint32_t dependent_slice_segments_enabled_flag : 1;
            uint32_t pps_slice_chroma_qp_offsets_present_flag : 1;
            uint32_t sample_adaptive_offset_enabled_flag : 1;
            uint32_t deblocking_filter_override_enabled_flag : 1;
            uint32_t pps_disable_deblocking_filter_flag : 1;
            uint32_t slice_segment_header_extension_present_flag : 1;

            /** current picture with NUT between 16 and 21 inclusive */
            uint32_t rap_pic_flag : 1;
            /** current picture with NUT between 19 and 20 inclusive */
            uint32_t idr_pic_flag : 1;
            /** current picture has only intra slices */
            uint32_t intra_pic_flag : 1;

            uint32_t reserved_bits : 18;
        } bits;
        uint32_t value;
    } slice_parsing_fields;

    /** following parameters have same syntax with those in HEVC spec */
    uint8_t log2_max_pic_order_cnt_lsb_minus4;
    uint8_t num_short_term_ref_pic_sets;
    uint8_t num_long_term_ref_pic_sps;
    uint8_t num_ref_idx_l0_default_active_minus1;
    uint8_t num_ref_idx_l1_default_active_minus1;
    int8_t pps_beta_offset_div2;
    int8_t pps_tc_offset_div2;
    uint8_t num_extra_slice_header_bits;
    /**
     * \brief number of bits that structure
     * short_term_ref_pic_set( num_short_term_ref_pic_sets ) takes in slice
     * segment header when short_term_ref_pic_set_sps_flag equals 0.
     * if short_term_ref_pic_set_sps_flag equals 1, the value should be 0.
     * the bit count is calculated after emulation prevention bytes are removed
     * from bit streams.
     * This variable is used for accelorater to skip parsing the
     * short_term_ref_pic_set( num_short_term_ref_pic_sets ) structure.
     */
    uint32_t st_rps_bits;
    uint32_t reserved[8];
} RocdecHevcPicParams;

/***********************************************************/
//! \struct RocdecHevcSliceParams
//! \ingroup group_amd_rocdecode
//! HEVC slice parameters
//! This structure is used in RocdecPicParams structure
/***********************************************************/
typedef struct _RocdecHevcSliceParams {
    /** \brief Number of bytes in the slice data buffer for this slice
     * counting from and including NAL unit header.
     */
    uint32_t slice_data_size;
    /** \brief The offset to the NAL unit header for this slice */
    uint32_t slice_data_offset;
    /** \brief Slice data buffer flags. See \c VA_SLICE_DATA_FLAG_XXX. */
    uint32_t slice_data_flag;
    /**
     * \brief Byte offset from NAL unit header to the begining of slice_data().
     *
     * This byte offset is relative to and includes the NAL unit header
     * and represents the number of bytes parsed in the slice_header()
     * after the removal of any emulation prevention bytes in
     * there. However, the slice data buffer passed to the hardware is
     * the original bitstream, thus including any emulation prevention
     * bytes.
     */
    uint32_t slice_data_byte_offset;
    /** HEVC syntax element. */
    uint32_t slice_segment_address;
    /** \brief index into ReferenceFrames[]
     * ref_pic_list[0][] corresponds to RefPicList0[] of HEVC variable.
     * ref_pic_list[1][] corresponds to RefPicList1[] of HEVC variable.
     * value range [0..14, 0xFF], where 0xFF indicates invalid entry.
     */
    uint8_t ref_pic_list[2][15];
    union {
        uint32_t value;
        struct {
            /** current slice is last slice of picture. */
            uint32_t last_slice_of_pic : 1;
            /** HEVC syntax element. */
            uint32_t dependent_slice_segment_flag : 1;
            uint32_t slice_type : 2;
            uint32_t color_plane_id : 2;
            uint32_t slice_sao_luma_flag : 1;
            uint32_t slice_sao_chroma_flag : 1;
            uint32_t mvd_l1_zero_flag : 1;
            uint32_t cabac_init_flag : 1;
            uint32_t slice_temporal_mvp_enabled_flag : 1;
            uint32_t slice_deblocking_filter_disabled_flag : 1;
            uint32_t collocated_from_l0_flag : 1;
            uint32_t slice_loop_filter_across_slices_enabled_flag : 1;
            uint32_t reserved : 18;
        } fields;
    } long_slice_flags;

    /** HEVC syntax element. */
    uint8_t collocated_ref_idx;
    uint8_t num_ref_idx_l0_active_minus1;
    uint8_t num_ref_idx_l1_active_minus1;
    int8_t slice_qp_delta;
    int8_t slice_cb_qp_offset;
    int8_t slice_cr_qp_offset;
    int8_t slice_beta_offset_div2;
    int8_t slice_tc_offset_div2;
    uint8_t luma_log2_weight_denom;
    int8_t delta_chroma_log2_weight_denom;
    int8_t delta_luma_weight_l0[15];
    int8_t luma_offset_l0[15];
    int8_t delta_chroma_weight_l0[15][2];
    /** corresponds to HEVC spec variable of the same name. */
    int8_t chroma_offset_l0[15][2];
    /** HEVC syntax element. */
    int8_t delta_luma_weight_l1[15];
    int8_t luma_offset_l1[15];
    int8_t delta_chroma_weight_l1[15][2];
    /** corresponds to HEVC spec variable of the same name. */
    int8_t chroma_offset_l1[15][2];
    /** HEVC syntax element. */
    uint8_t five_minus_max_num_merge_cand;
    uint16_t num_entry_point_offsets;
    uint16_t entry_offset_to_subset_array;
    /** \brief Number of emulation prevention bytes in slice header. */
    uint16_t slice_data_num_emu_prevn_bytes;

    uint32_t reserved[2];
} RocdecHevcSliceParams;

/***********************************************************/
//! \struct RocdecHevcIQMatrix
//! \ingroup group_amd_rocdecode
//! HEVC IQMatrix
//! This structure is sent once per frame,
//! and only when scaling_list_enabled_flag = 1.
//! When sps_scaling_list_data_present_flag = 0, app still
//! needs to send in this structure with default matrix values.
//! This structure is used in RocdecHevcQMatrix structure
/***********************************************************/
typedef struct _RocdecHevcIQMatrix {
    /**
     * \brief 4x4 scaling,
     * correspongs i = 0, MatrixID is in the range of 0 to 5,
     * inclusive. And j is in the range of 0 to 15, inclusive.
     */
    uint8_t scaling_list_4x4[6][16];
    /**
     * \brief 8x8 scaling,
     * correspongs i = 1, MatrixID is in the range of 0 to 5,
     * inclusive. And j is in the range of 0 to 63, inclusive.
     */
    uint8_t scaling_list_8x8[6][64];
    /**
     * \brief 16x16 scaling,
     * correspongs i = 2, MatrixID is in the range of 0 to 5,
     * inclusive. And j is in the range of 0 to 63, inclusive.
     */
    uint8_t scaling_list_16x16[6][64];
    /**
     * \brief 32x32 scaling,
     * correspongs i = 3, MatrixID is in the range of 0 to 1,
     * inclusive. And j is in the range of 0 to 63, inclusive.
     */
    uint8_t scaling_list_32x32[2][64];
    /**
     * \brief DC values of the 16x16 scaling lists,
     * corresponds to HEVC spec syntax
     * scaling_list_dc_coef_minus8[ sizeID - 2 ][ matrixID ] + 8
     * with sizeID = 2 and matrixID in the range of 0 to 5, inclusive.
     */
    uint8_t scaling_list_dc_16x16[6];
    /**
     * \brief DC values of the 32x32 scaling lists,
     * corresponds to HEVC spec syntax
     * scaling_list_dc_coef_minus8[ sizeID - 2 ][ matrixID ] + 8
     * with sizeID = 3 and matrixID in the range of 0 to 1, inclusive.
     */
    uint8_t scaling_list_dc_32x32[2];
    uint32_t reserved[4];
} RocdecHevcIQMatrix;

/***********************************************************/
//! \struct RocdecVp9PicParams
//! \ingroup group_amd_rocdecode
//! VP9 picture parameters
//! This structure is configured to be the same as VA-API VADecPictureParameterBufferVP9 structure.
/***********************************************************/
typedef struct  _RocdecVp9PicParams {
    /** \brief picture width
     *  Picture original resolution. The value may not be multiple of 8.
     */
    uint16_t frame_width;
    /** \brief picture height
     *  Picture original resolution. The value may not be multiple of 8.
     */
    uint16_t frame_height;

    /** \brief Surface indices of reference frames in DPB.
     *
     *  Each entry of the list specifies the surface index of the picture
     *  that is referred by current picture or will be referred by any future
     *  picture.
     *  Application who calls this API should update this list based on the
     *  refreshing information from VP9 bitstream.
     */
    uint32_t reference_frames[8];

    union {
        struct {
            /** \brief flags for current picture
             *  same syntax and semantic as those in VP9 code
             */
            uint32_t        subsampling_x                               : 1;
            uint32_t        subsampling_y                               : 1;
            uint32_t        frame_type                                  : 1;
            uint32_t        show_frame                                  : 1;
            uint32_t        error_resilient_mode                        : 1;
            uint32_t        intra_only                                  : 1;
            uint32_t        allow_high_precision_mv                     : 1;
            uint32_t        mcomp_filter_type                           : 3;
            uint32_t        frame_parallel_decoding_mode                : 1;
            uint32_t        reset_frame_context                         : 2;
            uint32_t        refresh_frame_context                       : 1;
            uint32_t        frame_context_idx                           : 2;
            uint32_t        segmentation_enabled                        : 1;

            /** \brief corresponds to variable temporal_update in VP9 code.
             */
            uint32_t segmentation_temporal_update                : 1;
            /** \brief corresponds to variable update_mb_segmentation_map
             *  in VP9 code.
             */
            uint32_t segmentation_update_map                     : 1;

            /** \brief Index of reference_frames[] and points to the
             *  LAST reference frame.
             *  It corresponds to active_ref_idx[0] in VP9 code.
             */
            uint32_t last_ref_frame                              : 3;
            /** \brief Sign Bias of the LAST reference frame.
             *  It corresponds to ref_frame_sign_bias[LAST_FRAME] in VP9 code.
             */
            uint32_t last_ref_frame_sign_bias                    : 1;
            /** \brief Index of reference_frames[] and points to the
             *  GOLDERN reference frame.
             *  It corresponds to active_ref_idx[1] in VP9 code.
             */
            uint32_t golden_ref_frame                            : 3;
            /** \brief Sign Bias of the GOLDERN reference frame.
             *  Corresponds to ref_frame_sign_bias[GOLDERN_FRAME] in VP9 code.
             */
            uint32_t golden_ref_frame_sign_bias                  : 1;
            /** \brief Index of reference_frames[] and points to the
             *  ALTERNATE reference frame.
             *  Corresponds to active_ref_idx[2] in VP9 code.
             */
            uint32_t alt_ref_frame                               : 3;
            /** \brief Sign Bias of the ALTERNATE reference frame.
             *  Corresponds to ref_frame_sign_bias[ALTREF_FRAME] in VP9 code.
             */
            uint32_t alt_ref_frame_sign_bias                     : 1;
            /** \brief Lossless Mode
             *  LosslessFlag = base_qindex == 0 &&
             *                 y_dc_delta_q == 0 &&
             *                 uv_dc_delta_q == 0 &&
             *                 uv_ac_delta_q == 0;
             *  Where base_qindex, y_dc_delta_q, uv_dc_delta_q and uv_ac_delta_q
             *  are all variables in VP9 code.
             */
            uint32_t  lossless_flag                               : 1;
        } bits;
        uint32_t value;
    } pic_fields;

    /* following parameters have same syntax with those in VP9 code */
    uint8_t filter_level;
    uint8_t sharpness_level;

    /** \brief number of tile rows specified by (1 << log2_tile_rows).
     *  It corresponds the variable with same name in VP9 code.
     */
    uint8_t log2_tile_rows;
    /** \brief number of tile columns specified by (1 << log2_tile_columns).
     *  It corresponds the variable with same name in VP9 code.
     */
    uint8_t log2_tile_columns;
    /** \brief Number of bytes taken up by the uncompressed frame header,
     *  which corresponds to byte length of function
     *  read_uncompressed_header() in VP9 code.
     *  Specifically, it is the byte count from bit stream buffer start to
     *  the last byte of uncompressed frame header.
     *  If there are other meta data in the buffer before uncompressed header,
     *  its size should be also included here.
     */
    uint8_t frame_header_length_in_bytes;

    /** \brief The byte count of compressed header the bitstream buffer,
     *  which corresponds to syntax first_partition_size in code.
     */
    uint16_t first_partition_size;

    /** These values are segment probabilities with same names in VP9
     *  function setup_segmentation(). They should be parsed directly from
     *  bitstream by application.
     */
    uint8_t mb_segment_tree_probs[7];
    uint8_t segment_pred_probs[3];

    /** \brief VP9 Profile definition
     *  value range [0..3].
      */
    uint8_t profile;

    /** \brief VP9 bit depth per sample
     *  same for both luma and chroma samples.
     */
    uint8_t bit_depth;

    /** \brief Reserved bytes for future use, must be zero */
    uint32_t va_reserved[8];

} RocdecVp9PicParams;

/**
 * \brief VP9 Segmentation Parameter Data Structure
 * This structure is configured to be the same as VA-API VASegmentParameterVP9 structure.
 */
typedef struct  _RocdecVp9SegmentParameter {
    union {
        struct {
            /** \brief Indicates if per segment reference frame indicator
             *  is enabled.
             *  Corresponding to variable feature_enabled when
             *  j == SEG_LVL_REF_FRAME in function setup_segmentation() VP9 code.
             */
            uint16_t segment_reference_enabled                   : 1;
            /** \brief Specifies per segment reference indication.
             *  0: reserved
             *  1: Last ref
             *  2: golden
             *  3: altref
             *  Value can be derived from variable data when
             *  j == SEG_LVL_REF_FRAME in function setup_segmentation() VP9 code.
             */
            uint16_t segment_reference                           : 2;
            /** \brief Indicates if per segment skip feature is enabled.
             *  Corresponding to variable feature_enabled when
             *  j == SEG_LVL_SKIP in function setup_segmentation() VP9 code.
             */
            uint16_t segment_reference_skipped                   : 1;
        } fields;
        uint16_t value;
    } segment_flags;

    /** \brief Specifies the filter level information per segment.
     *  The value corresponds to variable lfi->lvl[seg][ref][mode] in VP9 code,
     *  where m is [ref], and n is [mode] in FilterLevel[m][n].
     */
    uint8_t filter_level[4][2];
    /** \brief Specifies per segment Luma AC quantization scale.
     *  Corresponding to y_dequant[qindex][1] in vp9_mb_init_quantizer()
     *  function of VP9 code.
     */
    int16_t luma_ac_quant_scale;
    /** \brief Specifies per segment Luma DC quantization scale.
     *  Corresponding to y_dequant[qindex][0] in vp9_mb_init_quantizer()
     *  function of VP9 code.
     */
    int16_t luma_dc_quant_scale;
    /** \brief Specifies per segment Chroma AC quantization scale.
     *  Corresponding to uv_dequant[qindex][1] in vp9_mb_init_quantizer()
     *  function of VP9 code.
     */
    int16_t chroma_ac_quant_scale;
    /** \brief Specifies per segment Chroma DC quantization scale.
     *  Corresponding to uv_dequant[qindex][0] in vp9_mb_init_quantizer()
     *  function of VP9 code.
     */
    int16_t chroma_dc_quant_scale;

    /** \brief Reserved bytes for future use, must be zero */
    uint32_t va_reserved[4];

} RocdecVp9SegmentParameter;

/***********************************************************/
//! \struct RocdecVp9SliceParams
//! \ingroup group_amd_rocdecode
//! VP9 slice parameter buffer
//! This structure is configured to be the same as VA-API VASliceParameterBufferVP9 structure.
/***********************************************************/
typedef struct _RocdecVp9SliceParams {
    /** \brief The byte count of current frame in the bitstream buffer,
     *  starting from first byte of the buffer.
     *  It uses the name slice_data_size to be consitent with other codec,
     *  but actually means frame_data_size.
     */
    uint32_t slice_data_size;
    /**
     * offset to the first byte of partition data (control partition)
     */
    uint32_t slice_data_offset;
    /**
     * see VA_SLICE_DATA_FLAG_XXX definitions
     */
    uint32_t slice_data_flag;

    /**
     * \brief per segment information
     */
    RocdecVp9SegmentParameter seg_param[8];

    /** \brief Reserved bytes for future use, must be zero */
    uint32_t va_reserved[4];

} RocdecVp9SliceParams;

/** \brief Segmentation Information for AV1
 */
typedef struct _RocdecAv1SegmentationStruct {
    union {
        struct {
            /** Indicates whether segmentation map related syntax elements
             *  are present or not for current frame. If equal to 0,
             *  the segmentation map related syntax elements are
             *  not present for the current frame and the control flags of
             *  segmentation map related tables feature_data[][], and
             *  feature_mask[] are not valid and shall be ignored by accelerator.
             */
            uint32_t enabled : 1;
            /** Value 1 indicates that the segmentation map are updated
             *  during the decoding of this frame.
             *  Value 0 means that the segmentation map from the previous
             *  frame is used.
             */
            uint32_t update_map : 1;
            /** Value 1 indicates that the updates to the segmentation map
             *  are coded relative to the existing segmentation map.
             *  Value 0 indicates that the new segmentation map is coded
             *  without reference to the existing segmentation map.
             */
            uint32_t temporal_update : 1;
            /** Value 1 indicates that new parameters are about to be
             *  specified for each segment.
             *  Value 0 indicates that the segmentation parameters
             *  should keep their existing values.
             */
            uint32_t update_data : 1;

            /** \brief Reserved bytes for future use, must be zero */
            uint32_t reserved : 28;
        } bits;
        uint32_t value;
    } segment_info_fields;

    /** \brief Segmentation parameters for current frame.
     *  feature_data[segment_id][feature_id]
     *  where segment_id has value range [0..7] indicating the segment id.
     *  and feature_id is defined as
        typedef enum {
            SEG_LVL_ALT_Q,       // Use alternate Quantizer ....
            SEG_LVL_ALT_LF_Y_V,  // Use alternate loop filter value on y plane vertical
            SEG_LVL_ALT_LF_Y_H,  // Use alternate loop filter value on y plane horizontal
            SEG_LVL_ALT_LF_U,    // Use alternate loop filter value on u plane
            SEG_LVL_ALT_LF_V,    // Use alternate loop filter value on v plane
            SEG_LVL_REF_FRAME,   // Optional Segment reference frame
            SEG_LVL_SKIP,        // Optional Segment (0,0) + skip mode
            SEG_LVL_GLOBALMV,
            SEG_LVL_MAX
        } SEG_LVL_FEATURES;
        *  feature_data[][] is equivalent to variable FeatureData[][] in spec,
        *  which is after clip3() operation.
        *  Clip3(x, y, z) = (z < x)? x : ((z > y)? y : z);
        *  The limit is defined in Segmentation_Feature_Max[ SEG_LVL_MAX ] = {
        *  255, MAX_LOOP_FILTER, MAX_LOOP_FILTER, MAX_LOOP_FILTER, MAX_LOOP_FILTER, 7, 0, 0 }
        */
    int16_t feature_data[8][8];

    /** \brief indicates if a feature is enabled or not.
     *  Each bit field itself is the feature_id. Index is segment_id.
     *  feature_mask[segment_id] & (1 << feature_id) equal to 1 specify that the feature of
     *  feature_id for segment of segment_id is enabled, otherwise disabled.
     */
    uint8_t feature_mask[8];

    /** \brief Reserved bytes for future use, must be zero */
    uint32_t reserved[4];
} RocdecAv1SegmentationStruct;

/** \brief Film Grain Information for AV1
 */
typedef struct _RocdecAv1FilmGrainStruct {
    union {
        struct {
            /** \brief Specify whether or not film grain is applied on current frame.
             *  If set to 0, all the rest parameters should be set to zero
             *  and ignored.
             */
            uint32_t apply_grain : 1;
            uint32_t chroma_scaling_from_luma : 1;
            uint32_t grain_scaling_minus_8 : 2;
            uint32_t ar_coeff_lag : 2;
            uint32_t ar_coeff_shift_minus_6 : 2;
            uint32_t grain_scale_shift : 2;
            uint32_t overlap_flag : 1;
            uint32_t clip_to_restricted_range : 1;
            /** \brief Reserved bytes for future use, must be zero */
            uint32_t reserved : 20;
        } bits;
        uint32_t value;
    } film_grain_info_fields;

    uint16_t grain_seed;
    /*  value range [0..14] */
    uint8_t num_y_points;
    uint8_t point_y_value[14];
    uint8_t point_y_scaling[14];
    /*  value range [0..10] */
    uint8_t num_cb_points;
    uint8_t point_cb_value[10];
    uint8_t point_cb_scaling[10];
    /*  value range [0..10] */
    uint8_t num_cr_points;
    uint8_t point_cr_value[10];
    uint8_t point_cr_scaling[10];
    /*  value range [-128..127] */
    int8_t ar_coeffs_y[24];
    int8_t ar_coeffs_cb[25];
    int8_t ar_coeffs_cr[25];
    uint8_t cb_mult;
    uint8_t cb_luma_mult;
    uint16_t cb_offset;
    uint8_t cr_mult;
    uint8_t cr_luma_mult;
    uint16_t cr_offset;

    /** \brief Reserved bytes for future use, must be zero */
    uint32_t reserved[4];
} RocdecAv1FilmGrainStruct;

typedef enum {
    /** identity transformation, 0-parameter */
    RocdecAv1TransformationIdentity = 0,
    /** translational motion, 2-parameter */
    RocdecAv1TransformationTranslation = 1,
    /** simplified affine with rotation + zoom only, 4-parameter */
    RocdecAv1TransformationRotzoom = 2,
    /** affine, 6-parameter */
    RocdecAv1TransformationAffine = 3,
    /** transformation count */
    RocdecAv1TransformationCount
} RocdecAv1TransformationType;

typedef struct _RocdecAv1WarpedMotionParams {
    /** \brief Specify the type of warped motion */
    RocdecAv1TransformationType wmtype;

    /** \brief Specify warp motion parameters
     *  wm.wmmat[] corresponds to gm_params[][] in spec.
     *  Details in AV1 spec section 5.9.24 or refer to libaom code
     *  https://aomedia.googlesource.com/aom/+/refs/heads/master/av1/decoder/decodeframe.c
     */
    int32_t wmmat[8];

    /* valid or invalid on affine set */
    uint8_t invalid;

    /** \brief Reserved bytes for future use, must be zero */
    uint32_t reserved[4];
} RocdecAv1WarpedMotionParams;

/***********************************************************/
//! \struct RocdecAv1PicParams
//! \ingroup group_amd_rocdecode
//! AV1 picture parameters
//! This structure is used in RocdecAv1PicParams structure
/***********************************************************/
typedef struct _RocdecAV1PicParams {
    /** \brief sequence level information
     */

    /** \brief AV1 bit stream profile
     */
    uint8_t profile;

    uint8_t order_hint_bits_minus_1;

    /** \brief bit depth index
     *  value range [0..2]
     *  0 - bit depth 8;
     *  1 - bit depth 10;
     *  2 - bit depth 12;
     */
    uint8_t bit_depth_idx;

    /** \brief corresponds to AV1 spec variable of the same name. */
    uint8_t matrix_coefficients;

    union {
        struct {
            uint32_t still_picture : 1;
            uint32_t use_128x128_superblock : 1;
            uint32_t enable_filter_intra : 1;
            uint32_t enable_intra_edge_filter : 1;

            /** read_compound_tools */
            uint32_t enable_interintra_compound : 1;
            uint32_t enable_masked_compound : 1;

            uint32_t enable_dual_filter : 1;
            uint32_t enable_order_hint : 1;
            uint32_t enable_jnt_comp : 1;
            uint32_t enable_cdef : 1;
            uint32_t mono_chrome : 1;
            uint32_t color_range : 1;
            uint32_t subsampling_x : 1;
            uint32_t subsampling_y : 1;
            uint32_t chroma_sample_position : 1;
            uint32_t film_grain_params_present : 1;
            /** \brief Reserved bytes for future use, must be zero */
            uint32_t reserved : 16;
        } fields;
        uint32_t value;
    } seq_info_fields;

    /** \brief Picture level information
     */

    /** \brief buffer description of decoded current picture
     */
    int current_frame;

    /** \brief display buffer of current picture
     *  Used for film grain applied decoded picture.
     *  Valid only when apply_grain equals 1.
     */
    int current_display_picture;

    /** \brief number of anchor frames for large scale tile
     *  This parameter gives the number of entries of anchor_frames_list[].
     *  Value range [0..128].
     */
    uint8_t anchor_frames_num;

    /** \brief anchor frame list for large scale tile
     *  For large scale tile applications, the anchor frames could come from
     *  previously decoded frames in current sequence (aka. internal), or
     *  from external sources.
     *  For external anchor frames, application should call API
     *  vaCreateBuffer() to generate frame buffers and populate them with
     *  pixel frames. And this process may happen multiple times.
     *  The array anchor_frames_list[] is used to register all the available
     *  anchor frames from both external and internal, up to the current
     *  frame instance. If a previously registerred anchor frame is no longer
     *  needed, it should be removed from the list. But it does not prevent
     *  applications from relacing the frame buffer with new anchor frames.
     *  Please note that the internal anchor frames may not still be present
     *  in the current DPB buffer. But if it is in the anchor_frames_list[],
     *  it should not be replaced with other frames or removed from memory
     *  until it is not shown in the list.
     *  This number of entries of the list is given by parameter anchor_frames_num.
     */
    int *anchor_frames_list;

    /** \brief Picture resolution minus 1
     *  Picture original resolution. If SuperRes is enabled,
     *  this is the upscaled resolution.
     *  value range [0..65535]
     */
    uint16_t frame_width_minus1;
    uint16_t frame_height_minus1;

    /** \brief Output frame buffer size in unit of tiles
     *  Valid only when large_scale_tile equals 1.
     *  value range [0..65535]
     */
    uint16_t output_frame_width_in_tiles_minus_1;
    uint16_t output_frame_height_in_tiles_minus_1;

    /** \brief Surface indices of reference frames in DPB.
     *
     *  Contains a list of uncompressed frame buffer surface indices as references.
     *  Application needs to make sure all the entries point to valid frames
     *  except for intra frames by checking ref_frame_id[]. If missing frame
     *  is identified, application may choose to perform error recovery by
     *  pointing problematic index to an alternative frame buffer.
     *  Driver is not responsible to validate reference frames' id.
     */
    int ref_frame_map[8];

    /** \brief Reference frame indices.
     *
     *  Contains a list of indices into ref_frame_map[8].
     *  It specifies the reference frame correspondence.
     *  The indices of the array are defined as [LAST_FRAME – LAST_FRAME,
     *  LAST2_FRAME – LAST_FRAME, …, ALTREF_FRAME – LAST_FRAME], where each
     *  symbol is defined as:
     *  enum{INTRA_FRAME = 0, LAST_FRAME, LAST2_FRAME, LAST3_FRAME, GOLDEN_FRAME,
     *  BWDREF_FRAME, ALTREF2_FRAME, ALTREF_FRAME};
     */
    uint8_t ref_frame_idx[7];

    /** \brief primary reference frame index
     *  Index into ref_frame_idx[], specifying which reference frame contains
     *  propagated info that should be loaded at the start of the frame.
     *  When value equals PRIMARY_REF_NONE (7), it indicates there is
     *  no primary reference frame.
     *  value range [0..7]
     */
    uint8_t primary_ref_frame;
    uint8_t order_hint;

    RocdecAv1SegmentationStruct seg_info;
    RocdecAv1FilmGrainStruct film_grain_info;

    /** \brief tile structure
     *  When uniform_tile_spacing_flag == 1, width_in_sbs_minus_1[] and
     *  height_in_sbs_minus_1[] should be ignored, which will be generated
     *  by driver based on tile_cols and tile_rows.
     */
    uint8_t tile_cols;
    uint8_t tile_rows;

    /* The width/height of a tile minus 1 in units of superblocks. Though the
        * maximum number of tiles is 64, since ones of the last tile are computed
        * from ones of the other tiles and frame_width/height, they are not
        * necessarily specified.
        */
    uint16_t width_in_sbs_minus_1[63];
    uint16_t height_in_sbs_minus_1[63];

    /** \brief number of tiles minus 1 in large scale tile list
     *  Same as AV1 semantic element.
     *  Valid only when large_scale_tiles == 1.
     */
    uint16_t tile_count_minus_1;

    /* specify the tile index for context updating */
    uint16_t context_update_tile_id;

    union {
        /** \brief flags for current picture
         *  same syntax and semantic as those in AV1 code
         */
        struct {
            /** \brief Frame Type:
             *    0:     KEY_FRAME;
             *    1:     INTER_FRAME;
             *    2:     INTRA_ONLY_FRAME;
             *    3:     SWITCH_FRAME
             *  For SWITCH_FRAME, application shall set error_resilient_mode = 1,
             *  refresh_frame_flags, etc. appropriately. And driver will convert it
             *  to INTER_FRAME.
             */
            uint32_t frame_type : 2;
            uint32_t show_frame : 1;
            uint32_t showable_frame : 1;
            uint32_t error_resilient_mode : 1;
            uint32_t disable_cdf_update : 1;
            uint32_t allow_screen_content_tools : 1;
            uint32_t force_integer_mv : 1;
            uint32_t allow_intrabc : 1;
            uint32_t use_superres : 1;
            uint32_t allow_high_precision_mv : 1;
            uint32_t is_motion_mode_switchable : 1;
            uint32_t use_ref_frame_mvs : 1;
            /* disable_frame_end_update_cdf is coded as refresh_frame_context. */
            uint32_t disable_frame_end_update_cdf : 1;
            uint32_t uniform_tile_spacing_flag : 1;
            uint32_t allow_warped_motion : 1;
            /** \brief indicate if current frame in large scale tile mode */
            uint32_t large_scale_tile : 1;

            /** \brief Reserved bytes for future use, must be zero */
            uint32_t reserved : 15;
        } bits;
        uint32_t value;
    } pic_info_fields;

    /** \brief Supper resolution scale denominator.
     *  When use_superres=1, superres_scale_denominator must be in the range [9..16].
     *  When use_superres=0, superres_scale_denominator must be 8.
     */
    uint8_t superres_scale_denominator;

    /** \brief Interpolation filter.
     *  value range [0..4]
     */
    uint8_t interp_filter;

    /** \brief luma loop filter levels.
     *  value range [0..63].
     */
    uint8_t filter_level[2];

    /** \brief chroma loop filter levels.
     *  value range [0..63].
     */
    uint8_t filter_level_u;
    uint8_t filter_level_v;

    union {
        struct {
            /** \brief flags for reference pictures
             *  same syntax and semantic as those in AV1 code
             */
            uint8_t sharpness_level : 3;
            uint8_t mode_ref_delta_enabled : 1;
            uint8_t mode_ref_delta_update : 1;

            /** \brief Reserved bytes for future use, must be zero */
            uint8_t reserved : 3;
        } bits;
        uint8_t value;
    } loop_filter_info_fields;

    /** \brief The adjustment needed for the filter level based on
     *  the chosen reference frame.
     *  value range [-64..63].
     */
    int8_t ref_deltas[8];

    /** \brief The adjustment needed for the filter level based on
     *  the chosen mode.
     *  value range [-64..63].
     */
    int8_t mode_deltas[2];

    /** \brief quantization
     */
    /** \brief Y AC index
     *  value range [0..255]
     */
    uint8_t base_qindex;
    /** \brief Y DC delta from Y AC
     *  value range [-64..63]
     */
    int8_t y_dc_delta_q;
    /** \brief U DC delta from Y AC
     *  value range [-64..63]
     */
    int8_t u_dc_delta_q;
    /** \brief U AC delta from Y AC
     *  value range [-64..63]
     */
    int8_t u_ac_delta_q;
    /** \brief V DC delta from Y AC
     *  value range [-64..63]
     */
    int8_t v_dc_delta_q;
    /** \brief V AC delta from Y AC
     *  value range [-64..63]
     */
    int8_t v_ac_delta_q;

    /** \brief quantization_matrix
     */
    union {
        struct {
            uint16_t using_qmatrix : 1;
            /** \brief qm level
             *  value range [0..15]
             *  Invalid if using_qmatrix equals 0.
             */
            uint16_t qm_y : 4;
            uint16_t qm_u : 4;
            uint16_t qm_v : 4;

            /** \brief Reserved bytes for future use, must be zero */
            uint16_t reserved : 3;
        } bits;
        uint16_t value;
    } qmatrix_fields;

    union {
        struct {
            /** \brief delta_q parameters
             */
            uint32_t delta_q_present_flag : 1;
            uint32_t log2_delta_q_res : 2;

            /** \brief delta_lf parameters
             */
            uint32_t delta_lf_present_flag : 1;
            uint32_t log2_delta_lf_res : 2;

            /** \brief CONFIG_LOOPFILTER_LEVEL
             */
            uint32_t delta_lf_multi : 1;

            /** \brief read_tx_mode
             *  value range [0..2]
             */
            uint32_t tx_mode : 2;

            /* AV1 frame reference mode semantic */
            uint32_t reference_select : 1;

            uint32_t reduced_tx_set_used : 1;

            uint32_t skip_mode_present : 1;

            /** \brief Reserved bytes for future use, must be zero */
            uint32_t reserved : 20;
        } bits;
        uint32_t value;
    } mode_control_fields;

    /** \brief CDEF parameters
     */
    /*  value range [0..3]  */
    uint8_t cdef_damping_minus_3;
    /*  value range [0..3]  */
    uint8_t cdef_bits;

    /** Encode cdef strength:
     *
     * The cdef_y_strengths[] and cdef_uv_strengths[] are expected to be packed
     * with both primary and secondary strength. The secondary strength is
     * given in the lower two bits and the primary strength is given in the next
     * four bits.
     *
     * cdef_y_strengths[] & cdef_uv_strengths[] should be derived as:
     * (cdef_y_strengths[]) = (cdef_y_pri_strength[] << 2) | (cdef_y_sec_strength[] & 0x03)
     * (cdef_uv_strengths[]) = (cdef_uv_pri_strength[] << 2) | (cdef_uv_sec_strength[] & 0x03)
     * In which, cdef_y_pri_strength[]/cdef_y_sec_strength[]/cdef_uv_pri_strength[]/cdef_uv_sec_strength[]
     * are variables defined in AV1 Spec 5.9.19. The cdef_y_strengths[] & cdef_uv_strengths[]
     * are corresponding to LIBAOM variables cm->cdef_strengths[] & cm->cdef_uv_strengths[] respectively.
     */
    /*  value range [0..63]  */
    uint8_t cdef_y_strengths[8];
    /*  value range [0..63]  */
    uint8_t cdef_uv_strengths[8];

    /** \brief loop restoration parameters
     */
    union {
        struct {
            uint16_t yframe_restoration_type : 2;
            uint16_t cbframe_restoration_type : 2;
            uint16_t crframe_restoration_type : 2;
            uint16_t lr_unit_shift : 2;
            uint16_t lr_uv_shift : 1;

            /** \brief Reserved bytes for future use, must be zero */
            uint16_t reserved : 7;
        } bits;
        uint16_t value;
    } loop_restoration_fields;

    /** \brief global motion
     */
    RocdecAv1WarpedMotionParams wm[7];

    /**@}*/

    /** \brief Reserved bytes for future use, must be zero */
    uint32_t reserved[8];
} RocdecAv1PicParams;

/***********************************************************/
//! \struct RocdecAv1SliceParams
//! \ingroup group_amd_rocdecode
//! AV1 slice parameter buffer
//! This structure is configured to be the same as VA-API VASliceParameterBufferAV1 structure.
//! This structure conveys parameters related to bit stream data and should be sent once per tile.
//! It uses the name RocdecAv1SliceParams to be consistent with other codec, but actually means RocdecTileParameterAV1.
//! Slice data buffer of VASliceDataBufferType is used to send the bitstream.
/***********************************************************/
typedef struct _RocdecAv1SliceParams {
    /** \brief The byte count of current tile in the bitstream buffer,
     *  starting from first byte of the buffer.
     *  It uses the name slice_data_size to be consistent with other codec,
     *  but actually means tile_data_size.
     */
    uint32_t slice_data_size;
    /**
     * offset to the first byte of the data buffer.
     */
    uint32_t slice_data_offset;
    /**
     * see VA_SLICE_DATA_FLAG_XXX definitions
     */
    uint32_t slice_data_flag;

    uint16_t tile_row;
    uint16_t tile_column;

    uint16_t  tg_start;
    uint16_t  tg_end;

    /** \brief anchor frame index for large scale tile.
     *  index into an array AnchorFrames of the frames that the tile uses
     *  for prediction.
     *  valid only when large_scale_tile equals 1.
     */
    uint8_t anchor_frame_idx;

    /** \brief tile index in the tile list.
     *  Valid only when large_scale_tile is enabled.
     *  Driver uses this field to decide the tile output location.
     */
    uint16_t tile_idx_in_tile_list;

    /** \brief Reserved bytes for future use, must be zero */
    uint32_t reserved[4];
} RocdecAv1SliceParams;

/******************************************************************************************/
//! \struct _RocdecPicParams
//! \ingroup group_amd_rocdecode
//! Picture parameters for decoding
//! This structure is used in rocDecDecodeFrame API
//! IN  for rocDecDecodeFrame
/******************************************************************************************/
typedef struct _RocdecPicParams {
    int pic_width;         /**< IN: Coded frame width */
    int pic_height;        /**< IN: Coded frame height */
    int curr_pic_idx;      /**< IN: Output index of the current picture */
    int field_pic_flag;    /**< IN: 0=frame picture, 1=field picture */
    int bottom_field_flag; /**< IN: 0=top field, 1=bottom field (ignored if field_pic_flag=0) */
    int second_field;      /**< IN: Second field of a complementary field pair */
    // Bitstream data
    uint32_t bitstream_data_len;   /**< IN: Number of bytes in bitstream data buffer */
    const uint8_t *bitstream_data; /**< IN: Ptr to bitstream data for this picture (slice-layer) */
    uint32_t num_slices;           /**< IN: Number of slices in this picture */

    int ref_pic_flag;      /**< IN: This picture is a reference picture */
    int intra_pic_flag;    /**< IN: This picture is entirely intra coded */
    uint32_t reserved[30]; /**< Reserved for future use */

    // IN: Codec-specific data
    union {
        RocdecMpeg2PicParams mpeg2; /**< Also used for MPEG-1 */
        RocdecAvcPicParams avc;
        RocdecHevcPicParams hevc;
        RocdecVc1PicParams vc1;
        RocdecJPEGPicParams jpeg;
        RocdecVp9PicParams vp9;
        RocdecAv1PicParams av1;
        uint32_t codec_reserved[256];
    } pic_params;

    /*! \brief Variable size array. The user should allocate one slice param struct for each slice.
        */
    union {
        // Todo: Add slice params defines for other codecs.
        RocdecAvcSliceParams *avc;
        RocdecHevcSliceParams *hevc;
        RocdecVp9SliceParams *vp9;
        RocdecAv1SliceParams *av1;
    } slice_params;

    union {
        // Todo: Added IQ matrix defines for other codecs.
        RocdecAvcIQMatrix avc;
        RocdecHevcIQMatrix hevc;
    } iq_matrix;
} RocdecPicParams;

/******************************************************/
//! \struct RocdecProcParams
//! \ingroup group_amd_rocdecode
//! Picture parameters for postprocessing
//! This structure is used in rocDecGetVideoFrame API
/******************************************************/
typedef struct _RocdecProcParams {
    int progressive_frame;      /**< IN: Input is progressive (deinterlace_mode will be ignored) */
    int top_field_first;        /**< IN: Input frame is top field first (1st field is top, 2nd field is bottom) */
    uint32_t reserved_flags[2]; /**< Reserved for future use (set to zero) */

    // The fields below are used for raw YUV input
    uint64_t raw_input_dptr;    /**< IN: Input HIP device ptr for raw YUV extensions */
    uint32_t raw_input_pitch;   /**< IN: pitch in bytes of raw YUV input (should be aligned appropriately) */
    uint32_t raw_input_format;  /**< IN: Input YUV format (rocDecVideoCodec_enum) */
    uint64_t raw_output_dptr;   /**< IN: Output HIP device mem ptr for raw YUV extensions */
    uint32_t raw_output_pitch;  /**< IN: pitch in bytes of raw YUV output (should be aligned appropriately) */
    uint32_t raw_output_format; /**< IN: Output YUV format (rocDecVideoCodec_enum) */
    uint32_t reserved[16];      /**< Reserved for future use (set to zero) */
} RocdecProcParams;

/*****************************************************************************************************/
//! \fn rocDecStatus ROCDECAPI rocDecCreateDecoder(rocDecDecoderHandle *decoder_handle, RocDecoderCreateInfo *decoder_create_info)
//! \ingroup group_amd_rocdecode
//! Create the decoder object based on decoder_create_info. A handle to the created decoder is returned
/*****************************************************************************************************/
extern rocDecStatus ROCDECAPI rocDecCreateDecoder(rocDecDecoderHandle *decoder_handle, RocDecoderCreateInfo *decoder_create_info);

/*****************************************************************************************************/
//! \fn rocDecStatus ROCDECAPI rocDecDestroyDecoder(rocDecDecoderHandle decoder_handle)
//! \ingroup group_amd_rocdecode
//! Destroy the decoder object
/*****************************************************************************************************/
extern rocDecStatus ROCDECAPI rocDecDestroyDecoder(rocDecDecoderHandle decoder_handle);

/**********************************************************************************************************************/
//! \fn rocDecStatus ROCDECAPI rocdecGetDecoderCaps(RocdecDecodeCaps *decode_caps)
//! \ingroup group_amd_rocdecode
//! Queries decode capabilities of AMD's VCN decoder based on codec type, chroma_format and BitDepthMinus8 parameters.
//! 1. Application fills IN parameters codec_type, chroma_format and BitDepthMinus8 of RocdecDecodeCaps structure
//! 2. On calling rocdecGetDecoderCaps, driver fills OUT parameters (for GPU device) if the IN parameters are supported
//!    If IN parameters passed to the driver are not supported by AMD-VCN-HW, then all OUT params are set to 0.
/**********************************************************************************************************************/
extern rocDecStatus ROCDECAPI rocDecGetDecoderCaps(RocdecDecodeCaps *decode_caps);

/*****************************************************************************************************/
//! \fn rocDecStatus ROCDECAPI rocDecDecodeFrame(rocDecDecoderHandle decoder_handle, RocdecPicParams *pic_params)
//! \ingroup group_amd_rocdecode
//! Decodes a single picture
//! Submits the frame for HW decoding
/*****************************************************************************************************/
extern rocDecStatus ROCDECAPI rocDecDecodeFrame(rocDecDecoderHandle decoder_handle, RocdecPicParams *pic_params);

/************************************************************************************************************/
//! \fn rocDecStatus ROCDECAPI rocDecGetDecodeStatus(rocDecDecoderHandle decoder_handle, int pic_idx, RocdecDecodeStatus* decode_status);
//! \ingroup group_amd_rocdecode
//! Get the decode status for frame corresponding to nPicIdx.
//! Please note that this API makes a non-blocking call and returns the status of the frame associated with nPicIdx at the time of the call,
//! without waiting for the decoding to complete. The decode_status->decode_status can be either rocDecodeStatus_Success, indicating that
//! the decoding has been completed, or rocDecodeStatus_InProgress, which means that the decoding is still in progress.
/************************************************************************************************************/
extern rocDecStatus ROCDECAPI rocDecGetDecodeStatus(rocDecDecoderHandle decoder_handle, int pic_idx, RocdecDecodeStatus *decode_status);

/*********************************************************************************************************/
//! \fn rocDecStatus ROCDECAPI rocDecReconfigureDecoder(rocDecDecoderHandle decoder_handle, RocdecReconfigureDecoderInfo *reconfig_params)
//! \ingroup group_amd_rocdecode
//! Used to reuse single decoder for multiple clips. Currently supports resolution change, resize params
//! params, target area params change for same codec. Must be called during RocdecParserParams::pfn_sequence_callback
/*********************************************************************************************************/
extern rocDecStatus ROCDECAPI rocDecReconfigureDecoder(rocDecDecoderHandle decoder_handle, RocdecReconfigureDecoderInfo *reconfig_params);

/************************************************************************************************************************/
//! \fn extern rocDecStatus ROCDECAPI rocDecGetVideoFrame(rocDecDecoderHandle decoder_handle, int pic_idx,
//!                                           uint32_t *dev_mem_ptr, uint32_t *horizontal_pitch,
//!                                           RocdecProcParams *vid_postproc_params);
//! \ingroup group_amd_rocdecode
//! Post-process and map video frame corresponding to pic_idx for use in HIP. Returns HIP device pointer and associated
//! pitch(horizontal stride) of the video frame. Returns device memory pointers and pitch for each plane (Y, U and V) seperately
//! horizontal_pitch is a pointer to an unsigned 32-bit integer array of size 3.
//! Please note that this API is a blocking call. If the video frame associated with the pic_idx is not ready, the call
//! will wait for the decoding to complete before mapping the video frame for use in HIP.
/************************************************************************************************************************/
extern rocDecStatus ROCDECAPI rocDecGetVideoFrame(rocDecDecoderHandle decoder_handle, int pic_idx,
                                                    void *dev_mem_ptr[3], uint32_t *horizontal_pitch,
                                                    RocdecProcParams *vid_postproc_params);

/*****************************************************************************************************/
//! \fn const char* ROCDECAPI rocDecGetErrorName(rocDecStatus rocdec_status)
//! \ingroup group_amd_rocdecode
//! Return name of the specified error code in text form.
/*****************************************************************************************************/
extern const char *ROCDECAPI rocDecGetErrorName(rocDecStatus rocdec_status);

#ifdef  __cplusplus
}
#endif
