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

[vpu_api] add VPU_FRAME_ERR enums

Browse Source 
[mpp_frame] add error info functions
[h264d]     add callback function;
            update SEI function;
            DivX && YUV444 unsupport return

git-svn-id: https://10.10.10.66:8443/svn/MediaProcessPlatform/trunk/mpp@505 6e48237b-75ef-9749-8fc9-41990f28c85a
This commit is contained in:
DingWei
2015-12-09 21:28:43 +00:00
parent a5450d6fea
commit 21230b11bc
12 changed files with 145 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
inc/mpp_frame.h
View File

@@ -174,7 +174,8 @@ 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);
void mpp_frame_set_dts(MppFrame frame, RK_S64 dts); void mpp_frame_set_dts(MppFrame frame, RK_S64 dts);
RK_U32 mpp_frame_get_errinfo(const MppFrame frame);
void mpp_frame_set_errinfo(MppFrame frame, RK_U32 errinfo);
/* /*
* flow control parmeter * flow control parmeter
*/ */

6
inc/vpu_api.h
View File

@@ -205,6 +205,12 @@ typedef enum VPU_API_ERR {
VPU_API_ERR_BUTT, VPU_API_ERR_BUTT,
} VPU_API_ERR; } VPU_API_ERR;
typedef enum VPU_FRAME_ERR {
VPU_FRAME_ERR_UNKNOW = 0x0001,
VPU_FRAME_ERR_UNSUPPORT = 0x0002,
} VPU_FRAME_ERR;
typedef struct EncParameter { typedef struct EncParameter {
RK_S32 width; RK_S32 width;
RK_S32 height; RK_S32 height;

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

@@ -23,6 +23,8 @@
#include "mpp_packet_impl.h" #include "mpp_packet_impl.h"
#include "mpp_mem.h" #include "mpp_mem.h"
#include "vpu_api.h"
#include "h264d_log.h" #include "h264d_log.h"
#include "h264d_api.h" #include "h264d_api.h"
#include "h264d_global.h" #include "h264d_global.h"
@@ -372,11 +374,14 @@ static MPP_RET init_dec_ctx(H264_DecCtx_t *p_Dec)
//!< malloc mpp packet //!< malloc mpp packet
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);
//!< memset error context
memset(&p_Dec->err_ctx, 0, sizeof(H264dErrCtx_t));
//!< set Dec support decoder method //!< set Dec support decoder method
p_Dec->spt_decode_mtds = MPP_DEC_BY_FRAME; 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;
p_Dec->last_frame_slot_idx = -1;
__RETURN: __RETURN:
return ret = MPP_OK; return ret = MPP_OK;
@@ -405,6 +410,7 @@ static void get_pkt_timestamp(H264dCurStream_t *p_strm, H264dInputCtx_t *p_Inp,
} }
} }
#endif #endif
/*! /*!
*********************************************************************** ***********************************************************************
* \brief * \brief
@@ -636,7 +642,7 @@ MPP_RET h264d_prepare(void *decoder, MppPacket pkt, HalDecTask *task)
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]); FunctionIn(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);
if (p_Dec->p_Inp->has_get_eos || p_Dec->error_flag) { if (p_Dec->p_Inp->has_get_eos || p_Dec->err_ctx.err_flag) {
((MppPacketImpl *)pkt)->length = 0; ((MppPacketImpl *)pkt)->length = 0;
goto __RETURN; goto __RETURN;
} }
@@ -742,42 +748,21 @@ 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_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);
// 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);
// if (p_Dec->p_Inp->is_nalff && in_task->flags.eos) {
//h264d_flush(decoder);
//goto __RETURN;
// }
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]");
in_task->valid = 1; // register valid flag in_task->valid = 1; // register valid flag
in_task->syntax.number = p_Dec->dxva_ctx->syn.num; in_task->syntax.number = p_Dec->dxva_ctx->syn.num;
in_task->syntax.data = (void *)p_Dec->dxva_ctx->syn.buf; in_task->syntax.data = (void *)p_Dec->dxva_ctx->syn.buf;
FUN_CHECK(ret = update_dpb(p_Dec)); FUN_CHECK(ret = update_dpb(p_Dec));
//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*/);
//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);
if (in_task->flags.eos) { if (in_task->flags.eos) {
h264d_flush(decoder); h264d_flush(decoder);
} }
p_Dec->p_Vid->g_framecnt++; p_Dec->p_Vid->g_framecnt++;
} }
__RETURN: __RETURN:
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]); FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
return ret = MPP_OK; return ret = MPP_OK;
@@ -791,11 +776,41 @@ __FAILED:
* callback * callback
*********************************************************************** ***********************************************************************
*/ */
MPP_RET h264d_callback(void *decoder, void *err_info) MPP_RET h264d_callback(void *decoder, void *err_info)
{ {
(void) decoder; MPP_RET ret = MPP_ERR_UNKNOW;
(void) err_info; MppFrame m_frame;
return MPP_OK; H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
H264dErrCtx_t *ctx = (H264dErrCtx_t *)err_info;
INP_CHECK(ret, !decoder && !err_info);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
ctx->err_flag |= VPU_FRAME_ERR_UNSUPPORT;
if(ctx->err_flag & VPU_FRAME_ERR_UNSUPPORT) {
h264d_reset(decoder);
}
if (p_Dec->last_frame_slot_idx < 0) {
mpp_frame_init(&m_frame);
mpp_slots_get_prop(p_Dec->frame_slots, SLOTS_FRAME_INFO, m_frame);
mpp_buf_slot_get_unused(p_Dec->frame_slots, &p_Dec->last_frame_slot_idx);
mpp_buf_slot_set_prop(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, SLOT_FRAME, m_frame);
mpp_buf_slot_set_flag(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, SLOT_QUEUE_USE);
mpp_buf_slot_enqueue(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, QUEUE_DISPLAY);
mpp_buf_slot_clr_flag(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, SLOT_HAL_OUTPUT);
mpp_buf_slot_clr_flag(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, SLOT_CODEC_USE);
mpp_frame_deinit(&m_frame);
}
mpp_buf_slot_get_prop(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, SLOT_FRAME_PTR, &m_frame);
if (m_frame) {
mpp_frame_set_errinfo(m_frame, ctx->err_flag);
}
__RETURN:
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
return ret = MPP_OK;
} }
/*! /*!
*********************************************************************** ***********************************************************************

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

@@ -1746,21 +1746,24 @@ RK_U32 get_filed_dpb_combine_flag(H264_DpbBuf_t *p_Dpb, H264_StorePic_t *p)
MPP_RET init_dpb(H264dVideoCtx_t *p_Vid, H264_DpbBuf_t *p_Dpb, RK_S32 type) // type=1 AVC type=2 MVC MPP_RET init_dpb(H264dVideoCtx_t *p_Vid, H264_DpbBuf_t *p_Dpb, RK_S32 type) // type=1 AVC type=2 MVC
{ {
RK_U32 i = 0; RK_U32 i = 0;
RK_S32 PicSizeInMbs = 0;
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
H264_SPS_t *active_sps = p_Vid->active_sps; H264_SPS_t *active_sps = p_Vid->active_sps;
if(!active_sps){
ret = MPP_NOK;
goto __FAILED;
}
p_Dpb->p_Vid = p_Vid; p_Dpb->p_Vid = p_Vid;
if (p_Dpb->init_done) { if (p_Dpb->init_done) {
free_dpb(p_Dpb); free_dpb(p_Dpb);
} }
p_Dpb->size = getDpbSize(p_Vid, active_sps) + (type == 2 ? 0 : 1); p_Dpb->size = getDpbSize(p_Vid, active_sps) + (type == 2 ? 0 : 1);
p_Dpb->num_ref_frames = active_sps->max_num_ref_frames; p_Dpb->num_ref_frames = active_sps->max_num_ref_frames;
if (active_sps->max_dec_frame_buffering < active_sps->max_num_ref_frames) { //if (active_sps->max_dec_frame_buffering < active_sps->max_num_ref_frames) {
//H264D_LOG("DPB size at specified level is smaller than reference frames"); //H264D_LOG("DPB size at specified level is smaller than reference frames");
//LogError(runlog, "DPB size at specified level is smaller than reference frames"); //LogError(runlog, "DPB size at specified level is smaller than reference frames");
//goto __FAILED; //goto __FAILED;
} //}
p_Dpb->used_size = 0; p_Dpb->used_size = 0;
p_Dpb->last_picture = NULL; p_Dpb->last_picture = NULL;
p_Dpb->ref_frames_in_buffer = 0; p_Dpb->ref_frames_in_buffer = 0;
@@ -1794,7 +1797,6 @@ MPP_RET init_dpb(H264dVideoCtx_t *p_Vid, H264_DpbBuf_t *p_Dpb, RK_S32 type) //
} }
//!< allocate a dummy storable picture //!< allocate a dummy storable picture
if (!p_Vid->no_ref_pic) { if (!p_Vid->no_ref_pic) {
PicSizeInMbs = (p_Vid->active_sps->pic_height_in_map_units_minus1 + 1) * (p_Vid->active_sps->pic_width_in_mbs_minus1 + 1);
p_Vid->no_ref_pic = alloc_storable_picture(p_Vid, FRAME); p_Vid->no_ref_pic = alloc_storable_picture(p_Vid, FRAME);
MEM_CHECK(ret, p_Vid->no_ref_pic); MEM_CHECK(ret, p_Vid->no_ref_pic);
p_Vid->no_ref_pic->top_field = p_Vid->no_ref_pic; p_Vid->no_ref_pic->top_field = p_Vid->no_ref_pic;
@@ -1805,11 +1807,9 @@ MPP_RET init_dpb(H264dVideoCtx_t *p_Vid, H264_DpbBuf_t *p_Dpb, RK_S32 type) //
p_Dpb->last_output_view_id = -1; p_Dpb->last_output_view_id = -1;
p_Vid->last_has_mmco_5 = 0; p_Vid->last_has_mmco_5 = 0;
p_Dpb->init_done = 1; p_Dpb->init_done = 1;
(void)PicSizeInMbs;
return ret = MPP_OK; return ret = MPP_OK;
__FAILED: __FAILED:
ASSERT(0);
return ret; return ret;
} }
/*! /*!

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

@@ -693,6 +693,8 @@ typedef struct h264_sei_t {
//---- follow is used in other parts //---- follow is used in other parts
RK_S32 mvc_scalable_nesting_flag; RK_S32 mvc_scalable_nesting_flag;
RK_S32 seq_parameter_set_id; RK_S32 seq_parameter_set_id;
struct h264_dec_ctx_t *p_Dec;
} H264_SEI_t; } H264_SEI_t;
//!< SLICE //!< SLICE
@@ -820,9 +822,6 @@ 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 {
struct h264_dec_ctx_t *p_Dec; struct h264_dec_ctx_t *p_Dec;
@@ -1045,6 +1044,13 @@ typedef enum slice_state_type {
} SLICE_STATUS; } SLICE_STATUS;
//!< decoder video parameter
typedef struct h264_err_ctx_t {
RK_U32 err_flag;
void *data;
RK_U32 length;
}H264dErrCtx_t;
//!< decoder video parameter //!< decoder video parameter
typedef struct h264_dec_ctx_t { typedef struct h264_dec_ctx_t {
@@ -1079,8 +1085,7 @@ typedef struct h264_dec_ctx_t {
RK_U32 task_eos; RK_U32 task_eos;
HalDecTask *in_task; HalDecTask *in_task;
RK_S32 last_frame_slot_idx; RK_S32 last_frame_slot_idx;
struct h264_err_ctx_t err_ctx;
RK_U32 error_flag;
} H264_DecCtx_t; } H264_DecCtx_t;

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

@@ -157,9 +157,9 @@ static MPP_RET parser_nalu_header(H264_SLICE_t *currSlice)
ASSERT(cur_nal->forbidden_bit == 0); ASSERT(cur_nal->forbidden_bit == 0);
READ_BITS(p_bitctx, 2, (RK_S32 *)&cur_nal->nal_reference_idc, "nal_ref_idc"); READ_BITS(p_bitctx, 2, (RK_S32 *)&cur_nal->nal_reference_idc, "nal_ref_idc");
READ_BITS(p_bitctx, 5, (RK_S32 *)&cur_nal->nalu_type, "nalu_type"); READ_BITS(p_bitctx, 5, (RK_S32 *)&cur_nal->nalu_type, "nalu_type");
if (g_nalu_cnt0 == 2384) { //if (g_nalu_cnt0 == 2384) {
g_nalu_cnt0 = g_nalu_cnt0; // g_nalu_cnt0 = g_nalu_cnt0;
} //}
cur_nal->ualu_header_bytes = 1; cur_nal->ualu_header_bytes = 1;
currSlice->svc_extension_flag = -1; //!< initialize to -1 currSlice->svc_extension_flag = -1; //!< initialize to -1
@@ -189,9 +189,10 @@ static MPP_RET parser_nalu_header(H264_SLICE_t *currSlice)
//FPRINT(logctx->parr[LOG_READ_NALU]->fp, "g_nalu_cnt=%d, nalu_type=%d, len=%d \n", g_nalu_cnt++, cur_nal->nalu_type, cur_nal->sodb_len); //FPRINT(logctx->parr[LOG_READ_NALU]->fp, "g_nalu_cnt=%d, nalu_type=%d, len=%d \n", g_nalu_cnt++, cur_nal->nalu_type, cur_nal->sodb_len);
} }
cur_nal->ualu_header_bytes += 3; cur_nal->ualu_header_bytes += 3;
} else { }
//else {
//FPRINT(logctx->parr[LOG_READ_NALU]->fp, "g_nalu_cnt=%d, nalu_type=%d, len=%d \n", g_nalu_cnt++, cur_nal->nalu_type, cur_nal->sodb_len); //FPRINT(logctx->parr[LOG_READ_NALU]->fp, "g_nalu_cnt=%d, nalu_type=%d, len=%d \n", g_nalu_cnt++, cur_nal->nalu_type, cur_nal->sodb_len);
} //}
mpp_set_bitread_ctx(p_bitctx, (cur_nal->sodb_buf + cur_nal->ualu_header_bytes), (cur_nal->sodb_len - cur_nal->ualu_header_bytes)); // reset mpp_set_bitread_ctx(p_bitctx, (cur_nal->sodb_buf + cur_nal->ualu_header_bytes), (cur_nal->sodb_len - cur_nal->ualu_header_bytes)); // reset
p_Cur->p_Dec->nalu_ret = StartofNalu; p_Cur->p_Dec->nalu_ret = StartofNalu;
@@ -242,7 +243,7 @@ static MPP_RET parser_one_nalu(H264_SLICE_t *currSlice)
LogTrace(runlog, "nalu_type=SUB_SPS"); LogTrace(runlog, "nalu_type=SUB_SPS");
break; break;
case NALU_TYPE_SEI: case NALU_TYPE_SEI:
//FUN_CHECK(ret = process_sei(currSlice)); FUN_CHECK(ret = process_sei(currSlice));
LogTrace(runlog, "nalu_type=SEI"); LogTrace(runlog, "nalu_type=SEI");
currSlice->p_Dec->nalu_ret = NALU_SEI; currSlice->p_Dec->nalu_ret = NALU_SEI;
break; break;
@@ -630,7 +631,7 @@ MPP_RET parse_prepare_fast(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
if (!p_Inp->in_length) { if (!p_Inp->in_length) {
p_strm->nalu_offset = 0; p_strm->nalu_offset = 0;
p_Dec->nalu_ret = HaveNoStream; p_Dec->nalu_ret = HaveNoStream;
p_strm->endcode_found = 1; p_strm->endcode_found = 1;
p_Dec->nalu_ret = EndOfNalu; p_Dec->nalu_ret = EndOfNalu;
FUN_CHECK(ret = store_cur_nalu(&p_Dec->p_Cur->strm, p_Dec->dxva_ctx)); FUN_CHECK(ret = store_cur_nalu(&p_Dec->p_Cur->strm, p_Dec->dxva_ctx));
@@ -640,6 +641,7 @@ MPP_RET parse_prepare_fast(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
p_Cur->p_Inp->task_valid = 1; p_Cur->p_Inp->task_valid = 1;
p_Cur->p_Dec->is_new_frame = 0; p_Cur->p_Dec->is_new_frame = 0;
reset_nalu(p_strm); reset_nalu(p_strm);
p_strm->startcode_found = 0;
p_Cur->last_dts = p_Cur->curr_dts; p_Cur->last_dts = p_Cur->curr_dts;
p_Cur->last_pts = p_Cur->curr_pts; p_Cur->last_pts = p_Cur->curr_pts;
@@ -867,7 +869,6 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
case SliceSTATE_ResetSlice: case SliceSTATE_ResetSlice:
reset_slice(p_Dec->p_Vid); reset_slice(p_Dec->p_Vid);
p_Dec->next_state = SliceSTATE_ReadNalu; p_Dec->next_state = SliceSTATE_ReadNalu;
//H264D_LOG( "SliceSTATE_ResetSlice");
break; break;
case SliceSTATE_ReadNalu: case SliceSTATE_ReadNalu:
p_head = (H264dNaluHead_t *)p_curdata; p_head = (H264dNaluHead_t *)p_curdata;
@@ -883,7 +884,6 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
p_Dec->nalu_ret = EndOfNalu; p_Dec->nalu_ret = EndOfNalu;
p_Dec->next_state = SliceSTATE_ParseNalu; p_Dec->next_state = SliceSTATE_ParseNalu;
} }
//H264D_LOG( "SliceSTATE_ReadNalu");
break; break;
case SliceSTATE_ParseNalu: case SliceSTATE_ParseNalu:
(ret = parser_one_nalu(&p_Dec->p_Cur->slice)); (ret = parser_one_nalu(&p_Dec->p_Cur->slice));
@@ -894,30 +894,30 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
} else { } else {
p_Dec->next_state = SliceSTATE_ReadNalu; p_Dec->next_state = SliceSTATE_ReadNalu;
} }
//H264D_LOG("SliceSTATE_ParseNalu");
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; p_Dec->next_state = SliceSTATE_GetSliceData;
//H264D_LOG("SliceSTATE_InitPicture");
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; p_Dec->next_state = SliceSTATE_ResetSlice;
//H264D_LOG("SliceSTATE_GetSliceData");
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; p_Dec->next_state = SliceSTATE_ReadNalu;
//H264D_LOG("SliceSTATE_RegisterOneFrame");
break; break;
default: default:
ret = MPP_NOK; ret = MPP_NOK;
goto __FAILED; break;
} }
if (p_Dec->err_ctx.err_flag) {
h264d_callback((void *)p_Dec, (void*)&p_Dec->err_ctx);
goto __FAILED;
}
} }
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]); FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
//__RETURN: //__RETURN:

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

@@ -20,6 +20,8 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include "vpu_api.h"
#include "h264d_log.h" #include "h264d_log.h"
#include "h264d_sps.h" #include "h264d_sps.h"
#include "h264d_sei.h" #include "h264d_sei.h"
@@ -66,28 +68,37 @@ static MPP_RET interpret_user_data_unregistered_info(RK_U8 *payload, RK_S32 size
{ {
char *pdata = NULL; char *pdata = NULL;
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
H264D_LOG("size=%d",size);
ASSERT(size >= 16); ASSERT(size >= 16);
pdata = strupr((char *)payload);
sei_msg->user_data_DivX_flag = strstr(pdata, "DIVX") ? 1 : 0;
H264D_LOG("DivX is not supported. \n");
#if 0 #if 0
RK_U32 offset = 0; {
RK_U8 payload_byte; RK_U32 offset = 0;
mpp_log("User data unregistered SEI message\n"); RK_U8 payload_byte;
mpp_log("uuid_iso_11578 = 0x"); mpp_log("User data unregistered SEI message\n");
for (offset = 0; offset < 16; offset++) { mpp_log("uuid_iso_11578 = 0x");
mpp_log("%02x",payload[offset]); for (offset = 0; offset < 16; offset++) {
} mpp_log("%02x",payload[offset]);
while (offset < size) { }
payload_byte = payload[offset]; while (offset < size) {
offset++; payload_byte = payload[offset];
mpp_log("Unreg data payload_byte = %d\n", payload_byte); offset++;
mpp_log("Unreg data payload_byte = %02x\n", payload_byte);
}
} }
#endif #endif
sei_msg->user_data_DivX_flag = strstr(strupr((char *)&payload[16]), "DIVX") ? 1 : 0;
if (sei_msg->user_data_DivX_flag) {
H264D_ERR("DivX is not supported. \n");
sei_msg->p_Dec->err_ctx.err_flag |= VPU_FRAME_ERR_UNSUPPORT;
ret = MPP_NOK;
goto __FAILED;
}
return ret = MPP_OK; return ret = MPP_OK;
__FAILED:
return ret;
} }
static void interpret_pan_scan_rect_info() static void interpret_pan_scan_rect_info()
@@ -176,7 +187,7 @@ __BITREAD_ERR:
} }
static MPP_RET interpret_mvc_scalable_nesting_info(RK_U8 *payload, RK_S32 size, BitReadCtx_t *p_bitctx, H264_SEI_t *sei_msg) static MPP_RET interpret_mvc_scalable_nesting_info(RK_U8 *payload, RK_S32 size, BitReadCtx_t *p_bitctx)
{ {
RK_S32 i; RK_S32 i;
RK_U32 operation_point_flag; RK_U32 operation_point_flag;
@@ -207,8 +218,7 @@ static MPP_RET interpret_mvc_scalable_nesting_info(RK_U8 *payload, RK_S32 size,
READ_BITS(p_strm, 3, &sei_op_temporal_id, "sei_op_temporal_id"); READ_BITS(p_strm, 3, &sei_op_temporal_id, "sei_op_temporal_id");
} }
p_bitctx->used_bits = p_strm->used_bits; p_bitctx->used_bits = p_strm->used_bits;
sei_msg->mvc_scalable_nesting_flag = 1;
return ret = MPP_OK; return ret = MPP_OK;
__BITREAD_ERR: __BITREAD_ERR:
ret = p_bitctx->ret; ret = p_bitctx->ret;
@@ -246,15 +256,30 @@ static void interpret_reserved_info(RK_U8 *payload, RK_S32 size, BitReadCtx_t *p
(void)payload_byte; (void)payload_byte;
} }
static MPP_RET parserSEI(BitReadCtx_t *p_bitctx, H264_SEI_t *sei_msg, RK_U8 *msg) static MPP_RET parserSEI(H264_SLICE_t *cur_slice, BitReadCtx_t *p_bitctx, H264_SEI_t *sei_msg, RK_U8 *msg)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
//!< sei_payload( type, size ); H264dVideoCtx_t *p_Vid = cur_slice->p_Vid;
H264D_LOG("[SEI_TYPE] type=%d \n", sei_msg->type);
H264D_LOG("[SEI_TYPE] type=%d \n", sei_msg->type);
switch (sei_msg->type) { switch (sei_msg->type) {
case SEI_BUFFERING_PERIOD: case SEI_BUFFERING_PERIOD:
FUN_CHECK(ret = interpret_buffering_period_info(msg, sei_msg->payload_size, p_bitctx, sei_msg)); FUN_CHECK(ret = interpret_buffering_period_info(msg, sei_msg->payload_size, p_bitctx, sei_msg));
{
H264_SPS_t *sps = NULL;
H264_subSPS_t *subset_sps = NULL;
if (sei_msg->mvc_scalable_nesting_flag) {
p_Vid->active_mvc_sps_flag = 1;
sps = NULL;
subset_sps = &p_Vid->subspsSet[sei_msg->seq_parameter_set_id];
} else {
p_Vid->active_mvc_sps_flag = 0;
sps = &p_Vid->spsSet[sei_msg->seq_parameter_set_id];
subset_sps = NULL;
}
p_Vid->exit_picture_flag = 1;
FUN_CHECK(ret = activate_sps(p_Vid, sps, subset_sps));
}
break; break;
case SEI_PIC_TIMING: case SEI_PIC_TIMING:
interpret_picture_timing_info(); interpret_picture_timing_info();
@@ -269,7 +294,7 @@ static MPP_RET parserSEI(BitReadCtx_t *p_bitctx, H264_SEI_t *sei_msg, RK_U8 *msg
interpret_user_data_registered_itu_t_t35_info(); interpret_user_data_registered_itu_t_t35_info();
break; break;
case SEI_USER_DATA_UNREGISTERED: case SEI_USER_DATA_UNREGISTERED:
interpret_user_data_unregistered_info(msg, sei_msg->payload_size, sei_msg); FUN_CHECK(ret = interpret_user_data_unregistered_info(msg, sei_msg->payload_size, sei_msg));
break; break;
case SEI_RECOVERY_POINT: case SEI_RECOVERY_POINT:
FUN_CHECK(ret = interpret_recovery_point_info(msg, sei_msg->payload_size, p_bitctx, sei_msg)); FUN_CHECK(ret = interpret_recovery_point_info(msg, sei_msg->payload_size, p_bitctx, sei_msg));
@@ -328,7 +353,8 @@ static MPP_RET parserSEI(BitReadCtx_t *p_bitctx, H264_SEI_t *sei_msg, RK_U8 *msg
interpret_frame_packing_arrangement_info(); interpret_frame_packing_arrangement_info();
break; break;
case SEI_MVC_SCALABLE_NESTING: case SEI_MVC_SCALABLE_NESTING:
FUN_CHECK(ret = interpret_mvc_scalable_nesting_info(msg, sei_msg->payload_size, p_bitctx, sei_msg)); FUN_CHECK(ret = interpret_mvc_scalable_nesting_info(msg, sei_msg->payload_size, p_bitctx));
sei_msg->mvc_scalable_nesting_flag = 1;
break; break;
case SEI_VIEW_SCALABILITY_INFO: case SEI_VIEW_SCALABILITY_INFO:
interpret_mvc_scalability_info(); interpret_mvc_scalability_info();
@@ -342,40 +368,6 @@ static MPP_RET parserSEI(BitReadCtx_t *p_bitctx, H264_SEI_t *sei_msg, RK_U8 *msg
__FAILED: __FAILED:
return ret; return ret;
} }
static MPP_RET analysisSEI(H264_SLICE_t *cur_slice)
{
H264_SPS_t *sps = NULL;
H264_subSPS_t *subset_sps = NULL;
MPP_RET ret = MPP_ERR_UNKNOW;
H264dVideoCtx_t *p_Vid = cur_slice->p_Vid;
H264_SEI_t *sei_msg = &cur_slice->p_Cur->sei;
switch (sei_msg->type) { // sei_payload( type, size )
case SEI_BUFFERING_PERIOD:
if (sei_msg->mvc_scalable_nesting_flag) {
p_Vid->active_mvc_sps_flag = 1;
sps = NULL;
subset_sps = &p_Vid->subspsSet[sei_msg->seq_parameter_set_id];
} else {
p_Vid->active_mvc_sps_flag = 0;
sps = &p_Vid->spsSet[sei_msg->seq_parameter_set_id];
subset_sps = NULL;
}
p_Vid->exit_picture_flag = 1;
FUN_CHECK(ret = activate_sps(p_Vid, sps, subset_sps));
break;
default:
break;
}
return ret = MPP_OK;
__FAILED:
return ret;
}
/*! /*!
*********************************************************************** ***********************************************************************
* \brief * \brief
@@ -394,7 +386,7 @@ MPP_RET process_sei(H264_SLICE_t *currSlice)
FunctionIn(currSlice->logctx->parr[RUN_PARSE]); FunctionIn(currSlice->logctx->parr[RUN_PARSE]);
memset(sei_msg, 0, sizeof(*sei_msg)); memset(sei_msg, 0, sizeof(*sei_msg));
sei_msg->mvc_scalable_nesting_flag = 0; //init to false sei_msg->mvc_scalable_nesting_flag = 0; //init to false
sei_msg->p_Dec = currSlice->p_Dec;
do { do {
sei_msg->type = 0; sei_msg->type = 0;
READ_BITS(p_bitctx, 8, &tmp_byte, "tmp_byte"); READ_BITS(p_bitctx, 8, &tmp_byte, "tmp_byte");
@@ -413,9 +405,7 @@ MPP_RET process_sei(H264_SLICE_t *currSlice)
sei_msg->payload_size += tmp_byte; // this is the last byte sei_msg->payload_size += tmp_byte; // this is the last byte
//--- read sei info //--- read sei info
FUN_CHECK(ret = parserSEI(p_bitctx, sei_msg, p_bitctx->data_)); FUN_CHECK(ret = parserSEI(currSlice, p_bitctx, sei_msg, p_bitctx->data_));
//--- analysis sei info
FUN_CHECK(ret = analysisSEI(currSlice));
//--- set offset to read next sei nal //--- set offset to read next sei nal
if (SEI_MVC_SCALABLE_NESTING == sei_msg->type) { if (SEI_MVC_SCALABLE_NESTING == sei_msg->type) {
sei_msg->payload_size = ((p_bitctx->used_bits + 0x07) >> 3); sei_msg->payload_size = ((p_bitctx->used_bits + 0x07) >> 3);
@@ -432,6 +422,5 @@ MPP_RET process_sei(H264_SLICE_t *currSlice)
__BITREAD_ERR: __BITREAD_ERR:
ret = p_bitctx->ret; ret = p_bitctx->ret;
__FAILED: __FAILED:
ASSERT(0);
return ret; return ret;
} }

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

@@ -21,6 +21,8 @@
#include "mpp_mem.h" #include "mpp_mem.h"
#include "vpu_api.h"
#include "h264d_log.h" #include "h264d_log.h"
#include "h264d_sps.h" #include "h264d_sps.h"
#include "h264d_scalist.h" #include "h264d_scalist.h"
@@ -179,7 +181,7 @@ static MPP_RET parser_sps(BitReadCtx_t *p_bitctx, H264_SPS_t *cur_sps, H264_DecC
ASSERT(cur_sps->chroma_format_idc < 4); ASSERT(cur_sps->chroma_format_idc < 4);
if (cur_sps->chroma_format_idc >= 3) { if (cur_sps->chroma_format_idc >= 3) {
H264D_ERR("ERROR: Not support chroma_format_idc=%d.", cur_sps->chroma_format_idc); H264D_ERR("ERROR: Not support chroma_format_idc=%d.", cur_sps->chroma_format_idc);
p_Dec->error_flag = 1; p_Dec->err_ctx.err_flag |= VPU_FRAME_ERR_UNSUPPORT;
goto __FAILED; goto __FAILED;
} }
//if (cur_sps->chroma_format_idc == 3) { //if (cur_sps->chroma_format_idc == 3) {

14
mpp/codec/mpp_dec.cpp
View File

@@ -282,10 +282,11 @@ static MPP_RET try_proc_dec_task(Mpp *mpp, DecTask *task)
} }
} }
if (task_dec->flags.eos && task_dec->valid == 0) { //if (task_dec->flags.eos && task_dec->valid == 0)
{
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 discard; RK_U32 discard;
mpp_buf_slot_get_prop(frame_slots, index, SLOT_FRAME, &frame); mpp_buf_slot_get_prop(frame_slots, index, SLOT_FRAME, &frame);
@@ -650,31 +651,26 @@ void *mpp_dec_hal_thread(void *data)
if (index >= 0) if (index >= 0)
mpp_buf_slot_clr_flag(frame_slots, index, SLOT_HAL_INPUT); mpp_buf_slot_clr_flag(frame_slots, index, SLOT_HAL_INPUT);
} }
//mpp_log("--- task_dec->flags.eos=%d, out_frame=%d ---\n", task_dec->flags.eos, g_hal_out_frame);
if (task_dec->flags.eos) { if (task_dec->flags.eos) {
//mpp_log("--- mpp_dec flush ---\n");
mpp_dec_flush(dec); mpp_dec_flush(dec);
} }
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 discard; RK_U32 discard;
mpp_buf_slot_get_prop(frame_slots, index, SLOT_FRAME, &frame); mpp_buf_slot_get_prop(frame_slots, index, SLOT_FRAME, &frame);
discard = mpp_frame_get_discard(frame); discard = mpp_frame_get_discard(frame);
if (!dec->reset_flag && !discard) { if (!dec->reset_flag && !discard) {
mpp_put_frame(mpp, frame); mpp_put_frame(mpp, frame);
//mpp_log("discard=%d \n",0);
} else { } else {
mpp_frame_deinit(&frame); mpp_frame_deinit(&frame);
//mpp_log("discard=%d \n",1);
} }
mpp_buf_slot_clr_flag(frame_slots, index, SLOT_QUEUE_USE); mpp_buf_slot_clr_flag(frame_slots, index, SLOT_QUEUE_USE);
} }
} }
} }
//mpp_log("------- hal thread end ----------- \n");
return NULL; return NULL;
} }

4
mpp/legacy/vpu_api_legacy.cpp
View File

@@ -134,9 +134,11 @@ RK_S32 VpuApi:: decode_getoutframe(DecoderOut_t *aDecOut)
vframe->DisplayHeight = mpp_frame_get_height(mframe); vframe->DisplayHeight = mpp_frame_get_height(mframe);
vframe->FrameWidth = mpp_frame_get_hor_stride(mframe); vframe->FrameWidth = mpp_frame_get_hor_stride(mframe);
vframe->FrameHeight = mpp_frame_get_ver_stride(mframe); vframe->FrameHeight = mpp_frame_get_ver_stride(mframe);
vframe->ErrorInfo = mpp_frame_get_errinfo(mframe);
//mpp_err("vframe->ErrorInfo = %08x \n", vframe->ErrorInfo);
pts = mpp_frame_get_pts(mframe); pts = mpp_frame_get_pts(mframe);
aDecOut->timeUs = pts; aDecOut->timeUs = pts;
// mpp_err("get one frame timeUs %lld",aDecOut->timeUs); //mpp_err("get one frame timeUs %lld, errinfo=%08x",aDecOut->timeUs, vframe->ErrorInfo);
vframe->ShowTime.TimeHigh = (RK_U32)(pts >> 32); vframe->ShowTime.TimeHigh = (RK_U32)(pts >> 32);
vframe->ShowTime.TimeLow = (RK_U32)pts; vframe->ShowTime.TimeLow = (RK_U32)pts;
buf = mpp_frame_get_buffer(mframe); buf = mpp_frame_get_buffer(mframe);

2
mpp/mpp_frame.cpp
View File

@@ -171,4 +171,4 @@ MPP_FRAME_ACCESSORS(MppFrameChromaLocation, chroma_location)
MPP_FRAME_ACCESSORS(MppFrameFormat, fmt) MPP_FRAME_ACCESSORS(MppFrameFormat, fmt)
MPP_FRAME_ACCESSORS(MppBuffer, buffer) MPP_FRAME_ACCESSORS(MppBuffer, buffer)
MPP_FRAME_ACCESSORS(size_t, buf_size) MPP_FRAME_ACCESSORS(size_t, buf_size)
MPP_FRAME_ACCESSORS(RK_U32, errinfo)

2
mpp/mpp_frame_impl.h
View File

@@ -71,7 +71,7 @@ struct MppFrameImpl_t {
*/ */
RK_U32 eos; RK_U32 eos;
RK_U32 info_change; RK_U32 info_change;
RK_U32 errinfo;
MppFrameColorRange color_range; MppFrameColorRange color_range;
MppFrameColorPrimaries color_primaries; MppFrameColorPrimaries color_primaries;
MppFrameColorTransferCharacteristic color_trc; MppFrameColorTransferCharacteristic color_trc;