package/mpp
1
0
Fork 0
mirror of https://github.com/nyanmisaka/mpp.git synced 2025-10-05 09:06:50 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

[astyle]: format coding style

Browse Source 
git-svn-id: https://10.10.10.66:8443/svn/MediaProcessPlatform/trunk/mpp@539 6e48237b-75ef-9749-8fc9-41990f28c85a
This commit is contained in:
ChenHengming
2016-01-20 09:45:56 +00:00
parent 9f274ee171
commit 4bf0d086a3
34 changed files with 1670 additions and 1677 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
inc/vpu_api.h
View File

@@ -207,8 +207,8 @@ typedef enum VPU_API_ERR {
} VPU_API_ERR;
typedef enum VPU_FRAME_ERR {
VPU_FRAME_ERR_UNKNOW = 0x0001,
VPU_FRAME_ERR_UNSUPPORT = 0x0002,
VPU_FRAME_ERR_UNKNOW = 0x0001,
VPU_FRAME_ERR_UNSUPPORT = 0x0002,
} VPU_FRAME_ERR;

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

@@ -250,9 +250,9 @@ static MPP_RET init_vid_ctx(H264dVideoCtx_t *p_Vid)
p_Vid->p_Dpb_layer[i]->layer_id = i;
p_Vid->p_Dpb_layer[i]->p_Vid = p_Vid;
p_Vid->p_Dpb_layer[i]->init_done = 0;
memset(&p_Vid->outlist[i], 0, sizeof(p_Vid->outlist[i]));
p_Vid->outlist[i].max_size = MAX_MARK_SIZE;
p_Vid->last_outputpoc[i] = -1;
memset(&p_Vid->outlist[i], 0, sizeof(p_Vid->outlist[i]));
p_Vid->outlist[i].max_size = MAX_MARK_SIZE;
p_Vid->last_outputpoc[i] = -1;
}
//!< init video pars
for (i = 0; i < MAXSPS; i++) {
@@ -274,7 +274,7 @@ static MPP_RET init_vid_ctx(H264dVideoCtx_t *p_Vid)
p_Vid->subspsSet[i].num_views_minus1 = -1;
p_Vid->subspsSet[i].num_level_values_signalled_minus1 = -1;
}
p_Vid->has_get_i_frame_flag = 0;
p_Vid->has_get_i_frame_flag = 0;
FunctionOut(p_Vid->p_Dec->logctx.parr[RUN_PARSE]);
__RETURN:
return ret = MPP_OK;
@@ -306,7 +306,7 @@ static MPP_RET init_dxva_ctx(H264dDxvaCtx_t *p_dxva)
INP_CHECK(ret, !p_dxva);
FunctionIn(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
p_dxva->slice_count = 0;
p_dxva->slice_count = 0;
p_dxva->max_slice_size = MAX_SLICE_SIZE;
p_dxva->max_strm_size = FRAME_BUF_MAX_SIZE;
p_dxva->slice_long = mpp_calloc(DXVA_Slice_H264_Long, p_dxva->max_slice_size);
@@ -352,11 +352,11 @@ static MPP_RET init_dec_ctx(H264_DecCtx_t *p_Dec)
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
p_Dec->mem = mpp_calloc(H264_DecMem_t, 1);
MEM_CHECK(ret, p_Dec->mem);
p_Dec->dpb_mark = p_Dec->mem->dpb_mark; //!< for write out, MAX_DPB_SIZE
p_Dec->dpb_info = p_Dec->mem->dpb_info; //!< 16
p_Dec->dpb_old[0] = p_Dec->mem->dpb_old[0];
p_Dec->dpb_old[1] = p_Dec->mem->dpb_old[1];
p_Dec->refpic_info_p = p_Dec->mem->refpic_info_p; //!< 32
p_Dec->dpb_mark = p_Dec->mem->dpb_mark; //!< for write out, MAX_DPB_SIZE
p_Dec->dpb_info = p_Dec->mem->dpb_info; //!< 16
p_Dec->dpb_old[0] = p_Dec->mem->dpb_old[0];
p_Dec->dpb_old[1] = p_Dec->mem->dpb_old[1];
p_Dec->refpic_info_p = p_Dec->mem->refpic_info_p; //!< 32
p_Dec->refpic_info_b[0] = p_Dec->mem->refpic_info_b[0]; //!< [2][32]
p_Dec->refpic_info_b[1] = p_Dec->mem->refpic_info_b[1]; //!< [2][32]
//!< init dxva memory
@@ -372,18 +372,18 @@ static MPP_RET init_dec_ctx(H264_DecCtx_t *p_Dec)
p_Dec->dpb_mark[i].pic = NULL;
mpp_frame_init(&p_Dec->dpb_mark[i].frame);
}
mpp_buf_slot_setup(p_Dec->frame_slots, MAX_MARK_SIZE);
mpp_buf_slot_setup(p_Dec->frame_slots, MAX_MARK_SIZE);
//!< malloc mpp packet
mpp_packet_init(&p_Dec->task_pkt, p_Dec->dxva_ctx->bitstream, p_Dec->dxva_ctx->max_strm_size);
MEM_CHECK(ret, p_Dec->task_pkt);
//!< memset error context
memset(&p_Dec->err_ctx, 0, sizeof(H264dErrCtx_t));
//!< memset error context
memset(&p_Dec->err_ctx, 0, sizeof(H264dErrCtx_t));
//!< set Dec support decoder method
p_Dec->spt_decode_mtds = MPP_DEC_BY_FRAME;
p_Dec->next_state = SliceSTATE_ResetSlice;
p_Dec->nalu_ret = NALU_NULL;
p_Dec->is_first_frame = 1;
p_Dec->last_frame_slot_idx = -1;
p_Dec->last_frame_slot_idx = -1;
__RETURN:
return ret = MPP_OK;
@@ -396,20 +396,20 @@ __FAILED:
#if 0
static void get_pkt_timestamp(H264dCurStream_t *p_strm, H264dInputCtx_t *p_Inp, MppPacket pkt)
{
H264dTimeStamp_t *p_last = NULL, *p_curr = NULL;
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];
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);
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);
}
//mpp_log("[init_pts] prepare_pts=%lld, g_framecnt=%d \n",p_curr->pts, p_Inp->p_Vid->g_framecnt);
}
}
#endif
@@ -474,7 +474,7 @@ MPP_RET h264d_deinit(void *decoder)
INP_CHECK(ret, !decoder);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
h264d_flush(decoder);
h264d_flush(decoder);
free_input_ctx(p_Dec->p_Inp);
MPP_FREE(p_Dec->p_Inp);
free_cur_ctx(p_Dec->p_Cur);
@@ -499,7 +499,7 @@ MPP_RET h264d_reset(void *decoder)
RK_U32 i = 0;
MPP_RET ret = MPP_ERR_UNKNOW;
H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
H264dCurStream_t *p_strm = NULL;
H264dCurStream_t *p_strm = NULL;
INP_CHECK(ret, !decoder);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
@@ -508,24 +508,24 @@ MPP_RET h264d_reset(void *decoder)
//!< reset input parameter
p_Dec->p_Inp->in_buf = NULL;
p_Dec->p_Inp->pkt_eos = 0;
p_Dec->p_Inp->task_eos = 0;
p_Dec->p_Inp->in_pts = 0;
p_Dec->p_Inp->in_dts = 0;
p_Dec->p_Inp->task_eos = 0;
p_Dec->p_Inp->in_pts = 0;
p_Dec->p_Inp->in_dts = 0;
p_Dec->p_Inp->out_buf = NULL;
p_Dec->p_Inp->out_length = 0;
p_Dec->p_Inp->has_get_eos = 0;
p_Dec->p_Inp->has_get_eos = 0;
//!< reset video parameter
p_Dec->p_Vid->g_framecnt = 0;
p_Dec->p_Vid->last_outputpoc[0] = -1;
p_Dec->p_Vid->last_outputpoc[1] = -1;
p_Dec->p_Vid->has_get_i_frame_flag = 0;
//!< reset current time stamp
p_Dec->p_Cur->last_dts = 0;
p_Dec->p_Cur->last_pts = 0;
p_Dec->p_Cur->curr_dts = 0;
p_Dec->p_Cur->curr_pts = 0;
p_Dec->p_Vid->last_outputpoc[0] = -1;
p_Dec->p_Vid->last_outputpoc[1] = -1;
p_Dec->p_Vid->has_get_i_frame_flag = 0;
//!< reset current time stamp
p_Dec->p_Cur->last_dts = 0;
p_Dec->p_Cur->last_pts = 0;
p_Dec->p_Cur->curr_dts = 0;
p_Dec->p_Cur->curr_pts = 0;
//!< reset current stream
p_strm = &p_Dec->p_Cur->strm;
p_strm = &p_Dec->p_Cur->strm;
p_strm->prefixdata[0] = 0xff;
p_strm->prefixdata[1] = 0xff;
p_strm->prefixdata[2] = 0xff;
@@ -534,10 +534,10 @@ MPP_RET h264d_reset(void *decoder)
p_strm->head_offset = 0;
p_strm->startcode_found = 0;
p_strm->endcode_found = 0;
p_strm->pkt_ts_idx = 0;
p_strm->pkt_used_bytes = 0;
p_strm->startcode_found = p_Dec->p_Inp->is_nalff;
memset(p_strm->pkt_ts, 0, MAX_PTS_NUM*sizeof(H264dTimeStamp_t));
p_strm->pkt_ts_idx = 0;
p_strm->pkt_used_bytes = 0;
p_strm->startcode_found = p_Dec->p_Inp->is_nalff;
memset(p_strm->pkt_ts, 0, MAX_PTS_NUM * sizeof(H264dTimeStamp_t));
//!< reset decoder parameter
p_Dec->next_state = SliceSTATE_ResetSlice;
p_Dec->nalu_ret = NALU_NULL;
@@ -547,15 +547,15 @@ MPP_RET h264d_reset(void *decoder)
p_Dec->dxva_ctx->strm_offset = 0;
p_Dec->dxva_ctx->slice_count = 0;
memset(p_Dec->dpb_old[0], 0, MAX_DPB_SIZE * sizeof(H264_DpbInfo_t));
memset(p_Dec->dpb_old[1], 0, MAX_DPB_SIZE * sizeof(H264_DpbInfo_t));
memset(p_Dec->dpb_old[0], 0, MAX_DPB_SIZE * sizeof(H264_DpbInfo_t));
memset(p_Dec->dpb_old[1], 0, MAX_DPB_SIZE * sizeof(H264_DpbInfo_t));
//!< reset dpb
FUN_CHECK(ret = flush_dpb(p_Dec->p_Vid->p_Dpb_layer[0], 1));
FUN_CHECK(ret = flush_dpb(p_Dec->p_Vid->p_Dpb_layer[0], 1));
FUN_CHECK(ret = init_dpb(p_Dec->p_Vid, p_Dec->p_Vid->p_Dpb_layer[0], 1));
if (p_Dec->mvc_valid)
{ // layer_id == 1
FUN_CHECK(ret = flush_dpb(p_Dec->p_Vid->p_Dpb_layer[1], 1));
if (p_Dec->mvc_valid) {
// layer_id == 1
FUN_CHECK(ret = flush_dpb(p_Dec->p_Vid->p_Dpb_layer[1], 1));
FUN_CHECK(ret = init_dpb(p_Dec->p_Vid, p_Dec->p_Vid->p_Dpb_layer[1], 2));
}
for (i = 0; i < MAX_MARK_SIZE; i++) {
@@ -583,26 +583,26 @@ MPP_RET h264d_flush(void *decoder)
{
MPP_RET ret = MPP_ERR_UNKNOW;
H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
//MppFrame m_frame;
//MppFrame m_frame;
INP_CHECK(ret, !decoder);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
FUN_CHECK(ret = flush_dpb(p_Dec->p_Vid->p_Dpb_layer[0], 1));
FUN_CHECK(ret = init_dpb(p_Dec->p_Vid, p_Dec->p_Vid->p_Dpb_layer[0], 1));
//free_dpb(p_Dec->p_Vid->p_Dpb_layer[0]);
if (p_Dec->mvc_valid)
{ // layer_id == 1
if (p_Dec->mvc_valid) {
// layer_id == 1
FUN_CHECK(ret = flush_dpb(p_Dec->p_Vid->p_Dpb_layer[1], 2));
FUN_CHECK(ret = init_dpb(p_Dec->p_Vid, p_Dec->p_Vid->p_Dpb_layer[1], 2));
//free_dpb(p_Dec->p_Vid->p_Dpb_layer[1]);
flush_muti_view_output(p_Dec->frame_slots, p_Dec->p_Vid->outlist, p_Dec->p_Vid);
flush_muti_view_output(p_Dec->frame_slots, p_Dec->p_Vid->outlist, p_Dec->p_Vid);
}
H264D_LOG("[FLUSH] -------- flush over.------, task_eos=%d, last_slot_idx=%d", p_Dec->p_Inp->task_eos, p_Dec->last_frame_slot_idx);
H264D_LOG("[FLUSH] -------- flush over.------, task_eos=%d, last_slot_idx=%d", p_Dec->p_Inp->task_eos, p_Dec->last_frame_slot_idx);
//mpp_buf_slot_get_prop(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, SLOT_FRAME_PTR, &m_frame);
//mpp_buf_slot_get_prop(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, SLOT_FRAME_PTR, &m_frame);
mpp_buf_slot_set_prop(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, SLOT_EOS, &p_Dec->p_Inp->task_eos);
FPRINT(g_debug_file0, "[FLUSH] -------- flush over.------\n");
FPRINT(g_debug_file0, "[FLUSH] -------- flush over.------\n");
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
__RETURN:
return ret = MPP_OK;
@@ -647,83 +647,83 @@ MPP_RET h264d_prepare(void *decoder, MppPacket pkt, HalDecTask *task)
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
//LogTrace(logctx, "Prepare In:len=%d, valid=%d ", mpp_packet_get_length(pkt), task->valid);
if (p_Dec->p_Inp->has_get_eos || p_Dec->err_ctx.err_flag) {
((MppPacketImpl *)pkt)->length = 0;
goto __RETURN;
}
p_Dec->p_Inp->in_pkt = pkt;
p_Dec->p_Inp->in_pts = mpp_packet_get_pts(pkt);
p_Dec->p_Inp->in_dts = mpp_packet_get_dts(pkt);
//get_pkt_timestamp(&p_Dec->p_Cur->strm, p_Dec->p_Inp, pkt);
if (p_Dec->p_Inp->has_get_eos || p_Dec->err_ctx.err_flag) {
((MppPacketImpl *)pkt)->length = 0;
goto __RETURN;
}
p_Dec->p_Inp->in_pkt = pkt;
p_Dec->p_Inp->in_pts = mpp_packet_get_pts(pkt);
p_Dec->p_Inp->in_dts = mpp_packet_get_dts(pkt);
//get_pkt_timestamp(&p_Dec->p_Cur->strm, p_Dec->p_Inp, pkt);
if (mpp_packet_get_eos(pkt)) {
p_Dec->p_Inp->in_buf = NULL;
p_Dec->p_Inp->in_length = 0;
p_Dec->p_Inp->pkt_eos = 1;
p_Dec->p_Inp->has_get_eos = 1;
} else {
p_Dec->p_Inp->in_buf = (RK_U8 *)mpp_packet_get_pos(pkt);
p_Dec->p_Inp->in_length = mpp_packet_get_length(pkt);
p_Dec->p_Inp->pkt_eos = 0;
if (mpp_packet_get_eos(pkt)) {
p_Dec->p_Inp->in_buf = NULL;
p_Dec->p_Inp->in_length = 0;
p_Dec->p_Inp->pkt_eos = 1;
p_Dec->p_Inp->has_get_eos = 1;
} else {
p_Dec->p_Inp->in_buf = (RK_U8 *)mpp_packet_get_pos(pkt);
p_Dec->p_Inp->in_length = mpp_packet_get_length(pkt);
p_Dec->p_Inp->pkt_eos = 0;
FPRINT(g_debug_file1, "[nal_ff_data] %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
p_Dec->p_Inp->in_buf[0],
p_Dec->p_Inp->in_buf[1],
p_Dec->p_Inp->in_buf[2],
p_Dec->p_Inp->in_buf[3],
p_Dec->p_Inp->in_buf[4],
p_Dec->p_Inp->in_buf[5],
p_Dec->p_Inp->in_buf[6],
p_Dec->p_Inp->in_buf[7],
p_Dec->p_Inp->in_buf[8]);
}
//mpp_log("mpp_packet_get_flag(pkt)=%d\n", mpp_packet_get_flag(pkt));
FPRINT(g_debug_file1, "[nal_ff_data] %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
p_Dec->p_Inp->in_buf[0],
p_Dec->p_Inp->in_buf[1],
p_Dec->p_Inp->in_buf[2],
p_Dec->p_Inp->in_buf[3],
p_Dec->p_Inp->in_buf[4],
p_Dec->p_Inp->in_buf[5],
p_Dec->p_Inp->in_buf[6],
p_Dec->p_Inp->in_buf[7],
p_Dec->p_Inp->in_buf[8]);
}
//mpp_log("mpp_packet_get_flag(pkt)=%d\n", mpp_packet_get_flag(pkt));
if (mpp_packet_get_flag(pkt)& MPP_PACKET_FLAG_EXTRA_DATA) {
RK_U8 *pdata = p_Dec->p_Inp->in_buf;
p_Dec->p_Inp->is_nalff = (p_Dec->p_Inp->in_length > 3)&& (pdata[0] && pdata[1]);
if (mpp_packet_get_flag(pkt)& MPP_PACKET_FLAG_EXTRA_DATA) {
RK_U8 *pdata = p_Dec->p_Inp->in_buf;
p_Dec->p_Inp->is_nalff = (p_Dec->p_Inp->in_length > 3) && (pdata[0] && pdata[1]);
if (p_Dec->p_Inp->is_nalff) {
(ret = parse_prepare_extra_header(p_Dec->p_Inp, p_Dec->p_Cur));
goto __RETURN;
}
}
//mpp_log("p_Dec->p_Inp->is_nalff=%d, len=%d \n", p_Dec->p_Inp->is_nalff, p_Dec->p_Inp->in_length);
if (p_Dec->p_Inp->is_nalff) {
(ret = parse_prepare_extra_header(p_Dec->p_Inp, p_Dec->p_Cur));
goto __RETURN;
}
}
//mpp_log("p_Dec->p_Inp->is_nalff=%d, len=%d \n", p_Dec->p_Inp->is_nalff, p_Dec->p_Inp->in_length);
//mpp_err("[timePkt_in] pts=%lld, dts=%lld", p_Dec->p_Inp->pts, p_Dec->p_Inp->dts);
//mpp_err("[timePkt_in] pts=%lld, dts=%lld", p_Dec->p_Inp->pts, p_Dec->p_Inp->dts);
//LogTrace(logctx, "[Prepare_In] in_length=%d, eos=%d, g_framecnt=%d", mpp_packet_get_length(pkt), mpp_packet_get_eos(pkt), p_Dec->p_Vid->g_framecnt);
//FPRINT(g_debug_file0, "[Prepare_In] in_length=%d, eos=%d, g_framecnt=%d \n", mpp_packet_get_length(pkt), mpp_packet_get_eos(pkt), p_Dec->p_Vid->g_framecnt);
H264D_LOG("[ pkt_in timeUs ] p_Inp_is_nalff=%d, preprare input_pts=%lld, pkt_eos=%d, len=%d, g_framecnt=%d \n",
p_Dec->p_Inp->is_nalff, p_Dec->p_Inp->in_pts, p_Dec->p_Inp->pkt_eos, p_Dec->p_Inp->in_length, p_Dec->p_Vid->g_framecnt);
H264D_LOG("[ pkt_in timeUs ] p_Inp_is_nalff=%d, preprare input_pts=%lld, pkt_eos=%d, len=%d, g_framecnt=%d \n",
p_Dec->p_Inp->is_nalff, p_Dec->p_Inp->in_pts, p_Dec->p_Inp->pkt_eos, p_Dec->p_Inp->in_length, p_Dec->p_Vid->g_framecnt);
if (p_Dec->p_Inp->is_nalff) {
(ret = parse_prepare_extra_data(p_Dec->p_Inp, p_Dec->p_Cur));
task->valid = p_Dec->p_Inp->task_valid; //!< prepare valid flag
} else {
do{
(ret = parse_prepare_fast(p_Dec->p_Inp, p_Dec->p_Cur));
task->valid = p_Dec->p_Inp->task_valid; //!< prepare valid flag
//LogTrace(logctx, "[Prepare_Ing] length=%d, valid=%d,strm_off=%d, g_framecnt=%d", mpp_packet_get_length(pkt), task->valid, p_Dec->dxva_ctx->strm_offset, p_Dec->p_Vid->g_framecnt);
//FPRINT(g_debug_file0, "[Prepare_Ing] length=%d, valid=%d,strm_off=%d, g_framecnt=%d \n", mpp_packet_get_length(pkt), task->valid, p_Dec->dxva_ctx->strm_offset, p_Dec->p_Vid->g_framecnt);
if (p_Dec->p_Inp->is_nalff) {
(ret = parse_prepare_extra_data(p_Dec->p_Inp, p_Dec->p_Cur));
task->valid = p_Dec->p_Inp->task_valid; //!< prepare valid flag
} else {
do {
(ret = parse_prepare_fast(p_Dec->p_Inp, p_Dec->p_Cur));
task->valid = p_Dec->p_Inp->task_valid; //!< prepare valid flag
//LogTrace(logctx, "[Prepare_Ing] length=%d, valid=%d,strm_off=%d, g_framecnt=%d", mpp_packet_get_length(pkt), task->valid, p_Dec->dxva_ctx->strm_offset, p_Dec->p_Vid->g_framecnt);
//FPRINT(g_debug_file0, "[Prepare_Ing] length=%d, valid=%d,strm_off=%d, g_framecnt=%d \n", mpp_packet_get_length(pkt), task->valid, p_Dec->dxva_ctx->strm_offset, p_Dec->p_Vid->g_framecnt);
}while(mpp_packet_get_length(pkt) && !task->valid);
}
} while (mpp_packet_get_length(pkt) && !task->valid);
}
//LogTrace(logctx, "Prepare Out: len=%d, valid=%d ", mpp_packet_get_length(pkt), task->valid);
//mpp_log("Prepare Out: len=%d, valid=%d ", mpp_packet_get_length(pkt), task->valid);
task->flags.eos = p_Dec->p_Inp->pkt_eos;
//mpp_log("Prepare Out: len=%d, valid=%d ", mpp_packet_get_length(pkt), task->valid);
task->flags.eos = p_Dec->p_Inp->pkt_eos;
if (task->valid) {
memset(p_Dec->dxva_ctx->bitstream + p_Dec->dxva_ctx->strm_offset, 0,
MPP_ALIGN(p_Dec->dxva_ctx->strm_offset, 16) - p_Dec->dxva_ctx->strm_offset);
memset(p_Dec->dxva_ctx->bitstream + p_Dec->dxva_ctx->strm_offset, 0,
MPP_ALIGN(p_Dec->dxva_ctx->strm_offset, 16) - p_Dec->dxva_ctx->strm_offset);
mpp_packet_set_data(p_Dec->task_pkt, p_Dec->dxva_ctx->bitstream);
mpp_packet_set_length(p_Dec->task_pkt, MPP_ALIGN(p_Dec->dxva_ctx->strm_offset, 16));
mpp_packet_set_size(p_Dec->task_pkt, p_Dec->dxva_ctx->max_strm_size);
//LogTrace(logctx, "[Prepare_Out] ptr=%08x, stream_len=%d, max_size=%d", p_Dec->dxva_ctx->bitstream, p_Dec->dxva_ctx->strm_offset, p_Dec->dxva_ctx->max_strm_size);
//mpp_log("[Prepare_Out] g_framecnt=%d, stream_len=%d \n", p_Dec->p_Vid->g_framecnt, p_Dec->dxva_ctx->strm_offset);
task->input_packet = p_Dec->task_pkt;
//task->flags.eos = p_Dec->p_Inp->pkt_eos;
task->input_packet = p_Dec->task_pkt;
//task->flags.eos = p_Dec->p_Inp->pkt_eos;
} else {
task->input_packet = NULL;
}
@@ -753,7 +753,7 @@ MPP_RET h264d_parse(void *decoder, HalDecTask *in_task)
in_task->valid = 0; // prepare end flag
p_Dec->in_task = in_task;
FUN_CHECK(ret = parse_loop(p_Dec));
FUN_CHECK(ret = parse_loop(p_Dec));
if (p_Dec->is_parser_end) {
p_Dec->is_parser_end = 0;
@@ -762,10 +762,10 @@ MPP_RET h264d_parse(void *decoder, HalDecTask *in_task)
in_task->syntax.data = (void *)p_Dec->dxva_ctx->syn.buf;
FUN_CHECK(ret = update_dpb(p_Dec));
if (in_task->flags.eos) {
h264d_flush(decoder);
}
p_Dec->p_Vid->g_framecnt++;
if (in_task->flags.eos) {
h264d_flush(decoder);
}
p_Dec->p_Vid->g_framecnt++;
}
__RETURN:
@@ -784,38 +784,38 @@ __FAILED:
MPP_RET h264d_callback(void *decoder, void *err_info)
{
MPP_RET ret = MPP_ERR_UNKNOW;
MppFrame m_frame;
H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
H264dErrCtx_t *ctx = (H264dErrCtx_t *)err_info;
MPP_RET ret = MPP_ERR_UNKNOW;
MppFrame m_frame;
H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
H264dErrCtx_t *ctx = (H264dErrCtx_t *)err_info;
INP_CHECK(ret, !decoder && !err_info);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
INP_CHECK(ret, !decoder && !err_info);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
ctx->err_flag |= VPU_FRAME_ERR_UNSUPPORT;
ctx->err_flag |= VPU_FRAME_ERR_UNSUPPORT;
if(ctx->err_flag & VPU_FRAME_ERR_UNSUPPORT) {
h264d_reset(decoder);
}
if (ctx->err_flag & VPU_FRAME_ERR_UNSUPPORT) {
h264d_reset(decoder);
}
if (p_Dec->last_frame_slot_idx < 0) {
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) {
mpp_frame_set_errinfo(m_frame, ctx->err_flag);
}
if (p_Dec->last_frame_slot_idx < 0) {
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) {
mpp_frame_set_errinfo(m_frame, ctx->err_flag);
}
__RETURN:
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
return ret = MPP_OK;
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
return ret = MPP_OK;
}
/*!
***********************************************************************

707
mpp/codec/dec/h264/h264d_dpb.c
View File

@@ -120,18 +120,18 @@ static RK_S32 getDpbSize(H264dVideoCtx_t *p_Vid, H264_SPS_t *active_sps)
} else {
size = MPP_MIN(size, 16);
}
if (active_sps->vui_parameters_present_flag && active_sps->vui_seq_parameters.bitstream_restriction_flag) {
RK_S32 size_vui = 0;
//if ((RK_S32)active_sps->vui_seq_parameters.max_dec_frame_buffering > size) {
//H264D_LOG("max_dec_frame_buffering larger than MaxDpbSize");
//}
size_vui = MPP_MAX (1, active_sps->vui_seq_parameters.max_dec_frame_buffering);
if (active_sps->vui_parameters_present_flag && active_sps->vui_seq_parameters.bitstream_restriction_flag) {
RK_S32 size_vui = 0;
//if ((RK_S32)active_sps->vui_seq_parameters.max_dec_frame_buffering > size) {
//H264D_LOG("max_dec_frame_buffering larger than MaxDpbSize");
//}
size_vui = MPP_MAX (1, active_sps->vui_seq_parameters.max_dec_frame_buffering);
//if(size_vui < size) {
//H264D_LOG("Warning: max_dec_frame_buffering(%d) is less than DPB size(%d) calculated from Profile/Level.\n", size_vui, size);
//}
size = size_vui;
}
//if(size_vui < size) {
//H264D_LOG("Warning: max_dec_frame_buffering(%d) is less than DPB size(%d) calculated from Profile/Level.\n", size_vui, size);
//}
size = size_vui;
}
return size;
}
@@ -178,7 +178,7 @@ static void unmark_for_reference(H264_DecCtx_t *p_Dec, H264_FrameStore_t* fs)
//mpp_buf_slot_clr_flag(p_Dec->frame_slots, cur_pic->mem_mark->slot_idx, SLOT_CODEC_USE);
}
}
(void)p_Dec;
(void)p_Dec;
}
static RK_U32 is_short_term_reference(H264_FrameStore_t* fs)
@@ -632,9 +632,9 @@ static RK_U32 is_used_for_reference(H264_FrameStore_t* fs)
static void free_dpb_mark(H264_DecCtx_t *p_Dec, H264_DpbMark_t *p, RK_S32 structure)
{
MppFrame frame;
RK_U64 pts;
RK_U32 poc;
MppFrame frame;
RK_U64 pts;
RK_U32 poc;
if (structure == FRAME) {
p->top_used = (p->top_used > 0) ? (p->top_used - 1) : 0;
@@ -645,24 +645,24 @@ static void free_dpb_mark(H264_DecCtx_t *p_Dec, H264_DpbMark_t *p, RK_S32 struct
p->bot_used = (p->bot_used > 0) ? (p->bot_used - 1) : 0;
}
if (p->top_used == 0 && p->bot_used == 0
&& p->out_flag == 0 && (p->slot_idx >= 0)) {
&& p->out_flag == 0 && (p->slot_idx >= 0)) {
//if (p_Dec->p_Vid->g_framecnt == 692) {
// p = p;
//}
mpp_buf_slot_clr_flag(p_Dec->frame_slots, p->slot_idx, SLOT_CODEC_USE);
//mpp_buf_slot_clr_flag(p_Dec->frame_slots, p->slot_idx, SLOT_HAL_INPUT);
//mpp_buf_slot_clr_flag(p_Dec->frame_slots, p->slot_idx, SLOT_HAL_OUTPUT);
//mpp_buf_slot_clr_flag(p_Dec->frame_slots, p->slot_idx, SLOT_HAL_INPUT);
//mpp_buf_slot_clr_flag(p_Dec->frame_slots, p->slot_idx, SLOT_HAL_OUTPUT);
//mpp_buf_slot_clr_flag(p_Dec->frame_slots, p->slot_idx, SLOT_QUEUE_USE);
mpp_buf_slot_get_prop(p_Dec->frame_slots, p->slot_idx, SLOT_FRAME_PTR, &frame);
pts = frame ? mpp_frame_get_pts(frame) : 0;
poc = frame ? mpp_frame_get_poc(frame) : 0;
H264D_LOG("[FREE] g_frame_no=%d, structure=%d, mark_idx=%d, slot_idx=%d, poc=%d, pts=%lld, %p \n",
p_Dec->p_Vid->g_framecnt, structure, p->mark_idx, p->slot_idx, poc, pts, frame);
//mpp_print_slot_flag_info(g_debug_file1, p_Dec->frame_slots, p->slot_idx);
mpp_buf_slot_get_prop(p_Dec->frame_slots, p->slot_idx, SLOT_FRAME_PTR, &frame);
pts = frame ? mpp_frame_get_pts(frame) : 0;
poc = frame ? mpp_frame_get_poc(frame) : 0;
H264D_LOG("[FREE] g_frame_no=%d, structure=%d, mark_idx=%d, slot_idx=%d, poc=%d, pts=%lld, %p \n",
p_Dec->p_Vid->g_framecnt, structure, p->mark_idx, p->slot_idx, poc, pts, frame);
//mpp_print_slot_flag_info(g_debug_file1, p_Dec->frame_slots, p->slot_idx);
(void)pts;
(void)poc;
(void)pts;
(void)poc;
p->slot_idx = -1;
}
@@ -841,89 +841,87 @@ __FAILED:
static void muti_view_output(MppBufSlots frame_slots, H264_DpbMark_t *p_mark, H264dVideoCtx_t *p_Vid)
{
//!< add slot
{
MppFrame frame;
RK_S32 layer_id = -1;
H264dOutList_t *p_cur = NULL;
//!< add slot
{
MppFrame frame;
RK_S32 layer_id = -1;
H264dOutList_t *p_cur = NULL;
mpp_buf_slot_get_prop(frame_slots, p_mark->slot_idx, SLOT_FRAME_PTR, &frame);
layer_id = mpp_frame_get_viewid(frame);
H264D_LOG("[Write_picture] frame_%d_pts=%lld \n", layer_id, mpp_frame_get_pts(frame));
p_cur = &p_Vid->outlist[layer_id];
p_cur->list[p_cur->end] = p_mark;
p_cur->end = (p_cur->end + 1) % p_cur->max_size;
}
//!< enqueue
{
RK_S64 pts = 0;
MppFrame frame0;
MppFrame frame1;
H264_DpbMark_t *p_mark0 = NULL;
H264_DpbMark_t *p_mark1 = NULL;
H264dOutList_t *p_out[MAX_NUM_DPB_LAYERS] = { NULL };
mpp_buf_slot_get_prop(frame_slots, p_mark->slot_idx, SLOT_FRAME_PTR, &frame);
layer_id = mpp_frame_get_viewid(frame);
H264D_LOG("[Write_picture] frame_%d_pts=%lld \n", layer_id, mpp_frame_get_pts(frame));
p_cur = &p_Vid->outlist[layer_id];
p_cur->list[p_cur->end] = p_mark;
p_cur->end = (p_cur->end + 1) % p_cur->max_size;
}
//!< enqueue
{
RK_S64 pts = 0;
MppFrame frame0;
MppFrame frame1;
H264_DpbMark_t *p_mark0 = NULL;
H264_DpbMark_t *p_mark1 = NULL;
H264dOutList_t *p_out[MAX_NUM_DPB_LAYERS] = { NULL };
p_out[0] = &p_Vid->outlist[0];
p_out[1] = &p_Vid->outlist[1];
p_out[0] = &p_Vid->outlist[0];
p_out[1] = &p_Vid->outlist[1];
p_mark0 = p_out[0]->list[p_out[0]->begin];
p_mark1 = p_out[1]->list[p_out[1]->begin];
p_mark0 = p_out[0]->list[p_out[0]->begin];
p_mark1 = p_out[1]->list[p_out[1]->begin];
#if 1
while (p_mark0 && p_mark1) {
mpp_buf_slot_get_prop(frame_slots, p_mark0->slot_idx, SLOT_FRAME_PTR, &frame0);
mpp_buf_slot_get_prop(frame_slots, p_mark1->slot_idx, SLOT_FRAME_PTR, &frame1);
while (p_mark0 && p_mark1) {
mpp_buf_slot_get_prop(frame_slots, p_mark0->slot_idx, SLOT_FRAME_PTR, &frame0);
mpp_buf_slot_get_prop(frame_slots, p_mark1->slot_idx, SLOT_FRAME_PTR, &frame1);
if (mpp_frame_get_poc(frame0) == mpp_frame_get_poc(frame1)) {
H264D_LOG("[Write_picture] mark0_poc == mark1_poc \n");
if (mpp_frame_get_poc(frame0) == mpp_frame_get_poc(frame1)) {
H264D_LOG("[Write_picture] mark0_poc == mark1_poc \n");
pts = MPP_MIN(mpp_frame_get_pts(frame0), mpp_frame_get_pts(frame1));
mpp_frame_set_pts(frame0, pts);
mpp_frame_set_pts(frame1, pts);
mpp_buf_slot_enqueue(frame_slots, p_mark0->slot_idx, QUEUE_DISPLAY);
mpp_buf_slot_enqueue(frame_slots, p_mark1->slot_idx, QUEUE_DISPLAY);
pts = MPP_MIN(mpp_frame_get_pts(frame0), mpp_frame_get_pts(frame1));
mpp_frame_set_pts(frame0, pts);
mpp_frame_set_pts(frame1, pts);
mpp_buf_slot_enqueue(frame_slots, p_mark0->slot_idx, QUEUE_DISPLAY);
mpp_buf_slot_enqueue(frame_slots, p_mark1->slot_idx, QUEUE_DISPLAY);
H264D_LOG("[Write_picture] begin0=%d, end0=%d, begin1=%d, end1=%d, frame0_pts=%lld,%p,%p,frame1_pts=%lld,%p,%p \n",
p_out[0]->begin, p_out[0]->end, p_out[1]->begin, p_out[1]->end, mpp_frame_get_pts(frame0), frame0, p_mark0->frame, mpp_frame_get_pts(frame1), frame1, p_mark1->frame);
H264D_LOG("[Write_picture] begin0=%d, end0=%d, begin1=%d, end1=%d, frame0_pts=%lld,%p,%p,frame1_pts=%lld,%p,%p \n",
p_out[0]->begin, p_out[0]->end, p_out[1]->begin, p_out[1]->end, mpp_frame_get_pts(frame0), frame0, p_mark0->frame, mpp_frame_get_pts(frame1), frame1, p_mark1->frame);
p_mark0->out_flag = 0;
p_mark1->out_flag = 0;
p_Vid->p_Dec->last_frame_slot_idx = p_mark1->slot_idx;
p_mark0->out_flag = 0;
p_mark1->out_flag = 0;
p_Vid->p_Dec->last_frame_slot_idx = p_mark1->slot_idx;
free_dpb_mark(p_Vid->p_Dec, p_mark0, FRAME);
free_dpb_mark(p_Vid->p_Dec, p_mark1, FRAME);
p_out[0]->list[p_out[0]->begin] = NULL;
p_out[1]->list[p_out[1]->begin] = NULL;
p_out[0]->begin = (p_out[0]->begin + 1) % p_out[0]->max_size;
p_out[1]->begin = (p_out[1]->begin + 1) % p_out[1]->max_size;
}
else if (mpp_frame_get_poc(frame0) > mpp_frame_get_poc(frame1)) {
H264D_LOG("[Write_picture] p_mark0->poc > p_mark1->poc \n");
mpp_buf_slot_enqueue(frame_slots, p_mark1->slot_idx, QUEUE_DISPLAY);
p_mark1->out_flag = 0;
free_dpb_mark(p_Vid->p_Dec, p_mark1, FRAME);
p_out[1]->list[p_out[1]->begin] = NULL;
p_out[1]->begin = (p_out[1]->begin + 1) % p_out[1]->max_size;
mpp_frame_set_discard(frame1, 1);
}
else { //!< mpp_frame_get_poc(frame0) < mpp_frame_get_poc(frame1)
H264D_LOG("[Write_picture] p_mark0->poc < p_mark1->poc \n");
mpp_buf_slot_enqueue(frame_slots, p_mark0->slot_idx, QUEUE_DISPLAY);
p_mark0->out_flag = 0;
free_dpb_mark(p_Vid->p_Dec, p_mark0, FRAME);
p_out[0]->list[p_out[0]->begin] = NULL;
p_out[0]->begin = (p_out[0]->begin + 1) % p_out[0]->max_size;
mpp_frame_set_discard(frame0, 1);
}
free_dpb_mark(p_Vid->p_Dec, p_mark0, FRAME);
free_dpb_mark(p_Vid->p_Dec, p_mark1, FRAME);
p_out[0]->list[p_out[0]->begin] = NULL;
p_out[1]->list[p_out[1]->begin] = NULL;
p_out[0]->begin = (p_out[0]->begin + 1) % p_out[0]->max_size;
p_out[1]->begin = (p_out[1]->begin + 1) % p_out[1]->max_size;
} else if (mpp_frame_get_poc(frame0) > mpp_frame_get_poc(frame1)) {
H264D_LOG("[Write_picture] p_mark0->poc > p_mark1->poc \n");
mpp_buf_slot_enqueue(frame_slots, p_mark1->slot_idx, QUEUE_DISPLAY);
p_mark1->out_flag = 0;
free_dpb_mark(p_Vid->p_Dec, p_mark1, FRAME);
p_out[1]->list[p_out[1]->begin] = NULL;
p_out[1]->begin = (p_out[1]->begin + 1) % p_out[1]->max_size;
mpp_frame_set_discard(frame1, 1);
} else { //!< mpp_frame_get_poc(frame0) < mpp_frame_get_poc(frame1)
H264D_LOG("[Write_picture] p_mark0->poc < p_mark1->poc \n");
mpp_buf_slot_enqueue(frame_slots, p_mark0->slot_idx, QUEUE_DISPLAY);
p_mark0->out_flag = 0;
free_dpb_mark(p_Vid->p_Dec, p_mark0, FRAME);
p_out[0]->list[p_out[0]->begin] = NULL;
p_out[0]->begin = (p_out[0]->begin + 1) % p_out[0]->max_size;
mpp_frame_set_discard(frame0, 1);
}
p_mark0 = p_out[0]->list[p_out[0]->begin];
p_mark1 = p_out[1]->list[p_out[1]->begin];
}
}
p_mark0 = p_out[0]->list[p_out[0]->begin];
p_mark1 = p_out[1]->list[p_out[1]->begin];
}
}
#else
mpp_buf_slot_enqueue(frame_slots, p_mark->slot_idx, QUEUE_DISPLAY);
p_Vid->p_Dec->last_frame_slot_idx = p_mark->slot_idx;
p_mark->out_flag = 0;
mpp_buf_slot_enqueue(frame_slots, p_mark->slot_idx, QUEUE_DISPLAY);
p_Vid->p_Dec->last_frame_slot_idx = p_mark->slot_idx;
p_mark->out_flag = 0;
#endif
}
@@ -931,55 +929,54 @@ static void muti_view_output(MppBufSlots frame_slots, H264_DpbMark_t *p_mark, H2
static void write_picture(H264_StorePic_t *p, H264dVideoCtx_t *p_Vid)
{
MppFrame frame;
MppFrame frame;
H264_DpbMark_t *p_mark = NULL;
p_mark = p->mem_mark;
p_mark = p->mem_mark;
if (p->mem_malloc_type == Mem_Malloc && p->structure == FRAME && p_mark->out_flag) {
mpp_buf_slot_get_prop(p_Vid->p_Dec->frame_slots, p_mark->slot_idx, SLOT_FRAME_PTR, &frame);
mpp_buf_slot_get_prop(p_Vid->p_Dec->frame_slots, p_mark->slot_idx, SLOT_FRAME_PTR, &frame);
mpp_frame_set_poc(frame, p->poc);
p_mark->poc = p->poc;
p_mark->pts = mpp_frame_get_pts(frame);
mpp_frame_set_poc(frame, p->poc);
p_mark->poc = p->poc;
p_mark->pts = mpp_frame_get_pts(frame);
mpp_frame_set_viewid(frame, p->layer_id);
//if (p->layer_id == 1) {
// mpp_frame_set_discard(frame, 1);
//}
//else {
// mpp_frame_set_discard(frame, 1);
//}
mpp_frame_set_viewid(frame, p->layer_id);
//if (p->layer_id == 1) {
// mpp_frame_set_discard(frame, 1);
//}
//else {
// mpp_frame_set_discard(frame, 1);
//}
p_Vid->has_get_i_frame_flag = (p_Vid->has_get_i_frame_flag || (p->slice_type == I_SLICE)) ? 1 : 0;
if (!p_Vid->has_get_i_frame_flag) {
mpp_frame_set_discard(frame, 1);
}
if (p->poc
&& (p_Vid->last_outputpoc[p->layer_id] >= 0)
&& (p->poc < p_Vid->last_outputpoc[p->layer_id])) {
mpp_frame_set_discard(frame, 1);
}
H264D_LOG("[dispaly] layer_id=%d, pic_num=%d, poc=%d, last_poc=%d, slice_type=%d(isdir=%d), pts=%lld, g_framecnt=%d \n", p->layer_id,
p->pic_num, p->poc, p_Vid->last_outputpoc[p->layer_id], p->slice_type, p->idr_flag, mpp_frame_get_pts(frame), p_Vid->g_framecnt);
p_Vid->last_outputpoc[p->layer_id] = p->poc;
p_Vid->has_get_i_frame_flag = (p_Vid->has_get_i_frame_flag || (p->slice_type == I_SLICE)) ? 1 : 0;
if (!p_Vid->has_get_i_frame_flag) {
mpp_frame_set_discard(frame, 1);
}
if (p->poc
&& (p_Vid->last_outputpoc[p->layer_id] >= 0)
&& (p->poc < p_Vid->last_outputpoc[p->layer_id])) {
mpp_frame_set_discard(frame, 1);
}
H264D_LOG("[dispaly] layer_id=%d, pic_num=%d, poc=%d, last_poc=%d, slice_type=%d(isdir=%d), pts=%lld, g_framecnt=%d \n", p->layer_id,
p->pic_num, p->poc, p_Vid->last_outputpoc[p->layer_id], p->slice_type, p->idr_flag, mpp_frame_get_pts(frame), p_Vid->g_framecnt);
p_Vid->last_outputpoc[p->layer_id] = p->poc;
mpp_buf_slot_set_flag(p_Vid->p_Dec->frame_slots, p_mark->slot_idx, SLOT_QUEUE_USE);
mpp_buf_slot_set_flag(p_Vid->p_Dec->frame_slots, p_mark->slot_idx, SLOT_QUEUE_USE);
if (p_Vid->p_Dec->mvc_valid) {
muti_view_output(p_Vid->p_Dec->frame_slots, p_mark, p_Vid);
} else
{
mpp_buf_slot_enqueue(p_Vid->p_Dec->frame_slots, p_mark->slot_idx, QUEUE_DISPLAY);
p_Vid->p_Dec->last_frame_slot_idx = p_mark->slot_idx;
p_mark->out_flag = 0;
}
// FPRINT(g_debug_file0, "[WRITE_PICTURE] lay_id=%d, g_frame_no=%d, mark_idx=%d, slot_idx=%d, pts=%lld \n",
//p->layer_id, p_Vid->g_framecnt, p_mark->mark_idx, p_mark->slot_idx, mpp_frame_get_pts(frame));
if (p_Vid->p_Dec->mvc_valid) {
muti_view_output(p_Vid->p_Dec->frame_slots, p_mark, p_Vid);
} else {
mpp_buf_slot_enqueue(p_Vid->p_Dec->frame_slots, p_mark->slot_idx, QUEUE_DISPLAY);
p_Vid->p_Dec->last_frame_slot_idx = p_mark->slot_idx;
p_mark->out_flag = 0;
}
// FPRINT(g_debug_file0, "[WRITE_PICTURE] lay_id=%d, g_frame_no=%d, mark_idx=%d, slot_idx=%d, pts=%lld \n",
//p->layer_id, p_Vid->g_framecnt, p_mark->mark_idx, p_mark->slot_idx, mpp_frame_get_pts(frame));
//H264D_LOG("[WRITE_PICTURE] lay_id=%d, g_frame_no=%d, mark_idx=%d, slot_idx=%d, pts=%lld \n",
// p->layer_id, p_Vid->g_framecnt, p_mark->mark_idx, p_mark->slot_idx, mpp_frame_get_pts(frame));
//H264D_LOG("[WRITE_PICTURE] lay_id=%d, g_frame_no=%d, mark_idx=%d, slot_idx=%d, pts=%lld \n",
// p->layer_id, p_Vid->g_framecnt, p_mark->mark_idx, p_mark->slot_idx, mpp_frame_get_pts(frame));
//LogInfo(p_Vid->p_Dec->logctx.parr[RUN_PARSE], "[WRITE_PICTURE] g_frame_cnt=%d", p_Vid->g_framecnt);
}
@@ -1383,7 +1380,7 @@ static MPP_RET store_picture_in_dpb(H264_DpbBuf_t *p_Dpb, H264_StorePic_t *p)
p_Dpb->used_size++;
update_ref_list(p_Dpb);
update_ltref_list(p_Dpb);
H264D_LOG("SLOT_CODEC_USE slot_idx=%d \n", p->mem_mark->slot_idx);
H264D_LOG("SLOT_CODEC_USE slot_idx=%d \n", p->mem_mark->slot_idx);
mpp_buf_slot_set_flag(p_Vid->p_Dec->frame_slots, p->mem_mark->slot_idx, SLOT_CODEC_USE);
__RETURN:
@@ -1402,27 +1399,27 @@ __FAILED:
//extern "C"
void flush_muti_view_output(MppBufSlots frame_slots, H264dOutList_t *p_list, H264dVideoCtx_t *p_Vid)
{
RK_U32 i= 0;
MppFrame frame;
H264_DpbMark_t *p_mark = NULL;
H264dOutList_t *p_out = NULL;
RK_U32 i = 0;
MppFrame frame;
H264_DpbMark_t *p_mark = NULL;
H264dOutList_t *p_out = NULL;
//!< flush unpaired
for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) {
p_out = &p_list[i];
p_mark = p_out->list[p_out->begin];
while (p_mark) {
H264D_LOG("[Write_picture] ---- Flush discard --- mpp_frame_get_pts(frame0) \n");
mpp_buf_slot_get_prop(frame_slots, p_mark->slot_idx, SLOT_FRAME_PTR, &frame);
mpp_buf_slot_enqueue(frame_slots, p_mark->slot_idx, QUEUE_DISPLAY);
p_mark->out_flag = 0;
free_dpb_mark(p_Vid->p_Dec, p_mark, FRAME);
p_out->list[p_out->begin] = NULL;
p_out->begin = (p_out->begin + 1) % p_out->max_size;
p_mark = p_out->list[p_out->begin];
mpp_frame_set_discard(frame, 1);
}
}
//!< flush unpaired
for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) {
p_out = &p_list[i];
p_mark = p_out->list[p_out->begin];
while (p_mark) {
H264D_LOG("[Write_picture] ---- Flush discard --- mpp_frame_get_pts(frame0) \n");
mpp_buf_slot_get_prop(frame_slots, p_mark->slot_idx, SLOT_FRAME_PTR, &frame);
mpp_buf_slot_enqueue(frame_slots, p_mark->slot_idx, QUEUE_DISPLAY);
p_mark->out_flag = 0;
free_dpb_mark(p_Vid->p_Dec, p_mark, FRAME);
p_out->list[p_out->begin] = NULL;
p_out->begin = (p_out->begin + 1) % p_out->max_size;
p_mark = p_out->list[p_out->begin];
mpp_frame_set_discard(frame, 1);
}
}
}
/*!
@@ -1758,21 +1755,21 @@ MPP_RET init_dpb(H264dVideoCtx_t *p_Vid, H264_DpbBuf_t *p_Dpb, RK_S32 type) //
MPP_RET ret = MPP_ERR_UNKNOW;
H264_SPS_t *active_sps = p_Vid->active_sps;
if(!active_sps){
ret = MPP_NOK;
goto __FAILED;
}
if (!active_sps) {
ret = MPP_NOK;
goto __FAILED;
}
p_Dpb->p_Vid = p_Vid;
if (p_Dpb->init_done) {
free_dpb(p_Dpb);
}
p_Dpb->size = getDpbSize(p_Vid, active_sps) + (type == 2 ? 0 : 1);
p_Dpb->num_ref_frames = active_sps->max_num_ref_frames;
//if (active_sps->max_dec_frame_buffering < active_sps->max_num_ref_frames) {
//H264D_LOG("DPB size at specified level is smaller than reference frames");
//LogError(runlog, "DPB size at specified level is smaller than reference frames");
//goto __FAILED;
//}
//if (active_sps->max_dec_frame_buffering < active_sps->max_num_ref_frames) {
//H264D_LOG("DPB size at specified level is smaller than reference frames");
//LogError(runlog, "DPB size at specified level is smaller than reference frames");
//goto __FAILED;
//}
p_Dpb->used_size = 0;
p_Dpb->last_picture = NULL;
p_Dpb->ref_frames_in_buffer = 0;
@@ -1862,7 +1859,7 @@ MPP_RET flush_dpb(H264_DpbBuf_t *p_Dpb, RK_S32 type)
FUN_CHECK(ret = output_one_frame_from_dpb(p_Dpb));
}
p_Dpb->last_output_poc = INT_MIN;
(void)type;
(void)type;
__RETURN:
return ret = MPP_OK;
__FAILED:
@@ -1909,104 +1906,104 @@ __FAILED:
static void reset_dpb_info(H264_DpbInfo_t *p)
{
p->picbuf = NULL;
p->TOP_POC = 0;
p->BOT_POC = 0;
p->field_flag = 0;
p->slot_index = -1;
p->colmv_is_used = 0;
p->frame_num = 0;
p->is_long_term = 0;
p->long_term_pic_num = 0;
p->voidx = 0;
p->view_id = 0;
p->is_used = 0;
p->picbuf = NULL;
p->TOP_POC = 0;
p->BOT_POC = 0;
p->field_flag = 0;
p->slot_index = -1;
p->colmv_is_used = 0;
p->frame_num = 0;
p->is_long_term = 0;
p->long_term_pic_num = 0;
p->voidx = 0;
p->view_id = 0;
p->is_used = 0;
}
#if 0
static MPP_RET adjust_input(H264_SLICE_t *currSlice)
{
RK_U32 i = 0, j = 0;
RK_U32 find_flag = 0;
RK_U32 i = 0, j = 0;
RK_U32 find_flag = 0;
H264_DecCtx_t *p_Dec = currSlice->p_Dec;
H264_DpbInfo_t *new_dpb = p_Dec->dpb_info;
H264_DpbInfo_t *old_dpb = p_Dec->dpb_old[currSlice->layer_id];
H264_DecCtx_t *p_Dec = currSlice->p_Dec;
H264_DpbInfo_t *new_dpb = p_Dec->dpb_info;
H264_DpbInfo_t *old_dpb = p_Dec->dpb_old[currSlice->layer_id];
//for (i = 0; i < MAX_DPB_SIZE; i++) {
// if (new_dpb[i].picbuf) {
// FPRINT(g_debug_file0, "i=%2d, picnum=%d, framenum=%2d, ", i, new_dpb[i].frame_num, new_dpb[i].frame_num);
// FPRINT(g_debug_file0, " dbp_idx=%d, longterm=%d, poc=%d \n", new_dpb[i].slot_index, new_dpb[i].is_long_term,
// new_dpb[i].TOP_POC);
// }
//}
//FPRINT(g_debug_file0, "--------- [new DPB] -------- \n");
//for (i = 0; i < MAX_DPB_SIZE; i++) {
// if (old_dpb[i].picbuf) {
// FPRINT(g_debug_file0, "i=%2d, picnum=%d, framenum=%2d, ", i, old_dpb[i].frame_num, old_dpb[i].frame_num);
// FPRINT(g_debug_file0, " dbp_idx=%d, longterm=%d, poc=%d \n", old_dpb[i].slot_index, old_dpb[i].is_long_term,
// old_dpb[i].TOP_POC);
// }
//}
//FPRINT(g_debug_file0, "--------- [Old DPB] -------- \n");
//for (i = 0; i < MAX_DPB_SIZE; i++) {
// if (new_dpb[i].picbuf) {
// FPRINT(g_debug_file0, "i=%2d, picnum=%d, framenum=%2d, ", i, new_dpb[i].frame_num, new_dpb[i].frame_num);
// FPRINT(g_debug_file0, " dbp_idx=%d, longterm=%d, poc=%d \n", new_dpb[i].slot_index, new_dpb[i].is_long_term,
// new_dpb[i].TOP_POC);
// }
//}
//FPRINT(g_debug_file0, "--------- [new DPB] -------- \n");
//for (i = 0; i < MAX_DPB_SIZE; i++) {
// if (old_dpb[i].picbuf) {
// FPRINT(g_debug_file0, "i=%2d, picnum=%d, framenum=%2d, ", i, old_dpb[i].frame_num, old_dpb[i].frame_num);
// FPRINT(g_debug_file0, " dbp_idx=%d, longterm=%d, poc=%d \n", old_dpb[i].slot_index, old_dpb[i].is_long_term,
// old_dpb[i].TOP_POC);
// }
//}
//FPRINT(g_debug_file0, "--------- [Old DPB] -------- \n");
//!< delete old dpb
for (i = 0; i < MAX_DPB_SIZE; i++) {
find_flag = 0;
if (old_dpb[i].picbuf) {
for (j = 0; j < MAX_DPB_SIZE; j++) {
if(new_dpb[j].picbuf) {
find_flag = (old_dpb[i].frame_num == new_dpb[j].frame_num) ? 1 : 0;
find_flag = (old_dpb[i].slot_index == new_dpb[j].slot_index) ? find_flag : 0;
if (new_dpb[j].is_used & 0x1) {
find_flag = (old_dpb[i].TOP_POC == new_dpb[j].TOP_POC) ? find_flag : 0;
}
if (new_dpb[j].is_used & 0x2) {
find_flag = (old_dpb[i].BOT_POC == new_dpb[j].BOT_POC) ? find_flag : 0;
}
if (find_flag) { //!< found
new_dpb[j].have_same = 1;
break;
}
}
}
}
//!< not found
if (find_flag == 0) {
reset_dpb_info(&old_dpb[i]);
}
}
//!< add new dpb
for (j = 0; j < MAX_DPB_SIZE; j++) {
if ((new_dpb[j].picbuf == 0) || new_dpb[j].have_same) {
continue;
}
for (i = 0; i < MAX_DPB_SIZE; i++) {
if (old_dpb[i].picbuf == 0) {
old_dpb[i] = new_dpb[j];
break;
}
}
}
//memcpy(new_dpb, old_dpb, MAX_DPB_SIZE*sizeof(H264_DpbInfo_t));
memset(new_dpb, 0, MAX_DPB_SIZE*sizeof(H264_DpbInfo_t));
for (i = 0, j = 0; i < MAX_DPB_SIZE; i++) {
if (old_dpb[i].picbuf) {
new_dpb[j] = old_dpb[i];
//FPRINT(g_debug_file0, "i=%2d, picnum=%d, framenum=%2d, ", j, old_dpb[j].frame_num, old_dpb[j].frame_num);
//FPRINT(g_debug_file0, " dbp_idx=%d, longterm=%d, poc=%d \n", old_dpb[j].slot_index, old_dpb[j].is_long_term,
// old_dpb[i].TOP_POC);
j++;
}
}
for (; j < 16; j++) {
reset_dpb_info(&new_dpb[j]);
}
memcpy(old_dpb, new_dpb, MAX_DPB_SIZE*sizeof(H264_DpbInfo_t));
//!< delete old dpb
for (i = 0; i < MAX_DPB_SIZE; i++) {
find_flag = 0;
if (old_dpb[i].picbuf) {
for (j = 0; j < MAX_DPB_SIZE; j++) {
if (new_dpb[j].picbuf) {
find_flag = (old_dpb[i].frame_num == new_dpb[j].frame_num) ? 1 : 0;
find_flag = (old_dpb[i].slot_index == new_dpb[j].slot_index) ? find_flag : 0;
if (new_dpb[j].is_used & 0x1) {
find_flag = (old_dpb[i].TOP_POC == new_dpb[j].TOP_POC) ? find_flag : 0;
}
if (new_dpb[j].is_used & 0x2) {
find_flag = (old_dpb[i].BOT_POC == new_dpb[j].BOT_POC) ? find_flag : 0;
}
if (find_flag) { //!< found
new_dpb[j].have_same = 1;
break;
}
}
}
}
//!< not found
if (find_flag == 0) {
reset_dpb_info(&old_dpb[i]);
}
}
//!< add new dpb
for (j = 0; j < MAX_DPB_SIZE; j++) {
if ((new_dpb[j].picbuf == 0) || new_dpb[j].have_same) {
continue;
}
for (i = 0; i < MAX_DPB_SIZE; i++) {
if (old_dpb[i].picbuf == 0) {
old_dpb[i] = new_dpb[j];
break;
}
}
}
//memcpy(new_dpb, old_dpb, MAX_DPB_SIZE*sizeof(H264_DpbInfo_t));
memset(new_dpb, 0, MAX_DPB_SIZE * sizeof(H264_DpbInfo_t));
for (i = 0, j = 0; i < MAX_DPB_SIZE; i++) {
if (old_dpb[i].picbuf) {
new_dpb[j] = old_dpb[i];
//FPRINT(g_debug_file0, "i=%2d, picnum=%d, framenum=%2d, ", j, old_dpb[j].frame_num, old_dpb[j].frame_num);
//FPRINT(g_debug_file0, " dbp_idx=%d, longterm=%d, poc=%d \n", old_dpb[j].slot_index, old_dpb[j].is_long_term,
// old_dpb[i].TOP_POC);
j++;
}
}
for (; j < 16; j++) {
reset_dpb_info(&new_dpb[j]);
}
memcpy(old_dpb, new_dpb, MAX_DPB_SIZE * sizeof(H264_DpbInfo_t));
return MPP_OK;
return MPP_OK;
}
#endif
@@ -2025,10 +2022,10 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
H264_DecCtx_t *p_Dec = currSlice->p_Dec;
memset(p_Dec->dpb_info, 0, MAX_DPB_SIZE * sizeof(H264_DpbInfo_t));
memset(&p_Dec->in_task->refer, -1, sizeof(p_Dec->in_task->refer));
memset(&p_Dec->in_task->refer, -1, sizeof(p_Dec->in_task->refer));
if (currSlice->idr_flag && (currSlice->layer_id == 0)) { // idr_flag==1 && layer_id==0
memset(p_Dec->dpb_old[0], 0, MAX_DPB_SIZE * sizeof(H264_DpbInfo_t));
memset(p_Dec->dpb_old[1], 0, MAX_DPB_SIZE * sizeof(H264_DpbInfo_t));
memset(p_Dec->dpb_old[0], 0, MAX_DPB_SIZE * sizeof(H264_DpbInfo_t));
memset(p_Dec->dpb_old[1], 0, MAX_DPB_SIZE * sizeof(H264_DpbInfo_t));
goto __RETURN;
}
//!<---- reference
@@ -2126,118 +2123,118 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
}
#if 1
//!< inter-layer reference (for multi-layered codecs)
for (j = 0; j < p_Dpb->used_size_il; i++, j++) {
if (currSlice->structure == FRAME && p_Dpb->fs_ilref[j]->is_used == 3) {
if (p_Dpb->fs_ilref[j]->inter_view_flag[0] == 0 && p_Dpb->fs_ilref[j]->inter_view_flag[1] == 0)
break;
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ilref[j]->frame;
//!< inter-layer reference (for multi-layered codecs)
for (j = 0; j < p_Dpb->used_size_il; i++, j++) {
if (currSlice->structure == FRAME && p_Dpb->fs_ilref[j]->is_used == 3) {
if (p_Dpb->fs_ilref[j]->inter_view_flag[0] == 0 && p_Dpb->fs_ilref[j]->inter_view_flag[1] == 0)
break;
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ilref[j]->frame;
if (p_Dpb->fs_ilref[j]->frame->is_mmco_5) {
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->frame->top_poc_mmco5;
p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ilref[j]->frame->bot_poc_mmco5;
} else {
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->frame->top_poc;
p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ilref[j]->frame->bottom_poc;
}
p_Dec->dpb_info[i].field_flag = p_Dpb->fs_ilref[j]->frame->iCodingType == FIELD_CODING;
p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ilref[j]->frame->mem_mark->slot_idx;
p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ilref[j]->frame->colmv_no_used_flag ? 0 : 1);
} else if (currSlice->structure != FRAME && p_Dpb->fs_ilref[j]->is_used) {
if (p_Dpb->fs_ilref[j]->is_used == 0x3) {
if (p_Dpb->fs_ilref[j]->inter_view_flag[currSlice->structure == BOTTOM_FIELD] == 0)
break;
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ilref[j]->top_field;
if (p_Dpb->fs_ilref[j]->frame->is_mmco_5) {
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->frame->top_poc_mmco5;
p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ilref[j]->frame->bot_poc_mmco5;
} else {
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->frame->top_poc;
p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ilref[j]->frame->bottom_poc;
}
p_Dec->dpb_info[i].field_flag = p_Dpb->fs_ilref[j]->frame->iCodingType == FIELD_CODING;
p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ilref[j]->frame->mem_mark->slot_idx;
p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ilref[j]->frame->colmv_no_used_flag ? 0 : 1);
} else if (currSlice->structure != FRAME && p_Dpb->fs_ilref[j]->is_used) {
if (p_Dpb->fs_ilref[j]->is_used == 0x3) {
if (p_Dpb->fs_ilref[j]->inter_view_flag[currSlice->structure == BOTTOM_FIELD] == 0)
break;
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ilref[j]->top_field;
if (p_Dpb->fs_ilref[j]->top_field->is_mmco_5) {
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->top_field->top_poc_mmco5;
} else {
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->top_field->top_poc;
}
if (p_Dpb->fs_ilref[j]->bottom_field->is_mmco_5) {
p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ilref[j]->bottom_field->bot_poc_mmco5;
} else {
p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ilref[j]->bottom_field->bottom_poc;
}
p_Dec->dpb_info[i].field_flag = p_Dpb->fs_ilref[j]->frame->iCodingType == FIELD_CODING;
p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ilref[j]->frame->mem_mark->slot_idx;
p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ilref[j]->frame->colmv_no_used_flag ? 0 : 1);
}
if (p_Dpb->fs_ilref[j]->is_used & 0x1) {
if (p_Dpb->fs_ilref[j]->inter_view_flag[0] == 0)
break;
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ilref[j]->top_field;
if (p_Dpb->fs_ilref[j]->top_field->is_mmco_5) {
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->top_field->top_poc_mmco5;
} else {
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->top_field->top_poc;
}
if (p_Dpb->fs_ilref[j]->bottom_field->is_mmco_5) {
p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ilref[j]->bottom_field->bot_poc_mmco5;
} else {
p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ilref[j]->bottom_field->bottom_poc;
}
p_Dec->dpb_info[i].field_flag = p_Dpb->fs_ilref[j]->frame->iCodingType == FIELD_CODING;
p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ilref[j]->frame->mem_mark->slot_idx;
p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ilref[j]->frame->colmv_no_used_flag ? 0 : 1);
}
if (p_Dpb->fs_ilref[j]->is_used & 0x1) {
if (p_Dpb->fs_ilref[j]->inter_view_flag[0] == 0)
break;
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ilref[j]->top_field;
if (p_Dpb->fs_ilref[j]->top_field->is_mmco_5) {
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->top_field->top_poc_mmco5;
} else {
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->top_field->top_poc;
}
p_Dec->dpb_info[i].BOT_POC = 0;
p_Dec->dpb_info[i].field_flag = 1;
p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ilref[j]->top_field->mem_mark->slot_idx;
p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ilref[j]->top_field->colmv_no_used_flag ? 0 : 1);
} else { // if(p_Dpb->fs_ref[j]->is_used & 0x2)
if (p_Dpb->fs_ilref[j]->inter_view_flag[1] == 0)
break;
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ilref[j]->bottom_field;
if (p_Dpb->fs_ilref[j]->top_field->is_mmco_5) {
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->top_field->top_poc_mmco5;
} else {
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->top_field->top_poc;
}
p_Dec->dpb_info[i].BOT_POC = 0;
p_Dec->dpb_info[i].field_flag = 1;
p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ilref[j]->top_field->mem_mark->slot_idx;
p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ilref[j]->top_field->colmv_no_used_flag ? 0 : 1);
} else { // if(p_Dpb->fs_ref[j]->is_used & 0x2)
if (p_Dpb->fs_ilref[j]->inter_view_flag[1] == 0)
break;
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ilref[j]->bottom_field;
p_Dec->dpb_info[i].TOP_POC = 0;
if (p_Dpb->fs_ilref[j]->bottom_field->is_mmco_5) {
p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ilref[j]->bottom_field->bot_poc_mmco5;
} else {
p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ilref[j]->bottom_field->bottom_poc;
}
p_Dec->dpb_info[i].field_flag = 1;
p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ilref[j]->bottom_field->mem_mark->slot_idx;
p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ilref[j]->bottom_field->colmv_no_used_flag ? 0 : 1);
}
}
p_Dec->dpb_info[i].frame_num = p_Dpb->fs_ilref[j]->frame_num;
p_Dec->dpb_info[i].is_long_term = 0;//p_Dpb->fs_ilref[j]->is_long_term;
p_Dec->dpb_info[i].is_ilt_flag = 1;
p_Dec->dpb_info[i].long_term_pic_num = 0;
p_Dec->dpb_info[i].long_term_frame_idx = 0;
p_Dec->dpb_info[i].voidx = p_Dpb->fs_ilref[j]->layer_id;
p_Dec->dpb_info[i].view_id = p_Dpb->fs_ilref[j]->view_id;
p_Dec->dpb_info[i].is_used = p_Dpb->fs_ilref[j]->is_used;
}
p_Dec->dpb_info[i].TOP_POC = 0;
if (p_Dpb->fs_ilref[j]->bottom_field->is_mmco_5) {
p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ilref[j]->bottom_field->bot_poc_mmco5;
} else {
p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ilref[j]->bottom_field->bottom_poc;
}
p_Dec->dpb_info[i].field_flag = 1;
p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ilref[j]->bottom_field->mem_mark->slot_idx;
p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ilref[j]->bottom_field->colmv_no_used_flag ? 0 : 1);
}
}
p_Dec->dpb_info[i].frame_num = p_Dpb->fs_ilref[j]->frame_num;
p_Dec->dpb_info[i].is_long_term = 0;//p_Dpb->fs_ilref[j]->is_long_term;
p_Dec->dpb_info[i].is_ilt_flag = 1;
p_Dec->dpb_info[i].long_term_pic_num = 0;
p_Dec->dpb_info[i].long_term_frame_idx = 0;
p_Dec->dpb_info[i].voidx = p_Dpb->fs_ilref[j]->layer_id;
p_Dec->dpb_info[i].view_id = p_Dpb->fs_ilref[j]->view_id;
p_Dec->dpb_info[i].is_used = p_Dpb->fs_ilref[j]->is_used;
}
#endif
//for(j = 0; j < i; j++) {
// FPRINT(g_debug_file1, "i=%2d, picnum=%d, framenum=%2d, ", j, p_Dec->dpb_info[j].frame_num, p_Dec->dpb_info[j].frame_num);
// FPRINT(g_debug_file1, " dbp_idx=%d, longterm=%d, poc=%d \n", p_Dec->dpb_info[j].slot_index, p_Dec->dpb_info[j].is_long_term,
// p_Dec->dpb_info[j].TOP_POC);
//}
//FPRINT(g_debug_file1, "--------- [FLUSH_CNT] flush framecnt=%d -------- \n", p_Dec->p_Vid->g_framecnt);
//for(j = 0; j < i; j++) {
// FPRINT(g_debug_file1, "i=%2d, picnum=%d, framenum=%2d, ", j, p_Dec->dpb_info[j].frame_num, p_Dec->dpb_info[j].frame_num);
// FPRINT(g_debug_file1, " dbp_idx=%d, longterm=%d, poc=%d \n", p_Dec->dpb_info[j].slot_index, p_Dec->dpb_info[j].is_long_term,
// p_Dec->dpb_info[j].TOP_POC);
//}
//FPRINT(g_debug_file1, "--------- [FLUSH_CNT] flush framecnt=%d -------- \n", p_Dec->p_Vid->g_framecnt);
//if (p_Dec->p_Vid->g_framecnt == 255) {
// i = i;
//}
//if (p_Dec->p_Vid->g_framecnt == 255) {
// i = i;
//}
//!< reset left parameters
for (; i < 16; i++) {
reset_dpb_info(&p_Dec->dpb_info[i]);
}
//!< reset left parameters
for (; i < 16; i++) {
reset_dpb_info(&p_Dec->dpb_info[i]);
}
//FPRINT(g_debug_file0, "---g_framecnt=%d\n", p_Dec->p_Vid->g_framecnt);
//for (i = 0; i< 16; i++)
//{
// FPRINT(g_debug_file0, "i=%d, top_poc=%d, bot_poc=%d, frame_num=%d, is_lt=%d, voidx=%d\n", i, p_Dec->dpb_info[i].TOP_POC,
// p_Dec->dpb_info[i].BOT_POC, p_Dec->dpb_info[i].frame_num, p_Dec->dpb_info[i].is_ilt_flag, p_Dec->dpb_info[i].voidx);
//}
//FPRINT(g_debug_file0, "---g_framecnt=%d\n", p_Dec->p_Vid->g_framecnt);
//for (i = 0; i< 16; i++)
//{
// FPRINT(g_debug_file0, "i=%d, top_poc=%d, bot_poc=%d, frame_num=%d, is_lt=%d, voidx=%d\n", i, p_Dec->dpb_info[i].TOP_POC,
// p_Dec->dpb_info[i].BOT_POC, p_Dec->dpb_info[i].frame_num, p_Dec->dpb_info[i].is_ilt_flag, p_Dec->dpb_info[i].voidx);
//}
//adjust_input(currSlice);
//adjust_input(currSlice);
for (i = 0; i < MAX_DPB_SIZE; i++) {
if ((NULL != p_Dec->dpb_info[i].picbuf) && (p_Dec->dpb_info[i].slot_index >= 0)) {
p_Dec->in_task->refer[i] = p_Dec->dpb_info[i].slot_index;
mpp_buf_slot_set_flag(p_Dec->frame_slots, p_Dec->dpb_info[i].slot_index, SLOT_HAL_INPUT);
mpp_buf_slot_set_flag(p_Dec->frame_slots, p_Dec->dpb_info[i].slot_index, SLOT_CODEC_USE);
}
}
for (i = 0; i < MAX_DPB_SIZE; i++) {
if ((NULL != p_Dec->dpb_info[i].picbuf) && (p_Dec->dpb_info[i].slot_index >= 0)) {
p_Dec->in_task->refer[i] = p_Dec->dpb_info[i].slot_index;
mpp_buf_slot_set_flag(p_Dec->frame_slots, p_Dec->dpb_info[i].slot_index, SLOT_HAL_INPUT);
mpp_buf_slot_set_flag(p_Dec->frame_slots, p_Dec->dpb_info[i].slot_index, SLOT_CODEC_USE);
}
}
__RETURN:
return MPP_OK;

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

@@ -197,12 +197,12 @@ typedef enum {
typedef struct h264_dpb_mark_t {
RK_U8 top_used;
RK_U8 bot_used;
RK_U8 out_flag;
RK_U8 out_flag;
RK_U8 mark_idx;
MppFrame frame;
RK_S32 slot_idx;
RK_S32 poc;
RK_S64 pts;
RK_S32 poc;
RK_S64 pts;
struct h264_store_pic_t *pic;
} H264_DpbMark_t;
@@ -226,7 +226,7 @@ typedef struct h264_dpb_info_t {
RK_U32 bot_valid;
struct h264_store_pic_t *picbuf;
RK_U32 have_same;
RK_U32 have_same;
} H264_DpbInfo_t;
//!< refence picture information
@@ -688,7 +688,7 @@ typedef struct h264_sei_t {
//-- for adding
} scalable_nesting;
RK_U32 user_data_DivX_flag;
RK_U32 user_data_DivX_flag;
// Placeholder; in future more supported types will contribute to more
//---- follow is used in other parts
RK_S32 mvc_scalable_nesting_flag;
@@ -832,36 +832,36 @@ typedef struct h264d_input_ctx_t {
//!< input data
RK_U8 *in_buf;
size_t in_length;
RK_U32 pkt_eos;
RK_U32 pkt_eos;
MppPacket in_pkt;
MppPacket in_pkt;
RK_S64 in_pts;
RK_S64 in_dts;
RK_U8 has_get_eos;
RK_S64 in_pts;
RK_S64 in_dts;
RK_U8 has_get_eos;
//!< output data
RK_U8 *out_buf;
RK_U32 out_length;
RK_U8 task_valid;
RK_U32 task_eos;
RK_U32 task_eos;
//!< have extradata
RK_U8 is_nalff;
RK_U8 profile;
RK_U8 level;
RK_U32 nal_size;
RK_S32 sps_num;
RK_S32 pps_num;
//!< have extradata
RK_U8 is_nalff;
RK_U8 profile;
RK_U8 level;
RK_U32 nal_size;
RK_S32 sps_num;
RK_S32 pps_num;
} H264dInputCtx_t;
//!< TimeStamp context
#define MAX_PTS_NUM 5
typedef struct h264d_timestamp_t{
RK_U64 begin_off;
RK_U64 end_off;
RK_S64 pts;
RK_S64 dts;
}H264dTimeStamp_t;
typedef struct h264d_timestamp_t {
RK_U64 begin_off;
RK_U64 end_off;
RK_S64 pts;
RK_S64 dts;
} H264dTimeStamp_t;
//!< current stream
typedef struct h264d_curstrm_t {
@@ -881,12 +881,12 @@ typedef struct h264d_curstrm_t {
RK_U8 prefixdata[START_PREFIX_3BYTE];
RK_U8 startcode_found;
RK_U8 endcode_found;
//!< time stamp
//RK_S32 has_fetch_ts;
RK_U8 pkt_ts_idx;
RK_U64 pkt_used_bytes; //!< byte offset from starting packet start
//!< time stamp
//RK_S32 has_fetch_ts;
RK_U8 pkt_ts_idx;
RK_U64 pkt_used_bytes; //!< byte offset from starting packet start
H264dTimeStamp_t pkt_ts[MAX_PTS_NUM];
H264dTimeStamp_t pkt_ts[MAX_PTS_NUM];
} H264dCurStream_t;
//!< current parameters
@@ -906,18 +906,18 @@ typedef struct h264d_cur_ctx_t {
struct h264_dec_ctx_t *p_Dec;
struct h264d_video_ctx_t *p_Vid; //!< parameters for video decoder
RK_S64 last_pts;
RK_S64 last_dts;
RK_S64 curr_pts;
RK_S64 curr_dts;
RK_S64 last_pts;
RK_S64 last_dts;
RK_S64 curr_pts;
RK_S64 curr_dts;
} H264dCurCtx_t;
typedef struct h264d_outlist_t {
RK_U32 begin;
RK_U32 end;
RK_U32 max_size;
H264_DpbMark_t *list[MAX_MARK_SIZE];
}H264dOutList_t;
RK_U32 begin;
RK_U32 end;
RK_U32 max_size;
H264_DpbMark_t *list[MAX_MARK_SIZE];
} H264dOutList_t;
//!< parameters for video decoder
typedef struct h264d_video_ctx_t {
@@ -956,8 +956,8 @@ typedef struct h264d_video_ctx_t {
RK_U32 PicWidthInMbs;
RK_U32 FrameHeightInMbs;
RK_S32 yuv_format;
RK_U32 bit_depth_chroma;
RK_U32 bit_depth_luma;
RK_U32 bit_depth_chroma;
RK_U32 bit_depth_luma;
RK_S32 width;
RK_S32 height;
RK_U32 width_after_crop;
@@ -988,17 +988,17 @@ typedef struct h264d_video_ctx_t {
RK_S32 active_mvc_sps_flag;
RK_U32 g_framecnt;
RK_U32 dpb_size[MAX_NUM_DPB_LAYERS];
struct h264d_outlist_t outlist[MAX_NUM_DPB_LAYERS];
RK_S32 last_outputpoc[MAX_NUM_DPB_LAYERS];
RK_U32 has_get_i_frame_flag;
RK_U32 dpb_size[MAX_NUM_DPB_LAYERS];
struct h264d_outlist_t outlist[MAX_NUM_DPB_LAYERS];
RK_S32 last_outputpoc[MAX_NUM_DPB_LAYERS];
RK_U32 has_get_i_frame_flag;
} H264dVideoCtx_t;
typedef struct h264d_mem_t {
struct h264_dpb_mark_t dpb_mark[MAX_MARK_SIZE]; //!< for fpga register check, dpb mark
struct h264_dpb_info_t dpb_info[MAX_DPB_SIZE]; //!< 16
struct h264_dpb_info_t dpb_old[2][MAX_DPB_SIZE];
struct h264_refpic_info_t refpic_info_p[MAX_REF_SIZE]; //!< 32
struct h264_refpic_info_t refpic_info_p[MAX_REF_SIZE]; //!< 32
struct h264_refpic_info_t refpic_info_b[2][MAX_REF_SIZE]; //!< [2][32]
struct h264d_dxva_ctx_t dxva_ctx;
} H264_DecMem_t;
@@ -1048,10 +1048,10 @@ typedef enum slice_state_type {
//!< decoder video parameter
typedef struct h264_err_ctx_t {
RK_U32 err_flag;
void *data;
RK_U32 length;
}H264dErrCtx_t;
RK_U32 err_flag;
void *data;
RK_U32 length;
} H264dErrCtx_t;
//!< decoder video parameter
@@ -1059,7 +1059,7 @@ typedef struct h264_dec_ctx_t {
struct h264d_mem_t *mem;
struct h264_dpb_mark_t *dpb_mark; //!< for write out, MAX_DPB_SIZE
struct h264_dpb_info_t *dpb_info; //!< 16
struct h264_dpb_info_t *dpb_old[2]; //!< 16
struct h264_dpb_info_t *dpb_old[2]; //!< 16
struct h264_refpic_info_t *refpic_info_p; //!< 32
struct h264_refpic_info_t *refpic_info_b[2]; //!< [2][32]
struct h264d_dxva_ctx_t *dxva_ctx;
@@ -1073,7 +1073,7 @@ typedef struct h264_dec_ctx_t {
RK_U8 is_first_frame;
RK_U8 is_new_frame;
RK_U8 is_parser_end;
RK_U8 mvc_valid;
RK_U8 mvc_valid;
struct h264d_logctx_t logctx; //!< debug log file
struct log_ctx_t logctxbuf[LOG_MAX];
@@ -1087,7 +1087,7 @@ typedef struct h264_dec_ctx_t {
RK_U32 task_eos;
HalDecTask *in_task;
RK_S32 last_frame_slot_idx;
struct h264_err_ctx_t err_ctx;
struct h264_err_ctx_t err_ctx;
} H264_DecCtx_t;

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

@@ -381,8 +381,8 @@ __FAILED:
static void dpb_mark_malloc(H264dVideoCtx_t *p_Vid, RK_S32 structure, RK_U8 combine_flag, RK_S32 layer_id)
{
RK_U8 idx = 1;
H264_DpbMark_t *cur_mark = NULL;
RK_U32 hor_stride = 0, ver_stride = 0;
H264_DpbMark_t *cur_mark = NULL;
RK_U32 hor_stride = 0, ver_stride = 0;
H264_DecCtx_t *p_Dec = p_Vid->p_Dec;
H264_DpbMark_t *p_mark = p_Vid->p_Dec->dpb_mark;
@@ -395,50 +395,49 @@ static void dpb_mark_malloc(H264dVideoCtx_t *p_Vid, RK_S32 structure, RK_U8 comb
mpp_buf_slot_get_unused(p_Vid->p_Dec->frame_slots, &p_mark[idx].slot_idx);
cur_mark = &p_mark[idx];
cur_mark->out_flag = 1;
if(p_Vid->g_framecnt == 255)
{
idx = idx;
}
//LogInfo(p_Vid->p_Dec->logctx.parr[RUN_PARSE], "[MALLOC] g_frame_no=%d, mark_idx=%d, slot_idx=%d \n", p_Vid->g_framecnt, cur_mark->mark_idx, cur_mark->slot_idx);
cur_mark->out_flag = 1;
if (p_Vid->g_framecnt == 255) {
idx = idx;
}
//LogInfo(p_Vid->p_Dec->logctx.parr[RUN_PARSE], "[MALLOC] g_frame_no=%d, mark_idx=%d, slot_idx=%d \n", p_Vid->g_framecnt, cur_mark->mark_idx, cur_mark->slot_idx);
//mpp_print_slot_flag_info(g_debug_file1, p_Dec->frame_slots, cur_mark->slot_idx);
H264D_LOG("[extra_data][Malloc] lay_id=%d, g_framecnt=%d, mark_idx=%d, slot_idx=%d, pts=%lld \n", layer_id,
p_Vid->g_framecnt, cur_mark->mark_idx, cur_mark->slot_idx, p_Vid->p_Inp->in_pts);
H264D_LOG("[extra_data][Malloc] lay_id=%d, g_framecnt=%d, mark_idx=%d, slot_idx=%d, pts=%lld \n", layer_id,
p_Vid->g_framecnt, cur_mark->mark_idx, cur_mark->slot_idx, p_Vid->p_Inp->in_pts);
//FPRINT(g_debug_file1, "[MALLOC] g_frame_no=%d, mark_idx=%d, slot_idx=%d \n", p_Vid->g_framecnt, cur_mark->mark_idx, cur_mark->slot_idx);
//FPRINT(g_debug_file1, "[MALLOC] g_frame_no=%d, mark_idx=%d, slot_idx=%d \n", p_Vid->g_framecnt, cur_mark->mark_idx, cur_mark->slot_idx);
if((YUV420 == p_Vid->yuv_format) && (8 == p_Vid->bit_depth_luma)) {
mpp_frame_set_fmt(cur_mark->frame, MPP_FMT_YUV420SP);
} else if ((YUV420 == p_Vid->yuv_format) && (10 == p_Vid->bit_depth_luma)) {
mpp_frame_set_fmt(cur_mark->frame, MPP_FMT_YUV420SP_10BIT);
H264D_LOG(" alloc_picture ----- MPP_FMT_YUV420SP_10BIT ------ \n");
} else if ((YUV422 == p_Vid->yuv_format) && (8 == p_Vid->bit_depth_luma)) {
mpp_frame_set_fmt(cur_mark->frame, MPP_FMT_YUV422SP);
} else if ((YUV422 == p_Vid->yuv_format) && (10 == p_Vid->bit_depth_luma)) {
mpp_frame_set_fmt(cur_mark->frame, MPP_FMT_YUV422SP_10BIT);
}
if ((YUV420 == p_Vid->yuv_format) && (8 == p_Vid->bit_depth_luma)) {
mpp_frame_set_fmt(cur_mark->frame, MPP_FMT_YUV420SP);
} else if ((YUV420 == p_Vid->yuv_format) && (10 == p_Vid->bit_depth_luma)) {
mpp_frame_set_fmt(cur_mark->frame, MPP_FMT_YUV420SP_10BIT);
H264D_LOG(" alloc_picture ----- MPP_FMT_YUV420SP_10BIT ------ \n");
} else if ((YUV422 == p_Vid->yuv_format) && (8 == p_Vid->bit_depth_luma)) {
mpp_frame_set_fmt(cur_mark->frame, MPP_FMT_YUV422SP);
} else if ((YUV422 == p_Vid->yuv_format) && (10 == p_Vid->bit_depth_luma)) {
mpp_frame_set_fmt(cur_mark->frame, MPP_FMT_YUV422SP_10BIT);
}
hor_stride = ((p_Vid->width * p_Vid->bit_depth_luma + 127) & (~127))/8;
ver_stride = p_Vid->height;
hor_stride = MPP_ALIGN(hor_stride, 256) | 256;
ver_stride = MPP_ALIGN(ver_stride, 16);
hor_stride = ((p_Vid->width * p_Vid->bit_depth_luma + 127) & (~127)) / 8;
ver_stride = p_Vid->height;
hor_stride = MPP_ALIGN(hor_stride, 256) | 256;
ver_stride = MPP_ALIGN(ver_stride, 16);
mpp_frame_set_hor_stride(cur_mark->frame, hor_stride); // before crop
mpp_frame_set_ver_stride(cur_mark->frame, ver_stride);
mpp_frame_set_hor_stride(cur_mark->frame, hor_stride); // before crop
mpp_frame_set_ver_stride(cur_mark->frame, ver_stride);
mpp_frame_set_width(cur_mark->frame, p_Vid->width_after_crop); // after crop
mpp_frame_set_height(cur_mark->frame, p_Vid->height_after_crop);
H264D_LOG("hor_stride=%d, ver_stride=%d, width=%d, height=%d, crop_width=%d, crop_height =%d \n", hor_stride,
ver_stride, p_Vid->width, p_Vid->height, p_Vid->width_after_crop, p_Vid->height_after_crop);
mpp_frame_set_width(cur_mark->frame, p_Vid->width_after_crop); // after crop
mpp_frame_set_height(cur_mark->frame, p_Vid->height_after_crop);
H264D_LOG("hor_stride=%d, ver_stride=%d, width=%d, height=%d, crop_width=%d, crop_height =%d \n", hor_stride,
ver_stride, p_Vid->width, p_Vid->height, p_Vid->width_after_crop, p_Vid->height_after_crop);
mpp_frame_set_pts(cur_mark->frame, p_Vid->p_Cur->last_pts);
mpp_frame_set_dts(cur_mark->frame, p_Vid->p_Cur->last_dts);
//mpp_log("[ timeUs ] alloc_pts=%lld, input_pts=%lld \n", p_Vid->p_Cur->last_pts, p_Vid->p_Inp->in_pts);
mpp_frame_set_pts(cur_mark->frame, p_Vid->p_Cur->last_pts);
mpp_frame_set_dts(cur_mark->frame, p_Vid->p_Cur->last_dts);
//mpp_log("[ timeUs ] alloc_pts=%lld, input_pts=%lld \n", p_Vid->p_Cur->last_pts, p_Vid->p_Inp->in_pts);
mpp_buf_slot_set_prop(p_Dec->frame_slots, cur_mark->slot_idx, SLOT_FRAME, cur_mark->frame);
FPRINT(g_debug_file0, "[Malloc] g_framecnt=%d, mark_idx=%d, slot_idx=%d, lay_id=%d, pts=%lld \n",
p_Vid->g_framecnt, cur_mark->mark_idx, cur_mark->slot_idx, layer_id, p_Vid->p_Inp->in_pts);
mpp_buf_slot_set_prop(p_Dec->frame_slots, cur_mark->slot_idx, SLOT_FRAME, cur_mark->frame);
FPRINT(g_debug_file0, "[Malloc] g_framecnt=%d, mark_idx=%d, slot_idx=%d, lay_id=%d, pts=%lld \n",
p_Vid->g_framecnt, cur_mark->mark_idx, cur_mark->slot_idx, layer_id, p_Vid->p_Inp->in_pts);
p_Vid->active_dpb_mark[layer_id] = cur_mark;
}

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

File diff suppressed because it is too large Load Diff

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

@@ -31,11 +31,11 @@
#include <ctype.h>
char *_strupr(char *str)
{
char *orign=str;
for (; *str != '\0'; str++) {
*str = toupper(*str);
}
return orign;
char *orign = str;
for (; *str != '\0'; str++) {
*str = toupper(*str);
}
return orign;
}
#endif
@@ -66,38 +66,38 @@ static void interpret_user_data_registered_itu_t_t35_info()
static MPP_RET interpret_user_data_unregistered_info(RK_U8 *payload, RK_S32 size, H264_SEI_t *sei_msg)
{
MPP_RET ret = MPP_ERR_UNKNOW;
H264D_LOG("size=%d",size);
ASSERT(size >= 16);
MPP_RET ret = MPP_ERR_UNKNOW;
H264D_LOG("size=%d", size);
ASSERT(size >= 16);
#if 0
{
RK_U32 offset = 0;
RK_U8 payload_byte;
mpp_log("User data unregistered SEI message\n");
mpp_log("uuid_iso_11578 = 0x");
for (offset = 0; offset < 16; offset++) {
mpp_log("%02x",payload[offset]);
}
while (offset < size) {
payload_byte = payload[offset];
offset++;
mpp_log("Unreg data payload_byte = %02x\n", payload_byte);
}
}
{
RK_U32 offset = 0;
RK_U8 payload_byte;
mpp_log("User data unregistered SEI message\n");
mpp_log("uuid_iso_11578 = 0x");
for (offset = 0; offset < 16; offset++) {
mpp_log("%02x", payload[offset]);
}
while (offset < size) {
payload_byte = payload[offset];
offset++;
mpp_log("Unreg data payload_byte = %02x\n", payload_byte);
}
}
#endif
sei_msg->user_data_DivX_flag = strstr(_strupr((char *)&payload[16]), "DIVX") ? 1 : 0;
if (sei_msg->user_data_DivX_flag) {
H264D_ERR("DivX is not supported. \n");
sei_msg->p_Dec->err_ctx.err_flag |= VPU_FRAME_ERR_UNSUPPORT;
ret = MPP_NOK;
goto __FAILED;
}
sei_msg->user_data_DivX_flag = strstr(_strupr((char *)&payload[16]), "DIVX") ? 1 : 0;
if (sei_msg->user_data_DivX_flag) {
H264D_ERR("DivX is not supported. \n");
sei_msg->p_Dec->err_ctx.err_flag |= VPU_FRAME_ERR_UNSUPPORT;
ret = MPP_NOK;
goto __FAILED;
}
return ret = MPP_OK;
return ret = MPP_OK;
__FAILED:
return ret;
return ret;
}
static void interpret_pan_scan_rect_info()
@@ -232,8 +232,8 @@ static MPP_RET interpret_buffering_period_info(RK_U8 *payload, RK_S32 size, BitR
p_bitctx = &tmp_strmdata;
mpp_set_bitread_ctx(p_bitctx, payload, size);
READ_UE(p_bitctx, &sei_msg->seq_parameter_set_id, "seq_parameter_set_id");
//mpp_log("sei_msg->seq_parameter_set_id=%d \n", sei_msg->seq_parameter_set_id);
CHECK_RANGE(p_bitctx, sei_msg->seq_parameter_set_id, 0, 32);
//mpp_log("sei_msg->seq_parameter_set_id=%d \n", sei_msg->seq_parameter_set_id);
CHECK_RANGE(p_bitctx, sei_msg->seq_parameter_set_id, 0, 32);
return ret = MPP_OK;
__BITREAD_ERR:
ret = p_bitctx->ret;
@@ -258,27 +258,27 @@ static void interpret_reserved_info(RK_U8 *payload, RK_S32 size, BitReadCtx_t *p
static MPP_RET parserSEI(H264_SLICE_t *cur_slice, BitReadCtx_t *p_bitctx, H264_SEI_t *sei_msg, RK_U8 *msg)
{
MPP_RET ret = MPP_ERR_UNKNOW;
H264dVideoCtx_t *p_Vid = cur_slice->p_Vid;
H264dVideoCtx_t *p_Vid = cur_slice->p_Vid;
H264D_LOG("[SEI_TYPE] type=%d \n", sei_msg->type);
H264D_LOG("[SEI_TYPE] type=%d \n", sei_msg->type);
switch (sei_msg->type) {
case SEI_BUFFERING_PERIOD:
FUN_CHECK(ret = interpret_buffering_period_info(msg, sei_msg->payload_size, p_bitctx, sei_msg));
{
H264_SPS_t *sps = NULL;
H264_subSPS_t *subset_sps = NULL;
if (sei_msg->mvc_scalable_nesting_flag) {
p_Vid->active_mvc_sps_flag = 1;
sps = NULL;
subset_sps = &p_Vid->subspsSet[sei_msg->seq_parameter_set_id];
} else {
p_Vid->active_mvc_sps_flag = 0;
sps = &p_Vid->spsSet[sei_msg->seq_parameter_set_id];
subset_sps = NULL;
}
p_Vid->exit_picture_flag = 1;
FUN_CHECK(ret = activate_sps(p_Vid, sps, subset_sps));
}
{
H264_SPS_t *sps = NULL;
H264_subSPS_t *subset_sps = NULL;
if (sei_msg->mvc_scalable_nesting_flag) {
p_Vid->active_mvc_sps_flag = 1;
sps = NULL;
subset_sps = &p_Vid->subspsSet[sei_msg->seq_parameter_set_id];
} else {
p_Vid->active_mvc_sps_flag = 0;
sps = &p_Vid->spsSet[sei_msg->seq_parameter_set_id];
subset_sps = NULL;
}
p_Vid->exit_picture_flag = 1;
FUN_CHECK(ret = activate_sps(p_Vid, sps, subset_sps));
}
break;
case SEI_PIC_TIMING:
interpret_picture_timing_info();
@@ -353,7 +353,7 @@ static MPP_RET parserSEI(H264_SLICE_t *cur_slice, BitReadCtx_t *p_bitctx, H264_S
break;
case SEI_MVC_SCALABLE_NESTING:
FUN_CHECK(ret = interpret_mvc_scalable_nesting_info(msg, sei_msg->payload_size, p_bitctx));
sei_msg->mvc_scalable_nesting_flag = 1;
sei_msg->mvc_scalable_nesting_flag = 1;
break;
case SEI_VIEW_SCALABILITY_INFO:
interpret_mvc_scalability_info();
@@ -385,7 +385,7 @@ MPP_RET process_sei(H264_SLICE_t *currSlice)
FunctionIn(currSlice->logctx->parr[RUN_PARSE]);
memset(sei_msg, 0, sizeof(*sei_msg));
sei_msg->mvc_scalable_nesting_flag = 0; //init to false
sei_msg->p_Dec = currSlice->p_Dec;
sei_msg->p_Dec = currSlice->p_Dec;
do {
sei_msg->type = 0;
READ_BITS(p_bitctx, 8, &tmp_byte, "tmp_byte");

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

@@ -398,7 +398,7 @@ static MPP_RET set_slice_user_parmeters(H264_SLICE_t *currSlice)
currSlice->active_sps = p_Vid->active_sps;
currSlice->active_pps = p_Vid->active_pps;
p_Vid->type = currSlice->slice_type;
p_Vid->type = currSlice->slice_type;
return MPP_OK;
__FAILED:
ASSERT(0);

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

@@ -179,11 +179,11 @@ static MPP_RET parser_sps(BitReadCtx_t *p_bitctx, H264_SPS_t *cur_sps, H264_DecC
|| cur_sps->profile_idc == 128 || cur_sps->profile_idc == 138) {
READ_UE(p_bitctx, &cur_sps->chroma_format_idc, "chroma_format_idc");
ASSERT(cur_sps->chroma_format_idc < 4);
//if (cur_sps->chroma_format_idc >= 3) {
// H264D_ERR("ERROR: Not support chroma_format_idc=%d.", cur_sps->chroma_format_idc);
// p_Dec->err_ctx.err_flag |= VPU_FRAME_ERR_UNSUPPORT;
// goto __FAILED;
//}
//if (cur_sps->chroma_format_idc >= 3) {
// H264D_ERR("ERROR: Not support chroma_format_idc=%d.", cur_sps->chroma_format_idc);
// p_Dec->err_ctx.err_flag |= VPU_FRAME_ERR_UNSUPPORT;
// goto __FAILED;
//}
//if (cur_sps->chroma_format_idc == 3) {
// READ_ONEBIT(p_bitctx, &cur_sps->separate_colour_plane_flag, "separate_colour_plane_flag");
// LogError(p_bitctx->ctx, "Not support YUV444 format current.");
@@ -361,8 +361,8 @@ static void update_video_pars(H264dVideoCtx_t *p_Vid, H264_SPS_t *sps)
p_Vid->width = p_Vid->PicWidthInMbs * 16;
p_Vid->height = p_Vid->FrameHeightInMbs * 16;
p_Vid->bit_depth_luma = sps->bit_depth_luma_minus8 + 8;
p_Vid->bit_depth_chroma = sps->bit_depth_chroma_minus8 + 8;
p_Vid->bit_depth_luma = sps->bit_depth_luma_minus8 + 8;
p_Vid->bit_depth_chroma = sps->bit_depth_chroma_minus8 + 8;
if (p_Vid->yuv_format == YUV420) {
p_Vid->width_cr = (p_Vid->width >> 1);
@@ -545,10 +545,10 @@ MPP_RET activate_sps(H264dVideoCtx_t *p_Vid, H264_SPS_t *sps, H264_subSPS_t *sub
if (video_pars_changed(p_Vid, p_Vid->active_sps, 1)) {
FUN_CHECK(ret = flush_dpb(p_Vid->p_Dpb_layer[1], 2));
FUN_CHECK(ret = init_dpb(p_Vid, p_Vid->p_Dpb_layer[1], 2));
update_last_video_pars(p_Vid, p_Vid->active_sps, 1);
//!< init frame slots, store frame buffer size
p_Vid->dpb_size[1] = p_Vid->p_Dpb_layer[1]->size;
//mpp_buf_slot_setup(p_Vid->p_Dec->frame_slots, p_Vid->dpb_size[0] + p_Vid->dpb_size[1] + 3);
update_last_video_pars(p_Vid, p_Vid->active_sps, 1);
//!< init frame slots, store frame buffer size
p_Vid->dpb_size[1] = p_Vid->p_Dpb_layer[1]->size;
//mpp_buf_slot_setup(p_Vid->p_Dec->frame_slots, p_Vid->dpb_size[0] + p_Vid->dpb_size[1] + 3);
}
} else { //!< layer_id == 0
p_Vid->active_sps = sps;
@@ -560,10 +560,10 @@ MPP_RET activate_sps(H264dVideoCtx_t *p_Vid, H264_SPS_t *sps, H264_subSPS_t *sub
FUN_CHECK(ret = flush_dpb(p_Vid->p_Dpb_layer[0], 1));
}
FUN_CHECK(ret = init_dpb(p_Vid, p_Vid->p_Dpb_layer[0], 1));
update_last_video_pars(p_Vid, p_Vid->active_sps, 0);
//!< init frame slots, store frame buffer size
p_Vid->dpb_size[0] = p_Vid->p_Dpb_layer[0]->size;
//mpp_buf_slot_setup(p_Vid->p_Dec->frame_slots, p_Vid->dpb_size[0] + 3);
update_last_video_pars(p_Vid, p_Vid->active_sps, 0);
//!< init frame slots, store frame buffer size
p_Vid->dpb_size[0] = p_Vid->p_Dpb_layer[0]->size;
//mpp_buf_slot_setup(p_Vid->p_Dec->frame_slots, p_Vid->dpb_size[0] + 3);
}
}
update_video_pars(p_Vid, p_Vid->active_sps);

48
mpp/codec/dec/h265/h265d_parser.c
View File

@@ -716,11 +716,11 @@ static RK_S32 hls_slice_header(HEVCContext *s)
if (s->nal_unit_type >= 16 && s->nal_unit_type <= 23)
READ_ONEBIT(gb, &sh->no_output_of_prior_pics_flag);
if(IS_IRAP(s) && s->miss_ref_flag && sh->first_slice_in_pic_flag){
// mpp_err("s->nal_unit_type = %d s->poc %d",s->nal_unit_type,s->poc);
if (IS_IRAP(s) && s->miss_ref_flag && sh->first_slice_in_pic_flag) {
// mpp_err("s->nal_unit_type = %d s->poc %d",s->nal_unit_type,s->poc);
s->max_ra = INT_MAX;
s->miss_ref_flag = 0;
}
}
READ_UE(gb, &pps_id);
if (pps_id >= MAX_PPS_COUNT || !s->pps_list[pps_id]) {
@@ -1134,8 +1134,8 @@ static RK_S32 hevc_frame_start(HEVCContext *s)
s->miss_ref_flag = 0;
ret = mpp_hevc_frame_rps(s);
if(s->miss_ref_flag && !IS_IRAP(s)){
mpp_frame_set_errinfo(s->frame,VPU_FRAME_ERR_UNKNOW);
if (s->miss_ref_flag && !IS_IRAP(s)) {
mpp_frame_set_errinfo(s->frame, VPU_FRAME_ERR_UNKNOW);
s->ref->error_flag = 1;
}
@@ -1485,18 +1485,18 @@ static RK_S32 split_nal_units(HEVCContext *s, RK_U8 *buf, RK_U32 length)
continue;
}
if (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
RK_U32 state = (RK_U32)-1;
RK_U32 state = (RK_U32) - 1;
int has_nal = 0;
for (i = 0; i < (RK_S32)length; i++) {
state = (state << 8) | buf[i];
if (((state >> 8) & 0xFFFFFF) == START_CODE){
if (((state >> 8) & 0xFFFFFF) == START_CODE) {
has_nal = 1;
i = i -3;
i = i - 3;
break;
}
}
if(has_nal){
if (has_nal) {
length -= i;
buf += i;
continue;
@@ -1671,7 +1671,7 @@ MPP_RET h265d_prepare(void *ctx, MppPacket pkt, HalDecTask *task)
void *pos = NULL;
RK_S32 length = 0;
//task->valid = 0;
//task->valid = 0;
s->eos = mpp_packet_get_eos(pkt);
if (sc != NULL) {
sc->eos = s->eos;
@@ -1717,12 +1717,12 @@ MPP_RET h265d_prepare(void *ctx, MppPacket pkt, HalDecTask *task)
pos = buf + length;
s->pts = pts;
mpp_packet_set_pos(pkt, pos);
if(s->eos){
task->valid = 0;
task->flags.eos = 1;
if (s->eos) {
task->valid = 0;
task->flags.eos = 1;
h265d_flush(ctx);
}
h265d_flush(ctx);
}
}
#ifdef dump
if (s->nb_frame < 10 && fp != NULL) {
@@ -1974,11 +1974,11 @@ MPP_RET h265d_flush(void *ctx)
ret = mpp_hevc_output_frame(ctx, 1);
} while (ret);
frame = &s->DPB[s->output_frame_idx];
if(frame->slot_index < 0xff){
if (frame->slot_index < 0xff) {
mpp_buf_slot_set_prop(s->slots, frame->slot_index, SLOT_EOS, &eos);
}else{
if(s->notify_cb.callBack != NULL){
s->notify_cb.callBack(s->notify_cb.opaque,NULL);
} else {
if (s->notify_cb.callBack != NULL) {
s->notify_cb.callBack(s->notify_cb.opaque, NULL);
}
}
@@ -2013,17 +2013,17 @@ MPP_RET h265d_callback(void *ctx, void *err_info)
HEVCContext *s = (HEVCContext *)h265dctx->priv_data;
RK_U32 i = 0;
s->max_ra = INT_MAX;
// s->miss_ref_flag = 1;
mpp_buf_slot_get_prop(s->slots, s->ref->slot_index,SLOT_FRAME,&s->ref->frame);
mpp_frame_set_errinfo(s->ref->frame,VPU_FRAME_ERR_UNKNOW);
// s->miss_ref_flag = 1;
mpp_buf_slot_get_prop(s->slots, s->ref->slot_index, SLOT_FRAME, &s->ref->frame);
mpp_frame_set_errinfo(s->ref->frame, VPU_FRAME_ERR_UNKNOW);
mpp_buf_slot_set_prop(s->slots, s->ref->slot_index, SLOT_FRAME, s->ref->frame);
for (i = 0; i < MPP_ARRAY_ELEMS(s->DPB); i++) {
if(s->DPB[i].slot_index == s->ref->slot_index){
if (s->DPB[i].slot_index == s->ref->slot_index) {
s->DPB[i].error_flag = 1;
}
}
(void) err_info;
(void) err_info;
return MPP_OK;
}

4
mpp/codec/dec/h265/h265d_parser.h
View File

@@ -696,8 +696,8 @@ typedef struct HEVCContext {
void *hal_pic_private;
RK_S64 pts;
RK_U8 has_get_eos;
RK_U8 miss_ref_flag;
RK_U8 has_get_eos;
RK_U8 miss_ref_flag;
IOInterruptCB notify_cb;
} HEVCContext;

3
mpp/codec/dec/h265/h265d_parser2_syntax.c
View File

@@ -172,8 +172,7 @@ static void fill_picture_parameters(const HEVCContext *h,
}
// mpp_err("fill RefPicList from the DPB");
// fill RefPicList from the DPB
for (i = 0, j = 0; i < MPP_ARRAY_ELEMS(pp->RefPicList); i++)
{
for (i = 0, j = 0; i < MPP_ARRAY_ELEMS(pp->RefPicList); i++) {
const HEVCFrame *frame = NULL;
while (!frame && j < MPP_ARRAY_ELEMS(h->DPB)) {
if (&h->DPB[j] != current_picture &&

4
mpp/codec/dec/h265/h265d_refs.c
View File

@@ -96,7 +96,7 @@ static HEVCFrame *alloc_frame(HEVCContext *s)
mpp_frame_set_hor_stride(frame->frame, (s->h265dctx->coded_width * s->h265dctx->nBitDepth) >> 3);
mpp_frame_set_ver_stride(frame->frame, s->h265dctx->coded_height);
mpp_frame_set_fmt(frame->frame, s->h265dctx->pix_fmt);
mpp_frame_set_errinfo(frame->frame,0);
mpp_frame_set_errinfo(frame->frame, 0);
h265d_dbg(H265D_DBG_GLOBAL, "w_stride %d h_stride %d\n", s->h265dctx->coded_width, s->h265dctx->coded_height);
@@ -349,7 +349,7 @@ static int add_candidate_ref(HEVCContext *s, RefPicList *list,
mpp_buf_slot_set_flag(s->slots, ref->slot_index, SLOT_CODEC_USE);
}
mark_ref(ref, ref_flag);
if(ref->error_flag){
if (ref->error_flag) {
s->miss_ref_flag = 1;
}
return 0;

20
mpp/codec/mpp_buf_slot.cpp
View File

@@ -194,7 +194,7 @@ struct MppBufSlotsImpl_t {
// buffer parameter, default alignement is 16
AlignFunc hal_hor_align; // default NULL
AlignFunc hal_ver_align; // default NULL
AlignFunc hal_len_align; // default NULL
AlignFunc hal_len_align; // default NULL
size_t buf_size;
RK_S32 buf_count;
// buffer size equal to (h_stride * v_stride) * numerator / denominator
@@ -239,7 +239,7 @@ static void generate_info_set(MppBufSlotsImpl *impl, MppFrame frame)
RK_U32 size = hal_hor_stride * hal_ver_stride;
size *= impl->numerator;
size /= impl->denominator;
size = impl->hal_len_align ? impl->hal_len_align(hal_hor_stride * hal_ver_stride) : size;
size = impl->hal_len_align ? impl->hal_len_align(hal_hor_stride * hal_ver_stride) : size;
mpp_frame_set_width(impl->info_set, width);
mpp_frame_set_height(impl->info_set, height);
@@ -514,7 +514,7 @@ MPP_RET mpp_buf_slot_init(MppBufSlots *slots)
// slots information default setup
impl->hal_hor_align = default_align_16;
impl->hal_ver_align = default_align_16;
impl->hal_len_align = NULL;
impl->hal_len_align = NULL;
impl->numerator = 10;
impl->denominator = 5;
@@ -789,7 +789,7 @@ MPP_RET mpp_buf_slot_set_prop(MppBufSlots slots, RK_S32 index, SlotPropType type
mpp_log("new width %4d height %4d stride hor %4d ver %4d\n",
dst->width, dst->height, dst->hor_stride, dst->ver_stride);
#endif
// info change found here
// info change found here
}
} break;
case SLOT_BUFFER: {
@@ -830,7 +830,7 @@ MPP_RET mpp_buf_slot_get_prop(MppBufSlots slots, RK_S32 index, SlotPropType type
} break;
case SLOT_FRAME: {
MppFrame *frame = (MppFrame *)val;
//*frame = (slot->status.has_frame) ? (slot->frame) : (NULL);
//*frame = (slot->status.has_frame) ? (slot->frame) : (NULL);
mpp_assert(slot->status.has_frame);
if (slot->status.has_frame) {
@@ -840,9 +840,9 @@ MPP_RET mpp_buf_slot_get_prop(MppBufSlots slots, RK_S32 index, SlotPropType type
} else
*frame = NULL;
} break;
case SLOT_FRAME_PTR: {
case SLOT_FRAME_PTR: {
MppFrame *frame = (MppFrame *)val;
*frame = (slot->status.has_frame) ? (slot->frame) : (NULL);
*frame = (slot->status.has_frame) ? (slot->frame) : (NULL);
} break;
case SLOT_BUFFER: {
MppBuffer *buffer = (MppBuffer *)val;
@@ -874,9 +874,9 @@ MPP_RET mpp_slots_set_prop(MppBufSlots slots, SlotsPropType type, void *val)
case SLOTS_VER_ALIGN: {
impl->hal_ver_align = (AlignFunc)val;
} break;
case SLOTS_LEN_ALIGN: {
impl->hal_len_align = (AlignFunc)val;
} break;
case SLOTS_LEN_ALIGN: {
impl->hal_len_align = (AlignFunc)val;
} break;
case SLOTS_COUNT: {
impl->buf_count = value;
} break;

6
mpp/codec/mpp_dec.cpp
View File

@@ -555,8 +555,8 @@ void *mpp_dec_parser_thread(void *data)
}
parser->lock();
if(MPP_THREAD_RUNNING == parser->get_status()){
if (check_task_wait(dec, &task))
if (MPP_THREAD_RUNNING == parser->get_status()) {
if (check_task_wait(dec, &task))
parser->wait();
}
parser->unlock();
@@ -606,7 +606,7 @@ void *mpp_dec_hal_thread(void *data)
* hal thread wait for dxva interface intput firt
*/
hal->lock();
if(MPP_THREAD_RUNNING == hal->get_status()){
if (MPP_THREAD_RUNNING == hal->get_status()) {
if (hal_task_get_hnd(tasks, TASK_PROCESSING, &task))
hal->wait();
}

46
mpp/common/h264d_log.h
View File

@@ -160,38 +160,38 @@ typedef struct h264d_logctx_t {
//!< vaule check
#define VAL_CHECK(ret, val, ...)\
do{ if(!(val)){\
ret = MPP_ERR_VALUE;\
mpp_log("Function:%s:%d, ERROR: value error.\n", __FUNCTION__, __LINE__);\
goto __FAILED;\
} } while (0)
do{ if(!(val)){\
ret = MPP_ERR_VALUE;\
mpp_log("Function:%s:%d, ERROR: value error.\n", __FUNCTION__, __LINE__);\
goto __FAILED;\
} } while (0)
//!< memory malloc check
#define MEM_CHECK(ret, val, ...)\
do{ if(!(val)) {\
ret = MPP_ERR_MALLOC;\
mpp_log("Function:%s:%d, ERROR: malloc buffer.\n", __FUNCTION__, __LINE__);\
mpp_assert(0); goto __FAILED;\
} } while (0)
do{ if(!(val)) {\
ret = MPP_ERR_MALLOC;\
mpp_log("Function:%s:%d, ERROR: malloc buffer.\n", __FUNCTION__, __LINE__);\
mpp_assert(0); goto __FAILED;\
} } while (0)
//!< file check
#define FLE_CHECK(ret, val, ...)\
do{ if(!(val)) {\
ret = MPP_ERR_OPEN_FILE;\
mpp_log("Function:%s:%d, ERROR: open file.\n", __FUNCTION__, __LINE__);\
ASSERT(0); goto __FAILED;\
} } while (0)
do{ if(!(val)) {\
ret = MPP_ERR_OPEN_FILE;\
mpp_log("Function:%s:%d, ERROR: open file.\n", __FUNCTION__, __LINE__);\
ASSERT(0); goto __FAILED;\
} } while (0)
//!< input check
#define INP_CHECK(ret, val, ...)\
do{ if((val)) {\
ret = MPP_ERR_INIT;\
mpp_log("Function:%s:%d, WARNNING: input empty.\n", __FUNCTION__, __LINE__);\
goto __RETURN;\
} } while (0)
do{ if((val)) {\
ret = MPP_ERR_INIT;\
mpp_log("Function:%s:%d, WARNNING: input empty.\n", __FUNCTION__, __LINE__);\
goto __RETURN;\
} } while (0)
//!< function return check
#define FUN_CHECK(val)\
do{ if((val) < 0) {\
goto __FAILED;\
} } while (0)
do{ if((val) < 0) {\
goto __FAILED;\
} } while (0)
#ifdef ANDROID
#define FPRINT(fp, ...) //{ { mpp_log(__VA_ARGS__); } if (fp) { fprintf(fp, ##__VA_ARGS__); fflush(fp);} }

12
mpp/hal/rkdec/h264d/hal_h264d_api.c
View File

@@ -178,7 +178,7 @@ static void explain_input_buffer(void *hal, HalDecTask *task)
#ifndef ANDROID
RK_S32 VPUClientGetIOMMUStatus()
{
return 0;
return 0;
}
#endif
/*!
@@ -190,8 +190,8 @@ RK_S32 VPUClientGetIOMMUStatus()
//extern "C"
MPP_RET hal_h264d_init(void *hal, MppHalCfg *cfg)
{
MppHalApi *p_api = NULL;
VPU_CLIENT_TYPE vpu_client;
MppHalApi *p_api = NULL;
VPU_CLIENT_TYPE vpu_client;
MPP_RET ret = MPP_ERR_UNKNOW;
H264dHalCtx_t *p_hal = (H264dHalCtx_t *)hal;
@@ -214,7 +214,7 @@ MPP_RET hal_h264d_init(void *hal, MppHalCfg *cfg)
p_api->reset = rkv_h264d_reset;
p_api->flush = rkv_h264d_flush;
p_api->control = rkv_h264d_control;
vpu_client = VPU_DEC_RKV;
vpu_client = VPU_DEC_RKV;
break;
case HAL_VDPU:
p_api->init = vdpu_h264d_init;
@@ -225,7 +225,7 @@ MPP_RET hal_h264d_init(void *hal, MppHalCfg *cfg)
p_api->reset = vdpu_h264d_reset;
p_api->flush = vdpu_h264d_flush;
p_api->control = vdpu_h264d_control;
vpu_client = VPU_DEC;
vpu_client = VPU_DEC;
default:
break;
}
@@ -254,7 +254,7 @@ MPP_RET hal_h264d_init(void *hal, MppHalCfg *cfg)
//!< run init funtion
FUN_CHECK(ret = p_api->init(hal, cfg));
(void *)vpu_client;
(void *)vpu_client;
__RETURN:
return MPP_OK;
__FAILED:

156
mpp/hal/rkdec/h264d/hal_h264d_rkv_pkt.c
View File

@@ -55,7 +55,7 @@ const enum {
static void rkv_write_sps_to_fifo(H264dHalCtx_t *p_hal, FifoCtx_t *pkt)
{
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
fifo_write_bits(pkt, -1, 4, "seq_parameter_set_id"); //!< not used in hard
fifo_write_bits(pkt, -1, 8, "profile_idc"); //!< not used in hard
@@ -104,14 +104,14 @@ static void rkv_write_sps_to_fifo(H264dHalCtx_t *p_hal, FifoCtx_t *pkt)
fifo_write_bits(pkt, 0, 10, "non_anchor_ref_l1");
}
fifo_align_bits(pkt, 32);
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
}
static void rkv_write_pps_to_fifo(H264dHalCtx_t *p_hal, FifoCtx_t *pkt)
{
RK_U32 Scaleing_list_address = 0;
RK_U32 offset = RKV_CABAC_TAB_SIZE + RKV_SPSPPS_SIZE + RKV_RPS_SIZE;
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
fifo_write_bits(pkt, -1, 8, "pps_pic_parameter_set_id");
fifo_write_bits(pkt, -1, 5, "pps_seq_parameter_set_id");
fifo_write_bits(pkt, p_hal->pp->entropy_coding_mode_flag, 1, "entropy_coding_mode_flag");
@@ -131,19 +131,19 @@ static void rkv_write_pps_to_fifo(H264dHalCtx_t *p_hal, FifoCtx_t *pkt)
fifo_write_bits(pkt, p_hal->pp->scaleing_list_enable_flag, 1, "scaleing_list_enable_flag");
Scaleing_list_address = mpp_buffer_get_fd(p_hal->cabac_buf);
//mpp_log("fd=%08x, offset=%d", Scaleing_list_address, offset);
//mpp_log("fd=%08x, offset=%d", Scaleing_list_address, offset);
if (VPUClientGetIOMMUStatus() > 0) {
Scaleing_list_address |= offset << 10;
} else {
Scaleing_list_address += offset;
}
//mpp_log("Scaleing_list_address=%08x \n", Scaleing_list_address);
//mpp_log("Scaleing_list_address=%08x \n", Scaleing_list_address);
#if FPGA_TEST
fifo_write_bits(pkt, 0, 32, "Scaleing_list_address");
#else
fifo_write_bits(pkt, Scaleing_list_address, 32, "Scaleing_list_address");
fifo_write_bits(pkt, Scaleing_list_address, 32, "Scaleing_list_address");
#endif
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
}
@@ -196,7 +196,7 @@ MPP_RET rkv_alloc_fifo_packet(H264dLogCtx_t *logctx, H264dRkvPkt_t *pkts)
RK_U32 sclst_size = RKV_SCALING_LIST_SIZE + 64;
RK_U32 regs_size = sizeof(H264dRkvRegs_t);
FunctionIn(logctx->parr[RUN_HAL]);
FunctionIn(logctx->parr[RUN_HAL]);
//!< initial packages header and malloc buffer
FUN_CHECK(ret = fifo_packet_alloc(&pkts->spspps, H264dPPS_HEADER, pps_size));
FUN_CHECK(ret = fifo_packet_alloc(&pkts->rps, H264dRPS_HEADER, rps_size));
@@ -222,7 +222,7 @@ MPP_RET rkv_alloc_fifo_packet(H264dLogCtx_t *logctx, H264dRkvPkt_t *pkts)
pkts->scanlist.fp_data = NULL;
pkts->reg.fp_data = NULL;
}
FunctionOut(logctx->parr[RUN_HAL]);
FunctionOut(logctx->parr[RUN_HAL]);
return ret = MPP_OK;
__FAILED:
rkv_free_fifo_packet(pkts);
@@ -243,7 +243,7 @@ void rkv_prepare_spspps_packet(void *hal, FifoCtx_t *pkt)
RK_S32 is_long_term = 0, voidx = 0;
H264dHalCtx_t *p_hal = (H264dHalCtx_t *)hal;
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
fifo_packet_reset(pkt);
LogInfo(pkt->logctx, "------------------ Frame SPS_PPS begin ------------------------");
rkv_write_sps_to_fifo(p_hal, pkt);
@@ -259,7 +259,7 @@ void rkv_prepare_spspps_packet(void *hal, FifoCtx_t *pkt)
}
fifo_align_bits(pkt, 64);
fifo_fwrite_data(pkt); //!< "PPSH" header 32 bit
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
}
/*!
***********************************************************************
@@ -277,7 +277,7 @@ void rkv_prepare_framerps_packet(void *hal, FifoCtx_t *pkt)
RK_U16 frame_num_wrap = 0;
H264dHalCtx_t *p_hal = (H264dHalCtx_t *)hal;
DXVA_PicParams_H264_MVC *pp = p_hal->pp;
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
fifo_packet_reset(pkt);
LogInfo(pkt->logctx, "------------------ Frame RPS begin ------------------------");
max_frame_num = 1 << (pp->log2_max_frame_num_minus4 + 4);
@@ -324,7 +324,7 @@ void rkv_prepare_framerps_packet(void *hal, FifoCtx_t *pkt)
fifo_align_bits(pkt, 128);
fifo_flush_bits(pkt);
fifo_fwrite_data(pkt); //!< "RPSH" header 32 bit
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
}
/*!
***********************************************************************
@@ -337,7 +337,7 @@ void rkv_prepare_scanlist_packet(void *hal, FifoCtx_t *pkt)
{
RK_S32 i = 0;
H264dHalCtx_t *p_hal = (H264dHalCtx_t *)hal;
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
if (p_hal->pp->scaleing_list_enable_flag) {
fifo_packet_reset(pkt);
LogInfo(pkt->logctx, "------------------ Scanlist begin ------------------------");
@@ -349,7 +349,7 @@ void rkv_prepare_scanlist_packet(void *hal, FifoCtx_t *pkt)
}
fifo_fwrite_data(pkt); //!< "SCLS" header 32 bit
}
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
}
/*!
@@ -363,56 +363,56 @@ void rkv_generate_regs(void *hal, HalTaskInfo *task, FifoCtx_t *pkt)
{
RK_S32 i = 0;
MppBuffer frame_buf = NULL;
MppBuffer bitstream_buf = NULL;
MppBuffer bitstream_buf = NULL;
H264dHalCtx_t *p_hal = (H264dHalCtx_t *)hal;
DXVA_PicParams_H264_MVC *pp = p_hal->pp;
H264dRkvRegs_t *p_regs = (H264dRkvRegs_t *)p_hal->regs;
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
memset(p_regs, 0, sizeof(H264dRkvRegs_t));
p_regs->swreg2_sysctrl.sw_dec_mode = 1; //!< h264
p_regs->swreg2_sysctrl.sw_dec_mode = 1; //!< h264
if (p_regs->swreg2_sysctrl.sw_rlc_mode == 1) {
p_regs->swreg5_stream_rlc_len.sw_stream_len = 0;
} else {
p_regs->swreg5_stream_rlc_len.sw_stream_len = (RK_U32)mpp_packet_get_length(task->dec.input_packet);
}
//!< caculate the yuv_frame_size
{
MppFrame cur_frame = NULL;
RK_U32 hor_virstride = 0;
RK_U32 ver_virstride = 0;
RK_U32 y_virstride = 0;
RK_U32 yuv_virstride = 0;
if (p_regs->swreg2_sysctrl.sw_rlc_mode == 1) {
p_regs->swreg5_stream_rlc_len.sw_stream_len = 0;
} else {
p_regs->swreg5_stream_rlc_len.sw_stream_len = (RK_U32)mpp_packet_get_length(task->dec.input_packet);
}
//!< caculate the yuv_frame_size
{
MppFrame cur_frame = NULL;
RK_U32 hor_virstride = 0;
RK_U32 ver_virstride = 0;
RK_U32 y_virstride = 0;
RK_U32 yuv_virstride = 0;
mpp_buf_slot_get_prop(p_hal->frame_slots, pp->CurrPic.Index7Bits, SLOT_FRAME_PTR, &cur_frame);
hor_virstride = mpp_frame_get_hor_stride(cur_frame);
ver_virstride = mpp_frame_get_ver_stride(cur_frame);
y_virstride = hor_virstride * ver_virstride;
mpp_buf_slot_get_prop(p_hal->frame_slots, pp->CurrPic.Index7Bits, SLOT_FRAME_PTR, &cur_frame);
hor_virstride = mpp_frame_get_hor_stride(cur_frame);
ver_virstride = mpp_frame_get_ver_stride(cur_frame);
y_virstride = hor_virstride * ver_virstride;
if (pp->chroma_format_idc == 0) { //!< Y400
yuv_virstride = y_virstride;
} else if (pp->chroma_format_idc == 1) { //!< Y420
yuv_virstride += y_virstride + y_virstride / 2;
} else if (pp->chroma_format_idc == 2) { //!< Y422
yuv_virstride += 2 * y_virstride;
}
p_regs->swreg3_picpar.sw_y_hor_virstride = hor_virstride/16;
p_regs->swreg3_picpar.sw_uv_hor_virstride = hor_virstride/16;
p_regs->swreg8_y_virstride.sw_y_virstride = y_virstride/16;
p_regs->swreg9_yuv_virstride.sw_yuv_virstride = yuv_virstride/16;
//mpp_log("$$$$$$$$ hor_stride=%d, y_stride=%d, yuv_stride=%d \n", p_regs->swreg3_picpar.sw_y_hor_virstride,
// p_regs->swreg8_y_virstride.sw_y_virstride, p_regs->swreg9_yuv_virstride.sw_yuv_virstride);
}
//!< caculate mv_size
{
RK_U32 mb_width = 0, mb_height = 0, mv_size = 0;
mb_width = pp->wFrameWidthInMbsMinus1 + 1;
mb_height = (2 - pp->frame_mbs_only_flag) * (pp->wFrameHeightInMbsMinus1 + 1);
mv_size = mb_width * mb_height * 8; // 64bit per 4x4
p_regs->compare_len = (p_regs->swreg9_yuv_virstride.sw_yuv_virstride + mv_size) * 2;
}
if (pp->chroma_format_idc == 0) { //!< Y400
yuv_virstride = y_virstride;
} else if (pp->chroma_format_idc == 1) { //!< Y420
yuv_virstride += y_virstride + y_virstride / 2;
} else if (pp->chroma_format_idc == 2) { //!< Y422
yuv_virstride += 2 * y_virstride;
}
p_regs->swreg3_picpar.sw_y_hor_virstride = hor_virstride / 16;
p_regs->swreg3_picpar.sw_uv_hor_virstride = hor_virstride / 16;
p_regs->swreg8_y_virstride.sw_y_virstride = y_virstride / 16;
p_regs->swreg9_yuv_virstride.sw_yuv_virstride = yuv_virstride / 16;
//mpp_log("$$$$$$$$ hor_stride=%d, y_stride=%d, yuv_stride=%d \n", p_regs->swreg3_picpar.sw_y_hor_virstride,
// p_regs->swreg8_y_virstride.sw_y_virstride, p_regs->swreg9_yuv_virstride.sw_yuv_virstride);
}
//!< caculate mv_size
{
RK_U32 mb_width = 0, mb_height = 0, mv_size = 0;
mb_width = pp->wFrameWidthInMbsMinus1 + 1;
mb_height = (2 - pp->frame_mbs_only_flag) * (pp->wFrameHeightInMbsMinus1 + 1);
mv_size = mb_width * mb_height * 8; // 64bit per 4x4
p_regs->compare_len = (p_regs->swreg9_yuv_virstride.sw_yuv_virstride + mv_size) * 2;
}
if (p_regs->swreg2_sysctrl.sw_h264_rps_mode) { // rps_mode == 1
p_regs->swreg43_rps_base.sw_rps_base += 0x8;
@@ -425,10 +425,10 @@ void rkv_generate_regs(void *hal, HalTaskInfo *task, FifoCtx_t *pkt)
mpp_buf_slot_get_prop(p_hal->frame_slots, pp->CurrPic.Index7Bits, SLOT_BUFFER, &frame_buf); //!< current out phy addr
#if FPGA_TEST
p_regs->swreg7_decout_base.sw_decout_base = pp->CurrPic.Index7Bits + 1;
p_regs->swreg7_decout_base.sw_decout_base = pp->CurrPic.Index7Bits + 1;
#else
p_regs->swreg7_decout_base.sw_decout_base = mpp_buffer_get_fd(frame_buf);
//mpp_log_f("line=%d, decout_fd=%d over \n", __LINE__, mpp_buffer_get_fd(frame_buf));
//mpp_log_f("line=%d, decout_fd=%d over \n", __LINE__, mpp_buffer_get_fd(frame_buf));
#endif
//!< set reference
@@ -445,9 +445,9 @@ void rkv_generate_regs(void *hal, HalTaskInfo *task, FifoCtx_t *pkt)
} else {
mpp_buf_slot_get_prop(p_hal->frame_slots, pp->RefFrameList[i].Index7Bits, SLOT_BUFFER, &frame_buf); //!< reference phy addr
}
//mpp_log_f("line=%d, ref[%d]=%d over \n", __LINE__, i, mpp_buffer_get_fd(frame_buf));
//mpp_log_f("line=%d, ref[%d]=%d over \n", __LINE__, i, mpp_buffer_get_fd(frame_buf));
#if FPGA_TEST
p_regs->swreg10_24_refer0_14_base[i].sw_refer_base = pp->RefFrameList[i].Index7Bits + 1;
p_regs->swreg10_24_refer0_14_base[i].sw_refer_base = pp->RefFrameList[i].Index7Bits + 1;
#else
p_regs->swreg10_24_refer0_14_base[i].sw_refer_base = mpp_buffer_get_fd(frame_buf);
#endif
@@ -466,28 +466,28 @@ void rkv_generate_regs(void *hal, HalTaskInfo *task, FifoCtx_t *pkt)
#if FPGA_TEST
p_regs->swreg48_refer15_base.sw_refer_base = pp->RefFrameList[15].Index7Bits + 1;
p_regs->swreg4_strm_rlc_base.sw_strm_rlc_base = 0;
p_regs->swreg6_cabactbl_prob_base.sw_cabactbl_base = 0;
p_regs->swreg4_strm_rlc_base.sw_strm_rlc_base = 0;
p_regs->swreg6_cabactbl_prob_base.sw_cabactbl_base = 0;
#else
p_regs->swreg48_refer15_base.sw_refer_base = mpp_buffer_get_fd(frame_buf);
//mpp_log_f("line=%d, ref[%d]=%d over \n", __LINE__, 15, mpp_buffer_get_fd(frame_buf));
p_regs->swreg6_cabactbl_prob_base.sw_cabactbl_base = mpp_buffer_get_fd(p_hal->cabac_buf);
//mpp_log_f("line=%d, cabac_table_fd=%d over \n", __LINE__, mpp_buffer_get_fd(p_hal->cabac_buf));
mpp_buf_slot_get_prop(p_hal->packet_slots, task->dec.input, SLOT_BUFFER, &bitstream_buf);
p_regs->swreg4_strm_rlc_base.sw_strm_rlc_base = mpp_buffer_get_fd(bitstream_buf);
//mpp_log_f("line=%d, rlc_base_fd=%d over \n", __LINE__,mpp_buffer_get_fd(bitstream_buf));
p_regs->swreg41_rlcwrite_base.sw_rlcwrite_base = p_regs->swreg4_strm_rlc_base.sw_strm_rlc_base;
//mpp_log_f("line=%d, ref[%d]=%d over \n", __LINE__, 15, mpp_buffer_get_fd(frame_buf));
p_regs->swreg6_cabactbl_prob_base.sw_cabactbl_base = mpp_buffer_get_fd(p_hal->cabac_buf);
//mpp_log_f("line=%d, cabac_table_fd=%d over \n", __LINE__, mpp_buffer_get_fd(p_hal->cabac_buf));
mpp_buf_slot_get_prop(p_hal->packet_slots, task->dec.input, SLOT_BUFFER, &bitstream_buf);
p_regs->swreg4_strm_rlc_base.sw_strm_rlc_base = mpp_buffer_get_fd(bitstream_buf);
//mpp_log_f("line=%d, rlc_base_fd=%d over \n", __LINE__,mpp_buffer_get_fd(bitstream_buf));
p_regs->swreg41_rlcwrite_base.sw_rlcwrite_base = p_regs->swreg4_strm_rlc_base.sw_strm_rlc_base;
#endif
//{
// RK_U32 *ptr = (RK_U32*)p_hal->regs;
// for (i = 0; i < 80; i++)
// {
// FPRINT(g_debug_file1, "register[%3d] = %08x\n", i, ptr[i]);
// }
// FPRINT(g_debug_file1, "-----frame=%d----------\n", p_hal->iDecodedNum);
//}
//{
// RK_U32 *ptr = (RK_U32*)p_hal->regs;
// for (i = 0; i < 80; i++)
// {
// FPRINT(g_debug_file1, "register[%3d] = %08x\n", i, ptr[i]);
// }
// FPRINT(g_debug_file1, "-----frame=%d----------\n", p_hal->iDecodedNum);
//}
fifo_packet_reset(pkt);
fifo_write_bytes(pkt, (void *)p_hal->regs, 80 * sizeof(RK_U32));
@@ -495,7 +495,7 @@ void rkv_generate_regs(void *hal, HalTaskInfo *task, FifoCtx_t *pkt)
fifo_flush_bits(pkt);
fifo_fwrite_data(pkt); //!< "REGH" header 32 bit
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
}
/*!

94
mpp/hal/rkdec/h264d/hal_h264d_rkv_reg.c
View File

@@ -204,7 +204,7 @@ static RK_U32 rkv_hor_align(RK_U32 val)
static RK_U32 rkv_len_align(RK_U32 val)
{
return (2 * MPP_ALIGN(val, 16));
return (2 * MPP_ALIGN(val, 16));
}
/*!
***********************************************************************
@@ -221,7 +221,7 @@ MPP_RET rkv_h264d_init(void *hal, MppHalCfg *cfg)
INP_CHECK(ret, NULL == p_hal);
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
p_hal->iDecodedNum = 0;
p_hal->iDecodedNum = 0;
MEM_CHECK(ret, p_hal->pkts = mpp_calloc_size(void, sizeof(H264dRkvPkt_t)));
//!< malloc cabac+scanlis + packets + poc_buf
cabac_size = RKV_CABAC_TAB_SIZE + RKV_SPSPPS_SIZE + RKV_RPS_SIZE + RKV_SCALING_LIST_SIZE + RKV_ERROR_INFO_SIZE;
@@ -233,7 +233,7 @@ MPP_RET rkv_h264d_init(void *hal, MppHalCfg *cfg)
mpp_slots_set_prop(p_hal->frame_slots, SLOTS_HOR_ALIGN, rkv_hor_align);
mpp_slots_set_prop(p_hal->frame_slots, SLOTS_VER_ALIGN, rkv_ver_align);
mpp_slots_set_prop(p_hal->frame_slots, SLOTS_LEN_ALIGN, rkv_len_align);
mpp_slots_set_prop(p_hal->frame_slots, SLOTS_LEN_ALIGN, rkv_len_align);
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
(void)cfg;
@@ -280,39 +280,39 @@ __FAILED:
//extern "C"
MPP_RET rkv_h264d_gen_regs(void *hal, HalTaskInfo *task)
{
RK_U32 i = 0;
RK_U32 hw_base = 0;
RK_U32 i = 0;
RK_U32 hw_base = 0;
RK_U32 strm_offset = 0;
MPP_RET ret = MPP_ERR_UNKNOW;
H264dHalCtx_t *p_hal = (H264dHalCtx_t *)hal;
H264dRkvPkt_t *pkts = (H264dRkvPkt_t *)p_hal->pkts;
H264dRkvRegs_t *p_regs = (H264dRkvRegs_t *)p_hal->regs;
H264dRkvRegs_t *p_regs = (H264dRkvRegs_t *)p_hal->regs;
INP_CHECK(ret, NULL == p_hal);
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
rkv_prepare_spspps_packet(hal, &pkts->spspps);
rkv_prepare_framerps_packet(hal, &pkts->rps);
rkv_prepare_scanlist_packet(hal, &pkts->scanlist);
rkv_prepare_spspps_packet(hal, &pkts->spspps);
rkv_prepare_framerps_packet(hal, &pkts->rps);
rkv_prepare_scanlist_packet(hal, &pkts->scanlist);
rkv_generate_regs(p_hal, task, &pkts->reg);
hw_base = mpp_buffer_get_fd(p_hal->cabac_buf);
hw_base = mpp_buffer_get_fd(p_hal->cabac_buf);
//!< copy datas
strm_offset = RKV_CABAC_TAB_SIZE;
for (i = 0; i < 256; i++) {
mpp_buffer_write(p_hal->cabac_buf, (strm_offset + 32 * i), (void *)pkts->spspps.pbuf, RKV_SPSPPS_SIZE);
}
p_regs->swreg42_pps_base.sw_pps_base = hw_base + (strm_offset<<10);
for (i = 0; i < 256; i++) {
mpp_buffer_write(p_hal->cabac_buf, (strm_offset + 32 * i), (void *)pkts->spspps.pbuf, RKV_SPSPPS_SIZE);
}
p_regs->swreg42_pps_base.sw_pps_base = hw_base + (strm_offset << 10);
strm_offset += RKV_SPSPPS_SIZE;
mpp_buffer_write(p_hal->cabac_buf, strm_offset, (void *)pkts->rps.pbuf, RKV_RPS_SIZE);
p_regs->swreg43_rps_base.sw_rps_base = hw_base + (strm_offset<<10);
p_regs->swreg43_rps_base.sw_rps_base = hw_base + (strm_offset << 10);
strm_offset += RKV_RPS_SIZE;
mpp_buffer_write(p_hal->cabac_buf, strm_offset, (void *)pkts->scanlist.pbuf, RKV_SCALING_LIST_SIZE);
strm_offset += RKV_SCALING_LIST_SIZE;
p_regs->swreg75_h264_errorinfo_base.sw_errorinfo_base = hw_base + (strm_offset<<10);
strm_offset += RKV_SCALING_LIST_SIZE;
p_regs->swreg75_h264_errorinfo_base.sw_errorinfo_base = hw_base + (strm_offset << 10);
((HalDecTask*)&task->dec)->valid = 0;
@@ -330,32 +330,32 @@ __RETURN:
//extern "C"
MPP_RET rkv_h264d_start(void *hal, HalTaskInfo *task)
{
//RK_U32 i = 0;
RK_U32 *p_regs = NULL;
//RK_U32 i = 0;
RK_U32 *p_regs = NULL;
MPP_RET ret = MPP_ERR_UNKNOW;
H264dHalCtx_t *p_hal = (H264dHalCtx_t *)hal;
INP_CHECK(ret, NULL == p_hal);
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
p_regs = (RK_U32 *)p_hal->regs;
p_regs = (RK_U32 *)p_hal->regs;
//FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_QTABLE_BASE, mpp_buffer_get_fd(p_hal->cabac_buf))); //!< cabacInit.phy_addr
//FUN_CHECK(ret = vdpu_h264d_print_regs(p_hal, p_drv));
p_regs[64] = 0;
p_regs[65] = 0;
p_regs[66] = 0;
p_regs[67] = 0x000000ff; // disable fpga reset
p_regs[44] = 0; // 0xffff_ffff, debug enable
p_regs[77] = 0; // 0xffff_dfff, debug enable
p_regs[1] = 0x00000021; // run hardware
p_regs[64] = 0;
p_regs[65] = 0;
p_regs[66] = 0;
p_regs[67] = 0x000000ff; // disable fpga reset
p_regs[44] = 0; // 0xffff_ffff, debug enable
p_regs[77] = 0; // 0xffff_dfff, debug enable
p_regs[1] = 0x00000021; // run hardware
//mpp_log("------- register input ------ \n");
//for(i=0; i<78; i++)
//{
// mpp_log("reg[%d]=%08x \n", i, p_regs[i]);
//}
//mpp_log("------- register input ------ \n");
//for(i=0; i<78; i++)
//{
// mpp_log("reg[%d]=%08x \n", i, p_regs[i]);
//}
#ifdef ANDROID
if (VPUClientSendReg(p_hal->vpu_socket, (RK_U32 *)p_regs, DEC_RKV_REGISTERS)) {
@@ -388,9 +388,9 @@ MPP_RET rkv_h264d_wait(void *hal, HalTaskInfo *task)
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
#ifdef ANDROID
RK_S32 wait_ret = -1;
RK_S32 ret_len = 0, cur_deat = 0;
VPU_CMD_TYPE ret_cmd = VPU_CMD_BUTT;
RK_S32 wait_ret = -1;
RK_S32 ret_len = 0, cur_deat = 0;
VPU_CMD_TYPE ret_cmd = VPU_CMD_BUTT;
static struct timeval tv1, tv2;
gettimeofday(&tv1, NULL);
wait_ret = VPUClientWaitResult(p_hal->vpu_socket, (RK_U32 *)p_hal->regs, DEC_RKV_REGISTERS, &ret_cmd, &ret_len);
@@ -398,21 +398,21 @@ MPP_RET rkv_h264d_wait(void *hal, HalTaskInfo *task)
cur_deat = (tv2.tv_sec - tv1.tv_sec) * 1000 + (tv2.tv_usec - tv1.tv_usec) / 1000;
p_hal->total_time += cur_deat;
//mpp_log("H264 RKV FlushRegs success, dec_no=%lld, time=%d ms, av_time=%lld ms. \n",
// p_hal->iDecodedNum, cur_deat, p_hal->total_time/(p_hal->iDecodedNum + 1));
//mpp_log("H264 RKV FlushRegs success, dec_no=%lld, time=%d ms, av_time=%lld ms. \n",
// p_hal->iDecodedNum, cur_deat, p_hal->total_time/(p_hal->iDecodedNum + 1));
p_hal->iDecodedNum++;
(void)wait_ret;
(void)wait_ret;
#endif
//mpp_log("------- register output ------ \n");
//RK_U32 i = 0;
//RK_U32 *ptr = NULL;
//ptr = (RK_U32 *)p_hal->regs;
//for(i=0; i<78; i++)
//{
// mpp_log("reg[%d]=%08x \n", i, ptr[i]);
//}
p_regs = (H264dRkvRegs_t *)p_hal->regs;
//mpp_log("------- register output ------ \n");
//RK_U32 i = 0;
//RK_U32 *ptr = NULL;
//ptr = (RK_U32 *)p_hal->regs;
//for(i=0; i<78; i++)
//{
// mpp_log("reg[%d]=%08x \n", i, ptr[i]);
//}
p_regs = (H264dRkvRegs_t *)p_hal->regs;
memset(&p_regs->swreg1_int, 0, sizeof(RK_U32));
FunctionOut(p_hal->logctx.parr[RUN_HAL]);

8
mpp/hal/rkdec/h264d/hal_h264d_rkv_reg.h
View File

@@ -107,7 +107,7 @@ typedef struct h264d_rkv_regs_t {
RK_U32 sw_yuv_virstride : 21;
} swreg9_yuv_virstride;
struct {
RK_U32 sw_refer_base : 10;
RK_U32 sw_refer_base : 10;
RK_U32 sw_ref_field : 1;
RK_U32 sw_ref_topfield_used : 1;
RK_U32 sw_ref_botfield_used : 1;
@@ -148,7 +148,7 @@ typedef struct h264d_rkv_regs_t {
RK_U32 sw_saowr_yoffset : 10;
} swreg47_sao_ctu_position;
struct {
RK_U32 sw_refer_base : 10;
RK_U32 sw_refer_base : 10;
RK_U32 sw_ref_field : 1;
RK_U32 sw_ref_topfield_used : 1;
RK_U32 sw_ref_botfield_used : 1;
@@ -199,7 +199,7 @@ typedef struct h264d_rkv_regs_t {
struct {
//RK_U32 reserve : 4;
//RK_U32 sw_errorinfo_base : 28;
RK_U32 sw_errorinfo_base : 32;
RK_U32 sw_errorinfo_base : 32;
} swreg75_h264_errorinfo_base;
struct {
RK_U32 sw_slicedec_num : 14;
@@ -212,7 +212,7 @@ typedef struct h264d_rkv_regs_t {
RK_U32 reserve : 2;
} swreg77_h264_error_e;
RK_U32 compare_len;
RK_U32 reverse[100];
RK_U32 reverse[100];
} H264dRkvRegs_t;

140
mpp/hal/rkdec/h264d/hal_h264d_vdpu_pkt.c
View File

@@ -237,7 +237,7 @@ const HalRegDrv_t g_vdpu_drv[VDPU_MAX_SIZE + 1] = {
{ VDPU_DEC_OUT_DIS , 3 , 1, 15, "sw03_dec_out_dis " },
{ VDPU_FILTERING_DIS , 3 , 1, 14, "sw03_filtering_dis " },
{ VDPU_PIC_FIXED_QUANT , 3 , 1, 13, "sw03_pic_fixed_quant " },
{ VDPU_MVC_E , 3 , 1, 13, "sw03_mvc_e " },
{ VDPU_MVC_E , 3 , 1, 13, "sw03_mvc_e " },
{ VDPU_WRITE_MVS_E , 3 , 1, 12, "sw03_write_mvs_e " },
{ VDPU_REFTOPFIRST_E , 3 , 1, 11, "sw03_reftopfirst_e " },
{ VDPU_SEQ_MBAFF_E , 3 , 1, 10, "sw03_seq_mbaff_e " },
@@ -1062,10 +1062,10 @@ MPP_RET vdpu_set_vlc_regs(void *hal, HalRegDrvCtx_t *p_drv)
FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_REFER_VALID_E, validFlags << 16));
//FPRINT(g_debug_file0, "ref_valid_e=%08x, longterm=%08x, mvc_e=%d, cur_poc=%d \n",
// validFlags << 16, longTermflags << 16, 0, p_hal->pp->CurrFieldOrderCnt[0]);
//FPRINT(g_debug_file0, "ref_valid_e=%08x, longterm=%08x, mvc_e=%d, cur_poc=%d \n",
// validFlags << 16, longTermflags << 16, 0, p_hal->pp->CurrFieldOrderCnt[0]);
//FPRINT(g_debug_file0, "--------- [FLUSH_CNT] flush framecnt=%d -------- \n", p_hal->iDecodedNum++);
//FPRINT(g_debug_file0, "--------- [FLUSH_CNT] flush framecnt=%d -------- \n", p_hal->iDecodedNum++);
}
@@ -1100,28 +1100,28 @@ MPP_RET vdpu_set_vlc_regs(void *hal, HalRegDrvCtx_t *p_drv)
}
#if 0
//pocBase = (RK_U32 *) ((RK_U8 *)mpp_buffer_get_ptr(p_hal->cabac_buf) + VDPU_CABAC_TAB_SIZE);
//for (i = 0; i < VDPU_POC_BUF_SIZE / 4; i++)
//{
// FPRINT(g_debug_file1, "i=%d, poc_value=%d, idx=%d \n", i, *pocBase++, p_hal->pp->RefFrameList[i / 2].Index7Bits);
//}
//pocBase = (RK_U32 *) ((RK_U8 *)mpp_buffer_get_ptr(p_hal->cabac_buf) + VDPU_CABAC_TAB_SIZE);
//for (i = 0; i < VDPU_POC_BUF_SIZE / 4; i++)
//{
// FPRINT(g_debug_file1, "i=%d, poc_value=%d, idx=%d \n", i, *pocBase++, p_hal->pp->RefFrameList[i / 2].Index7Bits);
//}
//FPRINT(g_debug_file0, "------ g_framecnt=%d \n", p_hal->in_task->g_framecnt);
pocBase = (RK_U32 *) ((RK_U8 *)mpp_buffer_get_ptr(p_hal->cabac_buf) + VDPU_CABAC_TAB_SIZE);
for(i = 0; i < 16; i++) {
RK_S32 dpb_idx = 0, longTermTmp = 0;
if (p_hal->pp->RefFrameList[i / 2].bPicEntry != 0xff) {
FPRINT(g_debug_file1, "i=%2d, picnum=%d, framenum=%2d,", i, p_hal->pp->FrameNumList[i], p_hal->pp->FrameNumList[i]);
longTermTmp = p_hal->pp->RefFrameList[i].AssociatedFlag;
dpb_idx = p_hal->pp->RefFrameList[i / 2].Index7Bits;
FPRINT(g_debug_file1, " dbp_idx=%d, longterm=%d, poc=%d \n", dpb_idx, longTermTmp, *pocBase);
}
pocBase +=2;
}
hal_get_regdrv((HalRegDrvCtx_t *)p_hal->regs, VDPU_REFER_VALID_E, &validFlags);
FPRINT(g_debug_file1, " view=%d, nonivref=%d, iv_base=%08x, ref_valid_e=%d, mvc_e=%d, cur_poc=%d \n", 0, 0, 0x0, validFlags, 0, *pocBase);
FPRINT(g_debug_file1, "--------- [FLUSH_CNT] flush framecnt=%d --------\n", p_hal->iDecodedNum);
pocBase = (RK_U32 *) ((RK_U8 *)mpp_buffer_get_ptr(p_hal->cabac_buf) + VDPU_CABAC_TAB_SIZE);
for (i = 0; i < 16; i++) {
RK_S32 dpb_idx = 0, longTermTmp = 0;
if (p_hal->pp->RefFrameList[i / 2].bPicEntry != 0xff) {
FPRINT(g_debug_file1, "i=%2d, picnum=%d, framenum=%2d,", i, p_hal->pp->FrameNumList[i], p_hal->pp->FrameNumList[i]);
longTermTmp = p_hal->pp->RefFrameList[i].AssociatedFlag;
dpb_idx = p_hal->pp->RefFrameList[i / 2].Index7Bits;
FPRINT(g_debug_file1, " dbp_idx=%d, longterm=%d, poc=%d \n", dpb_idx, longTermTmp, *pocBase);
}
pocBase += 2;
}
hal_get_regdrv((HalRegDrvCtx_t *)p_hal->regs, VDPU_REFER_VALID_E, &validFlags);
FPRINT(g_debug_file1, " view=%d, nonivref=%d, iv_base=%08x, ref_valid_e=%d, mvc_e=%d, cur_poc=%d \n", 0, 0, 0x0, validFlags, 0, *pocBase);
FPRINT(g_debug_file1, "--------- [FLUSH_CNT] flush framecnt=%d --------\n", p_hal->iDecodedNum);
@@ -1228,14 +1228,14 @@ MPP_RET vdpu_set_asic_regs(void *hal, HalRegDrvCtx_t *p_drv)
/* reference picture physis address */
for (i = 0, j = 0xff; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) {
if (pp->RefFrameList[i].bPicEntry != 0xff) {
mpp_buf_slot_get_prop(p_hal->frame_slots, pp->RefFrameList[i].Index7Bits, SLOT_BUFFER, &frame_buf); //!< reference phy addr
j = i;
} else/* if(j == 0xff)*/ {
mpp_buf_slot_get_prop(p_hal->frame_slots, pp->CurrPic.Index7Bits, SLOT_BUFFER, &frame_buf); //!< current out phy addr
}
//else {
// mpp_buf_slot_get_prop(p_hal->frame_slots, j, SLOT_BUFFER, &frame_buf); //!< current out phy addr
//}
mpp_buf_slot_get_prop(p_hal->frame_slots, pp->RefFrameList[i].Index7Bits, SLOT_BUFFER, &frame_buf); //!< reference phy addr
j = i;
} else { /* if(j == 0xff)*/
mpp_buf_slot_get_prop(p_hal->frame_slots, pp->CurrPic.Index7Bits, SLOT_BUFFER, &frame_buf); //!< current out phy addr
}
//else {
// mpp_buf_slot_get_prop(p_hal->frame_slots, j, SLOT_BUFFER, &frame_buf); //!< current out phy addr
//}
FUN_CHECK(ret = hal_set_regdrv(p_drv, g_refBase[i], mpp_buffer_get_fd(frame_buf)));
}
@@ -1290,49 +1290,49 @@ MPP_RET vdpu_set_asic_regs(void *hal, HalRegDrvCtx_t *p_drv)
FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_TYPE1_QUANT_E, pp->scaleing_list_enable_flag));
if (p_hal->pp->scaleing_list_enable_flag) {
RK_U32 temp = 0;
RK_U32 *ptr = NULL;
RK_U32 temp = 0;
RK_U32 *ptr = NULL;
ptr = (RK_U32 *)((RK_U8 *)mpp_buffer_get_ptr(p_hal->cabac_buf) + VDPU_CABAC_TAB_SIZE + VDPU_POC_BUF_SIZE);
for(i = 0; i < 6; i++) {
for(j = 0; j < 4; j++) {
temp = (p_hal->qm->bScalingLists4x4[i][4 * j + 0] << 24) |
(p_hal->qm->bScalingLists4x4[i][4 * j + 1] << 16) |
(p_hal->qm->bScalingLists4x4[i][4 * j + 2] << 8) |
(p_hal->qm->bScalingLists4x4[i][4 * j + 3]);
*ptr++ = temp;
}
}
for(i = 0; i < 2; i++) {
for(j = 0; j < 16; j++) {
temp = (p_hal->qm->bScalingLists8x8[i][4 * j + 0] << 24) |
(p_hal->qm->bScalingLists8x8[i][4 * j + 1] << 16) |
(p_hal->qm->bScalingLists8x8[i][4 * j + 2] << 8) |
(p_hal->qm->bScalingLists8x8[i][4 * j + 3]);
*ptr++ = temp;
}
}
}
for (i = 0; i < 6; i++) {
for (j = 0; j < 4; j++) {
temp = (p_hal->qm->bScalingLists4x4[i][4 * j + 0] << 24) |
(p_hal->qm->bScalingLists4x4[i][4 * j + 1] << 16) |
(p_hal->qm->bScalingLists4x4[i][4 * j + 2] << 8) |
(p_hal->qm->bScalingLists4x4[i][4 * j + 3]);
*ptr++ = temp;
}
}
for (i = 0; i < 2; i++) {
for (j = 0; j < 16; j++) {
temp = (p_hal->qm->bScalingLists8x8[i][4 * j + 0] << 24) |
(p_hal->qm->bScalingLists8x8[i][4 * j + 1] << 16) |
(p_hal->qm->bScalingLists8x8[i][4 * j + 2] << 8) |
(p_hal->qm->bScalingLists8x8[i][4 * j + 3]);
*ptr++ = temp;
}
}
}
#if 0
{
RK_U8 i = 0, j = 0;
RK_U8 *ptr = (RK_U8 *)mpp_buffer_get_ptr(p_hal->cabac_buf) + VDPU_CABAC_TAB_SIZE + VDPU_POC_BUF_SIZE;
for(i = 0; i < 6; i++) {
for(j = 0; j < 16; j++) {
FPRINT(g_debug_file1, "[i=%2d][j=%2d]=%d, ", i, j, *ptr);
ptr++;
}
FPRINT(g_debug_file1, "\n");
}
for(i = 6; i < 8; i++) {
for(j = 0; j < 64; j++) {
FPRINT(g_debug_file1, "[i=%2d][j=%2d]=%d, ", i, j, *ptr);
ptr++;
}
FPRINT(g_debug_file1, "\n");
}
}
{
RK_U8 i = 0, j = 0;
RK_U8 *ptr = (RK_U8 *)mpp_buffer_get_ptr(p_hal->cabac_buf) + VDPU_CABAC_TAB_SIZE + VDPU_POC_BUF_SIZE;
for (i = 0; i < 6; i++) {
for (j = 0; j < 16; j++) {
FPRINT(g_debug_file1, "[i=%2d][j=%2d]=%d, ", i, j, *ptr);
ptr++;
}
FPRINT(g_debug_file1, "\n");
}
for (i = 6; i < 8; i++) {
for (j = 0; j < 64; j++) {
FPRINT(g_debug_file1, "[i=%2d][j=%2d]=%d, ", i, j, *ptr);
ptr++;
}
FPRINT(g_debug_file1, "\n");
}
}
#endif
FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_DEC_OUT_DIS, 0)); //!< set defalut 0

285
mpp/hal/rkdec/h264d/hal_h264d_vdpu_reg.c
View File

@@ -37,10 +37,10 @@
static void print_single_regs(HalRegDrvCtx_t *p_drv, const HalRegDrv_t *pcur)
{
RK_S32 val = 0;
hal_get_regdrv(p_drv, pcur->syn_id, (RK_U32 *)&val);
LogInfo((LogCtx_t *)p_drv->log, "name=[%24s], reg=[%.2d], bit=[%.2d], len=[%.2d], val=[%8d]",
pcur->name, pcur->reg_id, pcur->bitpos, pcur->bitlen, val);
RK_S32 val = 0;
hal_get_regdrv(p_drv, pcur->syn_id, (RK_U32 *)&val);
LogInfo((LogCtx_t *)p_drv->log, "name=[%24s], reg=[%.2d], bit=[%.2d], len=[%.2d], val=[%8d]",
pcur->name, pcur->reg_id, pcur->bitpos, pcur->bitlen, val);
}
@@ -57,8 +57,8 @@ static MPP_RET vdpu_h264d_print_regs(H264dHalCtx_t *p_hal, HalRegDrvCtx_t *p_drv
logctx = (LogCtx_t *)p_drv->log;
if (LogEnable(logctx, LOG_LEVEL_INFO)) {
#if 1
if (g_print_init_value) {
g_print_init_value = 0;
if (g_print_init_value) {
g_print_init_value = 0;
LogInfo((LogCtx_t *)p_drv->log, "---------------- VDPU REG START ------------------ ");
//!< ---------------- init register -------------
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DEC_MODE ]);
@@ -97,91 +97,91 @@ static MPP_RET vdpu_h264d_print_regs(H264dHalCtx_t *p_hal, HalRegDrvCtx_t *p_drv
#endif
#if 1
{
LogInfo(logctx, "[SET_REG] g_framecnt=%d, ---- DECODE BEING -------", p_hal->iDecodedNum);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DEC_OUT_DIS ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_RLC_MODE_E ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_INIT_QP ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_REFIDX0_ACTIVE ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_REF_FRAMES ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_FRAMENUM_LEN ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_FRAMENUM ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_CONST_INTRA_E ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_FILT_CTRL_PRES ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_RDPIC_CNT_PRES ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_REFPIC_MK_LEN ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_IDR_PIC_E ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_IDR_PIC_ID ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_PPS_ID ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_POC_LENGTH ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_REFER_LTERM_E ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_REFER_VALID_E ]);
for (i = 0; i < 16; i++) {
if (p_hal->pp->RefFrameList[i].bPicEntry != 0xff) { //!< valid
print_single_regs(p_drv, &p_drv->p_emt[g_refPicNum[i]]);
}
}
print_single_regs(p_drv, &p_drv->p_emt[VDPU_PICORD_COUNT_E ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_CABAC_E ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_START_CODE_E ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_STRM_START_BIT ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_RLC_VLC_BASE ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_STREAM_LEN ]);
/* P lists */
for (i = 0; i < MPP_ARRAY_ELEMS(g_refPicListP); i++) {
print_single_regs(p_drv, &p_drv->p_emt[g_refPicListP[i]]);
}
/* B lists */
for (i = 0; i < MPP_ARRAY_ELEMS(g_refPicList0); i++) {
print_single_regs(p_drv, &p_drv->p_emt[g_refPicList0[i]]);
print_single_regs(p_drv, &p_drv->p_emt[g_refPicList1[i]]);
}
/* reference based address */
for (i = 0; i < MPP_ARRAY_ELEMS(g_refBase); i++) {
print_single_regs(p_drv, &p_drv->p_emt[g_refBase[i]]);
}
/* inter-view reference picture */
if (p_hal->pp->curr_layer_id && p_hal->pp->inter_view_flag) {
{
LogInfo(logctx, "[SET_REG] g_framecnt=%d, ---- DECODE BEING -------", p_hal->iDecodedNum);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DEC_OUT_DIS ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_RLC_MODE_E ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_INIT_QP ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_REFIDX0_ACTIVE ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_REF_FRAMES ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_FRAMENUM_LEN ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_FRAMENUM ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_CONST_INTRA_E ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_FILT_CTRL_PRES ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_RDPIC_CNT_PRES ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_REFPIC_MK_LEN ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_IDR_PIC_E ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_IDR_PIC_ID ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_PPS_ID ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_POC_LENGTH ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_REFER_LTERM_E ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_REFER_VALID_E ]);
for (i = 0; i < 16; i++) {
if (p_hal->pp->RefFrameList[i].bPicEntry != 0xff) { //!< valid
print_single_regs(p_drv, &p_drv->p_emt[g_refPicNum[i]]);
}
}
print_single_regs(p_drv, &p_drv->p_emt[VDPU_PICORD_COUNT_E ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_CABAC_E ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_START_CODE_E ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_STRM_START_BIT ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_RLC_VLC_BASE ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_STREAM_LEN ]);
/* P lists */
for (i = 0; i < MPP_ARRAY_ELEMS(g_refPicListP); i++) {
print_single_regs(p_drv, &p_drv->p_emt[g_refPicListP[i]]);
}
/* B lists */
for (i = 0; i < MPP_ARRAY_ELEMS(g_refPicList0); i++) {
print_single_regs(p_drv, &p_drv->p_emt[g_refPicList0[i]]);
print_single_regs(p_drv, &p_drv->p_emt[g_refPicList1[i]]);
}
/* reference based address */
for (i = 0; i < MPP_ARRAY_ELEMS(g_refBase); i++) {
print_single_regs(p_drv, &p_drv->p_emt[g_refBase[i]]);
}
/* inter-view reference picture */
if (p_hal->pp->curr_layer_id && p_hal->pp->inter_view_flag) {
print_single_regs(p_drv, &p_drv->p_emt[VDPU_INTER_VIEW_BASE]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_REFER_VALID_E]);
}
print_single_regs(p_drv, &p_drv->p_emt[VDPU_INTER_VIEW_BASE]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_REFER_VALID_E]);
}
print_single_regs(p_drv, &p_drv->p_emt[VDPU_PIC_FIXED_QUANT]); //!< VDPU_MVC_E
print_single_regs(p_drv, &p_drv->p_emt[VDPU_FILTERING_DIS]); //!< filterDisable = 0;
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DEC_OUT_BASE]); //!< outPhyAddr, pp->CurrPic.Index7Bits
print_single_regs(p_drv, &p_drv->p_emt[VDPU_PIC_FIXED_QUANT]); //!< VDPU_MVC_E
print_single_regs(p_drv, &p_drv->p_emt[VDPU_FILTERING_DIS]); //!< filterDisable = 0;
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DEC_OUT_BASE]); //!< outPhyAddr, pp->CurrPic.Index7Bits
print_single_regs(p_drv, &p_drv->p_emt[VDPU_CH_QP_OFFSET]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_CH_QP_OFFSET2]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_CH_QP_OFFSET]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_CH_QP_OFFSET2]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DIR_MV_BASE]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_WRITE_MVS_E]); //!< defalut set 1
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DIR_8X8_INFER_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_WEIGHT_PRED_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_WEIGHT_BIPR_IDC]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_REFIDX1_ACTIVE]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_FIELDPIC_FLAG_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_PIC_INTERLACE_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_PIC_FIELDMODE_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_PIC_TOPFIELD_E]); //!< bottomFieldFlag
print_single_regs(p_drv, &p_drv->p_emt[VDPU_SEQ_MBAFF_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_8X8TRANS_FLAG_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_BLACKWHITE_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_TYPE1_QUANT_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DIR_MV_BASE]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_WRITE_MVS_E]); //!< defalut set 1
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DIR_8X8_INFER_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_WEIGHT_PRED_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_WEIGHT_BIPR_IDC]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_REFIDX1_ACTIVE]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_FIELDPIC_FLAG_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_PIC_INTERLACE_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_PIC_FIELDMODE_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_PIC_TOPFIELD_E]); //!< bottomFieldFlag
print_single_regs(p_drv, &p_drv->p_emt[VDPU_SEQ_MBAFF_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_8X8TRANS_FLAG_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_BLACKWHITE_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_TYPE1_QUANT_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DEC_OUT_DIS]); //!< set defalut 0
print_single_regs(p_drv, &p_drv->p_emt[VDPU_CH_8PIX_ILEAV_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DEC_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_QTABLE_BASE]);
LogInfo((LogCtx_t *)p_drv->log, "--------- [FLUSH_CNT] flush framecnt=%d -------- \n", p_hal->iDecodedNum);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DEC_IRQ_STAT]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DEC_IRQ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DEC_PIC_INF]);
}
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DEC_OUT_DIS]); //!< set defalut 0
print_single_regs(p_drv, &p_drv->p_emt[VDPU_CH_8PIX_ILEAV_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DEC_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_QTABLE_BASE]);
LogInfo((LogCtx_t *)p_drv->log, "--------- [FLUSH_CNT] flush framecnt=%d -------- \n", p_hal->iDecodedNum);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DEC_IRQ_STAT]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DEC_IRQ]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DEC_PIC_INF]);
}
#endif
}
(void)i;
(void)p_hal;
(void)i;
(void)p_hal;
__RETURN:
return ret = MPP_OK;
}
@@ -294,7 +294,7 @@ static MPP_RET vdpu_adjust_input(H264dHalCtx_t *p_hal)
H264dVdpuDpb_t *ilt_dpb = priv->ilt_dpb;
assert(pp->curr_layer_id == 0);
assert(pp->curr_layer_id == 0);
//!< change input dxva into pdb structure
priv->new_dpb_cnt = 0;
@@ -323,7 +323,7 @@ static MPP_RET vdpu_adjust_input(H264dHalCtx_t *p_hal)
}
//!< inter-view frame flag
if (new_dpb[i].is_ilt) {
assert(0);
assert(0);
ilt_dpb[priv->ilt_dpb_cnt] = new_dpb[i];
ilt_dpb[priv->ilt_dpb_cnt].valid = 1;
priv->ilt_dpb_cnt++;
@@ -333,49 +333,48 @@ static MPP_RET vdpu_adjust_input(H264dHalCtx_t *p_hal)
}
}
}
if (p_hal->iDecodedNum == 3)
{
i = i;
}
if (p_hal->iDecodedNum == 3) {
i = i;
}
//for (i = 0; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) {
// if (new_dpb[i].valid) {
// FPRINT(g_debug_file0, "i=%2d, picnum=%d, framenum=%2d, ", i, new_dpb[i].frame_num, new_dpb[i].frame_num);
// FPRINT(g_debug_file0, " dbp_idx=%d, longterm=%d, poc=%d \n", new_dpb[i].slot_index, new_dpb[i].is_long_term,
// new_dpb[i].TOP_POC);
// }
//}
//FPRINT(g_debug_file0, "--------- [new DPB] -------- \n");
//for (i = 0; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) {
// if (old_dpb[i].valid) {
// FPRINT(g_debug_file0, "i=%2d, picnum=%d, framenum=%2d, ", i, old_dpb[i].frame_num, old_dpb[i].frame_num);
// FPRINT(g_debug_file0, " dbp_idx=%d, longterm=%d, poc=%d \n", old_dpb[i].slot_index, old_dpb[i].is_long_term,
// old_dpb[i].TOP_POC);
// }
//}
//FPRINT(g_debug_file0, "--------- [Old DPB] -------- \n");
//for (i = 0; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) {
// if (new_dpb[i].valid) {
// FPRINT(g_debug_file0, "i=%2d, picnum=%d, framenum=%2d, ", i, new_dpb[i].frame_num, new_dpb[i].frame_num);
// FPRINT(g_debug_file0, " dbp_idx=%d, longterm=%d, poc=%d \n", new_dpb[i].slot_index, new_dpb[i].is_long_term,
// new_dpb[i].TOP_POC);
// }
//}
//FPRINT(g_debug_file0, "--------- [new DPB] -------- \n");
//for (i = 0; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) {
// if (old_dpb[i].valid) {
// FPRINT(g_debug_file0, "i=%2d, picnum=%d, framenum=%2d, ", i, old_dpb[i].frame_num, old_dpb[i].frame_num);
// FPRINT(g_debug_file0, " dbp_idx=%d, longterm=%d, poc=%d \n", old_dpb[i].slot_index, old_dpb[i].is_long_term,
// old_dpb[i].TOP_POC);
// }
//}
//FPRINT(g_debug_file0, "--------- [Old DPB] -------- \n");
//!< delete old dpb
for (i = 0; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) {
find_flag = 0;
find_flag = 0;
if (old_dpb[i].valid) {
for (j = 0; j < MPP_ARRAY_ELEMS(pp->RefFrameList); j++) {
if(new_dpb[j].valid) {
find_flag = (old_dpb[i].frame_num == new_dpb[j].frame_num) ? 1 : 0;
if (new_dpb[j].top_used) {
find_flag = (old_dpb[i].TOP_POC == new_dpb[j].TOP_POC) ? find_flag : 0;
}
if (new_dpb[j].bot_used) {
find_flag = (old_dpb[i].BOT_POC == new_dpb[j].BOT_POC) ? find_flag : 0;
}
if (find_flag) { //!< found
new_dpb[j].have_same = 1;
break;
}
}
}
}
if (old_dpb[i].valid) {
for (j = 0; j < MPP_ARRAY_ELEMS(pp->RefFrameList); j++) {
if (new_dpb[j].valid) {
find_flag = (old_dpb[i].frame_num == new_dpb[j].frame_num) ? 1 : 0;
if (new_dpb[j].top_used) {
find_flag = (old_dpb[i].TOP_POC == new_dpb[j].TOP_POC) ? find_flag : 0;
}
if (new_dpb[j].bot_used) {
find_flag = (old_dpb[i].BOT_POC == new_dpb[j].BOT_POC) ? find_flag : 0;
}
if (find_flag) { //!< found
new_dpb[j].have_same = 1;
break;
}
}
}
}
//!< not found
if (find_flag == 0) {
memset(&old_dpb[i], 0, sizeof(H264dVdpuDpb_t));
@@ -383,14 +382,14 @@ static MPP_RET vdpu_adjust_input(H264dHalCtx_t *p_hal)
}
//!< add new dpb
for (j = 0; j < MPP_ARRAY_ELEMS(pp->RefFrameList); j++) {
if ((new_dpb[j].valid == 0) || new_dpb[j].have_same) {
continue;
}
if ((new_dpb[j].valid == 0) || new_dpb[j].have_same) {
continue;
}
for (i = 0; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) {
if (old_dpb[i].valid == 0) {
old_dpb[i] = new_dpb[j];
break;
}
if (old_dpb[i].valid == 0) {
old_dpb[i] = new_dpb[j];
break;
}
}
}
//!< re-fill reference dxva syntax
@@ -425,13 +424,13 @@ static MPP_RET vdpu_adjust_input(H264dHalCtx_t *p_hal)
}
}
//for (i = 0; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) {
// if (old_dpb[i].valid) {
// FPRINT(g_debug_file0, "i=%2d, picnum=%d, framenum=%2d, ", i, old_dpb[i].frame_num, old_dpb[i].frame_num);
// FPRINT(g_debug_file0, " dbp_idx=%d, longterm=%d, poc=%d \n", old_dpb[i].slot_index, old_dpb[i].is_long_term,
// old_dpb[i].TOP_POC);
// }
//}
//for (i = 0; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) {
// if (old_dpb[i].valid) {
// FPRINT(g_debug_file0, "i=%2d, picnum=%d, framenum=%2d, ", i, old_dpb[i].frame_num, old_dpb[i].frame_num);
// FPRINT(g_debug_file0, " dbp_idx=%d, longterm=%d, poc=%d \n", old_dpb[i].slot_index, old_dpb[i].is_long_term,
// old_dpb[i].TOP_POC);
// }
//}
return MPP_OK;
@@ -483,7 +482,7 @@ MPP_RET vdpu_h264d_init(void *hal, MppHalCfg *cfg)
vdpu_set_device_regs(p_drv);
mpp_slots_set_prop(p_hal->frame_slots, SLOTS_HOR_ALIGN, vdpu_hor_align);
mpp_slots_set_prop(p_hal->frame_slots, SLOTS_VER_ALIGN, vdpu_ver_align);
mpp_slots_set_prop(p_hal->frame_slots, SLOTS_LEN_ALIGN, NULL);
mpp_slots_set_prop(p_hal->frame_slots, SLOTS_LEN_ALIGN, NULL);
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
(void)cfg;
@@ -614,9 +613,9 @@ MPP_RET vdpu_h264d_wait(void *hal, HalTaskInfo *task)
INP_CHECK(ret, NULL == p_hal);
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
#ifdef ANDROID
RK_S32 wait_ret = -1;
RK_S32 ret_len = 0, cur_deat = 0;
VPU_CMD_TYPE ret_cmd = VPU_CMD_BUTT;
RK_S32 wait_ret = -1;
RK_S32 ret_len = 0, cur_deat = 0;
VPU_CMD_TYPE ret_cmd = VPU_CMD_BUTT;
static struct timeval tv1, tv2;
gettimeofday(&tv1, NULL);
wait_ret = VPUClientWaitResult(p_hal->vpu_socket, p_drv->p_reg, DEC_X170_REGISTERS, &ret_cmd, &ret_len);
@@ -624,7 +623,7 @@ MPP_RET vdpu_h264d_wait(void *hal, HalTaskInfo *task)
cur_deat = (tv2.tv_sec - tv1.tv_sec) * 1000 + (tv2.tv_usec - tv1.tv_usec) / 1000;
p_hal->total_time += cur_deat;
p_hal->iDecodedNum++;
(void)wait_ret;
(void)wait_ret;
#endif
FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_DEC_IRQ_STAT, 0));

12
mpp/hal/rkdec/h265d/hal_h265d_reg.c
View File

@@ -1167,7 +1167,7 @@ RK_S32 hal_h265d_output_pps_packet(void *hal, void *dxva)
return MPP_ERR_NOMEM;
}
memset(pps_ptr, 0, 80 * 64);
// pps_packet = (RK_U64 *)(pps_ptr + dxva_cxt->pp.pps_id * 80);
// pps_packet = (RK_U64 *)(pps_ptr + dxva_cxt->pp.pps_id * 80);
#endif
@@ -1367,8 +1367,8 @@ RK_S32 hal_h265d_output_pps_packet(void *hal, void *dxva)
}
#ifdef ANDROID
for(i = 0; i < 64; i++){
memcpy(pps_ptr+i*80,pps_packet,80);
for (i = 0; i < 64; i++) {
memcpy(pps_ptr + i * 80, pps_packet, 80);
}
#ifdef dump
fwrite(pps_ptr, 1, 80 * 64, fp);
@@ -1501,8 +1501,8 @@ MPP_RET hal_h265d_gen_regs(void *hal, HalTaskInfo *syn)
hw_regs->sw_stream_len = ((dxva_cxt->bitstream_size + 15) & (~15)) + 64;
aglin_offset = hw_regs->sw_stream_len - dxva_cxt->bitstream_size;
if(aglin_offset > 0){
memset((void *)(dxva_cxt->bitstream + dxva_cxt->bitstream_size),0,aglin_offset);
if (aglin_offset > 0) {
memset((void *)(dxva_cxt->bitstream + dxva_cxt->bitstream_size), 0, aglin_offset);
}
hw_regs->sw_interrupt.sw_dec_e = 1;
hw_regs->sw_interrupt.sw_dec_timeout_e = 1;
@@ -1565,7 +1565,7 @@ MPP_RET hal_h265d_start(void *hal, HalTaskInfo *task)
hw_regs = ( H265d_REGS_t *)reg_cxt->hw_regs;
}
if(hw_regs == NULL){
if (hw_regs == NULL) {
mpp_err("hal_h265d_start hw_regs is NULL");
return MPP_ERR_NULL_PTR;
}

39
mpp/legacy/vpu_api.cpp
View File

@@ -202,22 +202,23 @@ public:
RK_S32 (*rkvpu_close_cxt)(VpuCodecContext **ctx);
VpulibDlsym()
: rkapi_hdl(NULL),
rkvpu_open_cxt(NULL),
rkvpu_close_cxt(NULL)
rkvpu_open_cxt(NULL),
rkvpu_close_cxt(NULL)
{
RK_S32 value = !!access("/dev/rkvdec", F_OK);
if (value) {
rkapi_hdl = dlopen("/system/lib/librk_on2.so", RTLD_LAZY);
}
if (rkapi_hdl == NULL) {
rkapi_hdl = dlopen("/system/lib/librk_vpuapi.so", RTLD_LAZY);
}
rkvpu_open_cxt = (RK_S32 (*)(VpuCodecContext **ctx))dlsym(rkapi_hdl, "vpu_open_context");
rkvpu_close_cxt = (RK_S32 (*)(VpuCodecContext **ctx))dlsym(rkapi_hdl, "vpu_close_context");
mpp_log("dlopen vpu lib");
RK_S32 value = !!access("/dev/rkvdec", F_OK);
if (value) {
rkapi_hdl = dlopen("/system/lib/librk_on2.so", RTLD_LAZY);
}
if (rkapi_hdl == NULL) {
rkapi_hdl = dlopen("/system/lib/librk_vpuapi.so", RTLD_LAZY);
}
rkvpu_open_cxt = (RK_S32 (*)(VpuCodecContext **ctx))dlsym(rkapi_hdl, "vpu_open_context");
rkvpu_close_cxt = (RK_S32 (*)(VpuCodecContext **ctx))dlsym(rkapi_hdl, "vpu_close_context");
mpp_log("dlopen vpu lib");
}
~VpulibDlsym(){
~VpulibDlsym()
{
dlclose(rkapi_hdl);
mpp_log("dlclose vpu lib");
}
@@ -227,8 +228,7 @@ VpulibDlsym gVpulib;
RK_S32 open_orign_vpu(VpuCodecContext **ctx)
{
if(NULL != gVpulib.rkvpu_open_cxt)
{
if (NULL != gVpulib.rkvpu_open_cxt) {
(gVpulib.rkvpu_open_cxt)(ctx);
}
return MPP_OK;
@@ -236,8 +236,7 @@ RK_S32 open_orign_vpu(VpuCodecContext **ctx)
RK_S32 close_orign_vpu(VpuCodecContext **ctx)
{
if(NULL != gVpulib.rkvpu_close_cxt)
{
if (NULL != gVpulib.rkvpu_close_cxt) {
(gVpulib.rkvpu_close_cxt)(ctx);
}
return MPP_OK;
@@ -252,7 +251,7 @@ RK_S32 vpu_open_context(VpuCodecContext **ctx)
#ifdef ANDROID
value = value || (!!access("/dev/rkvdec", F_OK));
if(s != NULL)
if (s != NULL)
value = (value & (s->videoCoding != OMX_RK_VIDEO_CodingHEVC));
if (value || !s) {
@@ -303,7 +302,7 @@ RK_S32 vpu_open_context(VpuCodecContext **ctx)
return 0;
} else {
#ifdef ANDROID
if(s != NULL){
if (s != NULL) {
free(s);
s = NULL;
}
@@ -336,7 +335,7 @@ RK_S32 vpu_close_context(VpuCodecContext **ctx)
}
#endif
if (s) {
s->flush(s);
s->flush(s);
VpuApi* api = (VpuApi*)(s->vpuApiObj);
if (s->vpuApiObj) {
delete api;

8
mpp/legacy/vpu_api_legacy.cpp
View File

@@ -130,7 +130,7 @@ RK_S32 VpuApi:: decode_getoutframe(DecoderOut_t *aDecOut)
aDecOut->size = 0;
return 0;
}
if(set_eos){
if (set_eos) {
aDecOut->size = 0;
return VPU_API_EOS_STREAM_REACHED;
}
@@ -144,8 +144,8 @@ RK_S32 VpuApi:: decode_getoutframe(DecoderOut_t *aDecOut)
vframe->DisplayHeight = mpp_frame_get_height(mframe);
vframe->FrameWidth = mpp_frame_get_hor_stride(mframe);
vframe->FrameHeight = mpp_frame_get_ver_stride(mframe);
vframe->ErrorInfo = mpp_frame_get_errinfo(mframe);
//mpp_err("vframe->ErrorInfo = %08x \n", vframe->ErrorInfo);
vframe->ErrorInfo = mpp_frame_get_errinfo(mframe);
//mpp_err("vframe->ErrorInfo = %08x \n", vframe->ErrorInfo);
pts = mpp_frame_get_pts(mframe);
aDecOut->timeUs = pts;
//mpp_err("get one frame timeUs %lld, errinfo=%08x",aDecOut->timeUs, vframe->ErrorInfo);
@@ -195,7 +195,7 @@ RK_S32 VpuApi:: decode_getoutframe(DecoderOut_t *aDecOut)
}
if (mpp_frame_get_eos(mframe)) {
set_eos = 1;
if(buf == NULL){
if (buf == NULL) {
aDecOut->size = 0;
}
}

8
mpp/legacy/vpu_mem_legacy.c
View File

@@ -192,7 +192,7 @@ RK_S32 VPUMallocLinear(VPUMemLinear_t *p, RK_U32 size)
int ret = 0;
MppBuffer buffer = NULL;
ret = mpp_buffer_get(NULL, &buffer, size);
if(ret != MPP_OK){
if (ret != MPP_OK) {
return -1;
}
p->phy_addr = (RK_U32)mpp_buffer_get_fd(buffer);
@@ -206,11 +206,11 @@ RK_S32 VPUMallocLinearFromRender(VPUMemLinear_t *p, RK_U32 size, void *ctx)
{
VPUMemLinear_t *dma_buf = NULL;
vpu_display_mem_pool_impl *p_mempool = (vpu_display_mem_pool_impl *)ctx;
if(ctx == NULL){
return VPUMallocLinear(p,size);
if (ctx == NULL) {
return VPUMallocLinear(p, size);
}
dma_buf = (VPUMemLinear_t *)p_mempool->get_free((vpu_display_mem_pool *)ctx);
memset(p,0,sizeof(VPUMemLinear_t));
memset(p, 0, sizeof(VPUMemLinear_t));
if (dma_buf != NULL) {
if (dma_buf->size < size) {
mpp_free(dma_buf);

10
mpp/mpi.cpp
View File

@@ -65,7 +65,7 @@ static MPP_RET mpi_decode_put_packet(MppCtx ctx, MppPacket packet)
if (NULL == p || p->check != p || NULL == p->ctx || NULL == packet) {
mpp_err_f("found invalid context input ctx %p packet %p\n",
ctx, packet);
ctx, packet);
return MPP_ERR_UNKNOW;
}
@@ -82,7 +82,7 @@ static MPP_RET mpi_decode_get_frame(MppCtx ctx, MppFrame *frame)
if (NULL == p || p->check != p || NULL == p->ctx || NULL == frame) {
mpp_err_f("found invalid context input ctx %p frame %p\n",
ctx, frame);
ctx, frame);
return MPP_ERR_UNKNOW;
}
@@ -99,7 +99,7 @@ static MPP_RET mpi_encode_put_frame(MppCtx ctx, MppFrame frame)
if (NULL == p || p->check != p || NULL == p->ctx || NULL == frame) {
mpp_err_f("found invalid context input ctx %p frame %p\n",
ctx, frame);
ctx, frame);
return MPP_ERR_UNKNOW;
}
@@ -116,7 +116,7 @@ static MPP_RET mpi_encode_get_packet(MppCtx ctx, MppPacket *packet)
if (NULL == p || p->check != p || NULL == p->ctx || NULL == packet) {
mpp_err_f("found invalid context input ctx %p packet %p\n",
ctx, packet);
ctx, packet);
return MPP_ERR_UNKNOW;
}
@@ -209,7 +209,7 @@ MPP_RET mpp_init(MppCtx ctx, MppCtxType type, MppCodingType coding)
type >= MPP_CTX_BUTT ||
coding >= MPP_VIDEO_CodingMax) {
mpp_err_f("invalid input ctx %p type %d coding %d\n",
ctx, type, coding);
ctx, type, coding);
return MPP_ERR_NULL_PTR;
}

30
mpp/mpp_bitread.h
View File

@@ -80,24 +80,24 @@ typedef void (*LOG_FUN)(void *ctx, ...);
} while (0)
#define CHECK_RANGE(bitctx, val, _min, _max)\
do {\
if ((val) < (_min) || (val) > (_max)) {\
mpp_log("%d[%d,%d]", val, _min, _max);\
bitctx->ret = MPP_ERR_VALUE;\
goto __BITREAD_ERR;\
}\
} while (0)
do {\
if ((val) < (_min) || (val) > (_max)) {\
mpp_log("%d[%d,%d]", val, _min, _max);\
bitctx->ret = MPP_ERR_VALUE;\
goto __BITREAD_ERR;\
}\
} while (0)
#define CHECK_ERROR(bitctx, val)\
do {\
if (!(val)) {\
mpp_log("value false");\
bitctx->ret = MPP_ERR_VALUE;\
ASSERT(0);\
goto __BITREAD_ERR;\
}\
} while (0)
do {\
if (!(val)) {\
mpp_log("value false");\
bitctx->ret = MPP_ERR_VALUE;\
ASSERT(0);\
goto __BITREAD_ERR;\
}\
} while (0)
typedef struct bitread_ctx_t {
// Pointer to the next unread (not in curr_byte_) byte in the stream.

4
mpp/mpp_buffer.cpp
View File

@@ -152,8 +152,8 @@ int mpp_buffer_get_fd(MppBuffer buffer)
MppBufferImpl *p = (MppBufferImpl*)buffer;
int fd = p->info.fd;
#ifdef ANDROID
mpp_assert(fd >= 0);
#ifdef ANDROID
mpp_assert(fd >= 0);
#endif
return fd;

2
mpp/mpp_buffer_impl.cpp
View File

@@ -298,7 +298,7 @@ MppBufferImpl *mpp_buffer_get_unused(MppBufferGroupImpl *p, size_t size)
if (!list_empty(&p->list_unused)) {
MppBufferImpl *pos, *n;
list_for_each_entry_safe(pos, n, &p->list_unused, MppBufferImpl, list_status) {
//mpp_log("[RKV_DEBUG]pos->info.size=%d, size=%d \n", pos->info.size, size);
//mpp_log("[RKV_DEBUG]pos->info.size=%d, size=%d \n", pos->info.size, size);
if (pos->info.size >= size) {
buffer = pos;
inc_buffer_ref_no_lock(buffer);

10
mpp/mpp_frame_impl.h
View File

@@ -54,10 +54,10 @@ struct MppFrameImpl_t {
* send decoded frame belong which view
*/
RK_U32 viewid;
/*
* poc - picture order count
*/
RK_U32 poc;
/*
* poc - picture order count
*/
RK_U32 poc;
/*
* pts - display time stamp
* dts - decode time stamp
@@ -71,7 +71,7 @@ struct MppFrameImpl_t {
*/
RK_U32 eos;
RK_U32 info_change;
RK_U32 errinfo;
RK_U32 errinfo;
MppFrameColorRange color_range;
MppFrameColorPrimaries color_primaries;
MppFrameColorTransferCharacteristic color_trc;

46
mpp/test/h264d_test.c
View File

@@ -106,11 +106,11 @@ static MPP_RET decoder_init(MppDec *pApi)
hal_cfg.coding = pApi->coding;
hal_cfg.work_mode = HAL_MODE_LIBVPU;
mpp_env_get_u32("h264d_chg_org", &hal_device_id, 0);
//if (hal_device_id == 1) {
hal_cfg.device_id = HAL_RKVDEC;
//} else {
//if (hal_device_id == 1) {
hal_cfg.device_id = HAL_RKVDEC;
//} else {
// hal_cfg.device_id = HAL_VDPU;
//}
//}
hal_cfg.frame_slots = pApi->frame_slots;
hal_cfg.packet_slots = pApi->packet_slots;
hal_cfg.task_count = parser_cfg.task_count;
@@ -129,14 +129,14 @@ __FAILED:
int main(int argc, char **argv)
{
RK_U32 i = 0;
RK_U32 end_of_flag = 0;
RK_U32 end_of_flag = 0;
RK_S32 frame_slot_idx = 0;
MPP_RET ret = MPP_ERR_UNKNOW;
MppPacket pkt = NULL;
MppFrame out_frame = NULL;
RK_U32 out_yuv_flag = 0;
MppBuffer dec_pkt_buf = NULL;
MppBuffer dec_pic_buf = NULL;
MppBuffer dec_pic_buf = NULL;
MppBufferGroup mFrameGroup = NULL;
MppBufferGroup mStreamGroup = NULL;
@@ -163,9 +163,9 @@ int main(int argc, char **argv)
//if (g_debug_file0 == NULL) {
// g_debug_file0 = fopen("rk_debugfile_view0.txt", "wb");
//}
//if (g_debug_file1 == NULL) {
// g_debug_file1 = fopen("rk_debugfile_view1.txt", "wb");
//}
//if (g_debug_file1 == NULL) {
// g_debug_file1 = fopen("rk_debugfile_view1.txt", "wb");
//}
MEM_CHECK(ret, pIn && pApi && task);
mpp_log("== test start == \n");
@@ -189,15 +189,15 @@ int main(int argc, char **argv)
//!< get one packet
if (pkt == NULL) {
if (pIn->is_eof ||
(pIn->iDecFrmNum && (pIn->iFrmdecoded >= pIn->iDecFrmNum))) {
(pIn->iDecFrmNum && (pIn->iFrmdecoded >= pIn->iDecFrmNum))) {
mpp_packet_init(&pkt, NULL, 0);
mpp_packet_set_eos(pkt);
//FPRINT(g_debug_file0, "[READ_PKT]pIn->iFrmdecoded=%d, strm_pkt_len=%d, is_eof=%d \n", pIn->iFrmdecoded, 0, 1);
//FPRINT(g_debug_file0, "[READ_PKT]pIn->iFrmdecoded=%d, strm_pkt_len=%d, is_eof=%d \n", pIn->iFrmdecoded, 0, 1);
} else {
FUN_CHECK(ret = h264d_read_one_frame(pIn));
mpp_packet_init(&pkt, pIn->strm.pbuf, pIn->strm.strmbytes);
//FPRINT(g_debug_file0, "[READ_PKT]pIn->iFrmdecoded=%d, strm_pkt_len=%d, is_eof=%d \n",
//pIn->iFrmdecoded, pIn->strm.strmbytes, 0);
//FPRINT(g_debug_file0, "[READ_PKT]pIn->iFrmdecoded=%d, strm_pkt_len=%d, is_eof=%d \n",
//pIn->iFrmdecoded, pIn->strm.strmbytes, 0);
}
mpp_log("---- decoder, read_one_frame Frame_no = %d \n", pIn->iFrmdecoded++);
}
@@ -239,7 +239,7 @@ int main(int argc, char **argv)
mpp_buf_slot_get_prop(pApi->frame_slots, task->dec.output, SLOT_BUFFER, &dec_pic_buf);
if (NULL == dec_pic_buf) {
RK_U32 size = (RK_U32)mpp_buf_slot_get_size(pApi->frame_slots);
// mpp_err("run hal module, size = %d", size);
// mpp_err("run hal module, size = %d", size);
mpp_buffer_get(mFrameGroup, &dec_pic_buf, size);
if (dec_pic_buf)
mpp_buf_slot_set_prop(pApi->frame_slots, task->dec.output, SLOT_BUFFER, dec_pic_buf);
@@ -291,15 +291,15 @@ int main(int argc, char **argv)
//FPRINT(g_debug_file1, "[FLUSH] flush begin \n");
//!< flush dpb and send to display
FUN_CHECK(ret = mpp_dec_flush(pApi));
while (MPP_OK == mpp_buf_slot_dequeue(pApi->frame_slots, &frame_slot_idx, QUEUE_DISPLAY)) {
//mpp_log("get_display for index = %d", frame_slot_idx);
mpp_buf_slot_get_prop(pApi->frame_slots, frame_slot_idx, SLOT_FRAME, &out_frame);
if (out_frame) {
mpp_frame_deinit(&out_frame);
}
mpp_buf_slot_clr_flag(pApi->frame_slots, frame_slot_idx, SLOT_QUEUE_USE);
}
FUN_CHECK(ret = mpp_dec_flush(pApi));
while (MPP_OK == mpp_buf_slot_dequeue(pApi->frame_slots, &frame_slot_idx, QUEUE_DISPLAY)) {
//mpp_log("get_display for index = %d", frame_slot_idx);
mpp_buf_slot_get_prop(pApi->frame_slots, frame_slot_idx, SLOT_FRAME, &out_frame);
if (out_frame) {
mpp_frame_deinit(&out_frame);
}
mpp_buf_slot_clr_flag(pApi->frame_slots, frame_slot_idx, SLOT_QUEUE_USE);
}
//FPRINT(g_debug_file1, "+++++++ all test return +++++++ \n");
ret = MPP_OK;

16
mpp/test/vp9d_test.c
View File

@@ -37,16 +37,16 @@
//!< memory malloc check
#define MEM_CHECK(ret, val, ...)\
do{ if(!(val)) {\
ret = MPP_ERR_MALLOC;\
mpp_log("Function:%s:%d, ERROR: malloc buffer.\n", __FUNCTION__, __LINE__);\
mpp_assert(0); goto __FAILED;\
} } while (0)
do{ if(!(val)) {\
ret = MPP_ERR_MALLOC;\
mpp_log("Function:%s:%d, ERROR: malloc buffer.\n", __FUNCTION__, __LINE__);\
mpp_assert(0); goto __FAILED;\
} } while (0)
//!< function return check
#define FUN_CHECK(val)\
do{ if((val) < 0) {\
goto __FAILED;\
} } while (0)
do{ if((val) < 0) {\
goto __FAILED;\
} } while (0)
static MPP_RET vp9_decoder_deinit(MppDec *pApi)