package/mpp
1
0
Fork 0
mirror of https://github.com/nyanmisaka/mpp.git synced 2025-10-20 15:55:13 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

[h264d_parser]: optimize the size of some struct

Browse Source 
optimize the size of some structures as blow:
1. H264dVideoCtx_t
2. H264dCurCtx_t
3. DXVA_Slice_H264_Long

Change-Id: If3d7ca2f8d92d2a590767a97324537700848ab90
Signed-off-by: Yandong Lin <yandong.lin@rock-chips.com>
This commit is contained in:
Yandong Lin
2021-08-10 11:26:01 +08:00
committed by Herman Chen
parent 549ef870ce
commit c1cec3933c
9 changed files with 75 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
mpp/codec/dec/h264/h264d_api.c
View File

@@ -80,6 +80,12 @@ static MPP_RET free_cur_ctx(H264dCurCtx_t *p_Cur)
}
MPP_FREE(p_Cur->strm.nalu_buf);
MPP_FREE(p_Cur->strm.head_buf);
for (i = 0; i < MAX_MARKING_TIMES; i++)
MPP_FREE(p_Cur->dec_ref_pic_marking_buffer[i]);
MPP_FREE(p_Cur->subsps);
MPP_FREE(p_Cur->sei);
}
__RETURN:
@@ -124,14 +130,19 @@ static MPP_RET free_vid_ctx(H264dVideoCtx_t *p_Vid)
INP_CHECK(ret, !p_Vid);
for (i = 0; i < MAXSPS; i++) {
recycle_subsps(&p_Vid->subspsSet[i]);
if (p_Vid->subspsSet[i])
recycle_subsps(p_Vid->subspsSet[i]);
}
for (i = 0; i < MAXSPS; i++) {
MPP_FREE(p_Vid->spsSet[i]);
MPP_FREE(p_Vid->ppsSet[i]);
MPP_FREE(p_Vid->subspsSet[i]);
}
for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) {
free_dpb(p_Vid->p_Dpb_layer[i]);
MPP_FREE(p_Vid->p_Dpb_layer[i]);
}
free_storable_picture(p_Vid->p_Dec, p_Vid->dec_pic);
//free_frame_store(p_Dec, &p_Vid->out_buffer);
if (p_Vid->pic_st) {
mpp_mem_pool_deinit(p_Vid->pic_st);
p_Vid->pic_st = NULL;
@@ -155,26 +166,12 @@ static MPP_RET init_vid_ctx(H264dVideoCtx_t *p_Vid)
p_Vid->p_Dpb_layer[i]->init_done = 0;
p_Vid->p_Dpb_layer[i]->poc_interval = 2;
}
//!< init video pars
for (i = 0; i < MAXSPS; i++) {
p_Vid->spsSet[i].seq_parameter_set_id = 0;
p_Vid->subspsSet[i].sps.seq_parameter_set_id = 0;
}
for (i = 0; i < MAXPPS; i++) {
p_Vid->ppsSet[i].pic_parameter_set_id = 0;
p_Vid->ppsSet[i].seq_parameter_set_id = 0;
}
//!< init active_sps
p_Vid->active_sps = NULL;
p_Vid->active_subsps = NULL;
p_Vid->active_sps_id[0] = -1;
p_Vid->active_sps_id[1] = -1;
//!< init subspsSet
for (i = 0; i < MAXSPS; i++) {
p_Vid->subspsSet[i].sps.seq_parameter_set_id = 0;
p_Vid->subspsSet[i].num_views_minus1 = -1;
p_Vid->subspsSet[i].num_level_values_signalled_minus1 = -1;
}
p_Vid->pic_st = mpp_mem_pool_init(sizeof(H264_StorePic_t));
__RETURN:
return ret = MPP_OK;
@@ -592,7 +589,8 @@ MPP_RET h264d_parse(void *decoder, HalDecTask *in_task)
p_err->cur_err_flag = 0;
p_err->used_ref_flag = 0;
p_Dec->is_parser_end = 0;
memset(&p_Dec->p_Cur->sei, 0, sizeof(p_Dec->p_Cur->sei));
if (p_Dec->p_Cur->sei)
memset(p_Dec->p_Cur->sei, 0, sizeof(*p_Dec->p_Cur->sei));
ret = parse_loop(p_Dec);
if (ret) {

3
mpp/codec/dec/h264/h264d_fill.c
View File

@@ -302,9 +302,6 @@ MPP_RET fill_slice_syntax(H264_SLICE_t *currSlice, H264dDxvaCtx_t *dxva_ctx)
p_long->nal_ref_idc = currSlice->nal_reference_idc;
p_long->profileIdc = currSlice->active_sps->profile_idc;
for (i = 0; i < MPP_ARRAY_ELEMS(p_long->RefPicList[0]); i++) {
dpb_idx = currSlice->p_Dec->refpic_info_p[i].dpb_idx;
dpb_valid = currSlice->p_Dec->refpic_info_p[i].valid;

15
mpp/codec/dec/h264/h264d_global.h
View File

@@ -121,7 +121,6 @@ if ((val) < 0) {\
}} while (0)
#define START_PREFIX_3BYTE 3
#define MAX_NUM_DPB_LAYERS 2 //!< must >= 2
#define MAX_LIST_SIZE 33 //!< for init list reorder
@@ -942,10 +941,10 @@ typedef struct h264d_curstrm_t {
//!< current parameters
typedef struct h264d_cur_ctx_t {
struct h264_sps_t sps;
struct h264_subsps_t subsps;
struct h264_subsps_t *subsps;
struct h264_pps_t pps;
struct h264_prefix_t prefix;
struct h264_sei_t sei;
struct h264_sei_t *sei;
struct h264_nalu_t nalu;
struct bitread_ctx_t bitctx; //!< for control bit_read
struct h264d_curstrm_t strm;
@@ -967,14 +966,14 @@ typedef struct h264d_cur_ctx_t {
RK_S32 long_term_pic_idx[2][MAX_REORDER_TIMES];
RK_S32 abs_diff_view_idx_minus1[2][MAX_REORDER_TIMES];
struct h264_drpm_t dec_ref_pic_marking_buffer[MAX_MARKING_TIMES];
struct h264_drpm_t *dec_ref_pic_marking_buffer[MAX_MARKING_TIMES];
} H264dCurCtx_t;
//!< parameters for video decoder
typedef struct h264d_video_ctx_t {
struct h264_sps_t spsSet[MAXSPS]; //!< MAXSPS, all sps storage
struct h264_subsps_t subspsSet[MAXSPS]; //!< MAXSPS, all subpps storage
struct h264_pps_t ppsSet[MAXPPS]; //!< MAXPPS, all pps storage
struct h264_sps_t *spsSet[MAXSPS]; //!< MAXSPS, all sps storage
struct h264_subsps_t *subspsSet[MAXSPS]; //!< MAXSPS, all subpps storage
struct h264_pps_t *ppsSet[MAXPPS]; //!< MAXPPS, all pps storage
struct h264_sps_t *active_sps;
struct h264_subsps_t *active_subsps;
struct h264_pps_t *active_pps;
@@ -990,7 +989,7 @@ typedef struct h264d_video_ctx_t {
struct h264_dpb_mark_t *active_dpb_mark[MAX_NUM_DPB_LAYERS]; //!< acitve_dpb_memory
struct h264_store_pic_t old_pic;
struct h264_old_slice_par_t old_slice;
RK_S32 *qmatrix[12]; //!< scanlist pointer
RK_U32 stream_size;
RK_S32 last_toppoc[MAX_NUM_DPB_LAYERS];

17
mpp/codec/dec/h264/h264d_init.c
View File

@@ -478,15 +478,16 @@ static MPP_RET dpb_mark_malloc(H264dVideoCtx_t *p_Vid, H264_StorePic_t *dec_pic)
mpp_meta_set_s32(meta, KEY_TEMPORAL_ID, svcExt->temporal_id);
}
if ((p_Vid->active_sps->vui_parameters_present_flag &&
p_Vid->active_sps->vui_seq_parameters.pic_struct_present_flag &&
p_Vid->p_Cur->sei.type == H264_SEI_PIC_TIMING) ||
p_Vid->p_Cur->sei.pic_timing.pic_struct != 0) {
if (p_Vid->p_Cur->sei.pic_timing.pic_struct == 3 ||
p_Vid->p_Cur->sei.pic_timing.pic_struct == 5)
if (p_Vid->p_Cur->sei &&
((p_Vid->active_sps->vui_parameters_present_flag &&
p_Vid->active_sps->vui_seq_parameters.pic_struct_present_flag &&
p_Vid->p_Cur->sei->type == H264_SEI_PIC_TIMING) ||
p_Vid->p_Cur->sei->pic_timing.pic_struct != 0)) {
if (p_Vid->p_Cur->sei->pic_timing.pic_struct == 3 ||
p_Vid->p_Cur->sei->pic_timing.pic_struct == 5)
impl->mode = MPP_FRAME_FLAG_PAIRED_FIELD | MPP_FRAME_FLAG_TOP_FIRST;
if (p_Vid->p_Cur->sei.pic_timing.pic_struct == 4 ||
p_Vid->p_Cur->sei.pic_timing.pic_struct == 6)
if (p_Vid->p_Cur->sei->pic_timing.pic_struct == 4 ||
p_Vid->p_Cur->sei->pic_timing.pic_struct == 6)
impl->mode = MPP_FRAME_FLAG_PAIRED_FIELD | MPP_FRAME_FLAG_BOT_FIRST;
}

6
mpp/codec/dec/h264/h264d_pps.c
View File

@@ -140,7 +140,11 @@ MPP_RET process_pps(H264_SLICE_t *currSlice)
FUN_CHECK(ret = parser_pps(p_bitctx, &p_Cur->sps, cur_pps));
//!< MakePPSavailable
ASSERT(cur_pps->Valid == 1);
memcpy(&currSlice->p_Vid->ppsSet[cur_pps->pic_parameter_set_id], cur_pps, sizeof(H264_PPS_t));
if (!currSlice->p_Vid->ppsSet[cur_pps->pic_parameter_set_id]) {
currSlice->p_Vid->ppsSet[cur_pps->pic_parameter_set_id] = mpp_malloc(H264_PPS_t, 1);
}
memcpy(currSlice->p_Vid->ppsSet[cur_pps->pic_parameter_set_id], cur_pps, sizeof(H264_PPS_t));
p_Cur->p_Vid->spspps_update = 1;
return ret = MPP_OK;

10
mpp/codec/dec/h264/h264d_sei.c
View File

@@ -38,7 +38,7 @@ static MPP_RET interpret_picture_timing_info(
RK_U32 num_clock_ts[9] = {1, 1, 1, 2, 2, 3, 3, 2, 3};
struct h264_vui_t *vui_seq_parameters = NULL;
vui_seq_parameters = &(p_videoctx->spsSet[sei_msg->seq_parameter_set_id].vui_seq_parameters);
vui_seq_parameters = &(p_videoctx->spsSet[sei_msg->seq_parameter_set_id]->vui_seq_parameters);
pic_timing = &(sei_msg->pic_timing);
if (vui_seq_parameters->nal_hrd_parameters_present_flag) {
@@ -167,7 +167,7 @@ static MPP_RET interpret_buffering_period_info(
}
sei_msg->seq_parameter_set_id = seq_parameter_set_id;
vui_seq_parameters = &(p_videoctx->spsSet[sei_msg->seq_parameter_set_id].vui_seq_parameters);
vui_seq_parameters = &(p_videoctx->spsSet[sei_msg->seq_parameter_set_id]->vui_seq_parameters);
if (vui_seq_parameters->nal_hrd_parameters_present_flag) {
for (i = 0; i < vui_seq_parameters->vcl_hrd_parameters.cpb_cnt_minus1; i++) {
@@ -266,10 +266,14 @@ MPP_RET process_sei(H264_SLICE_t *currSlice)
{
RK_S32 tmp_byte = 0;
MPP_RET ret = MPP_ERR_UNKNOW;
H264_SEI_t *sei_msg = &currSlice->p_Cur->sei;
H264_SEI_t *sei_msg = NULL;
BitReadCtx_t *p_bitctx = &currSlice->p_Cur->bitctx;
RK_U32 next;
if (!currSlice->p_Cur->sei)
currSlice->p_Cur->sei = mpp_calloc(H264_SEI_t, 1);
sei_msg = currSlice->p_Cur->sei;
sei_msg->mvc_scalable_nesting_flag = 0; //init to false
sei_msg->p_Dec = currSlice->p_Dec;
do {

18
mpp/codec/dec/h264/h264d_slice.c
View File

@@ -181,7 +181,9 @@ static MPP_RET dec_ref_pic_marking(H264_SLICE_t *pSlice)
if (pSlice->adaptive_ref_pic_buffering_flag) {
RK_U32 i = 0;
do { //!< read Memory Management Control Operation
tmp_drpm = &pSlice->p_Cur->dec_ref_pic_marking_buffer[i];
if (!pSlice->p_Cur->dec_ref_pic_marking_buffer[i])
pSlice->p_Cur->dec_ref_pic_marking_buffer[i] = mpp_calloc(H264_DRPM_t, 1);
tmp_drpm = pSlice->p_Cur->dec_ref_pic_marking_buffer[i];
tmp_drpm->Next = NULL;
READ_UE(p_bitctx, &val); //!< mmco
tmp_drpm->memory_management_control_operation = val;
@@ -329,30 +331,30 @@ static MPP_RET set_slice_user_parmeters(H264_SLICE_t *currSlice)
//!< use parameter set
if (currSlice->pic_parameter_set_id >= 0 &&
currSlice->pic_parameter_set_id < MAXPPS) {
cur_pps = &p_Vid->ppsSet[currSlice->pic_parameter_set_id];
cur_pps = p_Vid->ppsSet[currSlice->pic_parameter_set_id];
cur_pps = (cur_pps && cur_pps->Valid) ? cur_pps : NULL;
}
VAL_CHECK(ret, cur_pps != NULL);
if (currSlice->mvcExt.valid) {
cur_sps = &p_Vid->subspsSet[cur_pps->seq_parameter_set_id].sps;
cur_subsps = &p_Vid->subspsSet[cur_pps->seq_parameter_set_id];
cur_subsps = p_Vid->subspsSet[cur_pps->seq_parameter_set_id];
cur_sps = &cur_subsps->sps;
if (cur_subsps->Valid) {
if ((RK_S32)currSlice->mvcExt.view_id == cur_subsps->view_id[0]) { // combine subsps to sps
p_Vid->active_mvc_sps_flag = 0;
cur_subsps = NULL;
cur_sps = &p_Vid->spsSet[cur_pps->seq_parameter_set_id];
cur_sps = p_Vid->spsSet[cur_pps->seq_parameter_set_id];
} else if ((RK_S32)currSlice->mvcExt.view_id == cur_subsps->view_id[1]) {
p_Vid->active_mvc_sps_flag = 1;
}
} else {
p_Vid->active_mvc_sps_flag = 0;
cur_sps = &p_Vid->spsSet[cur_pps->seq_parameter_set_id];
cur_sps = p_Vid->spsSet[cur_pps->seq_parameter_set_id];
cur_subsps = NULL;
}
} else {
p_Vid->active_mvc_sps_flag = 0;
cur_sps = &p_Vid->spsSet[cur_pps->seq_parameter_set_id];
cur_sps = p_Vid->spsSet[cur_pps->seq_parameter_set_id];
cur_subsps = NULL;
}
@@ -383,7 +385,7 @@ static MPP_RET set_slice_user_parmeters(H264_SLICE_t *currSlice)
*/
if (p_Vid->p_Dec->mvc_valid) {
struct h264_subsps_t *active_subsps = NULL;
active_subsps = &p_Vid->subspsSet[cur_pps->seq_parameter_set_id];
active_subsps = p_Vid->subspsSet[cur_pps->seq_parameter_set_id];
if (active_subsps->Valid)
p_Vid->active_subsps = active_subsps;
else

20
mpp/codec/dec/h264/h264d_sps.c
View File

@@ -267,8 +267,8 @@ static MPP_RET parser_sps(BitReadCtx_t *p_bitctx, H264_SPS_t *cur_sps, H264_DecC
}
READ_ONEBIT(p_bitctx, &cur_sps->vui_parameters_present_flag);
init_VUI(&cur_sps->vui_seq_parameters);
if (cur_sps->vui_parameters_present_flag) {
init_VUI(&cur_sps->vui_seq_parameters);
ret = read_VUI(p_bitctx, &cur_sps->vui_seq_parameters);
}
cur_sps->Valid = 1;
@@ -455,7 +455,11 @@ MPP_RET process_sps(H264_SLICE_t *currSlice)
FUN_CHECK(ret = get_max_dec_frame_buf_size(cur_sps));
//!< make SPS available, copy
if (cur_sps->Valid) {
memcpy(&currSlice->p_Vid->spsSet[cur_sps->seq_parameter_set_id], cur_sps, sizeof(H264_SPS_t));
if (!currSlice->p_Vid->spsSet[cur_sps->seq_parameter_set_id]) {
currSlice->p_Vid->spsSet[cur_sps->seq_parameter_set_id] = mpp_calloc(H264_SPS_t, 1);
}
memcpy(currSlice->p_Vid->spsSet[cur_sps->seq_parameter_set_id],
cur_sps, sizeof(H264_SPS_t));
}
p_Cur->p_Vid->spspps_update = 1;
@@ -517,9 +521,13 @@ MPP_RET process_subsps(H264_SLICE_t *currSlice)
MPP_RET ret = MPP_ERR_UNKNOW;
BitReadCtx_t *p_bitctx = &currSlice->p_Cur->bitctx;
H264_subSPS_t *cur_subsps = &currSlice->p_Cur->subsps;
H264_subSPS_t *cur_subsps = NULL;
H264_subSPS_t *p_subset = NULL;
if (!currSlice->p_Cur->subsps)
currSlice->p_Cur->subsps = mpp_calloc(H264_subSPS_t, 1);
cur_subsps = currSlice->p_Cur->subsps;
reset_cur_subpps_data(cur_subsps); //reset
FUN_CHECK(ret = parser_sps(p_bitctx, &cur_subsps->sps, currSlice->p_Dec));
@@ -530,7 +538,9 @@ MPP_RET process_subsps(H264_SLICE_t *currSlice)
}
get_max_dec_frame_buf_size(&cur_subsps->sps);
//!< make subSPS available
p_subset = &currSlice->p_Vid->subspsSet[cur_subsps->sps.seq_parameter_set_id];
if (!currSlice->p_Vid->subspsSet[cur_subsps->sps.seq_parameter_set_id])
currSlice->p_Vid->subspsSet[cur_subsps->sps.seq_parameter_set_id] = mpp_malloc(H264_subSPS_t, 1);
p_subset = currSlice->p_Vid->subspsSet[cur_subsps->sps.seq_parameter_set_id];
if (p_subset->Valid) {
recycle_subsps(p_subset);
}
@@ -538,7 +548,7 @@ MPP_RET process_subsps(H264_SLICE_t *currSlice)
return ret = MPP_OK;
__FAILED:
recycle_subsps(&currSlice->p_Cur->subsps);
recycle_subsps(currSlice->p_Cur->subsps);
return ret;
}

10
mpp/common/h264d_syntax.h
View File

@@ -132,21 +132,23 @@ typedef struct _DXVA_Slice_H264_Long {
RK_U16 first_mb_in_slice;
RK_U16 NumMbsForSlice;
RK_U16 BitOffsetToSliceData; /* after CABAC alignment */
RK_U8 slice_type;
RK_U8 luma_log2_weight_denom;
RK_U8 chroma_log2_weight_denom;
RK_U8 num_ref_idx_l0_active_minus1;
RK_U8 num_ref_idx_l1_active_minus1;
DXVA_PicEntry_H264 RefPicList[3][32]; /* L0 & L1 */
#if 0
RK_U16 BitOffsetToSliceData; /* after CABAC alignment */
RK_U8 luma_log2_weight_denom;
RK_U8 chroma_log2_weight_denom;
RK_S8 slice_alpha_c0_offset_div2;
RK_S8 slice_beta_offset_div2;
RK_U8 Reserved8Bits;
DXVA_PicEntry_H264 RefPicList[3][32]; /* L0 & L1 */
RK_S16 Weights[2][32][3][2]; /* L0 & L1; Y, Cb, Cr */
RK_S8 slice_qs_delta;
/* rest off-host parse */
RK_S8 slice_qp_delta;
#endif
RK_U8 redundant_pic_cnt;
RK_U8 direct_spatial_mv_pred_flag;
RK_U8 cabac_init_idc;