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

[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_NORMAL,
MPP_BUFFER_TYPE_ION, MPP_BUFFER_TYPE_ION,
MPP_BUFFER_TYPE_V4L2, MPP_BUFFER_TYPE_V4L2,
MPP_BUFFER_TYPE_DRM, MPP_BUFFER_TYPE_DRM,
MPP_BUFFER_TYPE_BUTT, MPP_BUFFER_TYPE_BUTT,
} MppBufferType; } MppBufferType;

2
inc/rk_mpi.h
View File

@@ -73,7 +73,7 @@ typedef enum {
MPP_CODEC_SET_INFO_CHANGE_READY, MPP_CODEC_SET_INFO_CHANGE_READY,
MPP_CODEC_SET_FRAME_INFO, MPP_CODEC_SET_FRAME_INFO,
MPP_CODEC_GET_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_CMD_BASE = 0x40000,
MPP_DEC_SET_EXT_BUF_GROUP, /* IMPORTANT: set external buffer group to mpp decoder */ 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_SET_INFO_CHANGE,
VPU_API_USE_FAST_MODE, VPU_API_USE_FAST_MODE,
VPU_API_DEC_GET_STREAM_COUNT, VPU_API_DEC_GET_STREAM_COUNT,
VPU_API_GET_VPUMEM_USED_COUNT, VPU_API_GET_VPUMEM_USED_COUNT,
} VPU_API_CMD; } VPU_API_CMD;
typedef struct { 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, ...)\ #define READ_ONEBIT(bitctx, out, ...)\
do {\ do {\
RK_S32 _out; \ RK_S32 _out; \
bitctx->ret = mpp_read_bits(bitctx, 1, &_out); \ bitctx->ret = mpp_read_bits(bitctx, 1, &_out); \
BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \ BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \
if (!bitctx->ret) { *out = _out; }\ if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR; }\ else { goto __BITREAD_ERR; }\
} while (0) } while (0)
#define READ_BITS(bitctx, num_bits, out, ...)\ #define READ_BITS(bitctx, num_bits, out, ...)\
do {\ do {\
RK_S32 _out;\ RK_S32 _out;\
bitctx->ret = mpp_read_bits(bitctx, num_bits, &_out);\ bitctx->ret = mpp_read_bits(bitctx, num_bits, &_out);\
BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \ BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \
if (!bitctx->ret) { *out = _out; }\ if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR;}\ else { goto __BITREAD_ERR;}\
} while (0) } while (0)
#define READ_BITS_LONG(bitctx, num_bits, out, ...)\ #define READ_BITS_LONG(bitctx, num_bits, out, ...)\
do {\ do {\
RK_U32 _out; \ RK_U32 _out; \
bitctx->ret = mpp_read_longbits(bitctx, num_bits, &_out); \ bitctx->ret = mpp_read_longbits(bitctx, num_bits, &_out); \
BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \ BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \
if (!bitctx->ret) { *out = _out; }\ if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR; }\ else { goto __BITREAD_ERR; }\
} while (0) } while (0)
#define SHOW_BITS(bitctx, num_bits, out)\ #define SHOW_BITS(bitctx, num_bits, out)\
do {\ do {\
RK_S32 _out; \ RK_S32 _out; \
bitctx->ret = mpp_show_bits(bitctx, num_bits, &_out); \ bitctx->ret = mpp_show_bits(bitctx, num_bits, &_out); \
if (!bitctx->ret) { *out = _out; }\ if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR; }\ else { goto __BITREAD_ERR; }\
} while (0) } while (0)
#define SHOW_BITS_LONG(bitctx, num_bits, out)\ #define SHOW_BITS_LONG(bitctx, num_bits, out)\
do {\ do {\
RK_U32 _out; \ RK_U32 _out; \
bitctx->ret = mpp_show_longbits(bitctx, num_bits, &_out); \ bitctx->ret = mpp_show_longbits(bitctx, num_bits, &_out); \
if (!bitctx->ret) { *out = _out; }\ if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR; }\ else { goto __BITREAD_ERR; }\
} while (0) } while (0)
#define SKIP_BITS(bitctx, num_bits)\ #define SKIP_BITS(bitctx, num_bits)\
do {\ do {\
bitctx->ret = mpp_skip_bits(bitctx, num_bits);\ bitctx->ret = mpp_skip_bits(bitctx, num_bits);\
BitReadLog(bitctx, "%48s %d bits", "skip", num_bits);\ BitReadLog(bitctx, "%48s %d bits", "skip", num_bits);\
if (bitctx->ret) { goto __BITREAD_ERR; }\ if (bitctx->ret) { goto __BITREAD_ERR; }\
} while (0) } while (0)
#define SKIP_BITS_LONG(bitctx, num_bits)\ #define SKIP_BITS_LONG(bitctx, num_bits)\
do {\ do {\
bitctx->ret = mpp_skip_longbits(bitctx, num_bits); \ bitctx->ret = mpp_skip_longbits(bitctx, num_bits); \
BitReadLog(bitctx, "%48s %d bits", "skip", num_bits); \ BitReadLog(bitctx, "%48s %d bits", "skip", num_bits); \
if (bitctx->ret) { goto __BITREAD_ERR; }\ if (bitctx->ret) { goto __BITREAD_ERR; }\
} while (0) } while (0)
#define READ_UE(bitctx, out, ...)\ #define READ_UE(bitctx, out, ...)\
do {\ do {\
RK_U32 _out;\ RK_U32 _out;\
bitctx->ret = mpp_read_ue(bitctx, &_out);\ bitctx->ret = mpp_read_ue(bitctx, &_out);\
BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out);\ BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out);\
if (!bitctx->ret) { *out = _out; }\ if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR;}\ else { goto __BITREAD_ERR;}\
} while (0) } while (0)
#define READ_SE(bitctx, out, ...)\ #define READ_SE(bitctx, out, ...)\
do {\ do {\
RK_S32 _out;\ RK_S32 _out;\
bitctx->ret = mpp_read_se(bitctx, &_out);\ bitctx->ret = mpp_read_se(bitctx, &_out);\
BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out);\ BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out);\
if (!bitctx->ret) { *out = _out; }\ if (!bitctx->ret) { *out = _out; }\
else { goto __BITREAD_ERR;}\ else { goto __BITREAD_ERR;}\
} while (0) } while (0)
#define CHECK_RANGE(bitctx, val, _min, _max)\ #define CHECK_RANGE(bitctx, val, _min, _max)\
do {\ do {\
if ((val) < (_min) || (val) > (_max)) {\ if ((val) < (_min) || (val) > (_max)) {\
mpp_log("%d[%d,%d]", val, _min, _max);\ mpp_log("%d[%d,%d]", val, _min, _max);\
bitctx->ret = MPP_ERR_VALUE;\ bitctx->ret = MPP_ERR_VALUE;\
goto __BITREAD_ERR;\ goto __BITREAD_ERR;\
}\ }\
} while (0) } while (0)
#define CHECK_ERROR(bitctx, val)\ #define CHECK_ERROR(bitctx, val)\
do {\ do {\
if (!(val)) {\ if (!(val)) {\
mpp_log("value false");\ mpp_log("value false");\
bitctx->ret = MPP_ERR_VALUE;\ bitctx->ret = MPP_ERR_VALUE;\
goto __BITREAD_ERR;\ goto __BITREAD_ERR;\
}\ }\
} while (0) } while (0)
typedef struct bitread_ctx_t { 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) RK_S32 mpp_buf_slot_get_used_size(MppBufSlots slots)
{ {
if (NULL == slots) { if (NULL == slots) {
mpp_err_f("found NULL input\n"); mpp_err_f("found NULL input\n");
return 0; return 0;
} }
MppBufSlotsImpl *impl = (MppBufSlotsImpl *)slots; MppBufSlotsImpl *impl = (MppBufSlotsImpl *)slots;
AutoMutex auto_lock(impl->lock); AutoMutex auto_lock(impl->lock);
RK_S32 i; RK_S32 i;
RK_S32 used_size = 0; RK_S32 used_size = 0;
MppBufSlotEntry *slot = impl->slots; MppBufSlotEntry *slot = impl->slots;
for (i = 0; i < impl->buf_count; i++, slot++) { for (i = 0; i < impl->buf_count; i++, slot++) {
if (slot->status.on_used) { if (slot->status.on_used) {
buf_slot_dbg(BUF_SLOT_DBG_BUF_UESD, "[BUF_USED] buf_fd=%08x", mpp_buffer_get_fd(slot->buffer)); buf_slot_dbg(BUF_SLOT_DBG_BUF_UESD, "[BUF_USED] buf_fd=%08x", mpp_buffer_get_fd(slot->buffer));
used_size++; used_size++;
} }
} }
return used_size; return used_size;
} }
MPP_RET mpp_buf_slot_get_unused(MppBufSlots slots, RK_S32 *index) 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", "normal",
"ion", "ion",
"v4l2", "v4l2",
"drm", "drm",
}; };
static const char *ops2str[BUF_OPS_BUTT] = { static const char *ops2str[BUF_OPS_BUTT] = {
"grp create ", "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->buffer_count++;
group->count_unused++; 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: RET:
MPP_BUF_FUNCTION_LEAVE(); MPP_BUF_FUNCTION_LEAVE();
return ret; return ret;
@@ -526,7 +526,7 @@ RK_U32 MppBufferService::get_group_id()
{ {
// avoid group_id reuse // avoid group_id reuse
RK_U32 id = group_id++; RK_U32 id = group_id++;
while (get_group_by_id(group_id)){ while (get_group_by_id(group_id)) {
group_id++; group_id++;
} }
group_count++; group_count++;
@@ -534,7 +534,7 @@ RK_U32 MppBufferService::get_group_id()
} }
MppBufferGroupImpl *MppBufferService::get_group(const char *tag, const char *caller, MppBufferGroupImpl *MppBufferService::get_group(const char *tag, const char *caller,
MppBufferMode mode, MppBufferType type) MppBufferMode mode, MppBufferType type)
{ {
MppBufferGroupImpl *p = mpp_calloc(MppBufferGroupImpl, 1); MppBufferGroupImpl *p = mpp_calloc(MppBufferGroupImpl, 1);
if (NULL == p) { if (NULL == p) {
@@ -631,7 +631,7 @@ void MppBufferService::destroy_group(MppBufferGroupImpl *group)
mpp_assert(group->count_unused == 0); mpp_assert(group->count_unused == 0);
if (group->count_unused || group->count_used) { if (group->count_unused || group->count_used) {
mpp_err("mpp_buffer_group_deinit mismatch counter used %4d unused %4d found\n", 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_unused = 0;
group->count_used = 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 #else
MPP_RET avsd_deinit(void *decoder) MPP_RET avsd_deinit(void *decoder)
{ {
(void)decoder; (void)decoder;
return MPP_OK; return MPP_OK;
} }
MPP_RET avsd_init(void *decoder, ParserCfg *init) MPP_RET avsd_init(void *decoder, ParserCfg *init)
{ {
(void)decoder; (void)decoder;
(void)init; (void)init;
return MPP_OK; return MPP_OK;
} }
MPP_RET avsd_prepare(void *decoder, MppPacket pkt, HalDecTask *task) MPP_RET avsd_prepare(void *decoder, MppPacket pkt, HalDecTask *task)
{ {
(void)decoder; (void)decoder;
(void)pkt; (void)pkt;
(void)task; (void)task;
return MPP_OK; return MPP_OK;
} }
MPP_RET avsd_parse(void *decoder, HalDecTask *task) MPP_RET avsd_parse(void *decoder, HalDecTask *task)
{ {
(void)decoder; (void)decoder;
(void)task; (void)task;
return MPP_OK; return MPP_OK;
} }
MPP_RET avsd_reset(void *decoder) MPP_RET avsd_reset(void *decoder)
{ {
(void)decoder; (void)decoder;
return MPP_OK; return MPP_OK;
} }
MPP_RET avsd_flush(void *decoder) MPP_RET avsd_flush(void *decoder)
{ {
(void)decoder; (void)decoder;
return MPP_OK; return MPP_OK;
} }
MPP_RET avsd_control(void *decoder, RK_S32 cmd_type, void *param) MPP_RET avsd_control(void *decoder, RK_S32 cmd_type, void *param)
{ {
(void)decoder; (void)decoder;
(void)cmd_type; (void)cmd_type;
(void)param; (void)param;
return MPP_OK; return MPP_OK;
} }
MPP_RET avsd_callback(void *decoder, void *info) MPP_RET avsd_callback(void *decoder, void *info)
{ {
(void)decoder; (void)decoder;
(void)info; (void)info;
return MPP_OK; return MPP_OK;
} }
#endif #endif
/*! /*!

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

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

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

@@ -50,93 +50,91 @@
//!< input parameter //!< input parameter
typedef struct avsd_input_ctx_t { typedef struct avsd_input_ctx_t {
FILE *fp_log; FILE *fp_log;
ParserCfg init; ParserCfg init;
MppPacket in_pkt; MppPacket in_pkt;
HalDecTask *in_task; HalDecTask *in_task;
RK_S64 in_pts; RK_S64 in_pts;
RK_S64 in_dts; RK_S64 in_dts;
RK_U8 has_get_eos; RK_U8 has_get_eos;
RK_U64 pkt_no; RK_U64 pkt_no;
struct avsd_cur_ctx_t *p_cur; struct avsd_cur_ctx_t *p_cur;
struct avsd_video_ctx_t *p_vid; struct avsd_video_ctx_t *p_vid;
struct avs_dec_ctx_t *p_dec; struct avs_dec_ctx_t *p_dec;
} AvsdInputCtx_t; } AvsdInputCtx_t;
//!< current stream //!< current stream
typedef struct avsd_cur_strm_t { typedef struct avsd_cur_strm_t {
RK_U8 *p_start; //!< store read nalu data RK_U8 *p_start; //!< store read nalu data
RK_U32 len; RK_U32 len;
RK_U32 prefixdata; RK_U32 prefixdata;
RK_U8 got_frame_flag; RK_U8 got_frame_flag;
RK_U8 got_nalu_flag; RK_U8 got_nalu_flag;
} AvsdCurStream_t; } AvsdCurStream_t;
typedef struct avsd_nalu_t typedef struct avsd_nalu_t {
{ RK_U8 header;
RK_U8 header; RK_U8 *pdata;
RK_U8 *pdata; RK_U32 size;
RK_U32 size; RK_U32 length;
RK_U32 length; RK_U8 start_pos;
RK_U8 start_pos; RK_U8 eof; //!< end of frame stream
RK_U8 eof; //!< end of frame stream } AvsdNalu_t;
}AvsdNalu_t;
//!< current parameters //!< current parameters
typedef struct avsd_cur_ctx_t { typedef struct avsd_cur_ctx_t {
struct avsd_cur_strm_t m_strm; struct avsd_cur_strm_t m_strm;
struct avsd_nalu_t *cur_nalu; //!< current nalu struct avsd_nalu_t *cur_nalu; //!< current nalu
struct avsd_input_ctx_t *p_inp; struct avsd_input_ctx_t *p_inp;
struct avsd_video_ctx_t *p_vid; struct avsd_video_ctx_t *p_vid;
struct avs_dec_ctx_t *p_dec; struct avs_dec_ctx_t *p_dec;
} AvsdCurCtx_t; } AvsdCurCtx_t;
//!< decoder parameters //!< decoder parameters
typedef struct avsd_video_ctx_t { typedef struct avsd_video_ctx_t {
struct img_par *img; struct img_par *img;
struct avsd_input_ctx_t *p_inp; struct avsd_input_ctx_t *p_inp;
struct avsd_cur_ctx_t *p_cur; struct avsd_cur_ctx_t *p_cur;
struct avs_dec_ctx_t *p_dec; struct avs_dec_ctx_t *p_dec;
}AvsdVideoCtx_t; } AvsdVideoCtx_t;
typedef struct avsd_bitstream_t { typedef struct avsd_bitstream_t {
RK_U8 *pbuf; RK_U8 *pbuf;
RK_U32 size; RK_U32 size;
RK_U32 len; RK_U32 len;
RK_U32 offset; //!< start from the offset byte RK_U32 offset; //!< start from the offset byte
}AvsdBitstream_t; } AvsdBitstream_t;
typedef struct avsd_outframe_t typedef struct avsd_outframe_t {
{ RK_S32 nWidth;
RK_S32 nWidth; RK_S32 nHeight;
RK_S32 nHeight; RK_U8 *data[4]; // Y U V data
RK_U8 *data[4]; // Y U V data RK_S32 stride[4]; // Y U V stride
RK_S32 stride[4]; // Y U V stride RK_S32 corp[2]; // crop_right crop_bottom
RK_S32 corp[2]; // crop_right crop_bottom RK_S32 hor_stride;
RK_S32 hor_stride; RK_S32 ver_stride;
RK_S32 ver_stride; RK_S32 nFrameType; // 0I 1P 2B
RK_S32 nFrameType; // 0I 1P 2B RK_S32 nBitrate;
RK_S32 nBitrate; RK_S32 nFrameCoded;
RK_S32 nFrameCoded; RK_S32 nTopFieldFirst;
RK_S32 nTopFieldFirst; RK_S32 nFrameIndex;
RK_S32 nFrameIndex;
} AvsdOutframe_t; } AvsdOutframe_t;
typedef struct avsd_memory_t { typedef struct avsd_memory_t {
struct avsd_bitstream_t bitstream; struct avsd_bitstream_t bitstream;
struct avsd_outframe_t outframe; struct avsd_outframe_t outframe;
} AvsdMemory_t; } AvsdMemory_t;
@@ -145,52 +143,52 @@ typedef struct avsd_memory_t {
//!< decoder parameters //!< decoder parameters
typedef struct avs_dec_ctx_t { typedef struct avs_dec_ctx_t {
MppBufSlots frame_slots; MppBufSlots frame_slots;
MppBufSlots packet_slots; MppBufSlots packet_slots;
MppPacket task_pkt; MppPacket task_pkt;
struct avsd_memory_t *mem; //!< resotre slice data to decoder struct avsd_memory_t *mem; //!< resotre slice data to decoder
struct avsd_bitstream_t *bitstream; struct avsd_bitstream_t *bitstream;
struct avsd_input_ctx_t *p_inp; struct avsd_input_ctx_t *p_inp;
struct avsd_cur_ctx_t *p_cur; struct avsd_cur_ctx_t *p_cur;
struct avsd_video_ctx_t *p_vid; struct avsd_video_ctx_t *p_vid;
//!< use in libavs.so //!< use in libavs.so
void *libdec; void *libdec;
struct avsd_outframe_t *outframe; struct avsd_outframe_t *outframe;
RK_U32 dec_no; RK_U32 dec_no;
RK_U32 prepare_no; RK_U32 prepare_no;
RK_U32 parse_no; RK_U32 parse_no;
RK_U32 decode_no; RK_U32 decode_no;
RK_U32 nvcopy_no; RK_U32 nvcopy_no;
RK_S64 prepare_time; RK_S64 prepare_time;
RK_S64 parse_time; RK_S64 parse_time;
RK_S64 read_slice_header_time; RK_S64 read_slice_header_time;
RK_S64 init_arideco_slice_time; RK_S64 init_arideco_slice_time;
RK_S64 start_marcoblock_time; RK_S64 start_marcoblock_time;
RK_S64 read_marcoblock_time; RK_S64 read_marcoblock_time;
RK_S64 get_block_time; RK_S64 get_block_time;
RK_S64 inter_pred_block_time; RK_S64 inter_pred_block_time;
RK_S64 intra_pred_block_time; RK_S64 intra_pred_block_time;
RK_S64 idc_dequaut_time; RK_S64 idc_dequaut_time;
RK_S64 decode_marcoblock_time; RK_S64 decode_marcoblock_time;
RK_S64 deblock_time; RK_S64 deblock_time;
RK_S64 decode_init_time; RK_S64 decode_init_time;
RK_S64 decode_data_time; RK_S64 decode_data_time;
RK_S64 decode_update_time; RK_S64 decode_update_time;
RK_S64 frame_post_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; } 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); INP_CHECK(ret, !p_Inp);
FunctionIn(p_Inp->p_Dec->logctx.parr[RUN_PARSE]); FunctionIn(p_Inp->p_Dec->logctx.parr[RUN_PARSE]);
close_stream_file(p_Inp); close_stream_file(p_Inp);
MPP_FREE(p_Inp->spspps_buf); MPP_FREE(p_Inp->spspps_buf);
FunctionOut(p_Inp->p_Dec->logctx.parr[RUN_PARSE]); FunctionOut(p_Inp->p_Dec->logctx.parr[RUN_PARSE]);
__RETURN: __RETURN:
@@ -154,18 +154,18 @@ static MPP_RET init_input_ctx(H264dInputCtx_t *p_Inp, ParserCfg *init)
p_Inp->init = *init; p_Inp->init = *init;
mpp_env_get_u32("rkv_h264d_mvc_disable", &p_Inp->mvc_disable, 1); mpp_env_get_u32("rkv_h264d_mvc_disable", &p_Inp->mvc_disable, 1);
open_stream_file(p_Inp, "/sdcard"); open_stream_file(p_Inp, "/sdcard");
if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) { if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) {
p_Inp->spspps_size = HEAD_BUF_MAX_SIZE; p_Inp->spspps_size = HEAD_BUF_MAX_SIZE;
p_Inp->spspps_buf = mpp_malloc_size(RK_U8, p_Inp->spspps_size); p_Inp->spspps_buf = mpp_malloc_size(RK_U8, p_Inp->spspps_size);
MEM_CHECK(ret, p_Inp->spspps_buf); MEM_CHECK(ret, p_Inp->spspps_buf);
} }
FunctionOut(p_Inp->p_Dec->logctx.parr[RUN_PARSE]); FunctionOut(p_Inp->p_Dec->logctx.parr[RUN_PARSE]);
__RETURN: __RETURN:
return ret = MPP_OK; return ret = MPP_OK;
__FAILED: __FAILED:
free_input_ctx(p_Inp); free_input_ctx(p_Inp);
return ret; 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]); FunctionIn(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
p_strm = &p_Cur->strm; p_strm = &p_Cur->strm;
p_strm->nalu_buf = mpp_malloc_size(RK_U8, NALU_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); p_strm->head_buf = mpp_malloc_size(RK_U8, HEAD_BUF_MAX_SIZE);
MEM_CHECK(ret, p_strm->nalu_buf && p_strm->head_buf); MEM_CHECK(ret, p_strm->nalu_buf && p_strm->head_buf);
p_strm->prefixdata = 0xffffffff; p_strm->prefixdata = 0xffffffff;
for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) { 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*)); 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 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]); 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]->layer_id = i;
p_Vid->p_Dpb_layer[i]->p_Vid = p_Vid; 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]->init_done = 0;
p_Vid->p_Dpb_layer[i]->poc_interval = 2; p_Vid->p_Dpb_layer[i]->poc_interval = 2;
} }
//!< init video pars //!< init video pars
for (i = 0; i < MAXSPS; i++) { 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); INP_CHECK(ret, !p_dxva);
FunctionIn(p_dxva->p_Dec->logctx.parr[RUN_PARSE]); FunctionIn(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
p_dxva->slice_count = 0; 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); 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); p_dxva->syn.buf = mpp_calloc(DXVA2_DecodeBufferDesc, SYNTAX_BUF_SIZE);
MEM_CHECK(ret, p_dxva->bitstream && p_dxva->syn.buf); MEM_CHECK(ret, p_dxva->bitstream && p_dxva->syn.buf);
FunctionOut(p_dxva->p_Dec->logctx.parr[RUN_PARSE]); 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 //!< init Dpb_memory Mark
for (i = 0; i < MAX_MARK_SIZE; i++) { for (i = 0; i < MAX_MARK_SIZE; i++) {
reset_dpb_mark(&p_Dec->dpb_mark[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); mpp_buf_slot_setup(p_Dec->frame_slots, MAX_MARK_SIZE);
//!< malloc mpp packet //!< 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_Dec = p_Dec;
p_Dec->p_Vid->p_Inp = p_Dec->p_Inp; p_Dec->p_Vid->p_Inp = p_Dec->p_Inp;
p_Dec->p_Vid->p_Cur = p_Dec->p_Cur; 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_input_ctx(p_Dec->p_Inp, init));
FUN_CHECK(ret = init_cur_ctx(p_Dec->p_Cur)); FUN_CHECK(ret = init_cur_ctx(p_Dec->p_Cur));
FUN_CHECK(ret = init_vid_ctx(p_Dec->p_Vid)); FUN_CHECK(ret = init_vid_ctx(p_Dec->p_Vid));
FUN_CHECK(ret = init_dec_ctx(p_Dec)); 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->in_dts = 0;
p_Dec->p_Inp->has_get_eos = 0; p_Dec->p_Inp->has_get_eos = 0;
//!< reset video parameter //!< reset video parameter
p_Dec->p_Vid->have_outpicture_flag = 0; p_Dec->p_Vid->have_outpicture_flag = 0;
p_Dec->p_Vid->exit_picture_flag = 0; p_Dec->p_Vid->exit_picture_flag = 0;
p_Dec->p_Vid->active_mvc_sps_flag = 0; p_Dec->p_Vid->active_mvc_sps_flag = 0;
p_Dec->p_Vid->g_framecnt = 0; p_Dec->p_Vid->g_framecnt = 0;
p_Dec->p_Vid->dec_pic = NULL; p_Dec->p_Vid->dec_pic = NULL;
p_Dec->p_Vid->last_pic = NULL; p_Dec->p_Vid->last_pic = NULL;
memset(&p_Dec->p_Vid->old_pic, 0, sizeof(H264_StorePic_t)); memset(&p_Dec->p_Vid->old_pic, 0, sizeof(H264_StorePic_t));
memset(&p_Dec->errctx, 0, sizeof(H264dErrCtx_t)); memset(&p_Dec->errctx, 0, sizeof(H264dErrCtx_t));
//!< reset current time stamp //!< reset current time stamp
p_Dec->p_Cur->last_dts = 0; 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->is_parser_end = 0;
p_Dec->dxva_ctx->strm_offset = 0; p_Dec->dxva_ctx->strm_offset = 0;
p_Dec->dxva_ctx->slice_count = 0; p_Dec->dxva_ctx->slice_count = 0;
p_Dec->last_frame_slot_idx = -1; p_Dec->last_frame_slot_idx = -1;
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]); FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
__RETURN: __RETURN:
return ret = MPP_OK; return ret = MPP_OK;
__FAILED: __FAILED:
@@ -537,18 +537,18 @@ __FAILED:
MPP_RET h264d_flush(void *decoder) MPP_RET h264d_flush(void *decoder)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; 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; H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
INP_CHECK(ret, !decoder); INP_CHECK(ret, !decoder);
INP_CHECK(ret, !p_Dec->p_Inp); INP_CHECK(ret, !p_Dec->p_Inp);
INP_CHECK(ret, !p_Dec->p_Vid); INP_CHECK(ret, !p_Dec->p_Vid);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]); FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
dpb_used_size = p_Dec->p_Vid->p_Dpb_layer[0]->used_size; dpb_used_size = p_Dec->p_Vid->p_Dpb_layer[0]->used_size;
if (p_Dec->mvc_valid) { 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[1]->used_size;
} }
if (!dpb_used_size && p_Dec->p_Inp->has_get_eos) { if (!dpb_used_size && p_Dec->p_Inp->has_get_eos) {
IOInterruptCB *cb = &p_Dec->p_Inp->init.notify_cb; IOInterruptCB *cb = &p_Dec->p_Inp->init.notify_cb;
if (cb->callBack) { if (cb->callBack) {
@@ -567,7 +567,7 @@ MPP_RET h264d_flush(void *decoder)
} }
flush_dpb_buf_slot(p_Dec); flush_dpb_buf_slot(p_Dec);
if (p_Dec->last_frame_slot_idx >= 0) { 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); SLOT_EOS, &p_Dec->p_Inp->has_get_eos);
p_Dec->last_frame_slot_idx = -1; 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; p_Inp = p_Dec->p_Inp;
if (p_Inp->has_get_eos || p_Dec->errctx.un_spt_flag) { 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; goto __RETURN;
} }
p_Inp->in_pkt = pkt; 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); p_Inp->in_dts = mpp_packet_get_dts(pkt);
if (mpp_packet_get_eos(pkt)) { if (mpp_packet_get_eos(pkt)) {
p_Inp->pkt_eos = 1; p_Inp->pkt_eos = 1;
p_Inp->has_get_eos = 1; p_Inp->has_get_eos = 1;
if (p_Inp->in_length < 4) { if (p_Inp->in_length < 4) {
h264d_flush(decoder); h264d_flush(decoder);
goto __RETURN; goto __RETURN;
} }
p_Inp->in_buf = NULL; p_Inp->in_buf = NULL;
p_Inp->in_length = 0; 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->in_length = mpp_packet_get_length(pkt);
p_Inp->pkt_eos = 0; p_Inp->pkt_eos = 0;
} }
if (p_Inp->in_length > MAX_STREM_IN_SIZE) { 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", 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); p_Inp->in_pts, p_Inp->pkt_eos, p_Inp->in_length, p_Dec->p_Vid->g_framecnt);
mpp_packet_set_length(pkt, 0); mpp_packet_set_length(pkt, 0);
ret = MPP_NOK; ret = MPP_NOK;
goto __FAILED; goto __FAILED;
} }
//!< avcC stream //!< avcC stream
if (mpp_packet_get_flag(pkt) & MPP_PACKET_FLAG_EXTRA_DATA) { if (mpp_packet_get_flag(pkt) & MPP_PACKET_FLAG_EXTRA_DATA) {
RK_U8 *pdata = p_Inp->in_buf; 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)); (ret = parse_prepare_extra_data(p_Inp, p_Dec->p_Cur));
task->valid = p_Inp->task_valid; //!< prepare valid flag task->valid = p_Inp->task_valid; //!< prepare valid flag
} else { } 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 { do {
(ret = parse_prepare_fast(p_Inp, p_Dec->p_Cur)); (ret = parse_prepare_fast(p_Inp, p_Dec->p_Cur));
task->valid = p_Inp->task_valid; //!< prepare valid flag task->valid = p_Inp->task_valid; //!< prepare valid flag
@@ -684,7 +684,7 @@ __RETURN:
return ret = MPP_OK; return ret = MPP_OK;
__FAILED: __FAILED:
return ret; return ret;
} }
@@ -697,18 +697,18 @@ __FAILED:
MPP_RET h264d_parse(void *decoder, HalDecTask *in_task) MPP_RET h264d_parse(void *decoder, HalDecTask *in_task)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; 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; H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
INP_CHECK(ret, !decoder && !in_task); INP_CHECK(ret, !decoder && !in_task);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]); FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
p_err = &p_Dec->errctx; p_err = &p_Dec->errctx;
in_task->valid = 0; // prepare end flag in_task->valid = 0; // prepare end flag
p_Dec->in_task = in_task; p_Dec->in_task = in_task;
p_err->cur_err_flag = 0; p_err->cur_err_flag = 0;
p_err->used_ref_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)); FUN_CHECK(ret = parse_loop(p_Dec));
if (p_Dec->is_parser_end) { 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->valid = 1; // register valid flag
in_task->syntax.number = p_Dec->dxva_ctx->syn.num; in_task->syntax.number = p_Dec->dxva_ctx->syn.num;
in_task->syntax.data = (void *)p_Dec->dxva_ctx->syn.buf; in_task->syntax.data = (void *)p_Dec->dxva_ctx->syn.buf;
in_task->flags.used_for_ref = p_err->used_ref_flag; 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; 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.had_error = (p_err->dpb_err_flag | p_err->cur_err_flag) ? 1 : 0;
} }
__RETURN: __RETURN:
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]); FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
@@ -736,30 +736,30 @@ __RETURN:
__FAILED: __FAILED:
{ {
H264_StorePic_t *dec_pic = p_Dec->p_Vid->dec_pic; H264_StorePic_t *dec_pic = p_Dec->p_Vid->dec_pic;
if (dec_pic) { if (dec_pic) {
H264D_WARNNING("[h264d_parse] h264d_parse failed.\n"); H264D_WARNNING("[h264d_parse] h264d_parse failed.\n");
if (dec_pic->mem_mark if (dec_pic->mem_mark
&& dec_pic->mem_mark->out_flag && dec_pic->mem_mark->out_flag
&& (dec_pic->mem_mark->slot_idx >= 0)) { && (dec_pic->mem_mark->slot_idx >= 0)) {
MppFrame mframe = NULL; MppFrame mframe = NULL;
mpp_buf_slot_get_prop(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, SLOT_FRAME_PTR, &mframe); mpp_buf_slot_get_prop(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, SLOT_FRAME_PTR, &mframe);
if (mframe) { if (mframe) {
if (p_err->used_ref_flag) { if (p_err->used_ref_flag) {
mpp_frame_set_errinfo(mframe, VPU_FRAME_ERR_UNKNOW); mpp_frame_set_errinfo(mframe, VPU_FRAME_ERR_UNKNOW);
} else { } else {
mpp_frame_set_discard(mframe, VPU_FRAME_ERR_UNKNOW); mpp_frame_set_discard(mframe, VPU_FRAME_ERR_UNKNOW);
} }
} }
mpp_buf_slot_set_flag(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, SLOT_QUEUE_USE); 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_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); 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); reset_dpb_mark(dec_pic->mem_mark);
dec_pic->mem_mark = NULL; dec_pic->mem_mark = NULL;
MPP_FREE(dec_pic); MPP_FREE(dec_pic);
p_Dec->p_Vid->dec_pic = NULL; p_Dec->p_Vid->dec_pic = NULL;
} }
p_err->dpb_err_flag |= p_err->used_ref_flag ? 1 : 0; p_err->dpb_err_flag |= p_err->used_ref_flag ? 1 : 0;
} }
return ret; return ret;
@@ -775,36 +775,36 @@ MPP_RET h264d_callback(void *decoder, void *errinfo)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder; H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
RK_U32 *p_regs = NULL; RK_U32 *p_regs = NULL;
INP_CHECK(ret, !decoder); INP_CHECK(ret, !decoder);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]); FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
p_regs = (RK_U32*)errinfo; p_regs = (RK_U32*)errinfo;
{ {
MppFrame mframe = NULL; MppFrame mframe = NULL;
RK_U32 out_slot_idx = p_regs[78]; RK_U32 out_slot_idx = p_regs[78];
RK_U32 had_err_flag = p_regs[79]; RK_U32 had_err_flag = p_regs[79];
RK_U32 used_ref_flag = p_regs[80]; RK_U32 used_ref_flag = p_regs[80];
RK_U32 dec_error_sta = p_regs[1] & 0x00004000; RK_U32 dec_error_sta = p_regs[1] & 0x00004000;
RK_U32 dec_rdy_sta = p_regs[1] & 0x00001000; RK_U32 dec_rdy_sta = p_regs[1] & 0x00001000;
RK_U32 buf_empty_sta = p_regs[1] & 0x00010000; RK_U32 buf_empty_sta = p_regs[1] & 0x00010000;
RK_U32 strmd_error_status = p_regs[45]; RK_U32 strmd_error_status = p_regs[45];
RK_U32 strmd_error_detect_flag = p_regs[76] & 0x00008000; // strmd error detect flag 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); mpp_buf_slot_get_prop(p_Dec->frame_slots, out_slot_idx, SLOT_FRAME_PTR, &mframe);
if (mframe) { if (mframe) {
if (dec_error_sta || (!dec_rdy_sta) || buf_empty_sta if (dec_error_sta || (!dec_rdy_sta) || buf_empty_sta
|| had_err_flag || strmd_error_status || strmd_error_detect_flag) { || had_err_flag || strmd_error_status || strmd_error_detect_flag) {
if (used_ref_flag) { if (used_ref_flag) {
mpp_frame_set_errinfo(mframe, VPU_FRAME_ERR_UNKNOW); mpp_frame_set_errinfo(mframe, VPU_FRAME_ERR_UNKNOW);
} else { } else {
mpp_frame_set_discard(mframe, VPU_FRAME_ERR_UNKNOW); mpp_frame_set_discard(mframe, VPU_FRAME_ERR_UNKNOW);
} }
} }
H264D_DBG(H264D_DBG_CALLBACK, "[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", 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)); 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: __RETURN:
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]); 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) static RK_S32 get_smallest_poc(H264_DpbBuf_t *p_Dpb, RK_S32 *poc, RK_S32 *pos)
{ {
RK_U32 i = 0; RK_U32 i = 0;
RK_S32 find_flag = 0; RK_S32 find_flag = 0;
RK_S32 min_pos = -1; RK_S32 min_pos = -1;
RK_S32 min_poc = INT_MAX; RK_S32 min_poc = INT_MAX;
*pos = -1; *pos = -1;
*poc = INT_MAX; *poc = INT_MAX;
for (i = 0; i < p_Dpb->used_size; i++) { for (i = 0; i < p_Dpb->used_size; i++) {
if (min_poc > p_Dpb->fs[i]->poc) { if (min_poc > p_Dpb->fs[i]->poc) {
min_poc = p_Dpb->fs[i]->poc; min_poc = p_Dpb->fs[i]->poc;
min_pos = i; min_pos = i;
} }
if ((*poc > p_Dpb->fs[i]->poc) && (!p_Dpb->fs[i]->is_output)) { if ((*poc > p_Dpb->fs[i]->poc) && (!p_Dpb->fs[i]->is_output)) {
*poc = p_Dpb->fs[i]->poc; *poc = p_Dpb->fs[i]->poc;
*pos = i; *pos = i;
find_flag = 1; find_flag = 1;
} }
} }
if (!find_flag) { if (!find_flag) {
*poc = min_poc; *poc = min_poc;
*pos = min_pos; *pos = min_pos;
} }
return find_flag; return find_flag;
} }
static H264_FrameStore_t *alloc_frame_store() 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; H264dVideoCtx_t *p_Vid = p_Dpb->p_Vid;
//!< find smallest POC //!< find smallest POC
if (get_smallest_poc(p_Dpb, &poc, &pos)) { if (get_smallest_poc(p_Dpb, &poc, &pos)) {
p_Dpb->last_output_poc = poc; p_Dpb->last_output_poc = poc;
//!< JVT-P072 ends //!< JVT-P072 ends
FUN_CHECK(ret = write_stored_frame(p_Vid, p_Dpb->fs[pos])); FUN_CHECK(ret = write_stored_frame(p_Vid, p_Dpb->fs[pos]));
//!< free frame store and move empty store to end of buffer //!< free frame store and move empty store to end of buffer
if (!is_used_for_reference(p_Dpb->fs[pos])) { if (!is_used_for_reference(p_Dpb->fs[pos])) {
FUN_CHECK(ret = remove_frame_from_dpb(p_Dpb, pos)); FUN_CHECK(ret = remove_frame_from_dpb(p_Dpb, pos));
}
} }
}
return ret = MPP_OK; return ret = MPP_OK;
__FAILED: __FAILED:
return ret; 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 VAL_CHECK(ret, NULL != p); //!< if frame, check for new store
p_Vid->last_pic = NULL; p_Vid->last_pic = NULL;
//!< set use flag //!< set use flag
if (p->mem_mark && (p->mem_mark->slot_idx >= 0)) { 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); mpp_buf_slot_set_flag(p_Vid->p_Dec->frame_slots, p->mem_mark->slot_idx, SLOT_CODEC_USE);
} else { } else {
H264D_ERR("error, p->mem_mark == NULL"); H264D_ERR("error, p->mem_mark == NULL");
} }
//!< deal with all frames in dpb //!< deal with all frames in dpb
p_Vid->last_has_mmco_5 = 0; p_Vid->last_has_mmco_5 = 0;
p_Vid->last_pic_bottom_field = p->structure == BOTTOM_FIELD; 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); sliding_window_memory_management(p_Dpb);
p->is_long_term = 0; p->is_long_term = 0;
} }
while (!remove_unused_frame_from_dpb(p_Dpb)); while (!remove_unused_frame_from_dpb(p_Dpb));
#if 1 #if 1
while (p_Dpb->used_size == p_Dpb->size) { while (p_Dpb->used_size == p_Dpb->size) {
RK_S32 min_poc = 0, min_pos = 0; RK_S32 min_poc = 0, min_pos = 0;
RK_S32 find_flag = 0; RK_S32 find_flag = 0;
remove_unused_frame_from_dpb(p_Dpb); remove_unused_frame_from_dpb(p_Dpb);
find_flag = get_smallest_poc(p_Dpb, &min_poc, &min_pos); find_flag = get_smallest_poc(p_Dpb, &min_poc, &min_pos);
if (!p->used_for_reference) { if (!p->used_for_reference) {
if ((!find_flag) || (p->poc < min_poc)) { if ((!find_flag) || (p->poc < min_poc)) {
p_Dpb->last_output_poc = p->poc; p_Dpb->last_output_poc = p->poc;
FUN_CHECK(ret = direct_output(p_Vid, p)); //!< output frame FUN_CHECK(ret = direct_output(p_Vid, p)); //!< output frame
goto __RETURN; goto __RETURN;
} }
} }
//!< used for reference, but not find, then flush a frame in the first //!< used for reference, but not find, then flush a frame in the first
if ((!find_flag) || (p->poc < min_poc)) { if ((!find_flag) || (p->poc < min_poc)) {
//min_pos = 0; //min_pos = 0;
unmark_for_reference(p_Vid->p_Dec, p_Dpb->fs[min_pos]); unmark_for_reference(p_Vid->p_Dec, p_Dpb->fs[min_pos]);
if (!p_Dpb->fs[min_pos]->is_output) { if (!p_Dpb->fs[min_pos]->is_output) {
p_Dpb->last_output_poc = p_Dpb->fs[min_pos]->poc; 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 = write_stored_frame(p_Vid, p_Dpb->fs[min_pos]));
} }
FUN_CHECK(ret = remove_frame_from_dpb(p_Dpb, min_pos)); FUN_CHECK(ret = remove_frame_from_dpb(p_Dpb, min_pos));
p->is_long_term = 0; p->is_long_term = 0;
} }
FUN_CHECK(ret = output_one_frame_from_dpb(p_Dpb)); 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;
} }
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 #endif
#if 1 #if 1
{ {
RK_S32 min_poc = 0, min_pos = 0; //!< store current decoder picture at end of dpb
H264_FrameStore_t *fs = p_Dpb->fs[p_Dpb->used_size - 1]; FUN_CHECK(ret = insert_picture_in_dpb(p_Vid, p_Dpb->fs[p_Dpb->used_size], p, 0));
RK_S32 poc_inc = fs->poc - p_Dpb->last_output_poc; 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->used_size++;
p_Dpb->poc_interval = 1; 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_Dpb->last_output_poc > INT_MIN) && abs(poc_inc) & 0x1) {
if (p->idr_flag || (p->poc == 0) || (p_Dpb->last_output_poc == INT_MIN)) { p_Dpb->poc_interval = 1;
p_Dpb->last_output_poc = p->poc;
FUN_CHECK(ret = write_stored_frame(p_Vid, fs)); }
} if (p->idr_flag || (p->poc == 0) || (p_Dpb->last_output_poc == INT_MIN)) {
while ((p_Dpb->last_output_poc > INT_MIN) p_Dpb->last_output_poc = p->poc;
&& (get_smallest_poc(p_Dpb, &min_poc, &min_pos))) { FUN_CHECK(ret = write_stored_frame(p_Vid, fs));
if ((min_poc - p_Dpb->last_output_poc) <= p_Dpb->poc_interval) { }
p_Dpb->last_output_poc = min_poc; while ((p_Dpb->last_output_poc > INT_MIN)
FUN_CHECK(ret = write_stored_frame(p_Vid, p_Dpb->fs[min_pos])); && (get_smallest_poc(p_Dpb, &min_poc, &min_pos))) {
} if ((min_poc - p_Dpb->last_output_poc) <= p_Dpb->poc_interval) {
else { p_Dpb->last_output_poc = min_poc;
break; FUN_CHECK(ret = write_stored_frame(p_Vid, p_Dpb->fs[min_pos]));
} } else {
} break;
while (!remove_unused_frame_from_dpb(p_Dpb)); }
} }
while (!remove_unused_frame_from_dpb(p_Dpb));
}
#endif #endif
update_ref_list(p_Dpb); update_ref_list(p_Dpb);
update_ltref_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); free_dpb(p_Dpb);
} }
VAL_CHECK(ret, p_Dpb->size = getDpbSize(p_Vid, active_sps)); 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; p_Dpb->num_ref_frames = active_sps->max_num_ref_frames;
if (active_sps->max_dec_frame_buffering < active_sps->max_num_ref_frames) { if (active_sps->max_dec_frame_buffering < active_sps->max_num_ref_frames) {
H264D_WARNNING("DPB size at specified level is smaller than reference 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; RK_U32 streamlen_add = 0;
DXVA_Slice_H264_Long *p_long = NULL; DXVA_Slice_H264_Long *p_long = NULL;
if (dxva_ctx->slice_count > MAX_SLICE_NUM) { if (dxva_ctx->slice_count > MAX_SLICE_NUM) {
H264D_ERR("error, slcie_num is larger than 1024"); H264D_ERR("error, slcie_num is larger than 1024");
goto __FAILED; goto __FAILED;
} }
//streamlen_add = p_nal->sodb_len + sizeof(start_code); //streamlen_add = p_nal->sodb_len + sizeof(start_code);
//stream_offset = dxva_ctx->strm_offset + streamlen_add; //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, STRUCT_NULL = 0,
TOP_FIELD = 0x1, TOP_FIELD = 0x1,
BOTTOM_FIELD = 0x2, BOTTOM_FIELD = 0x2,
FRAME = 0x3, FRAME = 0x3,
STRUCT_MAX, STRUCT_MAX,
} PictureStructure; //!< New enum for field processing } PictureStructure; //!< New enum for field processing
typedef enum { typedef enum {
PIC_ERR_NULL = 0, PIC_ERR_NULL = 0,
PIC_ERR_TOP = 0x1, PIC_ERR_TOP = 0x1,
PIC_ERR_BOT = 0x2, PIC_ERR_BOT = 0x2,
PIC_ERR_FRAME = 0x3, PIC_ERR_FRAME = 0x3,
PIC_ERR_WHOLE = 0x3, PIC_ERR_WHOLE = 0x3,
PIC_ERR_MAX, PIC_ERR_MAX,
}PictureError; } PictureError;
typedef enum { typedef enum {
FIELD_ORDER_NULL, FIELD_ORDER_NULL,
FIELD_ORDER_TOP_FIRST, FIELD_ORDER_TOP_FIRST,
FIELD_ORDER_BOT_FIRST, FIELD_ORDER_BOT_FIRST,
FIELD_ORDER_SAME, FIELD_ORDER_SAME,
FIELD_ORDER_MAX FIELD_ORDER_MAX
}FieldOrder; } FieldOrder;
//!< Field Coding Types //!< Field Coding Types
typedef enum { typedef enum {
FRAME_CODING = 0, FRAME_CODING = 0,
@@ -191,11 +191,11 @@ typedef struct h264_nalu_mvc_ext_t {
//!< decoder refence picture marking //!< decoder refence picture marking
typedef struct h264_drpm_t { typedef struct h264_drpm_t {
RK_S32 memory_management_control_operation; RK_S32 memory_management_control_operation;
RK_S32 difference_of_pic_nums_minus1; RK_S32 difference_of_pic_nums_minus1;
RK_S32 long_term_pic_num; RK_S32 long_term_pic_num;
RK_S32 long_term_frame_idx; RK_S32 long_term_frame_idx;
RK_S32 max_long_term_frame_idx_plus1; RK_S32 max_long_term_frame_idx_plus1;
struct h264_drpm_t *Next; struct h264_drpm_t *Next;
} H264_DRPM_t; } H264_DRPM_t;
@@ -328,9 +328,9 @@ typedef struct h264_frame_store_t {
RK_S32 inter_view_flag[2]; RK_S32 inter_view_flag[2];
RK_S32 anchor_pic_flag[2]; RK_S32 anchor_pic_flag[2];
RK_S32 layer_id; RK_S32 layer_id;
RK_S32 slice_type; RK_S32 slice_type;
RK_U32 frame_num; RK_U32 frame_num;
RK_S32 structure; RK_S32 structure;
struct h264_store_pic_t *frame; struct h264_store_pic_t *frame;
struct h264_store_pic_t *top_field; struct h264_store_pic_t *top_field;
struct h264_store_pic_t *bottom_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 ltref_frames_in_buffer;
RK_U32 used_size_il; RK_U32 used_size_il;
RK_S32 poc_interval; RK_S32 poc_interval;
RK_S32 last_output_poc; RK_S32 last_output_poc;
RK_S32 last_output_view_id; RK_S32 last_output_view_id;
RK_S32 max_long_term_pic_idx; 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_active[2]; //!< number of available list references
RK_S32 num_ref_idx_override_flag; RK_S32 num_ref_idx_override_flag;
RK_S32 ref_pic_list_reordering_flag[2]; RK_S32 ref_pic_list_reordering_flag[2];
RK_S32 *modification_of_pic_nums_idc[2]; RK_S32 *modification_of_pic_nums_idc[2];
RK_S32 *abs_diff_pic_num_minus1[2]; RK_S32 *abs_diff_pic_num_minus1[2];
RK_S32 *long_term_pic_idx[2]; RK_S32 *long_term_pic_idx[2];
RK_S32 *abs_diff_view_idx_minus1[2]; RK_S32 *abs_diff_view_idx_minus1[2];
struct h264_drpm_t *dec_ref_pic_marking_buffer; struct h264_drpm_t *dec_ref_pic_marking_buffer;
RK_U32 drpm_used_bitlen; RK_U32 drpm_used_bitlen;
RK_S32 no_output_of_prior_pics_flag; RK_S32 no_output_of_prior_pics_flag;
@@ -866,14 +866,14 @@ typedef struct h264d_input_ctx_t {
RK_U32 nal_size; RK_U32 nal_size;
RK_S32 sps_num; RK_S32 sps_num;
RK_S32 pps_num; RK_S32 pps_num;
//!< write stream //!< write stream
char fname[2][512]; char fname[2][512];
FILE *fp; FILE *fp;
RK_U8 *spspps_buf; RK_U8 *spspps_buf;
RK_U32 spspps_size; RK_U32 spspps_size;
RK_U32 spspps_len; RK_U32 spspps_len;
RK_U32 spspps_offset; RK_U32 spspps_offset;
RK_U32 spspps_update_flag; RK_U32 spspps_update_flag;
} H264dInputCtx_t; } H264dInputCtx_t;
@@ -919,13 +919,13 @@ typedef struct h264d_cur_ctx_t {
RK_S64 last_dts; RK_S64 last_dts;
RK_S64 curr_pts; RK_S64 curr_pts;
RK_S64 curr_dts; RK_S64 curr_dts;
//!< malloc buffer for current slice //!< malloc buffer for current slice
RK_S32 modification_of_pic_nums_idc[2][MAX_REORDER_TIMES]; RK_S32 modification_of_pic_nums_idc[2][MAX_REORDER_TIMES];
RK_S32 abs_diff_pic_num_minus1[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 long_term_pic_idx[2][MAX_REORDER_TIMES];
RK_S32 abs_diff_view_idx_minus1[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]; struct h264_drpm_t dec_ref_pic_marking_buffer[MAX_MARKING_TIMES];
} H264dCurCtx_t; } H264dCurCtx_t;
//!< parameters for video decoder //!< parameters for video decoder
@@ -941,13 +941,13 @@ typedef struct h264d_video_ctx_t {
struct h264d_cur_ctx_t *p_Cur; //!< H264_CurParameters struct h264d_cur_ctx_t *p_Cur; //!< H264_CurParameters
struct h264_dpb_buf_t *p_Dpb_layer[MAX_NUM_DPB_LAYERS]; 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 *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_store_pic_t *no_ref_pic; //!< no reference picture
struct h264_frame_store_t out_buffer; struct h264_frame_store_t out_buffer;
struct h264_dpb_mark_t *active_dpb_mark[MAX_NUM_DPB_LAYERS]; //!< acitve_dpb_memory 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; struct h264_old_slice_par_t old_slice;
RK_S32 *qmatrix[12]; //!< scanlist pointer RK_S32 *qmatrix[12]; //!< scanlist pointer
RK_U32 stream_size; RK_U32 stream_size;
@@ -1054,10 +1054,10 @@ typedef enum slice_state_type {
} SLICE_STATUS; } SLICE_STATUS;
typedef struct h264_err_ctx_t { typedef struct h264_err_ctx_t {
RK_U32 un_spt_flag; RK_U32 un_spt_flag;
RK_U32 cur_err_flag; //!< current decoded picture error RK_U32 cur_err_flag; //!< current decoded picture error
RK_U32 used_ref_flag; 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_U32 i_slice_no;
RK_S32 first_iframe_poc; 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 || (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 == 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 || ((!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", 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); dec_pic->combine_flag, p_last->is_used, cur_structure);
return ret = MPP_NOK; 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_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_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); 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); reset_dpb_mark(p_mark);
@@ -1994,16 +1993,16 @@ MPP_RET init_picture(H264_SLICE_t *currSlice)
goto __FAILED; goto __FAILED;
} }
FUN_CHECK(ret = alloc_decpic(currSlice)); FUN_CHECK(ret = alloc_decpic(currSlice));
if (p_err->i_slice_no < 2) { if (p_err->i_slice_no < 2) {
if ((!currSlice->layer_id) && (I_SLICE == currSlice->slice_type)) { if ((!currSlice->layer_id) && (I_SLICE == currSlice->slice_type)) {
p_err->first_iframe_poc = p_Vid->dec_pic->poc; //!< recoder first i frame poc 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) { if (p_Vid->dec_pic->poc < p_err->first_iframe_poc) {
H264D_WARNNING("[Discard] Discard poc less than first I Slice. \n"); H264D_WARNNING("[Discard] Discard poc less than first I Slice. \n");
ret = MPP_NOK; ret = MPP_NOK;
goto __FAILED; goto __FAILED;
} }
} }
//!< idr_memory_management MVC_layer, idr_flag==1 //!< idr_memory_management MVC_layer, idr_flag==1
if (currSlice->layer_id && !currSlice->svc_extension_flag && !currSlice->mvcExt.non_idr_flag) { if (currSlice->layer_id && !currSlice->svc_extension_flag && !currSlice->mvcExt.non_idr_flag) {
ASSERT(currSlice->layer_id == 1); 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->listXsizeP[i] = 0;
currSlice->listXsizeB[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]); 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; MPP_RET ret = MPP_ERR_UNKNOW;
if ((*buf) == NULL) { if ((*buf) == NULL) {
H264D_ERR("[realloc_buffer] pointer is null, %p",(*buf)); H264D_ERR("[realloc_buffer] pointer is null, %p", (*buf));
ret = MPP_ERR_MALLOC; ret = MPP_ERR_MALLOC;
goto __FAILED; goto __FAILED;
} }
add_size = MPP_ALIGN(add_size, 16); add_size = MPP_ALIGN(add_size, 16);
(*buf) = mpp_realloc((*buf), RK_U8, ((*max_size) + add_size)); (*buf) = mpp_realloc((*buf), RK_U8, ((*max_size) + add_size));
if ((*buf) == NULL) { if ((*buf) == NULL) {
H264D_ERR("[realloc_buffer] max_size=%d, add_size=%d \n",(*max_size), add_size); H264D_ERR("[realloc_buffer] max_size=%d, add_size=%d \n", (*max_size), add_size);
ret = MPP_ERR_MALLOC; ret = MPP_ERR_MALLOC;
goto __FAILED; goto __FAILED;
} }
(*max_size) += add_size; (*max_size) += add_size;
return ret = MPP_OK; 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) 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->prefixdata & 0x00FFFFFF) == 0x00000001) {
if (p_strm->startcode_found) { if (p_strm->startcode_found) {
p_strm->endcode_found = 1; 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."); H264D_DBG(H264D_DBG_PARSE_NALU, "nalu_type=SLICE.");
FUN_CHECK(ret = process_slice(currSlice)); FUN_CHECK(ret = process_slice(currSlice));
//if (currSlice->start_mb_nr == 0) { //if (currSlice->start_mb_nr == 0) {
currSlice->p_Dec->nalu_ret = StartOfPicture; currSlice->p_Dec->nalu_ret = StartOfPicture;
//} else { //} else {
// currSlice->p_Dec->nalu_ret = StartOfSlice; // 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); RK_U32 add_size = sizeof(H264dNaluHead_t);
if ((p_strm->head_offset + add_size) > HEAD_BUF_MAX_SIZE) { if ((p_strm->head_offset + add_size) > HEAD_BUF_MAX_SIZE) {
H264D_ERR("error, head_offset is larger than %d", HEAD_BUF_MAX_SIZE); H264D_ERR("error, head_offset is larger than %d", HEAD_BUF_MAX_SIZE);
goto __FAILED; goto __FAILED;
} }
p_des = &p_strm->head_buf[p_strm->head_offset]; p_des = &p_strm->head_buf[p_strm->head_offset];
((H264dNaluHead_t *)p_des)->is_frame_end = 1; ((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_PREFIX)
|| (p_strm->nalu_type == NALU_TYPE_SLC_EXT)) { || (p_strm->nalu_type == NALU_TYPE_SLC_EXT)) {
RK_U32 head_size = MPP_MIN(HEAD_SYNTAX_MAX_SIZE, p_strm->nalu_len); 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 add_size = head_size + sizeof(H264dNaluHead_t);
if ((p_strm->head_offset + add_size) > HEAD_BUF_MAX_SIZE) { if ((p_strm->head_offset + add_size) > HEAD_BUF_MAX_SIZE) {
H264D_ERR("error, head_offset is larger than %d", HEAD_BUF_MAX_SIZE); H264D_ERR("error, head_offset is larger than %d", HEAD_BUF_MAX_SIZE);
goto __FAILED; goto __FAILED;
} }
p_des = &p_strm->head_buf[p_strm->head_offset]; p_des = &p_strm->head_buf[p_strm->head_offset];
((H264dNaluHead_t *)p_des)->is_frame_end = 0; ((H264dNaluHead_t *)p_des)->is_frame_end = 0;
((H264dNaluHead_t *)p_des)->nalu_type = p_strm->nalu_type; ((H264dNaluHead_t *)p_des)->nalu_type = p_strm->nalu_type;
((H264dNaluHead_t *)p_des)->sodb_len = head_size; ((H264dNaluHead_t *)p_des)->sodb_len = head_size;
memcpy(p_des + sizeof(H264dNaluHead_t), p_strm->nalu_buf, head_size); memcpy(p_des + sizeof(H264dNaluHead_t), p_strm->nalu_buf, head_size);
p_strm->head_offset += add_size; p_strm->head_offset += add_size;
} //!< fill sodb buffer } //!< 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)) { || (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) { if ((dxva_ctx->strm_offset + add_size) > SODB_BUF_MAX_SIZE) {
H264D_ERR("error, bitstream_offset is larger than %d", SODB_BUF_MAX_SIZE); H264D_ERR("error, bitstream_offset is larger than %d", SODB_BUF_MAX_SIZE);
goto __FAILED; goto __FAILED;
} }
p_des = &dxva_ctx->bitstream[dxva_ctx->strm_offset]; 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); memcpy(p_des + sizeof(g_start_precode), p_strm->nalu_buf, p_strm->nalu_len);
dxva_ctx->strm_offset += add_size; dxva_ctx->strm_offset += add_size;
} }
if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) { if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) {
H264dInputCtx_t *p_Inp = p_Cur->p_Inp; H264dInputCtx_t *p_Inp = p_Cur->p_Inp;
if ((p_strm->nalu_type == NALU_TYPE_SPS) if ((p_strm->nalu_type == NALU_TYPE_SPS)
|| (p_strm->nalu_type == NALU_TYPE_PPS)) { || (p_strm->nalu_type == NALU_TYPE_PPS)) {
if (p_Inp->spspps_update_flag) { if (p_Inp->spspps_update_flag) {
p_des = &p_Inp->spspps_buf[p_Inp->spspps_offset]; p_des = &p_Inp->spspps_buf[p_Inp->spspps_offset];
memcpy(p_des, g_start_precode, sizeof(g_start_precode)); 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); 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_offset += p_strm->nalu_len + sizeof(g_start_precode);
p_Inp->spspps_len = p_Inp->spspps_offset; p_Inp->spspps_len = p_Inp->spspps_offset;
} }
} } else if ((p_strm->nalu_type == NALU_TYPE_SLICE)
else if ((p_strm->nalu_type == NALU_TYPE_SLICE) || (p_strm->nalu_type == NALU_TYPE_IDR)) {
|| (p_strm->nalu_type == NALU_TYPE_IDR)) { p_Cur->p_Inp->spspps_update_flag = 1;
p_Cur->p_Inp->spspps_update_flag = 1; p_Inp->spspps_offset = 0;
p_Inp->spspps_offset = 0; }
} }
}
return ret = MPP_OK; return ret = MPP_OK;
__FAILED: __FAILED:
return ret; return ret;
@@ -462,19 +461,19 @@ static RK_U64 global_flie_size = 0;
*/ */
MPP_RET open_stream_file(H264dInputCtx_t *p_Inp, char *path) 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[0], "%s/rkv_h264d_file_00.h264", path);
sprintf(p_Inp->fname[1], "%s/rkv_h264d_file_01.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"); { p_Inp->fp = fopen(p_Inp->fname[global_file_fid], "ab"); {
if (p_Inp->fp == NULL) { if (p_Inp->fp == NULL) {
H264D_WARNNING("[open_stream_file] can not open stream file, %s.", p_Inp->fname[global_file_fid]); 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) 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 && (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN)) {
if (p_Inp->fp) { if (p_Inp->fp) {
fwrite(pdata, sizeof(RK_U8), len, p_Inp->fp); fwrite(pdata, sizeof(RK_U8), len, p_Inp->fp);
fflush(p_Inp->fp); fflush(p_Inp->fp);
} }
global_flie_size += len; global_flie_size += len;
if (global_flie_size > MAX_ES_FILE_SIZE) { if (global_flie_size > MAX_ES_FILE_SIZE) {
FCLOSE(p_Inp->fp); FCLOSE(p_Inp->fp);
global_file_fid = 1 - global_file_fid; global_file_fid = 1 - global_file_fid;
global_flie_size = 0; global_flie_size = 0;
p_Inp->fp = fopen(p_Inp->fname[global_file_fid], "wb"); p_Inp->fp = fopen(p_Inp->fname[global_file_fid], "wb");
if (p_Inp->fp == NULL) { if (p_Inp->fp == NULL) {
H264D_WARNNING("[open_stream_file] can not open stream file, %s", p_Inp->fname[global_file_fid]); H264D_WARNNING("[open_stream_file] can not open stream file, %s", p_Inp->fname[global_file_fid]);
} } else {
else { fwrite(p_Inp->spspps_buf, sizeof(RK_U8), p_Inp->spspps_len, p_Inp->fp);
fwrite(p_Inp->spspps_buf, sizeof(RK_U8), p_Inp->spspps_len, p_Inp->fp); fflush(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) MPP_RET close_stream_file(H264dInputCtx_t *p_Inp)
{ {
if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) { if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) {
if (p_Inp->fp) { if (p_Inp->fp) {
fflush(p_Inp->fp); fflush(p_Inp->fp);
FCLOSE(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--; pkt_impl->length--;
if (p_strm->startcode_found) { if (p_strm->startcode_found) {
if (p_strm->nalu_len >= NALU_BUF_MAX_SIZE) { if (p_strm->nalu_len >= NALU_BUF_MAX_SIZE) {
H264D_ERR("error, nalu_len is larger than %d", NALU_BUF_MAX_SIZE); H264D_ERR("error, nalu_len is larger than %d", NALU_BUF_MAX_SIZE);
goto __FAILED; goto __FAILED;
} }
p_strm->nalu_buf[p_strm->nalu_len++] = *p_strm->curdata; p_strm->nalu_buf[p_strm->nalu_len++] = *p_strm->curdata;
if (p_strm->nalu_len == 1) { 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--; pkt_impl->length--;
if (p_strm->startcode_found) { if (p_strm->startcode_found) {
if (p_strm->nalu_len >= NALU_BUF_MAX_SIZE) { if (p_strm->nalu_len >= NALU_BUF_MAX_SIZE) {
H264D_ERR("error, nalu_len is larger than %d", NALU_BUF_MAX_SIZE); H264D_ERR("error, nalu_len is larger than %d", NALU_BUF_MAX_SIZE);
goto __FAILED; goto __FAILED;
} }
p_strm->nalu_buf[p_strm->nalu_len++] = *p_strm->curdata; p_strm->nalu_buf[p_strm->nalu_len++] = *p_strm->curdata;
if (p_strm->nalu_len == 1) { 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_Inp->task_valid = 1;
p_Cur->p_Dec->is_new_frame = 0; p_Cur->p_Dec->is_new_frame = 0;
p_Cur->last_dts = p_Inp->in_dts; p_Cur->last_dts = p_Inp->in_dts;
p_Cur->last_pts = p_Inp->in_pts; p_Cur->last_pts = p_Inp->in_pts;
} }
//__RETURN: //__RETURN:
FunctionOut(logctx->parr[RUN_PARSE]); FunctionOut(logctx->parr[RUN_PARSE]);
@@ -907,14 +905,14 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
INP_CHECK(ret, !p_Dec); INP_CHECK(ret, !p_Dec);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]); FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
//!< ==== loop ==== //!< ==== loop ====
p_Dec->next_state = SliceSTATE_ResetSlice; p_Dec->next_state = SliceSTATE_ResetSlice;
p_curdata = p_Dec->p_Cur->strm.head_buf; p_curdata = p_Dec->p_Cur->strm.head_buf;
while (while_loop_flag) { while (while_loop_flag) {
switch (p_Dec->next_state) { switch (p_Dec->next_state) {
case SliceSTATE_ResetSlice: case SliceSTATE_ResetSlice:
reset_slice(p_Dec->p_Vid); reset_slice(p_Dec->p_Vid);
p_Dec->next_state = SliceSTATE_ReadNalu; p_Dec->next_state = SliceSTATE_ReadNalu;
H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_ResetSlice"); H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_ResetSlice");
break; break;
case SliceSTATE_ReadNalu: case SliceSTATE_ReadNalu:
@@ -948,32 +946,30 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_ParseNalu"); H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_ParseNalu");
break; break;
case SliceSTATE_InitPicture: case SliceSTATE_InitPicture:
if (!p_Dec->p_Vid->iNumOfSlicesDecoded) { if (!p_Dec->p_Vid->iNumOfSlicesDecoded) {
FUN_CHECK(ret = init_picture(&p_Dec->p_Cur->slice)); FUN_CHECK(ret = init_picture(&p_Dec->p_Cur->slice));
p_Dec->is_parser_end = 1; p_Dec->is_parser_end = 1;
} }
p_Dec->next_state = SliceSTATE_GetSliceData; p_Dec->next_state = SliceSTATE_GetSliceData;
H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_InitPicture"); H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_InitPicture");
break; break;
case SliceSTATE_GetSliceData: case SliceSTATE_GetSliceData:
FUN_CHECK(ret = fill_slice_syntax(&p_Dec->p_Cur->slice, p_Dec->dxva_ctx)); FUN_CHECK(ret = fill_slice_syntax(&p_Dec->p_Cur->slice, p_Dec->dxva_ctx));
p_Dec->p_Vid->iNumOfSlicesDecoded++; p_Dec->p_Vid->iNumOfSlicesDecoded++;
if (p_Dec->is_parser_end) { if (p_Dec->is_parser_end) {
p_Dec->next_state = SliceSTATE_RegisterOneFrame; p_Dec->next_state = SliceSTATE_RegisterOneFrame;
} } else {
else p_Dec->next_state = SliceSTATE_ResetSlice;
{ }
p_Dec->next_state = SliceSTATE_ResetSlice;
}
H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_GetSliceData"); H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_GetSliceData");
break; break;
case SliceSTATE_RegisterOneFrame: case SliceSTATE_RegisterOneFrame:
if (!p_Dec->is_parser_end){ if (!p_Dec->is_parser_end) {
ret = MPP_NOK; ret = MPP_NOK;
goto __FAILED; goto __FAILED;
} }
commit_buffer(p_Dec->dxva_ctx); commit_buffer(p_Dec->dxva_ctx);
while_loop_flag = 0; while_loop_flag = 0;
p_Dec->next_state = SliceSTATE_ReadNalu; p_Dec->next_state = SliceSTATE_ReadNalu;
H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_RegisterOneFrame"); H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_RegisterOneFrame");
break; 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) { 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"); 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]) { 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; i = 0;
do { do {
if (i >= size) { if (i >= size) {
ret = MPP_NOK; ret = MPP_NOK;
H264D_WARNNING("ref_pic_list_reordering error, i >= num_ref_idx_active[LIST_0](%d)", size); H264D_WARNNING("ref_pic_list_reordering error, i >= num_ref_idx_active[LIST_0](%d)", size);
goto __BITREAD_ERR; goto __BITREAD_ERR;
} }
READ_UE(p_bitctx, &modification_of_pic_nums_idc, "modification_of_pic_nums_idc"); 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; 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) { 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) { if (currSlice->slice_type % 5 == B_SLICE) {
READ_ONEBIT(p_bitctx, &currSlice->ref_pic_list_reordering_flag[LIST_1], "ref_pic_list_reordering_flag"); 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]) { 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; i = 0;
do { do {
if (i >= size) { if (i >= size) {
ret = MPP_NOK; ret = MPP_NOK;
H264D_WARNNING("ref_pic_list_reordering error, i >= num_ref_idx_active[LIST_1](%d)", size); H264D_WARNNING("ref_pic_list_reordering error, i >= num_ref_idx_active[LIST_1](%d)", size);
goto __BITREAD_ERR; goto __BITREAD_ERR;
} }
READ_UE(p_bitctx, &modification_of_pic_nums_idc, "modification_of_pic_nums_idc"); 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; 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) { 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: __BITREAD_ERR:
ret = p_bitctx->ret; ret = p_bitctx->ret;
return ret; return ret;
} }
static MPP_RET pred_weight_table(H264_SLICE_t *currSlice) 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"); READ_ONEBIT(p_bitctx, &pSlice->adaptive_ref_pic_buffering_flag, "adaptive_ref_pic_buffering_flag");
if (pSlice->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 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; tmp_drpm->Next = NULL;
READ_UE(p_bitctx, &val, "memory_management_control_operation"); READ_UE(p_bitctx, &val, "memory_management_control_operation");
tmp_drpm->memory_management_control_operation = val; 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; tmp_drpm2->Next = tmp_drpm;
} }
i++; i++;
} while (val != 0); } while (val != 0);
} }
} }
@@ -205,7 +205,7 @@ static MPP_RET dec_ref_pic_marking(H264_SLICE_t *pSlice)
__BITREAD_ERR: __BITREAD_ERR:
ret = p_bitctx->ret; ret = p_bitctx->ret;
return ret; return ret;
} }
static void init_slice_parmeters(H264_SLICE_t *currSlice) 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 //--- init slice syntax
currSlice->idr_flag = ((cur_nalu->nalu_type == NALU_TYPE_IDR) currSlice->idr_flag = ((cur_nalu->nalu_type == NALU_TYPE_IDR)
|| (currSlice->mvcExt.valid && !currSlice->mvcExt.non_idr_flag)); || (currSlice->mvcExt.valid && !currSlice->mvcExt.non_idr_flag));
currSlice->nal_reference_idc = cur_nalu->nal_reference_idc; currSlice->nal_reference_idc = cur_nalu->nal_reference_idc;
//!< set ref flag and dpb error flag //!< set ref flag and dpb error flag
{ {
p_Vid->p_Dec->errctx.used_ref_flag = currSlice->nal_reference_idc ? 1 : 0; p_Vid->p_Dec->errctx.used_ref_flag = currSlice->nal_reference_idc ? 1 : 0;
if (currSlice->slice_type == I_SLICE) { if (currSlice->slice_type == I_SLICE) {
p_Vid->p_Dec->errctx.dpb_err_flag = 0; p_Vid->p_Dec->errctx.dpb_err_flag = 0;
} }
} }
if ((!currSlice->svc_extension_flag) || currSlice->mvcExt.iPrefixNALU) { // MVC or have prefixNALU if ((!currSlice->svc_extension_flag) || currSlice->mvcExt.iPrefixNALU) { // MVC or have prefixNALU
currSlice->view_id = currSlice->mvcExt.view_id; currSlice->view_id = currSlice->mvcExt.view_id;
currSlice->inter_view_flag = currSlice->mvcExt.inter_view_flag; currSlice->inter_view_flag = currSlice->mvcExt.inter_view_flag;
@@ -373,21 +373,21 @@ __FAILED:
//extern "C" //extern "C"
MPP_RET reset_cur_slice(H264dCurCtx_t *p_Cur, H264_SLICE_t *p) MPP_RET reset_cur_slice(H264dCurCtx_t *p_Cur, H264_SLICE_t *p)
{ {
if (p) { if (p) {
p->modification_of_pic_nums_idc[LIST_0] = p_Cur->modification_of_pic_nums_idc[LIST_0]; 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->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->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->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->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->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->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->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; p_Vid->slice_type = currSlice->slice_type = temp % 5;
READ_UE(p_bitctx, &currSlice->pic_parameter_set_id, "slice_pic_parameter_set_id"); READ_UE(p_bitctx, &currSlice->pic_parameter_set_id, "slice_pic_parameter_set_id");
init_slice_parmeters(currSlice); init_slice_parmeters(currSlice);
FUN_CHECK(ret = set_slice_user_parmeters(currSlice)); FUN_CHECK(ret = set_slice_user_parmeters(currSlice));
//!< read rest slice header syntax //!< read rest slice header syntax
{ {
READ_BITS(p_bitctx, currSlice->active_sps->log2_max_frame_num_minus4 + 4, &currSlice->frame_num, "frame_num"); 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 if (currSlice->active_sps->frame_mbs_only_flag) { //!< user in_slice info
p_Vid->structure = FRAME; p_Vid->structure = FRAME;
currSlice->field_pic_flag = 0; currSlice->field_pic_flag = 0;
currSlice->bottom_field_flag = 0; currSlice->bottom_field_flag = 0;
} } else {
else { READ_ONEBIT(p_bitctx, &currSlice->field_pic_flag, "field_pic_flag");
READ_ONEBIT(p_bitctx, &currSlice->field_pic_flag, "field_pic_flag"); if (currSlice->field_pic_flag) {
if (currSlice->field_pic_flag) { READ_ONEBIT(p_bitctx, &currSlice->bottom_field_flag, "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;
p_Vid->structure = currSlice->bottom_field_flag ? BOTTOM_FIELD : TOP_FIELD; } else {
} p_Vid->structure = FRAME;
else { currSlice->bottom_field_flag = 0;
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));
currSlice->structure = p_Vid->structure; if (currSlice->idr_flag) {
currSlice->mb_aff_frame_flag = (currSlice->active_sps->mb_adaptive_frame_field_flag && (currSlice->field_pic_flag == 0)); READ_UE(p_bitctx, &currSlice->idr_pic_id, "idr_pic_id");
if (currSlice->idr_flag) { } else if (currSlice->svc_extension_flag == 0 && currSlice->mvcExt.non_idr_flag == 0) {
READ_UE(p_bitctx, &currSlice->idr_pic_id, "idr_pic_id"); READ_UE(p_bitctx, &currSlice->idr_pic_id, "idr_pic_id");
} }
else if (currSlice->svc_extension_flag == 0 && currSlice->mvcExt.non_idr_flag == 0) { poc_used_bits = p_bitctx->used_bits; //!< init poc used bits
READ_UE(p_bitctx, &currSlice->idr_pic_id, "idr_pic_id"); 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");
poc_used_bits = p_bitctx->used_bits; //!< init poc used bits if (currSlice->p_Vid->active_pps->bottom_field_pic_order_in_frame_present_flag == 1
if (currSlice->active_sps->pic_order_cnt_type == 0) { && !currSlice->field_pic_flag) {
READ_BITS(p_bitctx, currSlice->active_sps->log2_max_pic_order_cnt_lsb_minus4 + 4, &currSlice->pic_order_cnt_lsb, "pic_order_cnt_lsb"); READ_SE(p_bitctx, &currSlice->delta_pic_order_cnt_bottom, "delta_pic_order_cnt_bottom");
if (currSlice->p_Vid->active_pps->bottom_field_pic_order_in_frame_present_flag == 1 } else {
&& !currSlice->field_pic_flag) { currSlice->delta_pic_order_cnt_bottom = 0;
READ_SE(p_bitctx, &currSlice->delta_pic_order_cnt_bottom, "delta_pic_order_cnt_bottom"); }
} }
else { if (currSlice->active_sps->pic_order_cnt_type == 1) {
currSlice->delta_pic_order_cnt_bottom = 0; 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->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) { 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]"); READ_SE(p_bitctx, &currSlice->delta_pic_order_cnt[1], "delta_pic_order_cnt[1]");
} } else {
else { currSlice->delta_pic_order_cnt[1] = 0; //!< set to zero if not in stream
currSlice->delta_pic_order_cnt[1] = 0; //!< set to zero if not in stream }
} } else {
} currSlice->delta_pic_order_cnt[0] = 0;
else { currSlice->delta_pic_order_cnt[1] = 0;
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
}
currSlice->poc_used_bitlen = p_bitctx->used_bits - poc_used_bits; //!< calculate poc used bit length
//!< redundant_pic_cnt is missing here //!< 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 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) { 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)) { if (g_max_bytes < (p_bitctx->used_bits >> 3)) {
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", 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->slice_type, currSlice->layer_id, currSlice->active_sps->seq_parameter_set_id,
currSlice->active_pps->pic_parameter_set_id, currSlice->structure, currSlice->frame_num); currSlice->active_pps->pic_parameter_set_id, currSlice->structure, currSlice->frame_num);
} }
FunctionOut(logctx->parr[RUN_PARSE]); FunctionOut(logctx->parr[RUN_PARSE]);

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

@@ -27,7 +27,7 @@
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
MPP_RET process_slice(H264_SLICE_t *currSlice); 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) 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) { 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); mpp_log("[m2v]: resetFlag[%d] && picture_coding_type[%d] != I_TYPE", ctx->resetFlag, ctx->pic_head.picture_coding_type);
return MPP_NOK; return MPP_NOK;
@@ -1006,7 +1006,7 @@ MPP_RET m2vd_alloc_frame(M2VDParserContext *ctx)
ctx->frame_period = tmp_frame_period; 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) if (ctx->Group_start_Time < 0)
ctx->Group_start_Time = 0; ctx->Group_start_Time = 0;
ctx->PreGetFrameTime = pts; 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); 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++) { for (i = 0; i < 3; i++) {
if (s->refs[s->refidx[i]].ref != NULL) { if (s->refs[s->refidx[i]].ref != NULL) {
vp9d_dbg(VP9D_DBG_REF, "ref buf select %d", s->refs[s->refidx[i]].slot_index); vp9d_dbg(VP9D_DBG_REF, "ref buf select %d", s->refs[s->refidx[i]].slot_index);
} }
} }
// ref frame setup // ref frame setup
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
vp9d_dbg(VP9D_DBG_REF, "s->refreshrefmask = 0x%x", s->refreshrefmask); vp9d_dbg(VP9D_DBG_REF, "s->refreshrefmask = 0x%x", s->refreshrefmask);
res = 0; res = 0;
if (s->refreshrefmask & (1 << i)) { if (s->refreshrefmask & (1 << i)) {
if (s->refs[i].ref) if (s->refs[i].ref)
vp9_unref_frame(s, &s->refs[i]); vp9_unref_frame(s, &s->refs[i]);
vp9d_dbg(VP9D_DBG_REF, "update ref index in %d", i); vp9d_dbg(VP9D_DBG_REF, "update ref index in %d", i);
res = vp9_ref_frame(ctx, &s->refs[i], &s->frames[CUR_FRAME]); res = vp9_ref_frame(ctx, &s->refs[i], &s->frames[CUR_FRAME]);
} }
if (s->refs[i].ref) if (s->refs[i].ref)
vp9d_dbg(VP9D_DBG_REF, "s->refs[%d] = %d", i, s->refs[i].slot_index); vp9d_dbg(VP9D_DBG_REF, "s->refs[%d] = %d", i, s->refs[i].slot_index);
if (res < 0) if (res < 0)
return 0; return 0;
} }
return 0; return 0;
} }
@@ -1826,6 +1826,6 @@ void vp9_parser_update(Vp9CodecContext *ctx, void *count_info)
} }
} }
return; return;
} }

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

@@ -47,8 +47,8 @@ do {\
#define AVSD_DBG(level, fmt, ...)\ #define AVSD_DBG(level, fmt, ...)\
do {\ do {\
if (level & avsd_parse_debug)\ if (level & avsd_parse_debug)\
{ mpp_log(fmt, ## __VA_ARGS__); }\ { mpp_log(fmt, ## __VA_ARGS__); }\
} while (0) } while (0)
#ifdef INP_CHECK #ifdef INP_CHECK
@@ -58,9 +58,9 @@ do {\
#define INP_CHECK(ret, val, ...)\ #define INP_CHECK(ret, val, ...)\
do{\ do{\
if ((val)) {\ if ((val)) {\
ret = MPP_ERR_INIT; \ ret = MPP_ERR_INIT; \
AVSD_DBG(AVSD_DBG_WARNNING, "input empty(%d).\n", __LINE__); \ AVSD_DBG(AVSD_DBG_WARNNING, "input empty(%d).\n", __LINE__); \
goto __RETURN; \ goto __RETURN; \
}} while (0) }} while (0)
#ifdef MEM_CHECK #ifdef MEM_CHECK
#undef MEM_CHECK #undef MEM_CHECK
@@ -69,9 +69,9 @@ do{\
#define MEM_CHECK(ret, val, ...)\ #define MEM_CHECK(ret, val, ...)\
do{\ do{\
if(!(val)) {\ if(!(val)) {\
ret = MPP_ERR_MALLOC;\ ret = MPP_ERR_MALLOC;\
AVSD_DBG(AVSD_DBG_ERROR, "malloc buffer error(%d).\n", __LINE__); \ AVSD_DBG(AVSD_DBG_ERROR, "malloc buffer error(%d).\n", __LINE__); \
goto __FAILED; \ goto __FAILED; \
}} while (0) }} while (0)
#ifdef FUN_CHECK #ifdef FUN_CHECK
#undef FUN_CHECK #undef FUN_CHECK
@@ -80,8 +80,8 @@ do{\
#define FUN_CHECK(val)\ #define FUN_CHECK(val)\
do{\ do{\
if ((val) < 0) {\ if ((val) < 0) {\
AVSD_DBG(AVSD_DBG_WARNNING, "Function error(%d).\n", __LINE__); \ AVSD_DBG(AVSD_DBG_WARNNING, "Function error(%d).\n", __LINE__); \
goto __FAILED; \ goto __FAILED; \
}} while (0) }} 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); 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_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); 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++) { 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) { if (!task->status.curr_task_rdy) {
RK_S64 p_e, p_s,diff; RK_S64 p_e, p_s, diff;
p_s = mpp_time(); p_s = mpp_time();
parser_prepare(dec->parser, dec->mpp_pkt_in, task_dec); parser_prepare(dec->parser, dec->mpp_pkt_in, task_dec);
p_e = mpp_time(); p_e = mpp_time();
if(mpp_debug & MPP_TIMING){ if (mpp_debug & MPP_TIMING) {
diff = (p_e - p_s)/1000; diff = (p_e - p_s) / 1000;
if(diff > 15){ if (diff > 15) {
mpp_log("waring mpp prepare stream consume %lld big than 15ms ",diff); mpp_log("waring mpp prepare stream consume %lld big than 15ms ", diff);
} }
} }
if (0 == mpp_packet_get_length(dec->mpp_pkt_in)) { 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; HalDecTask *task_dec = &task_info.dec;
RK_S64 cur_deat = 0; RK_S64 cur_deat = 0;
RK_U64 dec_no = 0, total_time = 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(); p_s = mpp_time();
while (MPP_THREAD_RUNNING == hal->get_status()) { 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_slots_set_prop(dec->frame_slots, SLOTS_FRAME_INFO, frame);
mpp_frame_deinit(&frame); mpp_frame_deinit(&frame);
} break; } break;
case MPP_CODEC_GET_VPUMEM_USED_COUNT: { case MPP_CODEC_GET_VPUMEM_USED_COUNT: {
RK_S32 *p = (RK_S32 *)param; RK_S32 *p = (RK_S32 *)param;
*p = mpp_buf_slot_get_used_size(dec->frame_slots); *p = mpp_buf_slot_get_used_size(dec->frame_slots);
} break; } break;
default : { default : {
} break; } 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, ...)\ #define AVSD_HAL_DBG(level, fmt, ...)\
do {\ do {\
if (level & avsd_hal_debug)\ if (level & avsd_hal_debug)\
{ mpp_log(fmt, ## __VA_ARGS__); }\ { mpp_log(fmt, ## __VA_ARGS__); }\
} while (0) } while (0)
@@ -57,17 +57,17 @@ do {\
#define INP_CHECK(ret, val, ...)\ #define INP_CHECK(ret, val, ...)\
do{\ do{\
if ((val)) { \ if ((val)) { \
ret = MPP_ERR_INIT; \ ret = MPP_ERR_INIT; \
AVSD_HAL_DBG(AVSD_HAL_DBG_WARNNING, "input empty(%d).\n", __LINE__); \ AVSD_HAL_DBG(AVSD_HAL_DBG_WARNNING, "input empty(%d).\n", __LINE__); \
goto __RETURN; \ goto __RETURN; \
}} while (0) }} while (0)
typedef struct avsd_hal_ctx_t { typedef struct avsd_hal_ctx_t {
MppBufSlots frame_slots; MppBufSlots frame_slots;
MppBufSlots packet_slots; MppBufSlots packet_slots;
IOInterruptCB init_cb; IOInterruptCB init_cb;
} AvsdHalCtx_t; } AvsdHalCtx_t;

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

@@ -85,8 +85,8 @@ typedef union HalDecTaskFlag_t {
struct { struct {
RK_U32 eos : 1; RK_U32 eos : 1;
RK_U32 info_change : 1; RK_U32 info_change : 1;
RK_U32 had_error : 1; RK_U32 had_error : 1;
RK_U32 used_for_ref : 1; RK_U32 used_for_ref : 1;
}; };
} HalDecTaskFlag; } 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) 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) 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) 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 hal_avsd_init(void *decoder, MppHalCfg *cfg)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; 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); 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; p_hal = (AvsdHalCtx_t *)decoder;
memset(p_hal, 0, sizeof(AvsdHalCtx_t)); memset(p_hal, 0, sizeof(AvsdHalCtx_t));
p_hal->frame_slots = cfg->frame_slots; p_hal->frame_slots = cfg->frame_slots;
p_hal->packet_slots = cfg->packet_slots; p_hal->packet_slots = cfg->packet_slots;
//!< callback function to parser module //!< callback function to parser module
p_hal->init_cb = cfg->hal_int_cb; 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_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_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_LEN_ALIGN, avsd_len_align);
__RETURN: __RETURN:
AVSD_HAL_TRACE("Out."); AVSD_HAL_TRACE("Out.");
(void)decoder; (void)decoder;
(void)cfg; (void)cfg;
return ret = MPP_OK; return ret = MPP_OK;
@@ -97,7 +97,7 @@ MPP_RET hal_avsd_deinit(void *decoder)
AVSD_HAL_TRACE("In."); AVSD_HAL_TRACE("In.");
AVSD_HAL_TRACE("Out."); AVSD_HAL_TRACE("Out.");
(void)decoder; (void)decoder;
return ret = MPP_OK; return ret = MPP_OK;
} }
@@ -110,24 +110,24 @@ MPP_RET hal_avsd_deinit(void *decoder)
//extern "C" //extern "C"
MPP_RET hal_avsd_gen_regs(void *decoder, HalTaskInfo *task) MPP_RET hal_avsd_gen_regs(void *decoder, HalTaskInfo *task)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; 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); INP_CHECK(ret, NULL == decoder);
p_hal = (AvsdHalCtx_t *)decoder; p_hal = (AvsdHalCtx_t *)decoder;
if (p_hal->init_cb.callBack) { if (p_hal->init_cb.callBack) {
p_hal->init_cb.callBack(p_hal->init_cb.opaque, task); p_hal->init_cb.callBack(p_hal->init_cb.opaque, task);
} }
__RETURN: __RETURN:
AVSD_HAL_TRACE("Out."); AVSD_HAL_TRACE("Out.");
(void)decoder;
(void)decoder;
(void)task; (void)task;
return ret = MPP_OK; return ret = MPP_OK;
} }
@@ -143,10 +143,10 @@ MPP_RET hal_avsd_start(void *decoder, HalTaskInfo *task)
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
AVSD_HAL_TRACE("In."); AVSD_HAL_TRACE("In.");
INP_CHECK(ret, NULL == decoder); INP_CHECK(ret, NULL == decoder);
__RETURN: __RETURN:
AVSD_HAL_TRACE("Out."); AVSD_HAL_TRACE("Out.");
(void)decoder; (void)decoder;
(void)task; (void)task;
return ret = MPP_OK; return ret = MPP_OK;
@@ -161,19 +161,19 @@ __RETURN:
MPP_RET hal_avsd_wait(void *decoder, HalTaskInfo *task) MPP_RET hal_avsd_wait(void *decoder, HalTaskInfo *task)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; 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); INP_CHECK(ret, NULL == decoder);
//p_hal = (AvsdHalCtx_t *)decoder; //p_hal = (AvsdHalCtx_t *)decoder;
//if (p_hal->init_cb.callBack) { //if (p_hal->init_cb.callBack) {
// p_hal->init_cb.callBack(p_hal->init_cb.opaque, task); // p_hal->init_cb.callBack(p_hal->init_cb.opaque, task);
//} //}
__RETURN: __RETURN:
AVSD_HAL_TRACE("Out."); AVSD_HAL_TRACE("Out.");
(void)decoder; (void)decoder;
(void)task; (void)task;
return ret = MPP_OK; 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->frame_slots = cfg->frame_slots;
p_hal->packet_slots = cfg->packet_slots; p_hal->packet_slots = cfg->packet_slots;
//!< choose hard mode //!< choose hard mode
#ifdef RKPLATFORM #ifdef RKPLATFORM
{ {
RK_S32 value = (!!access("/dev/rkvdec", F_OK)); RK_S32 value = (!!access("/dev/rkvdec", F_OK));
cfg->device_id = value ? HAL_VDPU : HAL_RKVDEC; cfg->device_id = value ? HAL_VDPU : HAL_RKVDEC;
} }
#endif #endif
switch (cfg->device_id) { switch (cfg->device_id) {
case HAL_RKVDEC: case HAL_RKVDEC:

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

@@ -45,8 +45,7 @@
#define FPGA_TEST 0 #define FPGA_TEST 0
const enum const enum {
{
H264ScalingList4x4Length = 16, H264ScalingList4x4Length = 16,
H264ScalingList8x8Length = 64, H264ScalingList8x8Length = 64,
} ScalingListLength; } 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); INP_CHECK(ret, NULL == p_hal);
FunctionIn(p_hal->logctx.parr[RUN_HAL]); FunctionIn(p_hal->logctx.parr[RUN_HAL]);
if (task->dec.flags.had_error) { if (task->dec.flags.had_error) {
goto __RETURN; goto __RETURN;
} }
rkv_prepare_spspps_packet(hal, &pkts->spspps); rkv_prepare_spspps_packet(hal, &pkts->spspps);
rkv_prepare_framerps_packet(hal, &pkts->rps); rkv_prepare_framerps_packet(hal, &pkts->rps);
rkv_prepare_scanlist_packet(hal, &pkts->scanlist); 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); INP_CHECK(ret, NULL == p_hal);
FunctionIn(p_hal->logctx.parr[RUN_HAL]); FunctionIn(p_hal->logctx.parr[RUN_HAL]);
if (task->dec.flags.had_error) { if (task->dec.flags.had_error) {
goto __RETURN; goto __RETURN;
} }
p_regs = (RK_U32 *)p_hal->regs; p_regs = (RK_U32 *)p_hal->regs;
p_regs[64] = 0; 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); rkv_h264d_hal_dump(p_hal, H264D_DBG_GEN_REGS);
} }
} }
//!< current buffer slot fd //!< current buffer slot fd
H264D_DBG(H264D_DBG_DECOUT_INFO, "[DECOUT_INFO] decout_fd=0x%02x", p_regs[7]); H264D_DBG(H264D_DBG_DECOUT_INFO, "[DECOUT_INFO] decout_fd=0x%02x", p_regs[7]);
#ifdef RKPLATFORM #ifdef RKPLATFORM
if (VPUClientSendReg(p_hal->vpu_socket, (RK_U32 *)p_regs, DEC_RKV_REGISTERS)) { if (VPUClientSendReg(p_hal->vpu_socket, (RK_U32 *)p_regs, DEC_RKV_REGISTERS)) {
ret = MPP_ERR_VPUHW; ret = MPP_ERR_VPUHW;
H264D_ERR("H264 RKV FlushRegs fail. \n"); H264D_ERR("H264 RKV FlushRegs fail. \n");
} }
#endif #endif
FunctionOut(p_hal->logctx.parr[RUN_HAL]); FunctionOut(p_hal->logctx.parr[RUN_HAL]);
(void)task; (void)task;
@@ -421,22 +421,22 @@ MPP_RET rkv_h264d_wait(void *hal, HalTaskInfo *task)
FunctionIn(p_hal->logctx.parr[RUN_HAL]); FunctionIn(p_hal->logctx.parr[RUN_HAL]);
p_regs = (H264dRkvRegs_t *)p_hal->regs; p_regs = (H264dRkvRegs_t *)p_hal->regs;
if (task->dec.flags.had_error) { if (task->dec.flags.had_error) {
goto __SKIP_HARD; goto __SKIP_HARD;
} }
#ifdef RKPLATFORM #ifdef RKPLATFORM
RK_S32 wait_ret = -1; RK_S32 wait_ret = -1;
RK_S32 ret_len = 0, cur_deat = 0; RK_S32 ret_len = 0, cur_deat = 0;
VPU_CMD_TYPE ret_cmd = VPU_CMD_BUTT; VPU_CMD_TYPE ret_cmd = VPU_CMD_BUTT;
RK_S64 p_s,p_e; RK_S64 p_s, p_e;
p_s = mpp_time(); p_s = mpp_time();
wait_ret = VPUClientWaitResult(p_hal->vpu_socket, (RK_U32 *)p_hal->regs, DEC_RKV_REGISTERS, &ret_cmd, &ret_len); wait_ret = VPUClientWaitResult(p_hal->vpu_socket, (RK_U32 *)p_hal->regs, DEC_RKV_REGISTERS, &ret_cmd, &ret_len);
p_e = mpp_time(); p_e = mpp_time();
cur_deat = (p_e - p_s)/1000; cur_deat = (p_e - p_s) / 1000;
p_hal->total_time += cur_deat; p_hal->total_time += cur_deat;
p_hal->iDecodedNum++; p_hal->iDecodedNum++;
(void)wait_ret; (void)wait_ret;
#endif #endif
//!< dump registers //!< dump registers
{ {
H264dRkvErrDump_t *p_dump = (H264dRkvErrDump_t *)p_hal->dump; 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 wait_ret = -1;
RK_S32 ret_len = 0, cur_deat = 0; RK_S32 ret_len = 0, cur_deat = 0;
VPU_CMD_TYPE ret_cmd = VPU_CMD_BUTT; VPU_CMD_TYPE ret_cmd = VPU_CMD_BUTT;
RK_S64 p_s,p_e; RK_S64 p_s, p_e;
p_s = mpp_time(); p_s = mpp_time();
wait_ret = VPUClientWaitResult(p_hal->vpu_socket, p_drv->p_reg, DEC_X170_REGISTERS, &ret_cmd, &ret_len); wait_ret = VPUClientWaitResult(p_hal->vpu_socket, p_drv->p_reg, DEC_X170_REGISTERS, &ret_cmd, &ret_len);
p_e = mpp_time(); 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; int fd;
switch (type) { switch (type) {
case VPU_DEC_RKV: { case VPU_DEC_RKV: {
fd = open("/dev/rkvdec", O_RDWR); fd = open("/dev/rkvdec", O_RDWR);
type = VPU_DEC; type = VPU_DEC;
break; break;
} }
case VPU_DEC_HEVC: { case VPU_DEC_HEVC: {
fd = open("/dev/hevc_service", O_RDWR); fd = open("/dev/hevc_service", O_RDWR);
type = VPU_DEC; type = VPU_DEC;
break; break;
} }
case VPU_DEC_PP: case VPU_DEC_PP:
case VPU_PP: case VPU_PP:
case VPU_DEC: case VPU_DEC:
case VPU_ENC: { case VPU_ENC: {
fd = open("/dev/vpu_service", O_RDWR); fd = open("/dev/vpu_service", O_RDWR);
break; break;
} }
default: { default: {
fd = -1; fd = -1;
break; break;
} }
} }

6
mpp/legacy/vpu_api.cpp
View File

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

128
mpp/legacy/vpu_api_legacy.cpp
View File

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

2
mpp/legacy/vpu_api_legacy.h
View File

@@ -50,7 +50,7 @@ private:
RK_U32 set_eos; RK_U32 set_eos;
RK_U32 vpu_api_debug; RK_U32 vpu_api_debug;
FILE *fp; FILE *fp;
RK_U8 *fp_buf; RK_U8 *fp_buf;
}; };
#endif /*_VPU_API_H_*/ #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) { if (mPackets->list_size() < 4 || eos) {
MppPacket pkt; MppPacket pkt;
if (MPP_OK != mpp_packet_copy_init(&pkt, packet)) if (MPP_OK != mpp_packet_copy_init(&pkt, packet))
return MPP_NOK; return MPP_NOK;
mPackets->add_at_tail(&pkt, sizeof(pkt)); mPackets->add_at_tail(&pkt, sizeof(pkt));
mPacketPutCount++; mPacketPutCount++;
mThreadCodec->signal(); mThreadCodec->signal();
@@ -297,13 +297,13 @@ MPP_RET Mpp::control(MpiCmd cmd, MppParam param)
*((RK_S32 *)param) = mPackets->list_size(); *((RK_S32 *)param) = mPackets->list_size();
break; break;
} }
case MPP_CODEC_GET_VPUMEM_USED_COUNT: { case MPP_CODEC_GET_VPUMEM_USED_COUNT: {
AutoMutex autoLock(mPackets->mutex()); AutoMutex autoLock(mPackets->mutex());
if (mType == MPP_CTX_DEC) { if (mType == MPP_CTX_DEC) {
mpp_dec_control(mDec, cmd, param); mpp_dec_control(mDec, cmd, param);
} }
break; break;
} }
default : { default : {

649
mpp/test/avsd_test.c
View File

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

12
osal/inc/mpp_thread.h
View File

@@ -207,22 +207,26 @@ public:
void start(); void start();
void stop(); void stop();
void lock(MppThreadSignal id = THREAD_WORK) { void lock(MppThreadSignal id = THREAD_WORK)
{
mpp_assert(id < THREAD_SIGNAL_BUTT); mpp_assert(id < THREAD_SIGNAL_BUTT);
mMutexCond[id].lock(); mMutexCond[id].lock();
} }
void unlock(MppThreadSignal id = THREAD_WORK) { void unlock(MppThreadSignal id = THREAD_WORK)
{
mpp_assert(id < THREAD_SIGNAL_BUTT); mpp_assert(id < THREAD_SIGNAL_BUTT);
mMutexCond[id].unlock(); mMutexCond[id].unlock();
} }
void wait(MppThreadSignal id = THREAD_WORK) { void wait(MppThreadSignal id = THREAD_WORK)
{
mpp_assert(id < THREAD_SIGNAL_BUTT); mpp_assert(id < THREAD_SIGNAL_BUTT);
mMutexCond[id].wait(); mMutexCond[id].wait();
} }
void signal(MppThreadSignal id = THREAD_WORK) { void signal(MppThreadSignal id = THREAD_WORK)
{
mpp_assert(id < THREAD_SIGNAL_BUTT); mpp_assert(id < THREAD_SIGNAL_BUTT);
mMutexCond[id].signal(); 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"); mpp_err("os_allocator_get Linux MPP_BUFFER_TYPE_V4L2 do not implement yet\n");
*api = allocator_v4l2; *api = allocator_v4l2;
} break; } break;
case MPP_BUFFER_TYPE_DRM : { case MPP_BUFFER_TYPE_DRM : {
*api = allocator_drm; *api = allocator_drm;
} break; } break;
default : { default : {

6
osal/mpp_mem.cpp
View File

@@ -189,7 +189,7 @@ void mpp_show_mem_status()
pthread_mutex_lock(&mem_list_lock); pthread_mutex_lock(&mem_list_lock);
list_for_each_entry_safe(pos, n, &mem_list, struct mem_node, list) { list_for_each_entry_safe(pos, n, &mem_list, struct mem_node, list) {
mpp_log("unfree memory %p size %d tag %s index %llu", 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); pthread_mutex_unlock(&mem_list_lock);
} }
@@ -282,14 +282,14 @@ MPP_RET mpp_mem_squash_snapshot(MppMemSnapshot hnd0, MppMemSnapshot hnd1)
if (!found_match) { if (!found_match) {
mpp_log_f("snapshot0 %p found mismatch memory %p size %d tag %s index %llu", 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 */ /* handle 1 search */
list_for_each_entry_safe(pos1, n1, &p1->list, struct mem_node, list) { 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", 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); 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; const DWORD MS_VC_EXCEPTION = 0x406D1388;
#pragma pack(push,8) #pragma pack(push,8)
typedef struct tagTHREADNAME_INFO typedef struct tagTHREADNAME_INFO {
{
DWORD dwType; // Must be 0x1000. DWORD dwType; // Must be 0x1000.
LPCSTR szName; // Pointer to name (in user addr space). LPCSTR szName; // Pointer to name (in user addr space).
DWORD dwThreadID; // Thread ID (-1=caller thread). DWORD dwThreadID; // Thread ID (-1=caller thread).
DWORD dwFlags; // Reserved for future use, must be zero. DWORD dwFlags; // Reserved for future use, must be zero.
} THREADNAME_INFO; } THREADNAME_INFO;
#pragma pack(pop) #pragma pack(pop)
void SetThreadName(DWORD dwThreadID, const char* threadName) { void SetThreadName(DWORD dwThreadID, const char* threadName)
{
THREADNAME_INFO info; THREADNAME_INFO info;
info.dwType = 0x1000; info.dwType = 0x1000;
info.szName = threadName; info.szName = threadName;
@@ -112,10 +112,9 @@ void SetThreadName(DWORD dwThreadID, const char* threadName) {
info.dwFlags = 0; info.dwFlags = 0;
#pragma warning(push) #pragma warning(push)
#pragma warning(disable: 6320 6322) #pragma warning(disable: 6320 6322)
__try{ __try {
RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR), (ULONG_PTR*)&info); RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR), (ULONG_PTR*)&info);
} } __except (EXCEPTION_EXECUTE_HANDLER) {
__except (EXCEPTION_EXECUTE_HANDLER){
} }
#pragma warning(pop) #pragma warning(pop)
} }