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

[h264d] 1.h264d_init picbuf => refpic; astyle format

Browse Source 
git-svn-id: https://10.10.10.66:8443/svn/MediaProcessPlatform/trunk/mpp@591 6e48237b-75ef-9749-8fc9-41990f28c85a
This commit is contained in:
DingWei
2016-03-18 03:51:32 +00:00
parent a31b8ceebf
commit a9b5219f97
32 changed files with 933 additions and 958 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -395,7 +395,7 @@ static void flush_dpb_buf_slot(H264_DecCtx_t *p_Dec)
RK_U32 i = 0; RK_U32 i = 0;
H264_DpbMark_t *p_mark = NULL; H264_DpbMark_t *p_mark = NULL;
for(i = 0; i < MAX_MARK_SIZE; i++) { for (i = 0; i < MAX_MARK_SIZE; i++) {
p_mark = &p_Dec->dpb_mark[i]; p_mark = &p_Dec->dpb_mark[i];
if (p_mark->out_flag && (p_mark->slot_idx >= 0)) { if (p_mark->out_flag && (p_mark->slot_idx >= 0)) {
MppFrame mframe = NULL; MppFrame mframe = NULL;
@@ -508,8 +508,8 @@ MPP_RET h264d_reset(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));
if (p_Dec->mvc_valid) if (p_Dec->mvc_valid) {
{ // layer_id == 1 // layer_id == 1
FUN_CHECK(ret = flush_dpb(p_Dec->p_Vid->p_Dpb_layer[1], 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));
flush_muti_view_output(p_Dec->frame_slots, p_Dec->p_Vid->outlist, p_Dec->p_Vid); flush_muti_view_output(p_Dec->frame_slots, p_Dec->p_Vid->outlist, p_Dec->p_Vid);
@@ -759,8 +759,7 @@ __RETURN:
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]); FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
return ret = MPP_OK; return ret = MPP_OK;
__FAILED: __FAILED: {
{
H264_StorePic_t *dec_pic = p_Dec->p_Vid->dec_pic; H264_StorePic_t *dec_pic = p_Dec->p_Vid->dec_pic;
if (dec_pic && dec_pic->mem_mark->out_flag) { if (dec_pic && dec_pic->mem_mark->out_flag) {
MppFrame mframe = NULL; MppFrame mframe = NULL;
@@ -804,8 +803,7 @@ MPP_RET h264d_callback(void *decoder, void *errinfo)
mpp_buf_slot_get_prop(p_Dec->frame_slots, out_slot_idx, SLOT_FRAME_PTR, &mframe); mpp_buf_slot_get_prop(p_Dec->frame_slots, out_slot_idx, SLOT_FRAME_PTR, &mframe);
if (used_for_ref_flag) { if (used_for_ref_flag) {
mpp_frame_set_errinfo(mframe, VPU_FRAME_ERR_UNKNOW); mpp_frame_set_errinfo(mframe, VPU_FRAME_ERR_UNKNOW);
} } else {
else {
mpp_frame_set_discard(mframe, VPU_FRAME_ERR_UNKNOW); mpp_frame_set_discard(mframe, VPU_FRAME_ERR_UNKNOW);
} }
H264D_DBG(H264D_DBG_CALLBACK, "g_frame_no=%d, out_slot_idx=%d, swreg[01]=%08x, swreg[45]=%08x, dpb_err=%d, used_for_ref=%d", H264D_DBG(H264D_DBG_CALLBACK, "g_frame_no=%d, out_slot_idx=%d, swreg[01]=%08x, swreg[45]=%08x, dpb_err=%d, used_for_ref=%d",

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

@@ -630,11 +630,9 @@ static void free_dpb_mark(H264_DecCtx_t *p_Dec, H264_DpbMark_t *p, RK_S32 struct
if (structure == FRAME) { if (structure == FRAME) {
p->top_used = (p->top_used > 0) ? (p->top_used - 1) : 0; p->top_used = (p->top_used > 0) ? (p->top_used - 1) : 0;
p->bot_used = (p->bot_used > 0) ? (p->bot_used - 1) : 0; p->bot_used = (p->bot_used > 0) ? (p->bot_used - 1) : 0;
} } else if (structure == TOP_FIELD) {
else if (structure == TOP_FIELD) {
p->top_used = (p->top_used > 0) ? (p->top_used - 1) : 0; p->top_used = (p->top_used > 0) ? (p->top_used - 1) : 0;
} } 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
@@ -939,8 +937,7 @@ static void write_picture(H264_StorePic_t *p, H264dVideoCtx_t *p_Vid)
mpp_buf_slot_set_flag(p_Vid->p_Dec->frame_slots, p_mark->slot_idx, SLOT_QUEUE_USE); mpp_buf_slot_set_flag(p_Vid->p_Dec->frame_slots, p_mark->slot_idx, SLOT_QUEUE_USE);
if (p_Vid->p_Dec->mvc_valid && !p_Vid->p_Inp->mvc_disable) { if (p_Vid->p_Dec->mvc_valid && !p_Vid->p_Inp->mvc_disable) {
muti_view_output(p_Vid->p_Dec->frame_slots, p_mark, p_Vid); muti_view_output(p_Vid->p_Dec->frame_slots, p_mark, p_Vid);
} else } else {
{
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);
p_Vid->p_Dec->last_frame_slot_idx = p_mark->slot_idx; p_Vid->p_Dec->last_frame_slot_idx = p_mark->slot_idx;
p_mark->out_flag = 0; p_mark->out_flag = 0;
@@ -1850,7 +1847,7 @@ __FAILED:
static void reset_dpb_info(H264_DpbInfo_t *p) static void reset_dpb_info(H264_DpbInfo_t *p)
{ {
p->picbuf = NULL; p->refpic = NULL;
p->TOP_POC = 0; p->TOP_POC = 0;
p->BOT_POC = 0; p->BOT_POC = 0;
p->field_flag = 0; p->field_flag = 0;
@@ -1877,7 +1874,7 @@ static MPP_RET adjust_input(H264_SLICE_t *currSlice)
//for (i = 0; i < MAX_DPB_SIZE; i++) { //for (i = 0; i < MAX_DPB_SIZE; i++) {
// if (new_dpb[i].picbuf) { // if (new_dpb[i].refpic) {
// 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, "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, // 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); // new_dpb[i].TOP_POC);
@@ -1885,7 +1882,7 @@ static MPP_RET adjust_input(H264_SLICE_t *currSlice)
//} //}
//FPRINT(g_debug_file0, "--------- [new DPB] -------- \n"); //FPRINT(g_debug_file0, "--------- [new DPB] -------- \n");
//for (i = 0; i < MAX_DPB_SIZE; i++) { //for (i = 0; i < MAX_DPB_SIZE; i++) {
// if (old_dpb[i].picbuf) { // if (old_dpb[i].refpic) {
// 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, "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, // 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); // old_dpb[i].TOP_POC);
@@ -1896,9 +1893,9 @@ static MPP_RET adjust_input(H264_SLICE_t *currSlice)
//!< delete old dpb //!< delete old dpb
for (i = 0; i < MAX_DPB_SIZE; i++) { for (i = 0; i < MAX_DPB_SIZE; i++) {
find_flag = 0; find_flag = 0;
if (old_dpb[i].picbuf) { if (old_dpb[i].refpic) {
for (j = 0; j < MAX_DPB_SIZE; j++) { for (j = 0; j < MAX_DPB_SIZE; j++) {
if (new_dpb[j].picbuf) { if (new_dpb[j].refpic) {
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;
find_flag = (old_dpb[i].slot_index == new_dpb[j].slot_index) ? find_flag : 0; find_flag = (old_dpb[i].slot_index == new_dpb[j].slot_index) ? find_flag : 0;
if (new_dpb[j].is_used & 0x1) { if (new_dpb[j].is_used & 0x1) {
@@ -1921,11 +1918,11 @@ static MPP_RET adjust_input(H264_SLICE_t *currSlice)
} }
//!< add new dpb //!< add new dpb
for (j = 0; j < MAX_DPB_SIZE; j++) { for (j = 0; j < MAX_DPB_SIZE; j++) {
if ((new_dpb[j].picbuf == 0) || new_dpb[j].have_same) { if ((new_dpb[j].refpic == 0) || new_dpb[j].have_same) {
continue; continue;
} }
for (i = 0; i < MAX_DPB_SIZE; i++) { for (i = 0; i < MAX_DPB_SIZE; i++) {
if (old_dpb[i].picbuf == 0) { if (old_dpb[i].refpic == 0) {
old_dpb[i] = new_dpb[j]; old_dpb[i] = new_dpb[j];
break; break;
} }
@@ -1934,7 +1931,7 @@ static MPP_RET adjust_input(H264_SLICE_t *currSlice)
//memcpy(new_dpb, old_dpb, MAX_DPB_SIZE*sizeof(H264_DpbInfo_t)); //memcpy(new_dpb, old_dpb, MAX_DPB_SIZE*sizeof(H264_DpbInfo_t));
memset(new_dpb, 0, 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++) { for (i = 0, j = 0; i < MAX_DPB_SIZE; i++) {
if (old_dpb[i].picbuf) { if (old_dpb[i].refpic) {
new_dpb[j] = old_dpb[i]; 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, "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, //FPRINT(g_debug_file0, " dbp_idx=%d, longterm=%d, poc=%d \n", old_dpb[j].slot_index, old_dpb[j].is_long_term,
@@ -1973,9 +1970,10 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
goto __RETURN; goto __RETURN;
} }
//!<---- reference //!<---- reference
#if 1
for (i = 0, j = 0; j < p_Dpb->ref_frames_in_buffer; i++, j++) { for (i = 0, j = 0; j < p_Dpb->ref_frames_in_buffer; i++, j++) {
if (p_Dpb->fs_ref[j]->is_used == 3) { if (p_Dpb->fs_ref[j]->is_used == 3) {
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ref[j]->frame; p_Dec->dpb_info[i].refpic = p_Dpb->fs_ref[j]->frame;
if (p_Dpb->fs_ref[j]->frame->iCodingType == FIELD_CODING) { if (p_Dpb->fs_ref[j]->frame->iCodingType == FIELD_CODING) {
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ref[j]->top_field->poc; p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ref[j]->top_field->poc;
p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ref[j]->bottom_field->poc; p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ref[j]->bottom_field->poc;
@@ -1993,7 +1991,7 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
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);
} 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].refpic = p_Dpb->fs_ref[j]->top_field;
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ref[j]->top_field->poc; p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ref[j]->top_field->poc;
p_Dec->dpb_info[i].BOT_POC = 0; p_Dec->dpb_info[i].BOT_POC = 0;
@@ -2001,7 +1999,7 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
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);
} 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].refpic = p_Dpb->fs_ref[j]->bottom_field;
p_Dec->dpb_info[i].TOP_POC = 0; p_Dec->dpb_info[i].TOP_POC = 0;
p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ref[j]->bottom_field->poc; p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ref[j]->bottom_field->poc;
p_Dec->dpb_info[i].field_flag = 1; p_Dec->dpb_info[i].field_flag = 1;
@@ -2017,10 +2015,12 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
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;
} }
#endif
//!<---- long term reference //!<---- long term reference
#if 1
for (j = 0; j < p_Dpb->ltref_frames_in_buffer; i++, j++) { for (j = 0; j < p_Dpb->ltref_frames_in_buffer; i++, j++) {
if (p_Dpb->fs_ltref[j]->is_used == 3) { if (p_Dpb->fs_ltref[j]->is_used == 3) {
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ltref[j]->frame; p_Dec->dpb_info[i].refpic = p_Dpb->fs_ltref[j]->frame;
if (p_Dpb->fs_ltref[j]->frame->iCodingType == FIELD_CODING) { if (p_Dpb->fs_ltref[j]->frame->iCodingType == FIELD_CODING) {
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ltref[j]->top_field->poc; p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ltref[j]->top_field->poc;
@@ -2041,7 +2041,7 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
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;
} 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].refpic = p_Dpb->fs_ltref[j]->top_field;
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ltref[j]->top_field->poc; p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ltref[j]->top_field->poc;
p_Dec->dpb_info[i].BOT_POC = 0; p_Dec->dpb_info[i].BOT_POC = 0;
p_Dec->dpb_info[i].field_flag = 1; p_Dec->dpb_info[i].field_flag = 1;
@@ -2049,7 +2049,7 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
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;
} 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].refpic = p_Dpb->fs_ltref[j]->bottom_field;
p_Dec->dpb_info[i].TOP_POC = 0; p_Dec->dpb_info[i].TOP_POC = 0;
p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ltref[j]->bottom_field->poc; p_Dec->dpb_info[i].BOT_POC = p_Dpb->fs_ltref[j]->bottom_field->poc;
p_Dec->dpb_info[i].field_flag = 1; p_Dec->dpb_info[i].field_flag = 1;
@@ -2065,14 +2065,14 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
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;
} }
#endif
#if 1
//!< inter-layer reference (for multi-layered codecs) //!< inter-layer reference (for multi-layered codecs)
#if 1
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) {
if (p_Dpb->fs_ilref[j]->inter_view_flag[0] == 0 && p_Dpb->fs_ilref[j]->inter_view_flag[1] == 0) if (p_Dpb->fs_ilref[j]->inter_view_flag[0] == 0 && p_Dpb->fs_ilref[j]->inter_view_flag[1] == 0)
break; break;
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ilref[j]->frame; p_Dec->dpb_info[i].refpic = p_Dpb->fs_ilref[j]->frame;
if (p_Dpb->fs_ilref[j]->frame->is_mmco_5) { if (p_Dpb->fs_ilref[j]->frame->is_mmco_5) {
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->frame->top_poc_mmco5; p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->frame->top_poc_mmco5;
@@ -2088,7 +2088,7 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
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)
break; break;
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ilref[j]->top_field; p_Dec->dpb_info[i].refpic = p_Dpb->fs_ilref[j]->top_field;
if (p_Dpb->fs_ilref[j]->top_field->is_mmco_5) { if (p_Dpb->fs_ilref[j]->top_field->is_mmco_5) {
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->top_field->top_poc_mmco5; p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->top_field->top_poc_mmco5;
@@ -2107,7 +2107,7 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
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)
break; break;
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ilref[j]->top_field; p_Dec->dpb_info[i].refpic = p_Dpb->fs_ilref[j]->top_field;
if (p_Dpb->fs_ilref[j]->top_field->is_mmco_5) { if (p_Dpb->fs_ilref[j]->top_field->is_mmco_5) {
p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->top_field->top_poc_mmco5; p_Dec->dpb_info[i].TOP_POC = p_Dpb->fs_ilref[j]->top_field->top_poc_mmco5;
@@ -2121,7 +2121,7 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
} 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;
p_Dec->dpb_info[i].picbuf = p_Dpb->fs_ilref[j]->bottom_field; p_Dec->dpb_info[i].refpic = p_Dpb->fs_ilref[j]->bottom_field;
p_Dec->dpb_info[i].TOP_POC = 0; p_Dec->dpb_info[i].TOP_POC = 0;
if (p_Dpb->fs_ilref[j]->bottom_field->is_mmco_5) { if (p_Dpb->fs_ilref[j]->bottom_field->is_mmco_5) {
@@ -2144,44 +2144,24 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
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;
} }
#endif #endif
//!< dump dpb_init info
//for(j = 0; j < i; j++) { H264D_DBG(H264D_DBG_DPB_INFO, "---- DPB INFO ----");
// 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); for (j = 0; j < i; j++) {
// 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, H264D_DBG(H264D_DBG_DPB_INFO, "j=%d, top_poc=%d, bot_poc=%d, frame_num=%d, is_lt=%d, layer_id=%d\n", j, p_Dec->dpb_info[j].TOP_POC,
// p_Dec->dpb_info[j].TOP_POC); p_Dec->dpb_info[j].BOT_POC, p_Dec->dpb_info[j].frame_num, p_Dec->dpb_info[j].is_ilt_flag, p_Dec->dpb_info[j].voidx);
//} }
//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;
//}
//!< reset left parameters //!< reset left parameters
for (; i < MAX_DPB_SIZE; i++) { for (; i < MAX_DPB_SIZE; i++) {
reset_dpb_info(&p_Dec->dpb_info[i]); reset_dpb_info(&p_Dec->dpb_info[i]);
} }
//FPRINT(g_debug_file0, "---g_framecnt=%d\n", p_Dec->p_Vid->g_framecnt);
//for (i = 0; i< 16; i++)
//{
// FPRINT(g_debug_file0, "i=%d, top_poc=%d, bot_poc=%d, frame_num=%d, is_lt=%d, voidx=%d\n", i, p_Dec->dpb_info[i].TOP_POC,
// p_Dec->dpb_info[i].BOT_POC, p_Dec->dpb_info[i].frame_num, p_Dec->dpb_info[i].is_ilt_flag, p_Dec->dpb_info[i].voidx);
//}
//adjust_input(currSlice); //adjust_input(currSlice);
for (i = 0; i < MAX_DPB_SIZE; i++) { for (i = 0; i < MAX_DPB_SIZE; i++) {
if ((NULL != p_Dec->dpb_info[i].picbuf) && (p_Dec->dpb_info[i].slot_index >= 0)) { if ((NULL != p_Dec->dpb_info[i].refpic) && (p_Dec->dpb_info[i].slot_index >= 0)) {
p_Dec->in_task->refer[i] = p_Dec->dpb_info[i].slot_index; 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_HAL_INPUT);
mpp_buf_slot_set_flag(p_Dec->frame_slots, p_Dec->dpb_info[i].slot_index, SLOT_CODEC_USE); 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;
} }
@@ -2196,7 +2176,7 @@ __RETURN:
//extern "C" //extern "C"
MPP_RET prepare_init_ref_info(H264_SLICE_t *currSlice) MPP_RET prepare_init_ref_info(H264_SLICE_t *currSlice)
{ {
void *picbuf = NULL; void *refpic = NULL;
RK_U32 i = 0, j = 0, k = 0; RK_U32 i = 0, j = 0, k = 0;
RK_S32 poc = 0, TOP_POC = 0, BOT_POC = 0; RK_S32 poc = 0, TOP_POC = 0, BOT_POC = 0;
RK_S32 layer_id = 0, voidx = 0, is_used = 0; RK_S32 layer_id = 0, voidx = 0, is_used = 0;
@@ -2226,12 +2206,12 @@ MPP_RET prepare_init_ref_info(H264_SLICE_t *currSlice)
? currSlice->listP[0][j]->bot_poc_mmco5 : currSlice->listP[0][j]->bottom_poc; ? currSlice->listP[0][j]->bot_poc_mmco5 : currSlice->listP[0][j]->bottom_poc;
} }
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
picbuf = p_Dec->dpb_info[i].picbuf; refpic = p_Dec->dpb_info[i].refpic;
TOP_POC = p_Dec->dpb_info[i].TOP_POC; TOP_POC = p_Dec->dpb_info[i].TOP_POC;
BOT_POC = p_Dec->dpb_info[i].BOT_POC; BOT_POC = p_Dec->dpb_info[i].BOT_POC;
voidx = p_Dec->dpb_info[i].voidx; voidx = p_Dec->dpb_info[i].voidx;
is_used = p_Dec->dpb_info[i].is_used; is_used = p_Dec->dpb_info[i].is_used;
if (currSlice->structure == FRAME && picbuf) { if (currSlice->structure == FRAME && refpic) {
if (poc == MPP_MIN(TOP_POC, BOT_POC) && (layer_id == voidx)) if (poc == MPP_MIN(TOP_POC, BOT_POC) && (layer_id == voidx))
break; break;
} else { } else {
@@ -2249,7 +2229,6 @@ MPP_RET prepare_init_ref_info(H264_SLICE_t *currSlice)
} }
ASSERT(i < 16); ASSERT(i < 16);
p_Dec->refpic_info_p[j].dpb_idx = i; p_Dec->refpic_info_p[j].dpb_idx = i;
if (currSlice->listP[0][j]->structure == BOTTOM_FIELD) { if (currSlice->listP[0][j]->structure == BOTTOM_FIELD) {
p_Dec->refpic_info_p[j].bottom_flag = 1; p_Dec->refpic_info_p[j].bottom_flag = 1;
} else { } else {
@@ -2279,12 +2258,12 @@ MPP_RET prepare_init_ref_info(H264_SLICE_t *currSlice)
? currSlice->listB[k][j]->bot_poc_mmco5 : currSlice->listB[k][j]->bottom_poc; ? currSlice->listB[k][j]->bot_poc_mmco5 : currSlice->listB[k][j]->bottom_poc;
} }
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
picbuf = p_Dec->dpb_info[i].picbuf; refpic = p_Dec->dpb_info[i].refpic;
TOP_POC = p_Dec->dpb_info[i].TOP_POC; TOP_POC = p_Dec->dpb_info[i].TOP_POC;
BOT_POC = p_Dec->dpb_info[i].BOT_POC; BOT_POC = p_Dec->dpb_info[i].BOT_POC;
voidx = p_Dec->dpb_info[i].voidx; voidx = p_Dec->dpb_info[i].voidx;
is_used = p_Dec->dpb_info[i].is_used; is_used = p_Dec->dpb_info[i].is_used;
if (currSlice->structure == FRAME && picbuf) { if (currSlice->structure == FRAME && refpic) {
if (poc == MPP_MIN(TOP_POC, BOT_POC) && (layer_id == voidx)) if (poc == MPP_MIN(TOP_POC, BOT_POC) && (layer_id == voidx))
break; break;
} else { } else {
@@ -2302,13 +2281,11 @@ MPP_RET prepare_init_ref_info(H264_SLICE_t *currSlice)
} }
ASSERT(i < 16); ASSERT(i < 16);
p_Dec->refpic_info_b[k][j].dpb_idx = i; p_Dec->refpic_info_b[k][j].dpb_idx = i;
if (currSlice->listB[k][j]->structure == BOTTOM_FIELD) { if (currSlice->listB[k][j]->structure == BOTTOM_FIELD) {
p_Dec->refpic_info_b[k][j].bottom_flag = 1; p_Dec->refpic_info_b[k][j].bottom_flag = 1;
} else { } else {
p_Dec->refpic_info_b[k][j].bottom_flag = 0; p_Dec->refpic_info_b[k][j].bottom_flag = 0;
} }
p_Dec->refpic_info_b[k][j].valid = 1; p_Dec->refpic_info_b[k][j].valid = 1;
} else { } else {
p_Dec->refpic_info_b[k][j].valid = 0; p_Dec->refpic_info_b[k][j].valid = 0;

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

@@ -149,7 +149,7 @@ void fill_picparams(H264dVideoCtx_t *p_Vid, DXVA_PicParams_H264_MVC *pp)
pp->UsedForReferenceFlags = 0; pp->UsedForReferenceFlags = 0;
pp->NonExistingFrameFlags = 0; pp->NonExistingFrameFlags = 0;
for (i = 0; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) { for (i = 0; i < MPP_ARRAY_ELEMS(pp->RefFrameList); i++) {
if (dpb_info[i].picbuf) { if (dpb_info[i].refpic) {
fill_picture_entry(&pp->RefFrameList[i], dpb_info[i].slot_index, dpb_info[i].is_long_term); fill_picture_entry(&pp->RefFrameList[i], dpb_info[i].slot_index, dpb_info[i].is_long_term);
pp->FieldOrderCntList[i][0] = dpb_info[i].TOP_POC; pp->FieldOrderCntList[i][0] = dpb_info[i].TOP_POC;
pp->FieldOrderCntList[i][1] = dpb_info[i].BOT_POC; pp->FieldOrderCntList[i][1] = dpb_info[i].BOT_POC;
@@ -327,7 +327,7 @@ 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].refpic ? 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,7 +340,7 @@ MPP_RET fill_slice_syntax(H264_SLICE_t *currSlice, H264dDxvaCtx_t *dxva_ctx)
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].refpic ? 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);

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

@@ -225,7 +225,7 @@ typedef struct h264_dpb_info_t {
RK_U32 is_used; RK_U32 is_used;
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 *refpic;
RK_U32 have_same; RK_U32 have_same;
} H264_DpbInfo_t; } H264_DpbInfo_t;

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

@@ -399,14 +399,11 @@ static void dpb_mark_malloc(H264dVideoCtx_t *p_Vid, H264_StorePic_t *dec_pic)
mpp_frame_init(&mframe); mpp_frame_init(&mframe);
if ((YUV420 == p_Vid->yuv_format) && (8 == p_Vid->bit_depth_luma)) { if ((YUV420 == p_Vid->yuv_format) && (8 == p_Vid->bit_depth_luma)) {
mpp_frame_set_fmt(mframe, MPP_FMT_YUV420SP); mpp_frame_set_fmt(mframe, MPP_FMT_YUV420SP);
} } else if ((YUV420 == p_Vid->yuv_format) && (10 == p_Vid->bit_depth_luma)) {
else if ((YUV420 == p_Vid->yuv_format) && (10 == p_Vid->bit_depth_luma)) {
mpp_frame_set_fmt(mframe, MPP_FMT_YUV420SP_10BIT); mpp_frame_set_fmt(mframe, MPP_FMT_YUV420SP_10BIT);
} } else if ((YUV422 == p_Vid->yuv_format) && (8 == p_Vid->bit_depth_luma)) {
else if ((YUV422 == p_Vid->yuv_format) && (8 == p_Vid->bit_depth_luma)) {
mpp_frame_set_fmt(mframe, MPP_FMT_YUV422SP); mpp_frame_set_fmt(mframe, MPP_FMT_YUV422SP);
} } else if ((YUV422 == p_Vid->yuv_format) && (10 == p_Vid->bit_depth_luma)) {
else if ((YUV422 == p_Vid->yuv_format) && (10 == p_Vid->bit_depth_luma)) {
mpp_frame_set_fmt(mframe, MPP_FMT_YUV422SP_10BIT); mpp_frame_set_fmt(mframe, MPP_FMT_YUV422SP_10BIT);
} }
hor_stride = ((p_Vid->width * p_Vid->bit_depth_luma + 127) & (~127)) / 8; hor_stride = ((p_Vid->width * p_Vid->bit_depth_luma + 127) & (~127)) / 8;
@@ -1186,10 +1183,10 @@ static RK_U32 get_short_term_pic(H264_SLICE_t *currSlice, RK_S32 picNum, H264_St
} else { } else {
if ((p_Dpb->fs_ref[i]->is_reference & 1) if ((p_Dpb->fs_ref[i]->is_reference & 1)
&& (!p_Dpb->fs_ref[i]->top_field->is_long_term)) { && (!p_Dpb->fs_ref[i]->top_field->is_long_term)) {
if(p_Dpb->fs_ref[i]->top_field->pic_num == picNum){ if (p_Dpb->fs_ref[i]->top_field->pic_num == picNum) {
ret_pic = p_Dpb->fs_ref[i]->top_field; ret_pic = p_Dpb->fs_ref[i]->top_field;
break; break;
}else { } else {
near_pic = p_Dpb->fs_ref[i]->top_field; near_pic = p_Dpb->fs_ref[i]->top_field;
} }
} }
@@ -1233,16 +1230,37 @@ static H264_StorePic_t *get_long_term_pic(H264_SLICE_t *currSlice, RK_S32 Longte
} }
return NULL; return NULL;
} }
#if 0
static H264_StorePic_t *fake_short_term_pic(H264_SLICE_t *currSlice, RK_S32 picNumLX, H264_StorePic_t *tmp) static void fake_short_term_pic(H264_SLICE_t *currSlice, RK_S32 picNumLX, H264_StorePic_t *tmp)
{ {
#if 0
H264_StorePic_t *fake = NULL; H264_StorePic_t *fake = NULL;
H264_StorePic_t *dec_pic = NULL; H264_StorePic_t *dec_pic = NULL;
#if 1
fake = alloc_storable_picture(currSlice->p_Vid, FRAME); fake = alloc_storable_picture(currSlice->p_Vid, FRAME);
if (fake == NULL) { if (fake == NULL) {
H264D_ERR("failed to alloc new dpb buffer"); H264D_ERR("failed to alloc new dpb buffer.");
goto __FAILED; return;
}
fake->frame_mbs_only_flag = 0;
//fs_top = fs->top_field = alloc_storable_picture(p_Vid, TOP_FIELD);
fake->is_long_term = 0;
fake->view_id = fake->view_id;
fake->layer_id = currSlice->layer_id;
fake->frame_num = fake->pic_num = picNumLX;
dec_pic = currSlice->p_Vid->dec_pic;
fake->poc = dec_pic->poc - (dec_pic->pic_num - picNumLX) * 2;
fake->used_for_reference = 1;
fake->mem_malloc_type = Mem_Fake;
fake->mem_mark = tmp->mem_mark;
fake->mem_mark->pic = fake;
fake->is_output = 1;
#else
fake = clone_storable_picture(currSlice->p_Vid, tmp);
if (fake == NULL) {
H264D_ERR("failed to alloc new dpb buffer.");
return;
} }
fake->is_long_term = 0; fake->is_long_term = 0;
fake->view_id = fake->view_id; fake->view_id = fake->view_id;
@@ -1252,39 +1270,18 @@ static H264_StorePic_t *fake_short_term_pic(H264_SLICE_t *currSlice, RK_S32 picN
fake->poc = dec_pic->poc - (dec_pic->pic_num - picNumLX) * 2; fake->poc = dec_pic->poc - (dec_pic->pic_num - picNumLX) * 2;
fake->used_for_reference = 1; fake->used_for_reference = 1;
fake->mem_malloc_type = Mem_Fake; fake->mem_malloc_type = Mem_Fake;
#if 1
fake->mem_mark = tmp->mem_mark; fake->mem_mark = tmp->mem_mark;
fake->mem_mark->top_used += 1;
fake->mem_mark->bot_used += 1;
fake->mem_mark->pic = fake;
#else
fake->mem_mark = mpp_calloc(H264_DpbMark_t, 1);
if (fake->mem_mark == NULL) {
H264D_ERR("failed to alloc a fake memory");
goto __FAILED;
}
fake->mem_mark->top_used = 1;
fake->mem_mark->bot_used = 1;
fake->mem_mark->out_flag = 0;
fake->mem_mark->mark_idx = tmp->mem_mark->mark_idx;
fake->mem_mark->slot_idx = tmp->mem_mark->slot_idx;
fake->mem_mark->mark_idx = tmp->mem_mark->mark_idx;
fake->mem_mark->pts = tmp->mem_mark->pts;
fake->mem_mark->mframe = tmp->mem_mark->mframe;
fake->mem_mark->poc = fake->poc;
fake->mem_mark->pic = fake; fake->mem_mark->pic = fake;
store_picture_in_dpb(currSlice->p_Dpb, fake);
#endif #endif
mpp_log_f("p_Dpb->used_size=%d, p_Dpb->size=%d", currSlice->p_Dpb->used_size, currSlice->p_Dpb->size); #endif
store_picture_in_dpb(currSlice->p_Vid->p_Dpb_layer[currSlice->layer_id], fake); (void)currSlice;
return fake; (void)picNumLX;
__FAILED: (void)tmp;
if (fake) {
MPP_FREE(fake->mem_mark);
MPP_FREE(fake);
}
return NULL;
} }
#endif
static RK_U32 check_ref_pic_list(H264_SLICE_t *currSlice, RK_S32 cur_list) static RK_U32 check_ref_pic_list(H264_SLICE_t *currSlice, RK_S32 cur_list)
{ {
RK_S32 i = 0; RK_S32 i = 0;
@@ -1312,12 +1309,12 @@ static RK_U32 check_ref_pic_list(H264_SLICE_t *currSlice, RK_S32 cur_list)
continue; continue;
if (modification_of_pic_nums_idc[i] < 2) { if (modification_of_pic_nums_idc[i] < 2) {
if (modification_of_pic_nums_idc[i] == 0) { if (modification_of_pic_nums_idc[i] == 0) {
if( (picNumLXPred - (RK_S32)(abs_diff_pic_num_minus1[i] + 1)) < 0) if ( (picNumLXPred - (RK_S32)(abs_diff_pic_num_minus1[i] + 1)) < 0)
picNumLXNoWrap = picNumLXPred - (abs_diff_pic_num_minus1[i] + 1) + maxPicNum; picNumLXNoWrap = picNumLXPred - (abs_diff_pic_num_minus1[i] + 1) + maxPicNum;
else else
picNumLXNoWrap = picNumLXPred - (abs_diff_pic_num_minus1[i] + 1); picNumLXNoWrap = picNumLXPred - (abs_diff_pic_num_minus1[i] + 1);
} else { // (modification_of_pic_nums_idc[i] == 1) } else { // (modification_of_pic_nums_idc[i] == 1)
if(picNumLXPred + (abs_diff_pic_num_minus1[i] + 1) >= (RK_U32)maxPicNum) if (picNumLXPred + (abs_diff_pic_num_minus1[i] + 1) >= (RK_U32)maxPicNum)
picNumLXNoWrap = picNumLXPred + (abs_diff_pic_num_minus1[i] + 1) - maxPicNum; picNumLXNoWrap = picNumLXPred + (abs_diff_pic_num_minus1[i] + 1) - maxPicNum;
else else
picNumLXNoWrap = picNumLXPred + (abs_diff_pic_num_minus1[i] + 1); picNumLXNoWrap = picNumLXPred + (abs_diff_pic_num_minus1[i] + 1);
@@ -1339,11 +1336,10 @@ static RK_U32 check_ref_pic_list(H264_SLICE_t *currSlice, RK_S32 cur_list)
p_Vid->p_Dec->p_Vid->g_framecnt, tmp->mem_mark->slot_idx, i, mpp_frame_get_errinfo(mframe)); p_Vid->p_Dec->p_Vid->g_framecnt, tmp->mem_mark->slot_idx, i, mpp_frame_get_errinfo(mframe));
} }
} else { //!< missing short reference, and fake a reference } else { //!< missing short reference, and fake a reference
H264D_DBG(H264D_DBG_DPB_REF_ERR, "[DPB_REF_ERR] missing short ref, structure=%d, pic_num=%d", H264D_DBG(H264D_DBG_DPB_REF_ERR, "[DPB_REF_ERR] missing short ref, structure=%d, pic_num=%d", currSlice->structure, picNumLX);
currSlice->structure, picNumLX);
ASSERT(tmp != NULL); ASSERT(tmp != NULL);
if (tmp) { if (tmp) {
//fake_short_term_pic(currSlice, picNumLX, tmp); fake_short_term_pic(currSlice, picNumLX, tmp);
} }
dpb_error_flag |= 0; dpb_error_flag |= 0;
} }
@@ -1362,7 +1358,7 @@ static RK_U32 check_ref_dbp_err(H264_DecCtx_t *p_Dec, H264_RefPicInfo_t *pref)
RK_U32 dpb_error_flag = 0; RK_U32 dpb_error_flag = 0;
for (i = 0; i < MAX_REF_SIZE; i++) { for (i = 0; i < MAX_REF_SIZE; i++) {
if (pref[i].valid && (i < MAX_REF_SIZE)) { if (pref[i].valid) {
RK_U32 slot_idx = 0; RK_U32 slot_idx = 0;
MppFrame mframe = NULL; MppFrame mframe = NULL;
slot_idx = p_Dec->dpb_info[pref->dpb_idx].slot_index; slot_idx = p_Dec->dpb_info[pref->dpb_idx].slot_index;
@@ -1387,19 +1383,17 @@ static void check_refer_lists(H264_SLICE_t *currSlice)
#if 1 #if 1
if ((currSlice->slice_type % 5) != I_SLICE if ((currSlice->slice_type % 5) != I_SLICE
&& (currSlice->slice_type % 5) != SI_SLICE) { && (currSlice->slice_type % 5) != SI_SLICE) {
if (currSlice->ref_pic_list_reordering_flag[LIST_0]){ if (currSlice->ref_pic_list_reordering_flag[LIST_0]) {
p_Dec->errctx.dpb_err_flag |= check_ref_pic_list(currSlice, 0); p_Dec->errctx.dpb_err_flag |= check_ref_pic_list(currSlice, 0);
} } else {
else {
p_Dec->errctx.dpb_err_flag |= check_ref_dbp_err(p_Dec, p_Dec->refpic_info_b[0]); p_Dec->errctx.dpb_err_flag |= check_ref_dbp_err(p_Dec, p_Dec->refpic_info_b[0]);
} }
} }
if (currSlice->slice_type % 5 == B_SLICE) { if (currSlice->slice_type % 5 == B_SLICE) {
if (currSlice->ref_pic_list_reordering_flag[LIST_1]) { if (currSlice->ref_pic_list_reordering_flag[LIST_1]) {
p_Dec->errctx.dpb_err_flag |= check_ref_pic_list(currSlice, 1); p_Dec->errctx.dpb_err_flag |= check_ref_pic_list(currSlice, 1);
} } else {
else {
p_Dec->errctx.dpb_err_flag |= check_ref_dbp_err(p_Dec, p_Dec->refpic_info_b[1]); p_Dec->errctx.dpb_err_flag |= check_ref_dbp_err(p_Dec, p_Dec->refpic_info_b[1]);
} }
} }

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

@@ -71,10 +71,10 @@ static MPP_RET parser_pps(BitReadCtx_t *p_bitctx, H264_SPS_t *cur_sps, H264_PPS_
READ_UE(p_bitctx, &cur_pps->pic_parameter_set_id, "pic_parameter_set_id"); READ_UE(p_bitctx, &cur_pps->pic_parameter_set_id, "pic_parameter_set_id");
READ_UE(p_bitctx, &cur_pps->seq_parameter_set_id, "seq_parameter_set_id"); READ_UE(p_bitctx, &cur_pps->seq_parameter_set_id, "seq_parameter_set_id");
//VAL_CHECK(ret, cur_pps->seq_parameter_set_id < 32); //VAL_CHECK(ret, cur_pps->seq_parameter_set_id < 32);
if (cur_pps->seq_parameter_set_id <0 || cur_pps->seq_parameter_set_id > 32) { if (cur_pps->seq_parameter_set_id < 0 || cur_pps->seq_parameter_set_id > 32) {
cur_pps->seq_parameter_set_id = 0; cur_pps->seq_parameter_set_id = 0;
} }
if (cur_pps->pic_parameter_set_id <0 || cur_pps->pic_parameter_set_id > 256) { if (cur_pps->pic_parameter_set_id < 0 || cur_pps->pic_parameter_set_id > 256) {
cur_pps->pic_parameter_set_id = 0; cur_pps->pic_parameter_set_id = 0;
} }
READ_ONEBIT(p_bitctx, &cur_pps->entropy_coding_mode_flag, "entropy_coding_mode_flag"); READ_ONEBIT(p_bitctx, &cur_pps->entropy_coding_mode_flag, "entropy_coding_mode_flag");

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

@@ -252,8 +252,7 @@ static MPP_RET check_sps_pps(H264_SPS_t *sps, H264_subSPS_t *subset_sps, H264_PP
H264D_ERR("sps has error, sps_id=%d", sps->seq_parameter_set_id); H264D_ERR("sps has error, sps_id=%d", sps->seq_parameter_set_id);
goto __FAILED; goto __FAILED;
} }
if (subset_sps) //!< MVC if (subset_sps) { //!< MVC
{
ret |= (subset_sps->num_views_minus1 != 1); ret |= (subset_sps->num_views_minus1 != 1);
// ret |= (subset_sps->num_anchor_refs_l0[0] != 1); // ret |= (subset_sps->num_anchor_refs_l0[0] != 1);
if (subset_sps->num_anchor_refs_l0[0] > 0) if (subset_sps->num_anchor_refs_l0[0] > 0)

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

@@ -170,7 +170,7 @@ static MPP_RET parser_sps(BitReadCtx_t *p_bitctx, H264_SPS_t *cur_sps, H264_DecC
ASSERT(temp == 0); ASSERT(temp == 0);
READ_BITS(p_bitctx, 8, &cur_sps->level_idc, "level_idc"); READ_BITS(p_bitctx, 8, &cur_sps->level_idc, "level_idc");
READ_UE(p_bitctx, &cur_sps->seq_parameter_set_id, "seq_parameter_set_id"); READ_UE(p_bitctx, &cur_sps->seq_parameter_set_id, "seq_parameter_set_id");
if (cur_sps->seq_parameter_set_id <0 || cur_sps->seq_parameter_set_id > 32) { if (cur_sps->seq_parameter_set_id < 0 || cur_sps->seq_parameter_set_id > 32) {
cur_sps->seq_parameter_set_id = 0; cur_sps->seq_parameter_set_id = 0;
} }
if (cur_sps->profile_idc == 100 || cur_sps->profile_idc == 110 if (cur_sps->profile_idc == 100 || cur_sps->profile_idc == 110

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

@@ -2036,7 +2036,7 @@ MPP_RET h265d_callback(void *ctx, void *err_info)
H265dContext_t *h265dctx = (H265dContext_t *)ctx; H265dContext_t *h265dctx = (H265dContext_t *)ctx;
HEVCContext *s = (HEVCContext *)h265dctx->priv_data; HEVCContext *s = (HEVCContext *)h265dctx->priv_data;
RK_U32 i = 0; RK_U32 i = 0;
if(s->first_nal_type >= 16 && s->first_nal_type <= 23){ if (s->first_nal_type >= 16 && s->first_nal_type <= 23) {
mpp_log("IS_IRAP frame found error"); mpp_log("IS_IRAP frame found error");
s->max_ra = INT_MAX; s->max_ra = INT_MAX;
} }

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

@@ -137,7 +137,6 @@ static void rkv_write_pps_to_fifo(H264dHalCtx_t *p_hal, FifoCtx_t *pkt)
} else { } else {
Scaleing_list_address += offset; Scaleing_list_address += offset;
} }
//mpp_log("Scaleing_list_address=%08x \n", Scaleing_list_address);
#if FPGA_TEST #if FPGA_TEST
fifo_write_bits(pkt, 0, 32, "Scaleing_list_address"); fifo_write_bits(pkt, 0, 32, "Scaleing_list_address");
#else #else
@@ -361,9 +360,6 @@ void rkv_prepare_scanlist_packet(void *hal, FifoCtx_t *pkt)
//extern "C" //extern "C"
void rkv_generate_regs(void *hal, HalTaskInfo *task, FifoCtx_t *pkt) void rkv_generate_regs(void *hal, HalTaskInfo *task, FifoCtx_t *pkt)
{ {
RK_S32 i = 0;
MppBuffer frame_buf = NULL;
MppBuffer bitstream_buf = NULL;
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;
H264dRkvRegs_t *p_regs = (H264dRkvRegs_t *)p_hal->regs; H264dRkvRegs_t *p_regs = (H264dRkvRegs_t *)p_hal->regs;
@@ -371,13 +367,20 @@ void rkv_generate_regs(void *hal, HalTaskInfo *task, FifoCtx_t *pkt)
FunctionIn(p_hal->logctx.parr[RUN_HAL]); FunctionIn(p_hal->logctx.parr[RUN_HAL]);
memset(p_regs, 0, sizeof(H264dRkvRegs_t)); memset(p_regs, 0, sizeof(H264dRkvRegs_t));
//!< set dec_mode && rlc_mode && rps_mode && slice_num
{
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 = (RK_U32)mpp_packet_get_length(task->dec.input_packet); p_regs->swreg5_stream_rlc_len.sw_stream_len = (RK_U32)mpp_packet_get_length(task->dec.input_packet);
} }
if (p_regs->swreg2_sysctrl.sw_h264_rps_mode) { // rps_mode == 1
p_regs->swreg43_rps_base.sw_rps_base += 0x8;
}
p_regs->swreg3_picpar.sw_slice_num_lowbits = 0x7ff; // p_Vid->iNumOfSlicesDecoded & 0x7ff
p_regs->swreg3_picpar.sw_slice_num_highbit = 1; // (p_Vid->iNumOfSlicesDecoded >> 11) & 1
}
//!< caculate the yuv_frame_size //!< caculate the yuv_frame_size
{ {
MppFrame cur_frame = NULL; MppFrame cur_frame = NULL;
@@ -402,8 +405,6 @@ void rkv_generate_regs(void *hal, HalTaskInfo *task, FifoCtx_t *pkt)
p_regs->swreg3_picpar.sw_uv_hor_virstride = hor_virstride / 16; p_regs->swreg3_picpar.sw_uv_hor_virstride = hor_virstride / 16;
p_regs->swreg8_y_virstride.sw_y_virstride = y_virstride / 16; p_regs->swreg8_y_virstride.sw_y_virstride = y_virstride / 16;
p_regs->swreg9_yuv_virstride.sw_yuv_virstride = yuv_virstride / 16; p_regs->swreg9_yuv_virstride.sw_yuv_virstride = yuv_virstride / 16;
//mpp_log("$$$$$$$$ hor_stride=%d, y_stride=%d, yuv_stride=%d \n", p_regs->swreg3_picpar.sw_y_hor_virstride,
// p_regs->swreg8_y_virstride.sw_y_virstride, p_regs->swreg9_yuv_virstride.sw_yuv_virstride);
} }
//!< caculate mv_size //!< caculate mv_size
{ {
@@ -413,25 +414,25 @@ void rkv_generate_regs(void *hal, HalTaskInfo *task, FifoCtx_t *pkt)
mv_size = mb_width * mb_height * 8; // 64bit per 4x4 mv_size = mb_width * mb_height * 8; // 64bit per 4x4
p_regs->compare_len = (p_regs->swreg9_yuv_virstride.sw_yuv_virstride + mv_size) * 2; p_regs->compare_len = (p_regs->swreg9_yuv_virstride.sw_yuv_virstride + mv_size) * 2;
} }
if (p_regs->swreg2_sysctrl.sw_h264_rps_mode) { // rps_mode == 1
p_regs->swreg43_rps_base.sw_rps_base += 0x8;
}
p_regs->swreg3_picpar.sw_slice_num_lowbits = 0x7ff; // p_Vid->iNumOfSlicesDecoded & 0x7ff
p_regs->swreg3_picpar.sw_slice_num_highbit = 1; // (p_Vid->iNumOfSlicesDecoded >> 11) & 1
//!< set current //!< set current
{
MppBuffer frame_buf = NULL;
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
#if FPGA_TEST #if FPGA_TEST
p_regs->swreg7_decout_base.sw_decout_base = pp->CurrPic.Index7Bits + 1; p_regs->swreg7_decout_base.sw_decout_base = pp->CurrPic.Index7Bits + 1;
#else #else
p_regs->swreg7_decout_base.sw_decout_base = mpp_buffer_get_fd(frame_buf); p_regs->swreg7_decout_base.sw_decout_base = mpp_buffer_get_fd(frame_buf);
//mpp_log_f("line=%d, decout_fd=%d over \n", __LINE__, mpp_buffer_get_fd(frame_buf));
#endif #endif
}
//!< set reference //!< set reference
{
RK_S32 i = 0;
RK_S32 ref_index = -1;
RK_S32 near_index = -1;
MppBuffer frame_buf = NULL;
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];
p_regs->swreg49_63_refer15_29_poc[i] = (i & 1) ? pp->FieldOrderCntList[(i + 15) / 2][0] : pp->FieldOrderCntList[(i + 15) / 2][1]; p_regs->swreg49_63_refer15_29_poc[i] = (i & 1) ? pp->FieldOrderCntList[(i + 15) / 2][0] : pp->FieldOrderCntList[(i + 15) / 2][1];
@@ -439,53 +440,61 @@ void rkv_generate_regs(void *hal, HalTaskInfo *task, FifoCtx_t *pkt)
p_regs->swreg10_24_refer0_14_base[i].sw_ref_topfield_used = (pp->UsedForReferenceFlags >> (2 * i + 0)) & 0x01; p_regs->swreg10_24_refer0_14_base[i].sw_ref_topfield_used = (pp->UsedForReferenceFlags >> (2 * i + 0)) & 0x01;
p_regs->swreg10_24_refer0_14_base[i].sw_ref_botfield_used = (pp->UsedForReferenceFlags >> (2 * i + 1)) & 0x01; p_regs->swreg10_24_refer0_14_base[i].sw_ref_botfield_used = (pp->UsedForReferenceFlags >> (2 * i + 1)) & 0x01;
p_regs->swreg10_24_refer0_14_base[i].sw_ref_colmv_use_flag = (pp->RefPicColmvUsedFlags >> i) & 0x01; p_regs->swreg10_24_refer0_14_base[i].sw_ref_colmv_use_flag = (pp->RefPicColmvUsedFlags >> i) & 0x01;
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_log_f("line=%d, ref[%d]=%d over \n", __LINE__, i, mpp_buffer_get_fd(frame_buf));
#if FPGA_TEST #if FPGA_TEST
p_regs->swreg10_24_refer0_14_base[i].sw_refer_base = pp->RefFrameList[i].Index7Bits + 1; p_regs->swreg10_24_refer0_14_base[i].sw_refer_base = pp->RefFrameList[i].Index7Bits + 1;
#else #else
if (pp->RefFrameList[i].bPicEntry != 0xff) {
ref_index = pp->RefFrameList[i].Index7Bits;
near_index = pp->RefFrameList[i].Index7Bits;
}
if (near_index < 0) {
ref_index = pp->CurrPic.Index7Bits;
} else {
ref_index = pp->RefFrameList[i].Index7Bits;
}
mpp_buf_slot_get_prop(p_hal->frame_slots, ref_index, SLOT_BUFFER, &frame_buf); //!< reference phy addr
p_regs->swreg10_24_refer0_14_base[i].sw_refer_base = mpp_buffer_get_fd(frame_buf); p_regs->swreg10_24_refer0_14_base[i].sw_refer_base = mpp_buffer_get_fd(frame_buf);
#endif #endif
} }
p_regs->swreg72_refer30_poc = pp->FieldOrderCntList[i][0]; p_regs->swreg72_refer30_poc = pp->FieldOrderCntList[15][0];
p_regs->swreg73_refer31_poc = pp->FieldOrderCntList[i][1]; p_regs->swreg73_refer31_poc = pp->FieldOrderCntList[15][1];
p_regs->swreg48_refer15_base.sw_ref_field = (pp->RefPicFiledFlags >> 15) & 0x01; p_regs->swreg48_refer15_base.sw_ref_field = (pp->RefPicFiledFlags >> 15) & 0x01;
p_regs->swreg48_refer15_base.sw_ref_topfield_used = (pp->UsedForReferenceFlags >> 30) & 0x01; p_regs->swreg48_refer15_base.sw_ref_topfield_used = (pp->UsedForReferenceFlags >> 30) & 0x01;
p_regs->swreg48_refer15_base.sw_ref_botfield_used = (pp->UsedForReferenceFlags >> 31) & 0x01; p_regs->swreg48_refer15_base.sw_ref_botfield_used = (pp->UsedForReferenceFlags >> 31) & 0x01;
p_regs->swreg48_refer15_base.sw_ref_colmv_use_flag = (pp->RefPicColmvUsedFlags >> 15) & 0x01; p_regs->swreg48_refer15_base.sw_ref_colmv_use_flag = (pp->RefPicColmvUsedFlags >> 15) & 0x01;
#if FPGA_TEST
p_regs->swreg48_refer15_base.sw_refer_base = pp->RefFrameList[15].Index7Bits + 1;
#else
if (pp->RefFrameList[15].bPicEntry == 0xff) { if (pp->RefFrameList[15].bPicEntry == 0xff) {
mpp_buf_slot_get_prop(p_hal->frame_slots, pp->CurrPic.Index7Bits, SLOT_BUFFER, &frame_buf); //!< current out phy addr ref_index = pp->CurrPic.Index7Bits;
} else { } else {
mpp_buf_slot_get_prop(p_hal->frame_slots, pp->RefFrameList[15].Index7Bits, SLOT_BUFFER, &frame_buf); //!< reference phy addr ref_index = pp->RefFrameList[15].Index7Bits;
}
mpp_buf_slot_get_prop(p_hal->frame_slots, ref_index, SLOT_BUFFER, &frame_buf); //!< reference phy addr
p_regs->swreg48_refer15_base.sw_refer_base = mpp_buffer_get_fd(frame_buf);
#endif
} }
#if FPGA_TEST #if FPGA_TEST
p_regs->swreg48_refer15_base.sw_refer_base = pp->RefFrameList[15].Index7Bits + 1;
p_regs->swreg4_strm_rlc_base.sw_strm_rlc_base = 0; p_regs->swreg4_strm_rlc_base.sw_strm_rlc_base = 0;
p_regs->swreg6_cabactbl_prob_base.sw_cabactbl_base = 0; p_regs->swreg6_cabactbl_prob_base.sw_cabactbl_base = 0;
p_regs->swreg41_rlcwrite_base.sw_rlcwrite_base = 0;
#else #else
p_regs->swreg48_refer15_base.sw_refer_base = mpp_buffer_get_fd(frame_buf); {
//mpp_log_f("line=%d, ref[%d]=%d over \n", __LINE__, 15, mpp_buffer_get_fd(frame_buf)); MppBuffer bitstream_buf = NULL;
p_regs->swreg6_cabactbl_prob_base.sw_cabactbl_base = mpp_buffer_get_fd(p_hal->cabac_buf);
//mpp_log_f("line=%d, cabac_table_fd=%d over \n", __LINE__, mpp_buffer_get_fd(p_hal->cabac_buf));
mpp_buf_slot_get_prop(p_hal->packet_slots, task->dec.input, SLOT_BUFFER, &bitstream_buf); 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);
//mpp_log_f("line=%d, rlc_base_fd=%d over \n", __LINE__,mpp_buffer_get_fd(bitstream_buf)); p_regs->swreg6_cabactbl_prob_base.sw_cabactbl_base = mpp_buffer_get_fd(p_hal->cabac_buf);
p_regs->swreg41_rlcwrite_base.sw_rlcwrite_base = p_regs->swreg4_strm_rlc_base.sw_strm_rlc_base; p_regs->swreg41_rlcwrite_base.sw_rlcwrite_base = p_regs->swreg4_strm_rlc_base.sw_strm_rlc_base;
}
#endif #endif
fifo_packet_reset(pkt); fifo_packet_reset(pkt);
fifo_write_bytes(pkt, (void *)p_hal->regs, 80 * sizeof(RK_U32)); fifo_write_bytes(pkt, (void *)p_hal->regs, 80 * sizeof(RK_U32));
{ {
RK_U32 i = 0;
RK_U32 *ptr = (RK_U32*)p_hal->regs; RK_U32 *ptr = (RK_U32*)p_hal->regs;
LogInfo(pkt->logctx, "------------------ Frame REG begin ------------------------"); LogInfo(pkt->logctx, "------------------ Frame REG begin ------------------------");
for (i = 0; i < 80; i++) { for (i = 0; i < 80; i++) {
//fifo_write_bits(pkt, ptr[i], 32, "reg"); //!< not used in hard
LogInfo(pkt->logctx, " reg[%3d] = %08x \n", i, ptr[i]); LogInfo(pkt->logctx, " reg[%3d] = %08x \n", i, ptr[i]);
} }
} }

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

@@ -213,8 +213,7 @@ static void rkv_h264d_hal_dump(H264dHalCtx_t *p_hal, RK_U32 dump_type)
RK_U32 i = 0; RK_U32 i = 0;
RK_U32 *p_hal_regs = NULL; RK_U32 *p_hal_regs = NULL;
H264dRkvErrDump_t *p_dump = (H264dRkvErrDump_t *)p_hal->dump; H264dRkvErrDump_t *p_dump = (H264dRkvErrDump_t *)p_hal->dump;
switch (dump_type) switch (dump_type) {
{
case H264D_DBG_GEN_REGS: case H264D_DBG_GEN_REGS:
p_hal_regs = (RK_U32 *)p_dump->in_regs; p_hal_regs = (RK_U32 *)p_dump->in_regs;
mpp_log("------- register input ------ \n"); mpp_log("------- register input ------ \n");

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

@@ -221,12 +221,11 @@ typedef struct h264d_rkv_regs_t {
/* Number registers for the decoder */ /* Number registers for the decoder */
#define DEC_RKV_REGISTERS 78 #define DEC_RKV_REGISTERS 78
typedef struct h264d_rkv_err_dump_t typedef struct h264d_rkv_err_dump_t {
{
RK_U32 in_regs[DEC_RKV_REGISTERS]; RK_U32 in_regs[DEC_RKV_REGISTERS];
RK_U32 *out_regs; RK_U32 *out_regs;
}H264dRkvErrDump_t; } H264dRkvErrDump_t;

6
mpp/hal/rkdec/vp9d/hal_vp9d_api.c
View File

@@ -715,10 +715,10 @@ MPP_RET hal_vp9d_gen_regs(void *hal, HalTaskInfo *task)
/*0 map to 11*/ /*0 map to 11*/
/*1 map to 12*/ /*1 map to 12*/
/*2 map to 13*/ /*2 map to 13*/
if(framebuf != NULL){ if (framebuf != NULL) {
reg_ref_base[i] = mpp_buffer_get_fd(framebuf); reg_ref_base[i] = mpp_buffer_get_fd(framebuf);
}else{ } else {
mpp_log("ref buff address is no valid used out as base slot index 0x%x",pic_param->ref_frame_map[ref_idx].Index7Bits); mpp_log("ref buff address is no valid used out as base slot index 0x%x", pic_param->ref_frame_map[ref_idx].Index7Bits);
reg_ref_base[i] = vp9_hw_regs->swreg7_decout_base; //set reg_ref_base[i] = vp9_hw_regs->swreg7_decout_base; //set
} }
#endif #endif

6
mpp/mpp.cpp
View File

@@ -85,9 +85,9 @@ MPP_RET Mpp::init(MppCtxType type, MppCodingType coding)
mpp_dec_init(mDec, coding); mpp_dec_init(mDec, coding);
mThreadCodec = new MppThread(mpp_dec_parser_thread, this); mThreadCodec = new MppThread(mpp_dec_parser_thread, this);
mpp_log("mThreadCodec = %p",mThreadCodec); mpp_log("mThreadCodec = %p", mThreadCodec);
mThreadHal = new MppThread(mpp_dec_hal_thread, this); mThreadHal = new MppThread(mpp_dec_hal_thread, this);
mpp_log("mThreadHal = %p",mThreadHal); mpp_log("mThreadHal = %p", mThreadHal);
mpp_buffer_group_get_internal(&mInternalGroup, MPP_BUFFER_TYPE_ION); mpp_buffer_group_get_internal(&mInternalGroup, MPP_BUFFER_TYPE_ION);
mpp_buffer_group_get_internal(&mPacketGroup, MPP_BUFFER_TYPE_ION); mpp_buffer_group_get_internal(&mPacketGroup, MPP_BUFFER_TYPE_ION);
@@ -299,7 +299,7 @@ MPP_RET Mpp::control(MpiCmd cmd, MppParam param)
mFastMode = mode; mFastMode = mode;
break; break;
} }
case MPP_DEC_GET_STREAM_COUNT:{ case MPP_DEC_GET_STREAM_COUNT: {
AutoMutex autoLock(mPackets->mutex()); AutoMutex autoLock(mPackets->mutex());
mpp_assert(mType == MPP_CTX_DEC); mpp_assert(mType == MPP_CTX_DEC);
*((RK_S32 *)param) = mPackets->list_size(); *((RK_S32 *)param) = mPackets->list_size();

2
osal/mpp_thread.cpp
View File

@@ -64,7 +64,7 @@ void MppThread::stop()
if (MPP_THREAD_UNINITED != mStatus) { if (MPP_THREAD_UNINITED != mStatus) {
lock(); lock();
mStatus = MPP_THREAD_STOPPING; mStatus = MPP_THREAD_STOPPING;
mpp_log("MPP_THREAD_STOPPING status set mThread %p",this); mpp_log("MPP_THREAD_STOPPING status set mThread %p", this);
signal(); signal();
unlock(); unlock();
void *dummy; void *dummy;