| /****************************************************************************** |
| * |
| * 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; |
| }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; |
| |
| }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; |
| /** |
| * Number of ctb's to process in one loop |
| */ |
| WORD32 i4_nctb; |
| }process_ctxt_t; |
| |
| 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 |
| */ |
| void *pv_tu_data; |
| /** |
| * 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 */ |
| UWORD8 *pu1_proc_map; |
| /** |
| * 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; |
| /** |
| * 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 |
| */ |
| slice_header_t *ps_slice_hdr_base; |
| /** |
| * 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; |
| /** 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_ */ |