/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-rocdecode/checkouts/docs-6.1.1/api/rocdecode.h Source File

/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-rocdecode/checkouts/docs-6.1.1/api/rocdecode.h Source File#

rocDecode: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-rocdecode/checkouts/docs-6.1.1/api/rocdecode.h Source File
api
Go to the documentation of this file.
 /*
 Copyright (c) 2023 - 2024 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"
  
 #if defined(__cplusplus)
 extern "C" {
 #endif // __cplusplus
  
 /*********************************************************************************/
 /*********************************************************************************/
  
 typedef void *rocDecDecoderHandle;
  
 /*********************************************************************************/
 /*********************************************************************************/
 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;
  
 /*********************************************************************************/
 /*********************************************************************************/
 typedef enum rocDecVideoCodec_enum {
     rocDecVideoCodec_MPEG1 = 0,                                       
     rocDecVideoCodec_MPEG2,                                           
     rocDecVideoCodec_MPEG4,                                           
     rocDecVideoCodec_AVC,                                             
     rocDecVideoCodec_HEVC,                                            
     rocDecVideoCodec_AV1,                                             
     rocDecVideoCodec_VP8,                                             
     rocDecVideoCodec_VP9,                                             
     rocDecVideoCodec_JPEG,                                            
     rocDecVideoCodec_NumCodecs,                                       
     // Uncompressed YUV
     rocDecVideoCodec_YUV420 = (('I'<<24)|('Y'<<16)|('U'<<8)|('V')),   
     rocDecVideoCodec_YV12   = (('Y'<<24)|('V'<<16)|('1'<<8)|('2')),   
     rocDecVideoCodec_NV12   = (('N'<<24)|('V'<<16)|('1'<<8)|('2')),   
     rocDecVideoCodec_YUYV   = (('Y'<<24)|('U'<<16)|('Y'<<8)|('V')),   
     rocDecVideoCodec_UYVY   = (('U'<<24)|('Y'<<16)|('V'<<8)|('Y'))    
 } rocDecVideoCodec;
  
 /*********************************************************************************/
 /*********************************************************************************/
 typedef enum rocDecVideoSurfaceFormat_enum {
     rocDecVideoSurfaceFormat_NV12 = 0,          
     rocDecVideoSurfaceFormat_P016 = 1,          
     rocDecVideoSurfaceFormat_YUV444 = 2,        
     rocDecVideoSurfaceFormat_YUV444_16Bit = 3,  
 } rocDecVideoSurfaceFormat;
  
 /**************************************************************************************************************/
 /**************************************************************************************************************/
 typedef enum rocDecVideoChromaFormat_enum {
     rocDecVideoChromaFormat_Monochrome = 0,  
     rocDecVideoChromaFormat_420,           
     rocDecVideoChromaFormat_422,           
     rocDecVideoChromaFormat_444            
 } rocDecVideoChromaFormat;
  
  
 /*************************************************************************/
 /*************************************************************************/
 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;
  
 /**************************************************************************************************************/
 /**************************************************************************************************************/
 typedef struct _RocdecDecodeCaps {
     uint8_t                     device_id;                  
     rocDecVideoCodec            codec_type;                 
     rocDecVideoChromaFormat     chroma_format;              
     uint32_t                    bit_depth_minus_8;          
     uint32_t                    reserved_1[3];              
     uint8_t                     is_supported;               
     uint8_t                     num_decoders;               
     uint16_t                    output_format_mask;         
     uint32_t                    max_width;                  
     uint32_t                    max_height;                 
     uint16_t                    min_width;                  
     uint16_t                    min_height;                 
     uint32_t                    reserved_2[6];              
 } RocdecDecodeCaps;
  
 /**************************************************************************************************************/
 /**************************************************************************************************************/
 typedef struct _RocDecoderCreateInfo {
     uint8_t                     device_id;              
     uint32_t                    width;                  
     uint32_t                    height;                 
     uint32_t                    num_decode_surfaces;    
     rocDecVideoCodec            codec_type;             
     rocDecVideoChromaFormat     chroma_format;          
     uint32_t                    bit_depth_minus_8;      
     uint32_t                    intra_decode_only;      
     uint32_t                    max_width;             
     uint32_t                    max_height;            
     struct {
         int16_t left;
         int16_t top;
         int16_t right;
         int16_t bottom;
     } display_rect;                                    
     rocDecVideoSurfaceFormat    output_format;         
     uint32_t                    target_width;          
     uint32_t                    target_height;         
     uint32_t                    num_output_surfaces;   
     struct {
         int16_t left;
         int16_t top;
         int16_t right;
         int16_t bottom;
     } target_rect;                                     
     uint32_t                    reserved_2[4];         
 } RocDecoderCreateInfo;
  
 /*********************************************************************************************************/
 /*********************************************************************************************************/
 typedef struct _RocdecDecodeStatus {
     rocDecDecodeStatus  decode_status;
     uint32_t            reserved[31];
     void                *p_reserved[8];
 } RocdecDecodeStatus;
  
 /****************************************************/
 /****************************************************/
 typedef struct _RocdecReconfigureDecoderInfo {
     uint32_t width;                 
     uint32_t height;                
     uint32_t target_width;          
     uint32_t target_height;         
     uint32_t num_decode_surfaces;   
     uint32_t reserved_1[12];        
     struct {
         int16_t left;
         int16_t top;
         int16_t right;
         int16_t bottom;
     } display_rect;                 
     struct {
         int16_t left;
         int16_t top;
         int16_t right;
         int16_t bottom;
     } target_rect;                  
     uint32_t reserved_2[11]; 
 } RocdecReconfigureDecoderInfo; 
  
 /*********************************************************/
 /*********************************************************/
 typedef struct _RocdecAvcPicture {
     int         pic_idx;                    
     uint32_t    frame_idx;                  
     uint32_t    flags;                      
     int32_t     top_field_order_cnt;        
     int32_t     bottom_field_order_cnt;     
     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
  
 /*********************************************************/
 /*********************************************************/
 typedef struct _RocdecHevcPicture {
     int pic_idx;                 
  
     int poc;
     uint32_t flags;              
     uint32_t reserved[4];        
 } RocdecHevcPicture;
  
 /* flags in RocdecHevcPicture could be OR of the following */
 #define RocdecHevcPicture_INVALID                 0x00000001
 #define RocdecHevcPicture_FIELD_PIC               0x00000002
 #define RocdecHevcPicture_BOTTOM_FIELD            0x00000004
 #define RocdecHevcPicture_LONG_TERM_REFERENCE     0x00000008
 #define RocdecHevcPicture_RPS_ST_CURR_BEFORE      0x00000010
 #define RocdecHevcPicture_RPS_ST_CURR_AFTER       0x00000020
 #define RocdecHevcPicture_RPS_LT_CURR             0x00000040
  
 /***********************************************************/
 /***********************************************************/
 typedef struct _RocdecJPEGPicParams {
     int reserved;
 } RocdecJPEGPicParams;
  
 /***********************************************************/
 /***********************************************************/
 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;
  
 /***********************************************************/
 /***********************************************************/
 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;
  
 /***********************************************************/
 /***********************************************************/
 typedef struct _RocdecVc1PicParams {
     int reserved;
 } RocdecVc1PicParams;
  
 /***********************************************************/
 /***********************************************************/
 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;
  
 /***********************************************************/
 /***********************************************************/
 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 */
     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;
  
 /***********************************************************/
 /***********************************************************/
 typedef struct _RocdecAvcIQMatrix {
     uint8_t     scaling_list_4x4[6][16];
     uint8_t     scaling_list_8x8[2][64];
  
     uint32_t    reserved[4];
 } RocdecAvcIQMatrix;
  
 /***********************************************************/
 /***********************************************************/
 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 {
             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;
             uint32_t        no_pic_reordering_flag                      : 1;
             uint32_t        no_bi_pred_flag                             : 1;
             uint32_t        reserved_bits                               : 11;
         } bits;
         uint32_t            value;
     } pic_fields;
  
     uint8_t                 sps_max_dec_pic_buffering_minus1;       
     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_transform_block_size_minus2;
     uint8_t                 log2_diff_max_min_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;
     uint16_t                column_width_minus1[19];
     uint16_t                row_height_minus1[21];
  
     union {
         struct {
             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;
  
             uint32_t        rap_pic_flag                                : 1;
             uint32_t        idr_pic_flag                                : 1;
             uint32_t        intra_pic_flag                              : 1;
  
             uint32_t        reserved_bits                               : 18;
         } bits;
         uint32_t            value;
     } slice_parsing_fields;
  
     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;
     uint32_t                st_rps_bits;
  
     uint32_t                reserved[8];
 } RocdecHevcPicParams;
  
 /***********************************************************/
 /***********************************************************/
 typedef struct _RocdecHevcSliceParams {
     uint32_t                slice_data_size;
     uint32_t                slice_data_offset;
     uint32_t                slice_data_flag;
     uint32_t                slice_data_byte_offset;
     uint32_t                slice_segment_address;
     uint8_t                 ref_pic_list[2][15];
     union {
         uint32_t            value;
         struct {
             uint32_t        last_slice_of_pic                           : 1;
             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;
  
     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];
     int8_t                  chroma_offset_l0[15][2];
     int8_t                  delta_luma_weight_l1[15];
     int8_t                  luma_offset_l1[15];
     int8_t                  delta_chroma_weight_l1[15][2];
     int8_t                  chroma_offset_l1[15][2];
     uint8_t                 five_minus_max_num_merge_cand;
     uint16_t                num_entry_point_offsets;
     uint16_t                entry_offset_to_subset_array;
     uint16_t                slice_data_num_emu_prevn_bytes;
  
     uint32_t                reserved[2];
 } RocdecHevcSliceParams;
  
 /***********************************************************/
 /***********************************************************/
 typedef struct _RocdecHevcIQMatrix {
     uint8_t                 scaling_list_4x4[6][16];
     uint8_t                 scaling_list_8x8[6][64];
     uint8_t                 scaling_list_16x16[6][64];
     uint8_t                 scaling_list_32x32[2][64];
     uint8_t                 scaling_list_dc_16x16[6];
     uint8_t                 scaling_list_dc_32x32[2];
  
     uint32_t                reserved[4];
 } RocdecHevcIQMatrix;
  
 /******************************************************************************************/
 /******************************************************************************************/
 typedef struct _RocdecPicParams {
     int             pic_width;                         
     int             pic_height;                        
     int             curr_pic_idx;                      
     int             field_pic_flag;                    
     int             bottom_field_flag;                 
     int             second_field;                      
     // Bitstream data
     uint32_t        bitstream_data_len;                
     const uint8_t   *bitstream_data;                   
     uint32_t        num_slices;                        
     int             ref_pic_flag;                      
     int             intra_pic_flag;                    
     uint32_t        reserved[30];                      
     // IN: Codec-specific data
     union {
         RocdecMpeg2PicParams    mpeg2;                 
         RocdecAvcPicParams      avc;
         RocdecHevcPicParams     hevc;
         RocdecVc1PicParams      vc1;
         RocdecJPEGPicParams     jpeg;
         uint32_t                codec_reserved[256];
     } pic_params;
  
     union {
         // Todo: Add slice params defines for other codecs.
         RocdecAvcSliceParams    *avc;
         RocdecHevcSliceParams   *hevc;
     } slice_params;
  
     union {
         // Todo: Added IQ matrix defines for other codecs.
         RocdecAvcIQMatrix       avc;
         RocdecHevcIQMatrix      hevc;
     } iq_matrix;
 } RocdecPicParams;
  
 /******************************************************/
 /******************************************************/
 typedef struct _RocdecProcParams
 {
     int         progressive_frame;               
     int         top_field_first;                 
     uint32_t    reserved_flags[2];               
     // The fields below are used for raw YUV input
     uint64_t    raw_input_dptr;                  
     uint32_t    raw_input_pitch;                 
     uint32_t    raw_input_format;                
     uint64_t    raw_output_dptr;                 
     uint32_t    raw_output_pitch;                
     uint32_t    raw_output_format;               
     uint32_t    reserved[16];                    
 } RocdecProcParams;
  
 /*****************************************************************************************************/
 /*****************************************************************************************************/
 extern rocDecStatus ROCDECAPI rocDecCreateDecoder(rocDecDecoderHandle *decoder_handle, RocDecoderCreateInfo *decoder_create_info);
  
 /*****************************************************************************************************/
 /*****************************************************************************************************/
 extern rocDecStatus ROCDECAPI rocDecDestroyDecoder(rocDecDecoderHandle decoder_handle);
  
 /**********************************************************************************************************************/
 /**********************************************************************************************************************/
 extern rocDecStatus ROCDECAPI rocDecGetDecoderCaps(RocdecDecodeCaps *decode_caps);
  
 /*****************************************************************************************************/
 /*****************************************************************************************************/
 extern rocDecStatus ROCDECAPI rocDecDecodeFrame(rocDecDecoderHandle decoder_handle, RocdecPicParams *pic_params);
  
 /************************************************************************************************************/
 /************************************************************************************************************/
 extern rocDecStatus ROCDECAPI rocDecGetDecodeStatus(rocDecDecoderHandle decoder_handle, int pic_idx, RocdecDecodeStatus* decode_status);
  
 /*********************************************************************************************************/
 /*********************************************************************************************************/
 extern rocDecStatus ROCDECAPI rocDecReconfigureDecoder(rocDecDecoderHandle decoder_handle, RocdecReconfigureDecoderInfo *reconfig_params);
  
 /************************************************************************************************************************/
 /************************************************************************************************************************/
 extern rocDecStatus ROCDECAPI rocDecGetVideoFrame(rocDecDecoderHandle decoder_handle, int pic_idx,
                                            void *dev_mem_ptr[3], uint32_t (&horizontal_pitch)[3],
                                            RocdecProcParams *vid_postproc_params);
  
 /*****************************************************************************************************/
 /*****************************************************************************************************/
 extern const char* ROCDECAPI rocDecGetErrorName(rocDecStatus rocdec_status);
  
 #ifdef  __cplusplus
 }
 #endif