package/mpp
1
0
Fork 0
mirror of https://github.com/nyanmisaka/mpp.git synced 2025-10-06 01:26:49 +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);
RK_S64 mpp_frame_get_dts(const MppFrame frame);
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
*/

6
inc/vpu_api.h
View File

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

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

@@ -23,6 +23,8 @@
#include "mpp_packet_impl.h"
#include "mpp_mem.h"
#include "vpu_api.h"
#include "h264d_log.h"
#include "h264d_api.h"
#include "h264d_global.h"
@@ -372,11 +374,14 @@ static MPP_RET init_dec_ctx(H264_DecCtx_t *p_Dec)
//!< malloc mpp packet
mpp_packet_init(&p_Dec->task_pkt, p_Dec->dxva_ctx->bitstream, p_Dec->dxva_ctx->max_strm_size);
MEM_CHECK(ret, p_Dec->task_pkt);
//!< memset error context
memset(&p_Dec->err_ctx, 0, sizeof(H264dErrCtx_t));
//!< set Dec support decoder method
p_Dec->spt_decode_mtds = MPP_DEC_BY_FRAME;
p_Dec->next_state = SliceSTATE_ResetSlice;
p_Dec->nalu_ret = NALU_NULL;
p_Dec->is_first_frame = 1;
p_Dec->last_frame_slot_idx = -1;
__RETURN:
return ret = MPP_OK;
@@ -405,6 +410,7 @@ static void get_pkt_timestamp(H264dCurStream_t *p_strm, H264dInputCtx_t *p_Inp,
}
}
#endif
/*!
***********************************************************************
* \brief
@@ -636,7 +642,7 @@ MPP_RET h264d_prepare(void *decoder, MppPacket pkt, HalDecTask *task)
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
//LogTrace(logctx, "Prepare In:len=%d, valid=%d ", mpp_packet_get_length(pkt), task->valid);
if (p_Dec->p_Inp->has_get_eos || p_Dec->error_flag) {
if (p_Dec->p_Inp->has_get_eos || p_Dec->err_ctx.err_flag) {
((MppPacketImpl *)pkt)->length = 0;
goto __RETURN;
}
@@ -742,42 +748,21 @@ MPP_RET h264d_parse(void *decoder, HalDecTask *in_task)
in_task->valid = 0; // prepare end flag
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));
if (p_Dec->is_parser_end) {
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->syntax.number = p_Dec->dxva_ctx->syn.num;
in_task->syntax.data = (void *)p_Dec->dxva_ctx->syn.buf;
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) {
h264d_flush(decoder);
}
p_Dec->p_Vid->g_framecnt++;
}
__RETURN:
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
return ret = MPP_OK;
@@ -791,11 +776,41 @@ __FAILED:
* callback
***********************************************************************
*/
MPP_RET h264d_callback(void *decoder, void *err_info)
{
(void) decoder;
(void) err_info;
return MPP_OK;
MPP_RET ret = MPP_ERR_UNKNOW;
MppFrame m_frame;
H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
H264dErrCtx_t *ctx = (H264dErrCtx_t *)err_info;
INP_CHECK(ret, !decoder && !err_info);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
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
{
RK_U32 i = 0;
RK_S32 PicSizeInMbs = 0;
MPP_RET ret = MPP_ERR_UNKNOW;
H264_SPS_t *active_sps = p_Vid->active_sps;
if(!active_sps){
ret = MPP_NOK;
goto __FAILED;
}
p_Dpb->p_Vid = p_Vid;
if (p_Dpb->init_done) {
free_dpb(p_Dpb);
}
p_Dpb->size = getDpbSize(p_Vid, active_sps) + (type == 2 ? 0 : 1);
p_Dpb->num_ref_frames = active_sps->max_num_ref_frames;
if (active_sps->max_dec_frame_buffering < active_sps->max_num_ref_frames) {
//if (active_sps->max_dec_frame_buffering < active_sps->max_num_ref_frames) {
//H264D_LOG("DPB size at specified level is smaller than reference frames");
//LogError(runlog, "DPB size at specified level is smaller than reference frames");
//goto __FAILED;
}
//}
p_Dpb->used_size = 0;
p_Dpb->last_picture = NULL;
p_Dpb->ref_frames_in_buffer = 0;
@@ -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
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);
MEM_CHECK(ret, 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_Vid->last_has_mmco_5 = 0;
p_Dpb->init_done = 1;
(void)PicSizeInMbs;
return ret = MPP_OK;
__FAILED:
ASSERT(0);
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
RK_S32 mvc_scalable_nesting_flag;
RK_S32 seq_parameter_set_id;
struct h264_dec_ctx_t *p_Dec;
} H264_SEI_t;
//!< SLICE
@@ -820,9 +822,6 @@ typedef struct h264d_dxva_ctx_t {
struct h264_dec_ctx_t *p_Dec;
} H264dDxvaCtx_t;
//!< input parameter
typedef struct h264d_input_ctx_t {
struct h264_dec_ctx_t *p_Dec;
@@ -1045,6 +1044,13 @@ typedef enum slice_state_type {
} 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
typedef struct h264_dec_ctx_t {
@@ -1079,8 +1085,7 @@ typedef struct h264_dec_ctx_t {
RK_U32 task_eos;
HalDecTask *in_task;
RK_S32 last_frame_slot_idx;
RK_U32 error_flag;
struct h264_err_ctx_t err_ctx;
} H264_DecCtx_t;

26
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);
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");
if (g_nalu_cnt0 == 2384) {
g_nalu_cnt0 = g_nalu_cnt0;
}
//if (g_nalu_cnt0 == 2384) {
// g_nalu_cnt0 = g_nalu_cnt0;
//}
cur_nal->ualu_header_bytes = 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);
}
cur_nal->ualu_header_bytes += 3;
} 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);
}
//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);
//}
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;
@@ -242,7 +243,7 @@ static MPP_RET parser_one_nalu(H264_SLICE_t *currSlice)
LogTrace(runlog, "nalu_type=SUB_SPS");
break;
case NALU_TYPE_SEI:
//FUN_CHECK(ret = process_sei(currSlice));
FUN_CHECK(ret = process_sei(currSlice));
LogTrace(runlog, "nalu_type=SEI");
currSlice->p_Dec->nalu_ret = NALU_SEI;
break;
@@ -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_Dec->is_new_frame = 0;
reset_nalu(p_strm);
p_strm->startcode_found = 0;
p_Cur->last_dts = p_Cur->curr_dts;
p_Cur->last_pts = p_Cur->curr_pts;
@@ -867,7 +869,6 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
case SliceSTATE_ResetSlice:
reset_slice(p_Dec->p_Vid);
p_Dec->next_state = SliceSTATE_ReadNalu;
//H264D_LOG( "SliceSTATE_ResetSlice");
break;
case SliceSTATE_ReadNalu:
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->next_state = SliceSTATE_ParseNalu;
}
//H264D_LOG( "SliceSTATE_ReadNalu");
break;
case SliceSTATE_ParseNalu:
(ret = parser_one_nalu(&p_Dec->p_Cur->slice));
@@ -894,30 +894,30 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
} else {
p_Dec->next_state = SliceSTATE_ReadNalu;
}
//H264D_LOG("SliceSTATE_ParseNalu");
break;
case SliceSTATE_InitPicture:
(ret = init_picture(&p_Dec->p_Cur->slice));
p_Dec->next_state = SliceSTATE_GetSliceData;
//H264D_LOG("SliceSTATE_InitPicture");
break;
case SliceSTATE_GetSliceData:
(ret = fill_slice_syntax(&p_Dec->p_Cur->slice, p_Dec->dxva_ctx));
p_Dec->p_Vid->iNumOfSlicesDecoded++;
p_Dec->next_state = SliceSTATE_ResetSlice;
//H264D_LOG("SliceSTATE_GetSliceData");
break;
case SliceSTATE_RegisterOneFrame:
commit_buffer(p_Dec->dxva_ctx);
while_loop_flag = 0;
p_Dec->is_parser_end = 1;
p_Dec->next_state = SliceSTATE_ReadNalu;
//H264D_LOG("SliceSTATE_RegisterOneFrame");
break;
default:
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]);
//__RETURN:

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

@@ -20,6 +20,8 @@
#include <stdio.h>
#include <string.h>
#include "vpu_api.h"
#include "h264d_log.h"
#include "h264d_sps.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;
MPP_RET ret = MPP_ERR_UNKNOW;
H264D_LOG("size=%d",size);
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
RK_U32 offset = 0;
RK_U8 payload_byte;
mpp_log("User data unregistered SEI message\n");
mpp_log("uuid_iso_11578 = 0x");
for (offset = 0; offset < 16; offset++) {
mpp_log("%02x",payload[offset]);
}
while (offset < size) {
payload_byte = payload[offset];
offset++;
mpp_log("Unreg data payload_byte = %d\n", payload_byte);
{
RK_U32 offset = 0;
RK_U8 payload_byte;
mpp_log("User data unregistered SEI message\n");
mpp_log("uuid_iso_11578 = 0x");
for (offset = 0; offset < 16; offset++) {
mpp_log("%02x",payload[offset]);
}
while (offset < size) {
payload_byte = payload[offset];
offset++;
mpp_log("Unreg data payload_byte = %02x\n", payload_byte);
}
}
#endif
sei_msg->user_data_DivX_flag = strstr(strupr((char *)&payload[16]), "DIVX") ? 1 : 0;
if (sei_msg->user_data_DivX_flag) {
H264D_ERR("DivX is not supported. \n");
sei_msg->p_Dec->err_ctx.err_flag |= VPU_FRAME_ERR_UNSUPPORT;
ret = MPP_NOK;
goto __FAILED;
}
return ret = MPP_OK;
__FAILED:
return ret;
}
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_U32 operation_point_flag;
@@ -208,7 +219,6 @@ static MPP_RET interpret_mvc_scalable_nesting_info(RK_U8 *payload, RK_S32 size,
}
p_bitctx->used_bits = p_strm->used_bits;
sei_msg->mvc_scalable_nesting_flag = 1;
return ret = MPP_OK;
__BITREAD_ERR:
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;
}
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;
//!< sei_payload( type, size );
H264D_LOG("[SEI_TYPE] type=%d \n", sei_msg->type);
H264dVideoCtx_t *p_Vid = cur_slice->p_Vid;
H264D_LOG("[SEI_TYPE] type=%d \n", sei_msg->type);
switch (sei_msg->type) {
case SEI_BUFFERING_PERIOD:
FUN_CHECK(ret = interpret_buffering_period_info(msg, sei_msg->payload_size, p_bitctx, sei_msg));
{
H264_SPS_t *sps = NULL;
H264_subSPS_t *subset_sps = NULL;
if (sei_msg->mvc_scalable_nesting_flag) {
p_Vid->active_mvc_sps_flag = 1;
sps = NULL;
subset_sps = &p_Vid->subspsSet[sei_msg->seq_parameter_set_id];
} else {
p_Vid->active_mvc_sps_flag = 0;
sps = &p_Vid->spsSet[sei_msg->seq_parameter_set_id];
subset_sps = NULL;
}
p_Vid->exit_picture_flag = 1;
FUN_CHECK(ret = activate_sps(p_Vid, sps, subset_sps));
}
break;
case SEI_PIC_TIMING:
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();
break;
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;
case SEI_RECOVERY_POINT:
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();
break;
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;
case SEI_VIEW_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:
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
@@ -394,7 +386,7 @@ MPP_RET process_sei(H264_SLICE_t *currSlice)
FunctionIn(currSlice->logctx->parr[RUN_PARSE]);
memset(sei_msg, 0, sizeof(*sei_msg));
sei_msg->mvc_scalable_nesting_flag = 0; //init to false
sei_msg->p_Dec = currSlice->p_Dec;
do {
sei_msg->type = 0;
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
//--- read sei info
FUN_CHECK(ret = parserSEI(p_bitctx, sei_msg, p_bitctx->data_));
//--- analysis sei info
FUN_CHECK(ret = analysisSEI(currSlice));
FUN_CHECK(ret = parserSEI(currSlice, p_bitctx, sei_msg, p_bitctx->data_));
//--- set offset to read next sei nal
if (SEI_MVC_SCALABLE_NESTING == sei_msg->type) {
sei_msg->payload_size = ((p_bitctx->used_bits + 0x07) >> 3);
@@ -432,6 +422,5 @@ MPP_RET process_sei(H264_SLICE_t *currSlice)
__BITREAD_ERR:
ret = p_bitctx->ret;
__FAILED:
ASSERT(0);
return ret;
}

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

@@ -21,6 +21,8 @@
#include "mpp_mem.h"
#include "vpu_api.h"
#include "h264d_log.h"
#include "h264d_sps.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);
if (cur_sps->chroma_format_idc >= 3) {
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;
}
//if (cur_sps->chroma_format_idc == 3) {

12
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;
while (MPP_OK == mpp_buf_slot_dequeue(frame_slots, &index, QUEUE_DISPLAY)) {
MppFrame frame;
RK_U32 discard;
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)
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) {
//mpp_log("--- mpp_dec flush ---\n");
mpp_dec_flush(dec);
}
RK_S32 index;
while (MPP_OK == mpp_buf_slot_dequeue(frame_slots, &index, QUEUE_DISPLAY)) {
MppFrame frame;
RK_U32 discard;
mpp_buf_slot_get_prop(frame_slots, index, SLOT_FRAME, &frame);
discard = mpp_frame_get_discard(frame);
if (!dec->reset_flag && !discard) {
mpp_put_frame(mpp, frame);
//mpp_log("discard=%d \n",0);
} else {
mpp_frame_deinit(&frame);
//mpp_log("discard=%d \n",1);
}
mpp_buf_slot_clr_flag(frame_slots, index, SLOT_QUEUE_USE);
}
}
}
//mpp_log("------- hal thread end ----------- \n");
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->FrameWidth = mpp_frame_get_hor_stride(mframe);
vframe->FrameHeight = mpp_frame_get_ver_stride(mframe);
vframe->ErrorInfo = mpp_frame_get_errinfo(mframe);
//mpp_err("vframe->ErrorInfo = %08x \n", vframe->ErrorInfo);
pts = mpp_frame_get_pts(mframe);
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.TimeLow = (RK_U32)pts;
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(MppBuffer, buffer)
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 info_change;
RK_U32 errinfo;
MppFrameColorRange color_range;
MppFrameColorPrimaries color_primaries;
MppFrameColorTransferCharacteristic color_trc;