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

[format]: format coding style

Browse Source 
git-svn-id: https://10.10.10.66:8443/svn/MediaProcessPlatform/trunk/mpp@907 6e48237b-75ef-9749-8fc9-41990f28c85a
This commit is contained in:
ChenHengming
2016-06-13 09:47:19 +00:00
parent c0866a76f9
commit 4201f689c0
40 changed files with 1335 additions and 1350 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
inc/mpp_buffer.h
View File

@@ -149,7 +149,7 @@ typedef enum {
MPP_BUFFER_TYPE_NORMAL,
MPP_BUFFER_TYPE_ION,
MPP_BUFFER_TYPE_V4L2,
MPP_BUFFER_TYPE_DRM,
MPP_BUFFER_TYPE_DRM,
MPP_BUFFER_TYPE_BUTT,
} MppBufferType;

2
inc/rk_mpi.h
View File

@@ -73,7 +73,7 @@ typedef enum {
MPP_CODEC_SET_INFO_CHANGE_READY,
MPP_CODEC_SET_FRAME_INFO,
MPP_CODEC_GET_FRAME_INFO,
MPP_CODEC_GET_VPUMEM_USED_COUNT,
MPP_CODEC_GET_VPUMEM_USED_COUNT,
MPP_DEC_CMD_BASE = 0x40000,
MPP_DEC_SET_EXT_BUF_GROUP, /* IMPORTANT: set external buffer group to mpp decoder */

2
inc/vpu_api.h
View File

@@ -57,7 +57,7 @@ typedef enum VPU_API_CMD {
VPU_API_SET_INFO_CHANGE,
VPU_API_USE_FAST_MODE,
VPU_API_DEC_GET_STREAM_COUNT,
VPU_API_GET_VPUMEM_USED_COUNT,
VPU_API_GET_VPUMEM_USED_COUNT,
} VPU_API_CMD;
typedef struct {

120
mpp/base/inc/mpp_bitread.h
View File

@@ -34,96 +34,96 @@ typedef void (*LOG_FUN)(void *ctx, ...);
#define READ_ONEBIT(bitctx, out, ...)\
do {\
RK_S32 _out; \
bitctx->ret = mpp_read_bits(bitctx, 1, &_out); \
BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \
if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR; }\
} while (0)
do {\
RK_S32 _out; \
bitctx->ret = mpp_read_bits(bitctx, 1, &_out); \
BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \
if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR; }\
} while (0)
#define READ_BITS(bitctx, num_bits, out, ...)\
do {\
RK_S32 _out;\
bitctx->ret = mpp_read_bits(bitctx, num_bits, &_out);\
BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \
if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR;}\
} while (0)
RK_S32 _out;\
bitctx->ret = mpp_read_bits(bitctx, num_bits, &_out);\
BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \
if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR;}\
} while (0)
#define READ_BITS_LONG(bitctx, num_bits, out, ...)\
do {\
RK_U32 _out; \
bitctx->ret = mpp_read_longbits(bitctx, num_bits, &_out); \
BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \
if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR; }\
} while (0)
do {\
RK_U32 _out; \
bitctx->ret = mpp_read_longbits(bitctx, num_bits, &_out); \
BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \
if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR; }\
} while (0)
#define SHOW_BITS(bitctx, num_bits, out)\
do {\
RK_S32 _out; \
bitctx->ret = mpp_show_bits(bitctx, num_bits, &_out); \
if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR; }\
} while (0)
do {\
RK_S32 _out; \
bitctx->ret = mpp_show_bits(bitctx, num_bits, &_out); \
if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR; }\
} while (0)
#define SHOW_BITS_LONG(bitctx, num_bits, out)\
do {\
RK_U32 _out; \
bitctx->ret = mpp_show_longbits(bitctx, num_bits, &_out); \
if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR; }\
} while (0)
do {\
RK_U32 _out; \
bitctx->ret = mpp_show_longbits(bitctx, num_bits, &_out); \
if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR; }\
} while (0)
#define SKIP_BITS(bitctx, num_bits)\
do {\
bitctx->ret = mpp_skip_bits(bitctx, num_bits);\
BitReadLog(bitctx, "%48s %d bits", "skip", num_bits);\
if (bitctx->ret) { goto __BITREAD_ERR; }\
bitctx->ret = mpp_skip_bits(bitctx, num_bits);\
BitReadLog(bitctx, "%48s %d bits", "skip", num_bits);\
if (bitctx->ret) { goto __BITREAD_ERR; }\
} while (0)
#define SKIP_BITS_LONG(bitctx, num_bits)\
do {\
bitctx->ret = mpp_skip_longbits(bitctx, num_bits); \
BitReadLog(bitctx, "%48s %d bits", "skip", num_bits); \
if (bitctx->ret) { goto __BITREAD_ERR; }\
} while (0)
do {\
bitctx->ret = mpp_skip_longbits(bitctx, num_bits); \
BitReadLog(bitctx, "%48s %d bits", "skip", num_bits); \
if (bitctx->ret) { goto __BITREAD_ERR; }\
} while (0)
#define READ_UE(bitctx, out, ...)\
do {\
RK_U32 _out;\
bitctx->ret = mpp_read_ue(bitctx, &_out);\
BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out);\
if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR;}\
RK_U32 _out;\
bitctx->ret = mpp_read_ue(bitctx, &_out);\
BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out);\
if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR;}\
} while (0)
#define READ_SE(bitctx, out, ...)\
do {\
RK_S32 _out;\
bitctx->ret = mpp_read_se(bitctx, &_out);\
BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out);\
if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR;}\
RK_S32 _out;\
bitctx->ret = mpp_read_se(bitctx, &_out);\
BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out);\
if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR;}\
} while (0)
#define CHECK_RANGE(bitctx, val, _min, _max)\
do {\
if ((val) < (_min) || (val) > (_max)) {\
mpp_log("%d[%d,%d]", val, _min, _max);\
bitctx->ret = MPP_ERR_VALUE;\
goto __BITREAD_ERR;\
}\
if ((val) < (_min) || (val) > (_max)) {\
mpp_log("%d[%d,%d]", val, _min, _max);\
bitctx->ret = MPP_ERR_VALUE;\
goto __BITREAD_ERR;\
}\
} while (0)
#define CHECK_ERROR(bitctx, val)\
do {\
if (!(val)) {\
mpp_log("value false");\
bitctx->ret = MPP_ERR_VALUE;\
goto __BITREAD_ERR;\
}\
if (!(val)) {\
mpp_log("value false");\
bitctx->ret = MPP_ERR_VALUE;\
goto __BITREAD_ERR;\
}\
} while (0)
typedef struct bitread_ctx_t {

32
mpp/base/mpp_buf_slot.cpp
View File

@@ -631,22 +631,22 @@ size_t mpp_buf_slot_get_size(MppBufSlots slots)
RK_S32 mpp_buf_slot_get_used_size(MppBufSlots slots)
{
if (NULL == slots) {
mpp_err_f("found NULL input\n");
return 0;
}
MppBufSlotsImpl *impl = (MppBufSlotsImpl *)slots;
AutoMutex auto_lock(impl->lock);
RK_S32 i;
RK_S32 used_size = 0;
MppBufSlotEntry *slot = impl->slots;
for (i = 0; i < impl->buf_count; i++, slot++) {
if (slot->status.on_used) {
buf_slot_dbg(BUF_SLOT_DBG_BUF_UESD, "[BUF_USED] buf_fd=%08x", mpp_buffer_get_fd(slot->buffer));
used_size++;
}
}
return used_size;
if (NULL == slots) {
mpp_err_f("found NULL input\n");
return 0;
}
MppBufSlotsImpl *impl = (MppBufSlotsImpl *)slots;
AutoMutex auto_lock(impl->lock);
RK_S32 i;
RK_S32 used_size = 0;
MppBufSlotEntry *slot = impl->slots;
for (i = 0; i < impl->buf_count; i++, slot++) {
if (slot->status.on_used) {
buf_slot_dbg(BUF_SLOT_DBG_BUF_UESD, "[BUF_USED] buf_fd=%08x", mpp_buffer_get_fd(slot->buffer));
used_size++;
}
}
return used_size;
}
MPP_RET mpp_buf_slot_get_unused(MppBufSlots slots, RK_S32 *index)

10
mpp/base/mpp_buffer_impl.cpp
View File

@@ -104,7 +104,7 @@ static const char *type2str[MPP_BUFFER_TYPE_BUTT] = {
"normal",
"ion",
"v4l2",
"drm",
"drm",
};
static const char *ops2str[BUF_OPS_BUTT] = {
"grp create ",
@@ -284,7 +284,7 @@ MPP_RET mpp_buffer_create(const char *tag, const char *caller, RK_U32 group_id,
group->buffer_count++;
group->count_unused++;
buffer_group_add_log(group, p, (group->mode == MPP_BUFFER_INTERNAL)?(BUF_CREATE):(BUF_COMMIT));
buffer_group_add_log(group, p, (group->mode == MPP_BUFFER_INTERNAL) ? (BUF_CREATE) : (BUF_COMMIT));
RET:
MPP_BUF_FUNCTION_LEAVE();
return ret;
@@ -526,7 +526,7 @@ RK_U32 MppBufferService::get_group_id()
{
// avoid group_id reuse
RK_U32 id = group_id++;
while (get_group_by_id(group_id)){
while (get_group_by_id(group_id)) {
group_id++;
}
group_count++;
@@ -534,7 +534,7 @@ RK_U32 MppBufferService::get_group_id()
}
MppBufferGroupImpl *MppBufferService::get_group(const char *tag, const char *caller,
MppBufferMode mode, MppBufferType type)
MppBufferMode mode, MppBufferType type)
{
MppBufferGroupImpl *p = mpp_calloc(MppBufferGroupImpl, 1);
if (NULL == p) {
@@ -631,7 +631,7 @@ void MppBufferService::destroy_group(MppBufferGroupImpl *group)
mpp_assert(group->count_unused == 0);
if (group->count_unused || group->count_used) {
mpp_err("mpp_buffer_group_deinit mismatch counter used %4d unused %4d found\n",
group->count_used, group->count_unused);
group->count_used, group->count_unused);
group->count_unused = 0;
group->count_used = 0;
}

46
mpp/codec/dec/avs/avsd_api.c
View File

@@ -573,51 +573,51 @@ MPP_RET avsd_callback(void *decoder, void *info)
#else
MPP_RET avsd_deinit(void *decoder)
{
(void)decoder;
return MPP_OK;
(void)decoder;
return MPP_OK;
}
MPP_RET avsd_init(void *decoder, ParserCfg *init)
{
(void)decoder;
(void)init;
return MPP_OK;
(void)decoder;
(void)init;
return MPP_OK;
}
MPP_RET avsd_prepare(void *decoder, MppPacket pkt, HalDecTask *task)
{
(void)decoder;
(void)pkt;
(void)task;
return MPP_OK;
(void)decoder;
(void)pkt;
(void)task;
return MPP_OK;
}
MPP_RET avsd_parse(void *decoder, HalDecTask *task)
{
(void)decoder;
(void)task;
return MPP_OK;
(void)decoder;
(void)task;
return MPP_OK;
}
MPP_RET avsd_reset(void *decoder)
{
(void)decoder;
return MPP_OK;
(void)decoder;
return MPP_OK;
}
MPP_RET avsd_flush(void *decoder)
{
(void)decoder;
return MPP_OK;
(void)decoder;
return MPP_OK;
}
MPP_RET avsd_control(void *decoder, RK_S32 cmd_type, void *param)
{
(void)decoder;
(void)cmd_type;
(void)param;
return MPP_OK;
(void)decoder;
(void)cmd_type;
(void)param;
return MPP_OK;
}
MPP_RET avsd_callback(void *decoder, void *info)
{
(void)decoder;
(void)info;
return MPP_OK;
(void)decoder;
(void)info;
return MPP_OK;
}
#endif
/*!

236
mpp/codec/dec/avs/avsd_parse.c
View File

@@ -36,61 +36,61 @@
static void reset_curstream(AvsdCurStream_t *p_strm)
{
p_strm->p_start = NULL;
p_strm->len = 0;
p_strm->got_frame_flag = 0;
p_strm->got_nalu_flag = 0;
p_strm->p_start = NULL;
p_strm->len = 0;
p_strm->got_frame_flag = 0;
p_strm->got_nalu_flag = 0;
}
static MPP_RET add_nalu_header(AvsdCurCtx_t *p_cur)
{
MPP_RET ret = MPP_ERR_UNKNOW;
MPP_RET ret = MPP_ERR_UNKNOW;
RK_U32 add_size = sizeof(AvsdNalu_t);
AvsdBitstream_t *p_bitstream = p_cur->p_dec->bitstream;
RK_U32 add_size = sizeof(AvsdNalu_t);
AvsdBitstream_t *p_bitstream = p_cur->p_dec->bitstream;
if ((p_bitstream->offset + add_size) > p_bitstream->size) {
AVSD_DBG(AVSD_DBG_ERROR, "error, head_offset is larger than %d", p_bitstream->size);
goto __FAILED;
}
p_cur->cur_nalu = (AvsdNalu_t *)&p_bitstream->pbuf[p_bitstream->offset];
p_cur->cur_nalu->eof = 1;
p_cur->cur_nalu->header = 0;
p_cur->cur_nalu->pdata = NULL;
p_cur->cur_nalu->length = 0;
p_cur->cur_nalu->start_pos = 0;
p_bitstream->offset += add_size;
if ((p_bitstream->offset + add_size) > p_bitstream->size) {
AVSD_DBG(AVSD_DBG_ERROR, "error, head_offset is larger than %d", p_bitstream->size);
goto __FAILED;
}
p_cur->cur_nalu = (AvsdNalu_t *)&p_bitstream->pbuf[p_bitstream->offset];
p_cur->cur_nalu->eof = 1;
p_cur->cur_nalu->header = 0;
p_cur->cur_nalu->pdata = NULL;
p_cur->cur_nalu->length = 0;
p_cur->cur_nalu->start_pos = 0;
p_bitstream->offset += add_size;
(void)p_cur;
return ret = MPP_OK;
(void)p_cur;
return ret = MPP_OK;
__FAILED:
return ret;
return ret;
}
static MPP_RET store_cur_nalu(AvsdCurCtx_t *p_cur, AvsdCurStream_t *p_strm)
{
MPP_RET ret = MPP_ERR_UNKNOW;
MPP_RET ret = MPP_ERR_UNKNOW;
AvsdNalu_t *p_nalu = p_cur->cur_nalu;
AvsdBitstream_t *p_bitstream = p_cur->p_dec->bitstream;
AvsdNalu_t *p_nalu = p_cur->cur_nalu;
AvsdBitstream_t *p_bitstream = p_cur->p_dec->bitstream;
//!< fill bitstream buffer
RK_U32 add_size = p_strm->len;
//!< fill bitstream buffer
RK_U32 add_size = p_strm->len;
if ((p_bitstream->offset + add_size) > p_bitstream->size) {
AVSD_DBG(AVSD_DBG_ERROR, "error, head_offset is larger than %d", p_bitstream->size);
goto __FAILED;
}
p_nalu->length += p_strm->len;
p_nalu->pdata = &p_bitstream->pbuf[p_bitstream->offset];
memcpy(p_nalu->pdata, p_strm->p_start, p_strm->len);
p_bitstream->offset += add_size;
if ((p_bitstream->offset + add_size) > p_bitstream->size) {
AVSD_DBG(AVSD_DBG_ERROR, "error, head_offset is larger than %d", p_bitstream->size);
goto __FAILED;
}
p_nalu->length += p_strm->len;
p_nalu->pdata = &p_bitstream->pbuf[p_bitstream->offset];
memcpy(p_nalu->pdata, p_strm->p_start, p_strm->len);
p_bitstream->offset += add_size;
return ret = MPP_OK;
return ret = MPP_OK;
__FAILED:
return ret;
return ret;
}
/*!
@@ -103,108 +103,108 @@ __FAILED:
MPP_RET avsd_parse_prepare(AvsdInputCtx_t *p_inp, AvsdCurCtx_t *p_cur)
{
MPP_RET ret = MPP_ERR_UNKNOW;
RK_U8 *p_curdata = NULL;
MPP_RET ret = MPP_ERR_UNKNOW;
RK_U8 *p_curdata = NULL;
HalDecTask *in_task = p_inp->in_task;
MppPacket *in_pkt = p_inp->in_pkt;
MppPacketImpl *pkt_impl = (MppPacketImpl *)p_inp->in_pkt;
AvsdCurStream_t *p_strm = &p_cur->m_strm;
AvsdBitstream_t *p_bitstream = p_cur->p_dec->bitstream;
HalDecTask *in_task = p_inp->in_task;
MppPacket *in_pkt = p_inp->in_pkt;
MppPacketImpl *pkt_impl = (MppPacketImpl *)p_inp->in_pkt;
AvsdCurStream_t *p_strm = &p_cur->m_strm;
AvsdBitstream_t *p_bitstream = p_cur->p_dec->bitstream;
AVSD_PARSE_TRACE("In.");
//!< check input
if (!mpp_packet_get_length(in_pkt)) {
AVSD_DBG(AVSD_DBG_WARNNING, "input have no stream.");
goto __RETURN;
}
AVSD_PARSE_TRACE("In.");
//!< check input
if (!mpp_packet_get_length(in_pkt)) {
AVSD_DBG(AVSD_DBG_WARNNING, "input have no stream.");
goto __RETURN;
}
in_task->valid = 0;
in_task->flags.eos = 0;
in_task->valid = 0;
in_task->flags.eos = 0;
//!< check eos
if (mpp_packet_get_eos(in_pkt)) {
FUN_CHECK(ret = add_nalu_header(p_cur));
in_task->valid = 1;
in_task->flags.eos = 1;
AVSD_DBG(AVSD_DBG_LOG, "end of stream.");
goto __RETURN;
}
//!< check eos
if (mpp_packet_get_eos(in_pkt)) {
FUN_CHECK(ret = add_nalu_header(p_cur));
in_task->valid = 1;
in_task->flags.eos = 1;
AVSD_DBG(AVSD_DBG_LOG, "end of stream.");
goto __RETURN;
}
p_strm->p_start = p_curdata = (RK_U8 *)mpp_packet_get_pos(p_inp->in_pkt);
while (pkt_impl->length > 0) {
//!< found next picture start code
if (((*p_curdata) == I_PICTURE_START_CODE)
|| ((*p_curdata) == PB_PICTURE_START_CODE)) {
if (p_strm->got_frame_flag) {
FUN_CHECK(ret = add_nalu_header(p_cur));
in_task->valid = 1;
pkt_impl->length += START_PREFIX_3BYTE;
p_bitstream->len = p_bitstream->offset;
//!< reset value
p_bitstream->offset = 0;
reset_curstream(p_strm);
break;
}
p_strm->got_frame_flag = 1;
}
//!< found next nalu start code
p_strm->prefixdata = (p_strm->prefixdata << 8) | (*p_curdata);
if ((p_strm->prefixdata & 0xFFFFFF00) == 0x00000100) {
if (p_strm->got_nalu_flag) {
p_strm->len = (RK_U32)(p_curdata - p_strm->p_start) - START_PREFIX_3BYTE;
FUN_CHECK(ret = store_cur_nalu(p_cur, p_strm));
FPRINT(p_cur->p_inp->fp_log, "g_nalu_no=%d, length=%d, header=0x%02x \n", g_nalu_no++, p_cur->cur_nalu->length, p_cur->cur_nalu->header);
p_strm->p_start = p_curdata = (RK_U8 *)mpp_packet_get_pos(p_inp->in_pkt);
while (pkt_impl->length > 0) {
//!< found next picture start code
if (((*p_curdata) == I_PICTURE_START_CODE)
|| ((*p_curdata) == PB_PICTURE_START_CODE)) {
if (p_strm->got_frame_flag) {
FUN_CHECK(ret = add_nalu_header(p_cur));
in_task->valid = 1;
pkt_impl->length += START_PREFIX_3BYTE;
p_bitstream->len = p_bitstream->offset;
//!< reset value
p_bitstream->offset = 0;
reset_curstream(p_strm);
break;
}
p_strm->got_frame_flag = 1;
}
//!< found next nalu start code
p_strm->prefixdata = (p_strm->prefixdata << 8) | (*p_curdata);
if ((p_strm->prefixdata & 0xFFFFFF00) == 0x00000100) {
if (p_strm->got_nalu_flag) {
p_strm->len = (RK_U32)(p_curdata - p_strm->p_start) - START_PREFIX_3BYTE;
FUN_CHECK(ret = store_cur_nalu(p_cur, p_strm));
FPRINT(p_cur->p_inp->fp_log, "g_nalu_no=%d, length=%d, header=0x%02x \n", g_nalu_no++, p_cur->cur_nalu->length, p_cur->cur_nalu->header);
}
FUN_CHECK(ret = add_nalu_header(p_cur));
p_cur->cur_nalu->header = (*p_curdata);
p_cur->cur_nalu->eof = 0;
p_cur->cur_nalu->start_pos = START_PREFIX_3BYTE;
}
FUN_CHECK(ret = add_nalu_header(p_cur));
p_cur->cur_nalu->header = (*p_curdata);
p_cur->cur_nalu->eof = 0;
p_cur->cur_nalu->start_pos = START_PREFIX_3BYTE;
p_strm->p_start = p_curdata - START_PREFIX_3BYTE;
p_strm->got_nalu_flag = 1;
}
p_curdata++;
pkt_impl->length--;
}
if (!pkt_impl->length) {
p_strm->len = (RK_U32)(p_curdata - p_strm->p_start) - 1;
FUN_CHECK(ret = store_cur_nalu(p_cur, p_strm));
}
p_strm->p_start = p_curdata - START_PREFIX_3BYTE;
p_strm->got_nalu_flag = 1;
}
p_curdata++;
pkt_impl->length--;
}
if (!pkt_impl->length) {
p_strm->len = (RK_U32)(p_curdata - p_strm->p_start) - 1;
FUN_CHECK(ret = store_cur_nalu(p_cur, p_strm));
}
__RETURN:
AVSD_PARSE_TRACE("Out.");
AVSD_PARSE_TRACE("Out.");
return ret = MPP_OK;
return ret = MPP_OK;
__FAILED:
return ret;
return ret;
}
#else
MPP_RET avsd_parse_prepare(AvsdInputCtx_t *p_inp, AvsdCurCtx_t *p_cur)
{
RK_S32 ret_val = 0;
MPP_RET ret = MPP_ERR_UNKNOW;
RK_S32 ret_val = 0;
MPP_RET ret = MPP_ERR_UNKNOW;
Avs_DecCtx_t *p_dec = p_inp->p_dec;
HalDecTask *in_task = p_inp->in_task;
Avs_DecCtx_t *p_dec = p_inp->p_dec;
HalDecTask *in_task = p_inp->in_task;
AVSD_PARSE_TRACE("In.");
AVSD_PARSE_TRACE("In.");
in_task->input_packet = p_dec->task_pkt;
ret_val = lib_avsd_prepare(p_dec->libdec,
(RK_U8 *)mpp_packet_get_pos(p_inp->in_pkt), (RK_S32)mpp_packet_get_length(p_inp->in_pkt));
if (ret_val < 0) {
goto __FAILED;
}
in_task->valid = 1;
mpp_packet_set_length(p_inp->in_pkt, 0);
in_task->input_packet = p_dec->task_pkt;
ret_val = lib_avsd_prepare(p_dec->libdec,
(RK_U8 *)mpp_packet_get_pos(p_inp->in_pkt), (RK_S32)mpp_packet_get_length(p_inp->in_pkt));
if (ret_val < 0) {
goto __FAILED;
}
in_task->valid = 1;
mpp_packet_set_length(p_inp->in_pkt, 0);
AVSD_PARSE_TRACE("Out.");
(void)p_cur;
return ret = MPP_OK;
AVSD_PARSE_TRACE("Out.");
(void)p_cur;
return ret = MPP_OK;
__FAILED:
return ret;
return ret;
}
#endif

178
mpp/codec/dec/avs/avsd_parse.h
View File

@@ -50,93 +50,91 @@
//!< input parameter
typedef struct avsd_input_ctx_t {
FILE *fp_log;
FILE *fp_log;
ParserCfg init;
MppPacket in_pkt;
HalDecTask *in_task;
ParserCfg init;
MppPacket in_pkt;
HalDecTask *in_task;
RK_S64 in_pts;
RK_S64 in_dts;
RK_S64 in_pts;
RK_S64 in_dts;
RK_U8 has_get_eos;
RK_U64 pkt_no;
struct avsd_cur_ctx_t *p_cur;
struct avsd_video_ctx_t *p_vid;
struct avs_dec_ctx_t *p_dec;
RK_U8 has_get_eos;
RK_U64 pkt_no;
struct avsd_cur_ctx_t *p_cur;
struct avsd_video_ctx_t *p_vid;
struct avs_dec_ctx_t *p_dec;
} AvsdInputCtx_t;
//!< current stream
typedef struct avsd_cur_strm_t {
RK_U8 *p_start; //!< store read nalu data
RK_U32 len;
RK_U8 *p_start; //!< store read nalu data
RK_U32 len;
RK_U32 prefixdata;
RK_U32 prefixdata;
RK_U8 got_frame_flag;
RK_U8 got_nalu_flag;
RK_U8 got_frame_flag;
RK_U8 got_nalu_flag;
} AvsdCurStream_t;
typedef struct avsd_nalu_t
{
RK_U8 header;
RK_U8 *pdata;
RK_U32 size;
RK_U32 length;
RK_U8 start_pos;
RK_U8 eof; //!< end of frame stream
}AvsdNalu_t;
typedef struct avsd_nalu_t {
RK_U8 header;
RK_U8 *pdata;
RK_U32 size;
RK_U32 length;
RK_U8 start_pos;
RK_U8 eof; //!< end of frame stream
} AvsdNalu_t;
//!< current parameters
typedef struct avsd_cur_ctx_t {
struct avsd_cur_strm_t m_strm;
struct avsd_nalu_t *cur_nalu; //!< current nalu
struct avsd_cur_strm_t m_strm;
struct avsd_nalu_t *cur_nalu; //!< current nalu
struct avsd_input_ctx_t *p_inp;
struct avsd_video_ctx_t *p_vid;
struct avs_dec_ctx_t *p_dec;
struct avsd_input_ctx_t *p_inp;
struct avsd_video_ctx_t *p_vid;
struct avs_dec_ctx_t *p_dec;
} AvsdCurCtx_t;
//!< decoder parameters
typedef struct avsd_video_ctx_t {
struct img_par *img;
struct img_par *img;
struct avsd_input_ctx_t *p_inp;
struct avsd_cur_ctx_t *p_cur;
struct avs_dec_ctx_t *p_dec;
}AvsdVideoCtx_t;
struct avsd_input_ctx_t *p_inp;
struct avsd_cur_ctx_t *p_cur;
struct avs_dec_ctx_t *p_dec;
} AvsdVideoCtx_t;
typedef struct avsd_bitstream_t {
RK_U8 *pbuf;
RK_U32 size;
RK_U32 len;
RK_U32 offset; //!< start from the offset byte
}AvsdBitstream_t;
RK_U8 *pbuf;
RK_U32 size;
RK_U32 len;
RK_U32 offset; //!< start from the offset byte
} AvsdBitstream_t;
typedef struct avsd_outframe_t
{
RK_S32 nWidth;
RK_S32 nHeight;
RK_U8 *data[4]; // Y U V data
RK_S32 stride[4]; // Y U V stride
RK_S32 corp[2]; // crop_right crop_bottom
RK_S32 hor_stride;
RK_S32 ver_stride;
RK_S32 nFrameType; // 0I 1P 2B
RK_S32 nBitrate;
RK_S32 nFrameCoded;
RK_S32 nTopFieldFirst;
RK_S32 nFrameIndex;
typedef struct avsd_outframe_t {
RK_S32 nWidth;
RK_S32 nHeight;
RK_U8 *data[4]; // Y U V data
RK_S32 stride[4]; // Y U V stride
RK_S32 corp[2]; // crop_right crop_bottom
RK_S32 hor_stride;
RK_S32 ver_stride;
RK_S32 nFrameType; // 0I 1P 2B
RK_S32 nBitrate;
RK_S32 nFrameCoded;
RK_S32 nTopFieldFirst;
RK_S32 nFrameIndex;
} AvsdOutframe_t;
typedef struct avsd_memory_t {
struct avsd_bitstream_t bitstream;
struct avsd_outframe_t outframe;
struct avsd_bitstream_t bitstream;
struct avsd_outframe_t outframe;
} AvsdMemory_t;
@@ -145,52 +143,52 @@ typedef struct avsd_memory_t {
//!< decoder parameters
typedef struct avs_dec_ctx_t {
MppBufSlots frame_slots;
MppBufSlots packet_slots;
MppBufSlots frame_slots;
MppBufSlots packet_slots;
MppPacket task_pkt;
struct avsd_memory_t *mem; //!< resotre slice data to decoder
struct avsd_bitstream_t *bitstream;
MppPacket task_pkt;
struct avsd_memory_t *mem; //!< resotre slice data to decoder
struct avsd_bitstream_t *bitstream;
struct avsd_input_ctx_t *p_inp;
struct avsd_cur_ctx_t *p_cur;
struct avsd_video_ctx_t *p_vid;
//!< use in libavs.so
void *libdec;
struct avsd_outframe_t *outframe;
struct avsd_input_ctx_t *p_inp;
struct avsd_cur_ctx_t *p_cur;
struct avsd_video_ctx_t *p_vid;
//!< use in libavs.so
void *libdec;
struct avsd_outframe_t *outframe;
RK_U32 dec_no;
RK_U32 dec_no;
RK_U32 prepare_no;
RK_U32 parse_no;
RK_U32 decode_no;
RK_U32 nvcopy_no;
RK_U32 prepare_no;
RK_U32 parse_no;
RK_U32 decode_no;
RK_U32 nvcopy_no;
RK_S64 prepare_time;
RK_S64 parse_time;
RK_S64 prepare_time;
RK_S64 parse_time;
RK_S64 read_slice_header_time;
RK_S64 init_arideco_slice_time;
RK_S64 read_slice_header_time;
RK_S64 init_arideco_slice_time;
RK_S64 start_marcoblock_time;
RK_S64 read_marcoblock_time;
RK_S64 start_marcoblock_time;
RK_S64 read_marcoblock_time;
RK_S64 get_block_time;
RK_S64 inter_pred_block_time;
RK_S64 intra_pred_block_time;
RK_S64 idc_dequaut_time;
RK_S64 decode_marcoblock_time;
RK_S64 deblock_time;
RK_S64 get_block_time;
RK_S64 inter_pred_block_time;
RK_S64 intra_pred_block_time;
RK_S64 idc_dequaut_time;
RK_S64 decode_marcoblock_time;
RK_S64 deblock_time;
RK_S64 decode_init_time;
RK_S64 decode_data_time;
RK_S64 decode_update_time;
RK_S64 frame_post_time;
RK_S64 decode_init_time;
RK_S64 decode_data_time;
RK_S64 decode_update_time;
RK_S64 frame_post_time;
RK_S64 decode_frame_time;
RK_S64 decode_frame_time;
RK_S64 nvcopy_time;
RK_S64 nvcopy_time;
} Avs_DecCtx_t;

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

@@ -138,8 +138,8 @@ static MPP_RET free_input_ctx(H264dInputCtx_t *p_Inp)
INP_CHECK(ret, !p_Inp);
FunctionIn(p_Inp->p_Dec->logctx.parr[RUN_PARSE]);
close_stream_file(p_Inp);
MPP_FREE(p_Inp->spspps_buf);
close_stream_file(p_Inp);
MPP_FREE(p_Inp->spspps_buf);
FunctionOut(p_Inp->p_Dec->logctx.parr[RUN_PARSE]);
__RETURN:
@@ -154,18 +154,18 @@ static MPP_RET init_input_ctx(H264dInputCtx_t *p_Inp, ParserCfg *init)
p_Inp->init = *init;
mpp_env_get_u32("rkv_h264d_mvc_disable", &p_Inp->mvc_disable, 1);
open_stream_file(p_Inp, "/sdcard");
if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) {
p_Inp->spspps_size = HEAD_BUF_MAX_SIZE;
p_Inp->spspps_buf = mpp_malloc_size(RK_U8, p_Inp->spspps_size);
MEM_CHECK(ret, p_Inp->spspps_buf);
}
open_stream_file(p_Inp, "/sdcard");
if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) {
p_Inp->spspps_size = HEAD_BUF_MAX_SIZE;
p_Inp->spspps_buf = mpp_malloc_size(RK_U8, p_Inp->spspps_size);
MEM_CHECK(ret, p_Inp->spspps_buf);
}
FunctionOut(p_Inp->p_Dec->logctx.parr[RUN_PARSE]);
__RETURN:
return ret = MPP_OK;
__FAILED:
free_input_ctx(p_Inp);
return ret;
free_input_ctx(p_Inp);
return ret;
}
@@ -198,8 +198,8 @@ static MPP_RET init_cur_ctx(H264dCurCtx_t *p_Cur)
FunctionIn(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
p_strm = &p_Cur->strm;
p_strm->nalu_buf = mpp_malloc_size(RK_U8, NALU_BUF_MAX_SIZE);
p_strm->head_buf = mpp_malloc_size(RK_U8, HEAD_BUF_MAX_SIZE);
p_strm->nalu_buf = mpp_malloc_size(RK_U8, NALU_BUF_MAX_SIZE);
p_strm->head_buf = mpp_malloc_size(RK_U8, HEAD_BUF_MAX_SIZE);
MEM_CHECK(ret, p_strm->nalu_buf && p_strm->head_buf);
p_strm->prefixdata = 0xffffffff;
for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) {
@@ -207,7 +207,7 @@ static MPP_RET init_cur_ctx(H264dCurCtx_t *p_Cur)
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
}
reset_cur_slice(p_Cur, &p_Cur->slice);
reset_cur_slice(p_Cur, &p_Cur->slice);
FunctionOut(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
@@ -255,7 +255,7 @@ static MPP_RET init_vid_ctx(H264dVideoCtx_t *p_Vid)
p_Vid->p_Dpb_layer[i]->layer_id = i;
p_Vid->p_Dpb_layer[i]->p_Vid = p_Vid;
p_Vid->p_Dpb_layer[i]->init_done = 0;
p_Vid->p_Dpb_layer[i]->poc_interval = 2;
p_Vid->p_Dpb_layer[i]->poc_interval = 2;
}
//!< init video pars
for (i = 0; i < MAXSPS; i++) {
@@ -309,9 +309,9 @@ static MPP_RET init_dxva_ctx(H264dDxvaCtx_t *p_dxva)
INP_CHECK(ret, !p_dxva);
FunctionIn(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
p_dxva->slice_count = 0;
p_dxva->slice_long = mpp_calloc(DXVA_Slice_H264_Long, MAX_SLICE_NUM);
p_dxva->slice_long = mpp_calloc(DXVA_Slice_H264_Long, MAX_SLICE_NUM);
MEM_CHECK(ret, p_dxva->slice_long);
p_dxva->bitstream = mpp_malloc(RK_U8, BITSTREAM_MAX_SIZE);
p_dxva->bitstream = mpp_malloc(RK_U8, BITSTREAM_MAX_SIZE);
p_dxva->syn.buf = mpp_calloc(DXVA2_DecodeBufferDesc, SYNTAX_BUF_SIZE);
MEM_CHECK(ret, p_dxva->bitstream && p_dxva->syn.buf);
FunctionOut(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
@@ -360,7 +360,7 @@ static MPP_RET init_dec_ctx(H264_DecCtx_t *p_Dec)
//!< init Dpb_memory Mark
for (i = 0; i < MAX_MARK_SIZE; i++) {
reset_dpb_mark(&p_Dec->dpb_mark[i]);
p_Dec->dpb_mark[i].mark_idx = i;
p_Dec->dpb_mark[i].mark_idx = i;
}
mpp_buf_slot_setup(p_Dec->frame_slots, MAX_MARK_SIZE);
//!< malloc mpp packet
@@ -420,8 +420,8 @@ MPP_RET h264d_init(void *decoder, ParserCfg *init)
p_Dec->p_Vid->p_Dec = p_Dec;
p_Dec->p_Vid->p_Inp = p_Dec->p_Inp;
p_Dec->p_Vid->p_Cur = p_Dec->p_Cur;
FUN_CHECK(ret = init_input_ctx(p_Dec->p_Inp, init));
FUN_CHECK(ret = init_cur_ctx(p_Dec->p_Cur));
FUN_CHECK(ret = init_input_ctx(p_Dec->p_Inp, init));
FUN_CHECK(ret = init_cur_ctx(p_Dec->p_Cur));
FUN_CHECK(ret = init_vid_ctx(p_Dec->p_Vid));
FUN_CHECK(ret = init_dec_ctx(p_Dec));
@@ -490,13 +490,13 @@ MPP_RET h264d_reset(void *decoder)
p_Dec->p_Inp->in_dts = 0;
p_Dec->p_Inp->has_get_eos = 0;
//!< reset video parameter
p_Dec->p_Vid->have_outpicture_flag = 0;
p_Dec->p_Vid->exit_picture_flag = 0;
p_Dec->p_Vid->active_mvc_sps_flag = 0;
p_Dec->p_Vid->have_outpicture_flag = 0;
p_Dec->p_Vid->exit_picture_flag = 0;
p_Dec->p_Vid->active_mvc_sps_flag = 0;
p_Dec->p_Vid->g_framecnt = 0;
p_Dec->p_Vid->dec_pic = NULL;
p_Dec->p_Vid->last_pic = NULL;
memset(&p_Dec->p_Vid->old_pic, 0, sizeof(H264_StorePic_t));
p_Dec->p_Vid->dec_pic = NULL;
p_Dec->p_Vid->last_pic = NULL;
memset(&p_Dec->p_Vid->old_pic, 0, sizeof(H264_StorePic_t));
memset(&p_Dec->errctx, 0, sizeof(H264dErrCtx_t));
//!< reset current time stamp
p_Dec->p_Cur->last_dts = 0;
@@ -520,8 +520,8 @@ MPP_RET h264d_reset(void *decoder)
p_Dec->is_parser_end = 0;
p_Dec->dxva_ctx->strm_offset = 0;
p_Dec->dxva_ctx->slice_count = 0;
p_Dec->last_frame_slot_idx = -1;
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
p_Dec->last_frame_slot_idx = -1;
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
__RETURN:
return ret = MPP_OK;
__FAILED:
@@ -537,18 +537,18 @@ __FAILED:
MPP_RET h264d_flush(void *decoder)
{
MPP_RET ret = MPP_ERR_UNKNOW;
RK_U32 dpb_used_size = 0;
RK_U32 dpb_used_size = 0;
H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
INP_CHECK(ret, !decoder);
INP_CHECK(ret, !p_Dec->p_Inp);
INP_CHECK(ret, !p_Dec->p_Vid);
INP_CHECK(ret, !p_Dec->p_Inp);
INP_CHECK(ret, !p_Dec->p_Vid);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
dpb_used_size = p_Dec->p_Vid->p_Dpb_layer[0]->used_size;
if (p_Dec->mvc_valid) {
dpb_used_size += p_Dec->p_Vid->p_Dpb_layer[1]->used_size;
}
dpb_used_size = p_Dec->p_Vid->p_Dpb_layer[0]->used_size;
if (p_Dec->mvc_valid) {
dpb_used_size += p_Dec->p_Vid->p_Dpb_layer[1]->used_size;
}
if (!dpb_used_size && p_Dec->p_Inp->has_get_eos) {
IOInterruptCB *cb = &p_Dec->p_Inp->init.notify_cb;
if (cb->callBack) {
@@ -567,7 +567,7 @@ MPP_RET h264d_flush(void *decoder)
}
flush_dpb_buf_slot(p_Dec);
if (p_Dec->last_frame_slot_idx >= 0) {
mpp_buf_slot_set_prop(p_Dec->frame_slots, p_Dec->last_frame_slot_idx,
mpp_buf_slot_set_prop(p_Dec->frame_slots, p_Dec->last_frame_slot_idx,
SLOT_EOS, &p_Dec->p_Inp->has_get_eos);
p_Dec->last_frame_slot_idx = -1;
}
@@ -617,7 +617,7 @@ MPP_RET h264d_prepare(void *decoder, MppPacket pkt, HalDecTask *task)
p_Inp = p_Dec->p_Inp;
if (p_Inp->has_get_eos || p_Dec->errctx.un_spt_flag) {
mpp_packet_set_length(pkt, 0);
mpp_packet_set_length(pkt, 0);
goto __RETURN;
}
p_Inp->in_pkt = pkt;
@@ -625,11 +625,11 @@ MPP_RET h264d_prepare(void *decoder, MppPacket pkt, HalDecTask *task)
p_Inp->in_dts = mpp_packet_get_dts(pkt);
if (mpp_packet_get_eos(pkt)) {
p_Inp->pkt_eos = 1;
p_Inp->has_get_eos = 1;
p_Inp->pkt_eos = 1;
p_Inp->has_get_eos = 1;
if (p_Inp->in_length < 4) {
h264d_flush(decoder);
goto __RETURN;
goto __RETURN;
}
p_Inp->in_buf = NULL;
p_Inp->in_length = 0;
@@ -640,13 +640,13 @@ MPP_RET h264d_prepare(void *decoder, MppPacket pkt, HalDecTask *task)
p_Inp->in_length = mpp_packet_get_length(pkt);
p_Inp->pkt_eos = 0;
}
if (p_Inp->in_length > MAX_STREM_IN_SIZE) {
H264D_ERR("[pkt_in_timeUs] input error, stream too large, pts=%lld, eos=%d, len=%d, pkt_no=%d",
p_Inp->in_pts, p_Inp->pkt_eos, p_Inp->in_length, p_Dec->p_Vid->g_framecnt);
mpp_packet_set_length(pkt, 0);
ret = MPP_NOK;
goto __FAILED;
}
if (p_Inp->in_length > MAX_STREM_IN_SIZE) {
H264D_ERR("[pkt_in_timeUs] input error, stream too large, pts=%lld, eos=%d, len=%d, pkt_no=%d",
p_Inp->in_pts, p_Inp->pkt_eos, p_Inp->in_length, p_Dec->p_Vid->g_framecnt);
mpp_packet_set_length(pkt, 0);
ret = MPP_NOK;
goto __FAILED;
}
//!< avcC stream
if (mpp_packet_get_flag(pkt) & MPP_PACKET_FLAG_EXTRA_DATA) {
RK_U8 *pdata = p_Inp->in_buf;
@@ -662,7 +662,7 @@ MPP_RET h264d_prepare(void *decoder, MppPacket pkt, HalDecTask *task)
(ret = parse_prepare_extra_data(p_Inp, p_Dec->p_Cur));
task->valid = p_Inp->task_valid; //!< prepare valid flag
} else {
fwrite_stream_to_file(p_Inp, p_Inp->in_buf, (RK_U32)p_Inp->in_length);
fwrite_stream_to_file(p_Inp, p_Inp->in_buf, (RK_U32)p_Inp->in_length);
do {
(ret = parse_prepare_fast(p_Inp, p_Dec->p_Cur));
task->valid = p_Inp->task_valid; //!< prepare valid flag
@@ -684,7 +684,7 @@ __RETURN:
return ret = MPP_OK;
__FAILED:
return ret;
return ret;
}
@@ -697,18 +697,18 @@ __FAILED:
MPP_RET h264d_parse(void *decoder, HalDecTask *in_task)
{
MPP_RET ret = MPP_ERR_UNKNOW;
H264dErrCtx_t *p_err = NULL;
H264dErrCtx_t *p_err = NULL;
H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
INP_CHECK(ret, !decoder && !in_task);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
p_err = &p_Dec->errctx;
p_err = &p_Dec->errctx;
in_task->valid = 0; // prepare end flag
p_Dec->in_task = in_task;
p_err->cur_err_flag = 0;
p_err->cur_err_flag = 0;
p_err->used_ref_flag = 0;
p_Dec->is_parser_end = 0;
p_Dec->is_parser_end = 0;
FUN_CHECK(ret = parse_loop(p_Dec));
if (p_Dec->is_parser_end) {
@@ -725,9 +725,9 @@ MPP_RET h264d_parse(void *decoder, HalDecTask *in_task)
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;
in_task->flags.used_for_ref = p_err->used_ref_flag;
p_err->dpb_err_flag |= p_err->used_ref_flag ? p_err->cur_err_flag : 0;
in_task->flags.had_error = (p_err->dpb_err_flag | p_err->cur_err_flag) ? 1 : 0;
in_task->flags.used_for_ref = p_err->used_ref_flag;
p_err->dpb_err_flag |= p_err->used_ref_flag ? p_err->cur_err_flag : 0;
in_task->flags.had_error = (p_err->dpb_err_flag | p_err->cur_err_flag) ? 1 : 0;
}
__RETURN:
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
@@ -736,30 +736,30 @@ __RETURN:
__FAILED:
{
H264_StorePic_t *dec_pic = p_Dec->p_Vid->dec_pic;
if (dec_pic) {
H264D_WARNNING("[h264d_parse] h264d_parse failed.\n");
if (dec_pic->mem_mark
&& dec_pic->mem_mark->out_flag
&& (dec_pic->mem_mark->slot_idx >= 0)) {
MppFrame mframe = NULL;
mpp_buf_slot_get_prop(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, SLOT_FRAME_PTR, &mframe);
if (mframe) {
if (p_err->used_ref_flag) {
mpp_frame_set_errinfo(mframe, VPU_FRAME_ERR_UNKNOW);
} else {
mpp_frame_set_discard(mframe, VPU_FRAME_ERR_UNKNOW);
}
}
mpp_buf_slot_set_flag(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, SLOT_QUEUE_USE);
mpp_buf_slot_enqueue(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, QUEUE_DISPLAY);
mpp_buf_slot_clr_flag(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, SLOT_CODEC_USE);
}
reset_dpb_mark(dec_pic->mem_mark);
dec_pic->mem_mark = NULL;
MPP_FREE(dec_pic);
p_Dec->p_Vid->dec_pic = NULL;
}
p_err->dpb_err_flag |= p_err->used_ref_flag ? 1 : 0;
if (dec_pic) {
H264D_WARNNING("[h264d_parse] h264d_parse failed.\n");
if (dec_pic->mem_mark
&& dec_pic->mem_mark->out_flag
&& (dec_pic->mem_mark->slot_idx >= 0)) {
MppFrame mframe = NULL;
mpp_buf_slot_get_prop(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, SLOT_FRAME_PTR, &mframe);
if (mframe) {
if (p_err->used_ref_flag) {
mpp_frame_set_errinfo(mframe, VPU_FRAME_ERR_UNKNOW);
} else {
mpp_frame_set_discard(mframe, VPU_FRAME_ERR_UNKNOW);
}
}
mpp_buf_slot_set_flag(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, SLOT_QUEUE_USE);
mpp_buf_slot_enqueue(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, QUEUE_DISPLAY);
mpp_buf_slot_clr_flag(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, SLOT_CODEC_USE);
}
reset_dpb_mark(dec_pic->mem_mark);
dec_pic->mem_mark = NULL;
MPP_FREE(dec_pic);
p_Dec->p_Vid->dec_pic = NULL;
}
p_err->dpb_err_flag |= p_err->used_ref_flag ? 1 : 0;
}
return ret;
@@ -775,36 +775,36 @@ MPP_RET h264d_callback(void *decoder, void *errinfo)
{
MPP_RET ret = MPP_ERR_UNKNOW;
H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
RK_U32 *p_regs = NULL;
RK_U32 *p_regs = NULL;
INP_CHECK(ret, !decoder);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
p_regs = (RK_U32*)errinfo;
{
MppFrame mframe = NULL;
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
p_regs = (RK_U32*)errinfo;
{
MppFrame mframe = NULL;
RK_U32 out_slot_idx = p_regs[78];
RK_U32 had_err_flag = p_regs[79];
RK_U32 used_ref_flag = p_regs[80];
RK_U32 dec_error_sta = p_regs[1] & 0x00004000;
RK_U32 dec_rdy_sta = p_regs[1] & 0x00001000;
RK_U32 buf_empty_sta = p_regs[1] & 0x00010000;
RK_U32 strmd_error_status = p_regs[45];
RK_U32 strmd_error_detect_flag = p_regs[76] & 0x00008000; // strmd error detect flag
RK_U32 out_slot_idx = p_regs[78];
RK_U32 had_err_flag = p_regs[79];
RK_U32 used_ref_flag = p_regs[80];
RK_U32 dec_error_sta = p_regs[1] & 0x00004000;
RK_U32 dec_rdy_sta = p_regs[1] & 0x00001000;
RK_U32 buf_empty_sta = p_regs[1] & 0x00010000;
RK_U32 strmd_error_status = p_regs[45];
RK_U32 strmd_error_detect_flag = p_regs[76] & 0x00008000; // strmd error detect flag
mpp_buf_slot_get_prop(p_Dec->frame_slots, out_slot_idx, SLOT_FRAME_PTR, &mframe);
if (mframe) {
if (dec_error_sta || (!dec_rdy_sta) || buf_empty_sta
|| had_err_flag || strmd_error_status || strmd_error_detect_flag) {
if (used_ref_flag) {
mpp_frame_set_errinfo(mframe, VPU_FRAME_ERR_UNKNOW);
} else {
mpp_frame_set_discard(mframe, VPU_FRAME_ERR_UNKNOW);
}
}
H264D_DBG(H264D_DBG_CALLBACK, "[CALLBACK] g_no=%d, s_idx=%d, sw[01]=%08x, sw[45]=%08x, sw[76]=%08x, dpberr=%d, ref=%d, errinfo=%d, discard=%d \n",
p_Dec->p_Vid->g_framecnt, out_slot_idx, p_regs[1], p_regs[45], p_regs[76], had_err_flag, used_ref_flag, mpp_frame_get_errinfo(mframe), mpp_frame_get_discard(mframe));
}
}
mpp_buf_slot_get_prop(p_Dec->frame_slots, out_slot_idx, SLOT_FRAME_PTR, &mframe);
if (mframe) {
if (dec_error_sta || (!dec_rdy_sta) || buf_empty_sta
|| had_err_flag || strmd_error_status || strmd_error_detect_flag) {
if (used_ref_flag) {
mpp_frame_set_errinfo(mframe, VPU_FRAME_ERR_UNKNOW);
} else {
mpp_frame_set_discard(mframe, VPU_FRAME_ERR_UNKNOW);
}
}
H264D_DBG(H264D_DBG_CALLBACK, "[CALLBACK] g_no=%d, s_idx=%d, sw[01]=%08x, sw[45]=%08x, sw[76]=%08x, dpberr=%d, ref=%d, errinfo=%d, discard=%d \n",
p_Dec->p_Vid->g_framecnt, out_slot_idx, p_regs[1], p_regs[45], p_regs[76], had_err_flag, used_ref_flag, mpp_frame_get_errinfo(mframe), mpp_frame_get_discard(mframe));
}
}
__RETURN:
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);

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

@@ -733,29 +733,29 @@ __FAILED:
static RK_S32 get_smallest_poc(H264_DpbBuf_t *p_Dpb, RK_S32 *poc, RK_S32 *pos)
{
RK_U32 i = 0;
RK_S32 find_flag = 0;
RK_S32 min_pos = -1;
RK_S32 min_poc = INT_MAX;
RK_S32 find_flag = 0;
RK_S32 min_pos = -1;
RK_S32 min_poc = INT_MAX;
*pos = -1;
*poc = INT_MAX;
for (i = 0; i < p_Dpb->used_size; i++) {
if (min_poc > p_Dpb->fs[i]->poc) {
min_poc = p_Dpb->fs[i]->poc;
min_pos = i;
}
if (min_poc > p_Dpb->fs[i]->poc) {
min_poc = p_Dpb->fs[i]->poc;
min_pos = i;
}
if ((*poc > p_Dpb->fs[i]->poc) && (!p_Dpb->fs[i]->is_output)) {
*poc = p_Dpb->fs[i]->poc;
*pos = i;
find_flag = 1;
find_flag = 1;
}
}
if (!find_flag) {
*poc = min_poc;
*pos = min_pos;
}
if (!find_flag) {
*poc = min_poc;
*pos = min_pos;
}
return find_flag;
return find_flag;
}
static H264_FrameStore_t *alloc_frame_store()
@@ -987,15 +987,15 @@ static MPP_RET output_one_frame_from_dpb(H264_DpbBuf_t *p_Dpb)
H264dVideoCtx_t *p_Vid = p_Dpb->p_Vid;
//!< find smallest POC
if (get_smallest_poc(p_Dpb, &poc, &pos)) {
p_Dpb->last_output_poc = poc;
//!< JVT-P072 ends
FUN_CHECK(ret = write_stored_frame(p_Vid, p_Dpb->fs[pos]));
//!< free frame store and move empty store to end of buffer
if (!is_used_for_reference(p_Dpb->fs[pos])) {
FUN_CHECK(ret = remove_frame_from_dpb(p_Dpb, pos));
if (get_smallest_poc(p_Dpb, &poc, &pos)) {
p_Dpb->last_output_poc = poc;
//!< JVT-P072 ends
FUN_CHECK(ret = write_stored_frame(p_Vid, p_Dpb->fs[pos]));
//!< free frame store and move empty store to end of buffer
if (!is_used_for_reference(p_Dpb->fs[pos])) {
FUN_CHECK(ret = remove_frame_from_dpb(p_Dpb, pos));
}
}
}
return ret = MPP_OK;
__FAILED:
return ret;
@@ -1247,12 +1247,12 @@ MPP_RET store_picture_in_dpb(H264_DpbBuf_t *p_Dpb, H264_StorePic_t *p)
VAL_CHECK(ret, NULL != p); //!< if frame, check for new store
p_Vid->last_pic = NULL;
//!< set use flag
if (p->mem_mark && (p->mem_mark->slot_idx >= 0)) {
mpp_buf_slot_set_flag(p_Vid->p_Dec->frame_slots, p->mem_mark->slot_idx, SLOT_CODEC_USE);
} else {
H264D_ERR("error, p->mem_mark == NULL");
}
//!< set use flag
if (p->mem_mark && (p->mem_mark->slot_idx >= 0)) {
mpp_buf_slot_set_flag(p_Vid->p_Dec->frame_slots, p->mem_mark->slot_idx, SLOT_CODEC_USE);
} else {
H264D_ERR("error, p->mem_mark == NULL");
}
//!< deal with all frames in dpb
p_Vid->last_has_mmco_5 = 0;
p_Vid->last_pic_bottom_field = p->structure == BOTTOM_FIELD;
@@ -1277,77 +1277,76 @@ MPP_RET store_picture_in_dpb(H264_DpbBuf_t *p_Dpb, H264_StorePic_t *p)
sliding_window_memory_management(p_Dpb);
p->is_long_term = 0;
}
while (!remove_unused_frame_from_dpb(p_Dpb));
while (!remove_unused_frame_from_dpb(p_Dpb));
#if 1
while (p_Dpb->used_size == p_Dpb->size) {
RK_S32 min_poc = 0, min_pos = 0;
RK_S32 find_flag = 0;
while (p_Dpb->used_size == p_Dpb->size) {
RK_S32 min_poc = 0, min_pos = 0;
RK_S32 find_flag = 0;
remove_unused_frame_from_dpb(p_Dpb);
find_flag = get_smallest_poc(p_Dpb, &min_poc, &min_pos);
if (!p->used_for_reference) {
if ((!find_flag) || (p->poc < min_poc)) {
p_Dpb->last_output_poc = p->poc;
FUN_CHECK(ret = direct_output(p_Vid, p)); //!< output frame
goto __RETURN;
}
}
//!< used for reference, but not find, then flush a frame in the first
if ((!find_flag) || (p->poc < min_poc)) {
//min_pos = 0;
unmark_for_reference(p_Vid->p_Dec, p_Dpb->fs[min_pos]);
if (!p_Dpb->fs[min_pos]->is_output) {
p_Dpb->last_output_poc = p_Dpb->fs[min_pos]->poc;
FUN_CHECK(ret = write_stored_frame(p_Vid, p_Dpb->fs[min_pos]));
}
FUN_CHECK(ret = remove_frame_from_dpb(p_Dpb, min_pos));
p->is_long_term = 0;
}
FUN_CHECK(ret = output_one_frame_from_dpb(p_Dpb));
}
#endif
#if 1
{
//!< store current decoder picture at end of dpb
FUN_CHECK(ret = insert_picture_in_dpb(p_Vid, p_Dpb->fs[p_Dpb->used_size], p, 0));
if (p->structure != FRAME) {
p_Dpb->last_picture = p_Dpb->fs[p_Dpb->used_size];
} else {
p_Dpb->last_picture = NULL;
remove_unused_frame_from_dpb(p_Dpb);
find_flag = get_smallest_poc(p_Dpb, &min_poc, &min_pos);
if (!p->used_for_reference) {
if ((!find_flag) || (p->poc < min_poc)) {
p_Dpb->last_output_poc = p->poc;
FUN_CHECK(ret = direct_output(p_Vid, p)); //!< output frame
goto __RETURN;
}
}
//!< used for reference, but not find, then flush a frame in the first
if ((!find_flag) || (p->poc < min_poc)) {
//min_pos = 0;
unmark_for_reference(p_Vid->p_Dec, p_Dpb->fs[min_pos]);
if (!p_Dpb->fs[min_pos]->is_output) {
p_Dpb->last_output_poc = p_Dpb->fs[min_pos]->poc;
FUN_CHECK(ret = write_stored_frame(p_Vid, p_Dpb->fs[min_pos]));
}
FUN_CHECK(ret = remove_frame_from_dpb(p_Dpb, min_pos));
p->is_long_term = 0;
}
FUN_CHECK(ret = output_one_frame_from_dpb(p_Dpb));
}
memcpy(&p_Vid->old_pic, p, sizeof(H264_StorePic_t));
p_Vid->last_pic = &p_Vid->old_pic;
p_Dpb->used_size++;
H264D_DBG(H264D_DBG_DPB_INFO, "[DPB_size] p_Dpb->used_size=%d", p_Dpb->used_size);
}
#endif
#if 1
{
RK_S32 min_poc = 0, min_pos = 0;
H264_FrameStore_t *fs = p_Dpb->fs[p_Dpb->used_size - 1];
RK_S32 poc_inc = fs->poc - p_Dpb->last_output_poc;
{
//!< store current decoder picture at end of dpb
FUN_CHECK(ret = insert_picture_in_dpb(p_Vid, p_Dpb->fs[p_Dpb->used_size], p, 0));
if (p->structure != FRAME) {
p_Dpb->last_picture = p_Dpb->fs[p_Dpb->used_size];
} else {
p_Dpb->last_picture = NULL;
}
memcpy(&p_Vid->old_pic, p, sizeof(H264_StorePic_t));
p_Vid->last_pic = &p_Vid->old_pic;
if ((p_Dpb->last_output_poc > INT_MIN) && abs(poc_inc) & 0x1) {
p_Dpb->poc_interval = 1;
p_Dpb->used_size++;
H264D_DBG(H264D_DBG_DPB_INFO, "[DPB_size] p_Dpb->used_size=%d", p_Dpb->used_size);
}
#endif
#if 1
{
RK_S32 min_poc = 0, min_pos = 0;
H264_FrameStore_t *fs = p_Dpb->fs[p_Dpb->used_size - 1];
RK_S32 poc_inc = fs->poc - p_Dpb->last_output_poc;
}
if (p->idr_flag || (p->poc == 0) || (p_Dpb->last_output_poc == INT_MIN)) {
p_Dpb->last_output_poc = p->poc;
FUN_CHECK(ret = write_stored_frame(p_Vid, fs));
}
while ((p_Dpb->last_output_poc > INT_MIN)
&& (get_smallest_poc(p_Dpb, &min_poc, &min_pos))) {
if ((min_poc - p_Dpb->last_output_poc) <= p_Dpb->poc_interval) {
p_Dpb->last_output_poc = min_poc;
FUN_CHECK(ret = write_stored_frame(p_Vid, p_Dpb->fs[min_pos]));
}
else {
break;
}
}
while (!remove_unused_frame_from_dpb(p_Dpb));
}
if ((p_Dpb->last_output_poc > INT_MIN) && abs(poc_inc) & 0x1) {
p_Dpb->poc_interval = 1;
}
if (p->idr_flag || (p->poc == 0) || (p_Dpb->last_output_poc == INT_MIN)) {
p_Dpb->last_output_poc = p->poc;
FUN_CHECK(ret = write_stored_frame(p_Vid, fs));
}
while ((p_Dpb->last_output_poc > INT_MIN)
&& (get_smallest_poc(p_Dpb, &min_poc, &min_pos))) {
if ((min_poc - p_Dpb->last_output_poc) <= p_Dpb->poc_interval) {
p_Dpb->last_output_poc = min_poc;
FUN_CHECK(ret = write_stored_frame(p_Vid, p_Dpb->fs[min_pos]));
} else {
break;
}
}
while (!remove_unused_frame_from_dpb(p_Dpb));
}
#endif
update_ref_list(p_Dpb);
update_ltref_list(p_Dpb);
@@ -1708,7 +1707,7 @@ MPP_RET init_dpb(H264dVideoCtx_t *p_Vid, H264_DpbBuf_t *p_Dpb, RK_S32 type) //
free_dpb(p_Dpb);
}
VAL_CHECK(ret, p_Dpb->size = getDpbSize(p_Vid, active_sps));
p_Dpb->size = MPP_MAX(1, p_Dpb->size);
p_Dpb->size = MPP_MAX(1, p_Dpb->size);
p_Dpb->num_ref_frames = active_sps->max_num_ref_frames;
if (active_sps->max_dec_frame_buffering < active_sps->max_num_ref_frames) {
H264D_WARNNING("DPB size at specified level is smaller than reference frames");

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

@@ -48,9 +48,9 @@ static MPP_RET fill_slice_stream(H264dDxvaCtx_t *dxva_ctx, H264_Nalu_t *p_nal)
RK_U32 streamlen_add = 0;
DXVA_Slice_H264_Long *p_long = NULL;
if (dxva_ctx->slice_count > MAX_SLICE_NUM) {
H264D_ERR("error, slcie_num is larger than 1024");
goto __FAILED;
if (dxva_ctx->slice_count > MAX_SLICE_NUM) {
H264D_ERR("error, slcie_num is larger than 1024");
goto __FAILED;
}
//streamlen_add = p_nal->sodb_len + sizeof(start_code);
//stream_offset = dxva_ctx->strm_offset + streamlen_add;

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

@@ -107,25 +107,25 @@ typedef enum {
STRUCT_NULL = 0,
TOP_FIELD = 0x1,
BOTTOM_FIELD = 0x2,
FRAME = 0x3,
STRUCT_MAX,
FRAME = 0x3,
STRUCT_MAX,
} PictureStructure; //!< New enum for field processing
typedef enum {
PIC_ERR_NULL = 0,
PIC_ERR_TOP = 0x1,
PIC_ERR_BOT = 0x2,
PIC_ERR_FRAME = 0x3,
PIC_ERR_WHOLE = 0x3,
PIC_ERR_MAX,
}PictureError;
PIC_ERR_NULL = 0,
PIC_ERR_TOP = 0x1,
PIC_ERR_BOT = 0x2,
PIC_ERR_FRAME = 0x3,
PIC_ERR_WHOLE = 0x3,
PIC_ERR_MAX,
} PictureError;
typedef enum {
FIELD_ORDER_NULL,
FIELD_ORDER_TOP_FIRST,
FIELD_ORDER_BOT_FIRST,
FIELD_ORDER_SAME,
FIELD_ORDER_MAX
}FieldOrder;
FIELD_ORDER_NULL,
FIELD_ORDER_TOP_FIRST,
FIELD_ORDER_BOT_FIRST,
FIELD_ORDER_SAME,
FIELD_ORDER_MAX
} FieldOrder;
//!< Field Coding Types
typedef enum {
FRAME_CODING = 0,
@@ -191,11 +191,11 @@ typedef struct h264_nalu_mvc_ext_t {
//!< decoder refence picture marking
typedef struct h264_drpm_t {
RK_S32 memory_management_control_operation;
RK_S32 difference_of_pic_nums_minus1;
RK_S32 long_term_pic_num;
RK_S32 long_term_frame_idx;
RK_S32 max_long_term_frame_idx_plus1;
RK_S32 memory_management_control_operation;
RK_S32 difference_of_pic_nums_minus1;
RK_S32 long_term_pic_num;
RK_S32 long_term_frame_idx;
RK_S32 max_long_term_frame_idx_plus1;
struct h264_drpm_t *Next;
} H264_DRPM_t;
@@ -328,9 +328,9 @@ typedef struct h264_frame_store_t {
RK_S32 inter_view_flag[2];
RK_S32 anchor_pic_flag[2];
RK_S32 layer_id;
RK_S32 slice_type;
RK_S32 slice_type;
RK_U32 frame_num;
RK_S32 structure;
RK_S32 structure;
struct h264_store_pic_t *frame;
struct h264_store_pic_t *top_field;
struct h264_store_pic_t *bottom_field;
@@ -345,7 +345,7 @@ typedef struct h264_dpb_buf_t {
RK_U32 ltref_frames_in_buffer;
RK_U32 used_size_il;
RK_S32 poc_interval;
RK_S32 poc_interval;
RK_S32 last_output_poc;
RK_S32 last_output_view_id;
RK_S32 max_long_term_pic_idx;
@@ -742,10 +742,10 @@ typedef struct h264_slice_t {
RK_S32 num_ref_idx_active[2]; //!< number of available list references
RK_S32 num_ref_idx_override_flag;
RK_S32 ref_pic_list_reordering_flag[2];
RK_S32 *modification_of_pic_nums_idc[2];
RK_S32 *abs_diff_pic_num_minus1[2];
RK_S32 *long_term_pic_idx[2];
RK_S32 *abs_diff_view_idx_minus1[2];
RK_S32 *modification_of_pic_nums_idc[2];
RK_S32 *abs_diff_pic_num_minus1[2];
RK_S32 *long_term_pic_idx[2];
RK_S32 *abs_diff_view_idx_minus1[2];
struct h264_drpm_t *dec_ref_pic_marking_buffer;
RK_U32 drpm_used_bitlen;
RK_S32 no_output_of_prior_pics_flag;
@@ -866,14 +866,14 @@ typedef struct h264d_input_ctx_t {
RK_U32 nal_size;
RK_S32 sps_num;
RK_S32 pps_num;
//!< write stream
char fname[2][512];
FILE *fp;
RK_U8 *spspps_buf;
RK_U32 spspps_size;
RK_U32 spspps_len;
RK_U32 spspps_offset;
RK_U32 spspps_update_flag;
//!< write stream
char fname[2][512];
FILE *fp;
RK_U8 *spspps_buf;
RK_U32 spspps_size;
RK_U32 spspps_len;
RK_U32 spspps_offset;
RK_U32 spspps_update_flag;
} H264dInputCtx_t;
@@ -919,13 +919,13 @@ typedef struct h264d_cur_ctx_t {
RK_S64 last_dts;
RK_S64 curr_pts;
RK_S64 curr_dts;
//!< malloc buffer for current slice
RK_S32 modification_of_pic_nums_idc[2][MAX_REORDER_TIMES];
RK_S32 abs_diff_pic_num_minus1[2][MAX_REORDER_TIMES];
RK_S32 long_term_pic_idx[2][MAX_REORDER_TIMES];
RK_S32 abs_diff_view_idx_minus1[2][MAX_REORDER_TIMES];
struct h264_drpm_t dec_ref_pic_marking_buffer[MAX_MARKING_TIMES];
//!< malloc buffer for current slice
RK_S32 modification_of_pic_nums_idc[2][MAX_REORDER_TIMES];
RK_S32 abs_diff_pic_num_minus1[2][MAX_REORDER_TIMES];
RK_S32 long_term_pic_idx[2][MAX_REORDER_TIMES];
RK_S32 abs_diff_view_idx_minus1[2][MAX_REORDER_TIMES];
struct h264_drpm_t dec_ref_pic_marking_buffer[MAX_MARKING_TIMES];
} H264dCurCtx_t;
//!< parameters for video decoder
@@ -941,13 +941,13 @@ typedef struct h264d_video_ctx_t {
struct h264d_cur_ctx_t *p_Cur; //!< H264_CurParameters
struct h264_dpb_buf_t *p_Dpb_layer[MAX_NUM_DPB_LAYERS];
struct h264_store_pic_t *dec_pic; //!< current decoder picture
struct h264_store_pic_t *last_pic;
struct h264_store_pic_t *last_pic;
struct h264_store_pic_t *no_ref_pic; //!< no reference picture
struct h264_frame_store_t out_buffer;
struct h264_dpb_mark_t *active_dpb_mark[MAX_NUM_DPB_LAYERS]; //!< acitve_dpb_memory
struct h264_store_pic_t old_pic;
struct h264_store_pic_t old_pic;
struct h264_old_slice_par_t old_slice;
RK_S32 *qmatrix[12]; //!< scanlist pointer
RK_U32 stream_size;
@@ -1054,10 +1054,10 @@ typedef enum slice_state_type {
} SLICE_STATUS;
typedef struct h264_err_ctx_t {
RK_U32 un_spt_flag;
RK_U32 cur_err_flag; //!< current decoded picture error
RK_U32 un_spt_flag;
RK_U32 cur_err_flag; //!< current decoded picture error
RK_U32 used_ref_flag;
RK_U32 dpb_err_flag; //!< dpb storage had error
RK_U32 dpb_err_flag; //!< dpb storage had error
RK_U32 i_slice_no;
RK_S32 first_iframe_poc;

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

@@ -462,8 +462,7 @@ static MPP_RET check_dpb_field_paired(H264_FrameStore_t *p_last, H264_StorePic_t
|| (p_last->is_used == 2 && cur_structure == BOTTOM_FIELD) //!< Bot + Bot
//|| ((!dec_pic->combine_flag) && p_last->is_used == 2 && cur_structure == TOP_FIELD) //!< Bot + Top + not combine
|| ((!dec_pic->combine_flag) && p_last->is_used == 1 && cur_structure == BOTTOM_FIELD) //!< Top + Bot + not combine
)
{
) {
H264D_WARNNING("[check_field_paired] (discard) combine_flag=%d, last_used=%d, curr_struct=%d",
dec_pic->combine_flag, p_last->is_used, cur_structure);
return ret = MPP_NOK;
@@ -1945,7 +1944,7 @@ void flush_dpb_buf_slot(H264_DecCtx_t *p_Dec)
mpp_buf_slot_set_flag(p_Dec->frame_slots, p_mark->slot_idx, SLOT_QUEUE_USE);
mpp_buf_slot_enqueue(p_Dec->frame_slots, p_mark->slot_idx, QUEUE_DISPLAY);
mpp_buf_slot_clr_flag(p_Dec->frame_slots, p_mark->slot_idx, SLOT_CODEC_USE);
p_Dec->last_frame_slot_idx = p_mark->slot_idx;
p_Dec->last_frame_slot_idx = p_mark->slot_idx;
}
}
reset_dpb_mark(p_mark);
@@ -1994,16 +1993,16 @@ MPP_RET init_picture(H264_SLICE_t *currSlice)
goto __FAILED;
}
FUN_CHECK(ret = alloc_decpic(currSlice));
if (p_err->i_slice_no < 2) {
if ((!currSlice->layer_id) && (I_SLICE == currSlice->slice_type)) {
p_err->first_iframe_poc = p_Vid->dec_pic->poc; //!< recoder first i frame poc
}
if (p_Vid->dec_pic->poc < p_err->first_iframe_poc) {
H264D_WARNNING("[Discard] Discard poc less than first I Slice. \n");
ret = MPP_NOK;
goto __FAILED;
}
}
if (p_err->i_slice_no < 2) {
if ((!currSlice->layer_id) && (I_SLICE == currSlice->slice_type)) {
p_err->first_iframe_poc = p_Vid->dec_pic->poc; //!< recoder first i frame poc
}
if (p_Vid->dec_pic->poc < p_err->first_iframe_poc) {
H264D_WARNNING("[Discard] Discard poc less than first I Slice. \n");
ret = MPP_NOK;
goto __FAILED;
}
}
//!< idr_memory_management MVC_layer, idr_flag==1
if (currSlice->layer_id && !currSlice->svc_extension_flag && !currSlice->mvcExt.non_idr_flag) {
ASSERT(currSlice->layer_id == 1);

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

@@ -98,7 +98,7 @@ static void reset_slice(H264dVideoCtx_t *p_Vid)
currSlice->listXsizeP[i] = 0;
currSlice->listXsizeB[i] = 0;
}
reset_cur_slice(p_Vid->p_Cur, currSlice);
reset_cur_slice(p_Vid->p_Cur, currSlice);
FunctionOut(p_Vid->p_Dec->logctx.parr[RUN_PARSE]);
}
@@ -107,18 +107,18 @@ static MPP_RET realloc_buffer(RK_U8 **buf, RK_U32 *max_size, RK_U32 add_size)
{
MPP_RET ret = MPP_ERR_UNKNOW;
if ((*buf) == NULL) {
H264D_ERR("[realloc_buffer] pointer is null, %p",(*buf));
ret = MPP_ERR_MALLOC;
goto __FAILED;
}
add_size = MPP_ALIGN(add_size, 16);
H264D_ERR("[realloc_buffer] pointer is null, %p", (*buf));
ret = MPP_ERR_MALLOC;
goto __FAILED;
}
add_size = MPP_ALIGN(add_size, 16);
(*buf) = mpp_realloc((*buf), RK_U8, ((*max_size) + add_size));
if ((*buf) == NULL) {
H264D_ERR("[realloc_buffer] max_size=%d, add_size=%d \n",(*max_size), add_size);
ret = MPP_ERR_MALLOC;
goto __FAILED;
}
if ((*buf) == NULL) {
H264D_ERR("[realloc_buffer] max_size=%d, add_size=%d \n", (*max_size), add_size);
ret = MPP_ERR_MALLOC;
goto __FAILED;
}
(*max_size) += add_size;
return ret = MPP_OK;
@@ -138,7 +138,7 @@ static void reset_nalu(H264dCurStream_t *p_strm)
static void find_prefix_code(RK_U8 *p_data, H264dCurStream_t *p_strm)
{
p_strm->prefixdata = (p_strm->prefixdata << 8) | (*p_data);
p_strm->prefixdata = (p_strm->prefixdata << 8) | (*p_data);
if ((p_strm->prefixdata & 0x00FFFFFF) == 0x00000001) {
if (p_strm->startcode_found) {
p_strm->endcode_found = 1;
@@ -227,7 +227,7 @@ static MPP_RET parser_one_nalu(H264_SLICE_t *currSlice)
H264D_DBG(H264D_DBG_PARSE_NALU, "nalu_type=SLICE.");
FUN_CHECK(ret = process_slice(currSlice));
//if (currSlice->start_mb_nr == 0) {
currSlice->p_Dec->nalu_ret = StartOfPicture;
currSlice->p_Dec->nalu_ret = StartOfPicture;
//} else {
// currSlice->p_Dec->nalu_ret = StartOfSlice;
//}
@@ -309,8 +309,8 @@ static MPP_RET add_empty_nalu(H264dCurStream_t *p_strm)
RK_U32 add_size = sizeof(H264dNaluHead_t);
if ((p_strm->head_offset + add_size) > HEAD_BUF_MAX_SIZE) {
H264D_ERR("error, head_offset is larger than %d", HEAD_BUF_MAX_SIZE);
goto __FAILED;
H264D_ERR("error, head_offset is larger than %d", HEAD_BUF_MAX_SIZE);
goto __FAILED;
}
p_des = &p_strm->head_buf[p_strm->head_offset];
((H264dNaluHead_t *)p_des)->is_frame_end = 1;
@@ -338,28 +338,28 @@ static MPP_RET store_cur_nalu(H264dCurCtx_t *p_Cur, H264dCurStream_t *p_strm, H2
|| (p_strm->nalu_type == NALU_TYPE_PREFIX)
|| (p_strm->nalu_type == NALU_TYPE_SLC_EXT)) {
RK_U32 head_size = MPP_MIN(HEAD_SYNTAX_MAX_SIZE, p_strm->nalu_len);
RK_U32 add_size = head_size + sizeof(H264dNaluHead_t);
RK_U32 head_size = MPP_MIN(HEAD_SYNTAX_MAX_SIZE, p_strm->nalu_len);
RK_U32 add_size = head_size + sizeof(H264dNaluHead_t);
if ((p_strm->head_offset + add_size) > HEAD_BUF_MAX_SIZE) {
H264D_ERR("error, head_offset is larger than %d", HEAD_BUF_MAX_SIZE);
goto __FAILED;
if ((p_strm->head_offset + add_size) > HEAD_BUF_MAX_SIZE) {
H264D_ERR("error, head_offset is larger than %d", HEAD_BUF_MAX_SIZE);
goto __FAILED;
}
p_des = &p_strm->head_buf[p_strm->head_offset];
((H264dNaluHead_t *)p_des)->is_frame_end = 0;
((H264dNaluHead_t *)p_des)->nalu_type = p_strm->nalu_type;
((H264dNaluHead_t *)p_des)->sodb_len = head_size;
memcpy(p_des + sizeof(H264dNaluHead_t), p_strm->nalu_buf, head_size);
p_strm->head_offset += add_size;
((H264dNaluHead_t *)p_des)->sodb_len = head_size;
memcpy(p_des + sizeof(H264dNaluHead_t), p_strm->nalu_buf, head_size);
p_strm->head_offset += add_size;
} //!< fill sodb buffer
if ((p_strm->nalu_type == NALU_TYPE_SLICE)
if ((p_strm->nalu_type == NALU_TYPE_SLICE)
|| (p_strm->nalu_type == NALU_TYPE_IDR)) {
RK_U32 add_size = p_strm->nalu_len + sizeof(g_start_precode);
RK_U32 add_size = p_strm->nalu_len + sizeof(g_start_precode);
if ((dxva_ctx->strm_offset + add_size) > SODB_BUF_MAX_SIZE) {
H264D_ERR("error, bitstream_offset is larger than %d", SODB_BUF_MAX_SIZE);
goto __FAILED;
if ((dxva_ctx->strm_offset + add_size) > SODB_BUF_MAX_SIZE) {
H264D_ERR("error, bitstream_offset is larger than %d", SODB_BUF_MAX_SIZE);
goto __FAILED;
}
p_des = &dxva_ctx->bitstream[dxva_ctx->strm_offset];
@@ -367,24 +367,23 @@ static MPP_RET store_cur_nalu(H264dCurCtx_t *p_Cur, H264dCurStream_t *p_strm, H2
memcpy(p_des + sizeof(g_start_precode), p_strm->nalu_buf, p_strm->nalu_len);
dxva_ctx->strm_offset += add_size;
}
if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) {
H264dInputCtx_t *p_Inp = p_Cur->p_Inp;
if ((p_strm->nalu_type == NALU_TYPE_SPS)
|| (p_strm->nalu_type == NALU_TYPE_PPS)) {
if (p_Inp->spspps_update_flag) {
p_des = &p_Inp->spspps_buf[p_Inp->spspps_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);
p_Inp->spspps_offset += p_strm->nalu_len + sizeof(g_start_precode);
p_Inp->spspps_len = p_Inp->spspps_offset;
}
}
else if ((p_strm->nalu_type == NALU_TYPE_SLICE)
|| (p_strm->nalu_type == NALU_TYPE_IDR)) {
p_Cur->p_Inp->spspps_update_flag = 1;
p_Inp->spspps_offset = 0;
}
}
if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) {
H264dInputCtx_t *p_Inp = p_Cur->p_Inp;
if ((p_strm->nalu_type == NALU_TYPE_SPS)
|| (p_strm->nalu_type == NALU_TYPE_PPS)) {
if (p_Inp->spspps_update_flag) {
p_des = &p_Inp->spspps_buf[p_Inp->spspps_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);
p_Inp->spspps_offset += p_strm->nalu_len + sizeof(g_start_precode);
p_Inp->spspps_len = p_Inp->spspps_offset;
}
} else if ((p_strm->nalu_type == NALU_TYPE_SLICE)
|| (p_strm->nalu_type == NALU_TYPE_IDR)) {
p_Cur->p_Inp->spspps_update_flag = 1;
p_Inp->spspps_offset = 0;
}
}
return ret = MPP_OK;
__FAILED:
return ret;
@@ -462,19 +461,19 @@ static RK_U64 global_flie_size = 0;
*/
MPP_RET open_stream_file(H264dInputCtx_t *p_Inp, char *path)
{
if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) {
if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) {
sprintf(p_Inp->fname[0], "%s/rkv_h264d_file_00.h264", path);
sprintf(p_Inp->fname[1], "%s/rkv_h264d_file_01.h264", path);
sprintf(p_Inp->fname[0], "%s/rkv_h264d_file_00.h264", path);
sprintf(p_Inp->fname[1], "%s/rkv_h264d_file_01.h264", path);
p_Inp->fp = fopen(p_Inp->fname[global_file_fid], "ab"); {
if (p_Inp->fp == NULL) {
H264D_WARNNING("[open_stream_file] can not open stream file, %s.", p_Inp->fname[global_file_fid]);
}
}
}
p_Inp->fp = fopen(p_Inp->fname[global_file_fid], "ab"); {
if (p_Inp->fp == NULL) {
H264D_WARNNING("[open_stream_file] can not open stream file, %s.", p_Inp->fname[global_file_fid]);
}
}
}
return MPP_OK;
return MPP_OK;
}
/*!
***********************************************************************
@@ -484,28 +483,27 @@ MPP_RET open_stream_file(H264dInputCtx_t *p_Inp, char *path)
*/
MPP_RET fwrite_stream_to_file(H264dInputCtx_t *p_Inp, RK_U8 *pdata, RK_U32 len)
{
if (p_Inp->fp && (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN)) {
if (p_Inp->fp) {
fwrite(pdata, sizeof(RK_U8), len, p_Inp->fp);
fflush(p_Inp->fp);
}
global_flie_size += len;
if (global_flie_size > MAX_ES_FILE_SIZE) {
FCLOSE(p_Inp->fp);
global_file_fid = 1 - global_file_fid;
global_flie_size = 0;
p_Inp->fp = fopen(p_Inp->fname[global_file_fid], "wb");
if (p_Inp->fp == NULL) {
H264D_WARNNING("[open_stream_file] can not open stream file, %s", p_Inp->fname[global_file_fid]);
}
else {
fwrite(p_Inp->spspps_buf, sizeof(RK_U8), p_Inp->spspps_len, p_Inp->fp);
fflush(p_Inp->fp);
}
}
}
if (p_Inp->fp && (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN)) {
if (p_Inp->fp) {
fwrite(pdata, sizeof(RK_U8), len, p_Inp->fp);
fflush(p_Inp->fp);
}
global_flie_size += len;
if (global_flie_size > MAX_ES_FILE_SIZE) {
FCLOSE(p_Inp->fp);
global_file_fid = 1 - global_file_fid;
global_flie_size = 0;
p_Inp->fp = fopen(p_Inp->fname[global_file_fid], "wb");
if (p_Inp->fp == NULL) {
H264D_WARNNING("[open_stream_file] can not open stream file, %s", p_Inp->fname[global_file_fid]);
} else {
fwrite(p_Inp->spspps_buf, sizeof(RK_U8), p_Inp->spspps_len, p_Inp->fp);
fflush(p_Inp->fp);
}
}
}
return MPP_OK;
return MPP_OK;
}
/*!
***********************************************************************
@@ -515,14 +513,14 @@ MPP_RET fwrite_stream_to_file(H264dInputCtx_t *p_Inp, RK_U8 *pdata, RK_U32 len)
*/
MPP_RET close_stream_file(H264dInputCtx_t *p_Inp)
{
if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) {
if (p_Inp->fp) {
fflush(p_Inp->fp);
FCLOSE(p_Inp->fp);
}
}
if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) {
if (p_Inp->fp) {
fflush(p_Inp->fp);
FCLOSE(p_Inp->fp);
}
}
return MPP_OK;
return MPP_OK;
}
/*!
***********************************************************************
@@ -565,8 +563,8 @@ MPP_RET parse_prepare(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
pkt_impl->length--;
if (p_strm->startcode_found) {
if (p_strm->nalu_len >= NALU_BUF_MAX_SIZE) {
H264D_ERR("error, nalu_len is larger than %d", NALU_BUF_MAX_SIZE);
goto __FAILED;
H264D_ERR("error, nalu_len is larger than %d", NALU_BUF_MAX_SIZE);
goto __FAILED;
}
p_strm->nalu_buf[p_strm->nalu_len++] = *p_strm->curdata;
if (p_strm->nalu_len == 1) {
@@ -656,8 +654,8 @@ MPP_RET parse_prepare_fast(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
pkt_impl->length--;
if (p_strm->startcode_found) {
if (p_strm->nalu_len >= NALU_BUF_MAX_SIZE) {
H264D_ERR("error, nalu_len is larger than %d", NALU_BUF_MAX_SIZE);
goto __FAILED;
H264D_ERR("error, nalu_len is larger than %d", NALU_BUF_MAX_SIZE);
goto __FAILED;
}
p_strm->nalu_buf[p_strm->nalu_len++] = *p_strm->curdata;
if (p_strm->nalu_len == 1) {
@@ -874,8 +872,8 @@ MPP_RET parse_prepare_extra_data(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
p_Cur->p_Inp->task_valid = 1;
p_Cur->p_Dec->is_new_frame = 0;
p_Cur->last_dts = p_Inp->in_dts;
p_Cur->last_pts = p_Inp->in_pts;
p_Cur->last_dts = p_Inp->in_dts;
p_Cur->last_pts = p_Inp->in_pts;
}
//__RETURN:
FunctionOut(logctx->parr[RUN_PARSE]);
@@ -907,14 +905,14 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
INP_CHECK(ret, !p_Dec);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
//!< ==== loop ====
p_Dec->next_state = SliceSTATE_ResetSlice;
p_Dec->next_state = SliceSTATE_ResetSlice;
p_curdata = p_Dec->p_Cur->strm.head_buf;
while (while_loop_flag) {
switch (p_Dec->next_state) {
case SliceSTATE_ResetSlice:
reset_slice(p_Dec->p_Vid);
p_Dec->next_state = SliceSTATE_ReadNalu;
p_Dec->next_state = SliceSTATE_ReadNalu;
H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_ResetSlice");
break;
case SliceSTATE_ReadNalu:
@@ -948,32 +946,30 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_ParseNalu");
break;
case SliceSTATE_InitPicture:
if (!p_Dec->p_Vid->iNumOfSlicesDecoded) {
FUN_CHECK(ret = init_picture(&p_Dec->p_Cur->slice));
p_Dec->is_parser_end = 1;
}
p_Dec->next_state = SliceSTATE_GetSliceData;
if (!p_Dec->p_Vid->iNumOfSlicesDecoded) {
FUN_CHECK(ret = init_picture(&p_Dec->p_Cur->slice));
p_Dec->is_parser_end = 1;
}
p_Dec->next_state = SliceSTATE_GetSliceData;
H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_InitPicture");
break;
case SliceSTATE_GetSliceData:
FUN_CHECK(ret = fill_slice_syntax(&p_Dec->p_Cur->slice, p_Dec->dxva_ctx));
p_Dec->p_Vid->iNumOfSlicesDecoded++;
if (p_Dec->is_parser_end) {
p_Dec->next_state = SliceSTATE_RegisterOneFrame;
}
else
{
p_Dec->next_state = SliceSTATE_ResetSlice;
}
if (p_Dec->is_parser_end) {
p_Dec->next_state = SliceSTATE_RegisterOneFrame;
} else {
p_Dec->next_state = SliceSTATE_ResetSlice;
}
H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_GetSliceData");
break;
case SliceSTATE_RegisterOneFrame:
if (!p_Dec->is_parser_end){
ret = MPP_NOK;
goto __FAILED;
}
commit_buffer(p_Dec->dxva_ctx);
while_loop_flag = 0;
if (!p_Dec->is_parser_end) {
ret = MPP_NOK;
goto __FAILED;
}
commit_buffer(p_Dec->dxva_ctx);
while_loop_flag = 0;
p_Dec->next_state = SliceSTATE_ReadNalu;
H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_RegisterOneFrame");
break;

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

@@ -36,14 +36,14 @@ static MPP_RET ref_pic_list_mvc_modification(H264_SLICE_t *currSlice)
if ((currSlice->slice_type % 5) != I_SLICE && (currSlice->slice_type % 5) != SI_SLICE) {
READ_ONEBIT(p_bitctx, &currSlice->ref_pic_list_reordering_flag[LIST_0], "ref_pic_list_reordering_flag");
if (currSlice->ref_pic_list_reordering_flag[LIST_0]) {
RK_U32 size = currSlice->num_ref_idx_active[LIST_0] + 1;
RK_U32 size = currSlice->num_ref_idx_active[LIST_0] + 1;
i = 0;
do {
if (i >= size) {
ret = MPP_NOK;
H264D_WARNNING("ref_pic_list_reordering error, i >= num_ref_idx_active[LIST_0](%d)", size);
goto __BITREAD_ERR;
}
if (i >= size) {
ret = MPP_NOK;
H264D_WARNNING("ref_pic_list_reordering error, i >= num_ref_idx_active[LIST_0](%d)", size);
goto __BITREAD_ERR;
}
READ_UE(p_bitctx, &modification_of_pic_nums_idc, "modification_of_pic_nums_idc");
currSlice->modification_of_pic_nums_idc[LIST_0][i] = modification_of_pic_nums_idc;
if (modification_of_pic_nums_idc == 0 || modification_of_pic_nums_idc == 1) {
@@ -62,14 +62,14 @@ static MPP_RET ref_pic_list_mvc_modification(H264_SLICE_t *currSlice)
if (currSlice->slice_type % 5 == B_SLICE) {
READ_ONEBIT(p_bitctx, &currSlice->ref_pic_list_reordering_flag[LIST_1], "ref_pic_list_reordering_flag");
if (currSlice->ref_pic_list_reordering_flag[LIST_1]) {
RK_U32 size = currSlice->num_ref_idx_active[LIST_1] + 1;
RK_U32 size = currSlice->num_ref_idx_active[LIST_1] + 1;
i = 0;
do {
if (i >= size) {
ret = MPP_NOK;
H264D_WARNNING("ref_pic_list_reordering error, i >= num_ref_idx_active[LIST_1](%d)", size);
goto __BITREAD_ERR;
}
if (i >= size) {
ret = MPP_NOK;
H264D_WARNNING("ref_pic_list_reordering error, i >= num_ref_idx_active[LIST_1](%d)", size);
goto __BITREAD_ERR;
}
READ_UE(p_bitctx, &modification_of_pic_nums_idc, "modification_of_pic_nums_idc");
currSlice->modification_of_pic_nums_idc[LIST_1][i] = modification_of_pic_nums_idc;
if (modification_of_pic_nums_idc == 0 || modification_of_pic_nums_idc == 1) {
@@ -91,7 +91,7 @@ static MPP_RET ref_pic_list_mvc_modification(H264_SLICE_t *currSlice)
__BITREAD_ERR:
ret = p_bitctx->ret;
return ret;
return ret;
}
static MPP_RET pred_weight_table(H264_SLICE_t *currSlice)
@@ -167,9 +167,9 @@ static MPP_RET dec_ref_pic_marking(H264_SLICE_t *pSlice)
READ_ONEBIT(p_bitctx, &pSlice->adaptive_ref_pic_buffering_flag, "adaptive_ref_pic_buffering_flag");
if (pSlice->adaptive_ref_pic_buffering_flag) {
RK_U32 i = 0;
RK_U32 i = 0;
do { //!< read Memory Management Control Operation
tmp_drpm = &pSlice->p_Cur->dec_ref_pic_marking_buffer[i];
tmp_drpm = &pSlice->p_Cur->dec_ref_pic_marking_buffer[i];
tmp_drpm->Next = NULL;
READ_UE(p_bitctx, &val, "memory_management_control_operation");
tmp_drpm->memory_management_control_operation = val;
@@ -196,7 +196,7 @@ static MPP_RET dec_ref_pic_marking(H264_SLICE_t *pSlice)
}
tmp_drpm2->Next = tmp_drpm;
}
i++;
i++;
} while (val != 0);
}
}
@@ -205,7 +205,7 @@ static MPP_RET dec_ref_pic_marking(H264_SLICE_t *pSlice)
__BITREAD_ERR:
ret = p_bitctx->ret;
return ret;
return ret;
}
static void init_slice_parmeters(H264_SLICE_t *currSlice)
@@ -216,14 +216,14 @@ static void init_slice_parmeters(H264_SLICE_t *currSlice)
//--- init slice syntax
currSlice->idr_flag = ((cur_nalu->nalu_type == NALU_TYPE_IDR)
|| (currSlice->mvcExt.valid && !currSlice->mvcExt.non_idr_flag));
currSlice->nal_reference_idc = cur_nalu->nal_reference_idc;
//!< set ref flag and dpb error flag
{
p_Vid->p_Dec->errctx.used_ref_flag = currSlice->nal_reference_idc ? 1 : 0;
if (currSlice->slice_type == I_SLICE) {
p_Vid->p_Dec->errctx.dpb_err_flag = 0;
}
}
currSlice->nal_reference_idc = cur_nalu->nal_reference_idc;
//!< set ref flag and dpb error flag
{
p_Vid->p_Dec->errctx.used_ref_flag = currSlice->nal_reference_idc ? 1 : 0;
if (currSlice->slice_type == I_SLICE) {
p_Vid->p_Dec->errctx.dpb_err_flag = 0;
}
}
if ((!currSlice->svc_extension_flag) || currSlice->mvcExt.iPrefixNALU) { // MVC or have prefixNALU
currSlice->view_id = currSlice->mvcExt.view_id;
currSlice->inter_view_flag = currSlice->mvcExt.inter_view_flag;
@@ -373,21 +373,21 @@ __FAILED:
//extern "C"
MPP_RET reset_cur_slice(H264dCurCtx_t *p_Cur, H264_SLICE_t *p)
{
if (p) {
p->modification_of_pic_nums_idc[LIST_0] = p_Cur->modification_of_pic_nums_idc[LIST_0];
p->abs_diff_pic_num_minus1[LIST_0] = p_Cur->abs_diff_pic_num_minus1[LIST_0];
p->long_term_pic_idx[LIST_0] = p_Cur->long_term_pic_idx[LIST_0];
p->abs_diff_view_idx_minus1[LIST_0] = p_Cur->abs_diff_view_idx_minus1[LIST_0];
if (p) {
p->modification_of_pic_nums_idc[LIST_0] = p_Cur->modification_of_pic_nums_idc[LIST_0];
p->abs_diff_pic_num_minus1[LIST_0] = p_Cur->abs_diff_pic_num_minus1[LIST_0];
p->long_term_pic_idx[LIST_0] = p_Cur->long_term_pic_idx[LIST_0];
p->abs_diff_view_idx_minus1[LIST_0] = p_Cur->abs_diff_view_idx_minus1[LIST_0];
p->modification_of_pic_nums_idc[LIST_1] = p_Cur->modification_of_pic_nums_idc[LIST_1];
p->abs_diff_pic_num_minus1[LIST_1] = p_Cur->abs_diff_pic_num_minus1[LIST_1];
p->long_term_pic_idx[LIST_1] = p_Cur->long_term_pic_idx[LIST_1];
p->abs_diff_view_idx_minus1[LIST_1] = p_Cur->abs_diff_view_idx_minus1[LIST_1];
p->modification_of_pic_nums_idc[LIST_1] = p_Cur->modification_of_pic_nums_idc[LIST_1];
p->abs_diff_pic_num_minus1[LIST_1] = p_Cur->abs_diff_pic_num_minus1[LIST_1];
p->long_term_pic_idx[LIST_1] = p_Cur->long_term_pic_idx[LIST_1];
p->abs_diff_view_idx_minus1[LIST_1] = p_Cur->abs_diff_view_idx_minus1[LIST_1];
p->dec_ref_pic_marking_buffer = NULL;
}
p->dec_ref_pic_marking_buffer = NULL;
}
return MPP_OK;
return MPP_OK;
}
/*!
@@ -420,62 +420,56 @@ MPP_RET process_slice(H264_SLICE_t *currSlice)
p_Vid->slice_type = currSlice->slice_type = temp % 5;
READ_UE(p_bitctx, &currSlice->pic_parameter_set_id, "slice_pic_parameter_set_id");
init_slice_parmeters(currSlice);
FUN_CHECK(ret = set_slice_user_parmeters(currSlice));
//!< read rest slice header syntax
{
READ_BITS(p_bitctx, currSlice->active_sps->log2_max_frame_num_minus4 + 4, &currSlice->frame_num, "frame_num");
if (currSlice->active_sps->frame_mbs_only_flag) { //!< user in_slice info
p_Vid->structure = FRAME;
currSlice->field_pic_flag = 0;
currSlice->bottom_field_flag = 0;
}
else {
READ_ONEBIT(p_bitctx, &currSlice->field_pic_flag, "field_pic_flag");
if (currSlice->field_pic_flag) {
READ_ONEBIT(p_bitctx, &currSlice->bottom_field_flag, "field_pic_flag");
p_Vid->structure = currSlice->bottom_field_flag ? BOTTOM_FIELD : TOP_FIELD;
}
else {
p_Vid->structure = FRAME;
currSlice->bottom_field_flag = 0;
}
}
currSlice->structure = p_Vid->structure;
currSlice->mb_aff_frame_flag = (currSlice->active_sps->mb_adaptive_frame_field_flag && (currSlice->field_pic_flag == 0));
if (currSlice->idr_flag) {
READ_UE(p_bitctx, &currSlice->idr_pic_id, "idr_pic_id");
}
else if (currSlice->svc_extension_flag == 0 && currSlice->mvcExt.non_idr_flag == 0) {
READ_UE(p_bitctx, &currSlice->idr_pic_id, "idr_pic_id");
}
poc_used_bits = p_bitctx->used_bits; //!< init poc used bits
if (currSlice->active_sps->pic_order_cnt_type == 0) {
READ_BITS(p_bitctx, currSlice->active_sps->log2_max_pic_order_cnt_lsb_minus4 + 4, &currSlice->pic_order_cnt_lsb, "pic_order_cnt_lsb");
if (currSlice->p_Vid->active_pps->bottom_field_pic_order_in_frame_present_flag == 1
&& !currSlice->field_pic_flag) {
READ_SE(p_bitctx, &currSlice->delta_pic_order_cnt_bottom, "delta_pic_order_cnt_bottom");
}
else {
currSlice->delta_pic_order_cnt_bottom = 0;
}
}
if (currSlice->active_sps->pic_order_cnt_type == 1) {
if (!currSlice->active_sps->delta_pic_order_always_zero_flag) {
READ_SE(p_bitctx, &currSlice->delta_pic_order_cnt[0], "delta_pic_order_cnt[0]");
FUN_CHECK(ret = set_slice_user_parmeters(currSlice));
//!< read rest slice header syntax
{
READ_BITS(p_bitctx, currSlice->active_sps->log2_max_frame_num_minus4 + 4, &currSlice->frame_num, "frame_num");
if (currSlice->active_sps->frame_mbs_only_flag) { //!< user in_slice info
p_Vid->structure = FRAME;
currSlice->field_pic_flag = 0;
currSlice->bottom_field_flag = 0;
} else {
READ_ONEBIT(p_bitctx, &currSlice->field_pic_flag, "field_pic_flag");
if (currSlice->field_pic_flag) {
READ_ONEBIT(p_bitctx, &currSlice->bottom_field_flag, "field_pic_flag");
p_Vid->structure = currSlice->bottom_field_flag ? BOTTOM_FIELD : TOP_FIELD;
} else {
p_Vid->structure = FRAME;
currSlice->bottom_field_flag = 0;
}
}
currSlice->structure = p_Vid->structure;
currSlice->mb_aff_frame_flag = (currSlice->active_sps->mb_adaptive_frame_field_flag && (currSlice->field_pic_flag == 0));
if (currSlice->idr_flag) {
READ_UE(p_bitctx, &currSlice->idr_pic_id, "idr_pic_id");
} else if (currSlice->svc_extension_flag == 0 && currSlice->mvcExt.non_idr_flag == 0) {
READ_UE(p_bitctx, &currSlice->idr_pic_id, "idr_pic_id");
}
poc_used_bits = p_bitctx->used_bits; //!< init poc used bits
if (currSlice->active_sps->pic_order_cnt_type == 0) {
READ_BITS(p_bitctx, currSlice->active_sps->log2_max_pic_order_cnt_lsb_minus4 + 4, &currSlice->pic_order_cnt_lsb, "pic_order_cnt_lsb");
if (currSlice->p_Vid->active_pps->bottom_field_pic_order_in_frame_present_flag == 1
&& !currSlice->field_pic_flag) {
READ_SE(p_bitctx, &currSlice->delta_pic_order_cnt_bottom, "delta_pic_order_cnt_bottom");
} else {
currSlice->delta_pic_order_cnt_bottom = 0;
}
}
if (currSlice->active_sps->pic_order_cnt_type == 1) {
if (!currSlice->active_sps->delta_pic_order_always_zero_flag) {
READ_SE(p_bitctx, &currSlice->delta_pic_order_cnt[0], "delta_pic_order_cnt[0]");
if (currSlice->p_Vid->active_pps->bottom_field_pic_order_in_frame_present_flag == 1 && !currSlice->field_pic_flag) {
READ_SE(p_bitctx, &currSlice->delta_pic_order_cnt[1], "delta_pic_order_cnt[1]");
}
else {
currSlice->delta_pic_order_cnt[1] = 0; //!< set to zero if not in stream
}
}
else {
currSlice->delta_pic_order_cnt[0] = 0;
currSlice->delta_pic_order_cnt[1] = 0;
}
}
currSlice->poc_used_bitlen = p_bitctx->used_bits - poc_used_bits; //!< calculate poc used bit length
if (currSlice->p_Vid->active_pps->bottom_field_pic_order_in_frame_present_flag == 1 && !currSlice->field_pic_flag) {
READ_SE(p_bitctx, &currSlice->delta_pic_order_cnt[1], "delta_pic_order_cnt[1]");
} else {
currSlice->delta_pic_order_cnt[1] = 0; //!< set to zero if not in stream
}
} else {
currSlice->delta_pic_order_cnt[0] = 0;
currSlice->delta_pic_order_cnt[1] = 0;
}
}
currSlice->poc_used_bitlen = p_bitctx->used_bits - poc_used_bits; //!< calculate poc used bit length
//!< redundant_pic_cnt is missing here
ASSERT(currSlice->p_Vid->active_pps->redundant_pic_cnt_present_flag == 0); // add by dw, high 4:2:2 profile not support
if (currSlice->p_Vid->active_pps->redundant_pic_cnt_present_flag) {
@@ -517,10 +511,10 @@ 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);
}
H264D_DBG(H264D_DBG_PPS_SPS, "[SLICE_HEAD] type=%d, layer_id=%d,sps_id=%d, pps_id=%d, struct=%d, frame_num=%d",
currSlice->slice_type, currSlice->layer_id, currSlice->active_sps->seq_parameter_set_id,
currSlice->active_pps->pic_parameter_set_id, currSlice->structure, currSlice->frame_num);
}
H264D_DBG(H264D_DBG_PPS_SPS, "[SLICE_HEAD] type=%d, layer_id=%d,sps_id=%d, pps_id=%d, struct=%d, frame_num=%d",
currSlice->slice_type, currSlice->layer_id, currSlice->active_sps->seq_parameter_set_id,
currSlice->active_pps->pic_parameter_set_id, currSlice->structure, currSlice->frame_num);
}
FunctionOut(logctx->parr[RUN_PARSE]);

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

@@ -27,7 +27,7 @@
#ifdef __cplusplus
extern "C" {
#endif
#endif
MPP_RET process_slice(H264_SLICE_t *currSlice);

4
mpp/codec/dec/m2v/m2vd_parser.c
View File

@@ -973,7 +973,7 @@ MPP_RET m2vd_decode_head(M2VDParserContext *ctx)
MPP_RET m2vd_alloc_frame(M2VDParserContext *ctx)
{
RK_U32 pts = (RK_U32)(ctx->pts/1000);
RK_U32 pts = (RK_U32)(ctx->pts / 1000);
if (ctx->resetFlag && ctx->pic_head.picture_coding_type != M2VD_CODING_TYPE_I) {
mpp_log("[m2v]: resetFlag[%d] && picture_coding_type[%d] != I_TYPE", ctx->resetFlag, ctx->pic_head.picture_coding_type);
return MPP_NOK;
@@ -1006,7 +1006,7 @@ MPP_RET m2vd_alloc_frame(M2VDParserContext *ctx)
ctx->frame_period = tmp_frame_period;
}
}
ctx->Group_start_Time =pts - (ctx->pic_head.temporal_reference * ctx->frame_period / 256);
ctx->Group_start_Time = pts - (ctx->pic_head.temporal_reference * ctx->frame_period / 256);
if (ctx->Group_start_Time < 0)
ctx->Group_start_Time = 0;
ctx->PreGetFrameTime = pts;

32
mpp/codec/dec/vp9/vp9d_parser.c
View File

@@ -1652,25 +1652,25 @@ RK_S32 vp9_parser_frame(Vp9CodecContext *ctx, HalDecTask *task)
}
vp9d_dbg(VP9D_DBG_REF, "s->refreshrefmask = %d s->frames[CUR_FRAME] = %d", s->refreshrefmask, s->frames[CUR_FRAME].slot_index);
for (i = 0; i < 3; i++) {
if (s->refs[s->refidx[i]].ref != NULL) {
vp9d_dbg(VP9D_DBG_REF, "ref buf select %d", s->refs[s->refidx[i]].slot_index);
}
if (s->refs[s->refidx[i]].ref != NULL) {
vp9d_dbg(VP9D_DBG_REF, "ref buf select %d", s->refs[s->refidx[i]].slot_index);
}
}
// ref frame setup
for (i = 0; i < 8; i++) {
vp9d_dbg(VP9D_DBG_REF, "s->refreshrefmask = 0x%x", s->refreshrefmask);
res = 0;
if (s->refreshrefmask & (1 << i)) {
if (s->refs[i].ref)
vp9_unref_frame(s, &s->refs[i]);
vp9d_dbg(VP9D_DBG_REF, "update ref index in %d", i);
res = vp9_ref_frame(ctx, &s->refs[i], &s->frames[CUR_FRAME]);
}
vp9d_dbg(VP9D_DBG_REF, "s->refreshrefmask = 0x%x", s->refreshrefmask);
res = 0;
if (s->refreshrefmask & (1 << i)) {
if (s->refs[i].ref)
vp9_unref_frame(s, &s->refs[i]);
vp9d_dbg(VP9D_DBG_REF, "update ref index in %d", i);
res = vp9_ref_frame(ctx, &s->refs[i], &s->frames[CUR_FRAME]);
}
if (s->refs[i].ref)
vp9d_dbg(VP9D_DBG_REF, "s->refs[%d] = %d", i, s->refs[i].slot_index);
if (res < 0)
return 0;
if (s->refs[i].ref)
vp9d_dbg(VP9D_DBG_REF, "s->refs[%d] = %d", i, s->refs[i].slot_index);
if (res < 0)
return 0;
}
return 0;
}
@@ -1826,6 +1826,6 @@ void vp9_parser_update(Vp9CodecContext *ctx, void *count_info)
}
}
return;
}

20
mpp/codec/inc/avsd_api.h
View File

@@ -47,8 +47,8 @@ do {\
#define AVSD_DBG(level, fmt, ...)\
do {\
if (level & avsd_parse_debug)\
{ mpp_log(fmt, ## __VA_ARGS__); }\
if (level & avsd_parse_debug)\
{ mpp_log(fmt, ## __VA_ARGS__); }\
} while (0)
#ifdef INP_CHECK
@@ -58,9 +58,9 @@ do {\
#define INP_CHECK(ret, val, ...)\
do{\
if ((val)) {\
ret = MPP_ERR_INIT; \
AVSD_DBG(AVSD_DBG_WARNNING, "input empty(%d).\n", __LINE__); \
goto __RETURN; \
ret = MPP_ERR_INIT; \
AVSD_DBG(AVSD_DBG_WARNNING, "input empty(%d).\n", __LINE__); \
goto __RETURN; \
}} while (0)
#ifdef MEM_CHECK
#undef MEM_CHECK
@@ -69,9 +69,9 @@ do{\
#define MEM_CHECK(ret, val, ...)\
do{\
if(!(val)) {\
ret = MPP_ERR_MALLOC;\
AVSD_DBG(AVSD_DBG_ERROR, "malloc buffer error(%d).\n", __LINE__); \
goto __FAILED; \
ret = MPP_ERR_MALLOC;\
AVSD_DBG(AVSD_DBG_ERROR, "malloc buffer error(%d).\n", __LINE__); \
goto __FAILED; \
}} while (0)
#ifdef FUN_CHECK
#undef FUN_CHECK
@@ -80,8 +80,8 @@ do{\
#define FUN_CHECK(val)\
do{\
if ((val) < 0) {\
AVSD_DBG(AVSD_DBG_WARNNING, "Function error(%d).\n", __LINE__); \
goto __FAILED; \
AVSD_DBG(AVSD_DBG_WARNNING, "Function error(%d).\n", __LINE__); \
goto __FAILED; \
}} while (0)

22
mpp/codec/mpp_dec.cpp
View File

@@ -185,7 +185,7 @@ static RK_U32 reset_dec_task(Mpp *mpp, DecTask *task)
mpp_buf_slot_reset(frame_slots, task_dec->output);
}
if(task->status.task_parsed_rdy){
if (task->status.task_parsed_rdy) {
mpp_log("task no send to hal que must clr current frame hal status");
mpp_buf_slot_clr_flag(frame_slots, task_dec->output, SLOT_HAL_OUTPUT);
for (RK_U32 i = 0; i < MPP_ARRAY_ELEMS(task_dec->refer); i++) {
@@ -316,14 +316,14 @@ static MPP_RET try_proc_dec_task(Mpp *mpp, DecTask *task)
*
*/
if (!task->status.curr_task_rdy) {
RK_S64 p_e, p_s,diff;
RK_S64 p_e, p_s, diff;
p_s = mpp_time();
parser_prepare(dec->parser, dec->mpp_pkt_in, task_dec);
p_e = mpp_time();
if(mpp_debug & MPP_TIMING){
diff = (p_e - p_s)/1000;
if(diff > 15){
mpp_log("waring mpp prepare stream consume %lld big than 15ms ",diff);
if (mpp_debug & MPP_TIMING) {
diff = (p_e - p_s) / 1000;
if (diff > 15) {
mpp_log("waring mpp prepare stream consume %lld big than 15ms ", diff);
}
}
if (0 == mpp_packet_get_length(dec->mpp_pkt_in)) {
@@ -619,7 +619,7 @@ void *mpp_dec_hal_thread(void *data)
HalDecTask *task_dec = &task_info.dec;
RK_S64 cur_deat = 0;
RK_U64 dec_no = 0, total_time = 0;
RK_S64 p_s,p_e;
RK_S64 p_s, p_e;
p_s = mpp_time();
while (MPP_THREAD_RUNNING == hal->get_status()) {
/*
@@ -879,10 +879,10 @@ MPP_RET mpp_dec_control(MppDec *dec, MpiCmd cmd, void *param)
mpp_slots_set_prop(dec->frame_slots, SLOTS_FRAME_INFO, frame);
mpp_frame_deinit(&frame);
} break;
case MPP_CODEC_GET_VPUMEM_USED_COUNT: {
RK_S32 *p = (RK_S32 *)param;
*p = mpp_buf_slot_get_used_size(dec->frame_slots);
} break;
case MPP_CODEC_GET_VPUMEM_USED_COUNT: {
RK_S32 *p = (RK_S32 *)param;
*p = mpp_buf_slot_get_used_size(dec->frame_slots);
} break;
default : {
} break;
}

16
mpp/hal/inc/hal_avsd_api.h
View File

@@ -38,8 +38,8 @@ extern RK_U32 avsd_hal_debug;
#define AVSD_HAL_DBG(level, fmt, ...)\
do {\
if (level & avsd_hal_debug)\
{ mpp_log(fmt, ## __VA_ARGS__); }\
if (level & avsd_hal_debug)\
{ mpp_log(fmt, ## __VA_ARGS__); }\
} while (0)
@@ -57,17 +57,17 @@ do {\
#define INP_CHECK(ret, val, ...)\
do{\
if ((val)) { \
ret = MPP_ERR_INIT; \
AVSD_HAL_DBG(AVSD_HAL_DBG_WARNNING, "input empty(%d).\n", __LINE__); \
goto __RETURN; \
ret = MPP_ERR_INIT; \
AVSD_HAL_DBG(AVSD_HAL_DBG_WARNNING, "input empty(%d).\n", __LINE__); \
goto __RETURN; \
}} while (0)
typedef struct avsd_hal_ctx_t {
MppBufSlots frame_slots;
MppBufSlots packet_slots;
IOInterruptCB init_cb;
MppBufSlots frame_slots;
MppBufSlots packet_slots;
IOInterruptCB init_cb;
} AvsdHalCtx_t;

4
mpp/hal/inc/hal_task.h
View File

@@ -85,8 +85,8 @@ typedef union HalDecTaskFlag_t {
struct {
RK_U32 eos : 1;
RK_U32 info_change : 1;
RK_U32 had_error : 1;
RK_U32 used_for_ref : 1;
RK_U32 had_error : 1;
RK_U32 used_for_ref : 1;
};
} HalDecTaskFlag;

74
mpp/hal/rkdec/avsd/hal_avsd_api.c
View File

@@ -37,17 +37,17 @@ RK_U32 avsd_hal_debug = 0;
static RK_U32 avsd_ver_align(RK_U32 val)
{
return MPP_ALIGN(val, 16);
return MPP_ALIGN(val, 16);
}
static RK_U32 avsd_hor_align(RK_U32 val)
{
return MPP_ALIGN(val, 16);
return MPP_ALIGN(val, 16);
}
static RK_U32 avsd_len_align(RK_U32 val)
{
return (2 * MPP_ALIGN(val, 16));
return (2 * MPP_ALIGN(val, 16));
}
/*!
***********************************************************************
@@ -59,27 +59,27 @@ static RK_U32 avsd_len_align(RK_U32 val)
MPP_RET hal_avsd_init(void *decoder, MppHalCfg *cfg)
{
MPP_RET ret = MPP_ERR_UNKNOW;
AvsdHalCtx_t *p_hal = NULL;
AvsdHalCtx_t *p_hal = NULL;
AVSD_HAL_TRACE("In.");
INP_CHECK(ret, NULL == decoder);
INP_CHECK(ret, NULL == decoder);
mpp_env_get_u32("avsd_debug", &avsd_hal_debug, 0);
mpp_env_get_u32("avsd_debug", &avsd_hal_debug, 0);
p_hal = (AvsdHalCtx_t *)decoder;
memset(p_hal, 0, sizeof(AvsdHalCtx_t));
p_hal = (AvsdHalCtx_t *)decoder;
memset(p_hal, 0, sizeof(AvsdHalCtx_t));
p_hal->frame_slots = cfg->frame_slots;
p_hal->packet_slots = cfg->packet_slots;
//!< callback function to parser module
p_hal->init_cb = cfg->hal_int_cb;
p_hal->frame_slots = cfg->frame_slots;
p_hal->packet_slots = cfg->packet_slots;
//!< callback function to parser module
p_hal->init_cb = cfg->hal_int_cb;
mpp_slots_set_prop(p_hal->frame_slots, SLOTS_HOR_ALIGN, avsd_hor_align);
mpp_slots_set_prop(p_hal->frame_slots, SLOTS_VER_ALIGN, avsd_ver_align);
mpp_slots_set_prop(p_hal->frame_slots, SLOTS_LEN_ALIGN, avsd_len_align);
mpp_slots_set_prop(p_hal->frame_slots, SLOTS_HOR_ALIGN, avsd_hor_align);
mpp_slots_set_prop(p_hal->frame_slots, SLOTS_VER_ALIGN, avsd_ver_align);
mpp_slots_set_prop(p_hal->frame_slots, SLOTS_LEN_ALIGN, avsd_len_align);
__RETURN:
AVSD_HAL_TRACE("Out.");
AVSD_HAL_TRACE("Out.");
(void)decoder;
(void)cfg;
return ret = MPP_OK;
@@ -97,7 +97,7 @@ MPP_RET hal_avsd_deinit(void *decoder)
AVSD_HAL_TRACE("In.");
AVSD_HAL_TRACE("Out.");
AVSD_HAL_TRACE("Out.");
(void)decoder;
return ret = MPP_OK;
}
@@ -110,24 +110,24 @@ MPP_RET hal_avsd_deinit(void *decoder)
//extern "C"
MPP_RET hal_avsd_gen_regs(void *decoder, HalTaskInfo *task)
{
MPP_RET ret = MPP_ERR_UNKNOW;
AvsdHalCtx_t *p_hal = NULL;
MPP_RET ret = MPP_ERR_UNKNOW;
AvsdHalCtx_t *p_hal = NULL;
AVSD_HAL_TRACE("In.");
INP_CHECK(ret, NULL == decoder);
INP_CHECK(ret, NULL == decoder);
p_hal = (AvsdHalCtx_t *)decoder;
p_hal = (AvsdHalCtx_t *)decoder;
if (p_hal->init_cb.callBack) {
p_hal->init_cb.callBack(p_hal->init_cb.opaque, task);
}
if (p_hal->init_cb.callBack) {
p_hal->init_cb.callBack(p_hal->init_cb.opaque, task);
}
__RETURN:
AVSD_HAL_TRACE("Out.");
AVSD_HAL_TRACE("Out.");
(void)decoder;
(void)decoder;
(void)task;
return ret = MPP_OK;
}
@@ -143,10 +143,10 @@ MPP_RET hal_avsd_start(void *decoder, HalTaskInfo *task)
MPP_RET ret = MPP_ERR_UNKNOW;
AVSD_HAL_TRACE("In.");
INP_CHECK(ret, NULL == decoder);
INP_CHECK(ret, NULL == decoder);
__RETURN:
AVSD_HAL_TRACE("Out.");
AVSD_HAL_TRACE("Out.");
(void)decoder;
(void)task;
return ret = MPP_OK;
@@ -161,19 +161,19 @@ __RETURN:
MPP_RET hal_avsd_wait(void *decoder, HalTaskInfo *task)
{
MPP_RET ret = MPP_ERR_UNKNOW;
//AvsdHalCtx_t *p_hal = NULL;
//AvsdHalCtx_t *p_hal = NULL;
AVSD_HAL_TRACE("In.");
AVSD_HAL_TRACE("In.");
INP_CHECK(ret, NULL == decoder);
//p_hal = (AvsdHalCtx_t *)decoder;
INP_CHECK(ret, NULL == decoder);
//p_hal = (AvsdHalCtx_t *)decoder;
//if (p_hal->init_cb.callBack) {
// p_hal->init_cb.callBack(p_hal->init_cb.opaque, task);
//}
//if (p_hal->init_cb.callBack) {
// p_hal->init_cb.callBack(p_hal->init_cb.opaque, task);
//}
__RETURN:
AVSD_HAL_TRACE("Out.");
AVSD_HAL_TRACE("Out.");
(void)decoder;
(void)task;
return ret = MPP_OK;

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

@@ -204,12 +204,12 @@ MPP_RET hal_h264d_init(void *hal, MppHalCfg *cfg)
p_hal->frame_slots = cfg->frame_slots;
p_hal->packet_slots = cfg->packet_slots;
//!< choose hard mode
#ifdef RKPLATFORM
{
RK_S32 value = (!!access("/dev/rkvdec", F_OK));
cfg->device_id = value ? HAL_VDPU : HAL_RKVDEC;
}
//!< choose hard mode
#ifdef RKPLATFORM
{
RK_S32 value = (!!access("/dev/rkvdec", F_OK));
cfg->device_id = value ? HAL_VDPU : HAL_RKVDEC;
}
#endif
switch (cfg->device_id) {
case HAL_RKVDEC:

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

@@ -45,8 +45,7 @@
#define FPGA_TEST 0
const enum
{
const enum {
H264ScalingList4x4Length = 16,
H264ScalingList8x8Length = 64,
} ScalingListLength;

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

@@ -322,9 +322,9 @@ MPP_RET rkv_h264d_gen_regs(void *hal, HalTaskInfo *task)
INP_CHECK(ret, NULL == p_hal);
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
if (task->dec.flags.had_error) {
goto __RETURN;
}
if (task->dec.flags.had_error) {
goto __RETURN;
}
rkv_prepare_spspps_packet(hal, &pkts->spspps);
rkv_prepare_framerps_packet(hal, &pkts->rps);
rkv_prepare_scanlist_packet(hal, &pkts->scanlist);
@@ -370,9 +370,9 @@ MPP_RET rkv_h264d_start(void *hal, HalTaskInfo *task)
INP_CHECK(ret, NULL == p_hal);
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
if (task->dec.flags.had_error) {
goto __RETURN;
}
if (task->dec.flags.had_error) {
goto __RETURN;
}
p_regs = (RK_U32 *)p_hal->regs;
p_regs[64] = 0;
@@ -391,13 +391,13 @@ MPP_RET rkv_h264d_start(void *hal, HalTaskInfo *task)
rkv_h264d_hal_dump(p_hal, H264D_DBG_GEN_REGS);
}
}
//!< current buffer slot fd
H264D_DBG(H264D_DBG_DECOUT_INFO, "[DECOUT_INFO] decout_fd=0x%02x", p_regs[7]);
//!< current buffer slot fd
H264D_DBG(H264D_DBG_DECOUT_INFO, "[DECOUT_INFO] decout_fd=0x%02x", p_regs[7]);
#ifdef RKPLATFORM
if (VPUClientSendReg(p_hal->vpu_socket, (RK_U32 *)p_regs, DEC_RKV_REGISTERS)) {
ret = MPP_ERR_VPUHW;
H264D_ERR("H264 RKV FlushRegs fail. \n");
}
if (VPUClientSendReg(p_hal->vpu_socket, (RK_U32 *)p_regs, DEC_RKV_REGISTERS)) {
ret = MPP_ERR_VPUHW;
H264D_ERR("H264 RKV FlushRegs fail. \n");
}
#endif
FunctionOut(p_hal->logctx.parr[RUN_HAL]);
(void)task;
@@ -421,22 +421,22 @@ MPP_RET rkv_h264d_wait(void *hal, HalTaskInfo *task)
FunctionIn(p_hal->logctx.parr[RUN_HAL]);
p_regs = (H264dRkvRegs_t *)p_hal->regs;
if (task->dec.flags.had_error) {
goto __SKIP_HARD;
}
if (task->dec.flags.had_error) {
goto __SKIP_HARD;
}
#ifdef RKPLATFORM
RK_S32 wait_ret = -1;
RK_S32 ret_len = 0, cur_deat = 0;
VPU_CMD_TYPE ret_cmd = VPU_CMD_BUTT;
RK_S64 p_s,p_e;
p_s = mpp_time();
wait_ret = VPUClientWaitResult(p_hal->vpu_socket, (RK_U32 *)p_hal->regs, DEC_RKV_REGISTERS, &ret_cmd, &ret_len);
p_e = mpp_time();
cur_deat = (p_e - p_s)/1000;
p_hal->total_time += cur_deat;
p_hal->iDecodedNum++;
(void)wait_ret;
#endif
RK_S32 wait_ret = -1;
RK_S32 ret_len = 0, cur_deat = 0;
VPU_CMD_TYPE ret_cmd = VPU_CMD_BUTT;
RK_S64 p_s, p_e;
p_s = mpp_time();
wait_ret = VPUClientWaitResult(p_hal->vpu_socket, (RK_U32 *)p_hal->regs, DEC_RKV_REGISTERS, &ret_cmd, &ret_len);
p_e = mpp_time();
cur_deat = (p_e - p_s) / 1000;
p_hal->total_time += cur_deat;
p_hal->iDecodedNum++;
(void)wait_ret;
#endif
//!< dump registers
{
H264dRkvErrDump_t *p_dump = (H264dRkvErrDump_t *)p_hal->dump;

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

@@ -617,7 +617,7 @@ MPP_RET vdpu_h264d_wait(void *hal, HalTaskInfo *task)
RK_S32 wait_ret = -1;
RK_S32 ret_len = 0, cur_deat = 0;
VPU_CMD_TYPE ret_cmd = VPU_CMD_BUTT;
RK_S64 p_s,p_e;
RK_S64 p_s, p_e;
p_s = mpp_time();
wait_ret = VPUClientWaitResult(p_hal->vpu_socket, p_drv->p_reg, DEC_X170_REGISTERS, &ret_cmd, &ret_len);
p_e = mpp_time();

42
mpp/hal/worker/libvpu/vpu.c
View File

@@ -53,27 +53,27 @@ int VPUClientInit(VPU_CLIENT_TYPE type)
int fd;
switch (type) {
case VPU_DEC_RKV: {
fd = open("/dev/rkvdec", O_RDWR);
type = VPU_DEC;
break;
}
case VPU_DEC_HEVC: {
fd = open("/dev/hevc_service", O_RDWR);
type = VPU_DEC;
break;
}
case VPU_DEC_PP:
case VPU_PP:
case VPU_DEC:
case VPU_ENC: {
fd = open("/dev/vpu_service", O_RDWR);
break;
}
default: {
fd = -1;
break;
}
case VPU_DEC_RKV: {
fd = open("/dev/rkvdec", O_RDWR);
type = VPU_DEC;
break;
}
case VPU_DEC_HEVC: {
fd = open("/dev/hevc_service", O_RDWR);
type = VPU_DEC;
break;
}
case VPU_DEC_PP:
case VPU_PP:
case VPU_DEC:
case VPU_ENC: {
fd = open("/dev/vpu_service", O_RDWR);
break;
}
default: {
fd = -1;
break;
}
}

6
mpp/legacy/vpu_api.cpp
View File

@@ -203,7 +203,8 @@ public:
VpulibDlsym()
: rkapi_hdl(NULL),
rkvpu_open_cxt(NULL),
rkvpu_close_cxt(NULL) {
rkvpu_close_cxt(NULL)
{
if (!!access("/dev/rkvdec", F_OK)) {
rkapi_hdl = dlopen("/system/lib/librk_on2.so", RTLD_LAZY);
}
@@ -219,7 +220,8 @@ public:
}
}
~VpulibDlsym() {
~VpulibDlsym()
{
if (rkapi_hdl) {
dlclose(rkapi_hdl);
mpp_log("dlclose vpu lib");

128
mpp/legacy/vpu_api_legacy.cpp
View File

@@ -41,11 +41,11 @@ VpuApi::VpuApi()
set_eos = 0;
vpu_api_debug = 0;
fp = NULL;
fp_buf = NULL;
fp_buf = NULL;
mpp_env_get_u32("vpu_api_debug", &vpu_api_debug, 0);
if (vpu_api_debug & VPU_API_DBG_DUMP_YUV) {
fp = fopen("/sdcard/rk_mpp_dump.yuv", "wb");
fp_buf = mpp_malloc(RK_U8, (MAX_WRITE_HEIGHT * MAX_WRITE_WIDTH * 2));
fp_buf = mpp_malloc(RK_U8, (MAX_WRITE_HEIGHT * MAX_WRITE_WIDTH * 2));
}
mpp_log_f("ok\n");
}
@@ -55,11 +55,11 @@ VpuApi::~VpuApi()
mpp_log_f("in\n");
if (fp) {
fclose(fp);
fp = NULL;
fp = NULL;
}
if (fp_buf) {
mpp_free(fp_buf);
fp_buf = NULL;
if (fp_buf) {
mpp_free(fp_buf);
fp_buf = NULL;
}
mpp_destroy(mpp_ctx);
mpp_log_f("ok\n");
@@ -85,10 +85,10 @@ RK_S32 VpuApi::init(VpuCodecContext *ctx, RK_U8 *extraData, RK_U32 extra_size)
return MPP_ERR_NULL_PTR;
}
ret = mpp_init(mpp_ctx, type, (MppCodingType)ctx->videoCoding);
if (ret) {
mpp_err_f(" init error. \n");
return ret;
}
if (ret) {
mpp_err_f(" init error. \n");
return ret;
}
VPU_GENERIC vpug;
vpug.CodecType = ctx->codecType;
vpug.ImgWidth = ctx->width;
@@ -206,53 +206,53 @@ RK_S32 VpuApi:: decode_getoutframe(DecoderOut_t *aDecOut)
vframe->vpumem.vir_addr = (RK_U32*)ptr;
frame_count++;
//!< Dump yuv
if (fp && !vframe->ErrorInfo) {
if ((vframe->FrameWidth >= 1920) || (vframe->FrameHeight >= 1080)) {
RK_U32 i = 0, j = 0, step = 0;
RK_U32 img_w = 0, img_h = 0;
RK_U8 *pdes = NULL, *psrc = NULL;
step = MPP_MAX(vframe->FrameWidth / MAX_WRITE_WIDTH, vframe->FrameHeight / MAX_WRITE_HEIGHT);
img_w = vframe->FrameWidth / step;
img_h = vframe->FrameHeight / step;
pdes = fp_buf;
psrc = (RK_U8 *)ptr;
for (i = 0; i < img_h; i++) {
for (j = 0; j < img_w; j++) {
pdes[j] = psrc[j * step];
}
pdes += img_w;
psrc += step * vframe->FrameWidth;
}
pdes = fp_buf + img_w * img_h;
psrc = (RK_U8 *)ptr + vframe->FrameWidth * vframe->FrameHeight;
for (i = 0; i < (img_h / 2); i++) {
for (j = 0; j < (img_w / 2); j++) {
pdes[2 * j + 0] = psrc[2 * j * step + 0];
pdes[2 * j + 1] = psrc[2 * j * step + 1];
}
pdes += img_w;
psrc += step * vframe->FrameWidth;
}
fwrite(fp_buf, 1, img_w * img_h * 3 / 2, fp);
if (vpu_api_debug & VPU_API_DBG_DUMP_LOG) {
mpp_log("[write_out_yuv] timeUs=%lld, FrameWidth=%d, FrameHeight=%d", aDecOut->timeUs, img_w, img_h);
}
} else {
fwrite(ptr, 1, vframe->FrameWidth * vframe->FrameHeight * 3 / 2, fp);
if (vpu_api_debug & VPU_API_DBG_DUMP_LOG) {
mpp_log("[write_out_yuv] timeUs=%lld, FrameWidth=%d, FrameHeight=%d", aDecOut->timeUs, vframe->FrameWidth, vframe->FrameHeight);
}
}
if (fp && !vframe->ErrorInfo) {
if ((vframe->FrameWidth >= 1920) || (vframe->FrameHeight >= 1080)) {
RK_U32 i = 0, j = 0, step = 0;
RK_U32 img_w = 0, img_h = 0;
RK_U8 *pdes = NULL, *psrc = NULL;
step = MPP_MAX(vframe->FrameWidth / MAX_WRITE_WIDTH, vframe->FrameHeight / MAX_WRITE_HEIGHT);
img_w = vframe->FrameWidth / step;
img_h = vframe->FrameHeight / step;
pdes = fp_buf;
psrc = (RK_U8 *)ptr;
for (i = 0; i < img_h; i++) {
for (j = 0; j < img_w; j++) {
pdes[j] = psrc[j * step];
}
pdes += img_w;
psrc += step * vframe->FrameWidth;
}
pdes = fp_buf + img_w * img_h;
psrc = (RK_U8 *)ptr + vframe->FrameWidth * vframe->FrameHeight;
for (i = 0; i < (img_h / 2); i++) {
for (j = 0; j < (img_w / 2); j++) {
pdes[2 * j + 0] = psrc[2 * j * step + 0];
pdes[2 * j + 1] = psrc[2 * j * step + 1];
}
pdes += img_w;
psrc += step * vframe->FrameWidth;
}
fwrite(fp_buf, 1, img_w * img_h * 3 / 2, fp);
if (vpu_api_debug & VPU_API_DBG_DUMP_LOG) {
mpp_log("[write_out_yuv] timeUs=%lld, FrameWidth=%d, FrameHeight=%d", aDecOut->timeUs, img_w, img_h);
}
} else {
fwrite(ptr, 1, vframe->FrameWidth * vframe->FrameHeight * 3 / 2, fp);
if (vpu_api_debug & VPU_API_DBG_DUMP_LOG) {
mpp_log("[write_out_yuv] timeUs=%lld, FrameWidth=%d, FrameHeight=%d", aDecOut->timeUs, vframe->FrameWidth, vframe->FrameHeight);
}
}
fflush(fp);
}
vframe->vpumem.phy_addr = fd;
vframe->vpumem.size = vframe->FrameWidth * vframe->FrameHeight * 3 / 2;
vframe->vpumem.offset = (RK_U32*)buf;
}
if (vpu_api_debug & VPU_API_DBG_OUTPUT) {
mpp_log("get one frame timeUs %lld, fd=0x%x, poc=%d, errinfo=%d, discard=%d, eos=%d, verr=%d", aDecOut->timeUs, fd,
mpp_frame_get_poc(mframe), mpp_frame_get_errinfo(mframe), mpp_frame_get_discard(mframe), mpp_frame_get_eos(mframe), vframe->ErrorInfo);
}
if (vpu_api_debug & VPU_API_DBG_OUTPUT) {
mpp_log("get one frame timeUs %lld, fd=0x%x, poc=%d, errinfo=%d, discard=%d, eos=%d, verr=%d", aDecOut->timeUs, fd,
mpp_frame_get_poc(mframe), mpp_frame_get_errinfo(mframe), mpp_frame_get_discard(mframe), mpp_frame_get_eos(mframe), vframe->ErrorInfo);
}
if (mpp_frame_get_eos(mframe)) {
set_eos = 1;
if (buf == NULL) {
@@ -267,7 +267,7 @@ RK_S32 VpuApi:: decode_getoutframe(DecoderOut_t *aDecOut)
* The we have to clear the buffer pointer in mframe then release mframe.
*/
mpp_frame_set_buffer(mframe, NULL);
mpp_frame_deinit(&mframe);
mpp_frame_deinit(&mframe);
} else {
aDecOut->size = 0;
}
@@ -344,15 +344,15 @@ RK_S32 VpuApi::control(VpuCodecContext *ctx, VPU_API_CMD cmd, void *param)
}
case VPU_API_SET_DEFAULT_WIDTH_HEIGH: {
VPU_GENERIC *p = (VPU_GENERIC *)param;
RK_U32 ImgWidth = p->ImgWidth;
RK_U32 ImgWidth = p->ImgWidth;
mpicmd = MPP_CODEC_SET_FRAME_INFO;
/**hightest of p->ImgWidth bit show current dec bitdepth
* 0 - 8bit
* 1 - 10bit
**/
if(((p->ImgWidth&0x80000000)>>31)){
p->ImgWidth = (p->ImgWidth&0x7FFFFFFF);
ImgWidth = (p->ImgWidth *10)>>3;
/**hightest of p->ImgWidth bit show current dec bitdepth
* 0 - 8bit
* 1 - 10bit
**/
if (((p->ImgWidth & 0x80000000) >> 31)) {
p->ImgWidth = (p->ImgWidth & 0x7FFFFFFF);
ImgWidth = (p->ImgWidth * 10) >> 3;
}
if (ctx->videoCoding == OMX_RK_VIDEO_CodingHEVC) {
p->ImgHorStride = hevc_ver_align_256_odd(ImgWidth);
@@ -375,10 +375,10 @@ RK_S32 VpuApi::control(VpuCodecContext *ctx, VPU_API_CMD cmd, void *param)
mpicmd = MPP_DEC_GET_STREAM_COUNT;
break;
}
case VPU_API_GET_VPUMEM_USED_COUNT:{
mpicmd = MPP_CODEC_GET_VPUMEM_USED_COUNT;
break;
}
case VPU_API_GET_VPUMEM_USED_COUNT: {
mpicmd = MPP_CODEC_GET_VPUMEM_USED_COUNT;
break;
}
default: {
break;
}

2
mpp/legacy/vpu_api_legacy.h
View File

@@ -50,7 +50,7 @@ private:
RK_U32 set_eos;
RK_U32 vpu_api_debug;
FILE *fp;
RK_U8 *fp_buf;
RK_U8 *fp_buf;
};
#endif /*_VPU_API_H_*/

16
mpp/mpp.cpp
View File

@@ -188,7 +188,7 @@ MPP_RET Mpp::put_packet(MppPacket packet)
if (mPackets->list_size() < 4 || eos) {
MppPacket pkt;
if (MPP_OK != mpp_packet_copy_init(&pkt, packet))
return MPP_NOK;
return MPP_NOK;
mPackets->add_at_tail(&pkt, sizeof(pkt));
mPacketPutCount++;
mThreadCodec->signal();
@@ -297,13 +297,13 @@ MPP_RET Mpp::control(MpiCmd cmd, MppParam param)
*((RK_S32 *)param) = mPackets->list_size();
break;
}
case MPP_CODEC_GET_VPUMEM_USED_COUNT: {
AutoMutex autoLock(mPackets->mutex());
if (mType == MPP_CTX_DEC) {
mpp_dec_control(mDec, cmd, param);
}
break;
}
case MPP_CODEC_GET_VPUMEM_USED_COUNT: {
AutoMutex autoLock(mPackets->mutex());
if (mType == MPP_CTX_DEC) {
mpp_dec_control(mDec, cmd, param);
}
break;
}
default : {

649
mpp/test/avsd_test.c
View File

@@ -52,424 +52,419 @@
#define AVSD_TEST_LOG(level, fmt, ...)\
do {\
if (level & rkv_avsd_test_debug)\
{ mpp_log(fmt, ## __VA_ARGS__); }\
{ mpp_log(fmt, ## __VA_ARGS__); }\
} while (0)
typedef struct ParserImpl_t {
ParserCfg cfg;
ParserCfg cfg;
const ParserApi *api;
void *ctx;
const ParserApi *api;
void *ctx;
} ParserImpl;
static RK_U32 rkv_avsd_test_debug = 0;
typedef struct inp_par_t {
FILE *fp_in;
FILE *fp_out;
FILE *fp_read;
RK_U8 *pbuf;
RK_U32 bufsize;
RK_U32 len;
FILE *fp_in;
FILE *fp_out;
FILE *fp_read;
RK_U8 *pbuf;
RK_U32 bufsize;
RK_U32 len;
RK_U32 output_dec_pic; // output_dec_pic
RK_U32 output_dec_pic; // output_dec_pic
RK_U32 dec_num; // to be decoded
RK_U32 dec_no; // current decoded number
RK_U32 dec_num; // to be decoded
RK_U32 dec_no; // current decoded number
RK_U32 is_eof;
RK_U32 is_eof;
} InputParams;
typedef struct avsd_test_ctx_t {
MppDec m_api;
InputParams m_in;
HalTaskInfo m_task;
MppDec m_api;
InputParams m_in;
HalTaskInfo m_task;
MppBuffer m_dec_pkt_buf;
MppBuffer m_dec_pic_buf;
MppBufferGroup mFrameGroup;
MppBufferGroup mStreamGroup;
MppBuffer m_dec_pkt_buf;
MppBuffer m_dec_pic_buf;
MppBufferGroup mFrameGroup;
MppBufferGroup mStreamGroup;
} AvsdTestCtx_t;
static MPP_RET decoder_deinit(AvsdTestCtx_t *pctx)
{
MppDec *pApi = &pctx->m_api;
MppDec *pApi = &pctx->m_api;
if (pApi->parser) {
parser_deinit(pApi->parser);
pApi->parser = NULL;
}
if (pApi->hal) {
mpp_hal_deinit(pApi->hal);
pApi->hal = NULL;
}
if (pApi->frame_slots) {
mpp_buf_slot_deinit(pApi->frame_slots);
pApi->frame_slots = NULL;
}
if (pApi->packet_slots) {
mpp_buf_slot_deinit(pApi->packet_slots);
pApi->packet_slots = NULL;
}
if (pctx->m_dec_pkt_buf) {
mpp_buffer_put(pctx->m_dec_pkt_buf);
pctx->m_dec_pkt_buf = NULL;
}
if (pctx->m_dec_pic_buf) {
mpp_buffer_put(pctx->m_dec_pic_buf);
pctx->m_dec_pic_buf = NULL;
}
if (pctx->mFrameGroup) {
mpp_err("mFrameGroup deInit");
mpp_buffer_group_put(pctx->mFrameGroup);
pctx->mFrameGroup = NULL;
}
if (pctx->mStreamGroup) {
mpp_err("mStreamGroup deInit");
mpp_buffer_group_put(pctx->mStreamGroup);
pctx->mStreamGroup = NULL;
}
if (pApi->parser) {
parser_deinit(pApi->parser);
pApi->parser = NULL;
}
if (pApi->hal) {
mpp_hal_deinit(pApi->hal);
pApi->hal = NULL;
}
if (pApi->frame_slots) {
mpp_buf_slot_deinit(pApi->frame_slots);
pApi->frame_slots = NULL;
}
if (pApi->packet_slots) {
mpp_buf_slot_deinit(pApi->packet_slots);
pApi->packet_slots = NULL;
}
if (pctx->m_dec_pkt_buf) {
mpp_buffer_put(pctx->m_dec_pkt_buf);
pctx->m_dec_pkt_buf = NULL;
}
if (pctx->m_dec_pic_buf) {
mpp_buffer_put(pctx->m_dec_pic_buf);
pctx->m_dec_pic_buf = NULL;
}
if (pctx->mFrameGroup) {
mpp_err("mFrameGroup deInit");
mpp_buffer_group_put(pctx->mFrameGroup);
pctx->mFrameGroup = NULL;
}
if (pctx->mStreamGroup) {
mpp_err("mStreamGroup deInit");
mpp_buffer_group_put(pctx->mStreamGroup);
pctx->mStreamGroup = NULL;
}
return MPP_OK;
return MPP_OK;
}
static MPP_RET decoder_init(AvsdTestCtx_t *pctx)
{
MPP_RET ret = MPP_ERR_UNKNOW;
ParserCfg parser_cfg;
MppHalCfg hal_cfg;
MppDec *pApi = &pctx->m_api;
MPP_RET ret = MPP_ERR_UNKNOW;
ParserCfg parser_cfg;
MppHalCfg hal_cfg;
MppDec *pApi = &pctx->m_api;
if (pctx->mFrameGroup == NULL) {
ret = mpp_buffer_group_get_internal(&pctx->mFrameGroup, MPP_BUFFER_TYPE_NORMAL);
if (MPP_OK != ret) {
mpp_err("avsd mpp_buffer_group_get failed\n");
goto __FAILED;
}
}
if (pctx->mStreamGroup == NULL) {
ret = mpp_buffer_group_get_internal(&pctx->mStreamGroup, MPP_BUFFER_TYPE_NORMAL);
if (MPP_OK != ret) {
mpp_err("avsd mpp_buffer_group_get failed\n");
goto __FAILED;
}
}
// codec
pApi->coding = MPP_VIDEO_CodingAVS;
// malloc slot
FUN_CHECK(ret = mpp_buf_slot_init(&pApi->frame_slots));
MEM_CHECK(ret, pApi->frame_slots);
ret = mpp_buf_slot_init(&pApi->packet_slots);
MEM_CHECK(ret, pApi->packet_slots);
mpp_buf_slot_setup(pApi->packet_slots, 2);
// init parser part
memset(&parser_cfg, 0, sizeof(parser_cfg));
parser_cfg.coding = pApi->coding;
parser_cfg.frame_slots = pApi->frame_slots;
parser_cfg.packet_slots = pApi->packet_slots;
parser_cfg.task_count = 2;
FUN_CHECK(ret = parser_init(&pApi->parser, &parser_cfg));
if (pctx->mFrameGroup == NULL) {
ret = mpp_buffer_group_get_internal(&pctx->mFrameGroup, MPP_BUFFER_TYPE_NORMAL);
if (MPP_OK != ret) {
mpp_err("avsd mpp_buffer_group_get failed\n");
goto __FAILED;
}
}
if (pctx->mStreamGroup == NULL) {
ret = mpp_buffer_group_get_internal(&pctx->mStreamGroup, MPP_BUFFER_TYPE_NORMAL);
if (MPP_OK != ret) {
mpp_err("avsd mpp_buffer_group_get failed\n");
goto __FAILED;
}
}
// codec
pApi->coding = MPP_VIDEO_CodingAVS;
// malloc slot
FUN_CHECK(ret = mpp_buf_slot_init(&pApi->frame_slots));
MEM_CHECK(ret, pApi->frame_slots);
ret = mpp_buf_slot_init(&pApi->packet_slots);
MEM_CHECK(ret, pApi->packet_slots);
mpp_buf_slot_setup(pApi->packet_slots, 2);
// init parser part
memset(&parser_cfg, 0, sizeof(parser_cfg));
parser_cfg.coding = pApi->coding;
parser_cfg.frame_slots = pApi->frame_slots;
parser_cfg.packet_slots = pApi->packet_slots;
parser_cfg.task_count = 2;
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 = pApi->coding;
hal_cfg.work_mode = HAL_MODE_LIBVPU;
hal_cfg.device_id = HAL_RKVDEC;
hal_cfg.frame_slots = pApi->frame_slots;
hal_cfg.packet_slots = pApi->packet_slots;
hal_cfg.task_count = parser_cfg.task_count;
hal_cfg.hal_int_cb.opaque = ((ParserImpl *)(pApi->parser))->ctx;
hal_cfg.hal_int_cb.callBack = api_avsd_parser.callback;
//api_avsd_parser.callback(hal_cfg.hal_int_cb.opaque, NULL);
FUN_CHECK(ret = mpp_hal_init(&pApi->hal, &hal_cfg));
pApi->tasks = hal_cfg.tasks;
// init hal part
memset(&hal_cfg, 0, sizeof(hal_cfg));
hal_cfg.type = MPP_CTX_DEC;
hal_cfg.coding = pApi->coding;
hal_cfg.work_mode = HAL_MODE_LIBVPU;
hal_cfg.device_id = HAL_RKVDEC;
hal_cfg.frame_slots = pApi->frame_slots;
hal_cfg.packet_slots = pApi->packet_slots;
hal_cfg.task_count = parser_cfg.task_count;
hal_cfg.hal_int_cb.opaque = ((ParserImpl *)(pApi->parser))->ctx;
hal_cfg.hal_int_cb.callBack = api_avsd_parser.callback;
//api_avsd_parser.callback(hal_cfg.hal_int_cb.opaque, NULL);
FUN_CHECK(ret = mpp_hal_init(&pApi->hal, &hal_cfg));
pApi->tasks = hal_cfg.tasks;
return MPP_OK;
return MPP_OK;
__FAILED:
decoder_deinit(pctx);
decoder_deinit(pctx);
return ret;
return ret;
}
static MPP_RET avsd_flush_frames(MppDec *pApi, FILE *fp)
{
RK_S32 slot_idx = 0;
MppFrame out_frame = NULL;
RK_S32 slot_idx = 0;
MppFrame out_frame = NULL;
while (MPP_OK == mpp_buf_slot_dequeue(pApi->frame_slots, &slot_idx, QUEUE_DISPLAY)) {
mpp_buf_slot_get_prop(pApi->frame_slots, slot_idx, SLOT_FRAME, &out_frame);
if (out_frame) {
RK_U32 stride_w, stride_h;
void *ptr = NULL;
MppBuffer framebuf;
stride_w = mpp_frame_get_hor_stride(out_frame);
stride_h = mpp_frame_get_ver_stride(out_frame);
framebuf = mpp_frame_get_buffer(out_frame);
ptr = mpp_buffer_get_ptr(framebuf);
if (fp) {
fwrite(ptr, 1, stride_w * stride_h * 3 / 2, fp);
fflush(fp);
}
mpp_frame_deinit(&out_frame);
out_frame = NULL;
}
mpp_buf_slot_clr_flag(pApi->frame_slots, slot_idx, SLOT_QUEUE_USE);
}
while (MPP_OK == mpp_buf_slot_dequeue(pApi->frame_slots, &slot_idx, QUEUE_DISPLAY)) {
mpp_buf_slot_get_prop(pApi->frame_slots, slot_idx, SLOT_FRAME, &out_frame);
if (out_frame) {
RK_U32 stride_w, stride_h;
void *ptr = NULL;
MppBuffer framebuf;
stride_w = mpp_frame_get_hor_stride(out_frame);
stride_h = mpp_frame_get_ver_stride(out_frame);
framebuf = mpp_frame_get_buffer(out_frame);
ptr = mpp_buffer_get_ptr(framebuf);
if (fp) {
fwrite(ptr, 1, stride_w * stride_h * 3 / 2, fp);
fflush(fp);
}
mpp_frame_deinit(&out_frame);
out_frame = NULL;
}
mpp_buf_slot_clr_flag(pApi->frame_slots, slot_idx, SLOT_QUEUE_USE);
}
return MPP_OK;
return MPP_OK;
}
static MPP_RET avsd_input_deinit(InputParams *inp)
{
MPP_RET ret = MPP_ERR_UNKNOW;
MPP_RET ret = MPP_ERR_UNKNOW;
MPP_FREE(inp->pbuf);
MPP_FCLOSE(inp->fp_in);
MPP_FCLOSE(inp->fp_out);
MPP_FCLOSE(inp->fp_read);
return ret = MPP_OK;
MPP_FREE(inp->pbuf);
MPP_FCLOSE(inp->fp_in);
MPP_FCLOSE(inp->fp_out);
MPP_FCLOSE(inp->fp_read);
return ret = MPP_OK;
}
static MPP_RET avsd_input_init(InputParams *inp, RK_S32 ac, char *av[])
{
MPP_RET ret = MPP_ERR_UNKNOW;
char infile_name[128]; //!< Telenor AVS input
char outfile_name[128]; //!< Decoded YUV 4:2:0 output
RK_S32 CLcount = 1;
MPP_RET ret = MPP_ERR_UNKNOW;
char infile_name[128]; //!< Telenor AVS input
char outfile_name[128]; //!< Decoded YUV 4:2:0 output
RK_S32 CLcount = 1;
inp->output_dec_pic = 0;
while (CLcount < ac) {
if (!strncmp(av[CLcount], "-h", 2)) {
mpp_log("Options:");
mpp_log(" -h : prints help message.");
mpp_log(" -i :[file] Set input AVS+ bitstream file.");
mpp_log(" -o :[file] Set output YUV file.");
mpp_log(" -n :[number] Set decoded frames.");
CLcount += 1;
}
else if (!strncmp(av[CLcount], "-i", 2)) {
strncpy(infile_name, av[CLcount + 1], strlen((const char*)av[CLcount + 1]) + 1);
CLcount += 2;
}
else if (!strncmp(av[CLcount], "-n", 2)) {
if (!sscanf(av[CLcount + 1], "%d", &inp->dec_num)) {
goto __FAILED;
}
CLcount += 2;
}
else if (!strncmp(av[CLcount], "-o", 2)) {
if (rkv_avsd_test_debug & AVSD_TEST_DUMPYUV) {
inp->output_dec_pic = 1;
strncpy(outfile_name, av[CLcount + 1], strlen((const char*)av[CLcount + 1]) + 1);
}
CLcount += 2;
}
else {
mpp_err("error, %s cannot explain command! \n", av[CLcount]);
goto __FAILED;
}
}
if ((inp->fp_in = fopen(infile_name, "rb")) == 0) {
mpp_err("error, open file %s ", infile_name);
goto __FAILED;
}
if (inp->output_dec_pic) {
if ((inp->fp_out = fopen(outfile_name, "wb")) == 0) {
mpp_err("error, open file %s ", outfile_name);
goto __FAILED;
}
}
if ((inp->fp_read = fopen("F:/avs_log/avs_read.txt", "wb")) == 0) {
mpp_log("error, open file %s", "F:/avs_log/avs_read.txt");
goto __FAILED;
}
inp->output_dec_pic = 0;
while (CLcount < ac) {
if (!strncmp(av[CLcount], "-h", 2)) {
mpp_log("Options:");
mpp_log(" -h : prints help message.");
mpp_log(" -i :[file] Set input AVS+ bitstream file.");
mpp_log(" -o :[file] Set output YUV file.");
mpp_log(" -n :[number] Set decoded frames.");
CLcount += 1;
} else if (!strncmp(av[CLcount], "-i", 2)) {
strncpy(infile_name, av[CLcount + 1], strlen((const char*)av[CLcount + 1]) + 1);
CLcount += 2;
} else if (!strncmp(av[CLcount], "-n", 2)) {
if (!sscanf(av[CLcount + 1], "%d", &inp->dec_num)) {
goto __FAILED;
}
CLcount += 2;
} else if (!strncmp(av[CLcount], "-o", 2)) {
if (rkv_avsd_test_debug & AVSD_TEST_DUMPYUV) {
inp->output_dec_pic = 1;
strncpy(outfile_name, av[CLcount + 1], strlen((const char*)av[CLcount + 1]) + 1);
}
CLcount += 2;
} else {
mpp_err("error, %s cannot explain command! \n", av[CLcount]);
goto __FAILED;
}
}
if ((inp->fp_in = fopen(infile_name, "rb")) == 0) {
mpp_err("error, open file %s ", infile_name);
goto __FAILED;
}
if (inp->output_dec_pic) {
if ((inp->fp_out = fopen(outfile_name, "wb")) == 0) {
mpp_err("error, open file %s ", outfile_name);
goto __FAILED;
}
}
if ((inp->fp_read = fopen("F:/avs_log/avs_read.txt", "wb")) == 0) {
mpp_log("error, open file %s", "F:/avs_log/avs_read.txt");
goto __FAILED;
}
//!< malloc read buffer
inp->bufsize = 30*1024;
MEM_CHECK(ret, inp->pbuf = mpp_malloc(RK_U8, inp->bufsize));
//!< malloc read buffer
inp->bufsize = 30 * 1024;
MEM_CHECK(ret, inp->pbuf = mpp_malloc(RK_U8, inp->bufsize));
AVSD_TEST_LOG(AVSD_TEST_TRACE, "------------------------------------------------------------");
AVSD_TEST_LOG(AVSD_TEST_TRACE, "Input AVS+ bitstream : %s", infile_name);
AVSD_TEST_LOG(AVSD_TEST_TRACE, "Output decoded YUV : %s", outfile_name);
AVSD_TEST_LOG(AVSD_TEST_TRACE, "------------------------------------------------------------");
AVSD_TEST_LOG(AVSD_TEST_TRACE, "Frame TR QP SnrY SnrU SnrV Time(ms) FRM/FLD");
AVSD_TEST_LOG(AVSD_TEST_TRACE, "------------------------------------------------------------");
AVSD_TEST_LOG(AVSD_TEST_TRACE, "Input AVS+ bitstream : %s", infile_name);
AVSD_TEST_LOG(AVSD_TEST_TRACE, "Output decoded YUV : %s", outfile_name);
AVSD_TEST_LOG(AVSD_TEST_TRACE, "------------------------------------------------------------");
AVSD_TEST_LOG(AVSD_TEST_TRACE, "Frame TR QP SnrY SnrU SnrV Time(ms) FRM/FLD");
return MPP_OK;
return MPP_OK;
__FAILED:
avsd_deinit(inp);
avsd_deinit(inp);
return ret;
return ret;
}
static MPP_RET avsd_read_data(InputParams *inp)
{
MPP_RET ret = MPP_ERR_UNKNOW;
MPP_RET ret = MPP_ERR_UNKNOW;
inp->len = (RK_U32)fread(inp->pbuf, sizeof(RK_U8), inp->bufsize, inp->fp_in);
inp->is_eof = feof(inp->fp_in);
inp->len = (RK_U32)fread(inp->pbuf, sizeof(RK_U8), inp->bufsize, inp->fp_in);
inp->is_eof = feof(inp->fp_in);
if (inp->fp_read){
fwrite(inp->pbuf, inp->len, 1, inp->fp_read);
fflush(inp->fp_read);
}
if (inp->fp_read) {
fwrite(inp->pbuf, inp->len, 1, inp->fp_read);
fflush(inp->fp_read);
}
return ret = MPP_OK;
return ret = MPP_OK;
}
static MPP_RET decoder_single_test(AvsdTestCtx_t *pctx)
{
MppPacket pkt = NULL;
RK_U32 end_of_flag = 0;
MPP_RET ret = MPP_ERR_UNKNOW;
MppPacket pkt = NULL;
RK_U32 end_of_flag = 0;
MPP_RET ret = MPP_ERR_UNKNOW;
MppDec *pApi = &pctx->m_api;
InputParams *inp = &pctx->m_in;
HalTaskInfo *task = &pctx->m_task;
//!< initial task
memset(task, 0, sizeof(HalTaskInfo));
memset(task->dec.refer, -1, sizeof(task->dec.refer));
task->dec.input = -1;
do {
//!< get one packet
if (pkt == NULL) {
if (inp->is_eof ||
(inp->dec_num && (inp->dec_no >= inp->dec_num))) {
mpp_packet_init(&pkt, NULL, 0);
mpp_packet_set_eos(pkt);
}
else {
FUN_CHECK(ret = avsd_read_data(inp));
mpp_packet_init(&pkt, inp->pbuf, inp->len);
}
}
//!< prepare
FUN_CHECK(ret = parser_prepare(pApi->parser, pkt, &task->dec));
MppDec *pApi = &pctx->m_api;
InputParams *inp = &pctx->m_in;
HalTaskInfo *task = &pctx->m_task;
//!< initial task
memset(task, 0, sizeof(HalTaskInfo));
memset(task->dec.refer, -1, sizeof(task->dec.refer));
task->dec.input = -1;
do {
//!< get one packet
if (pkt == NULL) {
if (inp->is_eof ||
(inp->dec_num && (inp->dec_no >= inp->dec_num))) {
mpp_packet_init(&pkt, NULL, 0);
mpp_packet_set_eos(pkt);
} else {
FUN_CHECK(ret = avsd_read_data(inp));
mpp_packet_init(&pkt, inp->pbuf, inp->len);
}
}
//!< prepare
FUN_CHECK(ret = parser_prepare(pApi->parser, pkt, &task->dec));
//!< parse
if (task->dec.valid) {
MppBufferImpl *buf = NULL;
//!< parse
if (task->dec.valid) {
MppBufferImpl *buf = NULL;
task->dec.valid = 0;
if (task->dec.input < 0) {
mpp_buf_slot_get_unused(pApi->packet_slots, &task->dec.input);
}
mpp_buf_slot_get_prop(pApi->packet_slots, task->dec.input, SLOT_BUFFER, &pctx->m_dec_pkt_buf);
if (NULL == pctx->m_dec_pkt_buf) {
size_t stream_size = mpp_packet_get_size(task->dec.input_packet);
mpp_buffer_get(pctx->mStreamGroup, &pctx->m_dec_pkt_buf, stream_size);
if (pctx->m_dec_pkt_buf)
mpp_buf_slot_set_prop(pApi->packet_slots, task->dec.input, SLOT_BUFFER, pctx->m_dec_pkt_buf);
}
buf = (MppBufferImpl *)pctx->m_dec_pkt_buf;
memcpy(buf->info.ptr, mpp_packet_get_data(task->dec.input_packet), mpp_packet_get_length(task->dec.input_packet));
task->dec.valid = 0;
if (task->dec.input < 0) {
mpp_buf_slot_get_unused(pApi->packet_slots, &task->dec.input);
}
mpp_buf_slot_get_prop(pApi->packet_slots, task->dec.input, SLOT_BUFFER, &pctx->m_dec_pkt_buf);
if (NULL == pctx->m_dec_pkt_buf) {
size_t stream_size = mpp_packet_get_size(task->dec.input_packet);
mpp_buffer_get(pctx->mStreamGroup, &pctx->m_dec_pkt_buf, stream_size);
if (pctx->m_dec_pkt_buf)
mpp_buf_slot_set_prop(pApi->packet_slots, task->dec.input, SLOT_BUFFER, pctx->m_dec_pkt_buf);
}
buf = (MppBufferImpl *)pctx->m_dec_pkt_buf;
memcpy(buf->info.ptr, mpp_packet_get_data(task->dec.input_packet), mpp_packet_get_length(task->dec.input_packet));
mpp_buf_slot_set_flag(pApi->packet_slots, task->dec.input, SLOT_CODEC_READY);
mpp_buf_slot_set_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT);
FUN_CHECK(ret = parser_parse(pApi->parser, &task->dec));
mpp_buf_slot_set_flag(pApi->packet_slots, task->dec.input, SLOT_CODEC_READY);
mpp_buf_slot_set_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT);
FUN_CHECK(ret = parser_parse(pApi->parser, &task->dec));
AVSD_TEST_LOG(AVSD_TEST_TRACE, "[AVSD_TEST] ---- decoder, read_one_frame Frame_no = %d", inp->dec_no);
inp->dec_no++;
}
//!< deinit packet
if (mpp_packet_get_length(pkt) == 0) {
if (mpp_packet_get_eos(pkt)) {
if (task->dec.valid) {
mpp_buf_slot_clr_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT);
mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.output, SLOT_HAL_OUTPUT);
task->dec.valid = 0;
}
end_of_flag = 1; //!< end of stream
}
mpp_packet_deinit(&pkt);
pkt = NULL;
}
//!< run hal module
if (task->dec.valid) {
if (mpp_buf_slot_is_changed(pApi->frame_slots)) {
mpp_buf_slot_ready(pApi->frame_slots);
}
mpp_buf_slot_get_prop(pApi->frame_slots, task->dec.output, SLOT_BUFFER, &pctx->m_dec_pic_buf);
if (NULL == pctx->m_dec_pic_buf) {
RK_U32 size = 1920 * 1088 * 3 / 2;// (RK_U32)mpp_buf_slot_get_size(pApi->frame_slots);
mpp_buffer_get(pctx->mFrameGroup, &pctx->m_dec_pic_buf, size);
if (pctx->m_dec_pic_buf)
mpp_buf_slot_set_prop(pApi->frame_slots, task->dec.output, SLOT_BUFFER, pctx->m_dec_pic_buf);
}
FUN_CHECK(ret = mpp_hal_reg_gen(pApi->hal, task));
AVSD_TEST_LOG(AVSD_TEST_TRACE, "[AVSD_TEST] ---- decoder, read_one_frame Frame_no = %d", inp->dec_no);
inp->dec_no++;
}
//!< deinit packet
if (mpp_packet_get_length(pkt) == 0) {
if (mpp_packet_get_eos(pkt)) {
if (task->dec.valid) {
mpp_buf_slot_clr_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT);
mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.output, SLOT_HAL_OUTPUT);
task->dec.valid = 0;
}
end_of_flag = 1; //!< end of stream
}
mpp_packet_deinit(&pkt);
pkt = NULL;
}
//!< run hal module
if (task->dec.valid) {
if (mpp_buf_slot_is_changed(pApi->frame_slots)) {
mpp_buf_slot_ready(pApi->frame_slots);
}
mpp_buf_slot_get_prop(pApi->frame_slots, task->dec.output, SLOT_BUFFER, &pctx->m_dec_pic_buf);
if (NULL == pctx->m_dec_pic_buf) {
RK_U32 size = 1920 * 1088 * 3 / 2;// (RK_U32)mpp_buf_slot_get_size(pApi->frame_slots);
mpp_buffer_get(pctx->mFrameGroup, &pctx->m_dec_pic_buf, size);
if (pctx->m_dec_pic_buf)
mpp_buf_slot_set_prop(pApi->frame_slots, task->dec.output, SLOT_BUFFER, pctx->m_dec_pic_buf);
}
FUN_CHECK(ret = mpp_hal_reg_gen(pApi->hal, task));
FUN_CHECK(ret = mpp_hal_hw_start(pApi->hal, task));
FUN_CHECK(ret = mpp_hal_hw_wait(pApi->hal, task));
if (pctx->m_dec_pkt_buf) {
mpp_buffer_put(pctx->m_dec_pkt_buf);
pctx->m_dec_pkt_buf = NULL;
}
mpp_buf_slot_clr_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT);
mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.output, SLOT_HAL_OUTPUT);
//!< write frame out
avsd_flush_frames(pApi, inp->fp_out);
//!< clear refrece flag
{
RK_U32 i = 0;
for (i = 0; i < MPP_ARRAY_ELEMS(task->dec.refer); i++) {
if (task->dec.refer[i] >= 0) {
mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.refer[i], SLOT_HAL_INPUT);
}
}
}
//!< reset task
memset(task, 0, sizeof(HalTaskInfo));
memset(task->dec.refer, -1, sizeof(task->dec.refer));
task->dec.input = -1;
FUN_CHECK(ret = mpp_hal_hw_start(pApi->hal, task));
FUN_CHECK(ret = mpp_hal_hw_wait(pApi->hal, task));
if (pctx->m_dec_pkt_buf) {
mpp_buffer_put(pctx->m_dec_pkt_buf);
pctx->m_dec_pkt_buf = NULL;
}
mpp_buf_slot_clr_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT);
mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.output, SLOT_HAL_OUTPUT);
//!< write frame out
avsd_flush_frames(pApi, inp->fp_out);
//!< clear refrece flag
{
RK_U32 i = 0;
for (i = 0; i < MPP_ARRAY_ELEMS(task->dec.refer); i++) {
if (task->dec.refer[i] >= 0) {
mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.refer[i], SLOT_HAL_INPUT);
}
}
}
//!< reset task
memset(task, 0, sizeof(HalTaskInfo));
memset(task->dec.refer, -1, sizeof(task->dec.refer));
task->dec.input = -1;
}
} while (!end_of_flag);
}
} while (!end_of_flag);
//!< flush dpb and send to display
FUN_CHECK(ret = mpp_dec_flush(pApi));
//!< flush dpb and send to display
FUN_CHECK(ret = mpp_dec_flush(pApi));
ret = MPP_OK;
ret = MPP_OK;
__FAILED:
return ret;
return ret;
}
int main(int argc, char **argv)
{
MPP_RET ret = MPP_ERR_UNKNOW;
AvsdTestCtx_t m_decoder;
AvsdTestCtx_t *p_dec = &m_decoder;
MPP_RET ret = MPP_ERR_UNKNOW;
AvsdTestCtx_t m_decoder;
AvsdTestCtx_t *p_dec = &m_decoder;
#if defined(_MSC_VER)
mpp_env_set_u32("rkv_avsd_test_debug", 0xFF);
mpp_env_set_u32("rkv_avsd_test_debug", 0xFF);
#endif
mpp_env_get_u32("rkv_avsd_test_debug", &rkv_avsd_test_debug, 0x0F);
memset(p_dec, 0, sizeof(AvsdTestCtx_t));
// read file
FUN_CHECK(ret = avsd_input_init(&p_dec->m_in, argc, argv));
// init
decoder_init(p_dec);
// decode
ret = decoder_single_test(p_dec);
if (ret != MPP_OK) {
AVSD_TEST_LOG(AVSD_TEST_TRACE, "[AVSD_TEST] Single-thread test error.");
goto __FAILED;
}
mpp_env_get_u32("rkv_avsd_test_debug", &rkv_avsd_test_debug, 0x0F);
memset(p_dec, 0, sizeof(AvsdTestCtx_t));
// read file
FUN_CHECK(ret = avsd_input_init(&p_dec->m_in, argc, argv));
// init
decoder_init(p_dec);
// decode
ret = decoder_single_test(p_dec);
if (ret != MPP_OK) {
AVSD_TEST_LOG(AVSD_TEST_TRACE, "[AVSD_TEST] Single-thread test error.");
goto __FAILED;
}
ret = MPP_OK;
ret = MPP_OK;
__FAILED:
decoder_deinit(p_dec);
avsd_input_deinit(&p_dec->m_in);
decoder_deinit(p_dec);
avsd_input_deinit(&p_dec->m_in);
AVSD_TEST_LOG(AVSD_TEST_TRACE, "[AVSD_TEST] decoder_deinit over.");
AVSD_TEST_LOG(AVSD_TEST_TRACE, "[AVSD_TEST] decoder_deinit over.");
return ret;
return ret;
}

2
mpp/test/h264d_test.c
View File

@@ -303,7 +303,7 @@ static MPP_RET decoder_single_test(H264dTestCtx_t *pctx)
FUN_CHECK(ret = mpp_hal_hw_wait(pApi->hal, task));
if (pctx->m_dec_pkt_buf) {
mpp_buffer_put(pctx->m_dec_pkt_buf);
pctx->m_dec_pkt_buf = NULL;
pctx->m_dec_pkt_buf = NULL;
}
mpp_buf_slot_clr_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT);
mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.output, SLOT_HAL_OUTPUT);

8
osal/allocator/allocator_drm.c
View File

@@ -75,8 +75,8 @@ static int drm_alloc(int fd, size_t len, size_t align, unsigned int heap_mask,
if (ret < 0)
return ret;
*handle = dmcb.handle;
(void)heap_mask;
(void)flags;
(void)heap_mask;
(void)flags;
return ret;
}
@@ -103,7 +103,7 @@ static int drm_handle_to_fd(int fd, RK_U32 handle, int *map_fd, RK_U32 flags)
mpp_err("map ioctl returned negative fd\n");
return -EINVAL;
}
(void)flags;
(void)flags;
return ret;
}
@@ -141,7 +141,7 @@ static int drm_map(int fd, RK_U32 handle, size_t length, int prot,
mpp_err("mmap failed: %s\n", strerror(errno));
return -errno;
}
(void)offset;
(void)offset;
return ret;
}

12
osal/inc/mpp_thread.h
View File

@@ -207,22 +207,26 @@ public:
void start();
void stop();
void lock(MppThreadSignal id = THREAD_WORK) {
void lock(MppThreadSignal id = THREAD_WORK)
{
mpp_assert(id < THREAD_SIGNAL_BUTT);
mMutexCond[id].lock();
}
void unlock(MppThreadSignal id = THREAD_WORK) {
void unlock(MppThreadSignal id = THREAD_WORK)
{
mpp_assert(id < THREAD_SIGNAL_BUTT);
mMutexCond[id].unlock();
}
void wait(MppThreadSignal id = THREAD_WORK) {
void wait(MppThreadSignal id = THREAD_WORK)
{
mpp_assert(id < THREAD_SIGNAL_BUTT);
mMutexCond[id].wait();
}
void signal(MppThreadSignal id = THREAD_WORK) {
void signal(MppThreadSignal id = THREAD_WORK)
{
mpp_assert(id < THREAD_SIGNAL_BUTT);
mMutexCond[id].signal();
}

2
osal/linux/os_allocator.c
View File

@@ -136,7 +136,7 @@ MPP_RET os_allocator_get(os_allocator *api, MppBufferType type)
mpp_err("os_allocator_get Linux MPP_BUFFER_TYPE_V4L2 do not implement yet\n");
*api = allocator_v4l2;
} break;
case MPP_BUFFER_TYPE_DRM : {
case MPP_BUFFER_TYPE_DRM : {
*api = allocator_drm;
} break;
default : {

6
osal/mpp_mem.cpp
View File

@@ -189,7 +189,7 @@ void mpp_show_mem_status()
pthread_mutex_lock(&mem_list_lock);
list_for_each_entry_safe(pos, n, &mem_list, struct mem_node, list) {
mpp_log("unfree memory %p size %d tag %s index %llu",
pos->ptr, pos->size, pos->tag, pos->index);
pos->ptr, pos->size, pos->tag, pos->index);
}
pthread_mutex_unlock(&mem_list_lock);
}
@@ -282,14 +282,14 @@ MPP_RET mpp_mem_squash_snapshot(MppMemSnapshot hnd0, MppMemSnapshot hnd1)
if (!found_match) {
mpp_log_f("snapshot0 %p found mismatch memory %p size %d tag %s index %llu",
p0, pos0->ptr, pos0->size, pos0->tag, pos0->index);
p0, pos0->ptr, pos0->size, pos0->tag, pos0->index);
}
}
/* handle 1 search */
list_for_each_entry_safe(pos1, n1, &p1->list, struct mem_node, list) {
mpp_log_f("snapshot1 %p found mismatch memory %p size %d tag %s index %llu",
p1, pos1->ptr, pos1->size, pos1->tag, pos1->index);
p1, pos1->ptr, pos1->size, pos1->tag, pos1->index);
}
pthread_mutex_unlock(&mem_list_lock);

13
osal/mpp_thread.cpp
View File

@@ -95,16 +95,16 @@ void MppThread::stop()
const DWORD MS_VC_EXCEPTION = 0x406D1388;
#pragma pack(push,8)
typedef struct tagTHREADNAME_INFO
{
typedef struct tagTHREADNAME_INFO {
DWORD dwType; // Must be 0x1000.
LPCSTR szName; // Pointer to name (in user addr space).
DWORD dwThreadID; // Thread ID (-1=caller thread).
DWORD dwFlags; // Reserved for future use, must be zero.
} THREADNAME_INFO;
} THREADNAME_INFO;
#pragma pack(pop)
void SetThreadName(DWORD dwThreadID, const char* threadName) {
void SetThreadName(DWORD dwThreadID, const char* threadName)
{
THREADNAME_INFO info;
info.dwType = 0x1000;
info.szName = threadName;
@@ -112,10 +112,9 @@ void SetThreadName(DWORD dwThreadID, const char* threadName) {
info.dwFlags = 0;
#pragma warning(push)
#pragma warning(disable: 6320 6322)
__try{
__try {
RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR), (ULONG_PTR*)&info);
}
__except (EXCEPTION_EXECUTE_HANDLER){
} __except (EXCEPTION_EXECUTE_HANDLER) {
}
#pragma warning(pop)
}