package/mpp
1
0
Fork 0
mirror of https://github.com/nyanmisaka/mpp.git synced 2025-10-14 21:25:42 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

[h264d] add slice ref_pic_list_reordering realization

Browse Source 
git-svn-id: https://10.10.10.66:8443/svn/MediaProcessPlatform/trunk/mpp@570 6e48237b-75ef-9749-8fc9-41990f28c85a
This commit is contained in:
DingWei
2016-02-04 05:41:08 +00:00
parent a6e84c414c
commit edf77a03c0
5 changed files with 68 additions and 192 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -167,6 +167,7 @@ static MPP_RET free_cur_ctx(H264dCurCtx_t *p_Cur)
INP_CHECK(ret, !p_Cur); INP_CHECK(ret, !p_Cur);
FunctionIn(p_Cur->p_Dec->logctx.parr[RUN_PARSE]); FunctionIn(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
if (p_Cur) { if (p_Cur) {
free_ref_pic_list_reordering_buffer(&p_Cur->slice);
recycle_slice(&p_Cur->slice); recycle_slice(&p_Cur->slice);
for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) { for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) {
MPP_FREE(p_Cur->listP[i]); MPP_FREE(p_Cur->listP[i]);
@@ -411,60 +412,7 @@ static void flush_dpb_buf_slot(H264_DecCtx_t *p_Dec)
} }
} }
#if 0
static MPP_RET set_frame_errinfo(H264_DecCtx_t *p_Dec, H264dErrCtx_t *err_ctx)
{
MPP_RET ret = MPP_ERR_UNKNOW;
MppFrame m_frame;
INP_CHECK(ret, !p_Dec && !err_ctx);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
if (!err_ctx->err_flag) {
goto __RETURN;
}
if(p_Dec->last_frame_slot_idx < 0){
err_ctx->err_flag |= VPU_FRAME_ERR_UNKNOW;
mpp_frame_init(&m_frame);
mpp_slots_get_prop(p_Dec->frame_slots, SLOTS_FRAME_INFO, m_frame);
mpp_buf_slot_get_unused(p_Dec->frame_slots, &p_Dec->last_frame_slot_idx);
mpp_buf_slot_set_prop(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, SLOT_FRAME, m_frame);
mpp_buf_slot_set_flag(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, SLOT_QUEUE_USE);
mpp_buf_slot_enqueue(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, QUEUE_DISPLAY);
mpp_buf_slot_clr_flag(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, SLOT_HAL_OUTPUT);
mpp_buf_slot_clr_flag(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, SLOT_CODEC_USE);
mpp_frame_deinit(&m_frame);
}
mpp_buf_slot_get_prop(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, SLOT_FRAME_PTR, &m_frame);
if (m_frame) {
H264D_LOG("slot_idx=%d, errorifo=%d, pts=%lld", p_Dec->last_frame_slot_idx, err_ctx->err_flag, mpp_frame_get_pts(m_frame));
mpp_frame_set_errinfo(m_frame, err_ctx->err_flag);
}
//!< memset error context
memset(&p_Dec->p_Vid->err_ctx, 0, sizeof(H264dErrCtx_t));
__RETURN:
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
return ret = MPP_OK;
}
static void get_pkt_timestamp(H264dCurStream_t *p_strm, H264dInputCtx_t *p_Inp, MppPacket pkt)
{
H264dTimeStamp_t *p_last = NULL, *p_curr = NULL;
if (!p_Inp->in_length) {
p_last = &p_strm->pkt_ts[p_strm->pkt_ts_idx];
p_strm->pkt_ts_idx = (p_strm->pkt_ts_idx + 1) % MAX_PTS_NUM ;
p_curr = &p_strm->pkt_ts[p_strm->pkt_ts_idx];
p_curr->begin_off = p_last->end_off;
p_curr->end_off = p_curr->begin_off + mpp_packet_get_length(pkt);
p_curr->pts = mpp_packet_get_pts(pkt);
p_curr->dts = mpp_packet_get_dts(pkt);
//mpp_log("[init_pts] prepare_pts=%lld, g_framecnt=%d \n",p_curr->pts, p_Inp->p_Vid->g_framecnt);
}
}
#endif
/*! /*!
*********************************************************************** ***********************************************************************
@@ -817,6 +765,9 @@ MPP_RET h264d_parse(void *decoder, HalDecTask *in_task)
in_task->valid = 0; // prepare end flag in_task->valid = 0; // prepare end flag
p_Dec->in_task = in_task; p_Dec->in_task = in_task;
p_Dec->errctx.err_flag = 0;
p_Dec->errctx.dpb_err_flag = 0;
p_Dec->errctx.used_for_ref_flag = 0;
FUN_CHECK(ret = parse_loop(p_Dec)); FUN_CHECK(ret = parse_loop(p_Dec));
if (p_Dec->is_parser_end) { if (p_Dec->is_parser_end) {

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

@@ -724,7 +724,7 @@ typedef struct h264_slice_t {
RK_U32 num_ref_idx_active[2]; //!< number of available list references RK_U32 num_ref_idx_active[2]; //!< number of available list references
RK_S32 num_ref_idx_override_flag; RK_S32 num_ref_idx_override_flag;
RK_S32 ref_pic_list_reordering_flag[2]; RK_S32 ref_pic_list_reordering_flag[2];
RK_S32 *modification_of_pic_nums_idc[2]; RK_U32 *modification_of_pic_nums_idc[2];
RK_U32 *abs_diff_pic_num_minus1[2]; RK_U32 *abs_diff_pic_num_minus1[2];
RK_U32 *long_term_pic_idx[2]; RK_U32 *long_term_pic_idx[2];
RK_U32 *abs_diff_view_idx_minus1[2]; RK_U32 *abs_diff_view_idx_minus1[2];

11
mpp/codec/dec/h264/h264d_parse.c
View File

@@ -96,6 +96,7 @@ static void reset_slice(H264dVideoCtx_t *p_Vid)
currSlice->listXsizeP[i] = 0; currSlice->listXsizeP[i] = 0;
currSlice->listXsizeB[i] = 0; currSlice->listXsizeB[i] = 0;
} }
free_ref_pic_list_reordering_buffer(currSlice);
FunctionOut(p_Vid->p_Dec->logctx.parr[RUN_PARSE]); FunctionOut(p_Vid->p_Dec->logctx.parr[RUN_PARSE]);
} }
@@ -157,8 +158,13 @@ static MPP_RET parser_nalu_header(H264_SLICE_t *currSlice)
LogInfo(p_bitctx->ctx, "================== NAL begin ==================="); LogInfo(p_bitctx->ctx, "================== NAL begin ===================");
READ_BITS(p_bitctx, 1, &cur_nal->forbidden_bit, "forbidden_bit"); READ_BITS(p_bitctx, 1, &cur_nal->forbidden_bit, "forbidden_bit");
ASSERT(cur_nal->forbidden_bit == 0); ASSERT(cur_nal->forbidden_bit == 0);
READ_BITS(p_bitctx, 2, ((RK_S32 *)&cur_nal->nal_reference_idc), "nal_ref_idc"); {
READ_BITS(p_bitctx, 5, ((RK_S32 *)&cur_nal->nalu_type), "nalu_type"); RK_S32 *ptmp = NULL;
ptmp = (RK_S32 *)&cur_nal->nal_reference_idc;
READ_BITS(p_bitctx, 2, ptmp, "nal_ref_idc");
ptmp = (RK_S32 *)&cur_nal->nalu_type;
READ_BITS(p_bitctx, 5, ptmp, "nalu_type");
}
//if (g_nalu_cnt0 == 2384) { //if (g_nalu_cnt0 == 2384) {
// g_nalu_cnt0 = g_nalu_cnt0; // g_nalu_cnt0 = g_nalu_cnt0;
//} //}
@@ -882,7 +888,6 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]); FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
//!< ==== loop ==== //!< ==== loop ====
p_curdata = p_Dec->p_Cur->strm.head_buf; p_curdata = p_Dec->p_Cur->strm.head_buf;
p_Dec->errctx.err_flag = 0;
while (while_loop_flag) { while (while_loop_flag) {
switch (p_Dec->next_state) { switch (p_Dec->next_state) {
case SliceSTATE_ResetSlice: case SliceSTATE_ResetSlice:

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

@@ -34,156 +34,29 @@ static void free_slice_drpm_buffer(H264_SLICE_t *currSlice) // dec_ref_pic_mark
MPP_FREE(tmp_drpm); MPP_FREE(tmp_drpm);
} }
} }
#if 0
static RK_S32 get_voidx(H264_subSPS_t *subset_spsSet, H264_subSPS_t **subset_sps, RK_S32 iViewId)
{
RK_S32 i = 0, iVOIdx = -1;
RK_S32 *piViewIdMap = NULL;
H264_subSPS_t *active_subset_sps = *subset_sps;
if (active_subset_sps) {
piViewIdMap = active_subset_sps->view_id;
for (iVOIdx = active_subset_sps->num_views_minus1; iVOIdx >= 0; iVOIdx--)
if (piViewIdMap[iVOIdx] == iViewId)
break;
} else {
for (i = 0; i < MAXSPS; i++) {
if (subset_spsSet[i].num_views_minus1 >= 0 && subset_spsSet[i].sps.Valid) {
break;
}
}
if (i < MAXSPS) {
*subset_sps = active_subset_sps = &subset_spsSet[i];
piViewIdMap = active_subset_sps->view_id;
for (iVOIdx = active_subset_sps->num_views_minus1; iVOIdx >= 0; iVOIdx--)
if (piViewIdMap[iVOIdx] == iViewId)
break;
return iVOIdx;
} else {
iVOIdx = 0;
}
}
return iVOIdx;
}
static RK_U32 is_new_picture(H264_SLICE_t *currSlice)
{
RK_U32 is_new_pic_flag = 0;
RK_S32 result = 0, result1 = 0;
H264dVideoCtx_t *p_Vid = currSlice->p_Vid;
H264_OldSlice_t *p_old_slice = &currSlice->p_Vid->old_slice;
currSlice->is_new_picture_flag = 0;
if (p_old_slice == NULL) { // fist slice
is_new_pic_flag = 1;
goto __Updata;
} else {
result |= (currSlice->start_mb_nr == 0);
result |= (p_old_slice->pps_id != (RK_S32)currSlice->pic_parameter_set_id);
result |= (p_old_slice->frame_num != currSlice->frame_num);
result |= (p_old_slice->field_pic_flag != currSlice->field_pic_flag);
if (currSlice->field_pic_flag && p_old_slice->field_pic_flag) {
result |= (p_old_slice->bottom_field_flag != currSlice->bottom_field_flag);
}
if (p_Vid->old_slice.current_mb_nr != 0) {
if (currSlice->mb_aff_frame_flag)
result |= (currSlice->start_mb_nr << 1) < (p_Vid->old_slice.current_mb_nr);
else
result |= currSlice->start_mb_nr < p_Vid->old_slice.current_mb_nr;
}
result |= (p_old_slice->nal_ref_idc != currSlice->nal_reference_idc)
&& ((p_old_slice->nal_ref_idc == 0) || (currSlice->nal_reference_idc == 0));
result |= (p_old_slice->idr_flag != currSlice->idr_flag);
if (currSlice->idr_flag && p_old_slice->idr_flag) {
result |= (p_old_slice->idr_pic_id != (RK_S32)currSlice->idr_pic_id);
}
if (p_Vid->active_sps->pic_order_cnt_type == 0) {
result1 |= (p_old_slice->pic_oder_cnt_lsb != currSlice->pic_order_cnt_lsb);
if (p_Vid->active_pps->bottom_field_pic_order_in_frame_present_flag && !currSlice->field_pic_flag) {
result1 |= (p_old_slice->delta_pic_oder_cnt_bottom != currSlice->delta_pic_order_cnt_bottom);
}
} else if (p_Vid->active_sps->pic_order_cnt_type == 1) {
if (!p_Vid->active_sps->delta_pic_order_always_zero_flag) {
result1 |= (p_old_slice->delta_pic_order_cnt[0] != currSlice->delta_pic_order_cnt[0]);
if (p_Vid->active_pps->bottom_field_pic_order_in_frame_present_flag && !currSlice->field_pic_flag) {
result1 |= (p_old_slice->delta_pic_order_cnt[1] != currSlice->delta_pic_order_cnt[1]);
}
}
} else {
result1 |= (p_old_slice->frame_num != currSlice->frame_num);
}
result |= (currSlice->view_id != p_old_slice->view_id);
result |= (currSlice->inter_view_flag != p_old_slice->inter_view_flag);
result |= (currSlice->anchor_pic_flag != p_old_slice->anchor_pic_flag);
result |= (currSlice->layer_id != p_old_slice->layer_id);
}
if (result) {
is_new_pic_flag = 1;
goto __Updata;
} else {
return is_new_pic_flag = 0;
}
__Updata:
currSlice->is_new_picture_flag = 1;
p_old_slice->current_mb_nr = currSlice->current_mb_nr;
p_old_slice->pps_id = currSlice->pic_parameter_set_id;
p_old_slice->frame_num = currSlice->frame_num; //p_Vid->frame_num;
p_old_slice->field_pic_flag = currSlice->field_pic_flag; //p_Vid->field_pic_flag;
if (currSlice->field_pic_flag) {
p_old_slice->bottom_field_flag = currSlice->bottom_field_flag;
}
p_old_slice->nal_ref_idc = currSlice->nal_reference_idc;
p_old_slice->idr_flag = currSlice->idr_flag;
if (currSlice->idr_flag) {
p_old_slice->idr_pic_id = currSlice->idr_pic_id;
}
if (p_Vid->active_sps->pic_order_cnt_type == 0) {
p_old_slice->pic_oder_cnt_lsb = currSlice->pic_order_cnt_lsb;
p_old_slice->delta_pic_oder_cnt_bottom = currSlice->delta_pic_order_cnt_bottom;
}
if (p_Vid->active_sps->pic_order_cnt_type == 1) {
p_old_slice->delta_pic_order_cnt[0] = currSlice->delta_pic_order_cnt[0];
p_old_slice->delta_pic_order_cnt[1] = currSlice->delta_pic_order_cnt[1];
}
p_old_slice->view_id = currSlice->view_id;
p_old_slice->inter_view_flag = currSlice->inter_view_flag;
p_old_slice->anchor_pic_flag = currSlice->anchor_pic_flag;
p_old_slice->layer_id = currSlice->layer_id;
return is_new_pic_flag;
}
#endif
static MPP_RET ref_pic_list_mvc_modification(H264_SLICE_t *currSlice) static MPP_RET ref_pic_list_mvc_modification(H264_SLICE_t *currSlice)
{ {
RK_U32 i = 0; RK_U32 i = 0;
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
RK_U32 modification_of_pic_nums_idc = 0; RK_U32 modification_of_pic_nums_idc = 0;
RK_U32 abs_diff_pic_num_minus1 = 0;
RK_U32 long_term_pic_idx = 0;
RK_U32 abs_diff_view_idx_minus1 = 0;
BitReadCtx_t *p_bitctx = &currSlice->p_Cur->bitctx; BitReadCtx_t *p_bitctx = &currSlice->p_Cur->bitctx;
alloc_ref_pic_list_reordering_buffer(currSlice);
if ((currSlice->slice_type % 5) != I_SLICE && (currSlice->slice_type % 5) != SI_SLICE) { if ((currSlice->slice_type % 5) != I_SLICE && (currSlice->slice_type % 5) != SI_SLICE) {
READ_ONEBIT(p_bitctx, &currSlice->ref_pic_list_reordering_flag[LIST_0], "ref_pic_list_reordering_flag"); READ_ONEBIT(p_bitctx, &currSlice->ref_pic_list_reordering_flag[LIST_0], "ref_pic_list_reordering_flag");
if (currSlice->ref_pic_list_reordering_flag[LIST_0]) { if (currSlice->ref_pic_list_reordering_flag[LIST_0]) {
i = 0; i = 0;
do { do {
READ_UE(p_bitctx, &modification_of_pic_nums_idc, "modification_of_pic_nums_idc"); READ_UE(p_bitctx, &modification_of_pic_nums_idc, "modification_of_pic_nums_idc");
currSlice->modification_of_pic_nums_idc[LIST_0][i] = modification_of_pic_nums_idc;
if (modification_of_pic_nums_idc == 0 || modification_of_pic_nums_idc == 1) { if (modification_of_pic_nums_idc == 0 || modification_of_pic_nums_idc == 1) {
READ_UE(p_bitctx, &abs_diff_pic_num_minus1, "abs_diff_pic_num_minus1_lx"); READ_UE(p_bitctx, &currSlice->abs_diff_pic_num_minus1[LIST_0][i], "abs_diff_pic_num_minus1_lx");
} else { } else {
if (modification_of_pic_nums_idc == 2) { if (modification_of_pic_nums_idc == 2) {
READ_UE(p_bitctx, &long_term_pic_idx, "long_term_pic_idx"); READ_UE(p_bitctx, &currSlice->long_term_pic_idx[LIST_0][i], "long_term_pic_idx");
} else if (modification_of_pic_nums_idc == 4 || modification_of_pic_nums_idc == 5) { } else if (modification_of_pic_nums_idc == 4 || modification_of_pic_nums_idc == 5) {
READ_UE(p_bitctx, &abs_diff_view_idx_minus1, "abs_diff_view_idx_minus1"); READ_UE(p_bitctx, &currSlice->abs_diff_view_idx_minus1[LIST_0][i], "abs_diff_view_idx_minus1");
} }
} }
i++; i++;
@@ -196,13 +69,14 @@ static MPP_RET ref_pic_list_mvc_modification(H264_SLICE_t *currSlice)
i = 0; i = 0;
do { do {
READ_UE(p_bitctx, &modification_of_pic_nums_idc, "modification_of_pic_nums_idc"); READ_UE(p_bitctx, &modification_of_pic_nums_idc, "modification_of_pic_nums_idc");
currSlice->modification_of_pic_nums_idc[LIST_1][i] = modification_of_pic_nums_idc;
if (modification_of_pic_nums_idc == 0 || modification_of_pic_nums_idc == 1) { if (modification_of_pic_nums_idc == 0 || modification_of_pic_nums_idc == 1) {
READ_UE(p_bitctx, &abs_diff_pic_num_minus1, "abs_diff_pic_num_minus1_lx"); READ_UE(p_bitctx, &currSlice->abs_diff_pic_num_minus1[LIST_1][i], "abs_diff_pic_num_minus1_lx");
} else { } else {
if (modification_of_pic_nums_idc == 2) { if (modification_of_pic_nums_idc == 2) {
READ_UE(p_bitctx, &long_term_pic_idx, "long_term_pic_idx"); READ_UE(p_bitctx, &currSlice->long_term_pic_idx[LIST_1][i], "long_term_pic_idx");
} else if (modification_of_pic_nums_idc == 4 || modification_of_pic_nums_idc == 5) { } else if (modification_of_pic_nums_idc == 4 || modification_of_pic_nums_idc == 5) {
READ_UE(p_bitctx, &abs_diff_view_idx_minus1, "abs_diff_view_idx_minus1"); READ_UE(p_bitctx, &currSlice->abs_diff_view_idx_minus1[LIST_1][i], "abs_diff_view_idx_minus1");
} }
} }
i++; i++;
@@ -391,6 +265,7 @@ static MPP_RET set_slice_user_parmeters(H264_SLICE_t *currSlice)
cur_subsps = NULL; cur_subsps = NULL;
} }
ASSERT(cur_sps->separate_colour_plane_flag == 0); ASSERT(cur_sps->separate_colour_plane_flag == 0);
H264D_LOG("currSlice->pps_id=%d, cur_sps->sps_id=%d", currSlice->pic_parameter_set_id, cur_sps->seq_parameter_set_id);
FUN_CHECK(ret = activate_sps(p_Vid, cur_sps, cur_subsps)); FUN_CHECK(ret = activate_sps(p_Vid, cur_sps, cur_subsps));
FUN_CHECK(ret = activate_pps(p_Vid, cur_pps)); FUN_CHECK(ret = activate_pps(p_Vid, cur_pps));
//!< Set SPS to the subset SPS parameters //!< Set SPS to the subset SPS parameters
@@ -420,6 +295,49 @@ void recycle_slice(H264_SLICE_t *currSlice)
free_slice_drpm_buffer(currSlice); free_slice_drpm_buffer(currSlice);
} }
} }
void free_ref_pic_list_reordering_buffer(H264_SLICE_t *currSlice)
{
if (currSlice) {
MPP_FREE(currSlice->modification_of_pic_nums_idc[LIST_0]);
MPP_FREE(currSlice->abs_diff_pic_num_minus1[LIST_0]);
MPP_FREE(currSlice->long_term_pic_idx[LIST_0]);
MPP_FREE(currSlice->modification_of_pic_nums_idc[LIST_1]);
MPP_FREE(currSlice->abs_diff_pic_num_minus1[LIST_1]);
MPP_FREE(currSlice->long_term_pic_idx[LIST_1]);
MPP_FREE(currSlice->abs_diff_view_idx_minus1[LIST_0]);
MPP_FREE(currSlice->abs_diff_view_idx_minus1[LIST_1]);
}
}
MPP_RET alloc_ref_pic_list_reordering_buffer(H264_SLICE_t *currSlice)
{
MPP_RET ret = MPP_ERR_UNKNOW;
currSlice->modification_of_pic_nums_idc[LIST_0] = NULL;
currSlice->abs_diff_pic_num_minus1[LIST_0] = NULL;
currSlice->long_term_pic_idx[LIST_0] = NULL;
currSlice->abs_diff_view_idx_minus1[LIST_0] = NULL;
if (currSlice->slice_type != I_SLICE && currSlice->slice_type != SI_SLICE) {
RK_U32 size = currSlice->num_ref_idx_active[LIST_0] + 1;
MEM_CHECK(ret, currSlice->modification_of_pic_nums_idc[LIST_0] = mpp_calloc(RK_U32, size));
MEM_CHECK(ret, currSlice->abs_diff_pic_num_minus1[LIST_0] = mpp_calloc(RK_U32, size));
MEM_CHECK(ret, currSlice->long_term_pic_idx[LIST_0] = mpp_calloc(RK_U32, size));
MEM_CHECK(ret, currSlice->abs_diff_view_idx_minus1[LIST_0] = mpp_calloc(RK_U32, size));
}
currSlice->modification_of_pic_nums_idc[LIST_1] = NULL;
currSlice->abs_diff_pic_num_minus1[LIST_1] = NULL;
currSlice->long_term_pic_idx[LIST_1] = NULL;
currSlice->abs_diff_view_idx_minus1[LIST_1] = NULL;
if (currSlice->slice_type == B_SLICE) {
RK_U32 size = currSlice->num_ref_idx_active[LIST_1] + 1;
MEM_CHECK(ret, currSlice->modification_of_pic_nums_idc[LIST_1] = mpp_calloc(RK_U32, size));
MEM_CHECK(ret, currSlice->abs_diff_pic_num_minus1[LIST_1] = mpp_calloc(RK_U32, size));
MEM_CHECK(ret, currSlice->long_term_pic_idx[LIST_1] = mpp_calloc(RK_U32, size));
MEM_CHECK(ret, currSlice->abs_diff_view_idx_minus1[LIST_1] = mpp_calloc(RK_U32, size));
}
return ret = MPP_OK;
__FAILED:
free_ref_pic_list_reordering_buffer(currSlice);
return ret;
}
/*! /*!
*********************************************************************** ***********************************************************************
* \brief * \brief

2
mpp/codec/dec/h264/h264d_slice.h
View File

@@ -27,6 +27,8 @@
extern "C" { extern "C" {
#endif #endif
void free_ref_pic_list_reordering_buffer(H264_SLICE_t *currSlice);
MPP_RET alloc_ref_pic_list_reordering_buffer(H264_SLICE_t *currSlice);
void recycle_slice(H264_SLICE_t *currSlice); void recycle_slice(H264_SLICE_t *currSlice);
MPP_RET process_slice(H264_SLICE_t *currSlice); MPP_RET process_slice(H264_SLICE_t *currSlice);