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

[mpp_frame.h] add dispaly && viewid functions

Browse Source 
[mpp_buf_slot.cpp]   add case SLOT_FRAME_PTR, get frame_impl pointer
[mpp_dec.cpp]  add display condition
[h264_module]  update time stamp && prepare function

git-svn-id: https://10.10.10.66:8443/svn/MediaProcessPlatform/trunk/mpp@456 6e48237b-75ef-9749-8fc9-41990f28c85a
This commit is contained in:
DingWei
2015-11-16 14:22:15 +00:00
parent ca98c303f2
commit d83e77222c
21 changed files with 1027 additions and 493 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
inc/mpp_frame.h
View File

@@ -153,6 +153,10 @@ RK_U32 mpp_frame_get_ver_stride(const MppFrame frame);
void mpp_frame_set_ver_stride(MppFrame frame, RK_U32 ver_stride); void mpp_frame_set_ver_stride(MppFrame frame, RK_U32 ver_stride);
RK_U32 mpp_frame_get_mode(const MppFrame frame); RK_U32 mpp_frame_get_mode(const MppFrame frame);
void mpp_frame_set_mode(MppFrame frame, RK_U32 mode); void mpp_frame_set_mode(MppFrame frame, RK_U32 mode);
RK_U32 mpp_frame_get_display(const MppFrame frame);
void mpp_frame_set_display(MppFrame frame, RK_U32 display);
RK_U32 mpp_frame_get_viewid(const MppFrame frame);
void mpp_frame_set_viewid(MppFrame frame, RK_U32 viewid);
RK_S64 mpp_frame_get_pts(const MppFrame frame); RK_S64 mpp_frame_get_pts(const MppFrame frame);
void mpp_frame_set_pts(MppFrame frame, RK_S64 pts); void mpp_frame_set_pts(MppFrame frame, RK_S64 pts);
RK_S64 mpp_frame_get_dts(const MppFrame frame); RK_S64 mpp_frame_get_dts(const MppFrame frame);

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

@@ -348,6 +348,8 @@ static MPP_RET init_dec_ctx(H264_DecCtx_t *p_Dec)
MEM_CHECK(ret, p_Dec->mem); MEM_CHECK(ret, p_Dec->mem);
p_Dec->dpb_mark = p_Dec->mem->dpb_mark; //!< for write out, MAX_DPB_SIZE 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_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_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[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] p_Dec->refpic_info_b[1] = p_Dec->mem->refpic_info_b[1]; //!< [2][32]
@@ -355,8 +357,6 @@ static MPP_RET init_dec_ctx(H264_DecCtx_t *p_Dec)
p_Dec->mem->dxva_ctx.p_Dec = p_Dec; p_Dec->mem->dxva_ctx.p_Dec = p_Dec;
FUN_CHECK(ret = init_dxva_ctx(&p_Dec->mem->dxva_ctx)); FUN_CHECK(ret = init_dxva_ctx(&p_Dec->mem->dxva_ctx));
p_Dec->dxva_ctx = &p_Dec->mem->dxva_ctx; p_Dec->dxva_ctx = &p_Dec->mem->dxva_ctx;
//!< init frame slots, store frame buffer size
mpp_buf_slot_setup(p_Dec->frame_slots, MAX_MARK_SIZE);
//!< init Dpb_memory Mark, for fpga check //!< init Dpb_memory Mark, for fpga check
for (i = 0; i < MAX_MARK_SIZE; i++) { for (i = 0; i < MAX_MARK_SIZE; i++) {
p_Dec->dpb_mark[i].top_used = 0; p_Dec->dpb_mark[i].top_used = 0;
@@ -370,7 +370,7 @@ static MPP_RET init_dec_ctx(H264_DecCtx_t *p_Dec)
mpp_packet_init(&p_Dec->task_pkt, p_Dec->dxva_ctx->bitstream, p_Dec->dxva_ctx->max_strm_size); 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); MEM_CHECK(ret, p_Dec->task_pkt);
//!< set Dec support decoder method //!< set Dec support decoder method
p_Dec->spt_decode_mtds = MPP_DEC_BY_FRAME | MPP_DEC_BY_SLICE; p_Dec->spt_decode_mtds = MPP_DEC_BY_FRAME;
p_Dec->next_state = SliceSTATE_ResetSlice; p_Dec->next_state = SliceSTATE_ResetSlice;
p_Dec->nalu_ret = NALU_NULL; p_Dec->nalu_ret = NALU_NULL;
p_Dec->is_first_frame = 1; p_Dec->is_first_frame = 1;
@@ -384,8 +384,23 @@ __FAILED:
return ret; return ret;
} }
static void get_pkt_timestamp(H264dCurStream_t *p_strm, H264dInputCtx_t *p_Inp, MppPacket pkt)
{
H264dTimeStamp_t *p_last = NULL, *p_curr = NULL;
if (!p_Inp->in_length){
p_last = &p_strm->pkt_ts[p_strm->pkt_ts_idx];
p_strm->pkt_ts_idx = (p_strm->pkt_ts_idx + 1) % MAX_PTS_NUM ;
p_curr = &p_strm->pkt_ts[p_strm->pkt_ts_idx];
p_curr->begin_off = p_last->end_off;
p_curr->end_off = p_curr->begin_off + mpp_packet_get_length(pkt);
p_curr->pts = mpp_packet_get_pts(pkt);
p_curr->dts = mpp_packet_get_dts(pkt);
mpp_log("[init_pts] prepare_pts=%lld, g_framecnt=%d \n",p_curr->pts, p_Inp->p_Vid->g_framecnt);
}
}
/*! /*!
*********************************************************************** ***********************************************************************
@@ -473,29 +488,41 @@ MPP_RET h264d_reset(void *decoder)
RK_U32 i = 0; RK_U32 i = 0;
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder; H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
H264dCurStream_t *p_strm = NULL;
INP_CHECK(ret, !decoder); INP_CHECK(ret, !decoder);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]); FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
mpp_log_f("reset In,g_framecnt=%d ", p_Dec->p_Vid->g_framecnt); mpp_log_f("reset In,g_framecnt=%d ", p_Dec->p_Vid->g_framecnt);
//!< reset input parameter //!< reset input parameter
p_Dec->p_Inp->in_buf = NULL; p_Dec->p_Inp->in_buf = NULL;
p_Dec->p_Inp->in_size = 0; p_Dec->p_Inp->in_size = 0;
p_Dec->p_Inp->is_eos = 0; p_Dec->p_Inp->pkt_eos = 0;
p_Dec->p_Inp->pts = -1; p_Dec->p_Inp->task_eos = 0;
p_Dec->p_Inp->dts = -1; 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_buf = NULL;
p_Dec->p_Inp->out_length = 0; p_Dec->p_Inp->out_length = 0;
//!< reset video parameter //!< reset video parameter
p_Dec->p_Vid->g_framecnt = 0; p_Dec->p_Vid->g_framecnt = 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 //!< reset current stream
p_Dec->p_Cur->strm.prefixdata[0] = 0xff; p_strm = &p_Dec->p_Cur->strm;
p_Dec->p_Cur->strm.prefixdata[1] = 0xff; p_strm->prefixdata[0] = 0xff;
p_Dec->p_Cur->strm.prefixdata[2] = 0xff; p_strm->prefixdata[1] = 0xff;
p_Dec->p_Cur->strm.nalu_offset = 0; p_strm->prefixdata[2] = 0xff;
p_Dec->p_Cur->strm.nalu_len = 0; p_strm->nalu_offset = 0;
p_Dec->p_Cur->strm.head_offset = 0; p_strm->nalu_len = 0;
p_Dec->p_Cur->strm.startcode_found = 0; p_strm->head_offset = 0;
p_Dec->p_Cur->strm.endcode_found = 0; p_strm->startcode_found = 0;
p_strm->endcode_found = 0;
p_strm->pkt_ts_idx = 0;
p_strm->pkt_used_bytes = 0;
memset(p_strm->pkt_ts, 0, MAX_PTS_NUM*sizeof(H264dTimeStamp_t));
//!< reset decoder parameter //!< reset decoder parameter
p_Dec->next_state = SliceSTATE_ResetSlice; p_Dec->next_state = SliceSTATE_ResetSlice;
p_Dec->nalu_ret = NALU_NULL; p_Dec->nalu_ret = NALU_NULL;
@@ -504,9 +531,16 @@ MPP_RET h264d_reset(void *decoder)
p_Dec->is_parser_end = 0; p_Dec->is_parser_end = 0;
p_Dec->dxva_ctx->strm_offset = 0; p_Dec->dxva_ctx->strm_offset = 0;
p_Dec->dxva_ctx->slice_count = 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));
//!< reset dpb //!< reset dpb
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)); FUN_CHECK(ret = init_dpb(p_Dec->p_Vid, p_Dec->p_Vid->p_Dpb_layer[0], 1));
if (p_Dec->p_Vid->active_mvc_sps_flag) { // layer_id == 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)); 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++) { for (i = 0; i < MAX_MARK_SIZE; i++) {
@@ -539,15 +573,16 @@ MPP_RET h264d_flush(void *decoder)
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]); FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
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)); //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]); free_dpb(p_Dec->p_Vid->p_Dpb_layer[0]);
if (p_Dec->p_Vid->active_mvc_sps_flag) { // 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 = 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)); //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]); free_dpb(p_Dec->p_Vid->p_Dpb_layer[1]);
} }
mpp_buf_slot_set_prop(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, SLOT_EOS, &p_Dec->p_Inp->is_eos); 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");
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]); FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
__RETURN: __RETURN:
return ret = MPP_OK; return ret = MPP_OK;
@@ -588,28 +623,39 @@ MPP_RET h264d_prepare(void *decoder, MppPacket pkt, HalDecTask *task)
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
LogCtx_t *logctx = NULL; LogCtx_t *logctx = NULL;
H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder; H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
INP_CHECK(ret, !decoder && !pkt && !task); INP_CHECK(ret, !decoder && !pkt && !task);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]); FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
logctx = p_Dec->logctx.parr[RUN_PARSE]; logctx = p_Dec->logctx.parr[RUN_PARSE];
//LogTrace(logctx, "Prepare In:len=%d, valid=%d ", mpp_packet_get_length(pkt), task->valid); //LogTrace(logctx, "Prepare In:len=%d, valid=%d ", mpp_packet_get_length(pkt), task->valid);
p_Dec->p_Inp->in_pts = mpp_packet_get_pts(pkt);
p_Dec->p_Inp->in_dts = mpp_packet_get_dts(pkt);
//!< restore time stamp
get_pkt_timestamp(&p_Dec->p_Cur->strm, p_Dec->p_Inp, pkt);
mpp_err("[ pkt_in timeUs ] preprare input_pts=%lld \n",p_Dec->p_Inp->in_pts);
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->in_size = NULL;
} else {
p_Dec->p_Inp->in_buf = (RK_U8 *)mpp_packet_get_pos(pkt); 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->in_length = mpp_packet_get_length(pkt);
p_Dec->p_Inp->is_eos = mpp_packet_get_eos(pkt); p_Dec->p_Inp->pkt_eos = 0;
p_Dec->p_Inp->in_size = &((MppPacketImpl *)pkt)->length; p_Dec->p_Inp->in_size = &((MppPacketImpl *)pkt)->length;
p_Dec->p_Inp->pts = mpp_packet_get_pts(pkt);
p_Dec->p_Inp->dts = mpp_packet_get_dts(pkt);
task->flags.eos = p_Dec->p_Inp->is_eos;
if (p_Dec->p_Vid->g_framecnt == 1477) {
pkt = pkt;
} }
//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); 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);
do { do {
(ret = parse_prepare(p_Dec->p_Inp, p_Dec->p_Cur)); (ret = parse_prepare(p_Dec->p_Inp, p_Dec->p_Cur));
task->valid = p_Dec->p_Inp->task_valid; //!< prepare valid flag 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); 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); //LogTrace(logctx, "Prepare Out: len=%d, valid=%d ", mpp_packet_get_length(pkt), task->valid);
@@ -618,8 +664,9 @@ MPP_RET h264d_prepare(void *decoder, MppPacket pkt, HalDecTask *task)
mpp_packet_set_length(p_Dec->task_pkt, p_Dec->dxva_ctx->strm_offset); mpp_packet_set_length(p_Dec->task_pkt, p_Dec->dxva_ctx->strm_offset);
mpp_packet_set_size(p_Dec->task_pkt, p_Dec->dxva_ctx->max_strm_size); 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); 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);
FPRINT(g_debug_file0, "[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->input_packet = p_Dec->task_pkt;
task->flags.eos = p_Dec->p_Inp->pkt_eos;
} else { } else {
task->input_packet = NULL; task->input_packet = NULL;
} }
@@ -649,15 +696,17 @@ MPP_RET h264d_parse(void *decoder, HalDecTask *in_task)
in_task->valid = 0; // prepare end flag in_task->valid = 0; // prepare end flag
p_Dec->in_task = in_task; p_Dec->in_task = in_task;
mpp_packet_set_data(p_Dec->task_pkt, p_Dec->dxva_ctx->bitstream); // mpp_packet_set_data(p_Dec->task_pkt, p_Dec->dxva_ctx->bitstream);
mpp_packet_set_length(p_Dec->task_pkt, p_Dec->dxva_ctx->strm_offset); // mpp_packet_set_length(p_Dec->task_pkt, p_Dec->dxva_ctx->strm_offset);
mpp_packet_set_size(p_Dec->task_pkt, p_Dec->dxva_ctx->max_strm_size); // mpp_packet_set_size(p_Dec->task_pkt, p_Dec->dxva_ctx->max_strm_size);
// LogTrace(p_Dec->logctx.parr[RUN_PARSE], "[Parse_In] stream_len=%d, eos=%d, g_framecnt=%d",
//mpp_packet_get_length(p_Dec->task_pkt), in_task->flags.eos, p_Dec->p_Vid->g_framecnt);
//FPRINT(g_debug_file0, "[Parse_In] stream_len=%d, eos=%d, g_framecnt=%d \n",
// mpp_packet_get_length(p_Dec->task_pkt), in_task->flags.eos, p_Dec->p_Vid->g_framecnt);
LogTrace(p_Dec->logctx.parr[RUN_PARSE], "[Parse_In] stream_len=%d, eos=%d, g_framecnt=%d",
mpp_packet_get_length(p_Dec->task_pkt),
in_task->flags.eos,
p_Dec->p_Vid->g_framecnt);
FUN_CHECK(ret = parse_loop(p_Dec)); FUN_CHECK(ret = parse_loop(p_Dec));
if (p_Dec->is_parser_end) { if (p_Dec->is_parser_end) {
p_Dec->is_parser_end = 0; p_Dec->is_parser_end = 0;
//LogTrace(p_Dec->logctx.parr[RUN_PARSE], "[Prarse loop end]"); //LogTrace(p_Dec->logctx.parr[RUN_PARSE], "[Prarse loop end]");
@@ -667,7 +716,10 @@ MPP_RET h264d_parse(void *decoder, HalDecTask *in_task)
FUN_CHECK(ret = update_dpb(p_Dec)); FUN_CHECK(ret = update_dpb(p_Dec));
//LogTrace(p_Dec->logctx.parr[RUN_PARSE], "[Update dpb end]"); //LogTrace(p_Dec->logctx.parr[RUN_PARSE], "[Update dpb end]");
//mpp_log_f("[PARSE_OUT] line=%d, g_framecnt=%d",__LINE__, p_Dec->p_Vid->g_framecnt++/*in_task->g_framecnt*/); //mpp_log_f("[PARSE_OUT] line=%d, g_framecnt=%d",__LINE__, p_Dec->p_Vid->g_framecnt++/*in_task->g_framecnt*/);
LogTrace(p_Dec->logctx.parr[RUN_PARSE], "[PARSE_OUT] line=%d, g_framecnt=%d", __LINE__, p_Dec->p_Vid->g_framecnt++); //LogTrace(p_Dec->logctx.parr[RUN_PARSE], "[PARSE_OUT] line=%d, g_framecnt=%d", __LINE__, p_Dec->p_Vid->g_framecnt);
//FPRINT(g_debug_file0, "[PARSE_END] g_framecnt=%d \n", p_Dec->p_Vid->g_framecnt);
p_Dec->p_Vid->g_framecnt++;
} }
__RETURN: __RETURN:

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

@@ -22,6 +22,7 @@
#include "mpp_mem.h" #include "mpp_mem.h"
#include "mpp_common.h" #include "mpp_common.h"
#include "mpp_buf_slot.h"
#include "h264d_log.h" #include "h264d_log.h"
#include "h264d_scalist.h" #include "h264d_scalist.h"
@@ -628,7 +629,7 @@ static void free_dpb_memory_index(H264_DecCtx_t *p_Dec, H264_DpbMark_t *p, RK_S3
} else if (structure == BOTTOM_FIELD) { } else if (structure == BOTTOM_FIELD) {
p->bot_used = (p->bot_used > 0) ? (p->bot_used - 1) : 0; p->bot_used = (p->bot_used > 0) ? (p->bot_used - 1) : 0;
} }
if (p->top_used == 0 && p->bot_used == 0) { if (p->top_used == 0 && p->bot_used == 0 && (p->slot_idx != -1)) {
if (p_Dec->p_Vid->g_framecnt == 692) { if (p_Dec->p_Vid->g_framecnt == 692) {
p = p; p = p;
} }
@@ -637,11 +638,11 @@ static void free_dpb_memory_index(H264_DecCtx_t *p_Dec, H264_DpbMark_t *p, RK_S3
//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_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_OUTPUT);
//mpp_buf_slot_clr_flag(p_Dec->frame_slots, p->slot_idx, SLOT_QUEUE_USE); //mpp_buf_slot_clr_flag(p_Dec->frame_slots, p->slot_idx, SLOT_QUEUE_USE);
//FPRINT(g_debug_file0, "[FREE] g_frame_no=%d, structure=%d, mark_idx=%d, slot_idx=%d \n", p_Dec->p_Vid->g_framecnt, structure, p->mark_idx, p->slot_idx); //FPRINT(g_debug_file1, "[FREE] g_frame_no=%d, structure=%d, mark_idx=%d, slot_idx=%d \n", p_Dec->p_Vid->g_framecnt, structure, p->mark_idx, p->slot_idx);
//mpp_print_slot_flag_info(g_debug_file1, p_Dec->frame_slots, p->slot_idx); //mpp_print_slot_flag_info(g_debug_file1, p_Dec->frame_slots, p->slot_idx);
p_Dec->last_frame_slot_idx = p->slot_idx;
//p->slot_idx = -1; p->slot_idx = -1;
} }
} }
@@ -819,29 +820,31 @@ __FAILED:
static void write_picture(H264_StorePic_t *p, H264dVideoCtx_t *p_Vid) static void write_picture(H264_StorePic_t *p, H264dVideoCtx_t *p_Vid)
{ {
H264_DpbMark_t *p_mark = NULL; H264_DpbMark_t *p_mark = NULL;
MppFrame frame;
if (p->mem_malloc_type == Mem_Malloc || p->mem_malloc_type == Mem_Clone) { if (p->mem_malloc_type == Mem_Malloc /*|| p->mem_malloc_type == Mem_Clone*/) {
p_mark = p->mem_mark; p_mark = p->mem_mark;
//if (p->structure == FRAME) {
// p_mark->top_used = (p_mark->top_used > 0) ? (p_mark->top_used - 1) : 0;
// p_mark->bot_used = (p_mark->bot_used > 0) ? (p_mark->bot_used - 1) : 0;
//} else if (p->structure == TOP_FIELD) {
// p_mark->top_used = (p_mark->top_used > 0) ? (p_mark->top_used - 1) : 0;
//} else if (p->structure == BOTTOM_FIELD) {
// p_mark->bot_used = (p_mark->bot_used > 0) ? (p_mark->bot_used - 1) : 0;
//}
//}
//if (p->mem_malloc_type == Mem_Malloc) {
// if (!p_mark->top_used || !p_mark->bot_used)
// {
// ASSERT(0);
// }
//mpp_log_f(" [Write_picture] In"); //mpp_log_f(" [Write_picture] In");
mpp_buf_slot_get_prop(p_Vid->p_Dec->frame_slots, p_mark->slot_idx, SLOT_FRAME_PTR, &frame);
mpp_log("[dispaly] layer_id %d pts %lld\n", p->layer_id, mpp_frame_get_pts(frame));
mpp_frame_set_viewid(frame, p->layer_id);
//if (p->layer_id == 0) {
// mpp_frame_set_display(frame, 0);
//}
//else
{
mpp_frame_set_display(frame, 1);
}
p_Vid->p_Dec->last_frame_slot_idx = p_mark->slot_idx;
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);
mpp_buf_slot_enqueue(p_Vid->p_Dec->frame_slots, p_mark->slot_idx, QUEUE_DISPLAY); mpp_buf_slot_enqueue(p_Vid->p_Dec->frame_slots, p_mark->slot_idx, QUEUE_DISPLAY);
//FPRINT(g_debug_file1, "[WRITE_PICTURE] g_frame_no=%d, mark_idx=%d, slot_idx=%d \n", p_Vid->g_framecnt, p_mark->mark_idx, p_mark->slot_idx);
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));
//mpp_print_slot_flag_info(g_debug_file1, p_Vid->p_Dec->frame_slots, p_mark->slot_idx); //mpp_print_slot_flag_info(g_debug_file1, p_Vid->p_Dec->frame_slots, p_mark->slot_idx);
// mpp_log_f(" [Write_picture] Out"); //mpp_log_f(" [Write_picture] Out");
LogInfo(p_Vid->p_Dec->logctx.parr[RUN_PARSE], "[WRITE_PICTURE] g_frame_cnt=%d", p_Vid->g_framecnt); LogInfo(p_Vid->p_Dec->logctx.parr[RUN_PARSE], "[WRITE_PICTURE] g_frame_cnt=%d", p_Vid->g_framecnt);
} }
@@ -1735,6 +1738,112 @@ __FAILED:
return ret; return ret;
} }
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;
}
static MPP_RET adjust_input(H264_SLICE_t *currSlice)
{
RK_U32 i = 0, j = 0;
RK_U32 find_flag = 0;
H264_DpbBuf_t *p_Dpb = currSlice->p_Dpb;
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");
//!< 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;
}
/*! /*!
*********************************************************************** ***********************************************************************
* \brief * \brief
@@ -1745,14 +1854,14 @@ __FAILED:
MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice) MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
{ {
RK_U32 i = 0, j = 0; RK_U32 i = 0, j = 0;
RK_S32 slot_index = -1;
H264_DpbBuf_t *p_Dpb = currSlice->p_Dpb; H264_DpbBuf_t *p_Dpb = currSlice->p_Dpb;
H264_DecCtx_t *p_Dec = currSlice->p_Dec; H264_DecCtx_t *p_Dec = currSlice->p_Dec;
memset(p_Dec->dpb_info, 0, MAX_DPB_SIZE * sizeof(H264_DpbInfo_t)); 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) { // idr_flag==1 && layer_id==0 if (currSlice->idr_flag && !currSlice->layer_id) { // 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));
goto __RETURN; goto __RETURN;
} }
//!<---- reference //!<---- reference
@@ -1774,7 +1883,6 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
p_Dec->dpb_info[i].field_flag = p_Dpb->fs_ref[j]->frame->iCodingType == FIELD_CODING; p_Dec->dpb_info[i].field_flag = p_Dpb->fs_ref[j]->frame->iCodingType == FIELD_CODING;
p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ref[j]->frame->mem_mark->slot_idx; p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ref[j]->frame->mem_mark->slot_idx;
p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ref[j]->frame->colmv_no_used_flag ? 0 : 1); p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ref[j]->frame->colmv_no_used_flag ? 0 : 1);
slot_index = p_Dpb->fs_ref[j]->frame->mem_mark->slot_idx;
} else if (p_Dpb->fs_ref[j]->is_used) { } else if (p_Dpb->fs_ref[j]->is_used) {
if (p_Dpb->fs_ref[j]->is_used & 0x1) { // top if (p_Dpb->fs_ref[j]->is_used & 0x1) { // top
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ref[j]->top_field; p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ref[j]->top_field;
@@ -1784,7 +1892,6 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
p_Dec->dpb_info[i].field_flag = 1; p_Dec->dpb_info[i].field_flag = 1;
p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ref[j]->top_field->mem_mark->slot_idx; p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ref[j]->top_field->mem_mark->slot_idx;
p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ref[j]->top_field->colmv_no_used_flag ? 0 : 1); p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ref[j]->top_field->colmv_no_used_flag ? 0 : 1);
slot_index = p_Dpb->fs_ref[j]->top_field->mem_mark->slot_idx;
} else { // if(p_Dpb->fs_ref[j]->is_used & 0x2) // bottom } else { // if(p_Dpb->fs_ref[j]->is_used & 0x2) // bottom
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ref[j]->bottom_field; p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ref[j]->bottom_field;
p_Dec->dpb_info[i].TOP_POC = 0; p_Dec->dpb_info[i].TOP_POC = 0;
@@ -1792,7 +1899,6 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
p_Dec->dpb_info[i].field_flag = 1; p_Dec->dpb_info[i].field_flag = 1;
p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ref[j]->bottom_field->mem_mark->slot_idx; p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ref[j]->bottom_field->mem_mark->slot_idx;
p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ref[j]->bottom_field->colmv_no_used_flag ? 0 : 1); p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ref[j]->bottom_field->colmv_no_used_flag ? 0 : 1);
slot_index = p_Dpb->fs_ref[j]->bottom_field->mem_mark->slot_idx;
} }
} }
p_Dec->dpb_info[i].frame_num = p_Dpb->fs_ref[j]->frame_num; p_Dec->dpb_info[i].frame_num = p_Dpb->fs_ref[j]->frame_num;
@@ -1802,12 +1908,6 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
p_Dec->dpb_info[i].voidx = p_Dpb->fs_ref[j]->layer_id; p_Dec->dpb_info[i].voidx = p_Dpb->fs_ref[j]->layer_id;
p_Dec->dpb_info[i].view_id = p_Dpb->fs_ref[j]->view_id; p_Dec->dpb_info[i].view_id = p_Dpb->fs_ref[j]->view_id;
p_Dec->dpb_info[i].is_used = p_Dpb->fs_ref[j]->is_used; p_Dec->dpb_info[i].is_used = p_Dpb->fs_ref[j]->is_used;
//!< set frame slot
if (slot_index >= 0) {
p_Dec->in_task->refer[i] = slot_index;
mpp_buf_slot_set_flag(p_Dec->frame_slots, slot_index, SLOT_HAL_INPUT);
mpp_buf_slot_set_flag(p_Dec->frame_slots, slot_index, SLOT_CODEC_USE);
}
} }
//!<---- long term reference //!<---- long term reference
for (j = 0; j < p_Dpb->ltref_frames_in_buffer; i++, j++) { for (j = 0; j < p_Dpb->ltref_frames_in_buffer; i++, j++) {
@@ -1831,7 +1931,6 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ltref[j]->frame->mem_mark->slot_idx; p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ltref[j]->frame->mem_mark->slot_idx;
p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ltref[j]->frame->colmv_no_used_flag ? 0 : 1); p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ltref[j]->frame->colmv_no_used_flag ? 0 : 1);
p_Dec->dpb_info[i].long_term_pic_num = p_Dpb->fs_ltref[j]->frame->long_term_pic_num; p_Dec->dpb_info[i].long_term_pic_num = p_Dpb->fs_ltref[j]->frame->long_term_pic_num;
slot_index = p_Dpb->fs_ltref[j]->frame->mem_mark->slot_idx;
} else if (p_Dpb->fs_ltref[j]->is_used) { } else if (p_Dpb->fs_ltref[j]->is_used) {
if (p_Dpb->fs_ltref[j]->is_used & 0x1) { if (p_Dpb->fs_ltref[j]->is_used & 0x1) {
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ltref[j]->top_field; p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ltref[j]->top_field;
@@ -1841,7 +1940,6 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ltref[j]->top_field->mem_mark->slot_idx; p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ltref[j]->top_field->mem_mark->slot_idx;
p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ltref[j]->top_field->colmv_no_used_flag ? 0 : 1); p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ltref[j]->top_field->colmv_no_used_flag ? 0 : 1);
p_Dec->dpb_info[i].long_term_pic_num = p_Dpb->fs_ltref[j]->top_field->long_term_pic_num; p_Dec->dpb_info[i].long_term_pic_num = p_Dpb->fs_ltref[j]->top_field->long_term_pic_num;
slot_index = p_Dpb->fs_ltref[j]->top_field->mem_mark->slot_idx;
} else { // if(p_Dpb->fs_ref[j]->is_used & 0x2) } else { // if(p_Dpb->fs_ref[j]->is_used & 0x2)
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ltref[j]->bottom_field; p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ltref[j]->bottom_field;
p_Dec->dpb_info[i].TOP_POC = 0; p_Dec->dpb_info[i].TOP_POC = 0;
@@ -1850,7 +1948,6 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ltref[j]->bottom_field->mem_mark->slot_idx; p_Dec->dpb_info[i].slot_index = p_Dpb->fs_ltref[j]->bottom_field->mem_mark->slot_idx;
p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ltref[j]->bottom_field->colmv_no_used_flag ? 0 : 1); p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ltref[j]->bottom_field->colmv_no_used_flag ? 0 : 1);
p_Dec->dpb_info[i].long_term_pic_num = p_Dpb->fs_ltref[j]->bottom_field->long_term_pic_num; p_Dec->dpb_info[i].long_term_pic_num = p_Dpb->fs_ltref[j]->bottom_field->long_term_pic_num;
slot_index = p_Dpb->fs_ltref[j]->bottom_field->mem_mark->slot_idx;
} }
} }
p_Dec->dpb_info[i].frame_num = p_Dpb->fs_ltref[j]->long_term_frame_idx; //long term use long_term_frame_idx p_Dec->dpb_info[i].frame_num = p_Dpb->fs_ltref[j]->long_term_frame_idx; //long term use long_term_frame_idx
@@ -1859,13 +1956,9 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
p_Dec->dpb_info[i].voidx = p_Dpb->fs_ltref[j]->layer_id; p_Dec->dpb_info[i].voidx = p_Dpb->fs_ltref[j]->layer_id;
p_Dec->dpb_info[i].view_id = p_Dpb->fs_ltref[j]->view_id; p_Dec->dpb_info[i].view_id = p_Dpb->fs_ltref[j]->view_id;
p_Dec->dpb_info[i].is_used = p_Dpb->fs_ltref[j]->is_used; p_Dec->dpb_info[i].is_used = p_Dpb->fs_ltref[j]->is_used;
//!< set frame slot
if (slot_index >= 0) {
p_Dec->in_task->refer[i] = slot_index;
mpp_buf_slot_set_flag(p_Dec->frame_slots, slot_index, SLOT_HAL_INPUT);
mpp_buf_slot_set_flag(p_Dec->frame_slots, slot_index, SLOT_CODEC_USE);
}
} }
#if 1
//!< inter-layer reference (for multi-layered codecs) //!< inter-layer reference (for multi-layered codecs)
for (j = 0; j < p_Dpb->used_size_il; i++, j++) { for (j = 0; j < p_Dpb->used_size_il; i++, j++) {
if (currSlice->structure == FRAME && p_Dpb->fs_ilref[j]->is_used == 3) { if (currSlice->structure == FRAME && p_Dpb->fs_ilref[j]->is_used == 3) {
@@ -1883,7 +1976,6 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
p_Dec->dpb_info[i].field_flag = p_Dpb->fs_ilref[j]->frame->iCodingType == FIELD_CODING; 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].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); p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ilref[j]->frame->colmv_no_used_flag ? 0 : 1);
slot_index = p_Dpb->fs_ilref[j]->frame->mem_mark->slot_idx;
} else if (currSlice->structure != FRAME && p_Dpb->fs_ilref[j]->is_used) { } 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]->is_used == 0x3) {
if (p_Dpb->fs_ilref[j]->inter_view_flag[currSlice->structure == BOTTOM_FIELD] == 0) if (p_Dpb->fs_ilref[j]->inter_view_flag[currSlice->structure == BOTTOM_FIELD] == 0)
@@ -1903,7 +1995,6 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
p_Dec->dpb_info[i].field_flag = p_Dpb->fs_ilref[j]->frame->iCodingType == FIELD_CODING; 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].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); p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ilref[j]->frame->colmv_no_used_flag ? 0 : 1);
slot_index = p_Dpb->fs_ilref[j]->frame->mem_mark->slot_idx;
} }
if (p_Dpb->fs_ilref[j]->is_used & 0x1) { if (p_Dpb->fs_ilref[j]->is_used & 0x1) {
if (p_Dpb->fs_ilref[j]->inter_view_flag[0] == 0) if (p_Dpb->fs_ilref[j]->inter_view_flag[0] == 0)
@@ -1919,7 +2010,6 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
p_Dec->dpb_info[i].field_flag = 1; 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].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); p_Dec->dpb_info[i].colmv_is_used = (p_Dpb->fs_ilref[j]->top_field->colmv_no_used_flag ? 0 : 1);
slot_index = p_Dpb->fs_ilref[j]->top_field->mem_mark->slot_idx;
} else { // if(p_Dpb->fs_ref[j]->is_used & 0x2) } else { // if(p_Dpb->fs_ref[j]->is_used & 0x2)
if (p_Dpb->fs_ilref[j]->inter_view_flag[1] == 0) if (p_Dpb->fs_ilref[j]->inter_view_flag[1] == 0)
break; break;
@@ -1934,54 +2024,35 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
p_Dec->dpb_info[i].field_flag = 1; 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].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].colmv_is_used = (p_Dpb->fs_ilref[j]->bottom_field->colmv_no_used_flag ? 0 : 1);
slot_index = p_Dpb->fs_ilref[j]->bottom_field->mem_mark->slot_idx;
} }
} }
p_Dec->dpb_info[i].frame_num = p_Dpb->fs_ilref[j]->frame_num; 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_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].is_ilt_flag = 1;
p_Dec->dpb_info[i].long_term_pic_num = 0; 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].long_term_frame_idx = 0;
p_Dec->dpb_info[i].voidx = p_Dpb->fs_ilref[j]->layer_id; 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].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].is_used = p_Dpb->fs_ilref[j]->is_used;
//!< set frame slot
if (slot_index >= 0) {
p_Dec->in_task->refer[i] = slot_index;
mpp_buf_slot_set_flag(p_Dec->frame_slots, slot_index, SLOT_HAL_INPUT);
mpp_buf_slot_set_flag(p_Dec->frame_slots, slot_index, SLOT_CODEC_USE);
}
} }
#endif
//for(j = 0; j < i; j++) { //for(j = 0; j < i; j++) {
// FPRINT(g_debug_file0, "i=%2d, framenum=%2d,", j, p_Dec->dpb_info[j].frame_num); // 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_file0, " longterm=%d, poc=%d, voidx=%d, is_ilt=%d, layid=%d \n", p_Dec->dpb_info[j].is_long_term, // 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, p_Dec->dpb_info[j].voidx, p_Dec->dpb_info[j].is_ilt_flag, currSlice->layer_id); // p_Dec->dpb_info[j].TOP_POC);
//} //}
//FPRINT(g_debug_file0, "--------- [FLUSH_CNT] flush framecnt=%d -------- \n", p_Dec->p_Vid->g_framecnt); //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 == 20) {
i = i;
}
//!< reset left parameters //!< reset left parameters
for (; i < 16; i++) { for (; i < 16; i++) {
p_Dec->dpb_info[i].picbuf = NULL; reset_dpb_info(&p_Dec->dpb_info[i]);
p_Dec->dpb_info[i].TOP_POC = 0;
p_Dec->dpb_info[i].BOT_POC = 0;
p_Dec->dpb_info[i].field_flag = 0;
p_Dec->dpb_info[i].slot_index = -1;
p_Dec->dpb_info[i].colmv_is_used = 0;
p_Dec->dpb_info[i].frame_num = 0;
p_Dec->dpb_info[i].is_long_term = 0;
p_Dec->dpb_info[i].long_term_pic_num = 0;
p_Dec->dpb_info[i].voidx = 0;
p_Dec->dpb_info[i].view_id = 0;
p_Dec->dpb_info[i].is_used = 0;
p_Dec->in_task->refer[i] = -1;
} }
//FPRINT(g_debug_file0, "---g_framecnt=%d\n", p_Dec->p_Vid->g_framecnt); //FPRINT(g_debug_file0, "---g_framecnt=%d\n", p_Dec->p_Vid->g_framecnt);
//for (i = 0; i< 16; i++) //for (i = 0; i< 16; i++)
//{ //{
@@ -1989,6 +2060,18 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
// 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); // 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);
for (i = 0; i < MAX_DPB_SIZE; i++) {
if (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:
return MPP_OK; return MPP_OK;
} }
@@ -2009,11 +2092,9 @@ MPP_RET prepare_init_ref_info(H264_SLICE_t *currSlice)
RK_S32 layer_id = 0, voidx = 0, is_used = 0; RK_S32 layer_id = 0, voidx = 0, is_used = 0;
H264_DecCtx_t *p_Dec = currSlice->p_Dec; H264_DecCtx_t *p_Dec = currSlice->p_Dec;
//memset(p_Dec->dpb_info, 0, MAX_DPB_SIZE * sizeof(H264_DpbInfo_t));
memset(p_Dec->refpic_info_p, 0, MAX_REF_SIZE * sizeof(H264_RefPicInfo_t)); memset(p_Dec->refpic_info_p, 0, MAX_REF_SIZE * sizeof(H264_RefPicInfo_t));
memset(p_Dec->refpic_info_b[0], 0, MAX_REF_SIZE * sizeof(H264_RefPicInfo_t)); memset(p_Dec->refpic_info_b[0], 0, MAX_REF_SIZE * sizeof(H264_RefPicInfo_t));
memset(p_Dec->refpic_info_b[1], 0, MAX_REF_SIZE * sizeof(H264_RefPicInfo_t)); memset(p_Dec->refpic_info_b[1], 0, MAX_REF_SIZE * sizeof(H264_RefPicInfo_t));
//memset(&p_Dec->in_task->refer, -1, sizeof(p_Dec->in_task->refer));
if (currSlice->idr_flag && !currSlice->layer_id) { // idr_flag==1 && layer_id==0 if (currSlice->idr_flag && !currSlice->layer_id) { // idr_flag==1 && layer_id==0
goto __RETURN; goto __RETURN;

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

@@ -327,8 +327,8 @@ MPP_RET fill_slice_syntax(H264_SLICE_t *currSlice, H264dDxvaCtx_t *dxva_ctx)
for (i = 0; i < MPP_ARRAY_ELEMS(p_long->RefPicList[0]); i++) { for (i = 0; i < MPP_ARRAY_ELEMS(p_long->RefPicList[0]); i++) {
dpb_idx = currSlice->p_Dec->refpic_info_p[i].dpb_idx; dpb_idx = currSlice->p_Dec->refpic_info_p[i].dpb_idx;
//dpb_valid = currSlice->p_Dec->refpic_info_p[i].valid; dpb_valid = currSlice->p_Dec->refpic_info_p[i].valid;
dpb_valid = (currSlice->p_Dec->dpb_info[dpb_idx].picbuf ? 1 : 0); //dpb_valid = (currSlice->p_Dec->dpb_info[dpb_idx].picbuf ? 1 : 0);
if (dpb_valid) { if (dpb_valid) {
bottom_flag = currSlice->p_Dec->refpic_info_p[i].bottom_flag; bottom_flag = currSlice->p_Dec->refpic_info_p[i].bottom_flag;
fill_picture_entry(&p_long->RefPicList[0][i], dpb_idx, bottom_flag); fill_picture_entry(&p_long->RefPicList[0][i], dpb_idx, bottom_flag);
@@ -340,8 +340,8 @@ MPP_RET fill_slice_syntax(H264_SLICE_t *currSlice, H264dDxvaCtx_t *dxva_ctx)
for (list = 0; list < 2; list++) { for (list = 0; list < 2; list++) {
for (i = 0; i < MPP_ARRAY_ELEMS(p_long->RefPicList[list + 1]); i++) { for (i = 0; i < MPP_ARRAY_ELEMS(p_long->RefPicList[list + 1]); i++) {
dpb_idx = currSlice->p_Dec->refpic_info_b[list][i].dpb_idx; dpb_idx = currSlice->p_Dec->refpic_info_b[list][i].dpb_idx;
//dpb_valid = currSlice->p_Dec->refpic_info_b[list][i].valid; dpb_valid = currSlice->p_Dec->refpic_info_b[list][i].valid;
dpb_valid = (currSlice->p_Dec->dpb_info[dpb_idx].picbuf ? 1 : 0); //dpb_valid = (currSlice->p_Dec->dpb_info[dpb_idx].picbuf ? 1 : 0);
if (dpb_valid) { if (dpb_valid) {
bottom_flag = currSlice->p_Dec->refpic_info_b[list][i].bottom_flag; bottom_flag = currSlice->p_Dec->refpic_info_b[list][i].bottom_flag;
fill_picture_entry(&p_long->RefPicList[list + 1][i], dpb_idx, bottom_flag); fill_picture_entry(&p_long->RefPicList[list + 1][i], dpb_idx, bottom_flag);

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

@@ -39,12 +39,12 @@
#define MAX_MARK_SIZE 35 //!< for malloc buffer mark, can be changed #define MAX_MARK_SIZE 35 //!< for malloc buffer mark, can be changed
#define NALU_BUF_MAX_SIZE 10*1024 #define NALU_BUF_MAX_SIZE 1024
#define NALU_BUF_ADD_SIZE 1024 #define NALU_BUF_ADD_SIZE 512
#define HEAD_BUF_MAX_SIZE 10*1024*1024 #define HEAD_BUF_MAX_SIZE 10*1024
#define HEAD_BUF_ADD_SIZE 1024 #define HEAD_BUF_ADD_SIZE 512
#define SODB_BUF_MAX_SIZE 10*1024*1024 #define SODB_BUF_MAX_SIZE 10*1024
#define SODB_BUF_ADD_SIZE 1024 #define SODB_BUF_ADD_SIZE 512
//!< AVC Profile IDC definitions //!< AVC Profile IDC definitions
@@ -223,6 +223,8 @@ typedef struct h264_dpb_info_t {
RK_U32 top_valid; RK_U32 top_valid;
RK_U32 bot_valid; RK_U32 bot_valid;
struct h264_store_pic_t *picbuf; struct h264_store_pic_t *picbuf;
RK_U32 have_same;
} H264_DpbInfo_t; } H264_DpbInfo_t;
//!< refence picture information //!< refence picture information
@@ -815,9 +817,11 @@ typedef struct h264d_dxva_ctx_t {
struct h264_dec_ctx_t *p_Dec; struct h264_dec_ctx_t *p_Dec;
} H264dDxvaCtx_t; } H264dDxvaCtx_t;
//!< input parameter //!< input parameter
typedef struct h264d_input_ctx_t { typedef struct h264d_input_ctx_t {
RK_U32 is_eos;
struct h264_dec_ctx_t *p_Dec; struct h264_dec_ctx_t *p_Dec;
struct h264d_cur_ctx_t *p_Cur; //!< current parameters, use in read nalu struct h264d_cur_ctx_t *p_Cur; //!< current parameters, use in read nalu
struct h264d_video_ctx_t *p_Vid; //!< parameters for video decoder struct h264d_video_ctx_t *p_Vid; //!< parameters for video decoder
@@ -827,20 +831,33 @@ typedef struct h264d_input_ctx_t {
RK_U8 *in_buf; RK_U8 *in_buf;
size_t *in_size; size_t *in_size;
size_t in_length; size_t in_length;
RK_S64 pts; RK_U32 pkt_eos;
RK_S64 dts;
RK_S64 in_pts;
RK_S64 in_dts;
//!< output data //!< output data
RK_U8 *out_buf; RK_U8 *out_buf;
RK_U32 out_length; RK_U32 out_length;
RK_U8 task_valid; RK_U8 task_valid;
RK_U32 task_eos;
} H264dInputCtx_t; } 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;
//!< current stream //!< current stream
typedef struct h264d_curstrm_t { typedef struct h264d_curstrm_t {
RK_U32 nalu_offset; //!< The offset of the input stream RK_U32 nalu_offset; //!< The offset of the input stream
RK_U32 nalu_max_size; //!< Cur Unit Buffer size RK_U32 nalu_max_size; //!< Cur Unit Buffer size
RK_U8 *curdata; RK_U8 *curdata;
RK_S32 nal_unit_type; RK_S32 nal_unit_type;
RK_U32 nalu_len; RK_U32 nalu_len;
RK_U8 *nalu_buf; //!< store read nalu data RK_U8 *nalu_buf; //!< store read nalu data
@@ -852,6 +869,12 @@ typedef struct h264d_curstrm_t {
RK_U8 prefixdata[START_PREFIX_3BYTE]; RK_U8 prefixdata[START_PREFIX_3BYTE];
RK_U8 startcode_found; RK_U8 startcode_found;
RK_U8 endcode_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
H264dTimeStamp_t pkt_ts[MAX_PTS_NUM];
} H264dCurStream_t; } H264dCurStream_t;
//!< current parameters //!< current parameters
@@ -870,6 +893,11 @@ typedef struct h264d_cur_ctx_t {
struct h264d_input_ctx_t *p_Inp; struct h264d_input_ctx_t *p_Inp;
struct h264_dec_ctx_t *p_Dec; struct h264_dec_ctx_t *p_Dec;
struct h264d_video_ctx_t *p_Vid; //!< parameters for video decoder 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;
} H264dCurCtx_t; } H264dCurCtx_t;
//!< parameters for video decoder //!< parameters for video decoder
@@ -939,12 +967,13 @@ typedef struct h264d_video_ctx_t {
RK_S32 active_mvc_sps_flag; RK_S32 active_mvc_sps_flag;
RK_U32 g_framecnt; RK_U32 g_framecnt;
RK_U32 dpb_size[MAX_NUM_DPB_LAYERS];
} H264dVideoCtx_t; } H264dVideoCtx_t;
typedef struct h264d_mem_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_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_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 h264_refpic_info_t refpic_info_b[2][MAX_REF_SIZE]; //!< [2][32]
struct h264d_dxva_ctx_t dxva_ctx; struct h264d_dxva_ctx_t dxva_ctx;
@@ -999,6 +1028,7 @@ typedef struct h264_dec_ctx_t {
struct h264d_mem_t *mem; struct h264d_mem_t *mem;
struct h264_dpb_mark_t *dpb_mark; //!< for write out, MAX_DPB_SIZE 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_info; //!< 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_p; //!< 32
struct h264_refpic_info_t *refpic_info_b[2]; //!< [2][32] struct h264_refpic_info_t *refpic_info_b[2]; //!< [2][32]
struct h264d_dxva_ctx_t *dxva_ctx; struct h264d_dxva_ctx_t *dxva_ctx;
@@ -1012,6 +1042,7 @@ typedef struct h264_dec_ctx_t {
RK_U8 is_first_frame; RK_U8 is_first_frame;
RK_U8 is_new_frame; RK_U8 is_new_frame;
RK_U8 is_parser_end; RK_U8 is_parser_end;
RK_U8 mvc_valid;
struct h264d_logctx_t logctx; //!< debug log file struct h264d_logctx_t logctx; //!< debug log file
struct log_ctx_t logctxbuf[LOG_MAX]; struct log_ctx_t logctxbuf[LOG_MAX];

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

@@ -393,19 +393,29 @@ static void dpb_mark_malloc(H264dVideoCtx_t *p_Vid, RK_S32 structure, RK_U8 comb
ASSERT(idx <= MAX_MARK_SIZE); ASSERT(idx <= MAX_MARK_SIZE);
mpp_buf_slot_get_unused(p_Vid->p_Dec->frame_slots, &p_mark[idx].slot_idx); mpp_buf_slot_get_unused(p_Vid->p_Dec->frame_slots, &p_mark[idx].slot_idx);
cur_mark = &p_mark[idx]; cur_mark = &p_mark[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); 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);
mpp_log("[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);
mpp_frame_set_hor_stride(cur_mark->frame, p_Vid->width); // before crop mpp_frame_set_hor_stride(cur_mark->frame, p_Vid->width); // before crop
mpp_frame_set_ver_stride(cur_mark->frame, p_Vid->height); mpp_frame_set_ver_stride(cur_mark->frame, p_Vid->height);
mpp_frame_set_width(cur_mark->frame, p_Vid->width_after_crop); // 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); mpp_frame_set_height(cur_mark->frame, p_Vid->height_after_crop);
mpp_frame_set_pts(cur_mark->frame, p_Vid->p_Inp->pts);
//mpp_log("[Decpicture] width=%d, height=%d, slot_idx=%d\n", p_Vid->width, p_Vid->height, cur_mark->slot_idx); 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); 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; p_Vid->active_dpb_mark[layer_id] = cur_mark;
} }
@@ -417,6 +427,8 @@ static void dpb_mark_malloc(H264dVideoCtx_t *p_Vid, RK_S32 structure, RK_U8 comb
if (structure == FRAME || structure == BOTTOM_FIELD) { if (structure == FRAME || structure == BOTTOM_FIELD) {
cur_mark->bot_used += 1; cur_mark->bot_used += 1;
} }
p_Vid->p_Dec->in_task->output = cur_mark->slot_idx; p_Vid->p_Dec->in_task->output = cur_mark->slot_idx;
mpp_buf_slot_set_flag(p_Dec->frame_slots, cur_mark->slot_idx, SLOT_HAL_OUTPUT); mpp_buf_slot_set_flag(p_Dec->frame_slots, cur_mark->slot_idx, SLOT_HAL_OUTPUT);
} }

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

@@ -75,9 +75,9 @@ static void reset_slice(H264dVideoCtx_t *p_Vid)
static MPP_RET realloc_buffer(RK_U8 **buf, RK_U32 *max_size, RK_U32 add_size) static MPP_RET realloc_buffer(RK_U8 **buf, RK_U32 *max_size, RK_U32 add_size)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
*buf = mpp_realloc(*buf, RK_U8, *max_size + add_size); (*buf) = mpp_realloc((*buf), RK_U8, ((*max_size) + add_size));
MEM_CHECK(ret, *buf); MEM_CHECK(ret, (*buf));
*max_size += add_size; (*max_size) += add_size;
return ret = MPP_OK; return ret = MPP_OK;
__FAILED: __FAILED:
@@ -119,7 +119,6 @@ static MPP_RET read_one_nalu(H264dInputCtx_t *p_Inp, H264dCurStream_t *p_strm)
FunctionIn(logctx->parr[RUN_PARSE]); FunctionIn(logctx->parr[RUN_PARSE]);
reset_nalu(p_strm); reset_nalu(p_strm);
while (p_Inp->in_length > 0) { while (p_Inp->in_length > 0) {
p_strm->curdata = &p_Inp->in_buf[p_strm->nalu_offset++]; p_strm->curdata = &p_Inp->in_buf[p_strm->nalu_offset++];
(*p_Inp->in_size) -= 1; (*p_Inp->in_size) -= 1;
@@ -140,6 +139,7 @@ static MPP_RET read_one_nalu(H264dInputCtx_t *p_Inp, H264dCurStream_t *p_strm)
p_Dec->nalu_ret = EndOfNalu; p_Dec->nalu_ret = EndOfNalu;
break; break;
} }
p_Dec->nalu_ret = MidOfNalu;
} }
if (!p_Inp->in_length) { //!< check input if (!p_Inp->in_length) { //!< check input
p_strm->nalu_offset = 0; p_strm->nalu_offset = 0;
@@ -200,6 +200,7 @@ static MPP_RET parser_nalu_header(H264_SLICE_t *currSlice)
goto __FAILED; goto __FAILED;
} else { //!< MVC } else { //!< MVC
currSlice->mvcExt.valid = 1; currSlice->mvcExt.valid = 1;
p_Cur->p_Dec->mvc_valid = 1;
READ_ONEBIT(p_bitctx, &currSlice->mvcExt.non_idr_flag, "nalu_type"); READ_ONEBIT(p_bitctx, &currSlice->mvcExt.non_idr_flag, "nalu_type");
READ_BITS(p_bitctx, 6, &currSlice->mvcExt.priority_id, "priority_id"); READ_BITS(p_bitctx, 6, &currSlice->mvcExt.priority_id, "priority_id");
READ_BITS(p_bitctx, 10, &currSlice->mvcExt.view_id, "view_id"); READ_BITS(p_bitctx, 10, &currSlice->mvcExt.view_id, "view_id");
@@ -318,7 +319,7 @@ __FAILED:
return ret; return ret;
} }
static MPP_RET parse_nalu_header(H264dCurCtx_t *p_Cur) static MPP_RET analyze_cur_nalu(H264dCurCtx_t *p_Cur)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
RK_U32 nalu_header_bytes = 0; RK_U32 nalu_header_bytes = 0;
@@ -331,16 +332,17 @@ static MPP_RET parse_nalu_header(H264dCurCtx_t *p_Cur)
RK_U32 svc_extension_flag = -1; RK_U32 svc_extension_flag = -1;
FunctionIn(logctx->parr[RUN_PARSE]); FunctionIn(logctx->parr[RUN_PARSE]);
mpp_set_bitread_ctx(p_bitctx, p_strm->nalu_buf, p_strm->nalu_len); memset(p_bitctx, 0, sizeof(BitReadCtx_t));
mpp_set_bitread_ctx(p_bitctx, p_strm->nalu_buf, 4);
set_bitread_logctx(p_bitctx, logctx->parr[LOG_READ_NALU]); set_bitread_logctx(p_bitctx, logctx->parr[LOG_READ_NALU]);
READ_BITS(p_bitctx, 1, &forbidden_bit); READ_BITS(p_bitctx, 1, &forbidden_bit);
ASSERT(forbidden_bit == 0); ASSERT(forbidden_bit == 0);
READ_BITS(p_bitctx, 2, &nal_reference_idc); READ_BITS(p_bitctx, 2, &nal_reference_idc);
READ_BITS(p_bitctx, 5, &p_strm->nal_unit_type); READ_BITS(p_bitctx, 5, &p_strm->nal_unit_type);
if (g_nalu_cnt1 == 29) { //if (g_nalu_cnt1 == 29) {
g_nalu_cnt1 = g_nalu_cnt1; // g_nalu_cnt1 = g_nalu_cnt1;
} //}
//FPRINT(g_debug_file1, "g_nalu_cnt=%d, nal_type=%d, sodb_len=%d \n", g_nalu_cnt1++, p_strm->nal_unit_type, p_strm->nalu_len); //FPRINT(g_debug_file0, "[Analyze_NALU] g_framecnt=%d, g_nalu_cnt=%d, nal_type=%d, sodb_len=%d \n", p_Cur->p_Vid->g_framecnt, g_nalu_cnt1++, p_strm->nal_unit_type, p_strm->nalu_len);
nalu_header_bytes = 1; nalu_header_bytes = 1;
if ((p_strm->nal_unit_type == NALU_TYPE_PREFIX) || (p_strm->nal_unit_type == NALU_TYPE_SLC_EXT)) { if ((p_strm->nal_unit_type == NALU_TYPE_PREFIX) || (p_strm->nal_unit_type == NALU_TYPE_SLC_EXT)) {
@@ -359,6 +361,11 @@ static MPP_RET parse_nalu_header(H264dCurCtx_t *p_Cur)
if ( p_strm->nal_unit_type == NALU_TYPE_SLICE || p_strm->nal_unit_type == NALU_TYPE_IDR) { if ( p_strm->nal_unit_type == NALU_TYPE_SLICE || p_strm->nal_unit_type == NALU_TYPE_IDR) {
mpp_set_bitread_ctx(p_bitctx, (p_strm->nalu_buf + nalu_header_bytes), 4); // reset mpp_set_bitread_ctx(p_bitctx, (p_strm->nalu_buf + nalu_header_bytes), 4); // reset
READ_UE(p_bitctx, &first_mb_in_slice); READ_UE(p_bitctx, &first_mb_in_slice);
//if (first_mb_in_slice == 0)
{
//FPRINT(g_debug_file0, "[Analyze_NALU] first_mb_in_sile ==0 \n")
first_mb_in_slice = first_mb_in_slice;
}
if (!p_Cur->p_Dec->is_first_frame && (first_mb_in_slice == 0)) { if (!p_Cur->p_Dec->is_first_frame && (first_mb_in_slice == 0)) {
p_Cur->p_Dec->is_new_frame = 1; p_Cur->p_Dec->is_new_frame = 1;
@@ -374,13 +381,13 @@ __FAILED:
return ret; return ret;
} }
static MPP_RET add_empty_nalu(H264dCurCtx_t *p_Cur) static MPP_RET add_empty_nalu(H264dCurStream_t *p_strm)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
RK_U8 *p_des = NULL; RK_U8 *p_des = NULL;
H264dCurStream_t *p_strm = &p_Cur->strm; RK_U32 add_size = 0;
add_size = MPP_MAX(sizeof(H264dNaluHead_t), HEAD_BUF_ADD_SIZE);
if (p_strm->head_offset >= p_strm->head_max_size) { if ((p_strm->head_offset + add_size) >= p_strm->head_max_size) {
FUN_CHECK(ret = realloc_buffer(&p_strm->head_buf, &p_strm->head_max_size, HEAD_BUF_ADD_SIZE)); FUN_CHECK(ret = realloc_buffer(&p_strm->head_buf, &p_strm->head_max_size, HEAD_BUF_ADD_SIZE));
} }
@@ -389,14 +396,13 @@ static MPP_RET add_empty_nalu(H264dCurCtx_t *p_Cur)
((H264dNaluHead_t *)p_des)->is_frame_end = 1; ((H264dNaluHead_t *)p_des)->is_frame_end = 1;
((H264dNaluHead_t *)p_des)->nal_unit_type = 0; ((H264dNaluHead_t *)p_des)->nal_unit_type = 0;
((H264dNaluHead_t *)p_des)->sodb_len = 0; ((H264dNaluHead_t *)p_des)->sodb_len = 0;
p_strm->head_offset += sizeof(H264dNaluHead_t); p_strm->head_offset += add_size;
return ret = MPP_OK; return ret = MPP_OK;
__FAILED: __FAILED:
return ret; return ret;
} }
static MPP_RET store_cur_nalu(H264dCurCtx_t *p_Cur) static MPP_RET store_cur_nalu(H264dCurCtx_t *p_Cur)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
@@ -415,8 +421,8 @@ static MPP_RET store_cur_nalu(H264dCurCtx_t *p_Cur)
|| (p_strm->nal_unit_type == NALU_TYPE_SEI) || (p_strm->nal_unit_type == NALU_TYPE_SEI)
|| (p_strm->nal_unit_type == NALU_TYPE_PREFIX) || (p_strm->nal_unit_type == NALU_TYPE_PREFIX)
|| (p_strm->nal_unit_type == NALU_TYPE_SLC_EXT)) { || (p_strm->nal_unit_type == NALU_TYPE_SLC_EXT)) {
if (p_strm->head_offset >= p_strm->head_max_size) {
add_size = MPP_MAX(HEAD_BUF_ADD_SIZE, p_strm->nalu_len); add_size = MPP_MAX(HEAD_BUF_ADD_SIZE, p_strm->nalu_len);
if ((p_strm->head_offset + add_size) >= p_strm->head_max_size) {
FUN_CHECK(ret = realloc_buffer(&p_strm->head_buf, &p_strm->head_max_size, add_size)); FUN_CHECK(ret = realloc_buffer(&p_strm->head_buf, &p_strm->head_max_size, add_size));
} }
p_des = &p_strm->head_buf[p_strm->head_offset]; p_des = &p_strm->head_buf[p_strm->head_offset];
@@ -431,8 +437,8 @@ static MPP_RET store_cur_nalu(H264dCurCtx_t *p_Cur)
if ((p_strm->nal_unit_type == NALU_TYPE_SLICE) if ((p_strm->nal_unit_type == NALU_TYPE_SLICE)
|| (p_strm->nal_unit_type == NALU_TYPE_IDR)) { || (p_strm->nal_unit_type == NALU_TYPE_IDR)) {
dxva_ctx = p_Cur->p_Dec->dxva_ctx; dxva_ctx = p_Cur->p_Dec->dxva_ctx;
if (dxva_ctx->strm_offset >= dxva_ctx->max_strm_size) {
add_size = MPP_MAX(SODB_BUF_ADD_SIZE, p_strm->nalu_len); add_size = MPP_MAX(SODB_BUF_ADD_SIZE, p_strm->nalu_len);
if ((dxva_ctx->strm_offset + add_size) >= dxva_ctx->max_strm_size) {
realloc_buffer(&dxva_ctx->bitstream, &dxva_ctx->max_strm_size, add_size); realloc_buffer(&dxva_ctx->bitstream, &dxva_ctx->max_strm_size, add_size);
} }
p_des = &dxva_ctx->bitstream[dxva_ctx->strm_offset]; p_des = &dxva_ctx->bitstream[dxva_ctx->strm_offset];
@@ -448,6 +454,96 @@ __FAILED:
return ret; return ret;
} }
static void insert_timestamp(H264dCurCtx_t *p_Cur, H264dCurStream_t *p_strm)
{
RK_U8 i = 0;
H264dTimeStamp_t *p_curr = NULL;
RK_U64 used_bytes = p_Cur->strm.pkt_used_bytes;
for (i = 0; i < MAX_PTS_NUM; i++) {
p_curr = &p_strm->pkt_ts[i];
if ( (used_bytes > p_curr->begin_off)
&& (used_bytes < p_curr->end_off) ) {
p_Cur->curr_dts = p_curr->dts;
p_Cur->curr_pts = p_curr->pts;
mpp_err("[TimePkt] insert_pts=%lld, pkt_pts=%lld \n", p_curr->pts, p_Cur->p_Inp->in_pts);
break;
}
}
//p_Cur->dts = p_Cur->p_Inp->in_dts;
//p_Cur->pts = p_Cur->p_Inp->in_pts;
}
static MPP_RET judge_is_new_frame(H264dCurCtx_t *p_Cur, H264dCurStream_t *p_strm)
{
MPP_RET ret = MPP_ERR_UNKNOW;
RK_U32 nalu_header_bytes = 0;
RK_U32 first_mb_in_slice = 0;
H264dLogCtx_t *logctx = &p_Cur->p_Dec->logctx;
BitReadCtx_t *p_bitctx = &p_Cur->bitctx;
RK_U32 forbidden_bit = -1;
RK_U32 nal_reference_idc = -1;
RK_U32 svc_extension_flag = -1;
FunctionIn(logctx->parr[RUN_PARSE]);
memset(p_bitctx, 0, sizeof(BitReadCtx_t));
mpp_set_bitread_ctx(p_bitctx, p_strm->nalu_buf, 4);
set_bitread_logctx(p_bitctx, logctx->parr[LOG_READ_NALU]);
READ_BITS(p_bitctx, 1, &forbidden_bit);
ASSERT(forbidden_bit == 0);
READ_BITS(p_bitctx, 2, &nal_reference_idc);
READ_BITS(p_bitctx, 5, &p_strm->nal_unit_type);
//if (g_nalu_cnt1 == 29) {
// g_nalu_cnt1 = g_nalu_cnt1;
//}
//FPRINT(g_debug_file0, "[Analyze_NALU] g_framecnt=%d, g_nalu_cnt=%d, nal_type=%d, sodb_len=%d \n", p_Cur->p_Vid->g_framecnt, g_nalu_cnt1++, p_strm->nal_unit_type, p_strm->nalu_len);
nalu_header_bytes = 1;
if ((p_strm->nal_unit_type == NALU_TYPE_PREFIX) || (p_strm->nal_unit_type == NALU_TYPE_SLC_EXT)) {
READ_BITS(p_bitctx, 1, &svc_extension_flag);
if (svc_extension_flag) {
LogInfo(logctx->parr[RUN_PARSE], "svc_extension is not supported.");
goto __FAILED;
} else {
if (p_strm->nal_unit_type == NALU_TYPE_SLC_EXT) {
p_strm->nal_unit_type = NALU_TYPE_SLICE;
}
}
nalu_header_bytes += 3;
}
//-- parse slice
if ( p_strm->nal_unit_type == NALU_TYPE_SLICE || p_strm->nal_unit_type == NALU_TYPE_IDR) {
mpp_set_bitread_ctx(p_bitctx, (p_strm->nalu_buf + nalu_header_bytes), 4); // reset
READ_UE(p_bitctx, &first_mb_in_slice);
//!< get time stamp
if (first_mb_in_slice == 0) {
p_Cur->last_dts = p_Cur->curr_dts;
p_Cur->last_pts = p_Cur->curr_pts;
//insert_timestamp(p_Cur, p_strm);
mpp_log("[init_pts]p_Cur->last_pts=%lld, p_Cur->cur_pts=%lld, inp_pts=%lld, g_framecnt=%d \n",
p_Cur->last_pts, p_Cur->curr_pts, p_Cur->p_Inp->in_pts, p_Cur->p_Vid->g_framecnt);
p_Cur->curr_dts = p_Cur->p_Inp->in_dts;
p_Cur->curr_pts = p_Cur->p_Inp->in_pts;
if (!p_Cur->p_Dec->is_first_frame) {
p_Cur->p_Dec->is_new_frame = 1;
}
p_Cur->p_Dec->is_first_frame = 0;
}
}
FunctionOut(logctx->parr[RUN_PARSE]);
return ret = MPP_OK;
__BITREAD_ERR:
return ret = p_bitctx->ret;
__FAILED:
return ret;
}
#if 0
/*! /*!
*********************************************************************** ***********************************************************************
* \brief * \brief
@@ -460,27 +556,27 @@ MPP_RET parse_prepare(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
FunctionIn(p_Inp->p_Dec->logctx.parr[RUN_PARSE]); FunctionIn(p_Inp->p_Dec->logctx.parr[RUN_PARSE]);
p_Inp->task_valid = 0; p_Inp->task_valid = 0;
if (p_Cur->p_Inp->is_eos) { if (p_Cur->p_Dec->is_new_frame) {
if (p_Inp->p_Dec->nalu_ret == HaveNoStream) {
FUN_CHECK(ret = parse_nalu_header(p_Cur));
FUN_CHECK(ret = store_cur_nalu(p_Cur)); FUN_CHECK(ret = store_cur_nalu(p_Cur));
p_Cur->p_Dec->is_new_frame = 0;
} else if (p_Cur->p_Inp->pkt_eos) {
if (p_Inp->p_Dec->nalu_ret == HaveNoStream) {
//FUN_CHECK(ret = analyze_cur_nalu(p_Cur));
//FUN_CHECK(ret = store_cur_nalu(p_Cur));
} }
FUN_CHECK(ret = add_empty_nalu(p_Cur)); FUN_CHECK(ret = add_empty_nalu(&p_Cur->strm));
p_Inp->task_valid = 1; p_Inp->task_valid = 1;
LogInfo(p_Inp->p_Dec->logctx.parr[RUN_PARSE], "----- end of stream ----"); LogInfo(p_Inp->p_Dec->logctx.parr[RUN_PARSE], "----- end of stream ----");
goto __RETURN; goto __RETURN;
} else if (p_Cur->p_Dec->is_new_frame) {
FUN_CHECK(ret = store_cur_nalu(p_Cur));
p_Cur->p_Dec->is_new_frame = 0;
} }
FUN_CHECK(ret = read_one_nalu(p_Inp, &p_Cur->strm)); FUN_CHECK(ret = read_one_nalu(p_Inp, &p_Cur->strm));
if (p_Inp->p_Dec->nalu_ret == EndOfNalu) { if (p_Inp->p_Dec->nalu_ret == EndOfNalu) {
FUN_CHECK(ret = parse_nalu_header(p_Cur)); FUN_CHECK(ret = analyze_cur_nalu(p_Cur));
if (p_Cur->p_Dec->is_new_frame) { if (p_Cur->p_Dec->is_new_frame) {
//!< add an empty nalu to tell frame end //!< add an empty nalu to tell frame end
FUN_CHECK(ret = add_empty_nalu(p_Cur)); FUN_CHECK(ret = add_empty_nalu(&p_Cur->strm));
//!< reset curstream parameters //!< reset curstream parameters
p_Cur->strm.head_offset = 0; p_Cur->strm.head_offset = 0;
p_Inp->task_valid = 1; p_Inp->task_valid = 1;
@@ -496,8 +592,94 @@ __RETURN:
__FAILED: __FAILED:
return ret; return ret;
} }
#else
/*!
***********************************************************************
* \brief
* prepare function for parser
***********************************************************************
*/
MPP_RET parse_prepare(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
{
MPP_RET ret = MPP_ERR_UNKNOW;
H264dLogCtx_t *logctx = &p_Inp->p_Dec->logctx;
H264_DecCtx_t *p_Dec = p_Inp->p_Dec;
H264dCurStream_t *p_strm = &p_Cur->strm;
RK_U32 nalu_header_bytes = 0;
FunctionIn(logctx->parr[RUN_PARSE]);
p_Dec->nalu_ret = NALU_NULL;
p_Inp->task_valid = 0;
if (p_Inp->pkt_eos) {
FUN_CHECK(ret = store_cur_nalu(p_Dec->p_Cur));
FUN_CHECK(ret = add_empty_nalu(p_strm));
p_Dec->p_Inp->task_valid = 1;
p_Dec->p_Inp->task_eos = 1;
LogInfo(p_Inp->p_Dec->logctx.parr[RUN_PARSE], "----- end of stream ----");
goto __RETURN;
}
while (p_Inp->in_length > 0) {
p_strm->curdata = &p_Inp->in_buf[p_strm->nalu_offset++];
(*p_Inp->in_size) -= 1;
p_Inp->in_length--;
p_strm->pkt_used_bytes++;
if (p_strm->startcode_found) {
if (p_strm->nalu_len >= p_strm->nalu_max_size) {
FUN_CHECK(ret = realloc_buffer(&p_strm->nalu_buf, &p_strm->nalu_max_size, NALU_BUF_ADD_SIZE));
}
p_strm->nalu_buf[p_strm->nalu_len++] = *p_strm->curdata;
if (p_strm->nalu_len == 1) {
p_strm->nal_unit_type = p_strm->nalu_buf[0]&0x1F;
nalu_header_bytes += 1;
if ((p_strm->nal_unit_type == NALU_TYPE_PREFIX)
|| (p_strm->nal_unit_type == NALU_TYPE_SLC_EXT)) {
nalu_header_bytes += 3;
}
}
if (p_strm->nalu_len == (nalu_header_bytes + 4)) {
FUN_CHECK(ret = judge_is_new_frame(p_Cur, p_strm));
if (p_Cur->p_Dec->is_new_frame) {
//!< add an empty nalu to tell frame end
FUN_CHECK(ret = add_empty_nalu(&p_Cur->strm));
//!< reset curstream parameters
p_Cur->strm.head_offset = 0;
p_Cur->p_Inp->task_valid = 1;
p_Cur->p_Dec->is_new_frame = 0;
break;
}
}
}
find_prefix_code(p_strm->curdata, p_strm);
if (p_strm->endcode_found) {
p_strm->nalu_len -= START_PREFIX_3BYTE;
//!< find non-zeros byte
while (p_strm->nalu_buf[p_strm->nalu_len - 1] == 0x00) {
p_strm->nalu_len--;
break;
}
p_Dec->nalu_ret = EndOfNalu;
FUN_CHECK(ret = store_cur_nalu(p_Dec->p_Cur));
reset_nalu(p_strm);
break;
}
}
//!< check input
if (!p_Inp->in_length) {
p_strm->nalu_offset = 0;
p_Dec->nalu_ret = HaveNoStream;
}
__RETURN:
FunctionOut(logctx->parr[RUN_PARSE]);
return ret = MPP_OK;
__FAILED:
return ret;
}
#endif #endif
/*! /*!
*********************************************************************** ***********************************************************************
@@ -518,6 +700,7 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
switch (p_Dec->next_state) { switch (p_Dec->next_state) {
case SliceSTATE_ResetSlice: case SliceSTATE_ResetSlice:
reset_slice(p_Dec->p_Vid); reset_slice(p_Dec->p_Vid);
p_Dec->next_state = SliceSTATE_ReadNalu;
//FPRINT(g_debug_file0, "SliceSTATE_ResetSlice\n"); //FPRINT(g_debug_file0, "SliceSTATE_ResetSlice\n");
break; break;
case SliceSTATE_ReadNalu: case SliceSTATE_ReadNalu:
@@ -533,6 +716,7 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
p_curdata += p_head->sodb_len; p_curdata += p_head->sodb_len;
p_Dec->nalu_ret = EndOfNalu; p_Dec->nalu_ret = EndOfNalu;
p_Dec->next_state = SliceSTATE_ParseNalu; p_Dec->next_state = SliceSTATE_ParseNalu;
}
//FPRINT(g_debug_file0, "SliceSTATE_ReadNalu\n"); //FPRINT(g_debug_file0, "SliceSTATE_ReadNalu\n");
break; break;
case SliceSTATE_ParseNalu: case SliceSTATE_ParseNalu:
@@ -543,21 +727,25 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
p_Dec->next_state = SliceSTATE_InitPicture; p_Dec->next_state = SliceSTATE_InitPicture;
} else { } else {
p_Dec->next_state = SliceSTATE_ReadNalu; p_Dec->next_state = SliceSTATE_ReadNalu;
}
//FPRINT(g_debug_file0, "SliceSTATE_ParseNalu\n"); //FPRINT(g_debug_file0, "SliceSTATE_ParseNalu\n");
break; break;
case SliceSTATE_InitPicture: case SliceSTATE_InitPicture:
(ret = init_picture(&p_Dec->p_Cur->slice)); (ret = init_picture(&p_Dec->p_Cur->slice));
p_Dec->next_state = SliceSTATE_GetSliceData;
//FPRINT(g_debug_file0, "SliceSTATE_InitPicture\n"); //FPRINT(g_debug_file0, "SliceSTATE_InitPicture\n");
break; break;
case SliceSTATE_GetSliceData: case SliceSTATE_GetSliceData:
(ret = fill_slice_syntax(&p_Dec->p_Cur->slice, p_Dec->dxva_ctx)); (ret = fill_slice_syntax(&p_Dec->p_Cur->slice, p_Dec->dxva_ctx));
p_Dec->p_Vid->iNumOfSlicesDecoded++; p_Dec->p_Vid->iNumOfSlicesDecoded++;
p_Dec->next_state = SliceSTATE_ResetSlice;
//FPRINT(g_debug_file0, "SliceSTATE_GetSliceData\n"); //FPRINT(g_debug_file0, "SliceSTATE_GetSliceData\n");
break; break;
case SliceSTATE_RegisterOneFrame: case SliceSTATE_RegisterOneFrame:
commit_buffer(p_Dec->dxva_ctx); commit_buffer(p_Dec->dxva_ctx);
while_loop_flag = 0; while_loop_flag = 0;
p_Dec->is_parser_end = 1; p_Dec->is_parser_end = 1;
p_Dec->next_state = SliceSTATE_ReadNalu;
//FPRINT(g_debug_file0, "SliceSTATE_RegisterOneFrame\n"); //FPRINT(g_debug_file0, "SliceSTATE_RegisterOneFrame\n");
break; break;
default: default:

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

@@ -539,6 +539,9 @@ 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[1], 2)); 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)); 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); 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] + 2);
} }
} else { //!< layer_id == 0 } else { //!< layer_id == 0
p_Vid->active_sps = sps; p_Vid->active_sps = sps;
@@ -551,6 +554,9 @@ MPP_RET activate_sps(H264dVideoCtx_t *p_Vid, H264_SPS_t *sps, H264_subSPS_t *sub
} }
FUN_CHECK(ret = init_dpb(p_Vid, 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); 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] + 2);
} }
} }
update_video_pars(p_Vid, p_Vid->active_sps); update_video_pars(p_Vid, p_Vid->active_sps);

1
mpp/codec/inc/mpp_buf_slot.h
View File

@@ -221,6 +221,7 @@ typedef enum SlotPropType_e {
SLOT_EOS, SLOT_EOS,
SLOT_FRAME, SLOT_FRAME,
SLOT_BUFFER, SLOT_BUFFER,
SLOT_FRAME_PTR,
SLOT_PROP_BUTT, SLOT_PROP_BUTT,
} SlotPropType; } SlotPropType;

7
mpp/codec/mpp_buf_slot.cpp
View File

@@ -825,6 +825,8 @@ MPP_RET mpp_buf_slot_get_prop(MppBufSlots slots, RK_S32 index, SlotPropType type
} break; } break;
case SLOT_FRAME: { case SLOT_FRAME: {
MppFrame *frame = (MppFrame *)val; MppFrame *frame = (MppFrame *)val;
//*frame = (slot->status.has_frame) ? (slot->frame) : (NULL);
mpp_assert(slot->status.has_frame); mpp_assert(slot->status.has_frame);
if (slot->status.has_frame) { if (slot->status.has_frame) {
mpp_frame_init(frame); mpp_frame_init(frame);
@@ -832,6 +834,10 @@ MPP_RET mpp_buf_slot_get_prop(MppBufSlots slots, RK_S32 index, SlotPropType type
mpp_frame_copy(*frame, slot->frame); mpp_frame_copy(*frame, slot->frame);
} else } else
*frame = NULL; *frame = NULL;
} break;
case SLOT_FRAME_PTR: {
MppFrame *frame = (MppFrame *)val;
*frame = (slot->status.has_frame) ? (slot->frame) : (NULL);
} break; } break;
case SLOT_BUFFER: { case SLOT_BUFFER: {
MppBuffer *buffer = (MppBuffer *)val; MppBuffer *buffer = (MppBuffer *)val;
@@ -843,7 +849,6 @@ MPP_RET mpp_buf_slot_get_prop(MppBufSlots slots, RK_S32 index, SlotPropType type
return MPP_OK; return MPP_OK;
} }
MPP_RET mpp_slots_set_prop(MppBufSlots slots, SlotsPropType type, void *val) MPP_RET mpp_slots_set_prop(MppBufSlots slots, SlotsPropType type, void *val)
{ {
if (NULL == slots || NULL == val || type >= SLOTS_PROP_BUTT) { if (NULL == slots || NULL == val || type >= SLOTS_PROP_BUTT) {

5
mpp/codec/mpp_dec.cpp
View File

@@ -24,6 +24,7 @@
#include "mpp_common.h" #include "mpp_common.h"
#include "mpp.h" #include "mpp.h"
#include "mpp_frame.h"
#include "mpp_buffer_impl.h" #include "mpp_buffer_impl.h"
#include "mpp_packet_impl.h" #include "mpp_packet_impl.h"
#include "mpp_frame_impl.h" #include "mpp_frame_impl.h"
@@ -604,8 +605,10 @@ void *mpp_dec_hal_thread(void *data)
RK_S32 index; RK_S32 index;
while (MPP_OK == mpp_buf_slot_dequeue(frame_slots, &index, QUEUE_DISPLAY)) { while (MPP_OK == mpp_buf_slot_dequeue(frame_slots, &index, QUEUE_DISPLAY)) {
MppFrame frame; MppFrame frame;
RK_U32 display;
mpp_buf_slot_get_prop(frame_slots, index, SLOT_FRAME, &frame); mpp_buf_slot_get_prop(frame_slots, index, SLOT_FRAME, &frame);
if (!dec->reset_flag) { display = mpp_frame_get_display(frame);
if (!dec->reset_flag && display) {
mpp_put_frame(mpp, frame); mpp_put_frame(mpp, frame);
} else { } else {
mpp_frame_deinit(&frame); mpp_frame_deinit(&frame);

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

@@ -42,6 +42,9 @@
#define H264dSTM_HEADER 0x4d525453 #define H264dSTM_HEADER 0x4d525453
#define H264dERR_HEADER 0x524f5245 #define H264dERR_HEADER 0x524f5245
#define FPGA_TEST 0
const enum { const enum {
H264ScalingList4x4Length = 16, H264ScalingList4x4Length = 16,
H264ScalingList8x8Length = 64, H264ScalingList8x8Length = 64,
@@ -50,6 +53,8 @@ const enum {
static void rkv_write_sps_to_fifo(H264dHalCtx_t *p_hal, FifoCtx_t *pkt) static void rkv_write_sps_to_fifo(H264dHalCtx_t *p_hal, FifoCtx_t *pkt)
{ {
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, 4, "seq_parameter_set_id"); //!< not used in hard
fifo_write_bits(pkt, -1, 8, "profile_idc"); //!< not used in hard fifo_write_bits(pkt, -1, 8, "profile_idc"); //!< not used in hard
fifo_write_bits(pkt, -1, 1, "constraint_set3_flag"); //!< not used in hard fifo_write_bits(pkt, -1, 1, "constraint_set3_flag"); //!< not used in hard
@@ -97,13 +102,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_write_bits(pkt, 0, 10, "non_anchor_ref_l1");
} }
fifo_align_bits(pkt, 32); fifo_align_bits(pkt, 32);
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
} }
static void rkv_write_pps_to_fifo(H264dHalCtx_t *p_hal, FifoCtx_t *pkt) static void rkv_write_pps_to_fifo(H264dHalCtx_t *p_hal, FifoCtx_t *pkt)
{ {
RK_U32 Scaleing_list_address = 0; RK_U32 Scaleing_list_address = 0;
RK_U32 offset = RKV_CABAC_TAB_SIZE + RKV_SPSPPS_SIZE + RKV_RPS_SIZE; RK_U32 offset = RKV_CABAC_TAB_SIZE + RKV_SPSPPS_SIZE + RKV_RPS_SIZE;
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
fifo_write_bits(pkt, -1, 8, "pps_pic_parameter_set_id"); 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, -1, 5, "pps_seq_parameter_set_id");
fifo_write_bits(pkt, p_hal->pp->entropy_coding_mode_flag, 1, "entropy_coding_mode_flag"); fifo_write_bits(pkt, p_hal->pp->entropy_coding_mode_flag, 1, "entropy_coding_mode_flag");
@@ -128,7 +134,12 @@ static void rkv_write_pps_to_fifo(H264dHalCtx_t *p_hal, FifoCtx_t *pkt)
} else { } else {
Scaleing_list_address += offset; Scaleing_list_address += offset;
} }
#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]);
} }
@@ -181,6 +192,7 @@ MPP_RET rkv_alloc_fifo_packet(H264dLogCtx_t *logctx, H264dRkvPkt_t *pkts)
RK_U32 sclst_size = 256; RK_U32 sclst_size = 256;
RK_U32 regs_size = 512; RK_U32 regs_size = 512;
FunctionIn(logctx->parr[RUN_HAL]);
//!< initial packages header and malloc buffer //!< 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->spspps, H264dPPS_HEADER, pps_size));
FUN_CHECK(ret = fifo_packet_alloc(&pkts->rps, H264dRPS_HEADER, rps_size)); FUN_CHECK(ret = fifo_packet_alloc(&pkts->rps, H264dRPS_HEADER, rps_size));
@@ -206,6 +218,7 @@ MPP_RET rkv_alloc_fifo_packet(H264dLogCtx_t *logctx, H264dRkvPkt_t *pkts)
pkts->scanlist.fp_data = NULL; pkts->scanlist.fp_data = NULL;
pkts->reg.fp_data = NULL; pkts->reg.fp_data = NULL;
} }
FunctionOut(logctx->parr[RUN_HAL]);
return ret = MPP_OK; return ret = MPP_OK;
__FAILED: __FAILED:
rkv_free_fifo_packet(pkts); rkv_free_fifo_packet(pkts);
@@ -225,6 +238,8 @@ void rkv_prepare_spspps_packet(void *hal, FifoCtx_t *pkt)
RK_S32 i = 0; RK_S32 i = 0;
RK_S32 is_long_term = 0, voidx = 0; RK_S32 is_long_term = 0, voidx = 0;
H264dHalCtx_t *p_hal = (H264dHalCtx_t *)hal; H264dHalCtx_t *p_hal = (H264dHalCtx_t *)hal;
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
fifo_packet_reset(pkt); fifo_packet_reset(pkt);
LogInfo(pkt->logctx, "------------------ Frame SPS_PPS begin ------------------------"); LogInfo(pkt->logctx, "------------------ Frame SPS_PPS begin ------------------------");
rkv_write_sps_to_fifo(p_hal, pkt); rkv_write_sps_to_fifo(p_hal, pkt);
@@ -240,6 +255,7 @@ void rkv_prepare_spspps_packet(void *hal, FifoCtx_t *pkt)
} }
fifo_align_bits(pkt, 64); fifo_align_bits(pkt, 64);
fifo_fwrite_data(pkt); //!< "PPSH" header 32 bit fifo_fwrite_data(pkt); //!< "PPSH" header 32 bit
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
} }
/*! /*!
*********************************************************************** ***********************************************************************
@@ -257,7 +273,7 @@ void rkv_prepare_framerps_packet(void *hal, FifoCtx_t *pkt)
RK_U16 frame_num_wrap = 0; RK_U16 frame_num_wrap = 0;
H264dHalCtx_t *p_hal = (H264dHalCtx_t *)hal; H264dHalCtx_t *p_hal = (H264dHalCtx_t *)hal;
DXVA_PicParams_H264_MVC *pp = p_hal->pp; DXVA_PicParams_H264_MVC *pp = p_hal->pp;
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
fifo_packet_reset(pkt); fifo_packet_reset(pkt);
LogInfo(pkt->logctx, "------------------ Frame RPS begin ------------------------"); LogInfo(pkt->logctx, "------------------ Frame RPS begin ------------------------");
max_frame_num = 1 << (pp->log2_max_frame_num_minus4 + 4); max_frame_num = 1 << (pp->log2_max_frame_num_minus4 + 4);
@@ -304,6 +320,7 @@ void rkv_prepare_framerps_packet(void *hal, FifoCtx_t *pkt)
fifo_align_bits(pkt, 128); fifo_align_bits(pkt, 128);
fifo_flush_bits(pkt); fifo_flush_bits(pkt);
fifo_fwrite_data(pkt); //!< "RPSH" header 32 bit fifo_fwrite_data(pkt); //!< "RPSH" header 32 bit
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
} }
/*! /*!
*********************************************************************** ***********************************************************************
@@ -316,7 +333,7 @@ void rkv_prepare_scanlist_packet(void *hal, FifoCtx_t *pkt)
{ {
RK_S32 i = 0; RK_S32 i = 0;
H264dHalCtx_t *p_hal = (H264dHalCtx_t *)hal; H264dHalCtx_t *p_hal = (H264dHalCtx_t *)hal;
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
if (p_hal->pp->scaleing_list_enable_flag) { if (p_hal->pp->scaleing_list_enable_flag) {
fifo_packet_reset(pkt); fifo_packet_reset(pkt);
LogInfo(pkt->logctx, "------------------ Scanlist begin ------------------------"); LogInfo(pkt->logctx, "------------------ Scanlist begin ------------------------");
@@ -328,6 +345,7 @@ void rkv_prepare_scanlist_packet(void *hal, FifoCtx_t *pkt)
} }
fifo_fwrite_data(pkt); //!< "SCLS" header 32 bit fifo_fwrite_data(pkt); //!< "SCLS" header 32 bit
} }
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
} }
/*! /*!
@@ -354,14 +372,15 @@ void rkv_generate_regs(void *hal, HalTaskInfo *task, FifoCtx_t *pkt)
DXVA_PicParams_H264_MVC *pp = p_hal->pp; DXVA_PicParams_H264_MVC *pp = p_hal->pp;
H264dRkvRegs_t *p_regs = (H264dRkvRegs_t *)p_hal->regs; H264dRkvRegs_t *p_regs = (H264dRkvRegs_t *)p_hal->regs;
memset(p_regs, 0, sizeof(H264dRkvRegs_t)); 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) { if (p_regs->swreg2_sysctrl.sw_rlc_mode == 1) {
p_regs->swreg5_stream_rlc_len.sw_stream_len = 0; p_regs->swreg5_stream_rlc_len.sw_stream_len = 0;
} else { } else {
p_regs->swreg5_stream_rlc_len.sw_stream_len = p_hal->strm_len; p_regs->swreg5_stream_rlc_len.sw_stream_len = mpp_packet_get_length(task->dec.input_packet);
} }
//!< caculate the yuv_frame_size and mv_size //!< caculate the yuv_frame_size and mv_size
mb_width = pp->wFrameWidthInMbsMinus1 + 1; mb_width = pp->wFrameWidthInMbsMinus1 + 1;
@@ -413,8 +432,11 @@ void rkv_generate_regs(void *hal, HalTaskInfo *task, FifoCtx_t *pkt)
p_regs->swreg40_cur_poc.sw_cur_poc = pp->CurrFieldOrderCnt[0]; p_regs->swreg40_cur_poc.sw_cur_poc = pp->CurrFieldOrderCnt[0];
p_regs->swreg74_h264_cur_poc1.sw_h264_cur_poc1 = pp->CurrFieldOrderCnt[1]; p_regs->swreg74_h264_cur_poc1.sw_h264_cur_poc1 = pp->CurrFieldOrderCnt[1];
mpp_buf_slot_get_prop(p_hal->frame_slots, pp->CurrPic.Index7Bits, SLOT_BUFFER, &frame_buf); //!< current out phy addr mpp_buf_slot_get_prop(p_hal->frame_slots, pp->CurrPic.Index7Bits, SLOT_BUFFER, &frame_buf); //!< current out phy addr
//p_regs->swreg7_decout_base.sw_decout_base = pp->CurrPic.Index7Bits + 1; #if FPGA_TEST
p_regs->swreg7_decout_base.sw_decout_base = mpp_buffer_get_fd(frame_buf); 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) >> 4;
#endif
//!< set reference //!< set reference
for (i = 0; i < 15; i++) { for (i = 0; i < 15; i++) {
p_regs->swreg25_39_refer0_14_poc[i] = (i & 1) ? pp->FieldOrderCntList[i / 2][1] : pp->FieldOrderCntList[i / 2][0]; p_regs->swreg25_39_refer0_14_poc[i] = (i & 1) ? pp->FieldOrderCntList[i / 2][1] : pp->FieldOrderCntList[i / 2][0];
@@ -429,8 +451,11 @@ void rkv_generate_regs(void *hal, HalTaskInfo *task, FifoCtx_t *pkt)
} else { } else {
mpp_buf_slot_get_prop(p_hal->frame_slots, pp->RefFrameList[i].Index7Bits, SLOT_BUFFER, &frame_buf); //!< reference phy addr mpp_buf_slot_get_prop(p_hal->frame_slots, pp->RefFrameList[i].Index7Bits, SLOT_BUFFER, &frame_buf); //!< reference phy addr
} }
//p_regs->swreg10_24_refer0_14_base[i].sw_refer_base = pp->RefFrameList[i].Index7Bits + 1; #if FPGA_TEST
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) >> 4; p_regs->swreg10_24_refer0_14_base[i].sw_refer_base = mpp_buffer_get_fd(frame_buf) >> 4;
#endif
} }
p_regs->swreg72_refer30_poc = pp->FieldOrderCntList[i][0]; p_regs->swreg72_refer30_poc = pp->FieldOrderCntList[i][0];
p_regs->swreg73_refer31_poc = pp->FieldOrderCntList[i][1]; p_regs->swreg73_refer31_poc = pp->FieldOrderCntList[i][1];
@@ -443,19 +468,22 @@ void rkv_generate_regs(void *hal, HalTaskInfo *task, FifoCtx_t *pkt)
} else { } else {
mpp_buf_slot_get_prop(p_hal->frame_slots, pp->RefFrameList[15].Index7Bits, SLOT_BUFFER, &frame_buf); //!< reference phy addr mpp_buf_slot_get_prop(p_hal->frame_slots, pp->RefFrameList[15].Index7Bits, SLOT_BUFFER, &frame_buf); //!< reference phy addr
} }
// p_regs->swreg48_refer15_base.sw_refer_base = pp->RefFrameList[15].Index7Bits + 1; #if FPGA_TEST
p_regs->swreg48_refer15_base.sw_refer_base = pp->RefFrameList[15].Index7Bits + 1;
#else
p_regs->swreg48_refer15_base.sw_refer_base = mpp_buffer_get_fd(frame_buf) >> 4; p_regs->swreg48_refer15_base.sw_refer_base = mpp_buffer_get_fd(frame_buf) >> 4;
#endif
p_regs->swreg6_cabactbl_prob_base.sw_cabactbl_base = mpp_buffer_get_fd(p_hal->cabac_buf); p_regs->swreg6_cabactbl_prob_base.sw_cabactbl_base = mpp_buffer_get_fd(p_hal->cabac_buf) >> 4;
mpp_buf_slot_get_prop(p_hal->packet_slots, task->dec.input, SLOT_BUFFER, &bitstream_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); p_regs->swreg4_strm_rlc_base.sw_strm_rlc_base = mpp_buffer_get_fd(bitstream_buf) >> 4;
fifo_packet_reset(pkt); fifo_packet_reset(pkt);
fifo_write_bytes(pkt, (void *)p_hal->regs, sizeof(H264dRkvRegs_t)); fifo_write_bytes(pkt, (void *)p_hal->regs, sizeof(H264dRkvRegs_t));
fifo_align_bits(pkt, 64); fifo_align_bits(pkt, 64);
fifo_flush_bits(pkt); fifo_flush_bits(pkt);
fifo_fwrite_data(pkt); //!< "REGH" header 32 bit fifo_fwrite_data(pkt); //!< "REGH" header 32 bit
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
} }
/*! /*!

2
mpp/hal/rkdec/h264d/hal_h264d_rkv_pkt.h
View File

@@ -33,7 +33,7 @@
#define RKV_SPSPPS_SIZE (256*32 + 128) /* bytes */ #define RKV_SPSPPS_SIZE (256*32 + 128) /* bytes */
#define RKV_RPS_SIZE (128 + 128) /* bytes */ #define RKV_RPS_SIZE (128 + 128) /* bytes */
#define RKV_SCALING_LIST_SIZE (6*16+2*64 + 128) /* bytes */ #define RKV_SCALING_LIST_SIZE (6*16+2*64 + 128) /* bytes */
#define RKV_ERROR_INFO_SIZE (256*144*4) /* bytes */
typedef struct h264d_rkv_packet_t { typedef struct h264d_rkv_packet_t {
FifoCtx_t spspps; FifoCtx_t spspps;
FifoCtx_t rps; FifoCtx_t rps;

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

@@ -220,7 +220,7 @@ MPP_RET rkv_h264d_init(void *hal, MppHalCfg *cfg)
MEM_CHECK(ret, p_hal->pkts = mpp_calloc_size(void, sizeof(H264dRkvPkt_t))); MEM_CHECK(ret, p_hal->pkts = mpp_calloc_size(void, sizeof(H264dRkvPkt_t)));
//!< malloc cabac+scanlis + packets + poc_buf //!< malloc cabac+scanlis + packets + poc_buf
cabac_size = RKV_CABAC_TAB_SIZE + RKV_SPSPPS_SIZE + RKV_RPS_SIZE + RKV_SCALING_LIST_SIZE; cabac_size = RKV_CABAC_TAB_SIZE + RKV_SPSPPS_SIZE + RKV_RPS_SIZE + RKV_SCALING_LIST_SIZE + RKV_ERROR_INFO_SIZE;
FUN_CHECK(ret = mpp_buffer_get(p_hal->buf_group, &p_hal->cabac_buf, cabac_size)); FUN_CHECK(ret = mpp_buffer_get(p_hal->buf_group, &p_hal->cabac_buf, cabac_size));
//!< copy cabac table bytes //!< copy cabac table bytes
FUN_CHECK(ret = mpp_buffer_write(p_hal->cabac_buf, 0, (void *)H264_RKV_Cabac_table, sizeof(H264_RKV_Cabac_table))); FUN_CHECK(ret = mpp_buffer_write(p_hal->cabac_buf, 0, (void *)H264_RKV_Cabac_table, sizeof(H264_RKV_Cabac_table)));
@@ -299,9 +299,13 @@ MPP_RET rkv_h264d_gen_regs(void *hal, HalTaskInfo *task)
mpp_buffer_write(p_hal->cabac_buf, strm_offset, (void *)pkts->rps.pbuf, RKV_RPS_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; p_regs->swreg43_rps_base.sw_rps_base = hw_base + strm_offset;
strm_offset += RKV_SCALING_LIST_SIZE; strm_offset += RKV_RPS_SIZE;
mpp_buffer_write(p_hal->cabac_buf, strm_offset, (void *)pkts->scanlist.pbuf, RKV_SCALING_LIST_SIZE); mpp_buffer_write(p_hal->cabac_buf, strm_offset, (void *)pkts->scanlist.pbuf, RKV_SCALING_LIST_SIZE);
strm_offset += RKV_SCALING_LIST_SIZE;
strm_offset += mpp_buffer_get_fd(p_hal->cabac_buf) >> 4;
p_regs->swreg75_h264_errorinfo_base.sw_errorinfo_base = strm_offset;
((HalDecTask*)&task->dec)->valid = 0; ((HalDecTask*)&task->dec)->valid = 0;
FunctionOut(p_hal->logctx.parr[RUN_HAL]); FunctionOut(p_hal->logctx.parr[RUN_HAL]);

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

@@ -237,6 +237,7 @@ const HalRegDrv_t g_vdpu_drv[VDPU_MAX_SIZE + 1] = {
{ VDPU_DEC_OUT_DIS , 3 , 1, 15, "sw03_dec_out_dis " }, { VDPU_DEC_OUT_DIS , 3 , 1, 15, "sw03_dec_out_dis " },
{ VDPU_FILTERING_DIS , 3 , 1, 14, "sw03_filtering_dis " }, { VDPU_FILTERING_DIS , 3 , 1, 14, "sw03_filtering_dis " },
{ VDPU_PIC_FIXED_QUANT , 3 , 1, 13, "sw03_pic_fixed_quant " }, { VDPU_PIC_FIXED_QUANT , 3 , 1, 13, "sw03_pic_fixed_quant " },
{ VDPU_MVC_E , 3 , 1, 13, "sw03_mvc_e " },
{ VDPU_WRITE_MVS_E , 3 , 1, 12, "sw03_write_mvs_e " }, { VDPU_WRITE_MVS_E , 3 , 1, 12, "sw03_write_mvs_e " },
{ VDPU_REFTOPFIRST_E , 3 , 1, 11, "sw03_reftopfirst_e " }, { VDPU_REFTOPFIRST_E , 3 , 1, 11, "sw03_reftopfirst_e " },
{ VDPU_SEQ_MBAFF_E , 3 , 1, 10, "sw03_seq_mbaff_e " }, { VDPU_SEQ_MBAFF_E , 3 , 1, 10, "sw03_seq_mbaff_e " },
@@ -952,14 +953,6 @@ const RK_U32 g_refBase[16] = {
VDPU_REFER15_BASE VDPU_REFER15_BASE
}; };
const enum {
H264ScalingList4x4Length = 16,
H264ScalingList8x8Length = 64,
} ScalingListLength;
#ifndef ANDROID #ifndef ANDROID
RK_S32 VPUClientGetIOMMUStatus() RK_S32 VPUClientGetIOMMUStatus()
@@ -1073,6 +1066,13 @@ MPP_RET vdpu_set_vlc_regs(void *hal, HalRegDrvCtx_t *p_drv)
} }
FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_REFER_LTERM_E, longTermflags << 16)); FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_REFER_LTERM_E, longTermflags << 16));
FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_REFER_VALID_E, validFlags << 16)); 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, "--------- [FLUSH_CNT] flush framecnt=%d -------- \n", p_hal->iDecodedNum++);
} }
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
@@ -1104,17 +1104,48 @@ MPP_RET vdpu_set_vlc_regs(void *hal, HalRegDrvCtx_t *p_drv)
*pocBase++ = p_hal->pp->CurrFieldOrderCnt[0]; *pocBase++ = p_hal->pp->CurrFieldOrderCnt[0];
*pocBase++ = p_hal->pp->CurrFieldOrderCnt[1]; *pocBase++ = p_hal->pp->CurrFieldOrderCnt[1];
} }
#if 0
//pocBase = (RK_U32 *) ((RK_U8 *)mpp_buffer_get_ptr(p_hal->cabac_buf) + VDPU_CABAC_TAB_SIZE); //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++) //for (i = 0; i < VDPU_POC_BUF_SIZE / 4; i++)
//{ //{
// FPRINT(g_debug_file0, "i=%d, poc_value=%d, idx=%d \n", i, *pocBase++, p_hal->pp->RefFrameList[i / 2].Index7Bits); // 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); //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);
#endif
FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_CABAC_E , p_hal->pp->entropy_coding_mode_flag)); FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_CABAC_E , p_hal->pp->entropy_coding_mode_flag));
//!< stream position update //!< stream position update
FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_START_CODE_E , 1)); FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_START_CODE_E , 1));
@@ -1185,15 +1216,14 @@ __FAILED:
//extern "C" //extern "C"
MPP_RET vdpu_set_asic_regs(void *hal, HalRegDrvCtx_t *p_drv) MPP_RET vdpu_set_asic_regs(void *hal, HalRegDrvCtx_t *p_drv)
{ {
RK_U32 i = 0; RK_U32 i = 0, j = 0;
RK_U32 validTmp = 0; RK_U32 validTmp = 0;
RK_U32 outPhyAddr = 0; RK_U32 outPhyAddr = 0;
RK_U32 dirMvOffset = 0; RK_U32 dirMvOffset = 0;
RK_U32 picSizeInMbs = 0; RK_U32 picSizeInMbs = 0;
RK_U8 *p_start = NULL;
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
MppBuffer frame_buf = NULL; MppBuffer frame_buf = NULL;
FifoCtx_t pkt_scanlist = { 0 };
H264dHalCtx_t *p_hal = (H264dHalCtx_t *)hal; H264dHalCtx_t *p_hal = (H264dHalCtx_t *)hal;
DXVA_PicParams_H264_MVC *pp = p_hal->pp; DXVA_PicParams_H264_MVC *pp = p_hal->pp;
@@ -1202,16 +1232,19 @@ MPP_RET vdpu_set_asic_regs(void *hal, HalRegDrvCtx_t *p_drv)
FunctionIn(p_hal->logctx.parr[RUN_HAL]); FunctionIn(p_hal->logctx.parr[RUN_HAL]);
/* reference picture physis address */ /* reference picture physis address */
LogTrace(p_hal->logctx.parr[RUN_HAL], "reference mpp_buffer_get_fd begin"); for (i = 0, j = 0xff; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) {
for (i = 0; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) { if (pp->RefFrameList[i].bPicEntry != 0xff) {
if (pp->RefFrameList[i].bPicEntry == 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, pp->RefFrameList[i].Index7Bits, SLOT_BUFFER, &frame_buf); //!< reference 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))); FUN_CHECK(ret = hal_set_regdrv(p_drv, g_refBase[i], mpp_buffer_get_fd(frame_buf)));
} }
LogTrace(p_hal->logctx.parr[RUN_HAL], "reference mpp_buffer_get_fd end");
/* inter-view reference picture */ /* inter-view reference picture */
if (pp->curr_layer_id && priv->ilt_dpb[0].valid /*pp->inter_view_flag*/) { if (pp->curr_layer_id && priv->ilt_dpb[0].valid /*pp->inter_view_flag*/) {
mpp_buf_slot_get_prop(p_hal->frame_slots, priv->ilt_dpb[0].slot_index, SLOT_BUFFER, &frame_buf); //!< current out phy addr mpp_buf_slot_get_prop(p_hal->frame_slots, priv->ilt_dpb[0].slot_index, SLOT_BUFFER, &frame_buf); //!< current out phy addr
@@ -1222,10 +1255,8 @@ MPP_RET vdpu_set_asic_regs(void *hal, HalRegDrvCtx_t *p_drv)
} }
FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_MVC_E, pp->curr_layer_id)); FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_MVC_E, pp->curr_layer_id));
FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_FILTERING_DIS, 0)); //!< filterDisable = 0; FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_FILTERING_DIS, 0)); //!< filterDisable = 0;
LogTrace(p_hal->logctx.parr[RUN_HAL], "current mpp_buffer_get_fd begin");
mpp_buf_slot_get_prop(p_hal->frame_slots, pp->CurrPic.Index7Bits, SLOT_BUFFER, &frame_buf); //!< current out phy addr mpp_buf_slot_get_prop(p_hal->frame_slots, pp->CurrPic.Index7Bits, SLOT_BUFFER, &frame_buf); //!< current out phy addr
outPhyAddr = mpp_buffer_get_fd(frame_buf); outPhyAddr = mpp_buffer_get_fd(frame_buf);
LogTrace(p_hal->logctx.parr[RUN_HAL], "current mpp_buffer_get_fd end");
if (pp->field_pic_flag && pp->CurrPic.AssociatedFlag) { if (pp->field_pic_flag && pp->CurrPic.AssociatedFlag) {
if (VPUClientGetIOMMUStatus() > 0) { if (VPUClientGetIOMMUStatus() > 0) {
outPhyAddr |= ((pp->wFrameWidthInMbsMinus1 + 1) * 16) << 10; outPhyAddr |= ((pp->wFrameWidthInMbsMinus1 + 1) * 16) << 10;
@@ -1249,7 +1280,6 @@ MPP_RET vdpu_set_asic_regs(void *hal, HalRegDrvCtx_t *p_drv)
FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_DIR_MV_BASE, outPhyAddr + dirMvOffset)); FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_DIR_MV_BASE, outPhyAddr + dirMvOffset));
} }
FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_WRITE_MVS_E, (p_long->nal_ref_idc != 0))); //!< defalut set 1 FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_WRITE_MVS_E, (p_long->nal_ref_idc != 0))); //!< defalut set 1
FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_DIR_8X8_INFER_E, pp->direct_8x8_inference_flag)); FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_DIR_8X8_INFER_E, pp->direct_8x8_inference_flag));
FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_WEIGHT_PRED_E, pp->weighted_pred_flag)); FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_WEIGHT_PRED_E, pp->weighted_pred_flag));
@@ -1266,16 +1296,50 @@ 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)); 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) { if (p_hal->pp->scaleing_list_enable_flag) {
p_start = (RK_U8 *)mpp_buffer_get_ptr(p_hal->cabac_buf) + VDPU_CABAC_TAB_SIZE + VDPU_POC_BUF_SIZE; RK_U32 temp = 0;
RK_U32 *ptr = NULL;
fifo_packet_init(&pkt_scanlist, p_start, VDPU_SCALING_LIST_SIZE); 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) { //!< 4x4, 6 lists for(i = 0; i < 6; i++) {
fifo_write_bytes(&pkt_scanlist, p_hal->qm->bScalingLists4x4[i], H264ScalingList4x4Length); for(j = 0; j < 4; j++) {
} temp = (p_hal->qm->bScalingLists4x4[i][4 * j + 0] << 24) |
for (i = 0; i < 2; ++i) { (p_hal->qm->bScalingLists4x4[i][4 * j + 1] << 16) |
fifo_write_bytes(&pkt_scanlist, p_hal->qm->bScalingLists8x8[i], H264ScalingList8x8Length); (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");
}
}
#endif
FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_DEC_OUT_DIS, 0)); //!< set defalut 0 FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_DEC_OUT_DIS, 0)); //!< set defalut 0
FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_CH_8PIX_ILEAV_E, 0)); FUN_CHECK(ret = hal_set_regdrv(p_drv, VDPU_CH_8PIX_ILEAV_E, 0));

2
mpp/hal/rkdec/h264d/hal_h264d_vdpu_pkt.h
View File

@@ -141,7 +141,7 @@
#endif #endif
/* Check validity of values */ /* Check validity of values */
/* data discard and tiled mode can not be on simultaneously */ /* data display and tiled mode can not be on simultaneously */
#if (DEC_X170_DATA_DISCARD_ENABLE && (DEC_X170_OUTPUT_FORMAT == DEC_X170_OUTPUT_FORMAT_TILED)) #if (DEC_X170_DATA_DISCARD_ENABLE && (DEC_X170_OUTPUT_FORMAT == DEC_X170_OUTPUT_FORMAT_TILED))
#error "Bad value specified: DEC_X170_DATA_DISCARD_ENABLE && (DEC_X170_OUTPUT_FORMAT == DEC_X170_OUTPUT_FORMAT_TILED)" #error "Bad value specified: DEC_X170_DATA_DISCARD_ENABLE && (DEC_X170_OUTPUT_FORMAT == DEC_X170_OUTPUT_FORMAT_TILED)"
#endif #endif

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

@@ -35,16 +35,17 @@
//static void print_single_regs(HalRegDrvCtx_t *p_drv, const HalRegDrv_t *pcur) static void print_single_regs(HalRegDrvCtx_t *p_drv, const HalRegDrv_t *pcur)
//{ {
// RK_S32 val = 0; RK_S32 val = 0;
// hal_get_regdrv(p_drv, pcur->syn_id, (RK_U32 *)&val); 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]", 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); pcur->name, pcur->reg_id, pcur->bitpos, pcur->bitlen, val);
//} }
RK_U32 g_print_init_value = 1; RK_U32 g_print_init_value = 1;
static MPP_RET vdpu_h264d_print_regs(H264dHalCtx_t *p_hal, HalRegDrvCtx_t *p_drv) static MPP_RET vdpu_h264d_print_regs(H264dHalCtx_t *p_hal, HalRegDrvCtx_t *p_drv)
{ {
RK_U32 i = 0; RK_U32 i = 0;
@@ -55,7 +56,7 @@ static MPP_RET vdpu_h264d_print_regs(H264dHalCtx_t *p_hal, HalRegDrvCtx_t *p_drv
INP_CHECK(ret, NULL == p_drv); INP_CHECK(ret, NULL == p_drv);
logctx = (LogCtx_t *)p_drv->log; logctx = (LogCtx_t *)p_drv->log;
if (LogEnable(logctx, LOG_LEVEL_INFO)) { if (LogEnable(logctx, LOG_LEVEL_INFO)) {
#if 0 #if 1
if (g_print_init_value) { if (g_print_init_value) {
g_print_init_value = 0; g_print_init_value = 0;
LogInfo((LogCtx_t *)p_drv->log, "---------------- VDPU REG START ------------------ "); LogInfo((LogCtx_t *)p_drv->log, "---------------- VDPU REG START ------------------ ");
@@ -95,8 +96,9 @@ static MPP_RET vdpu_h264d_print_regs(H264dHalCtx_t *p_hal, HalRegDrvCtx_t *p_drv
} }
#endif #endif
#if 0 #if 1
LogInfo(logctx, "[SET_REG] g_framecnt=%d, ---- DECODE BEING -------", p_hal->in_task->g_framecnt); {
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_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_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_INIT_QP ]);
@@ -171,11 +173,11 @@ static MPP_RET vdpu_h264d_print_regs(H264dHalCtx_t *p_hal, HalRegDrvCtx_t *p_drv
print_single_regs(p_drv, &p_drv->p_emt[VDPU_CH_8PIX_ILEAV_E]); 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_DEC_E]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_QTABLE_BASE]); 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->in_task->g_framecnt); 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_STAT]);
print_single_regs(p_drv, &p_drv->p_emt[VDPU_DEC_IRQ]); 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_PIC_INF]);
}
#endif #endif
} }
(void)i; (void)i;
@@ -291,6 +293,9 @@ static MPP_RET vdpu_adjust_input(H264dHalCtx_t *p_hal)
H264dVdpuDpb_t *old_dpb = priv->old_dpb[pp->curr_layer_id]; H264dVdpuDpb_t *old_dpb = priv->old_dpb[pp->curr_layer_id];
H264dVdpuDpb_t *ilt_dpb = priv->ilt_dpb; H264dVdpuDpb_t *ilt_dpb = priv->ilt_dpb;
assert(pp->curr_layer_id == 0);
//!< change input dxva into pdb structure //!< change input dxva into pdb structure
priv->new_dpb_cnt = 0; priv->new_dpb_cnt = 0;
priv->ilt_dpb_cnt = 0; priv->ilt_dpb_cnt = 0;
@@ -318,6 +323,7 @@ static MPP_RET vdpu_adjust_input(H264dHalCtx_t *p_hal)
} }
//!< inter-view frame flag //!< inter-view frame flag
if (new_dpb[i].is_ilt) { if (new_dpb[i].is_ilt) {
assert(0);
ilt_dpb[priv->ilt_dpb_cnt] = new_dpb[i]; ilt_dpb[priv->ilt_dpb_cnt] = new_dpb[i];
ilt_dpb[priv->ilt_dpb_cnt].valid = 1; ilt_dpb[priv->ilt_dpb_cnt].valid = 1;
priv->ilt_dpb_cnt++; priv->ilt_dpb_cnt++;
@@ -327,12 +333,35 @@ static MPP_RET vdpu_adjust_input(H264dHalCtx_t *p_hal)
} }
} }
} }
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");
//!< delete old dpb //!< delete old dpb
for (i = 0; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) { for (i = 0; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) {
if (priv->new_dpb[i].valid == 0) { find_flag = 0;
continue;
} if (old_dpb[i].valid) {
for (j = 0; j <= priv->new_dpb_cnt; j++) { 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; find_flag = (old_dpb[i].frame_num == new_dpb[j].frame_num) ? 1 : 0;
if (new_dpb[j].top_used) { if (new_dpb[j].top_used) {
find_flag = (old_dpb[i].TOP_POC == new_dpb[j].TOP_POC) ? find_flag : 0; find_flag = (old_dpb[i].TOP_POC == new_dpb[j].TOP_POC) ? find_flag : 0;
@@ -345,47 +374,49 @@ static MPP_RET vdpu_adjust_input(H264dHalCtx_t *p_hal)
break; break;
} }
} }
}
}
//!< not found //!< not found
if (find_flag == 0) { if (find_flag == 0) {
memset(&old_dpb[i], 0, sizeof(H264dVdpuDpb_t)); memset(&old_dpb[i], 0, sizeof(H264dVdpuDpb_t));
} }
} }
//!< add new dpb //!< add new dpb
for (j = 0; j <= priv->new_dpb_cnt; j++) { for (j = 0; j < MPP_ARRAY_ELEMS(pp->RefFrameList); j++) {
if (priv->new_dpb[j].have_same) { if ((new_dpb[j].valid == 0) || new_dpb[j].have_same) {
continue; continue;
} }
for (i = 0; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) { for (i = 0; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) {
if (old_dpb[i].valid) { if (old_dpb[i].valid == 0) {
continue;
}
old_dpb[i] = new_dpb[j]; old_dpb[i] = new_dpb[j];
break;
}
} }
} }
//!< re-fill reference dxva syntax //!< re-fill reference dxva syntax
pp->UsedForReferenceFlags = 0; pp->UsedForReferenceFlags = 0;
pp->NonExistingFrameFlags = 0; pp->NonExistingFrameFlags = 0;
memset(pp->RefFrameList, 0, sizeof(pp->RefFrameList)); memset(pp->RefFrameList, 0xff, sizeof(pp->RefFrameList));
memset(pp->FieldOrderCntList, 0, sizeof(pp->FieldOrderCntList)); memset(pp->FieldOrderCntList, 0, sizeof(pp->FieldOrderCntList));
memset(pp->LongTermPicNumList, 0, sizeof(pp->LongTermPicNumList)); memset(pp->LongTermPicNumList, 0, sizeof(pp->LongTermPicNumList));
memset(pp->FrameNumList, 0, sizeof(pp->FrameNumList)); memset(pp->FrameNumList, 0, sizeof(pp->FrameNumList));
for (i = 0; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) { for (i = 0; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) {
if (new_dpb[i].valid) { if (old_dpb[i].valid) {
pp->RefFrameList[i].Index7Bits = new_dpb[i].slot_index; pp->RefFrameList[i].Index7Bits = old_dpb[i].slot_index;
pp->RefFrameList[i].AssociatedFlag = new_dpb[i].is_long_term; pp->RefFrameList[i].AssociatedFlag = old_dpb[i].is_long_term;
pp->FieldOrderCntList[i][0] = new_dpb[i].TOP_POC; pp->FieldOrderCntList[i][0] = old_dpb[i].TOP_POC;
pp->FieldOrderCntList[i][1] = new_dpb[i].BOT_POC; pp->FieldOrderCntList[i][1] = old_dpb[i].BOT_POC;
pp->FrameNumList[i] = new_dpb[i].frame_num; pp->FrameNumList[i] = old_dpb[i].frame_num;
pp->LongTermPicNumList[i] = new_dpb[i].LongTermPicNum; pp->LongTermPicNumList[i] = old_dpb[i].LongTermPicNum;
pp->NonExistingFrameFlags |= new_dpb[i].non_exist_frame ? (1 << i) : 0; pp->NonExistingFrameFlags |= old_dpb[i].non_exist_frame ? (1 << i) : 0;
if (new_dpb[i].top_used) { //!< top_field if (old_dpb[i].top_used) { //!< top_field
pp->UsedForReferenceFlags |= 1 << (2 * i + 0); pp->UsedForReferenceFlags |= 1 << (2 * i + 0);
} }
if (new_dpb[i].bot_used) { //!< bot_field //if (old_dpb[i].bot_used) { //!< bot_field
pp->UsedForReferenceFlags |= 1 << (2 * i + 1); // pp->UsedForReferenceFlags |= 1 << (2 * i + 1);
} //}
} else { } else {
pp->RefFrameList[i].bPicEntry = 0xff; pp->RefFrameList[i].bPicEntry = 0xff;
pp->FieldOrderCntList[i][0] = 0; pp->FieldOrderCntList[i][0] = 0;
@@ -394,6 +425,15 @@ 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);
// }
//}
return MPP_OK; return MPP_OK;
} }
@@ -506,7 +546,7 @@ MPP_RET vdpu_h264d_gen_regs(void *hal, HalTaskInfo *task)
FunctionIn(p_hal->logctx.parr[RUN_HAL]); FunctionIn(p_hal->logctx.parr[RUN_HAL]);
LogTrace(p_hal->logctx.parr[RUN_HAL], "[Generate register begin]"); LogTrace(p_hal->logctx.parr[RUN_HAL], "[Generate register begin]");
FUN_CHECK(ret = vdpu_adjust_input(p_hal)); //FUN_CHECK(ret = vdpu_adjust_input(p_hal));
FUN_CHECK(ret = vdpu_set_pic_regs(hal, p_drv)); FUN_CHECK(ret = vdpu_set_pic_regs(hal, p_drv));
FUN_CHECK(ret = vdpu_set_vlc_regs(hal, p_drv)); FUN_CHECK(ret = vdpu_set_vlc_regs(hal, p_drv));
FUN_CHECK(ret = vdpu_set_ref_regs(hal, p_drv)); FUN_CHECK(ret = vdpu_set_ref_regs(hal, p_drv));
@@ -546,7 +586,7 @@ MPP_RET vdpu_h264d_start(void *hal, HalTaskInfo *task)
ret = MPP_ERR_VPUHW; ret = MPP_ERR_VPUHW;
mpp_err_f("H264 VDPU FlushRegs fail. \n"); mpp_err_f("H264 VDPU FlushRegs fail. \n");
} else { } else {
mpp_log("H264 VDPU FlushRegs success, frame_no=%d. \n", p_hal->iDecodedNum); mpp_log("H264 VDPU FlushRegs success, pid=%d, hal_frame_no=%d. \n", getpid(), p_hal->iDecodedNum);
} }
#endif #endif

2
mpp/mpp_frame.cpp
View File

@@ -156,6 +156,8 @@ MPP_FRAME_ACCESSORS(RK_U32, height)
MPP_FRAME_ACCESSORS(RK_U32, hor_stride) MPP_FRAME_ACCESSORS(RK_U32, hor_stride)
MPP_FRAME_ACCESSORS(RK_U32, ver_stride) MPP_FRAME_ACCESSORS(RK_U32, ver_stride)
MPP_FRAME_ACCESSORS(RK_U32, mode) MPP_FRAME_ACCESSORS(RK_U32, mode)
MPP_FRAME_ACCESSORS(RK_U32, display)
MPP_FRAME_ACCESSORS(RK_U32, viewid)
MPP_FRAME_ACCESSORS(RK_S64, pts) MPP_FRAME_ACCESSORS(RK_S64, pts)
MPP_FRAME_ACCESSORS(RK_S64, dts) MPP_FRAME_ACCESSORS(RK_S64, dts)
MPP_FRAME_ACCESSORS(RK_U32, eos) MPP_FRAME_ACCESSORS(RK_U32, eos)

11
mpp/mpp_frame_impl.h
View File

@@ -43,6 +43,17 @@ struct MppFrameImpl_t {
* 7 - deinterlaced paired field * 7 - deinterlaced paired field
*/ */
RK_U32 mode; RK_U32 mode;
/*
* current decoded frame whether to display
*
* 0 - display
* 1 - display
*/
RK_U32 display;
/*
* send decoded frame belong which view
*/
RK_U32 viewid;
/* /*
* pts - display time stamp * pts - display time stamp

2
mpp/test/h264d_rwfile.c
View File

@@ -514,7 +514,7 @@ static MPP_RET read_next_nalu(InputParams *p_in)
//{ //{
// g_debug_file0 = fopen("rk_debugfile_view0.txt", "wb"); // g_debug_file0 = fopen("rk_debugfile_view0.txt", "wb");
//} //}
//FPRINT(g_debug_file0, "g_nalu_cnt = %d, nal_unit_type = %d, nalu_size = %d\n", g_nalu_cnt2++, nal_unit_type, p_in->IO.nalubytes); //FPRINT(g_debug_file0, "[Read_NALU] g_nalu_cnt = %d, nal_unit_type = %d, nalu_size = %d\n", g_nalu_cnt2++, nal_unit_type, p_in->IO.nalubytes);
nalu_header_bytes = 1; nalu_header_bytes = 1;
if ((nal_unit_type == NALU_TYPE_PREFIX) || (nal_unit_type == NALU_TYPE_SLC_EXT)) { if ((nal_unit_type == NALU_TYPE_PREFIX) || (nal_unit_type == NALU_TYPE_SLC_EXT)) {

22
mpp/test/h264d_test.c
View File

@@ -44,13 +44,13 @@ static MPP_RET manual_set_env(void)
#if defined(_MSC_VER) #if defined(_MSC_VER)
mpp_env_set_u32("h264d_log_help", 1 ); mpp_env_set_u32("h264d_log_help", 1 );
mpp_env_set_u32("h264d_log_show", 1 ); mpp_env_set_u32("h264d_log_show", 1 );
mpp_env_set_u32("h264d_log_ctrl", 0x803B ); mpp_env_set_u32("h264d_log_ctrl", 0x800B );
mpp_env_set_u32("h264d_log_level", 5 ); mpp_env_set_u32("h264d_log_level", 5 );
mpp_env_set_u32("h264d_log_decframe", 0 ); mpp_env_set_u32("h264d_log_decframe", 0 );
mpp_env_set_u32("h264d_log_begframe", 0 ); mpp_env_set_u32("h264d_log_begframe", 0 );
mpp_env_set_u32("h264d_log_endframe", 0 ); mpp_env_set_u32("h264d_log_endframe", 0 );
mpp_env_set_u32("h264d_log_yuv", 0 ); mpp_env_set_u32("h264d_log_yuv", 0 );
mpp_env_set_u32("h264d_chg_org", 1 ); //!< 0:VDPU 1: RKVDEC mpp_env_set_u32("h264d_chg_org", 0 ); //!< 0:VDPU 1: RKVDEC
mpp_env_set_str("h264d_log_outpath", "F:/h264_log/allegro_dat" ); mpp_env_set_str("h264d_log_outpath", "F:/h264_log/allegro_dat" );
mpp_env_set_str("h264d_log_cmppath", "F:/h264_log_driver/trunk_dat" ); mpp_env_set_str("h264d_log_cmppath", "F:/h264_log_driver/trunk_dat" );
#endif #endif
@@ -135,7 +135,8 @@ int main(int argc, char **argv)
MppPacket pkt = NULL; MppPacket pkt = NULL;
MppFrame out_frame = NULL; MppFrame out_frame = NULL;
RK_U32 out_yuv_flag = 0; RK_U32 out_yuv_flag = 0;
MppBuffer dec_pkt_buf, dec_pic_buf; MppBuffer dec_pkt_buf = NULL;
MppBuffer dec_pic_buf = NULL;
MppBufferGroup mFrameGroup = NULL; MppBufferGroup mFrameGroup = NULL;
MppBufferGroup mStreamGroup = NULL; MppBufferGroup mStreamGroup = NULL;
@@ -187,12 +188,16 @@ int main(int argc, char **argv)
do { do {
//!< get one packet //!< get one packet
if (pkt == NULL) { if (pkt == NULL) {
if (pIn->is_eof || (pIn->iFrmdecoded >= pIn->iDecFrmNum)) { if (pIn->is_eof ||
(pIn->iDecFrmNum && (pIn->iFrmdecoded >= pIn->iDecFrmNum))) {
mpp_packet_init(&pkt, NULL, 0); mpp_packet_init(&pkt, NULL, 0);
mpp_packet_set_eos(pkt); 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);
} else { } else {
FUN_CHECK(ret = h264d_read_one_frame(pIn)); FUN_CHECK(ret = h264d_read_one_frame(pIn));
mpp_packet_init(&pkt, pIn->strm.pbuf, pIn->strm.strmbytes); 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);
} }
mpp_log("---- decoder, read_one_frame Frame_no = %d \n", pIn->iFrmdecoded++); mpp_log("---- decoder, read_one_frame Frame_no = %d \n", pIn->iFrmdecoded++);
} }
@@ -247,6 +252,7 @@ int main(int argc, char **argv)
} }
mpp_buf_slot_clr_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT); mpp_buf_slot_clr_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT);
mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.output, SLOT_HAL_OUTPUT); mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.output, SLOT_HAL_OUTPUT);
//!< write frame out //!< write frame out
mpp_env_get_u32("h264d_log_yuv", &out_yuv_flag, 0); mpp_env_get_u32("h264d_log_yuv", &out_yuv_flag, 0);
mpp_log("h264d_log_yuv=%d", out_yuv_flag); mpp_log("h264d_log_yuv=%d", out_yuv_flag);
@@ -262,7 +268,6 @@ int main(int argc, char **argv)
framebuf = mpp_frame_get_buffer(out_frame); framebuf = mpp_frame_get_buffer(out_frame);
ptr = mpp_buffer_get_ptr(framebuf); ptr = mpp_buffer_get_ptr(framebuf);
if (out_yuv_flag && pIn->fp_yuv_data) { if (out_yuv_flag && pIn->fp_yuv_data) {
fwrite(ptr, 1, stride_w * stride_h * 3 / 2, pIn->fp_yuv_data); fwrite(ptr, 1, stride_w * stride_h * 3 / 2, pIn->fp_yuv_data);
fflush(pIn->fp_yuv_data); fflush(pIn->fp_yuv_data);
} }
@@ -282,10 +287,7 @@ int main(int argc, char **argv)
memset(task->dec.refer, -1, sizeof(task->dec.refer)); memset(task->dec.refer, -1, sizeof(task->dec.refer));
task->dec.input = -1; task->dec.input = -1;
} }
if (end_of_flag) { } while (!end_of_flag);
break;
}
} while (!pIn->iDecFrmNum || (pIn->iFrmdecoded < pIn->iDecFrmNum + 2));
//FPRINT(g_debug_file1, "[FLUSH] flush begin \n"); //FPRINT(g_debug_file1, "[FLUSH] flush begin \n");
//!< flush dpb and send to display //!< flush dpb and send to display
@@ -304,7 +306,7 @@ int main(int argc, char **argv)
__FAILED: __FAILED:
decoder_deinit(pApi); decoder_deinit(pApi);
h264d_free_frame_buffer(pIn); h264d_free_frame_buffer(pIn);
h264d_write_fpga_data(pIn); //!< for fpga debug //h264d_write_fpga_data(pIn); //!< for fpga debug
h264d_close_files(pIn); h264d_close_files(pIn);
MPP_FREE(pIn); MPP_FREE(pIn);
MPP_FREE(pApi); MPP_FREE(pApi);