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 module] add prepare function; deal with error nalu case

Browse Source 
[mpp.c]        function marco define, updated;
[h265d module] update warnning
[all module]   run A style

git-svn-id: https://10.10.10.66:8443/svn/MediaProcessPlatform/trunk/mpp@344 6e48237b-75ef-9749-8fc9-41990f28c85a
This commit is contained in:
DingWei
2015-10-10 02:18:04 +00:00
parent 12b80ea667
commit f82298b20b
30 changed files with 672 additions and 413 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -167,11 +167,12 @@ static MPP_RET free_cur_ctx(H264dCurCtx_t *p_Cur)
FunctionIn(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
if (p_Cur) {
recycle_slice(&p_Cur->slice);
for (i = 0; i < 2; i++) {
for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) {
MPP_FREE(p_Cur->listP[i]);
MPP_FREE(p_Cur->listB[i]);
}
MPP_FREE(p_Cur->strm.buf);
MPP_FREE(p_Cur->strm.nalu_buf);
MPP_FREE(p_Cur->strm.head_buf);
}
FunctionOut(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
__RETURN:
@@ -181,21 +182,28 @@ static MPP_RET init_cur_ctx(H264dCurCtx_t *p_Cur)
{
RK_U32 i = 0;
MPP_RET ret = MPP_ERR_UNKNOW;
H264dCurStream_t *p_strm = NULL;
INP_CHECK(ret, ctx, !p_Cur);
FunctionIn(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
p_Cur->strm.buf = mpp_malloc_size(RK_U8, NALU_BUF_MAX_SIZE);
MEM_CHECK(ret, p_Cur->strm.buf);
p_Cur->strm.max_size = NALU_BUF_MAX_SIZE;
p_Cur->strm.prefixdata[0] = 0xff;
p_Cur->strm.prefixdata[1] = 0xff;
p_Cur->strm.prefixdata[2] = 0xff;
for (i = 0; i < 2; i++) {
p_strm = &p_Cur->strm;
p_strm->nalu_max_size = NALU_BUF_MAX_SIZE;
p_strm->nalu_buf = mpp_malloc_size(RK_U8, p_strm->nalu_max_size);
p_strm->head_max_size = HEAD_BUF_MAX_SIZE;
p_strm->head_buf = mpp_malloc_size(RK_U8, p_strm->head_max_size);
MEM_CHECK(ret, p_strm->nalu_buf && p_strm->head_buf);
p_strm->prefixdata[0] = 0xff;
p_strm->prefixdata[1] = 0xff;
p_strm->prefixdata[2] = 0xff;
for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) {
p_Cur->listP[i] = mpp_malloc_size(H264_StorePic_t*, MAX_LIST_SIZE * sizeof(H264_StorePic_t*));
p_Cur->listB[i] = mpp_malloc_size(H264_StorePic_t*, MAX_LIST_SIZE * sizeof(H264_StorePic_t*));
MEM_CHECK(ret, p_Cur->listP[i] && p_Cur->listB[i]); // +1 for reordering
}
FunctionOut(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
__RETURN:
return ret = MPP_OK;
__FAILED:
@@ -354,7 +362,8 @@ static MPP_RET init_dec_ctx(H264_DecCtx_t *p_Dec)
p_Dec->spt_decode_mtds = MPP_DEC_BY_FRAME | MPP_DEC_BY_SLICE;
p_Dec->next_state = SliceSTATE_ResetSlice;
p_Dec->nalu_ret = NALU_NULL;
p_Dec->first_frame_flag = 1;
p_Dec->is_first_frame = 1;
p_Dec->is_first_frame2 = 1;
__RETURN:
return ret = MPP_OK;
@@ -450,12 +459,31 @@ __RETURN:
MPP_RET h264d_reset(void *decoder)
{
MPP_RET ret = MPP_ERR_UNKNOW;
H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
INP_CHECK(ret, ctx, decoder);
INP_CHECK(ret, ctx, !decoder);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
//!< reset input parameter
p_Dec->p_Inp->in_buf = NULL;
p_Dec->p_Inp->in_size = 0;
p_Dec->p_Inp->is_eos = 0;
p_Dec->p_Inp->in_timestamp = 0;
p_Dec->p_Inp->out_buf = NULL;
p_Dec->p_Inp->out_length = 0;
//!< reset current stream
p_Dec->p_Cur->strm.prefixdata[0] = 0xff;
p_Dec->p_Cur->strm.prefixdata[1] = 0xff;
p_Dec->p_Cur->strm.prefixdata[2] = 0xff;
//!< reset dpb
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[1], 2));
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
(void)decoder;
__RETURN:
return ret = MPP_OK;
__FAILED:
return ret = MPP_NOK;
}
/*!
@@ -467,12 +495,19 @@ __RETURN:
MPP_RET h264d_flush(void *decoder)
{
MPP_RET ret = MPP_ERR_UNKNOW;
H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
INP_CHECK(ret, ctx, decoder);
INP_CHECK(ret, ctx, !decoder);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
(void)decoder;
FUN_CHECK(ret = flush_dpb(p_Dec->p_Vid->p_Dpb_layer[0]));
FUN_CHECK(ret = flush_dpb(p_Dec->p_Vid->p_Dpb_layer[1]));
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
__RETURN:
return ret = MPP_OK;
__FAILED:
return ret = MPP_NOK;
}
/*!
@@ -484,15 +519,12 @@ __RETURN:
MPP_RET h264d_control(void *decoder, RK_S32 cmd_type, void *param)
{
MPP_RET ret = MPP_ERR_UNKNOW;
INP_CHECK(ret, ctx, decoder);
INP_CHECK(ret, ctx, !decoder);
(void)decoder;
(void)cmd_type;
(void)param;
__RETURN:
return ret = MPP_OK;
}
@@ -504,22 +536,21 @@ __RETURN:
* prepare
***********************************************************************
*/
MPP_RET h264d_prepare(void *decoder, MppPacket in_pkt, HalDecTask *in_task)
MPP_RET h264d_prepare(void *decoder, MppPacket pkt, HalDecTask *task)
{
MPP_RET ret = MPP_ERR_UNKNOW;
H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
MppPacketImpl *pkt = (MppPacketImpl *)in_pkt;
INP_CHECK(ret, ctx, !decoder && !in_pkt && !in_task);
INP_CHECK(ret, ctx, !decoder && !pkt && !task);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
p_Dec->p_Inp->in_buf = (RK_U8 *)pkt->pos;
p_Dec->p_Inp->in_size = &pkt->size;
p_Dec->p_Inp->is_eos = pkt->flag & MPP_PACKET_FLAG_EOS;
p_Dec->p_Inp->in_buf = (RK_U8 *)mpp_packet_get_pos(pkt);
p_Dec->p_Inp->in_length = mpp_packet_get_length(pkt);
p_Dec->p_Inp->is_eos = mpp_packet_get_eos(pkt);
p_Dec->p_Inp->in_size = &((MppPacketImpl *)pkt)->length;
do {
(ret = parse_prepare(p_Dec->p_Inp, p_Dec->p_Cur));
task->valid = p_Dec->p_Inp->task_valid; // prepare valid flag
} while (mpp_packet_get_length(pkt) && !task->valid);
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
__RETURN:
@@ -542,10 +573,10 @@ MPP_RET h264d_parse(void *decoder, HalDecTask *in_task)
INP_CHECK(ret, ctx, !decoder && !in_task);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
in_task->valid = 0; // prepare end flag
FUN_CHECK(ret = parse_loop(p_Dec));
if (p_Dec->parser_end_flag) {
in_task->valid = 1;
if (p_Dec->is_parser_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));

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

@@ -21,11 +21,10 @@
#include <string.h>
#include "mpp_mem.h"
#include "mpp_common.h"
#include "h264d_log.h"
#include "h264d_scalist.h"
#include "h264d_dpb.h"
@@ -114,9 +113,9 @@ static RK_S32 getDpbSize(H264dVideoCtx_t *p_Vid, H264_SPS_t *active_sps)
if (p_Vid->active_mvc_sps_flag &&
(p_Vid->profile_idc == MVC_HIGH || p_Vid->profile_idc == STEREO_HIGH)) {
num_views = p_Vid->active_subsps->num_views_minus1 + 1;
size = min(2 * size, max(1, RoundLog2(num_views)) * 16) / num_views;
size = MPP_MIN(2 * size, MPP_MAX(1, RoundLog2(num_views)) * 16) / num_views;
} else {
size = min(size, 16);
size = MPP_MIN(size, 16);
}
return size;
@@ -552,7 +551,7 @@ static void sliding_window_memory_management(H264_DpbBuf_t *p_Dpb, H264_StorePic
RK_U32 i = 0;
// if this is a reference pic with sliding window, unmark first ref frame
if (p_Dpb->ref_frames_in_buffer == max(1, p_Dpb->num_ref_frames) - p_Dpb->ltref_frames_in_buffer) {
if (p_Dpb->ref_frames_in_buffer == MPP_MAX(1, p_Dpb->num_ref_frames) - p_Dpb->ltref_frames_in_buffer) {
for (i = 0; i < p_Dpb->used_size; i++) {
if (p_Dpb->fs[i]->is_reference && (!(p_Dpb->fs[i]->is_long_term))) {
unmark_for_reference(p_Dpb->fs[i]);
@@ -568,8 +567,8 @@ static void check_num_ref(H264_DpbBuf_t *p_Dpb)
{
LogCtx_t *runlog = p_Dpb->p_Vid->p_Dec->logctx.parr[RUN_PARSE];
if ((RK_S32)(p_Dpb->ltref_frames_in_buffer + p_Dpb->ref_frames_in_buffer) > max(1, p_Dpb->num_ref_frames)) {
if ((RK_S32)(p_Dpb->ltref_frames_in_buffer + p_Dpb->ref_frames_in_buffer) > max(1, p_Dpb->num_ref_frames)) {
if ((RK_S32)(p_Dpb->ltref_frames_in_buffer + p_Dpb->ref_frames_in_buffer) > MPP_MAX(1, p_Dpb->num_ref_frames)) {
if ((RK_S32)(p_Dpb->ltref_frames_in_buffer + p_Dpb->ref_frames_in_buffer) > MPP_MAX(1, p_Dpb->num_ref_frames)) {
sliding_window_memory_management(p_Dpb, NULL);
LogWarnning(runlog, "Max number of reference frames exceeded");
}
@@ -753,7 +752,7 @@ static MPP_RET dpb_combine_field_yuv(H264dVideoCtx_t *p_Vid, H264_FrameStore_t *
ASSERT(fs->is_used == 0x03);
}
}
fs->poc = fs->frame->poc = fs->frame->frame_poc = min(fs->top_field->poc, fs->bottom_field->poc);
fs->poc = fs->frame->poc = fs->frame->frame_poc = MPP_MIN(fs->top_field->poc, fs->bottom_field->poc);
fs->bottom_field->frame_poc = fs->top_field->frame_poc = fs->frame->poc;
fs->bottom_field->top_poc = fs->frame->top_poc = fs->top_field->poc;
fs->top_field->bottom_poc = fs->frame->bottom_poc = fs->bottom_field->poc;
@@ -781,7 +780,7 @@ static MPP_RET dpb_combine_field_yuv(H264dVideoCtx_t *p_Vid, H264_FrameStore_t *
fs->bottom_field->bottom_field = fs->bottom_field;
fs->frame->is_mmco_5 = fs->top_field->is_mmco_5 || fs->bottom_field->is_mmco_5;
fs->frame->poc_mmco5 = min(fs->top_field->top_poc_mmco5, fs->bottom_field->bot_poc_mmco5);
fs->frame->poc_mmco5 = MPP_MIN(fs->top_field->top_poc_mmco5, fs->bottom_field->bot_poc_mmco5);
fs->frame->top_poc_mmco5 = fs->top_field->top_poc_mmco5;
fs->frame->bot_poc_mmco5 = fs->top_field->bot_poc_mmco5;
@@ -967,11 +966,11 @@ static MPP_RET adaptive_memory_management(H264_DpbBuf_t *p_Dpb, H264_StorePic_t
p->is_mmco_5 = 1;
p->top_poc_mmco5 = p->top_poc;
p->bot_poc_mmco5 = p->bottom_poc;
p->poc_mmco5 = min(p->top_poc, p->bottom_poc);
p->poc_mmco5 = MPP_MIN(p->top_poc, p->bottom_poc);
p->top_poc -= p->poc;
p->bottom_poc -= p->poc;
p->poc = min(p->top_poc, p->bottom_poc);
p->poc = MPP_MIN(p->top_poc, p->bottom_poc);
p->frame_poc = p->poc;
break;
@@ -1646,12 +1645,10 @@ MPP_RET exit_picture(H264dVideoCtx_t *p_Vid, H264_StorePic_t **dec_picture)
set_curframe_poc((*dec_picture), &p_Vid->p_Dec->regs);
#endif
FUN_CHECK(ret = store_picture_in_dpb(p_Vid->p_Dpb_layer[(*dec_picture)->layer_id], *dec_picture));
FPRINT(g_debug_file1, "decoder ending, g_framecnt=%d \n", p_Vid->g_framecnt);
// FPRINT(g_debug_file0, "decoder ending, g_framecnt=%d \n", p_Vid->g_framecnt);
//FPRINT(g_debug_file1, "decoder ending, g_framecnt=%d \n", p_Vid->g_framecnt);
mpp_log("decoder ending, g_framecnt=%d \n", p_Vid->g_framecnt++);
#if 0
update_all_logctx_framenum(&p_Vid->p_Dec->logctx, p_Vid->g_framecnt);
#endif
@@ -1876,7 +1873,7 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
voidx = p_Dec->dpb_info[i].voidx;
is_used = p_Dec->dpb_info[i].is_used;
if (currSlice->structure == FRAME && picbuf) {
if (poc == min(TOP_POC, BOT_POC) && (layer_id == voidx))
if (poc == MPP_MIN(TOP_POC, BOT_POC) && (layer_id == voidx))
break;
} else {
if (is_used == 3) {
@@ -1929,7 +1926,7 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
voidx = p_Dec->dpb_info[i].voidx;
is_used = p_Dec->dpb_info[i].is_used;
if (currSlice->structure == FRAME && picbuf) {
if (poc == min(TOP_POC, BOT_POC) && (layer_id == voidx))
if (poc == MPP_MIN(TOP_POC, BOT_POC) && (layer_id == voidx))
break;
} else {
if (is_used == 3) {
@@ -1975,7 +1972,7 @@ MPP_RET update_dpb(H264_DecCtx_t *p_Dec)
{
MPP_RET ret = MPP_ERR_UNKNOW;
p_Dec->parser_end_flag = 0;
p_Dec->is_parser_end = 0;
p_Dec->p_Vid->exit_picture_flag = 1;
p_Dec->p_Vid->have_outpicture_flag = 1;
FUN_CHECK(ret = exit_picture(p_Dec->p_Vid, &p_Dec->p_Vid->dec_picture));

4
mpp/codec/dec/h264/h264d_dpb.h
View File

@@ -36,8 +36,8 @@ MPP_RET idr_memory_management(H264_DpbBuf_t *p_Dpb, H264_StorePic_t *p);
MPP_RET insert_picture_in_dpb(H264dVideoCtx_t *p_Vid, H264_FrameStore_t *fs, H264_StorePic_t *p, RK_U8 combine_flag);
MPP_RET init_dpb (H264dVideoCtx_t *p_Vid, H264_DpbBuf_t *p_Dpb, RK_S32 type);
MPP_RET flush_dpb(H264_DpbBuf_t *p_Dpb);
MPP_RET update_dpb(H264_DecCtx_t *p_Dec);
MPP_RET flush_dpb (H264_DpbBuf_t *p_Dpb);
MPP_RET update_dpb (H264_DecCtx_t *p_Dec);
void free_dpb (H264_DpbBuf_t *p_Dpb);
MPP_RET exit_picture(H264dVideoCtx_t *p_Vid, H264_StorePic_t **dec_picture);
MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice);

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

@@ -46,23 +46,23 @@ __FAILED:
}
static MPP_RET realloc_stream_buffer(H264dDxvaCtx_t *dxva_ctx, RK_U32 stream_add)
{
MPP_RET ret = MPP_ERR_UNKNOW;
if (stream_add > FRAME_BUF_ADD_SIZE) {
dxva_ctx->max_strm_size += ALIGN(stream_add, 128);
} else {
dxva_ctx->max_strm_size += FRAME_BUF_ADD_SIZE;
}
dxva_ctx->bitstream = mpp_realloc(dxva_ctx->bitstream, RK_U8, dxva_ctx->max_strm_size);
MEM_CHECK (ret, dxva_ctx->bitstream);
return ret = MPP_OK;
__FAILED:
ASSERT(0);
return ret;
}
//static MPP_RET realloc_stream_buffer(H264dDxvaCtx_t *dxva_ctx, RK_U32 stream_add)
//{
// MPP_RET ret = MPP_ERR_UNKNOW;
//
// if (stream_add > FRAME_BUF_ADD_SIZE) {
// dxva_ctx->max_strm_size += ALIGN(stream_add, 128);
// } else {
// dxva_ctx->max_strm_size += FRAME_BUF_ADD_SIZE;
// }
// dxva_ctx->bitstream = mpp_realloc(dxva_ctx->bitstream, RK_U8, dxva_ctx->max_strm_size);
// MEM_CHECK (ret, dxva_ctx->bitstream);
//
// return ret = MPP_OK;
//__FAILED:
// ASSERT(0);
// return ret;
//}
static MPP_RET fill_stream_data(H264dDxvaCtx_t *dxva_ctx, H264_Nalu_t *p_nal)
{
@@ -74,20 +74,24 @@ static MPP_RET fill_stream_data(H264dDxvaCtx_t *dxva_ctx, H264_Nalu_t *p_nal)
if (dxva_ctx->slice_count >= dxva_ctx->max_slice_size) {
FUN_CHECK(ret = realloc_slice_list(dxva_ctx));
}
streamlen_add = p_nal->sodb_len + sizeof(start_code);
stream_offset = dxva_ctx->strm_offset + streamlen_add;
if (stream_offset > dxva_ctx->max_strm_size) {
FUN_CHECK (ret = realloc_stream_buffer(dxva_ctx, streamlen_add));
}
//streamlen_add = p_nal->sodb_len + sizeof(start_code);
//stream_offset = dxva_ctx->strm_offset + streamlen_add;
//if (stream_offset > dxva_ctx->max_strm_size) {
// FUN_CHECK (ret = realloc_stream_buffer(dxva_ctx, streamlen_add));
//}
p_long = &dxva_ctx->slice_long[dxva_ctx->slice_count];
memset(p_long, 0, sizeof(DXVA_Slice_H264_Long));
p_long->BSNALunitDataLocation = dxva_ctx->strm_offset;
p_long->wBadSliceChopping = 0; //!< set to 0 in Rock-Chip RKVDEC IP
memcpy(&dxva_ctx->bitstream[dxva_ctx->strm_offset], start_code, sizeof(start_code));
dxva_ctx->strm_offset += sizeof(start_code);
memcpy(&dxva_ctx->bitstream[dxva_ctx->strm_offset], p_nal->sodb_buf, p_nal->sodb_len);
dxva_ctx->strm_offset += p_nal->sodb_len;
p_long->SliceBytesInBuffer = dxva_ctx->strm_offset - p_long->BSNALunitDataLocation;
//memcpy(&dxva_ctx->bitstream[dxva_ctx->strm_offset], start_code, sizeof(start_code));
//dxva_ctx->strm_offset += sizeof(start_code);
//memcpy(&dxva_ctx->bitstream[dxva_ctx->strm_offset], p_nal->sodb_buf, p_nal->sodb_len);
//dxva_ctx->strm_offset += p_nal->sodb_len;
//p_long->SliceBytesInBuffer = dxva_ctx->strm_offset - p_long->BSNALunitDataLocation;
(void)p_nal;
(void)stream_offset;
(void)streamlen_add;
return ret = MPP_OK;
__FAILED:

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

@@ -42,17 +42,15 @@
#define DPB_INFO_SIZE 16
#define REFPIC_INFO_SIZE 32
#define MAX_TASK_SIZE 2
#define NALU_BUF_MAX_SIZE 10*1024*1024
#define NALU_BUF_ADD_SIZE 1024
#define NALU_BUF_MAX_SIZE 10
#define NALU_BUF_ADD_SIZE 10
#define HEAD_BUF_MAX_SIZE 10*1024*1024
#define HEAD_BUF_ADD_SIZE 1024
#define SODB_BUF_MAX_SIZE 10*1024*1024
#define SODB_BUF_ADD_SIZE 1024
#ifndef min
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif
#ifndef max
#define max(a,b) (((a) > (b)) ? (a) : (b))
#endif
//!< AVC Profile IDC definitions
typedef enum {
@@ -732,7 +730,7 @@ typedef struct h264_slice_t {
RK_S32 framepoc; //poc of this frame
RK_U32 AbsFrameNum;
RK_S32 PicOrderCntMsb;
RK_S32 is_new_picture_flag;
RK_S32 is_new_picture;
struct h264_sps_t *active_sps;
struct h264_subsps_t *active_subsps;
struct h264_pps_t *active_pps;
@@ -823,18 +821,28 @@ typedef struct h264d_input_ctx_t {
//!< input data
RK_U8 *in_buf;
size_t *in_size;
RK_S64 *in_timestamp;
size_t in_length;
RK_S64 in_timestamp;
//!< output data
RK_U8 *out_buf;
RK_U32 *out_length;
RK_U32 out_length;
RK_U8 task_valid;
} H264dInputCtx_t;
//!< current stream
typedef struct h264d_curstrm_t {
RK_U32 offset; //!< The offset of the input stream
RK_U32 max_size; //!< Cur Unit Buffer size
RK_U8 *buf; //!< store read nalu data
RK_U32 nalu_offset; //!< The offset of the input stream
RK_U32 nalu_max_size; //!< Cur Unit Buffer size
RK_U8 *curdata;
RK_S32 nal_unit_type;
RK_U32 nalu_len;
RK_U8 *nalu_buf; //!< store read nalu data
RK_U32 head_offset;
RK_U32 head_max_size;
RK_U8 *head_buf; //!< store header data, sps/pps/slice header
RK_U8 prefixdata[START_PREFIX_3BYTE];
RK_U8 startcode_found;
RK_U8 endcode_found;
@@ -937,11 +945,11 @@ typedef struct h264d_mem_t {
typedef enum nalu_state_tpye {
NALU_NULL = 0,
//StreamError,
StreamError,
HaveNoStream,
NaluNotSupport,
//ReadNaluError,
//StartofNalu,
ReadNaluError,
StartofNalu,
EndofStream,
//ReallocBufError,
MidOfNalu,
@@ -992,8 +1000,10 @@ typedef struct h264_dec_ctx_t {
RK_U32 spt_decode_mtds; //!< support decoder methods
NALU_STATUS nalu_ret; //!< current nalu state
SLICE_STATUS next_state; //!< RKV_SLICE_STATUS
RK_U8 first_frame_flag;
RK_U8 parser_end_flag;
RK_U8 is_first_frame;
RK_U8 is_first_frame2;
RK_U8 is_new_frame;
RK_U8 is_parser_end;
RK_U8 dxva_idx;
struct h264d_logctx_t logctx; //!< debug log file
struct log_ctx_t logctxbuf[LOG_MAX];

5
mpp/codec/dec/h264/h264d_log.c
View File

@@ -30,7 +30,8 @@
#define LOG_BUF_SIZE 512
RK_U32 g_nalu_cnt = 0;
RK_U32 g_nalu_cnt0 = 0;
RK_U32 g_nalu_cnt1 = 0;
RK_S32 g_max_bytes = 0;
RK_U32 g_max_slice_data = 0;
FILE *g_debug_file0 = NULL;
@@ -87,7 +88,7 @@ static void log_info(void *ctx, ...)
RK_U32 line = 0;
char argbuf[LOG_BUF_SIZE] = { 0 };
if(LogEnable(ctx, LOG_LEVEL_INFO)) {
if (LogEnable(ctx, LOG_LEVEL_INFO)) {
va_list argptr;
va_start(argptr, ctx);
fname = va_arg(argptr, char*);

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

@@ -33,6 +33,16 @@
#include "h264d_init.h"
#include "h264d_fill.h"
#define HEAD_MAX_SIZE 12800
static const RK_U8 g_start_precode[3] = {0, 0, 1};
typedef struct h264d_nalu_head_t {
RK_U16 is_frame_end;
RK_U16 nal_unit_type;
RK_U32 sodb_len;
} H264dNaluHead_t;
static void reset_slice(H264dVideoCtx_t *p_Vid)
{
RK_U32 i = 0, j = 0;
@@ -62,26 +72,26 @@ static void reset_slice(H264dVideoCtx_t *p_Vid)
FunctionOut(p_Vid->p_Dec->logctx.parr[RUN_PARSE]);
}
static MPP_RET realloc_curstrearm_buffer(H264dCurStream_t *p_strm)
static MPP_RET realloc_buffer(RK_U8 **buf, RK_U32 *max_size, RK_U32 add_size)
{
MPP_RET ret = MPP_ERR_UNKNOW;
p_strm->buf = mpp_realloc(p_strm->buf, RK_U8, p_strm->max_size + NALU_BUF_ADD_SIZE);
MEM_CHECK(ret, p_strm->buf);
p_strm->max_size += NALU_BUF_ADD_SIZE;
*buf = mpp_realloc(*buf, RK_U8, *max_size + add_size);
MEM_CHECK(ret, *buf);
*max_size += add_size;
return ret = MPP_OK;
__FAILED:
return ret;
}
static void reset_nalu(H264_Nalu_t*p_nal, H264dCurStream_t *p_strm)
static void reset_nalu(H264dCurStream_t *p_strm)
{
if (p_strm->endcode_found) {
p_strm->startcode_found = p_strm->endcode_found;
memset(p_nal, 0, sizeof(H264_Nalu_t));
p_strm->nalu_len = 0;
p_strm->nal_unit_type = NALU_TYPE_NULL;
p_strm->endcode_found = 0;
}
p_nal->sodb_buf = p_strm->buf;
}
static void find_prefix_code(RK_U8 *p_data, H264dCurStream_t *p_strm)
@@ -101,42 +111,39 @@ static void find_prefix_code(RK_U8 *p_data, H264dCurStream_t *p_strm)
}
}
static MPP_RET read_nalu(H264_SLICE_t *currSlice)
static MPP_RET read_one_nalu(H264dInputCtx_t *p_Inp, H264dCurStream_t *p_strm)
{
MPP_RET ret = MPP_ERR_UNKNOW;
RK_U8 *p_curdata = NULL;
H264dLogCtx_t *logctx = currSlice->logctx;
H264_DecCtx_t *p_Dec = currSlice->p_Dec;
H264dCurCtx_t *p_Cur = currSlice->p_Cur;
H264dInputCtx_t *p_Inp = currSlice->p_Inp;
H264dLogCtx_t *logctx = &p_Inp->p_Dec->logctx;
H264_DecCtx_t *p_Dec = p_Inp->p_Dec;
FunctionIn(logctx->parr[RUN_PARSE]);
reset_nalu(&p_Cur->nalu, &p_Cur->strm);
while ((*p_Inp->in_size) > 0) {
p_curdata = &p_Inp->in_buf[p_Cur->strm.offset++];
(*p_Inp->in_size) -= 1;
reset_nalu(p_strm);
if (p_Cur->strm.startcode_found) {
if (p_Cur->nalu.sodb_len >= p_Cur->strm.max_size) {
FUN_CHECK(ret = realloc_curstrearm_buffer(&p_Cur->strm));
p_Cur->nalu.sodb_buf = p_Cur->strm.buf;
while (p_Inp->in_length > 0) {
p_strm->curdata = &p_Inp->in_buf[p_strm->nalu_offset++];
(*p_Inp->in_size) -= 1;
p_Inp->in_length--;
if (p_strm->startcode_found) {
if (p_strm->nalu_len >= p_strm->nalu_max_size) {
FUN_CHECK(ret = realloc_buffer(&p_strm->nalu_buf, &p_strm->nalu_max_size, NALU_BUF_ADD_SIZE));
}
p_Cur->nalu.sodb_buf[p_Cur->nalu.sodb_len++] = *p_curdata;
p_strm->nalu_buf[p_strm->nalu_len++] = *p_strm->curdata;
}
find_prefix_code(p_curdata, &p_Cur->strm);
if (p_Cur->strm.endcode_found) {
p_Cur->nalu.sodb_len -= START_PREFIX_3BYTE;
while (p_Cur->nalu.sodb_buf[p_Cur->nalu.sodb_len - 1] == 0x00) { //!< find non-zeros byte
p_Cur->nalu.sodb_len--;
find_prefix_code(p_strm->curdata, p_strm);
if (p_strm->endcode_found) {
p_strm->nalu_len -= START_PREFIX_3BYTE;
while (p_strm->nalu_buf[p_strm->nalu_len - 1] == 0x00) { //!< find non-zeros byte
p_strm->nalu_len--;
}
p_Dec->nalu_ret = EndOfNalu;
break;
}
}
if (!(*p_Inp->in_size)) { //!< check input
p_Cur->strm.offset = 0;
p_Cur->strm.endcode_found = (p_Inp->is_eos && p_Cur->nalu.sodb_len) ? 1 : p_Cur->strm.endcode_found;
p_Dec->nalu_ret = p_Inp->is_eos ? (p_Cur->nalu.sodb_len ? EndOfNalu : EndofStream) : HaveNoStream;
if (!p_Inp->in_length) { //!< check input
p_strm->nalu_offset = 0;
p_Dec->nalu_ret = HaveNoStream;
}
FunctionIn(logctx->parr[RUN_PARSE]);
@@ -146,7 +153,8 @@ __FAILED:
return ret;
}
RK_U32 g_strm_bytes = 0;
static MPP_RET parser_nalu_header(H264_SLICE_t *currSlice)
{
MPP_RET ret = MPP_ERR_UNKNOW;
@@ -158,23 +166,29 @@ static MPP_RET parser_nalu_header(H264_SLICE_t *currSlice)
FunctionIn(logctx->parr[RUN_PARSE]);
mpp_set_bitread_ctx(p_bitctx, cur_nal->sodb_buf, cur_nal->sodb_len);
g_strm_bytes += p_Cur->nalu.sodb_len;
set_bitread_logctx(p_bitctx, logctx->parr[LOG_READ_NALU]);
LogInfo(p_bitctx->ctx, "================== NAL begin ===================");
READ_BITS(p_bitctx, 1, &cur_nal->forbidden_bit, "forbidden_bit");
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->nal_unit_type, "nal_unit_type");
if (g_nalu_cnt == 344) {
g_nalu_cnt = g_nalu_cnt;
if (g_nalu_cnt0 == 2384) {
g_nalu_cnt0 = g_nalu_cnt0;
}
//if (g_debug_file1 == NULL)
//{
// g_debug_file1 = fopen("rk_debugfile_view1.txt", "wb");
//}
//FPRINT(g_debug_file1, "g_nalu_cnt = %d, nal_unit_type = %d, nalu_size = %d\n", g_nalu_cnt++, cur_nal->nal_unit_type, cur_nal->sodb_len);
/* if((cur_nal->nal_unit_type == NALU_TYPE_SLICE)
|| (cur_nal->nal_unit_type == NALU_TYPE_IDR)
|| (cur_nal->nal_unit_type == NALU_TYPE_SPS)
|| (cur_nal->nal_unit_type == NALU_TYPE_PPS)
|| (cur_nal->nal_unit_type == NALU_TYPE_SUB_SPS)
|| (cur_nal->nal_unit_type == NALU_TYPE_SEI))*/{
FPRINT(g_debug_file0, "g_nalu_cnt=%d, nal_type=%d, sodb_len=%d \n", g_nalu_cnt0++, cur_nal->nal_unit_type, cur_nal->sodb_len);
}
cur_nal->ualu_header_bytes = 1;
currSlice->svc_extension_flag = -1; //!< initialize to -1
if ((cur_nal->nal_unit_type == NALU_TYPE_PREFIX) || (cur_nal->nal_unit_type == NALU_TYPE_SLC_EXT)) {
@@ -207,16 +221,19 @@ static MPP_RET parser_nalu_header(H264_SLICE_t *currSlice)
}
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;
FunctionOut(logctx->parr[RUN_PARSE]);
return ret = MPP_OK;
__BITREAD_ERR:
ret = p_bitctx->ret;
p_Cur->p_Dec->nalu_ret = ReadNaluError;
return ret = p_bitctx->ret;
__FAILED:
p_Cur->p_Dec->nalu_ret = StreamError;
return ret;
}
static MPP_RET parser_nalu(H264_SLICE_t *currSlice)
static MPP_RET parser_one_nalu(H264_SLICE_t *currSlice)
{
MPP_RET ret = MPP_ERR_UNKNOW;
LogCtx_t *runlog = currSlice->logctx->parr[RUN_PARSE];
@@ -227,8 +244,9 @@ static MPP_RET parser_nalu(H264_SLICE_t *currSlice)
case NALU_TYPE_SLICE:
case NALU_TYPE_IDR:
FUN_CHECK(ret = process_slice(currSlice));
if (currSlice->is_new_picture_flag) {
if (currSlice->is_new_picture) {
currSlice->p_Dec->nalu_ret = StartOfPicture;
FPRINT(g_debug_file0, "----- start of picture ---- \n");
} else {
currSlice->p_Dec->nalu_ret = StartOfSlice;
}
@@ -300,20 +318,199 @@ __FAILED:
return ret;
}
static MPP_RET find_next_frame(H264dCurCtx_t *p_Cur)
{
MPP_RET ret = MPP_ERR_UNKNOW;
RK_U32 nalu_header_bytes = 0;
RK_U32 first_mb_in_slice = 0;
H264dLogCtx_t *logctx = &p_Cur->p_Dec->logctx;
BitReadCtx_t *p_bitctx = &p_Cur->bitctx;
H264dCurStream_t *p_strm = &p_Cur->strm;
RK_U32 forbidden_bit = -1;
RK_U32 nal_reference_idc = -1;
RK_U32 svc_extension_flag = -1;
FunctionIn(logctx->parr[RUN_PARSE]);
mpp_set_bitread_ctx(p_bitctx, p_strm->nalu_buf, p_strm->nalu_len);
set_bitread_logctx(p_bitctx, logctx->parr[LOG_READ_NALU]);
READ_BITS(p_bitctx, 1, &forbidden_bit);
ASSERT(forbidden_bit == 0);
READ_BITS(p_bitctx, 2, &nal_reference_idc);
READ_BITS(p_bitctx, 5, &p_strm->nal_unit_type);
if (g_nalu_cnt1 == 29) {
g_nalu_cnt1 = g_nalu_cnt1;
}
FPRINT(g_debug_file1, "g_nalu_cnt=%d, nal_type=%d, sodb_len=%d \n", g_nalu_cnt1++, p_strm->nal_unit_type, p_strm->nalu_len);
nalu_header_bytes = 1;
if ((p_strm->nal_unit_type == NALU_TYPE_PREFIX) || (p_strm->nal_unit_type == NALU_TYPE_SLC_EXT)) {
READ_BITS(p_bitctx, 1, &svc_extension_flag);
if (svc_extension_flag) {
LogInfo(logctx->parr[RUN_PARSE], "svc_extension is not supported.");
goto __FAILED;
} else {
if (p_strm->nal_unit_type == NALU_TYPE_SLC_EXT) {
p_strm->nal_unit_type = NALU_TYPE_SLICE;
}
}
nalu_header_bytes += 3;
}
//-- parse slice
if ( p_strm->nal_unit_type == NALU_TYPE_SLICE || p_strm->nal_unit_type == NALU_TYPE_IDR) {
mpp_set_bitread_ctx(p_bitctx, (p_strm->nalu_buf + nalu_header_bytes), 4); // reset
READ_UE(p_bitctx, &first_mb_in_slice);
if (!p_Cur->p_Dec->is_first_frame && (first_mb_in_slice == 0)) {
p_Cur->p_Dec->is_new_frame = 1;
}
p_Cur->p_Dec->is_first_frame = 0;
}
FunctionOut(logctx->parr[RUN_PARSE]);
return ret = MPP_OK;
__BITREAD_ERR:
return ret = p_bitctx->ret;
__FAILED:
return ret;
}
static MPP_RET add_empty_nalu(H264dCurCtx_t *p_Cur)
{
MPP_RET ret = MPP_ERR_UNKNOW;
RK_U8 *p_des = NULL;
H264dCurStream_t *p_strm = &p_Cur->strm;
if (p_strm->head_offset >= p_strm->head_max_size) {
FUN_CHECK(ret = realloc_buffer(&p_strm->head_buf, &p_strm->head_max_size, HEAD_BUF_ADD_SIZE));
}
p_des = &p_strm->head_buf[p_strm->head_offset];
((H264dNaluHead_t *)p_des)->is_frame_end = 1;
((H264dNaluHead_t *)p_des)->nal_unit_type = 0;
((H264dNaluHead_t *)p_des)->sodb_len = 0;
p_strm->head_offset += sizeof(H264dNaluHead_t);
return ret = MPP_OK;
__FAILED:
return ret;
}
static MPP_RET store_cur_nalu(H264dCurCtx_t *p_Cur)
{
MPP_RET ret = MPP_ERR_UNKNOW;
RK_U8 *p_des = NULL;
RK_U32 add_size = 0;
H264dDxvaCtx_t *dxva_ctx = NULL;
H264dCurStream_t *p_strm = &p_Cur->strm;
FunctionIn(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
//!< fill head buffer
if ((p_strm->nal_unit_type == NALU_TYPE_SLICE)
|| (p_strm->nal_unit_type == NALU_TYPE_IDR)
|| (p_strm->nal_unit_type == NALU_TYPE_SPS)
|| (p_strm->nal_unit_type == NALU_TYPE_PPS)
|| (p_strm->nal_unit_type == NALU_TYPE_SUB_SPS)
|| (p_strm->nal_unit_type == NALU_TYPE_SEI)
|| (p_strm->nal_unit_type == NALU_TYPE_PREFIX)
|| (p_strm->nal_unit_type == NALU_TYPE_SLC_EXT)) {
if (p_strm->head_offset >= p_strm->head_max_size) {
add_size = MPP_MAX(HEAD_BUF_ADD_SIZE, p_strm->nalu_len);
FUN_CHECK(ret = realloc_buffer(&p_strm->head_buf, &p_strm->head_max_size, add_size));
}
p_des = &p_strm->head_buf[p_strm->head_offset];
add_size = MPP_MIN(HEAD_MAX_SIZE, p_strm->nalu_len);
((H264dNaluHead_t *)p_des)->is_frame_end = 0;
((H264dNaluHead_t *)p_des)->nal_unit_type = p_strm->nal_unit_type;
((H264dNaluHead_t *)p_des)->sodb_len = add_size;
memcpy(p_des + sizeof(H264dNaluHead_t), p_strm->nalu_buf, add_size);
p_strm->head_offset += add_size + sizeof(H264dNaluHead_t);
}
//!< fill sodb buffer
if ((p_strm->nal_unit_type == NALU_TYPE_SLICE)
|| (p_strm->nal_unit_type == NALU_TYPE_IDR)) {
dxva_ctx = p_Cur->p_Dec->dxva_ctx;
if (dxva_ctx->strm_offset >= dxva_ctx->max_strm_size) {
add_size = MPP_MAX(SODB_BUF_ADD_SIZE, p_strm->nalu_len);
realloc_buffer(&dxva_ctx->bitstream, &dxva_ctx->max_strm_size, add_size);
}
p_des = &dxva_ctx->bitstream[dxva_ctx->strm_offset];
memcpy(p_des, g_start_precode, sizeof(g_start_precode));
memcpy(p_des + sizeof(g_start_precode), p_strm->nalu_buf, p_strm->nalu_len);
dxva_ctx->strm_offset += p_strm->nalu_len + sizeof(g_start_precode);
}
FunctionIn(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
return ret = MPP_OK;
__FAILED:
return ret;
}
/*!
***********************************************************************
* \brief
* loop function for parser
* prepare function for parser
***********************************************************************
*/
MPP_RET parse_prepare(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
{
MPP_RET ret = MPP_ERR_UNKNOW;
FunctionIn(p_Inp->p_Dec->logctx.parr[RUN_PARSE]);
p_Inp->task_valid = 0;
if (p_Cur->p_Inp->is_eos) {
FUN_CHECK(ret = find_next_frame(p_Cur));
FUN_CHECK(ret = store_cur_nalu(p_Cur));
FUN_CHECK(ret = add_empty_nalu(p_Cur));
p_Inp->task_valid = 1;
FPRINT(g_debug_file1, "----- end of stream ---- \n");
goto __RETURN;
} else if (p_Cur->p_Dec->is_new_frame) {
FUN_CHECK(ret = store_cur_nalu(p_Cur));
p_Cur->p_Dec->is_new_frame = 0;
}
FUN_CHECK(ret = read_one_nalu(p_Inp, &p_Cur->strm));
if (p_Inp->p_Dec->nalu_ret == EndOfNalu) {
FUN_CHECK(ret = find_next_frame(p_Cur));
if (p_Cur->p_Dec->is_new_frame) {
//!< add an empty nalu to tell frame end
FUN_CHECK(ret = add_empty_nalu(p_Cur));
//!< reset curstream parameters
p_Cur->strm.head_offset = 0;
p_Inp->task_valid = 1;
FPRINT(g_debug_file1, "----- start of picture ---- \n");
} else {
FUN_CHECK(ret = store_cur_nalu(p_Cur));
}
}
__RETURN:
FunctionOut(p_Inp->p_Dec->logctx.parr[RUN_PARSE]);
return ret = MPP_OK;
__FAILED:
return ret;
}
/*!
***********************************************************************
* \brief
* main function for parser
***********************************************************************
*/
MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
{
MPP_RET ret = MPP_ERR_UNKNOW;
RK_U32 while_loop_flag = 1;
RK_U8 *p_curdata = NULL;
RK_U8 while_loop_flag = 1;
H264dNaluHead_t *p_head = NULL;
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
//!< ==== parse loop ====
//!< ==== loop ====
p_curdata = p_Dec->p_Cur->strm.head_buf;
while (while_loop_flag) {
switch (p_Dec->next_state) {
case SliceSTATE_ResetSlice:
@@ -321,26 +518,26 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
p_Dec->next_state = SliceSTATE_ReadNalu;
break;
case SliceSTATE_ReadNalu:
(ret = read_nalu(&p_Dec->p_Cur->slice));
if (p_Dec->nalu_ret == EndOfNalu) {
p_Dec->next_state = SliceSTATE_ParseNalu;
} else if (p_Dec->nalu_ret == EndofStream) {
p_head = (H264dNaluHead_t *)p_curdata;
if (p_head->is_frame_end) {
p_Dec->next_state = SliceSTATE_RegisterOneFrame;
} else if (p_Dec->nalu_ret == HaveNoStream) {
while_loop_flag = 0;
p_Dec->nalu_ret = HaveNoStream;
} else {
p_curdata += sizeof(H264dNaluHead_t);
memset(&p_Dec->p_Cur->nalu, 0, sizeof(H264_Nalu_t));
p_Dec->p_Cur->nalu.sodb_buf = p_curdata;
p_Dec->p_Cur->nalu.sodb_len = p_head->sodb_len;
p_curdata += p_head->sodb_len;
p_Dec->nalu_ret = EndOfNalu;
p_Dec->next_state = SliceSTATE_ParseNalu;
}
break;
case SliceSTATE_ParseNalu:
(ret = parser_nalu(&p_Dec->p_Cur->slice));
(ret = parser_one_nalu(&p_Dec->p_Cur->slice));
if (p_Dec->nalu_ret == StartOfSlice) {
p_Dec->next_state = SliceSTATE_GetSliceData;
} else if (p_Dec->nalu_ret == StartOfPicture) {
if (p_Dec->first_frame_flag) {
p_Dec->next_state = SliceSTATE_InitPicture;
p_Dec->first_frame_flag = 0;
} else {
p_Dec->next_state = SliceSTATE_RegisterOneFrame;
}
} else {
p_Dec->next_state = SliceSTATE_ReadNalu;
}
@@ -357,8 +554,8 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
case SliceSTATE_RegisterOneFrame:
commit_buffer(p_Dec->dxva_ctx);
while_loop_flag = 0;
p_Dec->parser_end_flag = 1;
p_Dec->next_state = SliceSTATE_InitPicture;
p_Dec->is_parser_end = 1;
p_Dec->next_state = SliceSTATE_ReadNalu;
break;
default:
ret = MPP_NOK;
@@ -366,10 +563,9 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
}
}
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
//__RETURN:
//__RETURN:
return ret = MPP_OK;
__FAILED:
return ret;
}

5
mpp/codec/dec/h264/h264d_parse.h
View File

@@ -29,9 +29,8 @@ extern "C" {
#endif
MPP_RET parse_loop(H264_DecCtx_t *p_Dec);
MPP_RET parse_prepare(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur);
MPP_RET parse_loop (H264_DecCtx_t *p_Dec);
#ifdef __cplusplus

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

@@ -279,7 +279,7 @@ MPP_RET get_max_dec_frame_buf_size(H264_SPS_t *sps)
* (sps->pic_height_in_map_units_minus1 + 1)
* (sps->frame_mbs_only_flag ? 1 : 2) * 384;
size /= pic_size;
size = min(size, 16);
size = MPP_MIN(size, 16);
sps->max_dec_frame_buffering = size;
return ret = MPP_OK;

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

@@ -537,7 +537,7 @@ MPP_RET process_slice(H264_SLICE_t *currSlice)
if (g_max_bytes < (p_bitctx->used_bits >> 3)) {
g_max_bytes = (p_bitctx->used_bits >> 3);
}
currSlice->is_new_picture_flag = 1;
currSlice->is_new_picture = 1;
}
FunctionOut(logctx->parr[RUN_PARSE]);

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

@@ -1468,7 +1468,7 @@ MPP_RET h265d_prepare(void *ctx, MppPacket pkt, HalDecTask *task)
HEVCContext *s = (HEVCContext *)h265dctx->priv_data;
RK_U8 *buf = NULL;
void *pos = NULL;
size_t length = 0;
RK_S32 length = 0;
s->eos = mpp_packet_get_eos(pkt);
buf = (RK_U8 *)mpp_packet_get_pos(pkt);
length = (RK_S32)mpp_packet_get_size(pkt);

4
mpp/codec/dec/h265/test/h265d_parser_test.c
View File

@@ -382,10 +382,10 @@ RK_S32 hevc_parser_test(ParserDemoCmdContext_t *cmd)
}
if (cutask->valid) {
HalTaskInfo syn;
MppBuffer buffer = NULL;
syn.dec = *cutask;
index = cutask->output;
MppBuffer buffer = NULL;
mpp_buf_slot_get_prop(slots, index, SLOT_BUFFER, &buffer);
if (NULL == buffer) {
RK_U32 size = mpp_buf_slot_get_size(slots);

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

@@ -131,7 +131,7 @@ RK_U32 mpp_buf_slot_get_size(MppBufSlots slots);
* called by parser
*
* mpp_buf_slot_get_unused
* - parser need a new slot ffor output, on field mode alloc one buffer for two field
* - parser need a new slot for output, on field mode alloc one buffer for two field
*
* mpp_buf_slot_set_dpb_ref
* - mark a slot to be used as reference frame in dpb

4
mpp/common/h264d_log.h
View File

@@ -215,7 +215,8 @@ typedef struct h264d_logctx_t {
#define FPRINT(fp, ...) { if (fp) { fprintf(fp, ##__VA_ARGS__); fflush(fp);} }
extern RK_U32 g_nalu_cnt;
extern RK_U32 g_nalu_cnt0;
extern RK_U32 g_nalu_cnt1;
extern RK_S32 g_max_bytes;
extern RK_U32 g_max_slice_data;
extern FILE *g_debug_file0;
@@ -235,7 +236,6 @@ MPP_RET get_logenv(LogEnv_t *env);
MPP_RET explain_ctrl_flag(RK_U32 ctrl_val, LogFlag_t *pflag);
void set_log_outpath(LogEnv_t *env);
void set_bitread_logctx(BitReadCtx_t *bitctx, LogCtx_t *p_ctx);
void writelog(void *ctx, ...);

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

@@ -215,7 +215,7 @@ MPP_RET hal_h264d_gen_regs(void *hal, HalTaskInfo *task)
prepare_stream_packet(hal, &p_hal->pkts->strm);
generate_regs(p_hal, &p_hal->pkts->reg);
//mpp_log("++++++++++ hal_h264_decoder, g_framecnt=%d \n", p_hal->g_framecnt++);
mpp_log("++++++++++ hal_h264_decoder, g_framecnt=%d \n", p_hal->g_framecnt++);
((HalDecTask*)&task->dec)->valid = 0;
FunctionOut(p_hal->logctx.parr[RUN_HAL]);

12
mpp/mpp.cpp
View File

@@ -65,12 +65,12 @@ Mpp::Mpp(MppCtxType type, MppCodingType coding)
mThreadCodec = new MppThread(mpp_dec_parser_thread, this);
mThreadHal = new MppThread(mpp_dec_hal_thread, this);
mpp_buffer_group_normal_get(&mInternalGroup, MPP_BUFFER_TYPE_ION);
mpp_buffer_group_get_internal(&mInternalGroup, MPP_BUFFER_TYPE_ION);
mpp_buffer_group_normal_get(&mPacketGroup, MPP_BUFFER_TYPE_ION);
mpp_buffer_group_get_internal(&mPacketGroup, MPP_BUFFER_TYPE_ION);
mpp_buffer_group_limit_config(mPacketGroup, MPP_TEST_PACKET_SIZE, 4);
mpp_buffer_group_normal_get(&mFrameGroup, MPP_BUFFER_TYPE_ION);
mpp_buffer_group_get_internal(&mFrameGroup, MPP_BUFFER_TYPE_ION);
mpp_buffer_group_limit_config(mFrameGroup, MPP_TEST_FRAME_SIZE, 4);
} break;
case MPP_CTX_ENC : {
@@ -82,9 +82,9 @@ Mpp::Mpp(MppCtxType type, MppCodingType coding)
mThreadCodec = new MppThread(mpp_enc_control_thread, this);
mThreadHal = new MppThread(mpp_dec_hal_thread, this);
mpp_buffer_group_normal_get(&mInternalGroup, MPP_BUFFER_TYPE_ION);
mpp_buffer_group_normal_get(&mPacketGroup, MPP_BUFFER_TYPE_NORMAL);
mpp_buffer_group_limited_get(&mFrameGroup, MPP_BUFFER_TYPE_ION);
mpp_buffer_group_get_internal(&mInternalGroup, MPP_BUFFER_TYPE_ION);
mpp_buffer_group_get_internal(&mPacketGroup, MPP_BUFFER_TYPE_NORMAL);
mpp_buffer_group_get_external(&mFrameGroup, MPP_BUFFER_TYPE_ION);
} break;
default : {
mpp_err("Mpp error type %d\n", mType);

12
mpp/test/h264d_rwfile.c
View File

@@ -743,11 +743,10 @@ __FAILED:
* read one frame
***********************************************************************
*/
MPP_RET h264d_read_one_frame(InputParams *p_in, MppPacket pkt)
MPP_RET h264d_read_one_frame(InputParams *p_in)
{
p_in->strm.strmbytes = 0;
p_in->is_new_frame = 0;
//-- copy first nalu
if (!p_in->is_fist_frame) {
write_nalu_prefix(p_in);
@@ -763,15 +762,6 @@ MPP_RET h264d_read_one_frame(InputParams *p_in, MppPacket pkt)
//FPRINT(g_debug_file0, "--- new frame ---- \n");
//}
//-- set code input context
((MppPacketImpl *)pkt)->pos = p_in->strm.pbuf;
((MppPacketImpl *)pkt)->size = p_in->strm.strmbytes;
if (g_max_slice_data < p_in->strm.strmbytes) {
g_max_slice_data = p_in->strm.strmbytes;
}
if (p_in->is_eof) {
mpp_packet_set_eos(pkt);
}
return MPP_OK;
}
/*!

4
mpp/test/h264d_rwfile.h
View File

@@ -18,7 +18,7 @@
#include <stdio.h>
#include "rk_type.h"
#include "mpp_err.h"
#include "mpp_packet.h"
#ifndef __H264D_RWFILE_H__
#define __H264D_RWFILE_H__
@@ -70,7 +70,7 @@ MPP_RET h264d_configure (InputParams *in, RK_S32 ac, char *av[]);
MPP_RET h264d_open_files (InputParams *in);
MPP_RET h264d_close_files(InputParams *in);
MPP_RET h264d_alloc_frame_buffer(InputParams *in);
MPP_RET h264d_read_one_frame (InputParams *in, MppPacket pkt);
MPP_RET h264d_read_one_frame (InputParams *in);
MPP_RET h264d_free_frame_buffer (InputParams *in);
MPP_RET h264d_write_fpga_data (InputParams *in);

91
mpp/test/h264d_test.c
View File

@@ -16,6 +16,7 @@
#define MODULE_TAG "h264d_test"
#if defined(_WIN32)
#include "vld.h"
#endif
@@ -32,24 +33,22 @@
#include "h264d_log.h"
#include "h264d_rwfile.h"
#include "h264d_api.h"
#include "hal_task.h"
#include "hal_h264d_api.h"
#define MODULE_TAG "h264d_test"
static MPP_RET manual_set_env(void)
{
#if defined(_MSC_VER)
mpp_env_set_u32("h264d_log_help", 1 );
mpp_env_set_u32("h264d_log_show", 1 );
mpp_env_set_u32("h264d_log_ctrl", 0x040B );
mpp_env_set_u32("h264d_log_ctrl", 0x100B );
mpp_env_set_u32("h264d_log_level", 5 );
mpp_env_set_u32("h264d_log_decframe", 0 );
mpp_env_set_u32("h264d_log_begframe", 0 );
mpp_env_set_u32("h264d_log_endframe", 0 );
mpp_env_set_str("h264d_log_outpath", "F:/h264_log" );
mpp_env_set_str("h264d_log_cmppath", "F:/h264_log" );
mpp_env_set_str("h264d_log_cmppath", "F:/h264_log_driver/trunk_dat" );
#endif
return MPP_OK;
}
@@ -78,22 +77,25 @@ static MPP_RET decoder_init(MppDec *pApi)
MPP_RET ret = MPP_ERR_UNKNOW;
ParserCfg parser_cfg;
MppHalCfg hal_cfg;
MppCodingType coding = MPP_VIDEO_CodingAVC;
pApi->coding = MPP_VIDEO_CodingAVC;
// malloc slot
FUN_CHECK(ret = mpp_buf_slot_init(&pApi->frame_slots));
MEM_CHECK(ret, pApi->frame_slots);
// init parser part
memset(&parser_cfg, 0, sizeof(parser_cfg));
parser_cfg.coding = coding;
parser_cfg.coding = pApi->coding;
parser_cfg.frame_slots = pApi->frame_slots;
parser_cfg.packet_slots = pApi->packet_slots;
FUN_CHECK(ret = parser_init(&pApi->parser, &parser_cfg));
// init hal part
memset(&hal_cfg, 0, sizeof(hal_cfg));
hal_cfg.type = MPP_CTX_DEC;
hal_cfg.coding = coding;
hal_cfg.coding = pApi->coding;
hal_cfg.mode = HAL_MODE_LIBVPU;
hal_cfg.frame_slots = pApi->frame_slots;
hal_cfg.packet_slots = pApi->packet_slots;
hal_cfg.task_count = parser_cfg.task_count;
FUN_CHECK(ret = mpp_hal_init(&pApi->hal, &hal_cfg));
pApi->tasks = hal_cfg.tasks;
@@ -112,13 +114,24 @@ int main(int argc, char **argv)
//FILE *g_debug_file = NULL;
//RK_S32 m_max_bytes = 0;
//RK_S32 m_max_slice_data = 0;
MPP_RET ret = MPP_ERR_UNKNOW;
MPP_RET ret = MPP_ERR_UNKNOW;
MppPacket pkt = NULL;
InputParams *pIn = mpp_calloc(InputParams, 1);
MppDec *pApi = mpp_calloc(MppDec, 1);
MppPacketImpl *pkt = mpp_calloc_size(MppPacketImpl, sizeof(MppPacketImpl));
HalTaskInfo *task = mpp_calloc_size(HalTaskInfo, sizeof(HalTaskInfo));
MEM_CHECK(ret, pIn && pApi && pkt && task);
RK_U32 end_of_flag = 0;
//if (g_debug_file0 == NULL) {
// g_debug_file0 = fopen("rk_debugfile_view0.txt", "wb");
//}
//if (g_debug_file1 == NULL) {
// g_debug_file1 = fopen("rk_debugfile_view1.txt", "wb");
//}
MEM_CHECK(ret, pIn && pApi && task);
mpp_log("== test start == \n");
// set debug mode
FUN_CHECK(ret = manual_set_env());
@@ -127,43 +140,61 @@ int main(int argc, char **argv)
// open files
FUN_CHECK(ret = h264d_open_files(pIn));
FUN_CHECK(ret = h264d_alloc_frame_buffer(pIn));
// init
//!< init decoder
FUN_CHECK(ret = decoder_init(pApi));
do {
if (!pkt->size) {
FUN_CHECK(ret = h264d_read_one_frame(pIn, (MppPacket)pkt));
//if (g_debug_file1 == NULL)
//{
// g_debug_file1 = fopen("rk_debugfile_view1.txt", "wb");
//}
//FPRINT(g_debug_file1, "---- read_one_frame Frame_no = %d, size = %d \n", pIn->iFrmdecoded, pkt->size);
//!< get one packet
if (pkt == NULL) {
if (pIn->is_eof) {
mpp_packet_init(&pkt, NULL, 0);
mpp_packet_set_eos(pkt);
} else {
FUN_CHECK(ret = h264d_read_one_frame(pIn));
mpp_packet_init(&pkt, pIn->strm.pbuf, pIn->strm.strmbytes);
}
mpp_log("---- decoder, read_one_frame Frame_no = %d \n", pIn->iFrmdecoded++);
}
//!< initial task
memset(task, 0, sizeof(HalTaskInfo));
memset(task->dec.refer, -1, sizeof(task->dec.refer));
//!< prepare
FUN_CHECK(ret = parser_prepare(pApi->parser, pkt, &task->dec));
//!< parse
if (task->dec.valid) {
task->dec.valid = 0;
FUN_CHECK(ret = parser_parse(pApi->parser, &task->dec));
//FPRINT(g_debug_file1, "parse, frame_no = %d, size = %d \n", pIn->iFrmdecoded, pkt->size);
if (((HalDecTask*)&task->dec)->valid) {
}
//!< deinit packet
if (mpp_packet_get_length(pkt) == 0) {
if (mpp_packet_get_eos(pkt)) {
end_of_flag = 1; //!< end of stream
}
mpp_packet_deinit(&pkt);
pkt = NULL;
}
//!< run hal module
if (task->dec.valid) {
FUN_CHECK(ret = mpp_hal_reg_gen(pApi->hal, task));
//!< end of stream
if (!pkt->size && (pkt->flag & MPP_PACKET_FLAG_EOS)) {
FUN_CHECK(ret = mpp_hal_hw_start(pApi->hal, task));
FUN_CHECK(ret = mpp_hal_hw_wait(pApi->hal, task));
//!< write frame out
}
if (end_of_flag) {
break;
}
//pIn->iFrmdecoded++;
}
} while (!pIn->iDecFrmNum || (pIn->iFrmdecoded < pIn->iDecFrmNum));
//!< flush dpb and send to display
FUN_CHECK(ret = mpp_dec_flush(pApi));
mpp_log("+++++++ all test return +++++++ \n");
ret = MPP_OK;
__FAILED:
decoder_deinit(pApi);
h264d_free_frame_buffer(pIn);
h264d_write_fpga_data(pIn); //!< for fpga debug
h264d_close_files(pIn);
MPP_FREE(pIn);
MPP_FREE(pApi);
MPP_FREE(pkt);
MPP_FREE(task);
//g_debug_file = fopen("rk_debugfile_view0.txt", "rb");