decoder/ihevcd_structs.h

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

/**
 *******************************************************************************
 * @file
 *  ihevcd_structs.h
 *
 * @brief
 *  Structure definitions used in the decoder
 *
 * @author
 *  Harish
 *
 * @par List of Functions:
 *
 * @remarks
 *  None
 *
 *******************************************************************************
 */

#ifndef _IHEVCD_STRUCTS_H_
#define _IHEVCD_STRUCTS_H_
typedef enum
{
    INIT_DONE, HEADER_DONE, FIRST_FRAME_DONE,
}CODEC_STATE_T;



typedef struct _codec_t codec_t;

/** Structure to hold format conversion context */
typedef struct
{
    /** Current row for which format conversion should be done */
    WORD32 i4_cur_row;

    /** Number of rows for which format conversion should be done */
    WORD32 i4_num_rows;
}fmt_conv_t;

/**
 * Bitstream structure
 */
typedef struct
{
    /**
     * Bitstream buffer base pointer
     */
    UWORD8 *pu1_buf_base;

    /**
     * Bitstream bit offset in current word. Value between 0 and 31
     */
    UWORD32 u4_bit_ofst;

    /**
     * Current bitstream buffer pointer
     */
    UWORD32 *pu4_buf;

    /**
     * Current word
     */
    UWORD32 u4_cur_word;

    /**
     * Next word
     */
    UWORD32 u4_nxt_word;

    /**
     * Max address for bitstream
     */
    UWORD8 *pu1_buf_max;
}bitstrm_t;

/**
******************************************************************************
 *  @brief      Cabac context for decoder
******************************************************************************
 */
typedef struct cab_ctxt
{
    /*********************************************************************/
    /*  CABAC ENGINE related fields                                      */
    /*********************************************************************/
    /** cabac interval range  R */
    UWORD32  u4_range;

    /** cabac interval offset O  */
    UWORD32  u4_ofst;

    /*********************************************************************/
    /*  CABAC context models                                             */
    /*********************************************************************/
    /** All Context models stored in pscked form pState[bits6-1] | MPS[bit0] */
    UWORD8  au1_ctxt_models[IHEVC_CAB_CTXT_END];

    /** Context models memorized after decoding 2nd CTB in a row to be used
     * during entropy sync cases
     */
    UWORD8 au1_ctxt_models_sync[IHEVC_CAB_CTXT_END];

}cab_ctxt_t;

typedef enum
{
    CMD_PROCESS,
    CMD_FMTCONV,
}JOBQ_CMD_T;

/**
 * Structure to represent a processing job entry
 */
typedef struct
{
    /**
     * Command
     * Currently: PROCESS, FMTCONV are the only two jobs
     */
    WORD32 i4_cmd;
    /**
     * CTB x of the starting CTB
     */
    WORD16 i2_ctb_x;

    /**
     * CTB y of the starting CTB
     */

    WORD16 i2_ctb_y;

    /**
     * Number of CTBs that need to be processed in this job
     */
    WORD16 i2_ctb_cnt;

    /**
     *  Slice index for the current CTB
     */
    WORD16 i2_slice_idx;

    /**
     * TU coefficient data offset for the current job
     */
    WORD32 i4_tu_coeff_data_ofst;
#ifdef GPU_BUILD
    /**
     * OpenCL Granularity
     */
    WORD16 i2_granularity_idx;

    /**
     * Index to the process context
     */
    //WORD16 i2_proc_idx;

    /**
     * GPU Wait or NOT
     */
    WORD16 i2_wait;
#endif
}proc_job_t;
/**
 * Structure to represent a MV Bank buffer
 */
typedef struct
{
    /**
     *  Pointer to hold PU index for each CTB in a picture
     */
    UWORD32 *pu4_pic_pu_idx;

    /**
     * Pointer to hold pu_t for each PU in a picture
     */
    pu_t *ps_pic_pu;

    /**
     * Pointer to hold PU map for each CTB in a picture
     */
    UWORD8 *pu1_pic_pu_map;

    /**
     * Pointer to hold the Slice map
     */
    UWORD16 *pu1_pic_slice_map;

    /**
     * Absolute POC for the current MV Bank
     */
    WORD32 i4_abs_poc;

    /**
     * Absolute POCs of reference List 0 for all slices in the frame from which this frame is reconstructed
     */
    WORD32 l0_collocated_poc[MAX_SLICE_SEGMENTS_IN_FRAME][MAX_DPB_SIZE];

    /**
     * Flag to indicate Long Term reference for POCs of reference List 0 for all slices in the frame from which this frame is reconstructed
     */
    WORD8 u1_l0_collocated_poc_lt[MAX_SLICE_SEGMENTS_IN_FRAME][MAX_DPB_SIZE];

    /**
     * Absolute POCs of reference List 1 for all slices in the frame from which this frame is reconstructed
     */
    WORD32 l1_collocated_poc[MAX_SLICE_SEGMENTS_IN_FRAME][MAX_DPB_SIZE];
    /**
     * Flag to indicate Long Term reference for POCs of reference List 1 for all slices in the frame from which this frame is reconstructed
     */
    WORD32 u1_l1_collocated_poc_lt[MAX_SLICE_SEGMENTS_IN_FRAME][MAX_DPB_SIZE];

}mv_buf_t;

typedef struct
{
    /**
     * Pointer to current PPS
     */
    pps_t *ps_pps;

    /**
     * Pointer to current SPS
     */
    sps_t *ps_sps;

    /**
     * Pointer to current slice header structure
     */
    slice_header_t *ps_slice_hdr;

    /**
     * CTB's x position within a picture in raster scan in CTB units
     */
    WORD32 i4_ctb_x;

    /**
     * CTB's y position within a picture in raster scan in CTB units
     */

    WORD32 i4_ctb_y;

    /**
     * Current PU structure - set to CTB pu_t pointer at the start of CTB processing and incremented
     * for every TU
     */
    pu_t *ps_pu;

    /**
     * Pointer to frame level pu_t for the current frame being parsed
     * where MVs and Intra pred modes will be updated
     */
    pu_t *ps_pic_pu;

    /**
     * Store the current tile's information. This is needed for the computation of mvs.
     */
    tile_t *ps_tile;

    /**
     * Points to an array of PU indices which is used to identify
     * start index of pu_t in ps_pic_pu and also to identify number of
     * PUs in the current CTB by subtracting current idx from next CTB's
     * PU idx
     */
    UWORD32 *pu4_pic_pu_idx;

    /** PU Index map per CTB. The indices in this map are w.r.t picture pu array and not
     * w.r.t CTB pu array.
     * This will be used during mv prediction and since neighbours will have different CTB pu map
     * it will be easier if they all have indices w.r.t picture level PU array rather than CTB level
     * PU array.
     * pu1_pic_pu_map is map w.r.t CTB's pu_t array
     */
    UWORD32 *pu4_pic_pu_idx_map;

    /**
      * Pointer to pu_map for the current frame being parsed
      * where MVs and Intra pred modes will be updated
      */
    UWORD8 *pu1_pic_pu_map;

    /**
     *  PU count in current CTB
     */
    WORD32 i4_ctb_pu_cnt;

    /**
     *  PU count in current CTB
     */
    WORD32 i4_ctb_start_pu_idx;

    /**
     *  Top availability for current CTB level
     */
    UWORD8 u1_top_ctb_avail;

    /**
     *  Top right availability for current CTB level
     */
    UWORD8 u1_top_rt_ctb_avail;
    /**
     *  Top left availability for current CTB level
     */
    UWORD8 u1_top_lt_ctb_avail;
    /**
     *  left availability for current CTB level
     */
    UWORD8 u1_left_ctb_avail;

}mv_ctxt_t;

typedef struct
{
    /**
     * Pointer to current PPS
     */
    pps_t *ps_pps;

    /**
     * Pointer to current SPS
     */
    sps_t *ps_sps;

    /*
     * Pointer to codec context
     */
    codec_t *ps_codec;

    /**
     * Index of the current Tile being parsed
     */
    tile_t *ps_tile;

    /**
     * Pointer to the current slice header
     */
    slice_header_t *ps_slice_hdr;

    /**
     *  TU count in current CTB
     */
    WORD32 i4_ctb_tu_cnt;

    /**
     * CTB's x position within a picture in raster scan in CTB units
     */
    WORD32 i4_ctb_x;

    /**
     * CTB's y position within a picture in raster scan in CTB units
     */

    WORD32 i4_ctb_y;

    /**
     * CTB's x position within a Tile in raster scan in CTB units
     */
    WORD32 i4_ctb_tile_x;

    /**
     * CTB's y position within a Tile in raster scan in CTB units
     */

    WORD32 i4_ctb_tile_y;

    /**
     * CTB's x position within a Slice in raster scan in CTB units
     */
    WORD32 i4_ctb_slice_x;

    /**
     * CTB's y position within a Slice in raster scan in CTB units
     */

    WORD32 i4_ctb_slice_y;

    /* Two bits per edge.
    Stored in format. BS[15] | BS[14] | .. |BS[0]*/
    UWORD32 *pu4_pic_vert_bs;

    /**
     * Horizontal Boundary strength
     */

    /* Two bits per edge.
    Stored in format. BS[15] | BS[14] | .. |BS[0]*/
    UWORD32 *pu4_pic_horz_bs;

    /**
     * Flags to indicate if QP is constant through out a CTB - 1 bit for each CTB
     * The bits are packed from LSB to MSB
     * To get the flag corresponding to CTB with (ctb_x, ctb_y), use
     *      pu4_qp_const_in_ctb[(ctb_x + pic_wd_in_ctb * ctb_y) >> 3] & (1 << ((ctb_x + pic_wd_in_ctb * ctb_y) & 7))
     */
    UWORD8 *pu1_pic_qp_const_in_ctb;

    /**
     *  Qp array stored for each 8x8 pixels
     */
    UWORD8  *pu1_pic_qp;

    /**
     * Current TU structure - set to CTB tu_t pointer at the start of CTB processing and incremented
     * for every TU
     */
    tu_t *ps_tu;

    /**
     * Points to an array of TU indices which is used to identify
     * start index of tu_t in ps_pic_tu and also to identify number of
     * TUs in the current CTB by subtracting current idx from next CTB's
     * TU idx
     */
    UWORD32 *pu4_pic_tu_idx;

    /**
     * Points to an array of PU indices which is used to identify
     * start index of pu_t in ps_pic_pu and also to identify number of
     * PUs in the current CTB by subtracting current idx from next CTB's
     * PU idx
     */
    UWORD32 *pu4_pic_pu_idx;

    /**
     * Current PU structure - set to CTB pu_t pointer at the start of CTB processing and incremented
     * for every TU
     */
    pu_t *ps_pu;

    /**
     * Pointer to frame level pu_t for the current frame being parsed
     * where MVs and Intra pred modes will be updated
     */
    pu_t *ps_pic_pu;

    /** PU Index map per CTB. The indices in this map are w.r.t picture pu array and not
     * w.r.t CTB pu array.
     * This will be used during mv prediction and since neighbours will have different CTB pu map
     * it will be easier if they all have indices w.r.t picture level PU array rather than CTB level
     * PU array.
     * pu1_pic_pu_map is map w.r.t CTB's pu_t array
     */
    UWORD32 *pu4_pic_pu_idx_map;

    /**
     * Variable to store the next ctb count to compute pu idx
     */
    WORD32 i4_next_pu_ctb_cnt;

    /**
     * Variable to store the next ctb count to compute tu idx
     */
    WORD32 i4_next_tu_ctb_cnt;
    /**
     * Points to the array of slice indices which is used to identify the slice
     *  to which each CTB in a frame belongs.
     */
    UWORD16 *pu1_slice_idx;
}bs_ctxt_t;

typedef struct
{
    /**
     * Pointer to current PPS
     */
    pps_t *ps_pps;

    /**
     * Pointer to current SPS
     */
    sps_t *ps_sps;

    /*
     * Pointer to codec context
     */
    codec_t *ps_codec;

    /**
     * Pointer to current slice header structure
     */
    slice_header_t *ps_slice_hdr;

    /**
     * Pointer to the structure that contains BS and QP frame level arrays
     */
    bs_ctxt_t s_bs_ctxt;

    /**
     * CTB's x position within a picture in raster scan in CTB units
     */
    WORD32 i4_ctb_x;

    /**
     * CTB's y position within a picture in raster scan in CTB units
     */

    WORD32 i4_ctb_y;

    /**
     * Current pictures loop filter flag map at 8x8 level
     */
    UWORD8 *pu1_pic_no_loop_filter_flag;

    /**
     * Current CTB's no_loop_filter_flags
     * each element corresponds to one row - including the left CTB's last 8x8
     */
    UWORD16 au2_ctb_no_loop_filter_flag[9];

    /*
     * Pointer to 0th luma pixel in current pic
     */
    UWORD8 *pu1_cur_pic_luma;

    /*
     * Pointer to 0th chroma pixel in current pic
     */
    UWORD8 *pu1_cur_pic_chroma;

    /* Points to the array of slice indices which is used to identify the slice
    *  to which each CTB in a frame belongs.
    */
    UWORD16 *pu1_slice_idx;

    /* Specifies if the chroma format is yuv420sp_vu */
    WORD32 is_chroma_yuv420sp_vu;

#ifdef GPU_BUILD
    //TODO GPU : Later define it for ARM only version as well
    /**
     * Pointer to base slice header structure
     */
    slice_header_t *ps_slice_hdr_base;
#endif
}deblk_ctxt_t;

typedef struct
{
    /**
     * Pointer to current PPS
     */
    pps_t *ps_pps;

    /**
     * Pointer to current SPS
     */
    sps_t *ps_sps;

    /* Pointer to codec context
     *
     */
    codec_t *ps_codec;

    /**
     * Pointer to base slice header structure
     */
    slice_header_t *ps_slice_hdr_base;

    /**
     * Pointer to current slice header structure
     */
    slice_header_t *ps_slice_hdr;

    /**
     * Pointer to current tile structure
     */
    tile_t *ps_tile;
    /**
     * CTB's x position within a picture in raster scan in CTB units
     */
    WORD32 i4_ctb_x;

    /**
     * CTB's y position within a picture in raster scan in CTB units
     */

    WORD32 i4_ctb_y;

    /**
     * Current pictures loop filter flag map at 8x8 level
     */
    UWORD8 *pu1_pic_no_loop_filter_flag;

    /*
     * Pointer to 0th luma pixel in current pic
     */
    UWORD8 *pu1_cur_pic_luma;

    /*
     * Pointer to 0th chroma pixel in current pic
     */
    UWORD8 *pu1_cur_pic_chroma;

    /**
     * Pointer to frame level sao_t for the current frame being parsed
     */
    sao_t *ps_pic_sao;

    /**
     * Temporary buffer needed during SAO processing
     */
    UWORD8 *pu1_tmp_buf_luma;

    /**
     * Temporary buffer needed during SAO processing
     */
    UWORD8 *pu1_tmp_buf_chroma;

    /**
     * Left column of luma pixels - used by SAO
     */
    UWORD8 *pu1_sao_src_left_luma;

    /**
     * Top row of luma pixels - used by SAO
     */
    UWORD8 *pu1_sao_src_top_luma;

    /**
     * Left column of chroma pixels(interleaved) - used by SAO
     */
    UWORD8 *pu1_sao_src_left_chroma;

    /**
     * Top row of chroma pixels(interleaved) - used by SAO
     */
    UWORD8 *pu1_sao_src_top_chroma;

    /**
     * Top-left luma pixel - used by SAO (for the top CTB row)
     */
    UWORD8 *pu1_sao_src_luma_top_left_ctb;

    /**
     * Top-left chroma pixel(interleaved) - used by SAO (for the top CTB row)
     */
    UWORD8 *pu1_sao_src_chroma_top_left_ctb;

    /**
     * Top-left luma pixel - used by SAO (for the current  CTB row)
     */
    UWORD8 *pu1_sao_src_top_left_luma_curr_ctb;

    /**
     * Top-left chroma pixel(interleaved) - used by SAO (for the current CTB row)
     */
    UWORD8 *pu1_sao_src_top_left_chroma_curr_ctb;

    /**
     * Top-right luma pixel - used by SAO (for the top CTB row)
     */
    UWORD8 *pu1_sao_src_top_left_luma_top_right;

    /**
     * Top-right chroma pixel(interleaved) - used by SAO (for the top CTB row)
     */
    UWORD8 *pu1_sao_src_top_left_chroma_top_right;

    /**
     * Bottom-left luma pixel - used by SAO
     */
    UWORD8 u1_sao_src_top_left_luma_bot_left;
    /**
     *  Pointer to array that stores bottom left luma pixel per row(interleaved) - used by SAO
     */
    UWORD8 *pu1_sao_src_top_left_luma_bot_left;

    /**
     * Bottom left chroma pixel(interleaved) - used by SAO
     */
    UWORD8 au1_sao_src_top_left_chroma_bot_left[2];
    /**
     *  Pointer to array that stores bottom left chroma pixel per row(interleaved) - used by SAO
     */
    UWORD8 *pu1_sao_src_top_left_chroma_bot_left;

    /*
     * Slice counter in a picture.
     */
    UWORD32 i4_cur_slice_idx;
    /**
     * Points to the array of slice indices which is used to identify the slice
     *  to which each CTB in a frame belongs.
     */
    UWORD16 *pu1_slice_idx;
    /**
     * Points to the array of tile indices which is used to identify the slice
     *  to which each CTB in a frame belongs.
     */
    UWORD16 *pu1_tile_idx;

    /* Specifies if the chroma format is yuv420sp_vu */
    WORD32 is_chroma_yuv420sp_vu;

}sao_ctxt_t;

typedef struct
{
    /** Log2 CU's size */
    WORD32 i4_log2_cb_size;

    /** CU's x position */
    WORD32 i4_pos_x;

    /** CU's y position */
    WORD32 i4_pos_y;
    /**
     * Transquant Bypass enable flag at CU level - To be replicated at TU level
     */
    WORD32 i4_cu_transquant_bypass;
    /**
     * Prediction mode
     */
    WORD32 i4_pred_mode;

    /**
     * Partition mode
     */
    WORD32 i4_part_mode;

    /**
     * Intra luma pred mode for current CU. In case of PART2Nx2N
     * the first value is replicated to avoid checks later
     */
    WORD32 ai4_intra_luma_pred_mode[4];

    /**
     * Previous intra luma pred flag used for intra pred mode computation
     */
    WORD32 ai4_prev_intra_luma_pred_flag[4];

    /**
     * mpm index used in intra prediction mode computation
     */
    WORD32 ai4_mpm_idx[4];
    /**
     * Remaining intra pred mode
     */
    WORD32 ai4_rem_intra_luma_pred_mode[4];
    /**
     * Chroma pred mode index to be used to compute intra pred mode for chroma
     */
    WORD32 i4_intra_chroma_pred_mode_idx;
    /**
     * Maximum transform depth
     */
    WORD32 i4_max_trafo_depth;

    /**
     *  Luma CBF for current TU
     */
    UWORD8 i1_cbf_luma;

    /**
     * Cb CBF
     */
    UWORD8 ai1_cbf_cb[MAX_TRAFO_DEPTH];

    /**
     * Cr CBF
     */
    UWORD8 ai1_cbf_cr[MAX_TRAFO_DEPTH];

    /**
     * Intra split flag
     */
    WORD32 i4_intra_split_flag;

    /**
     * Current QP
     */
    WORD32 i4_qp;

    /**
     * Number of TUs in CU parsed before a change in QP is signaled
     */
    WORD32 i4_tu_cnt;

    /**
     * Cu QP delta
     */
    WORD32 i4_cu_qp_delta;

}parse_cu_t;
/**
 * Structure contains few common state variables such as CTB positions, current SPS, PPS ids etc which are to be
 * used in the parsing thread. By keeping it a different structure it is being explicitly signalled that these
 * variables are specific to Parsing threads context and other threads should not update these elements
 */
typedef struct
{
    /**
     * CTB's x position within a picture in raster scan in CTB units
     */
    WORD32 i4_ctb_x;

    /**
     * CTB's y position within a picture in raster scan in CTB units
     */

    WORD32 i4_ctb_y;

    /**
     * CTB's x position within a Tile in raster scan in CTB units
     */
    WORD32 i4_ctb_tile_x;

    /**
     * CTB's y position within a Tile in raster scan in CTB units
     */

    WORD32 i4_ctb_tile_y;

    /**
     * CTB's x position within a Slice in raster scan in CTB units
     */
    WORD32 i4_ctb_slice_x;

    /**
     * CTB's y position within a Slice in raster scan in CTB units
     */

    WORD32 i4_ctb_slice_y;

    /**
     * Index of the current Tile being parsed
     */
    tile_t *ps_tile;

    /**
     * Current slice idx - Used in multi-core cases to ensure slice header is
     * preserved till the last CB of the slice is decoded
     */
    WORD32 i4_cur_slice_idx;
    /**
     * Current slice idx - Used in multi-core cases to ensure slice header is
     * preserved till the last CB of the slice is decoded
     */
    WORD32 i4_cur_independent_slice_idx;

    /**
     * Current slice idx - Used in multi-core cases to ensure slice header is
     * preserved till the last CB of the slice is decoded
     */
    WORD32 i4_cur_tile_idx;

    /**
     * Pointer to current PPS
     */
    pps_t *ps_pps;

    /**
     * Pointer to current SPS
     */
    sps_t *ps_sps;

    /**
     * Signal that pic_init is called first time
     */
    WORD32 i4_first_pic_init;

    /**
     * Flag to indicate if CU QP delta is coded.
     * By default it is set to 0 at the beginning of coding quad tree
     */
    WORD32 i4_is_cu_qp_delta_coded;

    /**
     * CU Qp delta
     * By default it is set to 0 at the beginning of coding quad tree
     */
    WORD32 i4_cu_qp_delta;

    /**
     * Bitstream structure
     */
    bitstrm_t s_bitstrm;

    /**
     * Pointer frame level TU subblock coeff data
     */
    void *pv_pic_tu_coeff_data;

    /**
     * Pointer to TU subblock coeff data and number of coded subblocks and scan idx
     * Incremented each time a coded subblock is parsed
     *
     */
    void *pv_tu_coeff_data;

    /**
     * Current TU structure - set to CTB tu_t pointer at the start of CTB parsing and incremented
     * for every TU
     */
    tu_t *ps_tu;

    /**
     * Current ctb's TU map
     */
    UWORD8 *pu1_tu_map;

    /**
     * Current PU structure - set to CTB pu_t pointer at the start of CTB parsing and incremented
     * for every TU
     */
    pu_t *ps_pu;

    /**
     * Points to the array of slice indices which is used to identify the independent slice
     *  to which each CTB in a frame belongs.
     */
    UWORD16 *pu1_slice_idx;

    /**
     * Current PU index in a frame
     */
    WORD32 i4_pic_pu_idx;

    /**
     * Current TU index in a frame
     */
    WORD32 i4_pic_tu_idx;

    /**
     * Current PU structure - set to CTB pu_map pointer at the start of CTB parsing
     */
    UWORD8 *pu1_pu_map;

    /**
     * Current QP
     */
    WORD32 u4_qp;

    /**
     * Current Group's QP
     */
    WORD32 u4_qpg;

    /**
     * Number of PCM blocks in current CTB - Needed only during parsing
     * If needed during recon then move it to ctb_t
     */
    WORD32 i4_ctb_num_pcm_blks;

    /**
     * PCM flag for the current CU
     */
    WORD32 i4_cu_pcm_flag;

    /**
     * CU related information to be used to populate tu_t and pu_t during
     * pred unit and transform tree parsing.
     */
    parse_cu_t s_cu;

    /**
     * Pointer to pu_map for the current frame being parsed
     */
    UWORD8 *pu1_pic_pu_map;

    /**
     * Pointer to frame level pu_t for the current frame being parsed
     * where MVs and Intra pred modes will be updated
     */
    pu_t *ps_pic_pu;

    /**
     * Pointer to tu_map for the current frame being parsed
     */
    UWORD8 *pu1_pic_tu_map;

    /**
     * Pointer to frame level tu_t for the current frame being parsed
     * where transform unit related info will be updated
     */
    tu_t *ps_pic_tu;

    /**
     * Points to an array of TU indices which is used to identify
     * start index of tu_t in ps_pic_tu and also to identify number of
     * TUs in the current CTB by subtracting current idx from next CTB's
     * TU idx
     */
    UWORD32 *pu4_pic_tu_idx;

    /**
     * Points to an array of PU indices which is used to identify
     * start index of pu_t in ps_pic_pu and also to identify number of
     * PUs in the current CTB by subtracting current idx from next CTB's
     * PU idx
     */
    UWORD32 *pu4_pic_pu_idx;


    /**
     * Current pictures intra mode map at 8x8 level
     */
    UWORD8 *pu1_pic_intra_flag;

    /**
     * Current pictures loop filter flag map at 8x8 level
     */
    UWORD8 *pu1_pic_no_loop_filter_flag;

    /**
     * Array to hold one row (top) of skip_flag flag stored at (8x8) level
     * 1 bit per (8x8)
     * read and written as a UWORD32
     * LSB gives skip_flag for 0th 8x8 and MSB gives skip_flag for 31st 8x8 and so on
     * This is independent of CTB size or minCU size
     * Packed format requires extra calculations in extracting required bits but makes it easier
     * to store skip data for larger sizes such as 32 x 32 where 4 bits need to be set instead of
     * 4 bytes or for 64 x 64 where 8 bits need to be set instead of 8 bytes.
     */
    UWORD32 *pu4_skip_cu_top;

    /**
     * Array to hold one 64 pixel column (left) of skip_flag flag stored at (8x8) level
     * 1 bit per (8x8)
     * read and written as a UWORD32
     * LSB gives skip_flag for 0th 8x8 and MSB gives skip for 31st 8x8 and so on
     * This is independent of CTB size and allocated to store data for 64 pixels, of
     * this only first ctb_size number of bits (starting from MSB) will have valid data
     * This is also independent of min CU size and data is stored at 8x8 level.
     * Since only 8 bits are needed to represent left 64 pixels at 8x8 level, this is not an array
     */
    UWORD32 u4_skip_cu_left;

    /**
     * Array to hold one row (top) of coding_tree_depth stored at (8x8) level
     * 2 bits per (8x8) pixels
     * read and written as a WORD32
     * 2 LSBits give coding_tree_depth for 0th 8x8 and 2 MSBits give coding_tree_depth for 15th 8x8 and so on
     * This is independent of CTB size or minCU size
     */
    UWORD32 *pu4_ct_depth_top;

    /**
     * Array to hold one 64 pixel column (left) of coding_tree_depth stored at (8x8) level
     * 2 bits per (8x8) pixels
     * read and written as a WORD32
     * 2 LSBits give coding_tree_depth for 0th 8x8 and 2 MSBits give coding_tree_depth for 15th 8x8 and so on
     * This is independent of CTB size and allocated to store data for 64 pixels, of
     * this only first ctb_size * 2 number of bits (starting from MSB) will have valid data
     * This is also independent of min CU size and data is stored at 8x8 level.
     * Since only 16 bits are needed to represent left 64 pixels at 8x8 level, this is not an array
     */
    UWORD32 u4_ct_depth_left;

    /**
     * Array to hold top (one row) luma_intra_pred_mode stored at (4x4) level for a CTB
     * 8 bits per (4x4) pixels
     * read and written as a UWORD8
     * This is independent of CTB size or minCU size
     * This is independent of CTB size and allocated to store data for 64 pixels i.e. 64 bits is the size
     * Note this data is used only within a CTB, There is no inter CTB dependencies for this
     */
    UWORD8 *pu1_luma_intra_pred_mode_top;

    /**
     * Array to hold  left (one column) luma_intra_pred_mode stored at (4x4) level for a CTB
     * 8 bits per (4x4) pixels
     * read and written as a UWORD8
     * This is independent of CTB size and allocated to store data for 64 pixels i.e. 64 bits is the size
     * This is also independent of min CU size and data is stored at 8x8 level.
     * This is used for prediction of next CTB within a row in a slice or tile
     */
    UWORD8 *pu1_luma_intra_pred_mode_left;


    /**
     * Pointer to base of Video parameter set structure array
     */
    vps_t *ps_vps_base;

    /**
     * Pointer to base of Sequence parameter set structure array
     */
    sps_t *ps_sps_base;

    /**
     * Pointer to base of Picture parameter set structure array
     */
    pps_t *ps_pps_base;

    /**
     * Pointer to base of slice header structure array
     */
    slice_header_t *ps_slice_hdr_base;

    /**
     * Pointer to current slice header structure
     */
    slice_header_t *ps_slice_hdr;


    /**
     * Error code during parse stage
     */
    WORD32 i4_error_code;

    /**
     * Void pointer to process job context
     */
    void *pv_proc_jobq;

    /* Cabac context */
    cab_ctxt_t s_cabac;

    /* Current Coding tree depth */
    WORD32 i4_ct_depth;

    /** Flag to signal end of frame */
    WORD32 i4_end_of_frame;

    /**
     * Index of the next CTB parsed
     */
    WORD32 i4_next_ctb_indx;

    /**
     * Pointer to the structure that contains BS and QP frame level arrays
     */
    bs_ctxt_t s_bs_ctxt;

    /**
     * Pointer to the structure that contains deblock context
     */
    deblk_ctxt_t s_deblk_ctxt;

    /**
     * Pointer to the structure that contains sao context
     */
    sao_ctxt_t s_sao_ctxt;

    /**
     * QP Array for the current CTB
     * Used in QP prediction
     */
    WORD8 ai1_8x8_cu_qp[MAX_CU_IN_CTB];


    /**
     * Pointer to frame level sao_t for the current frame being parsed
     */
    sao_t *ps_pic_sao;

    /**
     * Abs POC count of the frame
     */
    WORD32 i4_abs_pic_order_cnt;

    /**
     * Pointer points to mv_buffer of current frame
     */
    mv_buf_t *ps_cur_mv_buf;

    /**
     * Variable to store the next ctb count to compute pu idx
     */
    WORD32 i4_next_pu_ctb_cnt;

    /**
     * Variable to store the next ctb count to compute tu idx
     */
    WORD32 i4_next_tu_ctb_cnt;


}parse_ctxt_t;

/**
 * Pixel processing thread context
 */

typedef struct
{
    /* Pointer to codec context
     *
     */
    codec_t *ps_codec;

    /**
     * CTB's x position within a picture in raster scan in CTB units
     */
    WORD32 i4_ctb_x;

    /**
     * CTB's y position within a picture in raster scan in CTB units
     */

    WORD32 i4_ctb_y;

    /**
     * CTB's x position within a Tile in raster scan in CTB units
     */
    WORD32 i4_ctb_tile_x;

    /**
     * CTB's y position within a Tile in raster scan in CTB units
     */

    WORD32 i4_ctb_tile_y;

    /**
     * CTB's x position within a Slice in raster scan in CTB units
     */
    WORD32 i4_ctb_slice_x;

    /**
     * CTB's y position within a Slice in raster scan in CTB units
     */

    WORD32 i4_ctb_slice_y;

    /**
     * Current tile being processed
     */
    tile_t *ps_tile;

    /**
     * Current slice idx - Used in multi-core cases to store slice index for
     * each ctb for sao filtering.
     */
    WORD32 i4_cur_slice_idx;

    /**
     * Current tile idx - Used in multi-core cases to store tile index for
     * each ctb for sao filtering.
     */
    WORD32 i4_cur_tile_idx;
    /**
     * Pointer to current PPS
     */
    pps_t *ps_pps;

    /**
     * Pointer to current SPS
     */
    sps_t *ps_sps;

    /**
     * Pointer to current slice header structure
     */
    slice_header_t *ps_slice_hdr;

    /**
     * Error code during parse stage
     */
    WORD32 i4_error_code;

    /**
     * Signal that pic_init is called first time
     */
    WORD32 i4_first_pic_init;

    /**
     * Pointer frame level TU subblock coeff data
     */
    void *pv_pic_tu_coeff_data;

    /**
     * Pointer to TU subblock coeff data and number of subblocks and scan idx
     * Incremented each time a coded subblock is processed
     *
     */
    void *pv_tu_coeff_data;

    /**
     * Current TU structure - set to CTB tu_t pointer at the start of CTB processing and incremented
     * for every TU
     */
    tu_t *ps_tu;

    /**
     * Current ctb's TU map
     */
    UWORD8 *pu1_tu_map;

    /**
     * Current PU structure - set to CTB pu_t pointer at the start of CTB processing and incremented
     * for every TU
     */
    pu_t *ps_pu;

    /**
     * Points to an array of TU indices which is used to identify
     * start index of tu_t in ps_pic_tu and also to identify number of
     * TUs in the current CTB by subtracting current idx from next CTB's
     * TU idx
     */
    UWORD32 *pu4_pic_tu_idx;

    /**
     * Points to an array of PU indices which is used to identify
     * start index of pu_t in ps_pic_pu and also to identify number of
     * PUs in the current CTB by subtracting current idx from next CTB's
     * PU idx
     */
    UWORD32 *pu4_pic_pu_idx;

    /**
     * Pointer to tu_map for the current frame being parsed
     */
    UWORD8 *pu1_pic_tu_map;

    /**
      * Pointer to pu_map for the current frame being parsed
      * where MVs and Intra pred modes will be updated
      */
    UWORD8 *pu1_pic_pu_map;

    /**
     * Pointer to frame level pu_t for the current frame being parsed
     * where MVs and Intra pred modes will be updated
     */
    pu_t *ps_pic_pu;

    /** PU Index map per CTB. The indices in this map are w.r.t picture pu array and not
     * w.r.t CTB pu array.
     * This will be used during mv prediction and since neighbours will have different CTB pu map
     * it will be easier if they all have indices w.r.t picture level PU array rather than CTB level
     * PU array.
     * pu1_pic_pu_map is map w.r.t CTB's pu_t array
     */
    UWORD32 *pu4_pic_pu_idx_map;

    /**
     * PU Index of top 4x4 neighbors stored for an entire row
     */
    UWORD32 *pu4_pic_pu_idx_top;

    /**
     * PU Index of left 4x4 neighbors stored for 64 pixels
     */
    UWORD32 *pu4_pic_pu_idx_left;

    /**
     * Holds top left PU index at CTB level - top left gets overwritten
     * by left CTB while updating top array. Before updating top at CTB
     * level required top-left index is backed up in the following
     */
    UWORD32 u4_ctb_top_left_pu_idx;

    /**
     * Pointer to frame level tu_t for the current frame being parsed
     * where transform unit related info will be updated
     */
    tu_t *ps_pic_tu;


    /**
    * Current PU structure - set to CTB pu_map pointer at the start of CTB parsing
    */
    UWORD8 *pu1_pu_map;

    /** Current MV Bank's buffer ID */
    WORD32 i4_cur_mv_bank_buf_id;

    /**
     * Current pictures intra mode map at 8x8 level
     */
    UWORD8 *pu1_pic_intra_flag;

    /**
     * Current pictures loop filter flag map at 8x8 level
     */
    UWORD8 *pu1_pic_no_loop_filter_flag;

    /**
     * Void pointer to process job context
     */

    void *pv_proc_jobq;

    /**
     * Number of CTBs to be processed in the current Job
     */
    WORD32 i4_ctb_cnt;
    /**
     * ID for the current context - Used for debugging
     */
    WORD32 i4_id;

    /**
     * Flag to indicate if parsing status has to be checked
     * Needed when parsing and processing are done in different threads
     */
    WORD32 i4_check_parse_status;

    /**
     * Flag to indicate if processing status of top row CTBs has to be checked
     * Needed when processing of different rows is done in different threads
     */
    WORD32 i4_check_proc_status;

    /**
     * Holds Intra dequantization matrices
     */
    WORD16 *api2_dequant_intra_matrix[4];

    /**
     * Holds Inter dequantization matrices
     */
    WORD16 *api2_dequant_inter_matrix[4];


    /**
     * Temporary buffer 1 - Used as a scratch in inter_pred_ctb()
     */
    WORD16 *pi2_inter_pred_tmp_buf1;

    /**
     * Temporary buffer 2 - Used as a scratch in inter_pred_ctb()
     */
    WORD16 *pi2_inter_pred_tmp_buf2;

    /**
     * Temporary buffer 3 - Used as a scratch in inter_pred_ctb()
     */
    WORD16 *pi2_inter_pred_tmp_buf3;

    /**
     * The above temporary buffers' stride
     */
    WORD32 i4_inter_pred_tmp_buf_strd;
    /**
     * Picture stride
     * Used as prediction stride, destination stride while computing inverse transform
     */
    WORD32 i4_pic_strd;

    /**
     * Picture qp offset for U
     */
    WORD8 i1_pic_cb_qp_offset;

    /**
     * Slice qp offset for U
     */
    WORD32 i1_slice_cb_qp_offset;

    /**
     * Picture qp offset for V
     */
    WORD8 i1_pic_cr_qp_offset;

    /**
     * Slice qp offset for V
     */
    WORD32 i1_slice_cr_qp_offset;

    /** Pointer to current picture buffer structure */
    pic_buf_t *ps_cur_pic;

    /** Current pic_buf's picture buffer id */
    WORD32 i4_cur_pic_buf_id;

    /** Pointer to 0th luma pixel in current pic */
    UWORD8 *pu1_cur_pic_luma;

    /** Pointer to 0th chroma pixel in current pic */
    UWORD8 *pu1_cur_pic_chroma;

    /** Intermediate buffer to be used during inverse transform */
    WORD16 *pi2_itrans_intrmd_buf;

    /** Buffer to hold output of inverse scan */
    WORD16 *pi2_invscan_out;

    /**
     *  Top availability for current CTB level
     */
    UWORD8 u1_top_ctb_avail;

    /**
     *  Top right availability for current CTB level
     */
    UWORD8 u1_top_rt_ctb_avail;
    /**
     *  Top left availability for current CTB level
     */
    UWORD8 u1_top_lt_ctb_avail;
    /**
     *  left availability for current CTB level
     */
    UWORD8 u1_left_ctb_avail;
    /**
     *  TU count in current CTB
     */
    WORD32 i4_ctb_tu_cnt;

    /**
     *  Recon pointer to current CTB luma
     */
    UWORD8 *pu1_cur_ctb_luma;
    /**
     *  Recon pointer to current CTB chroma
     */
    UWORD8 *pu1_cur_ctb_chroma;

    /**
     *  PU count in current CTB
     */
    WORD32 i4_ctb_pu_cnt;

    /**
     *  PU count in current CTB
     */
    WORD32 i4_ctb_start_pu_idx;

    /* Pointer to a structure describing output display buffer */
    ivd_out_bufdesc_t *ps_out_buffer;

    /** Flag to indicate if ps_proc was intialized at least once in a frame.
     * This is needed to handle cases where a core starts to handle format conversion jobs directly
     */
    WORD32 i4_init_done;

    /**
     * Pointer to the structure that contains BS and QP frame level arrays
     */
    bs_ctxt_t s_bs_ctxt;

    /**
     * Pointer to the structure that contains deblock context
     */
    deblk_ctxt_t s_deblk_ctxt;

    /**
     * Pointer to the structure that contains sao context
     */
    sao_ctxt_t s_sao_ctxt;

    /**
     * Points to the array of slice indices which is used to identify the independent
     * slice to which each CTB in a frame belongs.
     */
    UWORD16 *pu1_slice_idx;

    /**
     * Points to the array of slice indices which is used to identify the slice
     *  to which each CTB in a frame belongs.
     */
    UWORD16 *pu1_tile_idx;
    /**
     * Variable to store the next ctb count to compute pu idx
     */
    WORD32 i4_next_pu_ctb_cnt;

    /**
     * Variable to store the next ctb count to compute tu idx
     */
    WORD32 i4_next_tu_ctb_cnt;
#ifdef GPU_BUILD
    //TODO GPU : Later define it for ARM only version as well
    /** Process status: one byte per CTB */
    UWORD8 *pu1_proc_map;
#endif
#ifdef GPU_BUILD
    UWORD32 u4_gpu_inter_flag;
#endif
#ifdef GPU_BUILD
    //TODO GPU : Later define it for ARM only version as well
    /**
     * Pointer to base slice header structure
     */
    slice_header_t *ps_slice_hdr_base;
#endif
    /**
     * Number of ctb's to process in one loop
     */
    WORD32 i4_nctb;
}process_ctxt_t;
#ifdef GPU_BUILD
typedef struct
{
    /** Pointer to private GPU memory */
    void *pv_gpu_priv;

    /**
     * Array that contains the no of ctbs in each grain of the frame.
     * Right now maximum no of grains in frame hardcoded to 16.
     */
    WORD32 ai4_ctbs_in_grain[16];

    /**
     * Array that contains the height of each grain of the frame in ctbs.
     * Right now maximum no of grains in frame hardcoded to 16.
     */
    WORD32 ai4_grain_ht_in_ctb[16];

    /**
     * Array that contains the X position of each grain in the current
     * frame in CTB units
     */
    WORD32 ai4_grain_pos_y[16];

    /**
     * Variables to store maximum extend of motion vectors in for the current grain.
     */
    //WORD32 i4_max_pu_y;
    //WORD32 i4_max_pu_x;

    /**
     * Parameter that holds current grain index.
     */
    WORD32 i4_curr_grain_idx;

    /**
     * Arry to store coefficient offsets for each ctb row.
     * Currently allocated for frame width of 4096(ctb size 16 * 256).
     */
    WORD32 ai4_tu_coeff_data_ofst[256];

    /**
     * Arry to store slice id for at the beginning of each ctb row.
     * Currently allocated for frame width of 4096(ctb size 16 * 256).
     */
    WORD32 ai4_cur_slice_idx[256];

    /**
     * Variable to keep track of no of ctbs parsed in the current frame grain.
     */
    WORD32 i4_curr_grain_ctb_cnt;
}gpu_ctxt_t;
#endif

typedef void (*pf_inter_pred)(void *,
                              void *,
                              WORD32,
                              WORD32,
                              WORD8 *,
                              WORD32,
                              WORD32);


typedef void (*pf_intra_pred)(UWORD8 *pu1_ref,
                              WORD32 src_strd,
                              UWORD8 *pu1_dst,
                              WORD32 dst_strd,
                              WORD32 nt,
                              WORD32 mode);

typedef void (*pf_itrans_recon)(WORD16 *pi2_src,
                                WORD16 *pi2_tmp,
                                UWORD8 *pu1_pred,
                                UWORD8 *pu1_dst,
                                WORD32 src_strd,
                                WORD32 pred_strd,
                                WORD32 dst_strd,
                                WORD32 zero_cols,
                                WORD32 zero_rows);

typedef void (*pf_recon)(WORD16 *pi2_src,
                         UWORD8 *pu1_pred,
                         UWORD8 *pu1_dst,
                         WORD32 src_strd,
                         WORD32 pred_strd,
                         WORD32 dst_strd,
                         WORD32 zero_cols);

typedef void (*pf_itrans_recon_dc)(UWORD8 *pu1_pred,
                                   UWORD8 *pu1_dst,
                                   WORD32 pred_strd,
                                   WORD32 dst_strd,
                                   WORD32 log2_trans_size,
                                   WORD16 i2_coeff_value);


typedef void (*pf_sao_luma)(UWORD8 *,
                            WORD32,
                            UWORD8 *,
                            UWORD8 *,
                            UWORD8 *,
                            UWORD8 *,
                            UWORD8 *,
                            UWORD8 *,
                            WORD8 *,
                            WORD32,
                            WORD32);

typedef void (*pf_sao_chroma)(UWORD8 *,
                              WORD32,
                              UWORD8 *,
                              UWORD8 *,
                              UWORD8 *,
                              UWORD8 *,
                              UWORD8 *,
                              UWORD8 *,
                              WORD8 *,
                              WORD8 *,
                              WORD32,
                              WORD32);

/**
 * Codec context
 */

struct _codec_t
{
    /**
     * Max width the codec can support
     */
    WORD32 i4_max_wd;

    /**
     * Max height the codec can support
     */
    WORD32 i4_max_ht;

    /**
     * Width : pic_width_in_luma_samples
     */
    WORD32 i4_wd;

    /**
     * Height : pic_height_in_luma_samples
     */
    WORD32 i4_ht;

    /**
     * Display width after cropping
     */
    WORD32 i4_disp_wd;

    /**
     * Display height after cropping
     */
    WORD32 i4_disp_ht;

    /**
     * Display stride
     */
    WORD32 i4_disp_strd;

    /*
     * In case stream width/height is greater than max_wd/max_ht used during init,
     * it is stored in the following and in order to decode the current stream
     * decoder has to be recreated with these dimensions.
     */
    /**
     * Stream width if it is greater than i4_max_wd
     */
    WORD32 i4_new_max_wd;

    /**
     * Stream height if it is greater than i4_max_ht
     */
    WORD32 i4_new_max_ht;

    /**
     * Stride of reference buffers.
     * For shared mode even display buffer will use the same stride
     */
    WORD32 i4_strd;

    /**
     * Level specified during init
     */
    WORD32 i4_init_level;

    /**
     * number of reference frames specified during init
     */
    WORD32 i4_init_num_ref;

    /**
     * number of reorder frames specified during init
     */
    WORD32 i4_init_num_reorder;

    /**
     * Number of extra display buffers allocated by application
     */
    WORD32 i4_init_num_extra_disp_buf;

    /**
     * Number of cores to be used
     */
    WORD32 i4_num_cores;

    /**
     * RASL output flag
     */
    WORD32 i4_rasl_output_flag;

    /**
     * Pictures that are are degraded
     * 0 : No degrade
     * 1 : Only on non-reference frames
     * 2 : Use interval specified by u4_nondegrade_interval
     * 3 : All non-key frames
     * 4 : All frames
     */
    WORD32                                     i4_degrade_pics;

    /**
     * Interval for pictures which are completely decoded without any degradation
     */
    WORD32                                     i4_nondegrade_interval;

    /**
     * bit position (lsb is zero): Type of degradation
     * 0 : Disable SAO
     * 1 : Disable deblocking
     * 2 : Faster inter prediction filters
     * 3 : Fastest inter prediction filters
     */
    WORD32                                     i4_degrade_type;

    /** Degrade pic count, Used to maintain the interval between non-degraded pics
     *
     */
    WORD32  i4_degrade_pic_cnt;

    /**
     * Total number of display buffers to be used
     * In case of shared mode, this will be number of reference frames
     */
    WORD32 i4_num_disp_bufs;

    /**
     * Flag to enable shared display buffer mode
     */
    WORD32 i4_share_disp_buf;

    /**
     * Chroma format of display buffers.
     In shared mode only 420SP_UV and 420SP_VU are supported
     */
    IV_COLOR_FORMAT_T e_chroma_fmt;

    /**
     * Chroma format of reference buffers.
     * In non-shared mode it will be 420SP_UV
     * In shared mode only 420SP_UV and 420SP_VU are supported
     */
    IV_COLOR_FORMAT_T e_ref_chroma_fmt;

    /**
     * Frame skip mode
     */
    IVD_FRAME_SKIP_MODE_T e_pic_skip_mode;

    /**
     * Display or decode order dump of output
     */
    IVD_DISPLAY_FRAME_OUT_MODE_T e_pic_out_order;

    /**
     * Coding type of the picture that is decoded
     */
    IV_PICTURE_CODING_TYPE_T e_dec_pic_type;

    /**
     * Flag to signal if a frame was decoded in this call
     */
    WORD32 i4_pic_decoded;

    /**
     * Flag to signal if picture data is present in the current input bitstream
     */
    WORD32 i4_pic_present;

    /**
     * Flag to disable deblocking of a frame
     */
    WORD32 i4_disable_deblk_pic;

    /**
     * Flag to disable sao of a frame
     */
    WORD32 i4_disable_sao_pic;

    /**
     * Flag to use full pel MC
     */
    WORD32 i4_fullpel_inter_pred;
    /**
     * Flush mode
     */
    WORD32 i4_flush_mode;

    /**
     * Decode header mode
     */
    WORD32 i4_header_mode;

    /**
     * Header in slice mode
     */
    WORD32 i4_header_in_slice_mode;

    /**
     * Flag to signal sps done
     */
    WORD32 i4_sps_done;

    /**
     * Flag to signal pps done
     */
    WORD32 i4_pps_done;

    /**
     * To signal successful completion of init
     */
    WORD32 i4_init_done;

    /**
     * To signal that at least one picture was decoded
     */
    WORD32 i4_first_pic_done;

    /**
     * To signal error in slice
     */
    WORD32 i4_slice_error;

    /**
     * Reset flag - Codec is reset if this flag is set
     */
    WORD32 i4_reset_flag;

    /**
     * Number of pictures decoded till now
     */
    UWORD32 u4_pic_cnt;

    /**
     * Number of pictures displayed till now
     */
    UWORD32 u4_disp_cnt;

    /**
     * Current error code
     */
    WORD32 i4_error_code;

    /**
     * Pointer to input bitstream. This is incremented everytime a NAL is processed
     */
    UWORD8 *pu1_inp_bitsbuf;

    /**
     * Offset to first byte after the start code in current NAL
     */
    WORD32 i4_nal_ofst;

    /**
     * Length of the NAL unit including the emulation bytes
     */
    WORD32 i4_nal_len;

    /**
     * Number of emulation prevention bytes present in the current NAL
     */
    WORD32 i4_num_emln_bytes;

    /**
     * Number of bytes remaining in the input bitstream
     */
    /**
     * Decremented everytime a NAL is processed
     */
    WORD32 i4_bytes_remaining;

    /**
     * Pointer to bitstream after emulation prevention
     */
    UWORD8 *pu1_bitsbuf;

    /**
     * Size of intermediate bitstream buffer
     */
    UWORD32 u4_bitsbuf_size;

    /**
     * Pointer to hold TU data for a set of CTBs or a picture
     */
#ifndef GPU_BUILD
    void *pv_tu_data;
#else
    void *apv_tu_data[2];
#endif
    /**
     * Holds mem records passed during init.
     * This will be used to return the mem records during retrieve call
     */
    iv_mem_rec_t *ps_mem_rec_backup;

    /**
     * Process Job queue buffer base
     */
    void *pv_proc_jobq_buf;

    /**
     * Process Job Queue mem tab size
     */
    WORD32 i4_proc_jobq_buf_size;

    /** Parse status: one byte per CTB */
    UWORD8 *pu1_parse_map;

    /** Process status: one byte per CTB */
#ifndef GPU_BUILD
    UWORD8 *pu1_proc_map;
#else
    UWORD8 *apu1_proc_map[2];
#endif
    /**
     * Current pictures intra mode map at 8x8 level
     */
#ifndef GPU_BUILD
    UWORD8 *pu1_pic_intra_flag;
#else
    UWORD8 *apu1_pic_intra_flag[2];
#endif
    /**
     * Current pictures loop filter flag map at 8x8 level
     */
#ifndef GPU_BUILD
    UWORD8 *pu1_pic_no_loop_filter_flag;
#else
    UWORD8 *apu1_pic_no_loop_filter_flag[2];
#endif
    /**
     * MV Bank buffer manager
     */
    void *pv_mv_buf_mgr;

    /**
     * Pointer to MV Buf structure array
     */
    void *ps_mv_buf;

    /**
     * Base address for Motion Vector bank buffer
     */
    void *pv_mv_bank_buf_base;

    /**
     * MV Bank size allocated
     */
    WORD32 i4_total_mv_bank_size;

    /**
     * Picture buffer manager
     */
    void *pv_pic_buf_mgr;

    /**
     * Pointer to Pic Buf structure array
     */
    void *ps_pic_buf;

    /**
     * Base address for Picture buffer
     */
    void *pv_pic_buf_base;

    /**
     * Total pic buffer size allocated
     */
    WORD32 i4_total_pic_buf_size;


    /**
     * Picture buffer manager
     */
    void *pv_disp_buf_mgr;

    /**
     * Current display buffer's buffer ID
     */
    WORD32 i4_disp_buf_id;

    /**
     * Current display buffer
     */
    pic_buf_t *ps_disp_buf;

    /**
     * Pointer to dpb manager structure
     */
    void *pv_dpb_mgr;

    /**
     * Scaling matrices for each PPS
     */
    WORD16 *pi2_scaling_mat;

    /**
     * Array containing Tile information for each PPS
     */
    tile_t *ps_tile;

    /**
     * Timestamp associated with the current display output
     */
    UWORD32 u4_ts;

    /**
     * Pointer to base of Video parameter set structure array
     */
    vps_t *ps_vps_base;

    /**
     * Pointer to base of Sequence parameter set structure array
     */
    sps_t *ps_sps_base;

    /**
     * Pointer to base of Picture parameter set structure array
     */
    pps_t *ps_pps_base;

    /**
     * Pointer to base of slice header structure array
     */
#ifndef GPU_BUILD
    slice_header_t *ps_slice_hdr_base;
#else
    slice_header_t *aps_slice_hdr_base[2];
#endif
    /**
     * Pointer to base of entry point offsets in a frame
     */
    WORD32 *pi4_entry_ofst;

    /**
     * Current offset in pi4_entry_ofst
     */
    WORD32 i4_cur_entry_ofst;

    /**
     *  Parsing context
     */
    parse_ctxt_t s_parse;

    /**
     * Processing context - One for each processing thread
     */
    process_ctxt_t as_process[MAX_PROCESS_THREADS];

    /**
     * Thread handle for each of the processing threads
     */
    void *apv_process_thread_handle[MAX_PROCESS_THREADS];

    /**
     * Thread created flag for each of the processing threads
     */
    WORD32 ai4_process_thread_created[MAX_PROCESS_THREADS];

    /**
     * Void pointer to process job context
     */
    void *pv_proc_jobq;

    /* Number of CTBs processed together for better instruction cache handling */
    WORD32 i4_proc_nctb;

    /**
     * Previous POC lsb
     */
    WORD32 i4_prev_poc_lsb;

    /**
     * Previous POC msb
     */
    WORD32 i4_prev_poc_msb;

    /**
     * Max POC lsb that has arrived till now
     */
    WORD32 i4_max_prev_poc_lsb;

    /** Context for format conversion */
    fmt_conv_t s_fmt_conv;

    /** Pointer to a structure describing output display buffer */
    ivd_out_bufdesc_t *ps_out_buffer;
    /**
     * Variable to store the next ctb count to compute pu idx
     */
    WORD32 i4_next_pu_ctb_cnt;

    /**
     * Variable to store the next ctb count to compute tu idx
     */
    WORD32 i4_next_tu_ctb_cnt;

    /**  Active SPS id - mainly to be used during codec initializations in shared mode */
    WORD32 i4_sps_id;

    /**  Number of ctbs to be decoded in one process call */
    UWORD32 u4_nctb;

    /** Flag to enable scheduling of format conversion jobs ahead of processing jobs */
    UWORD32 u4_enable_fmt_conv_ahead;

    /** Mask used to change MVs to full pel when configured to run in reduced complexity mode */
    WORD32 i4_mv_frac_mask;
#ifdef GPU_BUILD
    /* Two bits per edge.
    Stored in format. BS[15] | BS[14] | .. |BS[0]*/
    UWORD32 *apu4_pic_vert_bs[2];

    /**
     * Horizontal Boundary strength
     */

    /* Two bits per edge.
    Stored in format. BS[15] | BS[14] | .. |BS[0]*/
    UWORD32 *apu4_pic_horz_bs[2];

    /**
     * Flags to indicate if QP is constant through out a CTB - 1 bit for each CTB
     * The bits are packed from LSB to MSB
     * To get the flag corresponding to CTB with (ctb_x, ctb_y), use
     *      pu4_qp_const_in_ctb[(ctb_x + pic_wd_in_ctb * ctb_y) >> 3] & (1 << ((ctb_x + pic_wd_in_ctb * ctb_y) & 7))
     */
    UWORD8 *apu1_pic_qp_const_in_ctb[2];

    /**
     *  Qp array stored for each 8x8 pixels
     */
    UWORD8  *apu1_pic_qp[2];

    /**
     * Pointer to frame level sao_t for the current frame being parsed
     */
    sao_t *aps_pic_sao[2];

    /* GPU context structure */
    gpu_ctxt_t s_gpu_ctxt;

    /* Flag to switch bw MC on GPU and CPU dynamically */
    UWORD32 u4_gpu_enabled;

    /* Variable to store the view(ping or pong) for parsing */
    UWORD32 u4_parsing_view;

    /*
     * Set the flag to remember to add the frame for flushing
     * call is a flush call.
     */
    UWORD32 u4_add_last_frame;
#endif
    /**  Funtion pointers for inter_pred leaf level functions */
    pf_inter_pred apf_inter_pred[22];

    /**  Funtion pointers for inter_pred_luma leaf level functions */
    pf_intra_pred apf_intra_pred_luma[11];

    /**  Funtion pointers for inter_pred_chroma leaf level functions */
    pf_intra_pred apf_intra_pred_chroma[11];

    /**  Funtion pointers for itrans_recon leaf level functions */
    pf_itrans_recon apf_itrans_recon[8];

    /**  Funtion pointers for recon leaf level functions */
    pf_recon apf_recon[8];

    /**  Funtion pointers for itrans_recon_dc leaf level functions */
    pf_itrans_recon_dc apf_itrans_recon_dc[2];

    /**  Funtion pointers for sao_luma leaf level functions */
    pf_sao_luma apf_sao_luma[4];

    /**  Funtion pointers for sao_chroma leaf level functions */
    pf_sao_chroma apf_sao_chroma[4];

    /**  Funtion pointers for all the leaf level functions */
    func_selector_t s_func_selector;
    /**  Processor architecture */
    IVD_ARCH_T e_processor_arch;
    /**  Processor soc */
    IVD_SOC_T e_processor_soc;
};

#endif /* _IHEVCD_STRUCTS_H_ */