diff --git a/inc/mpp_buffer.h b/inc/mpp_buffer.h index d0092514..899288de 100644 --- a/inc/mpp_buffer.h +++ b/inc/mpp_buffer.h @@ -149,7 +149,7 @@ typedef enum { MPP_BUFFER_TYPE_NORMAL, MPP_BUFFER_TYPE_ION, MPP_BUFFER_TYPE_V4L2, - MPP_BUFFER_TYPE_DRM, + MPP_BUFFER_TYPE_DRM, MPP_BUFFER_TYPE_BUTT, } MppBufferType; diff --git a/inc/rk_mpi.h b/inc/rk_mpi.h index a8d132ff..e2e0a7a8 100644 --- a/inc/rk_mpi.h +++ b/inc/rk_mpi.h @@ -73,7 +73,7 @@ typedef enum { MPP_CODEC_SET_INFO_CHANGE_READY, MPP_CODEC_SET_FRAME_INFO, MPP_CODEC_GET_FRAME_INFO, - MPP_CODEC_GET_VPUMEM_USED_COUNT, + MPP_CODEC_GET_VPUMEM_USED_COUNT, MPP_DEC_CMD_BASE = 0x40000, MPP_DEC_SET_EXT_BUF_GROUP, /* IMPORTANT: set external buffer group to mpp decoder */ diff --git a/inc/vpu_api.h b/inc/vpu_api.h index 1ee4a295..6e5f517e 100644 --- a/inc/vpu_api.h +++ b/inc/vpu_api.h @@ -57,7 +57,7 @@ typedef enum VPU_API_CMD { VPU_API_SET_INFO_CHANGE, VPU_API_USE_FAST_MODE, VPU_API_DEC_GET_STREAM_COUNT, - VPU_API_GET_VPUMEM_USED_COUNT, + VPU_API_GET_VPUMEM_USED_COUNT, } VPU_API_CMD; typedef struct { diff --git a/mpp/base/inc/mpp_bitread.h b/mpp/base/inc/mpp_bitread.h index 13af9078..3dd35bf2 100644 --- a/mpp/base/inc/mpp_bitread.h +++ b/mpp/base/inc/mpp_bitread.h @@ -34,96 +34,96 @@ typedef void (*LOG_FUN)(void *ctx, ...); #define READ_ONEBIT(bitctx, out, ...)\ - do {\ - RK_S32 _out; \ - bitctx->ret = mpp_read_bits(bitctx, 1, &_out); \ - BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \ - if (!bitctx->ret) { *out = _out; }\ - else { goto __BITREAD_ERR; }\ - } while (0) + do {\ + RK_S32 _out; \ + bitctx->ret = mpp_read_bits(bitctx, 1, &_out); \ + BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \ + if (!bitctx->ret) { *out = _out; }\ + else { goto __BITREAD_ERR; }\ + } while (0) #define READ_BITS(bitctx, num_bits, out, ...)\ do {\ - RK_S32 _out;\ - bitctx->ret = mpp_read_bits(bitctx, num_bits, &_out);\ - BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \ - if (!bitctx->ret) { *out = _out; }\ - else { goto __BITREAD_ERR;}\ - } while (0) + RK_S32 _out;\ + bitctx->ret = mpp_read_bits(bitctx, num_bits, &_out);\ + BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \ + if (!bitctx->ret) { *out = _out; }\ + else { goto __BITREAD_ERR;}\ + } while (0) #define READ_BITS_LONG(bitctx, num_bits, out, ...)\ - do {\ - RK_U32 _out; \ - bitctx->ret = mpp_read_longbits(bitctx, num_bits, &_out); \ - BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \ - if (!bitctx->ret) { *out = _out; }\ - else { goto __BITREAD_ERR; }\ - } while (0) + do {\ + RK_U32 _out; \ + bitctx->ret = mpp_read_longbits(bitctx, num_bits, &_out); \ + BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out); \ + if (!bitctx->ret) { *out = _out; }\ + else { goto __BITREAD_ERR; }\ + } while (0) #define SHOW_BITS(bitctx, num_bits, out)\ - do {\ - RK_S32 _out; \ - bitctx->ret = mpp_show_bits(bitctx, num_bits, &_out); \ - if (!bitctx->ret) { *out = _out; }\ - else { goto __BITREAD_ERR; }\ - } while (0) + do {\ + RK_S32 _out; \ + bitctx->ret = mpp_show_bits(bitctx, num_bits, &_out); \ + if (!bitctx->ret) { *out = _out; }\ + else { goto __BITREAD_ERR; }\ + } while (0) #define SHOW_BITS_LONG(bitctx, num_bits, out)\ - do {\ - RK_U32 _out; \ - bitctx->ret = mpp_show_longbits(bitctx, num_bits, &_out); \ - if (!bitctx->ret) { *out = _out; }\ - else { goto __BITREAD_ERR; }\ - } while (0) + do {\ + RK_U32 _out; \ + bitctx->ret = mpp_show_longbits(bitctx, num_bits, &_out); \ + if (!bitctx->ret) { *out = _out; }\ + else { goto __BITREAD_ERR; }\ + } while (0) #define SKIP_BITS(bitctx, num_bits)\ do {\ - bitctx->ret = mpp_skip_bits(bitctx, num_bits);\ - BitReadLog(bitctx, "%48s %d bits", "skip", num_bits);\ - if (bitctx->ret) { goto __BITREAD_ERR; }\ + bitctx->ret = mpp_skip_bits(bitctx, num_bits);\ + BitReadLog(bitctx, "%48s %d bits", "skip", num_bits);\ + if (bitctx->ret) { goto __BITREAD_ERR; }\ } while (0) #define SKIP_BITS_LONG(bitctx, num_bits)\ - do {\ - bitctx->ret = mpp_skip_longbits(bitctx, num_bits); \ - BitReadLog(bitctx, "%48s %d bits", "skip", num_bits); \ - if (bitctx->ret) { goto __BITREAD_ERR; }\ - } while (0) + do {\ + bitctx->ret = mpp_skip_longbits(bitctx, num_bits); \ + BitReadLog(bitctx, "%48s %d bits", "skip", num_bits); \ + if (bitctx->ret) { goto __BITREAD_ERR; }\ + } while (0) #define READ_UE(bitctx, out, ...)\ do {\ - RK_U32 _out;\ - bitctx->ret = mpp_read_ue(bitctx, &_out);\ - BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out);\ - if (!bitctx->ret) { *out = _out; }\ - else { goto __BITREAD_ERR;}\ + RK_U32 _out;\ + bitctx->ret = mpp_read_ue(bitctx, &_out);\ + BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out);\ + if (!bitctx->ret) { *out = _out; }\ + else { goto __BITREAD_ERR;}\ } while (0) #define READ_SE(bitctx, out, ...)\ do {\ - RK_S32 _out;\ - bitctx->ret = mpp_read_se(bitctx, &_out);\ - BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out);\ - if (!bitctx->ret) { *out = _out; }\ - else { goto __BITREAD_ERR;}\ + RK_S32 _out;\ + bitctx->ret = mpp_read_se(bitctx, &_out);\ + BitReadLog(bitctx, "%48s = %10d", ##__VA_ARGS__, _out);\ + if (!bitctx->ret) { *out = _out; }\ + else { goto __BITREAD_ERR;}\ } while (0) #define CHECK_RANGE(bitctx, val, _min, _max)\ do {\ - if ((val) < (_min) || (val) > (_max)) {\ - mpp_log("%d[%d,%d]", val, _min, _max);\ - bitctx->ret = MPP_ERR_VALUE;\ - goto __BITREAD_ERR;\ - }\ + if ((val) < (_min) || (val) > (_max)) {\ + mpp_log("%d[%d,%d]", val, _min, _max);\ + bitctx->ret = MPP_ERR_VALUE;\ + goto __BITREAD_ERR;\ + }\ } while (0) #define CHECK_ERROR(bitctx, val)\ do {\ - if (!(val)) {\ - mpp_log("value false");\ - bitctx->ret = MPP_ERR_VALUE;\ - goto __BITREAD_ERR;\ - }\ + if (!(val)) {\ + mpp_log("value false");\ + bitctx->ret = MPP_ERR_VALUE;\ + goto __BITREAD_ERR;\ + }\ } while (0) typedef struct bitread_ctx_t { diff --git a/mpp/base/mpp_buf_slot.cpp b/mpp/base/mpp_buf_slot.cpp index 4953cc9e..2925eca6 100644 --- a/mpp/base/mpp_buf_slot.cpp +++ b/mpp/base/mpp_buf_slot.cpp @@ -631,22 +631,22 @@ size_t mpp_buf_slot_get_size(MppBufSlots slots) RK_S32 mpp_buf_slot_get_used_size(MppBufSlots slots) { - if (NULL == slots) { - mpp_err_f("found NULL input\n"); - return 0; - } - MppBufSlotsImpl *impl = (MppBufSlotsImpl *)slots; - AutoMutex auto_lock(impl->lock); - RK_S32 i; - RK_S32 used_size = 0; - MppBufSlotEntry *slot = impl->slots; - for (i = 0; i < impl->buf_count; i++, slot++) { - if (slot->status.on_used) { - buf_slot_dbg(BUF_SLOT_DBG_BUF_UESD, "[BUF_USED] buf_fd=%08x", mpp_buffer_get_fd(slot->buffer)); - used_size++; - } - } - return used_size; + if (NULL == slots) { + mpp_err_f("found NULL input\n"); + return 0; + } + MppBufSlotsImpl *impl = (MppBufSlotsImpl *)slots; + AutoMutex auto_lock(impl->lock); + RK_S32 i; + RK_S32 used_size = 0; + MppBufSlotEntry *slot = impl->slots; + for (i = 0; i < impl->buf_count; i++, slot++) { + if (slot->status.on_used) { + buf_slot_dbg(BUF_SLOT_DBG_BUF_UESD, "[BUF_USED] buf_fd=%08x", mpp_buffer_get_fd(slot->buffer)); + used_size++; + } + } + return used_size; } MPP_RET mpp_buf_slot_get_unused(MppBufSlots slots, RK_S32 *index) diff --git a/mpp/base/mpp_buffer_impl.cpp b/mpp/base/mpp_buffer_impl.cpp index 68e71b29..c6163e1e 100644 --- a/mpp/base/mpp_buffer_impl.cpp +++ b/mpp/base/mpp_buffer_impl.cpp @@ -104,7 +104,7 @@ static const char *type2str[MPP_BUFFER_TYPE_BUTT] = { "normal", "ion", "v4l2", - "drm", + "drm", }; static const char *ops2str[BUF_OPS_BUTT] = { "grp create ", @@ -284,7 +284,7 @@ MPP_RET mpp_buffer_create(const char *tag, const char *caller, RK_U32 group_id, group->buffer_count++; group->count_unused++; - buffer_group_add_log(group, p, (group->mode == MPP_BUFFER_INTERNAL)?(BUF_CREATE):(BUF_COMMIT)); + buffer_group_add_log(group, p, (group->mode == MPP_BUFFER_INTERNAL) ? (BUF_CREATE) : (BUF_COMMIT)); RET: MPP_BUF_FUNCTION_LEAVE(); return ret; @@ -526,7 +526,7 @@ RK_U32 MppBufferService::get_group_id() { // avoid group_id reuse RK_U32 id = group_id++; - while (get_group_by_id(group_id)){ + while (get_group_by_id(group_id)) { group_id++; } group_count++; @@ -534,7 +534,7 @@ RK_U32 MppBufferService::get_group_id() } MppBufferGroupImpl *MppBufferService::get_group(const char *tag, const char *caller, - MppBufferMode mode, MppBufferType type) + MppBufferMode mode, MppBufferType type) { MppBufferGroupImpl *p = mpp_calloc(MppBufferGroupImpl, 1); if (NULL == p) { @@ -631,7 +631,7 @@ void MppBufferService::destroy_group(MppBufferGroupImpl *group) mpp_assert(group->count_unused == 0); if (group->count_unused || group->count_used) { mpp_err("mpp_buffer_group_deinit mismatch counter used %4d unused %4d found\n", - group->count_used, group->count_unused); + group->count_used, group->count_unused); group->count_unused = 0; group->count_used = 0; } diff --git a/mpp/codec/dec/avs/avsd_api.c b/mpp/codec/dec/avs/avsd_api.c index 46881834..3f716e5f 100644 --- a/mpp/codec/dec/avs/avsd_api.c +++ b/mpp/codec/dec/avs/avsd_api.c @@ -573,51 +573,51 @@ MPP_RET avsd_callback(void *decoder, void *info) #else MPP_RET avsd_deinit(void *decoder) { - (void)decoder; - return MPP_OK; + (void)decoder; + return MPP_OK; } MPP_RET avsd_init(void *decoder, ParserCfg *init) { - (void)decoder; - (void)init; - return MPP_OK; + (void)decoder; + (void)init; + return MPP_OK; } MPP_RET avsd_prepare(void *decoder, MppPacket pkt, HalDecTask *task) { - (void)decoder; - (void)pkt; - (void)task; - return MPP_OK; + (void)decoder; + (void)pkt; + (void)task; + return MPP_OK; } MPP_RET avsd_parse(void *decoder, HalDecTask *task) { - (void)decoder; - (void)task; - return MPP_OK; + (void)decoder; + (void)task; + return MPP_OK; } MPP_RET avsd_reset(void *decoder) { - (void)decoder; - return MPP_OK; + (void)decoder; + return MPP_OK; } MPP_RET avsd_flush(void *decoder) { - (void)decoder; - return MPP_OK; + (void)decoder; + return MPP_OK; } MPP_RET avsd_control(void *decoder, RK_S32 cmd_type, void *param) { - (void)decoder; - (void)cmd_type; - (void)param; - return MPP_OK; + (void)decoder; + (void)cmd_type; + (void)param; + return MPP_OK; } MPP_RET avsd_callback(void *decoder, void *info) { - (void)decoder; - (void)info; - return MPP_OK; + (void)decoder; + (void)info; + return MPP_OK; } #endif /*! diff --git a/mpp/codec/dec/avs/avsd_parse.c b/mpp/codec/dec/avs/avsd_parse.c index 9ba89f54..c399ea13 100644 --- a/mpp/codec/dec/avs/avsd_parse.c +++ b/mpp/codec/dec/avs/avsd_parse.c @@ -36,61 +36,61 @@ static void reset_curstream(AvsdCurStream_t *p_strm) { - p_strm->p_start = NULL; - p_strm->len = 0; - p_strm->got_frame_flag = 0; - p_strm->got_nalu_flag = 0; + p_strm->p_start = NULL; + p_strm->len = 0; + p_strm->got_frame_flag = 0; + p_strm->got_nalu_flag = 0; } static MPP_RET add_nalu_header(AvsdCurCtx_t *p_cur) { - MPP_RET ret = MPP_ERR_UNKNOW; + MPP_RET ret = MPP_ERR_UNKNOW; - RK_U32 add_size = sizeof(AvsdNalu_t); - AvsdBitstream_t *p_bitstream = p_cur->p_dec->bitstream; + RK_U32 add_size = sizeof(AvsdNalu_t); + AvsdBitstream_t *p_bitstream = p_cur->p_dec->bitstream; - if ((p_bitstream->offset + add_size) > p_bitstream->size) { - AVSD_DBG(AVSD_DBG_ERROR, "error, head_offset is larger than %d", p_bitstream->size); - goto __FAILED; - } - p_cur->cur_nalu = (AvsdNalu_t *)&p_bitstream->pbuf[p_bitstream->offset]; - p_cur->cur_nalu->eof = 1; - p_cur->cur_nalu->header = 0; - p_cur->cur_nalu->pdata = NULL; - p_cur->cur_nalu->length = 0; - p_cur->cur_nalu->start_pos = 0; - p_bitstream->offset += add_size; + if ((p_bitstream->offset + add_size) > p_bitstream->size) { + AVSD_DBG(AVSD_DBG_ERROR, "error, head_offset is larger than %d", p_bitstream->size); + goto __FAILED; + } + p_cur->cur_nalu = (AvsdNalu_t *)&p_bitstream->pbuf[p_bitstream->offset]; + p_cur->cur_nalu->eof = 1; + p_cur->cur_nalu->header = 0; + p_cur->cur_nalu->pdata = NULL; + p_cur->cur_nalu->length = 0; + p_cur->cur_nalu->start_pos = 0; + p_bitstream->offset += add_size; - (void)p_cur; - return ret = MPP_OK; + (void)p_cur; + return ret = MPP_OK; __FAILED: - return ret; + return ret; } static MPP_RET store_cur_nalu(AvsdCurCtx_t *p_cur, AvsdCurStream_t *p_strm) { - MPP_RET ret = MPP_ERR_UNKNOW; + MPP_RET ret = MPP_ERR_UNKNOW; - AvsdNalu_t *p_nalu = p_cur->cur_nalu; - AvsdBitstream_t *p_bitstream = p_cur->p_dec->bitstream; + AvsdNalu_t *p_nalu = p_cur->cur_nalu; + AvsdBitstream_t *p_bitstream = p_cur->p_dec->bitstream; - //!< fill bitstream buffer - RK_U32 add_size = p_strm->len; + //!< fill bitstream buffer + RK_U32 add_size = p_strm->len; - if ((p_bitstream->offset + add_size) > p_bitstream->size) { - AVSD_DBG(AVSD_DBG_ERROR, "error, head_offset is larger than %d", p_bitstream->size); - goto __FAILED; - } - p_nalu->length += p_strm->len; - p_nalu->pdata = &p_bitstream->pbuf[p_bitstream->offset]; - memcpy(p_nalu->pdata, p_strm->p_start, p_strm->len); - p_bitstream->offset += add_size; + if ((p_bitstream->offset + add_size) > p_bitstream->size) { + AVSD_DBG(AVSD_DBG_ERROR, "error, head_offset is larger than %d", p_bitstream->size); + goto __FAILED; + } + p_nalu->length += p_strm->len; + p_nalu->pdata = &p_bitstream->pbuf[p_bitstream->offset]; + memcpy(p_nalu->pdata, p_strm->p_start, p_strm->len); + p_bitstream->offset += add_size; - return ret = MPP_OK; + return ret = MPP_OK; __FAILED: - return ret; + return ret; } /*! @@ -103,108 +103,108 @@ __FAILED: MPP_RET avsd_parse_prepare(AvsdInputCtx_t *p_inp, AvsdCurCtx_t *p_cur) { - MPP_RET ret = MPP_ERR_UNKNOW; - RK_U8 *p_curdata = NULL; + MPP_RET ret = MPP_ERR_UNKNOW; + RK_U8 *p_curdata = NULL; - HalDecTask *in_task = p_inp->in_task; - MppPacket *in_pkt = p_inp->in_pkt; - MppPacketImpl *pkt_impl = (MppPacketImpl *)p_inp->in_pkt; - AvsdCurStream_t *p_strm = &p_cur->m_strm; - AvsdBitstream_t *p_bitstream = p_cur->p_dec->bitstream; + HalDecTask *in_task = p_inp->in_task; + MppPacket *in_pkt = p_inp->in_pkt; + MppPacketImpl *pkt_impl = (MppPacketImpl *)p_inp->in_pkt; + AvsdCurStream_t *p_strm = &p_cur->m_strm; + AvsdBitstream_t *p_bitstream = p_cur->p_dec->bitstream; - AVSD_PARSE_TRACE("In."); - //!< check input - if (!mpp_packet_get_length(in_pkt)) { - AVSD_DBG(AVSD_DBG_WARNNING, "input have no stream."); - goto __RETURN; - } + AVSD_PARSE_TRACE("In."); + //!< check input + if (!mpp_packet_get_length(in_pkt)) { + AVSD_DBG(AVSD_DBG_WARNNING, "input have no stream."); + goto __RETURN; + } - in_task->valid = 0; - in_task->flags.eos = 0; + in_task->valid = 0; + in_task->flags.eos = 0; - //!< check eos - if (mpp_packet_get_eos(in_pkt)) { - FUN_CHECK(ret = add_nalu_header(p_cur)); - in_task->valid = 1; - in_task->flags.eos = 1; - AVSD_DBG(AVSD_DBG_LOG, "end of stream."); - goto __RETURN; - } + //!< check eos + if (mpp_packet_get_eos(in_pkt)) { + FUN_CHECK(ret = add_nalu_header(p_cur)); + in_task->valid = 1; + in_task->flags.eos = 1; + AVSD_DBG(AVSD_DBG_LOG, "end of stream."); + goto __RETURN; + } - p_strm->p_start = p_curdata = (RK_U8 *)mpp_packet_get_pos(p_inp->in_pkt); - while (pkt_impl->length > 0) { - //!< found next picture start code - if (((*p_curdata) == I_PICTURE_START_CODE) - || ((*p_curdata) == PB_PICTURE_START_CODE)) { - if (p_strm->got_frame_flag) { - FUN_CHECK(ret = add_nalu_header(p_cur)); - in_task->valid = 1; - pkt_impl->length += START_PREFIX_3BYTE; - p_bitstream->len = p_bitstream->offset; - //!< reset value - p_bitstream->offset = 0; - reset_curstream(p_strm); - break; - } - p_strm->got_frame_flag = 1; - } - //!< found next nalu start code - p_strm->prefixdata = (p_strm->prefixdata << 8) | (*p_curdata); - if ((p_strm->prefixdata & 0xFFFFFF00) == 0x00000100) { - if (p_strm->got_nalu_flag) { - p_strm->len = (RK_U32)(p_curdata - p_strm->p_start) - START_PREFIX_3BYTE; - FUN_CHECK(ret = store_cur_nalu(p_cur, p_strm)); - FPRINT(p_cur->p_inp->fp_log, "g_nalu_no=%d, length=%d, header=0x%02x \n", g_nalu_no++, p_cur->cur_nalu->length, p_cur->cur_nalu->header); + p_strm->p_start = p_curdata = (RK_U8 *)mpp_packet_get_pos(p_inp->in_pkt); + while (pkt_impl->length > 0) { + //!< found next picture start code + if (((*p_curdata) == I_PICTURE_START_CODE) + || ((*p_curdata) == PB_PICTURE_START_CODE)) { + if (p_strm->got_frame_flag) { + FUN_CHECK(ret = add_nalu_header(p_cur)); + in_task->valid = 1; + pkt_impl->length += START_PREFIX_3BYTE; + p_bitstream->len = p_bitstream->offset; + //!< reset value + p_bitstream->offset = 0; + reset_curstream(p_strm); + break; + } + p_strm->got_frame_flag = 1; + } + //!< found next nalu start code + p_strm->prefixdata = (p_strm->prefixdata << 8) | (*p_curdata); + if ((p_strm->prefixdata & 0xFFFFFF00) == 0x00000100) { + if (p_strm->got_nalu_flag) { + p_strm->len = (RK_U32)(p_curdata - p_strm->p_start) - START_PREFIX_3BYTE; + FUN_CHECK(ret = store_cur_nalu(p_cur, p_strm)); + FPRINT(p_cur->p_inp->fp_log, "g_nalu_no=%d, length=%d, header=0x%02x \n", g_nalu_no++, p_cur->cur_nalu->length, p_cur->cur_nalu->header); - } - FUN_CHECK(ret = add_nalu_header(p_cur)); - p_cur->cur_nalu->header = (*p_curdata); - p_cur->cur_nalu->eof = 0; - p_cur->cur_nalu->start_pos = START_PREFIX_3BYTE; + } + FUN_CHECK(ret = add_nalu_header(p_cur)); + p_cur->cur_nalu->header = (*p_curdata); + p_cur->cur_nalu->eof = 0; + p_cur->cur_nalu->start_pos = START_PREFIX_3BYTE; - p_strm->p_start = p_curdata - START_PREFIX_3BYTE; - p_strm->got_nalu_flag = 1; - } - p_curdata++; - pkt_impl->length--; - } - if (!pkt_impl->length) { - p_strm->len = (RK_U32)(p_curdata - p_strm->p_start) - 1; - FUN_CHECK(ret = store_cur_nalu(p_cur, p_strm)); - } + p_strm->p_start = p_curdata - START_PREFIX_3BYTE; + p_strm->got_nalu_flag = 1; + } + p_curdata++; + pkt_impl->length--; + } + if (!pkt_impl->length) { + p_strm->len = (RK_U32)(p_curdata - p_strm->p_start) - 1; + FUN_CHECK(ret = store_cur_nalu(p_cur, p_strm)); + } __RETURN: - AVSD_PARSE_TRACE("Out."); + AVSD_PARSE_TRACE("Out."); - return ret = MPP_OK; + return ret = MPP_OK; __FAILED: - return ret; + return ret; } #else MPP_RET avsd_parse_prepare(AvsdInputCtx_t *p_inp, AvsdCurCtx_t *p_cur) { - RK_S32 ret_val = 0; - MPP_RET ret = MPP_ERR_UNKNOW; + RK_S32 ret_val = 0; + MPP_RET ret = MPP_ERR_UNKNOW; - Avs_DecCtx_t *p_dec = p_inp->p_dec; - HalDecTask *in_task = p_inp->in_task; + Avs_DecCtx_t *p_dec = p_inp->p_dec; + HalDecTask *in_task = p_inp->in_task; - AVSD_PARSE_TRACE("In."); + AVSD_PARSE_TRACE("In."); - in_task->input_packet = p_dec->task_pkt; - ret_val = lib_avsd_prepare(p_dec->libdec, - (RK_U8 *)mpp_packet_get_pos(p_inp->in_pkt), (RK_S32)mpp_packet_get_length(p_inp->in_pkt)); - if (ret_val < 0) { - goto __FAILED; - } - in_task->valid = 1; - mpp_packet_set_length(p_inp->in_pkt, 0); + in_task->input_packet = p_dec->task_pkt; + ret_val = lib_avsd_prepare(p_dec->libdec, + (RK_U8 *)mpp_packet_get_pos(p_inp->in_pkt), (RK_S32)mpp_packet_get_length(p_inp->in_pkt)); + if (ret_val < 0) { + goto __FAILED; + } + in_task->valid = 1; + mpp_packet_set_length(p_inp->in_pkt, 0); - AVSD_PARSE_TRACE("Out."); - (void)p_cur; - return ret = MPP_OK; + AVSD_PARSE_TRACE("Out."); + (void)p_cur; + return ret = MPP_OK; __FAILED: - return ret; + return ret; } #endif diff --git a/mpp/codec/dec/avs/avsd_parse.h b/mpp/codec/dec/avs/avsd_parse.h index ec6a21d5..e02a58c0 100644 --- a/mpp/codec/dec/avs/avsd_parse.h +++ b/mpp/codec/dec/avs/avsd_parse.h @@ -50,93 +50,91 @@ //!< input parameter typedef struct avsd_input_ctx_t { - FILE *fp_log; + FILE *fp_log; - ParserCfg init; - MppPacket in_pkt; - HalDecTask *in_task; + ParserCfg init; + MppPacket in_pkt; + HalDecTask *in_task; - RK_S64 in_pts; - RK_S64 in_dts; + RK_S64 in_pts; + RK_S64 in_dts; - RK_U8 has_get_eos; - RK_U64 pkt_no; - struct avsd_cur_ctx_t *p_cur; - struct avsd_video_ctx_t *p_vid; - struct avs_dec_ctx_t *p_dec; + RK_U8 has_get_eos; + RK_U64 pkt_no; + struct avsd_cur_ctx_t *p_cur; + struct avsd_video_ctx_t *p_vid; + struct avs_dec_ctx_t *p_dec; } AvsdInputCtx_t; //!< current stream typedef struct avsd_cur_strm_t { - RK_U8 *p_start; //!< store read nalu data - RK_U32 len; + RK_U8 *p_start; //!< store read nalu data + RK_U32 len; - RK_U32 prefixdata; + RK_U32 prefixdata; - RK_U8 got_frame_flag; - RK_U8 got_nalu_flag; + RK_U8 got_frame_flag; + RK_U8 got_nalu_flag; } AvsdCurStream_t; -typedef struct avsd_nalu_t -{ - RK_U8 header; - RK_U8 *pdata; - RK_U32 size; - RK_U32 length; - RK_U8 start_pos; - RK_U8 eof; //!< end of frame stream -}AvsdNalu_t; +typedef struct avsd_nalu_t { + RK_U8 header; + RK_U8 *pdata; + RK_U32 size; + RK_U32 length; + RK_U8 start_pos; + RK_U8 eof; //!< end of frame stream +} AvsdNalu_t; //!< current parameters typedef struct avsd_cur_ctx_t { - struct avsd_cur_strm_t m_strm; - struct avsd_nalu_t *cur_nalu; //!< current nalu + struct avsd_cur_strm_t m_strm; + struct avsd_nalu_t *cur_nalu; //!< current nalu - struct avsd_input_ctx_t *p_inp; - struct avsd_video_ctx_t *p_vid; - struct avs_dec_ctx_t *p_dec; + struct avsd_input_ctx_t *p_inp; + struct avsd_video_ctx_t *p_vid; + struct avs_dec_ctx_t *p_dec; } AvsdCurCtx_t; //!< decoder parameters typedef struct avsd_video_ctx_t { - struct img_par *img; + struct img_par *img; - struct avsd_input_ctx_t *p_inp; - struct avsd_cur_ctx_t *p_cur; - struct avs_dec_ctx_t *p_dec; -}AvsdVideoCtx_t; + struct avsd_input_ctx_t *p_inp; + struct avsd_cur_ctx_t *p_cur; + struct avs_dec_ctx_t *p_dec; +} AvsdVideoCtx_t; typedef struct avsd_bitstream_t { - RK_U8 *pbuf; - RK_U32 size; - RK_U32 len; - RK_U32 offset; //!< start from the offset byte -}AvsdBitstream_t; + RK_U8 *pbuf; + RK_U32 size; + RK_U32 len; + RK_U32 offset; //!< start from the offset byte +} AvsdBitstream_t; -typedef struct avsd_outframe_t -{ - RK_S32 nWidth; - RK_S32 nHeight; - RK_U8 *data[4]; // Y U V data - RK_S32 stride[4]; // Y U V stride - RK_S32 corp[2]; // crop_right crop_bottom - RK_S32 hor_stride; - RK_S32 ver_stride; - RK_S32 nFrameType; // 0I 1P 2B - RK_S32 nBitrate; - RK_S32 nFrameCoded; - RK_S32 nTopFieldFirst; - RK_S32 nFrameIndex; +typedef struct avsd_outframe_t { + RK_S32 nWidth; + RK_S32 nHeight; + RK_U8 *data[4]; // Y U V data + RK_S32 stride[4]; // Y U V stride + RK_S32 corp[2]; // crop_right crop_bottom + RK_S32 hor_stride; + RK_S32 ver_stride; + RK_S32 nFrameType; // 0I 1P 2B + RK_S32 nBitrate; + RK_S32 nFrameCoded; + RK_S32 nTopFieldFirst; + RK_S32 nFrameIndex; } AvsdOutframe_t; typedef struct avsd_memory_t { - struct avsd_bitstream_t bitstream; - struct avsd_outframe_t outframe; + struct avsd_bitstream_t bitstream; + struct avsd_outframe_t outframe; } AvsdMemory_t; @@ -145,52 +143,52 @@ typedef struct avsd_memory_t { //!< decoder parameters typedef struct avs_dec_ctx_t { - MppBufSlots frame_slots; - MppBufSlots packet_slots; + MppBufSlots frame_slots; + MppBufSlots packet_slots; - MppPacket task_pkt; - struct avsd_memory_t *mem; //!< resotre slice data to decoder - struct avsd_bitstream_t *bitstream; + MppPacket task_pkt; + struct avsd_memory_t *mem; //!< resotre slice data to decoder + struct avsd_bitstream_t *bitstream; - struct avsd_input_ctx_t *p_inp; - struct avsd_cur_ctx_t *p_cur; - struct avsd_video_ctx_t *p_vid; - //!< use in libavs.so - void *libdec; - struct avsd_outframe_t *outframe; + struct avsd_input_ctx_t *p_inp; + struct avsd_cur_ctx_t *p_cur; + struct avsd_video_ctx_t *p_vid; + //!< use in libavs.so + void *libdec; + struct avsd_outframe_t *outframe; - RK_U32 dec_no; + RK_U32 dec_no; - RK_U32 prepare_no; - RK_U32 parse_no; - RK_U32 decode_no; - RK_U32 nvcopy_no; + RK_U32 prepare_no; + RK_U32 parse_no; + RK_U32 decode_no; + RK_U32 nvcopy_no; - RK_S64 prepare_time; - RK_S64 parse_time; + RK_S64 prepare_time; + RK_S64 parse_time; - RK_S64 read_slice_header_time; - RK_S64 init_arideco_slice_time; + RK_S64 read_slice_header_time; + RK_S64 init_arideco_slice_time; - RK_S64 start_marcoblock_time; - RK_S64 read_marcoblock_time; + RK_S64 start_marcoblock_time; + RK_S64 read_marcoblock_time; - RK_S64 get_block_time; - RK_S64 inter_pred_block_time; - RK_S64 intra_pred_block_time; - RK_S64 idc_dequaut_time; - RK_S64 decode_marcoblock_time; - RK_S64 deblock_time; + RK_S64 get_block_time; + RK_S64 inter_pred_block_time; + RK_S64 intra_pred_block_time; + RK_S64 idc_dequaut_time; + RK_S64 decode_marcoblock_time; + RK_S64 deblock_time; - RK_S64 decode_init_time; - RK_S64 decode_data_time; - RK_S64 decode_update_time; - RK_S64 frame_post_time; + RK_S64 decode_init_time; + RK_S64 decode_data_time; + RK_S64 decode_update_time; + RK_S64 frame_post_time; - RK_S64 decode_frame_time; + RK_S64 decode_frame_time; - RK_S64 nvcopy_time; + RK_S64 nvcopy_time; } Avs_DecCtx_t; diff --git a/mpp/codec/dec/h264/h264d_api.c b/mpp/codec/dec/h264/h264d_api.c index e7133430..74259a7d 100644 --- a/mpp/codec/dec/h264/h264d_api.c +++ b/mpp/codec/dec/h264/h264d_api.c @@ -138,8 +138,8 @@ static MPP_RET free_input_ctx(H264dInputCtx_t *p_Inp) INP_CHECK(ret, !p_Inp); FunctionIn(p_Inp->p_Dec->logctx.parr[RUN_PARSE]); - close_stream_file(p_Inp); - MPP_FREE(p_Inp->spspps_buf); + close_stream_file(p_Inp); + MPP_FREE(p_Inp->spspps_buf); FunctionOut(p_Inp->p_Dec->logctx.parr[RUN_PARSE]); __RETURN: @@ -154,18 +154,18 @@ static MPP_RET init_input_ctx(H264dInputCtx_t *p_Inp, ParserCfg *init) p_Inp->init = *init; mpp_env_get_u32("rkv_h264d_mvc_disable", &p_Inp->mvc_disable, 1); - open_stream_file(p_Inp, "/sdcard"); - if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) { - p_Inp->spspps_size = HEAD_BUF_MAX_SIZE; - p_Inp->spspps_buf = mpp_malloc_size(RK_U8, p_Inp->spspps_size); - MEM_CHECK(ret, p_Inp->spspps_buf); - } + open_stream_file(p_Inp, "/sdcard"); + if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) { + p_Inp->spspps_size = HEAD_BUF_MAX_SIZE; + p_Inp->spspps_buf = mpp_malloc_size(RK_U8, p_Inp->spspps_size); + MEM_CHECK(ret, p_Inp->spspps_buf); + } FunctionOut(p_Inp->p_Dec->logctx.parr[RUN_PARSE]); __RETURN: return ret = MPP_OK; __FAILED: - free_input_ctx(p_Inp); - return ret; + free_input_ctx(p_Inp); + return ret; } @@ -198,8 +198,8 @@ static MPP_RET init_cur_ctx(H264dCurCtx_t *p_Cur) FunctionIn(p_Cur->p_Dec->logctx.parr[RUN_PARSE]); p_strm = &p_Cur->strm; - p_strm->nalu_buf = mpp_malloc_size(RK_U8, NALU_BUF_MAX_SIZE); - p_strm->head_buf = mpp_malloc_size(RK_U8, HEAD_BUF_MAX_SIZE); + p_strm->nalu_buf = mpp_malloc_size(RK_U8, NALU_BUF_MAX_SIZE); + p_strm->head_buf = mpp_malloc_size(RK_U8, HEAD_BUF_MAX_SIZE); MEM_CHECK(ret, p_strm->nalu_buf && p_strm->head_buf); p_strm->prefixdata = 0xffffffff; for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) { @@ -207,7 +207,7 @@ static MPP_RET init_cur_ctx(H264dCurCtx_t *p_Cur) p_Cur->listB[i] = mpp_malloc_size(H264_StorePic_t*, MAX_LIST_SIZE * sizeof(H264_StorePic_t*)); MEM_CHECK(ret, p_Cur->listP[i] && p_Cur->listB[i]); // +1 for reordering } - reset_cur_slice(p_Cur, &p_Cur->slice); + reset_cur_slice(p_Cur, &p_Cur->slice); FunctionOut(p_Cur->p_Dec->logctx.parr[RUN_PARSE]); @@ -255,7 +255,7 @@ static MPP_RET init_vid_ctx(H264dVideoCtx_t *p_Vid) p_Vid->p_Dpb_layer[i]->layer_id = i; p_Vid->p_Dpb_layer[i]->p_Vid = p_Vid; p_Vid->p_Dpb_layer[i]->init_done = 0; - p_Vid->p_Dpb_layer[i]->poc_interval = 2; + p_Vid->p_Dpb_layer[i]->poc_interval = 2; } //!< init video pars for (i = 0; i < MAXSPS; i++) { @@ -309,9 +309,9 @@ static MPP_RET init_dxva_ctx(H264dDxvaCtx_t *p_dxva) INP_CHECK(ret, !p_dxva); FunctionIn(p_dxva->p_Dec->logctx.parr[RUN_PARSE]); p_dxva->slice_count = 0; - p_dxva->slice_long = mpp_calloc(DXVA_Slice_H264_Long, MAX_SLICE_NUM); + p_dxva->slice_long = mpp_calloc(DXVA_Slice_H264_Long, MAX_SLICE_NUM); MEM_CHECK(ret, p_dxva->slice_long); - p_dxva->bitstream = mpp_malloc(RK_U8, BITSTREAM_MAX_SIZE); + p_dxva->bitstream = mpp_malloc(RK_U8, BITSTREAM_MAX_SIZE); p_dxva->syn.buf = mpp_calloc(DXVA2_DecodeBufferDesc, SYNTAX_BUF_SIZE); MEM_CHECK(ret, p_dxva->bitstream && p_dxva->syn.buf); FunctionOut(p_dxva->p_Dec->logctx.parr[RUN_PARSE]); @@ -360,7 +360,7 @@ static MPP_RET init_dec_ctx(H264_DecCtx_t *p_Dec) //!< init Dpb_memory Mark for (i = 0; i < MAX_MARK_SIZE; i++) { reset_dpb_mark(&p_Dec->dpb_mark[i]); - p_Dec->dpb_mark[i].mark_idx = i; + p_Dec->dpb_mark[i].mark_idx = i; } mpp_buf_slot_setup(p_Dec->frame_slots, MAX_MARK_SIZE); //!< malloc mpp packet @@ -420,8 +420,8 @@ MPP_RET h264d_init(void *decoder, ParserCfg *init) p_Dec->p_Vid->p_Dec = p_Dec; p_Dec->p_Vid->p_Inp = p_Dec->p_Inp; p_Dec->p_Vid->p_Cur = p_Dec->p_Cur; - FUN_CHECK(ret = init_input_ctx(p_Dec->p_Inp, init)); - FUN_CHECK(ret = init_cur_ctx(p_Dec->p_Cur)); + FUN_CHECK(ret = init_input_ctx(p_Dec->p_Inp, init)); + FUN_CHECK(ret = init_cur_ctx(p_Dec->p_Cur)); FUN_CHECK(ret = init_vid_ctx(p_Dec->p_Vid)); FUN_CHECK(ret = init_dec_ctx(p_Dec)); @@ -490,13 +490,13 @@ MPP_RET h264d_reset(void *decoder) p_Dec->p_Inp->in_dts = 0; p_Dec->p_Inp->has_get_eos = 0; //!< reset video parameter - p_Dec->p_Vid->have_outpicture_flag = 0; - p_Dec->p_Vid->exit_picture_flag = 0; - p_Dec->p_Vid->active_mvc_sps_flag = 0; + p_Dec->p_Vid->have_outpicture_flag = 0; + p_Dec->p_Vid->exit_picture_flag = 0; + p_Dec->p_Vid->active_mvc_sps_flag = 0; p_Dec->p_Vid->g_framecnt = 0; - p_Dec->p_Vid->dec_pic = NULL; - p_Dec->p_Vid->last_pic = NULL; - memset(&p_Dec->p_Vid->old_pic, 0, sizeof(H264_StorePic_t)); + p_Dec->p_Vid->dec_pic = NULL; + p_Dec->p_Vid->last_pic = NULL; + memset(&p_Dec->p_Vid->old_pic, 0, sizeof(H264_StorePic_t)); memset(&p_Dec->errctx, 0, sizeof(H264dErrCtx_t)); //!< reset current time stamp p_Dec->p_Cur->last_dts = 0; @@ -520,8 +520,8 @@ MPP_RET h264d_reset(void *decoder) p_Dec->is_parser_end = 0; p_Dec->dxva_ctx->strm_offset = 0; p_Dec->dxva_ctx->slice_count = 0; - p_Dec->last_frame_slot_idx = -1; - FunctionOut(p_Dec->logctx.parr[RUN_PARSE]); + p_Dec->last_frame_slot_idx = -1; + FunctionOut(p_Dec->logctx.parr[RUN_PARSE]); __RETURN: return ret = MPP_OK; __FAILED: @@ -537,18 +537,18 @@ __FAILED: MPP_RET h264d_flush(void *decoder) { MPP_RET ret = MPP_ERR_UNKNOW; - RK_U32 dpb_used_size = 0; + RK_U32 dpb_used_size = 0; H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder; INP_CHECK(ret, !decoder); - INP_CHECK(ret, !p_Dec->p_Inp); - INP_CHECK(ret, !p_Dec->p_Vid); + INP_CHECK(ret, !p_Dec->p_Inp); + INP_CHECK(ret, !p_Dec->p_Vid); FunctionIn(p_Dec->logctx.parr[RUN_PARSE]); - dpb_used_size = p_Dec->p_Vid->p_Dpb_layer[0]->used_size; - if (p_Dec->mvc_valid) { - dpb_used_size += p_Dec->p_Vid->p_Dpb_layer[1]->used_size; - } + dpb_used_size = p_Dec->p_Vid->p_Dpb_layer[0]->used_size; + if (p_Dec->mvc_valid) { + dpb_used_size += p_Dec->p_Vid->p_Dpb_layer[1]->used_size; + } if (!dpb_used_size && p_Dec->p_Inp->has_get_eos) { IOInterruptCB *cb = &p_Dec->p_Inp->init.notify_cb; if (cb->callBack) { @@ -567,7 +567,7 @@ MPP_RET h264d_flush(void *decoder) } flush_dpb_buf_slot(p_Dec); if (p_Dec->last_frame_slot_idx >= 0) { - mpp_buf_slot_set_prop(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, + mpp_buf_slot_set_prop(p_Dec->frame_slots, p_Dec->last_frame_slot_idx, SLOT_EOS, &p_Dec->p_Inp->has_get_eos); p_Dec->last_frame_slot_idx = -1; } @@ -617,7 +617,7 @@ MPP_RET h264d_prepare(void *decoder, MppPacket pkt, HalDecTask *task) p_Inp = p_Dec->p_Inp; if (p_Inp->has_get_eos || p_Dec->errctx.un_spt_flag) { - mpp_packet_set_length(pkt, 0); + mpp_packet_set_length(pkt, 0); goto __RETURN; } p_Inp->in_pkt = pkt; @@ -625,11 +625,11 @@ MPP_RET h264d_prepare(void *decoder, MppPacket pkt, HalDecTask *task) p_Inp->in_dts = mpp_packet_get_dts(pkt); if (mpp_packet_get_eos(pkt)) { - p_Inp->pkt_eos = 1; - p_Inp->has_get_eos = 1; + p_Inp->pkt_eos = 1; + p_Inp->has_get_eos = 1; if (p_Inp->in_length < 4) { h264d_flush(decoder); - goto __RETURN; + goto __RETURN; } p_Inp->in_buf = NULL; p_Inp->in_length = 0; @@ -640,13 +640,13 @@ MPP_RET h264d_prepare(void *decoder, MppPacket pkt, HalDecTask *task) p_Inp->in_length = mpp_packet_get_length(pkt); p_Inp->pkt_eos = 0; } - if (p_Inp->in_length > MAX_STREM_IN_SIZE) { - H264D_ERR("[pkt_in_timeUs] input error, stream too large, pts=%lld, eos=%d, len=%d, pkt_no=%d", - p_Inp->in_pts, p_Inp->pkt_eos, p_Inp->in_length, p_Dec->p_Vid->g_framecnt); - mpp_packet_set_length(pkt, 0); - ret = MPP_NOK; - goto __FAILED; - } + if (p_Inp->in_length > MAX_STREM_IN_SIZE) { + H264D_ERR("[pkt_in_timeUs] input error, stream too large, pts=%lld, eos=%d, len=%d, pkt_no=%d", + p_Inp->in_pts, p_Inp->pkt_eos, p_Inp->in_length, p_Dec->p_Vid->g_framecnt); + mpp_packet_set_length(pkt, 0); + ret = MPP_NOK; + goto __FAILED; + } //!< avcC stream if (mpp_packet_get_flag(pkt) & MPP_PACKET_FLAG_EXTRA_DATA) { RK_U8 *pdata = p_Inp->in_buf; @@ -662,7 +662,7 @@ MPP_RET h264d_prepare(void *decoder, MppPacket pkt, HalDecTask *task) (ret = parse_prepare_extra_data(p_Inp, p_Dec->p_Cur)); task->valid = p_Inp->task_valid; //!< prepare valid flag } else { - fwrite_stream_to_file(p_Inp, p_Inp->in_buf, (RK_U32)p_Inp->in_length); + fwrite_stream_to_file(p_Inp, p_Inp->in_buf, (RK_U32)p_Inp->in_length); do { (ret = parse_prepare_fast(p_Inp, p_Dec->p_Cur)); task->valid = p_Inp->task_valid; //!< prepare valid flag @@ -684,7 +684,7 @@ __RETURN: return ret = MPP_OK; __FAILED: - return ret; + return ret; } @@ -697,18 +697,18 @@ __FAILED: MPP_RET h264d_parse(void *decoder, HalDecTask *in_task) { MPP_RET ret = MPP_ERR_UNKNOW; - H264dErrCtx_t *p_err = NULL; + H264dErrCtx_t *p_err = NULL; H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder; INP_CHECK(ret, !decoder && !in_task); FunctionIn(p_Dec->logctx.parr[RUN_PARSE]); - p_err = &p_Dec->errctx; + p_err = &p_Dec->errctx; in_task->valid = 0; // prepare end flag p_Dec->in_task = in_task; - p_err->cur_err_flag = 0; + p_err->cur_err_flag = 0; p_err->used_ref_flag = 0; - p_Dec->is_parser_end = 0; + p_Dec->is_parser_end = 0; FUN_CHECK(ret = parse_loop(p_Dec)); if (p_Dec->is_parser_end) { @@ -725,9 +725,9 @@ MPP_RET h264d_parse(void *decoder, HalDecTask *in_task) in_task->valid = 1; // register valid flag in_task->syntax.number = p_Dec->dxva_ctx->syn.num; in_task->syntax.data = (void *)p_Dec->dxva_ctx->syn.buf; - in_task->flags.used_for_ref = p_err->used_ref_flag; - p_err->dpb_err_flag |= p_err->used_ref_flag ? p_err->cur_err_flag : 0; - in_task->flags.had_error = (p_err->dpb_err_flag | p_err->cur_err_flag) ? 1 : 0; + in_task->flags.used_for_ref = p_err->used_ref_flag; + p_err->dpb_err_flag |= p_err->used_ref_flag ? p_err->cur_err_flag : 0; + in_task->flags.had_error = (p_err->dpb_err_flag | p_err->cur_err_flag) ? 1 : 0; } __RETURN: FunctionOut(p_Dec->logctx.parr[RUN_PARSE]); @@ -736,30 +736,30 @@ __RETURN: __FAILED: { H264_StorePic_t *dec_pic = p_Dec->p_Vid->dec_pic; - if (dec_pic) { - H264D_WARNNING("[h264d_parse] h264d_parse failed.\n"); - if (dec_pic->mem_mark - && dec_pic->mem_mark->out_flag - && (dec_pic->mem_mark->slot_idx >= 0)) { - MppFrame mframe = NULL; - mpp_buf_slot_get_prop(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, SLOT_FRAME_PTR, &mframe); - if (mframe) { - if (p_err->used_ref_flag) { - mpp_frame_set_errinfo(mframe, VPU_FRAME_ERR_UNKNOW); - } else { - mpp_frame_set_discard(mframe, VPU_FRAME_ERR_UNKNOW); - } - } - mpp_buf_slot_set_flag(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, SLOT_QUEUE_USE); - mpp_buf_slot_enqueue(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, QUEUE_DISPLAY); - mpp_buf_slot_clr_flag(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, SLOT_CODEC_USE); - } - reset_dpb_mark(dec_pic->mem_mark); - dec_pic->mem_mark = NULL; - MPP_FREE(dec_pic); - p_Dec->p_Vid->dec_pic = NULL; - } - p_err->dpb_err_flag |= p_err->used_ref_flag ? 1 : 0; + if (dec_pic) { + H264D_WARNNING("[h264d_parse] h264d_parse failed.\n"); + if (dec_pic->mem_mark + && dec_pic->mem_mark->out_flag + && (dec_pic->mem_mark->slot_idx >= 0)) { + MppFrame mframe = NULL; + mpp_buf_slot_get_prop(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, SLOT_FRAME_PTR, &mframe); + if (mframe) { + if (p_err->used_ref_flag) { + mpp_frame_set_errinfo(mframe, VPU_FRAME_ERR_UNKNOW); + } else { + mpp_frame_set_discard(mframe, VPU_FRAME_ERR_UNKNOW); + } + } + mpp_buf_slot_set_flag(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, SLOT_QUEUE_USE); + mpp_buf_slot_enqueue(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, QUEUE_DISPLAY); + mpp_buf_slot_clr_flag(p_Dec->frame_slots, dec_pic->mem_mark->slot_idx, SLOT_CODEC_USE); + } + reset_dpb_mark(dec_pic->mem_mark); + dec_pic->mem_mark = NULL; + MPP_FREE(dec_pic); + p_Dec->p_Vid->dec_pic = NULL; + } + p_err->dpb_err_flag |= p_err->used_ref_flag ? 1 : 0; } return ret; @@ -775,36 +775,36 @@ MPP_RET h264d_callback(void *decoder, void *errinfo) { MPP_RET ret = MPP_ERR_UNKNOW; H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder; - RK_U32 *p_regs = NULL; + RK_U32 *p_regs = NULL; INP_CHECK(ret, !decoder); - FunctionIn(p_Dec->logctx.parr[RUN_PARSE]); - p_regs = (RK_U32*)errinfo; - { - MppFrame mframe = NULL; + FunctionIn(p_Dec->logctx.parr[RUN_PARSE]); + p_regs = (RK_U32*)errinfo; + { + MppFrame mframe = NULL; - RK_U32 out_slot_idx = p_regs[78]; - RK_U32 had_err_flag = p_regs[79]; - RK_U32 used_ref_flag = p_regs[80]; - RK_U32 dec_error_sta = p_regs[1] & 0x00004000; - RK_U32 dec_rdy_sta = p_regs[1] & 0x00001000; - RK_U32 buf_empty_sta = p_regs[1] & 0x00010000; - RK_U32 strmd_error_status = p_regs[45]; - RK_U32 strmd_error_detect_flag = p_regs[76] & 0x00008000; // strmd error detect flag + RK_U32 out_slot_idx = p_regs[78]; + RK_U32 had_err_flag = p_regs[79]; + RK_U32 used_ref_flag = p_regs[80]; + RK_U32 dec_error_sta = p_regs[1] & 0x00004000; + RK_U32 dec_rdy_sta = p_regs[1] & 0x00001000; + RK_U32 buf_empty_sta = p_regs[1] & 0x00010000; + RK_U32 strmd_error_status = p_regs[45]; + RK_U32 strmd_error_detect_flag = p_regs[76] & 0x00008000; // strmd error detect flag - mpp_buf_slot_get_prop(p_Dec->frame_slots, out_slot_idx, SLOT_FRAME_PTR, &mframe); - if (mframe) { - if (dec_error_sta || (!dec_rdy_sta) || buf_empty_sta - || had_err_flag || strmd_error_status || strmd_error_detect_flag) { - if (used_ref_flag) { - mpp_frame_set_errinfo(mframe, VPU_FRAME_ERR_UNKNOW); - } else { - mpp_frame_set_discard(mframe, VPU_FRAME_ERR_UNKNOW); - } - } - H264D_DBG(H264D_DBG_CALLBACK, "[CALLBACK] g_no=%d, s_idx=%d, sw[01]=%08x, sw[45]=%08x, sw[76]=%08x, dpberr=%d, ref=%d, errinfo=%d, discard=%d \n", - p_Dec->p_Vid->g_framecnt, out_slot_idx, p_regs[1], p_regs[45], p_regs[76], had_err_flag, used_ref_flag, mpp_frame_get_errinfo(mframe), mpp_frame_get_discard(mframe)); - } - } + mpp_buf_slot_get_prop(p_Dec->frame_slots, out_slot_idx, SLOT_FRAME_PTR, &mframe); + if (mframe) { + if (dec_error_sta || (!dec_rdy_sta) || buf_empty_sta + || had_err_flag || strmd_error_status || strmd_error_detect_flag) { + if (used_ref_flag) { + mpp_frame_set_errinfo(mframe, VPU_FRAME_ERR_UNKNOW); + } else { + mpp_frame_set_discard(mframe, VPU_FRAME_ERR_UNKNOW); + } + } + H264D_DBG(H264D_DBG_CALLBACK, "[CALLBACK] g_no=%d, s_idx=%d, sw[01]=%08x, sw[45]=%08x, sw[76]=%08x, dpberr=%d, ref=%d, errinfo=%d, discard=%d \n", + p_Dec->p_Vid->g_framecnt, out_slot_idx, p_regs[1], p_regs[45], p_regs[76], had_err_flag, used_ref_flag, mpp_frame_get_errinfo(mframe), mpp_frame_get_discard(mframe)); + } + } __RETURN: FunctionOut(p_Dec->logctx.parr[RUN_PARSE]); diff --git a/mpp/codec/dec/h264/h264d_dpb.c b/mpp/codec/dec/h264/h264d_dpb.c index fb0b76b0..88c82072 100644 --- a/mpp/codec/dec/h264/h264d_dpb.c +++ b/mpp/codec/dec/h264/h264d_dpb.c @@ -733,29 +733,29 @@ __FAILED: static RK_S32 get_smallest_poc(H264_DpbBuf_t *p_Dpb, RK_S32 *poc, RK_S32 *pos) { RK_U32 i = 0; - RK_S32 find_flag = 0; - RK_S32 min_pos = -1; - RK_S32 min_poc = INT_MAX; + RK_S32 find_flag = 0; + RK_S32 min_pos = -1; + RK_S32 min_poc = INT_MAX; *pos = -1; *poc = INT_MAX; for (i = 0; i < p_Dpb->used_size; i++) { - if (min_poc > p_Dpb->fs[i]->poc) { - min_poc = p_Dpb->fs[i]->poc; - min_pos = i; - } + if (min_poc > p_Dpb->fs[i]->poc) { + min_poc = p_Dpb->fs[i]->poc; + min_pos = i; + } if ((*poc > p_Dpb->fs[i]->poc) && (!p_Dpb->fs[i]->is_output)) { *poc = p_Dpb->fs[i]->poc; *pos = i; - find_flag = 1; + find_flag = 1; } } - if (!find_flag) { - *poc = min_poc; - *pos = min_pos; - } + if (!find_flag) { + *poc = min_poc; + *pos = min_pos; + } - return find_flag; + return find_flag; } static H264_FrameStore_t *alloc_frame_store() @@ -987,15 +987,15 @@ static MPP_RET output_one_frame_from_dpb(H264_DpbBuf_t *p_Dpb) H264dVideoCtx_t *p_Vid = p_Dpb->p_Vid; //!< find smallest POC - if (get_smallest_poc(p_Dpb, &poc, &pos)) { - p_Dpb->last_output_poc = poc; - //!< JVT-P072 ends - FUN_CHECK(ret = write_stored_frame(p_Vid, p_Dpb->fs[pos])); - //!< free frame store and move empty store to end of buffer - if (!is_used_for_reference(p_Dpb->fs[pos])) { - FUN_CHECK(ret = remove_frame_from_dpb(p_Dpb, pos)); + if (get_smallest_poc(p_Dpb, &poc, &pos)) { + p_Dpb->last_output_poc = poc; + //!< JVT-P072 ends + FUN_CHECK(ret = write_stored_frame(p_Vid, p_Dpb->fs[pos])); + //!< free frame store and move empty store to end of buffer + if (!is_used_for_reference(p_Dpb->fs[pos])) { + FUN_CHECK(ret = remove_frame_from_dpb(p_Dpb, pos)); + } } - } return ret = MPP_OK; __FAILED: return ret; @@ -1247,12 +1247,12 @@ MPP_RET store_picture_in_dpb(H264_DpbBuf_t *p_Dpb, H264_StorePic_t *p) VAL_CHECK(ret, NULL != p); //!< if frame, check for new store p_Vid->last_pic = NULL; - //!< set use flag - if (p->mem_mark && (p->mem_mark->slot_idx >= 0)) { - mpp_buf_slot_set_flag(p_Vid->p_Dec->frame_slots, p->mem_mark->slot_idx, SLOT_CODEC_USE); - } else { - H264D_ERR("error, p->mem_mark == NULL"); - } + //!< set use flag + if (p->mem_mark && (p->mem_mark->slot_idx >= 0)) { + mpp_buf_slot_set_flag(p_Vid->p_Dec->frame_slots, p->mem_mark->slot_idx, SLOT_CODEC_USE); + } else { + H264D_ERR("error, p->mem_mark == NULL"); + } //!< deal with all frames in dpb p_Vid->last_has_mmco_5 = 0; p_Vid->last_pic_bottom_field = p->structure == BOTTOM_FIELD; @@ -1277,77 +1277,76 @@ MPP_RET store_picture_in_dpb(H264_DpbBuf_t *p_Dpb, H264_StorePic_t *p) sliding_window_memory_management(p_Dpb); p->is_long_term = 0; } - while (!remove_unused_frame_from_dpb(p_Dpb)); + while (!remove_unused_frame_from_dpb(p_Dpb)); #if 1 - while (p_Dpb->used_size == p_Dpb->size) { - RK_S32 min_poc = 0, min_pos = 0; - RK_S32 find_flag = 0; + while (p_Dpb->used_size == p_Dpb->size) { + RK_S32 min_poc = 0, min_pos = 0; + RK_S32 find_flag = 0; - remove_unused_frame_from_dpb(p_Dpb); - find_flag = get_smallest_poc(p_Dpb, &min_poc, &min_pos); - if (!p->used_for_reference) { - if ((!find_flag) || (p->poc < min_poc)) { - p_Dpb->last_output_poc = p->poc; - FUN_CHECK(ret = direct_output(p_Vid, p)); //!< output frame - goto __RETURN; - } - } - //!< used for reference, but not find, then flush a frame in the first - if ((!find_flag) || (p->poc < min_poc)) { - //min_pos = 0; - unmark_for_reference(p_Vid->p_Dec, p_Dpb->fs[min_pos]); - if (!p_Dpb->fs[min_pos]->is_output) { - p_Dpb->last_output_poc = p_Dpb->fs[min_pos]->poc; - FUN_CHECK(ret = write_stored_frame(p_Vid, p_Dpb->fs[min_pos])); - } - FUN_CHECK(ret = remove_frame_from_dpb(p_Dpb, min_pos)); - p->is_long_term = 0; - } - FUN_CHECK(ret = output_one_frame_from_dpb(p_Dpb)); - } -#endif -#if 1 - { - //!< store current decoder picture at end of dpb - FUN_CHECK(ret = insert_picture_in_dpb(p_Vid, p_Dpb->fs[p_Dpb->used_size], p, 0)); - if (p->structure != FRAME) { - p_Dpb->last_picture = p_Dpb->fs[p_Dpb->used_size]; - } else { - p_Dpb->last_picture = NULL; + remove_unused_frame_from_dpb(p_Dpb); + find_flag = get_smallest_poc(p_Dpb, &min_poc, &min_pos); + if (!p->used_for_reference) { + if ((!find_flag) || (p->poc < min_poc)) { + p_Dpb->last_output_poc = p->poc; + FUN_CHECK(ret = direct_output(p_Vid, p)); //!< output frame + goto __RETURN; + } + } + //!< used for reference, but not find, then flush a frame in the first + if ((!find_flag) || (p->poc < min_poc)) { + //min_pos = 0; + unmark_for_reference(p_Vid->p_Dec, p_Dpb->fs[min_pos]); + if (!p_Dpb->fs[min_pos]->is_output) { + p_Dpb->last_output_poc = p_Dpb->fs[min_pos]->poc; + FUN_CHECK(ret = write_stored_frame(p_Vid, p_Dpb->fs[min_pos])); + } + FUN_CHECK(ret = remove_frame_from_dpb(p_Dpb, min_pos)); + p->is_long_term = 0; + } + FUN_CHECK(ret = output_one_frame_from_dpb(p_Dpb)); } - memcpy(&p_Vid->old_pic, p, sizeof(H264_StorePic_t)); - p_Vid->last_pic = &p_Vid->old_pic; - - p_Dpb->used_size++; - H264D_DBG(H264D_DBG_DPB_INFO, "[DPB_size] p_Dpb->used_size=%d", p_Dpb->used_size); - } #endif #if 1 - { - RK_S32 min_poc = 0, min_pos = 0; - H264_FrameStore_t *fs = p_Dpb->fs[p_Dpb->used_size - 1]; - RK_S32 poc_inc = fs->poc - p_Dpb->last_output_poc; + { + //!< store current decoder picture at end of dpb + FUN_CHECK(ret = insert_picture_in_dpb(p_Vid, p_Dpb->fs[p_Dpb->used_size], p, 0)); + if (p->structure != FRAME) { + p_Dpb->last_picture = p_Dpb->fs[p_Dpb->used_size]; + } else { + p_Dpb->last_picture = NULL; + } + memcpy(&p_Vid->old_pic, p, sizeof(H264_StorePic_t)); + p_Vid->last_pic = &p_Vid->old_pic; - if ((p_Dpb->last_output_poc > INT_MIN) && abs(poc_inc) & 0x1) { - p_Dpb->poc_interval = 1; + p_Dpb->used_size++; + H264D_DBG(H264D_DBG_DPB_INFO, "[DPB_size] p_Dpb->used_size=%d", p_Dpb->used_size); + } +#endif +#if 1 + { + RK_S32 min_poc = 0, min_pos = 0; + H264_FrameStore_t *fs = p_Dpb->fs[p_Dpb->used_size - 1]; + RK_S32 poc_inc = fs->poc - p_Dpb->last_output_poc; - } - if (p->idr_flag || (p->poc == 0) || (p_Dpb->last_output_poc == INT_MIN)) { - p_Dpb->last_output_poc = p->poc; - FUN_CHECK(ret = write_stored_frame(p_Vid, fs)); - } - while ((p_Dpb->last_output_poc > INT_MIN) - && (get_smallest_poc(p_Dpb, &min_poc, &min_pos))) { - if ((min_poc - p_Dpb->last_output_poc) <= p_Dpb->poc_interval) { - p_Dpb->last_output_poc = min_poc; - FUN_CHECK(ret = write_stored_frame(p_Vid, p_Dpb->fs[min_pos])); - } - else { - break; - } - } - while (!remove_unused_frame_from_dpb(p_Dpb)); - } + if ((p_Dpb->last_output_poc > INT_MIN) && abs(poc_inc) & 0x1) { + p_Dpb->poc_interval = 1; + + } + if (p->idr_flag || (p->poc == 0) || (p_Dpb->last_output_poc == INT_MIN)) { + p_Dpb->last_output_poc = p->poc; + FUN_CHECK(ret = write_stored_frame(p_Vid, fs)); + } + while ((p_Dpb->last_output_poc > INT_MIN) + && (get_smallest_poc(p_Dpb, &min_poc, &min_pos))) { + if ((min_poc - p_Dpb->last_output_poc) <= p_Dpb->poc_interval) { + p_Dpb->last_output_poc = min_poc; + FUN_CHECK(ret = write_stored_frame(p_Vid, p_Dpb->fs[min_pos])); + } else { + break; + } + } + while (!remove_unused_frame_from_dpb(p_Dpb)); + } #endif update_ref_list(p_Dpb); update_ltref_list(p_Dpb); @@ -1708,7 +1707,7 @@ MPP_RET init_dpb(H264dVideoCtx_t *p_Vid, H264_DpbBuf_t *p_Dpb, RK_S32 type) // free_dpb(p_Dpb); } VAL_CHECK(ret, p_Dpb->size = getDpbSize(p_Vid, active_sps)); - p_Dpb->size = MPP_MAX(1, p_Dpb->size); + p_Dpb->size = MPP_MAX(1, p_Dpb->size); p_Dpb->num_ref_frames = active_sps->max_num_ref_frames; if (active_sps->max_dec_frame_buffering < active_sps->max_num_ref_frames) { H264D_WARNNING("DPB size at specified level is smaller than reference frames"); diff --git a/mpp/codec/dec/h264/h264d_fill.c b/mpp/codec/dec/h264/h264d_fill.c index daf8d630..009ca096 100644 --- a/mpp/codec/dec/h264/h264d_fill.c +++ b/mpp/codec/dec/h264/h264d_fill.c @@ -48,9 +48,9 @@ static MPP_RET fill_slice_stream(H264dDxvaCtx_t *dxva_ctx, H264_Nalu_t *p_nal) RK_U32 streamlen_add = 0; DXVA_Slice_H264_Long *p_long = NULL; - if (dxva_ctx->slice_count > MAX_SLICE_NUM) { - H264D_ERR("error, slcie_num is larger than 1024"); - goto __FAILED; + if (dxva_ctx->slice_count > MAX_SLICE_NUM) { + H264D_ERR("error, slcie_num is larger than 1024"); + goto __FAILED; } //streamlen_add = p_nal->sodb_len + sizeof(start_code); //stream_offset = dxva_ctx->strm_offset + streamlen_add; diff --git a/mpp/codec/dec/h264/h264d_global.h b/mpp/codec/dec/h264/h264d_global.h index 917c1214..f0de4a0c 100644 --- a/mpp/codec/dec/h264/h264d_global.h +++ b/mpp/codec/dec/h264/h264d_global.h @@ -107,25 +107,25 @@ typedef enum { STRUCT_NULL = 0, TOP_FIELD = 0x1, BOTTOM_FIELD = 0x2, - FRAME = 0x3, - STRUCT_MAX, + FRAME = 0x3, + STRUCT_MAX, } PictureStructure; //!< New enum for field processing typedef enum { - PIC_ERR_NULL = 0, - PIC_ERR_TOP = 0x1, - PIC_ERR_BOT = 0x2, - PIC_ERR_FRAME = 0x3, - PIC_ERR_WHOLE = 0x3, - PIC_ERR_MAX, -}PictureError; + PIC_ERR_NULL = 0, + PIC_ERR_TOP = 0x1, + PIC_ERR_BOT = 0x2, + PIC_ERR_FRAME = 0x3, + PIC_ERR_WHOLE = 0x3, + PIC_ERR_MAX, +} PictureError; typedef enum { - FIELD_ORDER_NULL, - FIELD_ORDER_TOP_FIRST, - FIELD_ORDER_BOT_FIRST, - FIELD_ORDER_SAME, - FIELD_ORDER_MAX -}FieldOrder; + FIELD_ORDER_NULL, + FIELD_ORDER_TOP_FIRST, + FIELD_ORDER_BOT_FIRST, + FIELD_ORDER_SAME, + FIELD_ORDER_MAX +} FieldOrder; //!< Field Coding Types typedef enum { FRAME_CODING = 0, @@ -191,11 +191,11 @@ typedef struct h264_nalu_mvc_ext_t { //!< decoder refence picture marking typedef struct h264_drpm_t { - RK_S32 memory_management_control_operation; - RK_S32 difference_of_pic_nums_minus1; - RK_S32 long_term_pic_num; - RK_S32 long_term_frame_idx; - RK_S32 max_long_term_frame_idx_plus1; + RK_S32 memory_management_control_operation; + RK_S32 difference_of_pic_nums_minus1; + RK_S32 long_term_pic_num; + RK_S32 long_term_frame_idx; + RK_S32 max_long_term_frame_idx_plus1; struct h264_drpm_t *Next; } H264_DRPM_t; @@ -328,9 +328,9 @@ typedef struct h264_frame_store_t { RK_S32 inter_view_flag[2]; RK_S32 anchor_pic_flag[2]; RK_S32 layer_id; - RK_S32 slice_type; + RK_S32 slice_type; RK_U32 frame_num; - RK_S32 structure; + RK_S32 structure; struct h264_store_pic_t *frame; struct h264_store_pic_t *top_field; struct h264_store_pic_t *bottom_field; @@ -345,7 +345,7 @@ typedef struct h264_dpb_buf_t { RK_U32 ltref_frames_in_buffer; RK_U32 used_size_il; - RK_S32 poc_interval; + RK_S32 poc_interval; RK_S32 last_output_poc; RK_S32 last_output_view_id; RK_S32 max_long_term_pic_idx; @@ -742,10 +742,10 @@ typedef struct h264_slice_t { RK_S32 num_ref_idx_active[2]; //!< number of available list references RK_S32 num_ref_idx_override_flag; RK_S32 ref_pic_list_reordering_flag[2]; - RK_S32 *modification_of_pic_nums_idc[2]; - RK_S32 *abs_diff_pic_num_minus1[2]; - RK_S32 *long_term_pic_idx[2]; - RK_S32 *abs_diff_view_idx_minus1[2]; + RK_S32 *modification_of_pic_nums_idc[2]; + RK_S32 *abs_diff_pic_num_minus1[2]; + RK_S32 *long_term_pic_idx[2]; + RK_S32 *abs_diff_view_idx_minus1[2]; struct h264_drpm_t *dec_ref_pic_marking_buffer; RK_U32 drpm_used_bitlen; RK_S32 no_output_of_prior_pics_flag; @@ -866,14 +866,14 @@ typedef struct h264d_input_ctx_t { RK_U32 nal_size; RK_S32 sps_num; RK_S32 pps_num; - //!< write stream - char fname[2][512]; - FILE *fp; - RK_U8 *spspps_buf; - RK_U32 spspps_size; - RK_U32 spspps_len; - RK_U32 spspps_offset; - RK_U32 spspps_update_flag; + //!< write stream + char fname[2][512]; + FILE *fp; + RK_U8 *spspps_buf; + RK_U32 spspps_size; + RK_U32 spspps_len; + RK_U32 spspps_offset; + RK_U32 spspps_update_flag; } H264dInputCtx_t; @@ -919,13 +919,13 @@ typedef struct h264d_cur_ctx_t { RK_S64 last_dts; RK_S64 curr_pts; RK_S64 curr_dts; - //!< malloc buffer for current slice - RK_S32 modification_of_pic_nums_idc[2][MAX_REORDER_TIMES]; - RK_S32 abs_diff_pic_num_minus1[2][MAX_REORDER_TIMES]; - RK_S32 long_term_pic_idx[2][MAX_REORDER_TIMES]; - RK_S32 abs_diff_view_idx_minus1[2][MAX_REORDER_TIMES]; - - struct h264_drpm_t dec_ref_pic_marking_buffer[MAX_MARKING_TIMES]; + //!< malloc buffer for current slice + RK_S32 modification_of_pic_nums_idc[2][MAX_REORDER_TIMES]; + RK_S32 abs_diff_pic_num_minus1[2][MAX_REORDER_TIMES]; + RK_S32 long_term_pic_idx[2][MAX_REORDER_TIMES]; + RK_S32 abs_diff_view_idx_minus1[2][MAX_REORDER_TIMES]; + + struct h264_drpm_t dec_ref_pic_marking_buffer[MAX_MARKING_TIMES]; } H264dCurCtx_t; //!< parameters for video decoder @@ -941,13 +941,13 @@ typedef struct h264d_video_ctx_t { struct h264d_cur_ctx_t *p_Cur; //!< H264_CurParameters struct h264_dpb_buf_t *p_Dpb_layer[MAX_NUM_DPB_LAYERS]; struct h264_store_pic_t *dec_pic; //!< current decoder picture - struct h264_store_pic_t *last_pic; - + struct h264_store_pic_t *last_pic; + struct h264_store_pic_t *no_ref_pic; //!< no reference picture struct h264_frame_store_t out_buffer; struct h264_dpb_mark_t *active_dpb_mark[MAX_NUM_DPB_LAYERS]; //!< acitve_dpb_memory - struct h264_store_pic_t old_pic; + struct h264_store_pic_t old_pic; struct h264_old_slice_par_t old_slice; RK_S32 *qmatrix[12]; //!< scanlist pointer RK_U32 stream_size; @@ -1054,10 +1054,10 @@ typedef enum slice_state_type { } SLICE_STATUS; typedef struct h264_err_ctx_t { - RK_U32 un_spt_flag; - RK_U32 cur_err_flag; //!< current decoded picture error + RK_U32 un_spt_flag; + RK_U32 cur_err_flag; //!< current decoded picture error RK_U32 used_ref_flag; - RK_U32 dpb_err_flag; //!< dpb storage had error + RK_U32 dpb_err_flag; //!< dpb storage had error RK_U32 i_slice_no; RK_S32 first_iframe_poc; diff --git a/mpp/codec/dec/h264/h264d_init.c b/mpp/codec/dec/h264/h264d_init.c index 30433f68..aaac5a28 100644 --- a/mpp/codec/dec/h264/h264d_init.c +++ b/mpp/codec/dec/h264/h264d_init.c @@ -462,8 +462,7 @@ static MPP_RET check_dpb_field_paired(H264_FrameStore_t *p_last, H264_StorePic_t || (p_last->is_used == 2 && cur_structure == BOTTOM_FIELD) //!< Bot + Bot //|| ((!dec_pic->combine_flag) && p_last->is_used == 2 && cur_structure == TOP_FIELD) //!< Bot + Top + not combine || ((!dec_pic->combine_flag) && p_last->is_used == 1 && cur_structure == BOTTOM_FIELD) //!< Top + Bot + not combine - ) - { + ) { H264D_WARNNING("[check_field_paired] (discard) combine_flag=%d, last_used=%d, curr_struct=%d", dec_pic->combine_flag, p_last->is_used, cur_structure); return ret = MPP_NOK; @@ -1945,7 +1944,7 @@ void flush_dpb_buf_slot(H264_DecCtx_t *p_Dec) mpp_buf_slot_set_flag(p_Dec->frame_slots, p_mark->slot_idx, SLOT_QUEUE_USE); mpp_buf_slot_enqueue(p_Dec->frame_slots, p_mark->slot_idx, QUEUE_DISPLAY); mpp_buf_slot_clr_flag(p_Dec->frame_slots, p_mark->slot_idx, SLOT_CODEC_USE); - p_Dec->last_frame_slot_idx = p_mark->slot_idx; + p_Dec->last_frame_slot_idx = p_mark->slot_idx; } } reset_dpb_mark(p_mark); @@ -1994,16 +1993,16 @@ MPP_RET init_picture(H264_SLICE_t *currSlice) goto __FAILED; } FUN_CHECK(ret = alloc_decpic(currSlice)); - if (p_err->i_slice_no < 2) { - if ((!currSlice->layer_id) && (I_SLICE == currSlice->slice_type)) { - p_err->first_iframe_poc = p_Vid->dec_pic->poc; //!< recoder first i frame poc - } - if (p_Vid->dec_pic->poc < p_err->first_iframe_poc) { - H264D_WARNNING("[Discard] Discard poc less than first I Slice. \n"); - ret = MPP_NOK; - goto __FAILED; - } - } + if (p_err->i_slice_no < 2) { + if ((!currSlice->layer_id) && (I_SLICE == currSlice->slice_type)) { + p_err->first_iframe_poc = p_Vid->dec_pic->poc; //!< recoder first i frame poc + } + if (p_Vid->dec_pic->poc < p_err->first_iframe_poc) { + H264D_WARNNING("[Discard] Discard poc less than first I Slice. \n"); + ret = MPP_NOK; + goto __FAILED; + } + } //!< idr_memory_management MVC_layer, idr_flag==1 if (currSlice->layer_id && !currSlice->svc_extension_flag && !currSlice->mvcExt.non_idr_flag) { ASSERT(currSlice->layer_id == 1); diff --git a/mpp/codec/dec/h264/h264d_parse.c b/mpp/codec/dec/h264/h264d_parse.c index f9b64104..07c2f1fd 100644 --- a/mpp/codec/dec/h264/h264d_parse.c +++ b/mpp/codec/dec/h264/h264d_parse.c @@ -98,7 +98,7 @@ static void reset_slice(H264dVideoCtx_t *p_Vid) currSlice->listXsizeP[i] = 0; currSlice->listXsizeB[i] = 0; } - reset_cur_slice(p_Vid->p_Cur, currSlice); + reset_cur_slice(p_Vid->p_Cur, currSlice); FunctionOut(p_Vid->p_Dec->logctx.parr[RUN_PARSE]); } @@ -107,18 +107,18 @@ static MPP_RET realloc_buffer(RK_U8 **buf, RK_U32 *max_size, RK_U32 add_size) { MPP_RET ret = MPP_ERR_UNKNOW; if ((*buf) == NULL) { - H264D_ERR("[realloc_buffer] pointer is null, %p",(*buf)); - ret = MPP_ERR_MALLOC; - goto __FAILED; - } - add_size = MPP_ALIGN(add_size, 16); - + H264D_ERR("[realloc_buffer] pointer is null, %p", (*buf)); + ret = MPP_ERR_MALLOC; + goto __FAILED; + } + add_size = MPP_ALIGN(add_size, 16); + (*buf) = mpp_realloc((*buf), RK_U8, ((*max_size) + add_size)); - if ((*buf) == NULL) { - H264D_ERR("[realloc_buffer] max_size=%d, add_size=%d \n",(*max_size), add_size); - ret = MPP_ERR_MALLOC; - goto __FAILED; - } + if ((*buf) == NULL) { + H264D_ERR("[realloc_buffer] max_size=%d, add_size=%d \n", (*max_size), add_size); + ret = MPP_ERR_MALLOC; + goto __FAILED; + } (*max_size) += add_size; return ret = MPP_OK; @@ -138,7 +138,7 @@ static void reset_nalu(H264dCurStream_t *p_strm) static void find_prefix_code(RK_U8 *p_data, H264dCurStream_t *p_strm) { - p_strm->prefixdata = (p_strm->prefixdata << 8) | (*p_data); + p_strm->prefixdata = (p_strm->prefixdata << 8) | (*p_data); if ((p_strm->prefixdata & 0x00FFFFFF) == 0x00000001) { if (p_strm->startcode_found) { p_strm->endcode_found = 1; @@ -227,7 +227,7 @@ static MPP_RET parser_one_nalu(H264_SLICE_t *currSlice) H264D_DBG(H264D_DBG_PARSE_NALU, "nalu_type=SLICE."); FUN_CHECK(ret = process_slice(currSlice)); //if (currSlice->start_mb_nr == 0) { - currSlice->p_Dec->nalu_ret = StartOfPicture; + currSlice->p_Dec->nalu_ret = StartOfPicture; //} else { // currSlice->p_Dec->nalu_ret = StartOfSlice; //} @@ -309,8 +309,8 @@ static MPP_RET add_empty_nalu(H264dCurStream_t *p_strm) RK_U32 add_size = sizeof(H264dNaluHead_t); if ((p_strm->head_offset + add_size) > HEAD_BUF_MAX_SIZE) { - H264D_ERR("error, head_offset is larger than %d", HEAD_BUF_MAX_SIZE); - goto __FAILED; + H264D_ERR("error, head_offset is larger than %d", HEAD_BUF_MAX_SIZE); + goto __FAILED; } p_des = &p_strm->head_buf[p_strm->head_offset]; ((H264dNaluHead_t *)p_des)->is_frame_end = 1; @@ -338,28 +338,28 @@ static MPP_RET store_cur_nalu(H264dCurCtx_t *p_Cur, H264dCurStream_t *p_strm, H2 || (p_strm->nalu_type == NALU_TYPE_PREFIX) || (p_strm->nalu_type == NALU_TYPE_SLC_EXT)) { - RK_U32 head_size = MPP_MIN(HEAD_SYNTAX_MAX_SIZE, p_strm->nalu_len); - RK_U32 add_size = head_size + sizeof(H264dNaluHead_t); + RK_U32 head_size = MPP_MIN(HEAD_SYNTAX_MAX_SIZE, p_strm->nalu_len); + RK_U32 add_size = head_size + sizeof(H264dNaluHead_t); - if ((p_strm->head_offset + add_size) > HEAD_BUF_MAX_SIZE) { - H264D_ERR("error, head_offset is larger than %d", HEAD_BUF_MAX_SIZE); - goto __FAILED; + if ((p_strm->head_offset + add_size) > HEAD_BUF_MAX_SIZE) { + H264D_ERR("error, head_offset is larger than %d", HEAD_BUF_MAX_SIZE); + goto __FAILED; } p_des = &p_strm->head_buf[p_strm->head_offset]; ((H264dNaluHead_t *)p_des)->is_frame_end = 0; ((H264dNaluHead_t *)p_des)->nalu_type = p_strm->nalu_type; - ((H264dNaluHead_t *)p_des)->sodb_len = head_size; - memcpy(p_des + sizeof(H264dNaluHead_t), p_strm->nalu_buf, head_size); - p_strm->head_offset += add_size; + ((H264dNaluHead_t *)p_des)->sodb_len = head_size; + memcpy(p_des + sizeof(H264dNaluHead_t), p_strm->nalu_buf, head_size); + p_strm->head_offset += add_size; } //!< fill sodb buffer - if ((p_strm->nalu_type == NALU_TYPE_SLICE) + if ((p_strm->nalu_type == NALU_TYPE_SLICE) || (p_strm->nalu_type == NALU_TYPE_IDR)) { - RK_U32 add_size = p_strm->nalu_len + sizeof(g_start_precode); + RK_U32 add_size = p_strm->nalu_len + sizeof(g_start_precode); - if ((dxva_ctx->strm_offset + add_size) > SODB_BUF_MAX_SIZE) { - H264D_ERR("error, bitstream_offset is larger than %d", SODB_BUF_MAX_SIZE); - goto __FAILED; + if ((dxva_ctx->strm_offset + add_size) > SODB_BUF_MAX_SIZE) { + H264D_ERR("error, bitstream_offset is larger than %d", SODB_BUF_MAX_SIZE); + goto __FAILED; } p_des = &dxva_ctx->bitstream[dxva_ctx->strm_offset]; @@ -367,24 +367,23 @@ static MPP_RET store_cur_nalu(H264dCurCtx_t *p_Cur, H264dCurStream_t *p_strm, H2 memcpy(p_des + sizeof(g_start_precode), p_strm->nalu_buf, p_strm->nalu_len); dxva_ctx->strm_offset += add_size; } - if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) { - H264dInputCtx_t *p_Inp = p_Cur->p_Inp; - if ((p_strm->nalu_type == NALU_TYPE_SPS) - || (p_strm->nalu_type == NALU_TYPE_PPS)) { - if (p_Inp->spspps_update_flag) { - p_des = &p_Inp->spspps_buf[p_Inp->spspps_offset]; - memcpy(p_des, g_start_precode, sizeof(g_start_precode)); - memcpy(p_des + sizeof(g_start_precode), p_strm->nalu_buf, p_strm->nalu_len); - p_Inp->spspps_offset += p_strm->nalu_len + sizeof(g_start_precode); - p_Inp->spspps_len = p_Inp->spspps_offset; - } - } - else if ((p_strm->nalu_type == NALU_TYPE_SLICE) - || (p_strm->nalu_type == NALU_TYPE_IDR)) { - p_Cur->p_Inp->spspps_update_flag = 1; - p_Inp->spspps_offset = 0; - } - } + if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) { + H264dInputCtx_t *p_Inp = p_Cur->p_Inp; + if ((p_strm->nalu_type == NALU_TYPE_SPS) + || (p_strm->nalu_type == NALU_TYPE_PPS)) { + if (p_Inp->spspps_update_flag) { + p_des = &p_Inp->spspps_buf[p_Inp->spspps_offset]; + memcpy(p_des, g_start_precode, sizeof(g_start_precode)); + memcpy(p_des + sizeof(g_start_precode), p_strm->nalu_buf, p_strm->nalu_len); + p_Inp->spspps_offset += p_strm->nalu_len + sizeof(g_start_precode); + p_Inp->spspps_len = p_Inp->spspps_offset; + } + } else if ((p_strm->nalu_type == NALU_TYPE_SLICE) + || (p_strm->nalu_type == NALU_TYPE_IDR)) { + p_Cur->p_Inp->spspps_update_flag = 1; + p_Inp->spspps_offset = 0; + } + } return ret = MPP_OK; __FAILED: return ret; @@ -462,19 +461,19 @@ static RK_U64 global_flie_size = 0; */ MPP_RET open_stream_file(H264dInputCtx_t *p_Inp, char *path) { - if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) { + if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) { - sprintf(p_Inp->fname[0], "%s/rkv_h264d_file_00.h264", path); - sprintf(p_Inp->fname[1], "%s/rkv_h264d_file_01.h264", path); + sprintf(p_Inp->fname[0], "%s/rkv_h264d_file_00.h264", path); + sprintf(p_Inp->fname[1], "%s/rkv_h264d_file_01.h264", path); - p_Inp->fp = fopen(p_Inp->fname[global_file_fid], "ab"); { - if (p_Inp->fp == NULL) { - H264D_WARNNING("[open_stream_file] can not open stream file, %s.", p_Inp->fname[global_file_fid]); - } - } - } + p_Inp->fp = fopen(p_Inp->fname[global_file_fid], "ab"); { + if (p_Inp->fp == NULL) { + H264D_WARNNING("[open_stream_file] can not open stream file, %s.", p_Inp->fname[global_file_fid]); + } + } + } - return MPP_OK; + return MPP_OK; } /*! *********************************************************************** @@ -484,28 +483,27 @@ MPP_RET open_stream_file(H264dInputCtx_t *p_Inp, char *path) */ MPP_RET fwrite_stream_to_file(H264dInputCtx_t *p_Inp, RK_U8 *pdata, RK_U32 len) { - if (p_Inp->fp && (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN)) { - if (p_Inp->fp) { - fwrite(pdata, sizeof(RK_U8), len, p_Inp->fp); - fflush(p_Inp->fp); - } - global_flie_size += len; - if (global_flie_size > MAX_ES_FILE_SIZE) { - FCLOSE(p_Inp->fp); - global_file_fid = 1 - global_file_fid; - global_flie_size = 0; - p_Inp->fp = fopen(p_Inp->fname[global_file_fid], "wb"); - if (p_Inp->fp == NULL) { - H264D_WARNNING("[open_stream_file] can not open stream file, %s", p_Inp->fname[global_file_fid]); - } - else { - fwrite(p_Inp->spspps_buf, sizeof(RK_U8), p_Inp->spspps_len, p_Inp->fp); - fflush(p_Inp->fp); - } - } - } + if (p_Inp->fp && (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN)) { + if (p_Inp->fp) { + fwrite(pdata, sizeof(RK_U8), len, p_Inp->fp); + fflush(p_Inp->fp); + } + global_flie_size += len; + if (global_flie_size > MAX_ES_FILE_SIZE) { + FCLOSE(p_Inp->fp); + global_file_fid = 1 - global_file_fid; + global_flie_size = 0; + p_Inp->fp = fopen(p_Inp->fname[global_file_fid], "wb"); + if (p_Inp->fp == NULL) { + H264D_WARNNING("[open_stream_file] can not open stream file, %s", p_Inp->fname[global_file_fid]); + } else { + fwrite(p_Inp->spspps_buf, sizeof(RK_U8), p_Inp->spspps_len, p_Inp->fp); + fflush(p_Inp->fp); + } + } + } - return MPP_OK; + return MPP_OK; } /*! *********************************************************************** @@ -515,14 +513,14 @@ MPP_RET fwrite_stream_to_file(H264dInputCtx_t *p_Inp, RK_U8 *pdata, RK_U32 len) */ MPP_RET close_stream_file(H264dInputCtx_t *p_Inp) { - if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) { - if (p_Inp->fp) { - fflush(p_Inp->fp); - FCLOSE(p_Inp->fp); - } - } + if (rkv_h264d_parse_debug & H264D_DBG_WRITE_ES_EN) { + if (p_Inp->fp) { + fflush(p_Inp->fp); + FCLOSE(p_Inp->fp); + } + } - return MPP_OK; + return MPP_OK; } /*! *********************************************************************** @@ -565,8 +563,8 @@ MPP_RET parse_prepare(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur) pkt_impl->length--; if (p_strm->startcode_found) { if (p_strm->nalu_len >= NALU_BUF_MAX_SIZE) { - H264D_ERR("error, nalu_len is larger than %d", NALU_BUF_MAX_SIZE); - goto __FAILED; + H264D_ERR("error, nalu_len is larger than %d", NALU_BUF_MAX_SIZE); + goto __FAILED; } p_strm->nalu_buf[p_strm->nalu_len++] = *p_strm->curdata; if (p_strm->nalu_len == 1) { @@ -656,8 +654,8 @@ MPP_RET parse_prepare_fast(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur) pkt_impl->length--; if (p_strm->startcode_found) { if (p_strm->nalu_len >= NALU_BUF_MAX_SIZE) { - H264D_ERR("error, nalu_len is larger than %d", NALU_BUF_MAX_SIZE); - goto __FAILED; + H264D_ERR("error, nalu_len is larger than %d", NALU_BUF_MAX_SIZE); + goto __FAILED; } p_strm->nalu_buf[p_strm->nalu_len++] = *p_strm->curdata; if (p_strm->nalu_len == 1) { @@ -874,8 +872,8 @@ MPP_RET parse_prepare_extra_data(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur) p_Cur->p_Inp->task_valid = 1; p_Cur->p_Dec->is_new_frame = 0; - p_Cur->last_dts = p_Inp->in_dts; - p_Cur->last_pts = p_Inp->in_pts; + p_Cur->last_dts = p_Inp->in_dts; + p_Cur->last_pts = p_Inp->in_pts; } //__RETURN: FunctionOut(logctx->parr[RUN_PARSE]); @@ -907,14 +905,14 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec) INP_CHECK(ret, !p_Dec); FunctionIn(p_Dec->logctx.parr[RUN_PARSE]); //!< ==== loop ==== - p_Dec->next_state = SliceSTATE_ResetSlice; + p_Dec->next_state = SliceSTATE_ResetSlice; p_curdata = p_Dec->p_Cur->strm.head_buf; while (while_loop_flag) { switch (p_Dec->next_state) { case SliceSTATE_ResetSlice: reset_slice(p_Dec->p_Vid); - p_Dec->next_state = SliceSTATE_ReadNalu; + p_Dec->next_state = SliceSTATE_ReadNalu; H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_ResetSlice"); break; case SliceSTATE_ReadNalu: @@ -948,32 +946,30 @@ MPP_RET parse_loop(H264_DecCtx_t *p_Dec) H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_ParseNalu"); break; case SliceSTATE_InitPicture: - if (!p_Dec->p_Vid->iNumOfSlicesDecoded) { - FUN_CHECK(ret = init_picture(&p_Dec->p_Cur->slice)); - p_Dec->is_parser_end = 1; - } - p_Dec->next_state = SliceSTATE_GetSliceData; + if (!p_Dec->p_Vid->iNumOfSlicesDecoded) { + FUN_CHECK(ret = init_picture(&p_Dec->p_Cur->slice)); + p_Dec->is_parser_end = 1; + } + p_Dec->next_state = SliceSTATE_GetSliceData; H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_InitPicture"); break; case SliceSTATE_GetSliceData: FUN_CHECK(ret = fill_slice_syntax(&p_Dec->p_Cur->slice, p_Dec->dxva_ctx)); p_Dec->p_Vid->iNumOfSlicesDecoded++; - if (p_Dec->is_parser_end) { - p_Dec->next_state = SliceSTATE_RegisterOneFrame; - } - else - { - p_Dec->next_state = SliceSTATE_ResetSlice; - } + if (p_Dec->is_parser_end) { + p_Dec->next_state = SliceSTATE_RegisterOneFrame; + } else { + p_Dec->next_state = SliceSTATE_ResetSlice; + } H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_GetSliceData"); break; case SliceSTATE_RegisterOneFrame: - if (!p_Dec->is_parser_end){ - ret = MPP_NOK; - goto __FAILED; - } - commit_buffer(p_Dec->dxva_ctx); - while_loop_flag = 0; + if (!p_Dec->is_parser_end) { + ret = MPP_NOK; + goto __FAILED; + } + commit_buffer(p_Dec->dxva_ctx); + while_loop_flag = 0; p_Dec->next_state = SliceSTATE_ReadNalu; H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_RegisterOneFrame"); break; diff --git a/mpp/codec/dec/h264/h264d_slice.c b/mpp/codec/dec/h264/h264d_slice.c index 10fae08e..1cf35d35 100644 --- a/mpp/codec/dec/h264/h264d_slice.c +++ b/mpp/codec/dec/h264/h264d_slice.c @@ -36,14 +36,14 @@ static MPP_RET ref_pic_list_mvc_modification(H264_SLICE_t *currSlice) if ((currSlice->slice_type % 5) != I_SLICE && (currSlice->slice_type % 5) != SI_SLICE) { READ_ONEBIT(p_bitctx, &currSlice->ref_pic_list_reordering_flag[LIST_0], "ref_pic_list_reordering_flag"); if (currSlice->ref_pic_list_reordering_flag[LIST_0]) { - RK_U32 size = currSlice->num_ref_idx_active[LIST_0] + 1; + RK_U32 size = currSlice->num_ref_idx_active[LIST_0] + 1; i = 0; do { - if (i >= size) { - ret = MPP_NOK; - H264D_WARNNING("ref_pic_list_reordering error, i >= num_ref_idx_active[LIST_0](%d)", size); - goto __BITREAD_ERR; - } + if (i >= size) { + ret = MPP_NOK; + H264D_WARNNING("ref_pic_list_reordering error, i >= num_ref_idx_active[LIST_0](%d)", size); + goto __BITREAD_ERR; + } READ_UE(p_bitctx, &modification_of_pic_nums_idc, "modification_of_pic_nums_idc"); currSlice->modification_of_pic_nums_idc[LIST_0][i] = modification_of_pic_nums_idc; if (modification_of_pic_nums_idc == 0 || modification_of_pic_nums_idc == 1) { @@ -62,14 +62,14 @@ static MPP_RET ref_pic_list_mvc_modification(H264_SLICE_t *currSlice) if (currSlice->slice_type % 5 == B_SLICE) { READ_ONEBIT(p_bitctx, &currSlice->ref_pic_list_reordering_flag[LIST_1], "ref_pic_list_reordering_flag"); if (currSlice->ref_pic_list_reordering_flag[LIST_1]) { - RK_U32 size = currSlice->num_ref_idx_active[LIST_1] + 1; + RK_U32 size = currSlice->num_ref_idx_active[LIST_1] + 1; i = 0; do { - if (i >= size) { - ret = MPP_NOK; - H264D_WARNNING("ref_pic_list_reordering error, i >= num_ref_idx_active[LIST_1](%d)", size); - goto __BITREAD_ERR; - } + if (i >= size) { + ret = MPP_NOK; + H264D_WARNNING("ref_pic_list_reordering error, i >= num_ref_idx_active[LIST_1](%d)", size); + goto __BITREAD_ERR; + } READ_UE(p_bitctx, &modification_of_pic_nums_idc, "modification_of_pic_nums_idc"); currSlice->modification_of_pic_nums_idc[LIST_1][i] = modification_of_pic_nums_idc; if (modification_of_pic_nums_idc == 0 || modification_of_pic_nums_idc == 1) { @@ -91,7 +91,7 @@ static MPP_RET ref_pic_list_mvc_modification(H264_SLICE_t *currSlice) __BITREAD_ERR: ret = p_bitctx->ret; - return ret; + return ret; } static MPP_RET pred_weight_table(H264_SLICE_t *currSlice) @@ -167,9 +167,9 @@ static MPP_RET dec_ref_pic_marking(H264_SLICE_t *pSlice) READ_ONEBIT(p_bitctx, &pSlice->adaptive_ref_pic_buffering_flag, "adaptive_ref_pic_buffering_flag"); if (pSlice->adaptive_ref_pic_buffering_flag) { - RK_U32 i = 0; + RK_U32 i = 0; do { //!< read Memory Management Control Operation - tmp_drpm = &pSlice->p_Cur->dec_ref_pic_marking_buffer[i]; + tmp_drpm = &pSlice->p_Cur->dec_ref_pic_marking_buffer[i]; tmp_drpm->Next = NULL; READ_UE(p_bitctx, &val, "memory_management_control_operation"); tmp_drpm->memory_management_control_operation = val; @@ -196,7 +196,7 @@ static MPP_RET dec_ref_pic_marking(H264_SLICE_t *pSlice) } tmp_drpm2->Next = tmp_drpm; } - i++; + i++; } while (val != 0); } } @@ -205,7 +205,7 @@ static MPP_RET dec_ref_pic_marking(H264_SLICE_t *pSlice) __BITREAD_ERR: ret = p_bitctx->ret; - return ret; + return ret; } static void init_slice_parmeters(H264_SLICE_t *currSlice) @@ -216,14 +216,14 @@ static void init_slice_parmeters(H264_SLICE_t *currSlice) //--- init slice syntax currSlice->idr_flag = ((cur_nalu->nalu_type == NALU_TYPE_IDR) || (currSlice->mvcExt.valid && !currSlice->mvcExt.non_idr_flag)); - currSlice->nal_reference_idc = cur_nalu->nal_reference_idc; - //!< set ref flag and dpb error flag - { - p_Vid->p_Dec->errctx.used_ref_flag = currSlice->nal_reference_idc ? 1 : 0; - if (currSlice->slice_type == I_SLICE) { - p_Vid->p_Dec->errctx.dpb_err_flag = 0; - } - } + currSlice->nal_reference_idc = cur_nalu->nal_reference_idc; + //!< set ref flag and dpb error flag + { + p_Vid->p_Dec->errctx.used_ref_flag = currSlice->nal_reference_idc ? 1 : 0; + if (currSlice->slice_type == I_SLICE) { + p_Vid->p_Dec->errctx.dpb_err_flag = 0; + } + } if ((!currSlice->svc_extension_flag) || currSlice->mvcExt.iPrefixNALU) { // MVC or have prefixNALU currSlice->view_id = currSlice->mvcExt.view_id; currSlice->inter_view_flag = currSlice->mvcExt.inter_view_flag; @@ -373,21 +373,21 @@ __FAILED: //extern "C" MPP_RET reset_cur_slice(H264dCurCtx_t *p_Cur, H264_SLICE_t *p) { - if (p) { - p->modification_of_pic_nums_idc[LIST_0] = p_Cur->modification_of_pic_nums_idc[LIST_0]; - p->abs_diff_pic_num_minus1[LIST_0] = p_Cur->abs_diff_pic_num_minus1[LIST_0]; - p->long_term_pic_idx[LIST_0] = p_Cur->long_term_pic_idx[LIST_0]; - p->abs_diff_view_idx_minus1[LIST_0] = p_Cur->abs_diff_view_idx_minus1[LIST_0]; + if (p) { + p->modification_of_pic_nums_idc[LIST_0] = p_Cur->modification_of_pic_nums_idc[LIST_0]; + p->abs_diff_pic_num_minus1[LIST_0] = p_Cur->abs_diff_pic_num_minus1[LIST_0]; + p->long_term_pic_idx[LIST_0] = p_Cur->long_term_pic_idx[LIST_0]; + p->abs_diff_view_idx_minus1[LIST_0] = p_Cur->abs_diff_view_idx_minus1[LIST_0]; - p->modification_of_pic_nums_idc[LIST_1] = p_Cur->modification_of_pic_nums_idc[LIST_1]; - p->abs_diff_pic_num_minus1[LIST_1] = p_Cur->abs_diff_pic_num_minus1[LIST_1]; - p->long_term_pic_idx[LIST_1] = p_Cur->long_term_pic_idx[LIST_1]; - p->abs_diff_view_idx_minus1[LIST_1] = p_Cur->abs_diff_view_idx_minus1[LIST_1]; + p->modification_of_pic_nums_idc[LIST_1] = p_Cur->modification_of_pic_nums_idc[LIST_1]; + p->abs_diff_pic_num_minus1[LIST_1] = p_Cur->abs_diff_pic_num_minus1[LIST_1]; + p->long_term_pic_idx[LIST_1] = p_Cur->long_term_pic_idx[LIST_1]; + p->abs_diff_view_idx_minus1[LIST_1] = p_Cur->abs_diff_view_idx_minus1[LIST_1]; - p->dec_ref_pic_marking_buffer = NULL; - } + p->dec_ref_pic_marking_buffer = NULL; + } - return MPP_OK; + return MPP_OK; } /*! @@ -420,62 +420,56 @@ MPP_RET process_slice(H264_SLICE_t *currSlice) p_Vid->slice_type = currSlice->slice_type = temp % 5; READ_UE(p_bitctx, &currSlice->pic_parameter_set_id, "slice_pic_parameter_set_id"); init_slice_parmeters(currSlice); - FUN_CHECK(ret = set_slice_user_parmeters(currSlice)); - //!< read rest slice header syntax - { - READ_BITS(p_bitctx, currSlice->active_sps->log2_max_frame_num_minus4 + 4, &currSlice->frame_num, "frame_num"); - if (currSlice->active_sps->frame_mbs_only_flag) { //!< user in_slice info - p_Vid->structure = FRAME; - currSlice->field_pic_flag = 0; - currSlice->bottom_field_flag = 0; - } - else { - READ_ONEBIT(p_bitctx, &currSlice->field_pic_flag, "field_pic_flag"); - if (currSlice->field_pic_flag) { - READ_ONEBIT(p_bitctx, &currSlice->bottom_field_flag, "field_pic_flag"); - p_Vid->structure = currSlice->bottom_field_flag ? BOTTOM_FIELD : TOP_FIELD; - } - else { - p_Vid->structure = FRAME; - currSlice->bottom_field_flag = 0; - } - } - currSlice->structure = p_Vid->structure; - currSlice->mb_aff_frame_flag = (currSlice->active_sps->mb_adaptive_frame_field_flag && (currSlice->field_pic_flag == 0)); - if (currSlice->idr_flag) { - READ_UE(p_bitctx, &currSlice->idr_pic_id, "idr_pic_id"); - } - else if (currSlice->svc_extension_flag == 0 && currSlice->mvcExt.non_idr_flag == 0) { - READ_UE(p_bitctx, &currSlice->idr_pic_id, "idr_pic_id"); - } - poc_used_bits = p_bitctx->used_bits; //!< init poc used bits - if (currSlice->active_sps->pic_order_cnt_type == 0) { - READ_BITS(p_bitctx, currSlice->active_sps->log2_max_pic_order_cnt_lsb_minus4 + 4, &currSlice->pic_order_cnt_lsb, "pic_order_cnt_lsb"); - if (currSlice->p_Vid->active_pps->bottom_field_pic_order_in_frame_present_flag == 1 - && !currSlice->field_pic_flag) { - READ_SE(p_bitctx, &currSlice->delta_pic_order_cnt_bottom, "delta_pic_order_cnt_bottom"); - } - else { - currSlice->delta_pic_order_cnt_bottom = 0; - } - } - if (currSlice->active_sps->pic_order_cnt_type == 1) { - if (!currSlice->active_sps->delta_pic_order_always_zero_flag) { - READ_SE(p_bitctx, &currSlice->delta_pic_order_cnt[0], "delta_pic_order_cnt[0]"); + FUN_CHECK(ret = set_slice_user_parmeters(currSlice)); + //!< read rest slice header syntax + { + READ_BITS(p_bitctx, currSlice->active_sps->log2_max_frame_num_minus4 + 4, &currSlice->frame_num, "frame_num"); + if (currSlice->active_sps->frame_mbs_only_flag) { //!< user in_slice info + p_Vid->structure = FRAME; + currSlice->field_pic_flag = 0; + currSlice->bottom_field_flag = 0; + } else { + READ_ONEBIT(p_bitctx, &currSlice->field_pic_flag, "field_pic_flag"); + if (currSlice->field_pic_flag) { + READ_ONEBIT(p_bitctx, &currSlice->bottom_field_flag, "field_pic_flag"); + p_Vid->structure = currSlice->bottom_field_flag ? BOTTOM_FIELD : TOP_FIELD; + } else { + p_Vid->structure = FRAME; + currSlice->bottom_field_flag = 0; + } + } + currSlice->structure = p_Vid->structure; + currSlice->mb_aff_frame_flag = (currSlice->active_sps->mb_adaptive_frame_field_flag && (currSlice->field_pic_flag == 0)); + if (currSlice->idr_flag) { + READ_UE(p_bitctx, &currSlice->idr_pic_id, "idr_pic_id"); + } else if (currSlice->svc_extension_flag == 0 && currSlice->mvcExt.non_idr_flag == 0) { + READ_UE(p_bitctx, &currSlice->idr_pic_id, "idr_pic_id"); + } + poc_used_bits = p_bitctx->used_bits; //!< init poc used bits + if (currSlice->active_sps->pic_order_cnt_type == 0) { + READ_BITS(p_bitctx, currSlice->active_sps->log2_max_pic_order_cnt_lsb_minus4 + 4, &currSlice->pic_order_cnt_lsb, "pic_order_cnt_lsb"); + if (currSlice->p_Vid->active_pps->bottom_field_pic_order_in_frame_present_flag == 1 + && !currSlice->field_pic_flag) { + READ_SE(p_bitctx, &currSlice->delta_pic_order_cnt_bottom, "delta_pic_order_cnt_bottom"); + } else { + currSlice->delta_pic_order_cnt_bottom = 0; + } + } + if (currSlice->active_sps->pic_order_cnt_type == 1) { + if (!currSlice->active_sps->delta_pic_order_always_zero_flag) { + READ_SE(p_bitctx, &currSlice->delta_pic_order_cnt[0], "delta_pic_order_cnt[0]"); - if (currSlice->p_Vid->active_pps->bottom_field_pic_order_in_frame_present_flag == 1 && !currSlice->field_pic_flag) { - READ_SE(p_bitctx, &currSlice->delta_pic_order_cnt[1], "delta_pic_order_cnt[1]"); - } - else { - currSlice->delta_pic_order_cnt[1] = 0; //!< set to zero if not in stream - } - } - else { - currSlice->delta_pic_order_cnt[0] = 0; - currSlice->delta_pic_order_cnt[1] = 0; - } - } - currSlice->poc_used_bitlen = p_bitctx->used_bits - poc_used_bits; //!< calculate poc used bit length + if (currSlice->p_Vid->active_pps->bottom_field_pic_order_in_frame_present_flag == 1 && !currSlice->field_pic_flag) { + READ_SE(p_bitctx, &currSlice->delta_pic_order_cnt[1], "delta_pic_order_cnt[1]"); + } else { + currSlice->delta_pic_order_cnt[1] = 0; //!< set to zero if not in stream + } + } else { + currSlice->delta_pic_order_cnt[0] = 0; + currSlice->delta_pic_order_cnt[1] = 0; + } + } + currSlice->poc_used_bitlen = p_bitctx->used_bits - poc_used_bits; //!< calculate poc used bit length //!< redundant_pic_cnt is missing here ASSERT(currSlice->p_Vid->active_pps->redundant_pic_cnt_present_flag == 0); // add by dw, high 4:2:2 profile not support if (currSlice->p_Vid->active_pps->redundant_pic_cnt_present_flag) { @@ -517,10 +511,10 @@ MPP_RET process_slice(H264_SLICE_t *currSlice) } if (g_max_bytes < (p_bitctx->used_bits >> 3)) { g_max_bytes = (p_bitctx->used_bits >> 3); - } - H264D_DBG(H264D_DBG_PPS_SPS, "[SLICE_HEAD] type=%d, layer_id=%d,sps_id=%d, pps_id=%d, struct=%d, frame_num=%d", - currSlice->slice_type, currSlice->layer_id, currSlice->active_sps->seq_parameter_set_id, - currSlice->active_pps->pic_parameter_set_id, currSlice->structure, currSlice->frame_num); + } + H264D_DBG(H264D_DBG_PPS_SPS, "[SLICE_HEAD] type=%d, layer_id=%d,sps_id=%d, pps_id=%d, struct=%d, frame_num=%d", + currSlice->slice_type, currSlice->layer_id, currSlice->active_sps->seq_parameter_set_id, + currSlice->active_pps->pic_parameter_set_id, currSlice->structure, currSlice->frame_num); } FunctionOut(logctx->parr[RUN_PARSE]); diff --git a/mpp/codec/dec/h264/h264d_slice.h b/mpp/codec/dec/h264/h264d_slice.h index 1c1a193e..01e3d0ca 100644 --- a/mpp/codec/dec/h264/h264d_slice.h +++ b/mpp/codec/dec/h264/h264d_slice.h @@ -27,7 +27,7 @@ #ifdef __cplusplus extern "C" { -#endif +#endif MPP_RET process_slice(H264_SLICE_t *currSlice); diff --git a/mpp/codec/dec/m2v/m2vd_parser.c b/mpp/codec/dec/m2v/m2vd_parser.c index f2ee2c9a..f380628c 100644 --- a/mpp/codec/dec/m2v/m2vd_parser.c +++ b/mpp/codec/dec/m2v/m2vd_parser.c @@ -973,7 +973,7 @@ MPP_RET m2vd_decode_head(M2VDParserContext *ctx) MPP_RET m2vd_alloc_frame(M2VDParserContext *ctx) { - RK_U32 pts = (RK_U32)(ctx->pts/1000); + RK_U32 pts = (RK_U32)(ctx->pts / 1000); if (ctx->resetFlag && ctx->pic_head.picture_coding_type != M2VD_CODING_TYPE_I) { mpp_log("[m2v]: resetFlag[%d] && picture_coding_type[%d] != I_TYPE", ctx->resetFlag, ctx->pic_head.picture_coding_type); return MPP_NOK; @@ -1006,7 +1006,7 @@ MPP_RET m2vd_alloc_frame(M2VDParserContext *ctx) ctx->frame_period = tmp_frame_period; } } - ctx->Group_start_Time =pts - (ctx->pic_head.temporal_reference * ctx->frame_period / 256); + ctx->Group_start_Time = pts - (ctx->pic_head.temporal_reference * ctx->frame_period / 256); if (ctx->Group_start_Time < 0) ctx->Group_start_Time = 0; ctx->PreGetFrameTime = pts; diff --git a/mpp/codec/dec/vp9/vp9d_parser.c b/mpp/codec/dec/vp9/vp9d_parser.c index 27f9a0ee..f2686373 100644 --- a/mpp/codec/dec/vp9/vp9d_parser.c +++ b/mpp/codec/dec/vp9/vp9d_parser.c @@ -1652,25 +1652,25 @@ RK_S32 vp9_parser_frame(Vp9CodecContext *ctx, HalDecTask *task) } vp9d_dbg(VP9D_DBG_REF, "s->refreshrefmask = %d s->frames[CUR_FRAME] = %d", s->refreshrefmask, s->frames[CUR_FRAME].slot_index); for (i = 0; i < 3; i++) { - if (s->refs[s->refidx[i]].ref != NULL) { - vp9d_dbg(VP9D_DBG_REF, "ref buf select %d", s->refs[s->refidx[i]].slot_index); - } + if (s->refs[s->refidx[i]].ref != NULL) { + vp9d_dbg(VP9D_DBG_REF, "ref buf select %d", s->refs[s->refidx[i]].slot_index); + } } // ref frame setup for (i = 0; i < 8; i++) { - vp9d_dbg(VP9D_DBG_REF, "s->refreshrefmask = 0x%x", s->refreshrefmask); - res = 0; - if (s->refreshrefmask & (1 << i)) { - if (s->refs[i].ref) - vp9_unref_frame(s, &s->refs[i]); - vp9d_dbg(VP9D_DBG_REF, "update ref index in %d", i); - res = vp9_ref_frame(ctx, &s->refs[i], &s->frames[CUR_FRAME]); - } + vp9d_dbg(VP9D_DBG_REF, "s->refreshrefmask = 0x%x", s->refreshrefmask); + res = 0; + if (s->refreshrefmask & (1 << i)) { + if (s->refs[i].ref) + vp9_unref_frame(s, &s->refs[i]); + vp9d_dbg(VP9D_DBG_REF, "update ref index in %d", i); + res = vp9_ref_frame(ctx, &s->refs[i], &s->frames[CUR_FRAME]); + } - if (s->refs[i].ref) - vp9d_dbg(VP9D_DBG_REF, "s->refs[%d] = %d", i, s->refs[i].slot_index); - if (res < 0) - return 0; + if (s->refs[i].ref) + vp9d_dbg(VP9D_DBG_REF, "s->refs[%d] = %d", i, s->refs[i].slot_index); + if (res < 0) + return 0; } return 0; } @@ -1826,6 +1826,6 @@ void vp9_parser_update(Vp9CodecContext *ctx, void *count_info) } } - + return; } diff --git a/mpp/codec/inc/avsd_api.h b/mpp/codec/inc/avsd_api.h index 1fcafb68..64ed7185 100644 --- a/mpp/codec/inc/avsd_api.h +++ b/mpp/codec/inc/avsd_api.h @@ -47,8 +47,8 @@ do {\ #define AVSD_DBG(level, fmt, ...)\ do {\ - if (level & avsd_parse_debug)\ - { mpp_log(fmt, ## __VA_ARGS__); }\ + if (level & avsd_parse_debug)\ + { mpp_log(fmt, ## __VA_ARGS__); }\ } while (0) #ifdef INP_CHECK @@ -58,9 +58,9 @@ do {\ #define INP_CHECK(ret, val, ...)\ do{\ if ((val)) {\ - ret = MPP_ERR_INIT; \ - AVSD_DBG(AVSD_DBG_WARNNING, "input empty(%d).\n", __LINE__); \ - goto __RETURN; \ + ret = MPP_ERR_INIT; \ + AVSD_DBG(AVSD_DBG_WARNNING, "input empty(%d).\n", __LINE__); \ + goto __RETURN; \ }} while (0) #ifdef MEM_CHECK #undef MEM_CHECK @@ -69,9 +69,9 @@ do{\ #define MEM_CHECK(ret, val, ...)\ do{\ if(!(val)) {\ - ret = MPP_ERR_MALLOC;\ - AVSD_DBG(AVSD_DBG_ERROR, "malloc buffer error(%d).\n", __LINE__); \ - goto __FAILED; \ + ret = MPP_ERR_MALLOC;\ + AVSD_DBG(AVSD_DBG_ERROR, "malloc buffer error(%d).\n", __LINE__); \ + goto __FAILED; \ }} while (0) #ifdef FUN_CHECK #undef FUN_CHECK @@ -80,8 +80,8 @@ do{\ #define FUN_CHECK(val)\ do{\ if ((val) < 0) {\ - AVSD_DBG(AVSD_DBG_WARNNING, "Function error(%d).\n", __LINE__); \ - goto __FAILED; \ + AVSD_DBG(AVSD_DBG_WARNNING, "Function error(%d).\n", __LINE__); \ + goto __FAILED; \ }} while (0) diff --git a/mpp/codec/mpp_dec.cpp b/mpp/codec/mpp_dec.cpp index 56a8517f..c7ccd95e 100644 --- a/mpp/codec/mpp_dec.cpp +++ b/mpp/codec/mpp_dec.cpp @@ -185,7 +185,7 @@ static RK_U32 reset_dec_task(Mpp *mpp, DecTask *task) mpp_buf_slot_reset(frame_slots, task_dec->output); } - if(task->status.task_parsed_rdy){ + if (task->status.task_parsed_rdy) { mpp_log("task no send to hal que must clr current frame hal status"); mpp_buf_slot_clr_flag(frame_slots, task_dec->output, SLOT_HAL_OUTPUT); for (RK_U32 i = 0; i < MPP_ARRAY_ELEMS(task_dec->refer); i++) { @@ -316,14 +316,14 @@ static MPP_RET try_proc_dec_task(Mpp *mpp, DecTask *task) * */ if (!task->status.curr_task_rdy) { - RK_S64 p_e, p_s,diff; + RK_S64 p_e, p_s, diff; p_s = mpp_time(); parser_prepare(dec->parser, dec->mpp_pkt_in, task_dec); p_e = mpp_time(); - if(mpp_debug & MPP_TIMING){ - diff = (p_e - p_s)/1000; - if(diff > 15){ - mpp_log("waring mpp prepare stream consume %lld big than 15ms ",diff); + if (mpp_debug & MPP_TIMING) { + diff = (p_e - p_s) / 1000; + if (diff > 15) { + mpp_log("waring mpp prepare stream consume %lld big than 15ms ", diff); } } if (0 == mpp_packet_get_length(dec->mpp_pkt_in)) { @@ -619,7 +619,7 @@ void *mpp_dec_hal_thread(void *data) HalDecTask *task_dec = &task_info.dec; RK_S64 cur_deat = 0; RK_U64 dec_no = 0, total_time = 0; - RK_S64 p_s,p_e; + RK_S64 p_s, p_e; p_s = mpp_time(); while (MPP_THREAD_RUNNING == hal->get_status()) { /* @@ -879,10 +879,10 @@ MPP_RET mpp_dec_control(MppDec *dec, MpiCmd cmd, void *param) mpp_slots_set_prop(dec->frame_slots, SLOTS_FRAME_INFO, frame); mpp_frame_deinit(&frame); } break; - case MPP_CODEC_GET_VPUMEM_USED_COUNT: { - RK_S32 *p = (RK_S32 *)param; - *p = mpp_buf_slot_get_used_size(dec->frame_slots); - } break; + case MPP_CODEC_GET_VPUMEM_USED_COUNT: { + RK_S32 *p = (RK_S32 *)param; + *p = mpp_buf_slot_get_used_size(dec->frame_slots); + } break; default : { } break; } diff --git a/mpp/hal/inc/hal_avsd_api.h b/mpp/hal/inc/hal_avsd_api.h index 2d3db287..f7adb755 100644 --- a/mpp/hal/inc/hal_avsd_api.h +++ b/mpp/hal/inc/hal_avsd_api.h @@ -38,8 +38,8 @@ extern RK_U32 avsd_hal_debug; #define AVSD_HAL_DBG(level, fmt, ...)\ do {\ - if (level & avsd_hal_debug)\ - { mpp_log(fmt, ## __VA_ARGS__); }\ + if (level & avsd_hal_debug)\ + { mpp_log(fmt, ## __VA_ARGS__); }\ } while (0) @@ -57,17 +57,17 @@ do {\ #define INP_CHECK(ret, val, ...)\ do{\ if ((val)) { \ - ret = MPP_ERR_INIT; \ - AVSD_HAL_DBG(AVSD_HAL_DBG_WARNNING, "input empty(%d).\n", __LINE__); \ - goto __RETURN; \ + ret = MPP_ERR_INIT; \ + AVSD_HAL_DBG(AVSD_HAL_DBG_WARNNING, "input empty(%d).\n", __LINE__); \ + goto __RETURN; \ }} while (0) typedef struct avsd_hal_ctx_t { - MppBufSlots frame_slots; - MppBufSlots packet_slots; - IOInterruptCB init_cb; + MppBufSlots frame_slots; + MppBufSlots packet_slots; + IOInterruptCB init_cb; } AvsdHalCtx_t; diff --git a/mpp/hal/inc/hal_task.h b/mpp/hal/inc/hal_task.h index e58ef864..39d522df 100644 --- a/mpp/hal/inc/hal_task.h +++ b/mpp/hal/inc/hal_task.h @@ -85,8 +85,8 @@ typedef union HalDecTaskFlag_t { struct { RK_U32 eos : 1; RK_U32 info_change : 1; - RK_U32 had_error : 1; - RK_U32 used_for_ref : 1; + RK_U32 had_error : 1; + RK_U32 used_for_ref : 1; }; } HalDecTaskFlag; diff --git a/mpp/hal/rkdec/avsd/hal_avsd_api.c b/mpp/hal/rkdec/avsd/hal_avsd_api.c index 9bc4b40d..3579c0b8 100644 --- a/mpp/hal/rkdec/avsd/hal_avsd_api.c +++ b/mpp/hal/rkdec/avsd/hal_avsd_api.c @@ -37,17 +37,17 @@ RK_U32 avsd_hal_debug = 0; static RK_U32 avsd_ver_align(RK_U32 val) { - return MPP_ALIGN(val, 16); + return MPP_ALIGN(val, 16); } static RK_U32 avsd_hor_align(RK_U32 val) { - return MPP_ALIGN(val, 16); + return MPP_ALIGN(val, 16); } static RK_U32 avsd_len_align(RK_U32 val) { - return (2 * MPP_ALIGN(val, 16)); + return (2 * MPP_ALIGN(val, 16)); } /*! *********************************************************************** @@ -59,27 +59,27 @@ static RK_U32 avsd_len_align(RK_U32 val) MPP_RET hal_avsd_init(void *decoder, MppHalCfg *cfg) { MPP_RET ret = MPP_ERR_UNKNOW; - AvsdHalCtx_t *p_hal = NULL; + AvsdHalCtx_t *p_hal = NULL; AVSD_HAL_TRACE("In."); - INP_CHECK(ret, NULL == decoder); + INP_CHECK(ret, NULL == decoder); - mpp_env_get_u32("avsd_debug", &avsd_hal_debug, 0); + mpp_env_get_u32("avsd_debug", &avsd_hal_debug, 0); - p_hal = (AvsdHalCtx_t *)decoder; - memset(p_hal, 0, sizeof(AvsdHalCtx_t)); + p_hal = (AvsdHalCtx_t *)decoder; + memset(p_hal, 0, sizeof(AvsdHalCtx_t)); - p_hal->frame_slots = cfg->frame_slots; - p_hal->packet_slots = cfg->packet_slots; - //!< callback function to parser module - p_hal->init_cb = cfg->hal_int_cb; + p_hal->frame_slots = cfg->frame_slots; + p_hal->packet_slots = cfg->packet_slots; + //!< callback function to parser module + p_hal->init_cb = cfg->hal_int_cb; - mpp_slots_set_prop(p_hal->frame_slots, SLOTS_HOR_ALIGN, avsd_hor_align); - mpp_slots_set_prop(p_hal->frame_slots, SLOTS_VER_ALIGN, avsd_ver_align); - mpp_slots_set_prop(p_hal->frame_slots, SLOTS_LEN_ALIGN, avsd_len_align); + mpp_slots_set_prop(p_hal->frame_slots, SLOTS_HOR_ALIGN, avsd_hor_align); + mpp_slots_set_prop(p_hal->frame_slots, SLOTS_VER_ALIGN, avsd_ver_align); + mpp_slots_set_prop(p_hal->frame_slots, SLOTS_LEN_ALIGN, avsd_len_align); __RETURN: - AVSD_HAL_TRACE("Out."); + AVSD_HAL_TRACE("Out."); (void)decoder; (void)cfg; return ret = MPP_OK; @@ -97,7 +97,7 @@ MPP_RET hal_avsd_deinit(void *decoder) AVSD_HAL_TRACE("In."); - AVSD_HAL_TRACE("Out."); + AVSD_HAL_TRACE("Out."); (void)decoder; return ret = MPP_OK; } @@ -110,24 +110,24 @@ MPP_RET hal_avsd_deinit(void *decoder) //extern "C" MPP_RET hal_avsd_gen_regs(void *decoder, HalTaskInfo *task) { - MPP_RET ret = MPP_ERR_UNKNOW; - AvsdHalCtx_t *p_hal = NULL; + MPP_RET ret = MPP_ERR_UNKNOW; + AvsdHalCtx_t *p_hal = NULL; AVSD_HAL_TRACE("In."); - INP_CHECK(ret, NULL == decoder); + INP_CHECK(ret, NULL == decoder); - p_hal = (AvsdHalCtx_t *)decoder; + p_hal = (AvsdHalCtx_t *)decoder; - if (p_hal->init_cb.callBack) { - p_hal->init_cb.callBack(p_hal->init_cb.opaque, task); - } + if (p_hal->init_cb.callBack) { + p_hal->init_cb.callBack(p_hal->init_cb.opaque, task); + } __RETURN: - AVSD_HAL_TRACE("Out."); - + AVSD_HAL_TRACE("Out."); - (void)decoder; + + (void)decoder; (void)task; return ret = MPP_OK; } @@ -143,10 +143,10 @@ MPP_RET hal_avsd_start(void *decoder, HalTaskInfo *task) MPP_RET ret = MPP_ERR_UNKNOW; AVSD_HAL_TRACE("In."); - INP_CHECK(ret, NULL == decoder); + INP_CHECK(ret, NULL == decoder); __RETURN: - AVSD_HAL_TRACE("Out."); + AVSD_HAL_TRACE("Out."); (void)decoder; (void)task; return ret = MPP_OK; @@ -161,19 +161,19 @@ __RETURN: MPP_RET hal_avsd_wait(void *decoder, HalTaskInfo *task) { MPP_RET ret = MPP_ERR_UNKNOW; - //AvsdHalCtx_t *p_hal = NULL; + //AvsdHalCtx_t *p_hal = NULL; - AVSD_HAL_TRACE("In."); + AVSD_HAL_TRACE("In."); - INP_CHECK(ret, NULL == decoder); - //p_hal = (AvsdHalCtx_t *)decoder; + INP_CHECK(ret, NULL == decoder); + //p_hal = (AvsdHalCtx_t *)decoder; - //if (p_hal->init_cb.callBack) { - // p_hal->init_cb.callBack(p_hal->init_cb.opaque, task); - //} + //if (p_hal->init_cb.callBack) { + // p_hal->init_cb.callBack(p_hal->init_cb.opaque, task); + //} __RETURN: - AVSD_HAL_TRACE("Out."); + AVSD_HAL_TRACE("Out."); (void)decoder; (void)task; return ret = MPP_OK; diff --git a/mpp/hal/rkdec/h264d/hal_h264d_api.c b/mpp/hal/rkdec/h264d/hal_h264d_api.c index ade9d463..35d8bd93 100644 --- a/mpp/hal/rkdec/h264d/hal_h264d_api.c +++ b/mpp/hal/rkdec/h264d/hal_h264d_api.c @@ -204,12 +204,12 @@ MPP_RET hal_h264d_init(void *hal, MppHalCfg *cfg) p_hal->frame_slots = cfg->frame_slots; p_hal->packet_slots = cfg->packet_slots; - //!< choose hard mode -#ifdef RKPLATFORM - { - RK_S32 value = (!!access("/dev/rkvdec", F_OK)); - cfg->device_id = value ? HAL_VDPU : HAL_RKVDEC; - } + //!< choose hard mode +#ifdef RKPLATFORM + { + RK_S32 value = (!!access("/dev/rkvdec", F_OK)); + cfg->device_id = value ? HAL_VDPU : HAL_RKVDEC; + } #endif switch (cfg->device_id) { case HAL_RKVDEC: diff --git a/mpp/hal/rkdec/h264d/hal_h264d_rkv_pkt.c b/mpp/hal/rkdec/h264d/hal_h264d_rkv_pkt.c index 1083e13a..94af5bbb 100644 --- a/mpp/hal/rkdec/h264d/hal_h264d_rkv_pkt.c +++ b/mpp/hal/rkdec/h264d/hal_h264d_rkv_pkt.c @@ -45,8 +45,7 @@ #define FPGA_TEST 0 -const enum -{ +const enum { H264ScalingList4x4Length = 16, H264ScalingList8x8Length = 64, } ScalingListLength; diff --git a/mpp/hal/rkdec/h264d/hal_h264d_rkv_reg.c b/mpp/hal/rkdec/h264d/hal_h264d_rkv_reg.c index 0d41f719..22955b86 100644 --- a/mpp/hal/rkdec/h264d/hal_h264d_rkv_reg.c +++ b/mpp/hal/rkdec/h264d/hal_h264d_rkv_reg.c @@ -322,9 +322,9 @@ MPP_RET rkv_h264d_gen_regs(void *hal, HalTaskInfo *task) INP_CHECK(ret, NULL == p_hal); FunctionIn(p_hal->logctx.parr[RUN_HAL]); - if (task->dec.flags.had_error) { - goto __RETURN; - } + if (task->dec.flags.had_error) { + goto __RETURN; + } rkv_prepare_spspps_packet(hal, &pkts->spspps); rkv_prepare_framerps_packet(hal, &pkts->rps); rkv_prepare_scanlist_packet(hal, &pkts->scanlist); @@ -370,9 +370,9 @@ MPP_RET rkv_h264d_start(void *hal, HalTaskInfo *task) INP_CHECK(ret, NULL == p_hal); FunctionIn(p_hal->logctx.parr[RUN_HAL]); - if (task->dec.flags.had_error) { - goto __RETURN; - } + if (task->dec.flags.had_error) { + goto __RETURN; + } p_regs = (RK_U32 *)p_hal->regs; p_regs[64] = 0; @@ -391,13 +391,13 @@ MPP_RET rkv_h264d_start(void *hal, HalTaskInfo *task) rkv_h264d_hal_dump(p_hal, H264D_DBG_GEN_REGS); } } - //!< current buffer slot fd - H264D_DBG(H264D_DBG_DECOUT_INFO, "[DECOUT_INFO] decout_fd=0x%02x", p_regs[7]); + //!< current buffer slot fd + H264D_DBG(H264D_DBG_DECOUT_INFO, "[DECOUT_INFO] decout_fd=0x%02x", p_regs[7]); #ifdef RKPLATFORM - if (VPUClientSendReg(p_hal->vpu_socket, (RK_U32 *)p_regs, DEC_RKV_REGISTERS)) { - ret = MPP_ERR_VPUHW; - H264D_ERR("H264 RKV FlushRegs fail. \n"); - } + if (VPUClientSendReg(p_hal->vpu_socket, (RK_U32 *)p_regs, DEC_RKV_REGISTERS)) { + ret = MPP_ERR_VPUHW; + H264D_ERR("H264 RKV FlushRegs fail. \n"); + } #endif FunctionOut(p_hal->logctx.parr[RUN_HAL]); (void)task; @@ -421,22 +421,22 @@ MPP_RET rkv_h264d_wait(void *hal, HalTaskInfo *task) FunctionIn(p_hal->logctx.parr[RUN_HAL]); p_regs = (H264dRkvRegs_t *)p_hal->regs; - if (task->dec.flags.had_error) { - goto __SKIP_HARD; - } + if (task->dec.flags.had_error) { + goto __SKIP_HARD; + } #ifdef RKPLATFORM - RK_S32 wait_ret = -1; - RK_S32 ret_len = 0, cur_deat = 0; - VPU_CMD_TYPE ret_cmd = VPU_CMD_BUTT; - RK_S64 p_s,p_e; - p_s = mpp_time(); - wait_ret = VPUClientWaitResult(p_hal->vpu_socket, (RK_U32 *)p_hal->regs, DEC_RKV_REGISTERS, &ret_cmd, &ret_len); - p_e = mpp_time(); - cur_deat = (p_e - p_s)/1000; - p_hal->total_time += cur_deat; - p_hal->iDecodedNum++; - (void)wait_ret; -#endif + RK_S32 wait_ret = -1; + RK_S32 ret_len = 0, cur_deat = 0; + VPU_CMD_TYPE ret_cmd = VPU_CMD_BUTT; + RK_S64 p_s, p_e; + p_s = mpp_time(); + wait_ret = VPUClientWaitResult(p_hal->vpu_socket, (RK_U32 *)p_hal->regs, DEC_RKV_REGISTERS, &ret_cmd, &ret_len); + p_e = mpp_time(); + cur_deat = (p_e - p_s) / 1000; + p_hal->total_time += cur_deat; + p_hal->iDecodedNum++; + (void)wait_ret; +#endif //!< dump registers { H264dRkvErrDump_t *p_dump = (H264dRkvErrDump_t *)p_hal->dump; diff --git a/mpp/hal/rkdec/h264d/hal_h264d_vdpu_reg.c b/mpp/hal/rkdec/h264d/hal_h264d_vdpu_reg.c index f6f10c2f..a285896e 100644 --- a/mpp/hal/rkdec/h264d/hal_h264d_vdpu_reg.c +++ b/mpp/hal/rkdec/h264d/hal_h264d_vdpu_reg.c @@ -617,7 +617,7 @@ MPP_RET vdpu_h264d_wait(void *hal, HalTaskInfo *task) RK_S32 wait_ret = -1; RK_S32 ret_len = 0, cur_deat = 0; VPU_CMD_TYPE ret_cmd = VPU_CMD_BUTT; - RK_S64 p_s,p_e; + RK_S64 p_s, p_e; p_s = mpp_time(); wait_ret = VPUClientWaitResult(p_hal->vpu_socket, p_drv->p_reg, DEC_X170_REGISTERS, &ret_cmd, &ret_len); p_e = mpp_time(); diff --git a/mpp/hal/worker/libvpu/vpu.c b/mpp/hal/worker/libvpu/vpu.c index ceccc3de..9bf1ad76 100644 --- a/mpp/hal/worker/libvpu/vpu.c +++ b/mpp/hal/worker/libvpu/vpu.c @@ -53,27 +53,27 @@ int VPUClientInit(VPU_CLIENT_TYPE type) int fd; switch (type) { - case VPU_DEC_RKV: { - fd = open("/dev/rkvdec", O_RDWR); - type = VPU_DEC; - break; - } - case VPU_DEC_HEVC: { - fd = open("/dev/hevc_service", O_RDWR); - type = VPU_DEC; - break; - } - case VPU_DEC_PP: - case VPU_PP: - case VPU_DEC: - case VPU_ENC: { - fd = open("/dev/vpu_service", O_RDWR); - break; - } - default: { - fd = -1; - break; - } + case VPU_DEC_RKV: { + fd = open("/dev/rkvdec", O_RDWR); + type = VPU_DEC; + break; + } + case VPU_DEC_HEVC: { + fd = open("/dev/hevc_service", O_RDWR); + type = VPU_DEC; + break; + } + case VPU_DEC_PP: + case VPU_PP: + case VPU_DEC: + case VPU_ENC: { + fd = open("/dev/vpu_service", O_RDWR); + break; + } + default: { + fd = -1; + break; + } } diff --git a/mpp/legacy/vpu_api.cpp b/mpp/legacy/vpu_api.cpp index f693e4a4..c72fb1d0 100644 --- a/mpp/legacy/vpu_api.cpp +++ b/mpp/legacy/vpu_api.cpp @@ -203,7 +203,8 @@ public: VpulibDlsym() : rkapi_hdl(NULL), rkvpu_open_cxt(NULL), - rkvpu_close_cxt(NULL) { + rkvpu_close_cxt(NULL) + { if (!!access("/dev/rkvdec", F_OK)) { rkapi_hdl = dlopen("/system/lib/librk_on2.so", RTLD_LAZY); } @@ -219,7 +220,8 @@ public: } } - ~VpulibDlsym() { + ~VpulibDlsym() + { if (rkapi_hdl) { dlclose(rkapi_hdl); mpp_log("dlclose vpu lib"); diff --git a/mpp/legacy/vpu_api_legacy.cpp b/mpp/legacy/vpu_api_legacy.cpp index a61ee3ae..3fe5b8b5 100644 --- a/mpp/legacy/vpu_api_legacy.cpp +++ b/mpp/legacy/vpu_api_legacy.cpp @@ -41,11 +41,11 @@ VpuApi::VpuApi() set_eos = 0; vpu_api_debug = 0; fp = NULL; - fp_buf = NULL; + fp_buf = NULL; mpp_env_get_u32("vpu_api_debug", &vpu_api_debug, 0); if (vpu_api_debug & VPU_API_DBG_DUMP_YUV) { fp = fopen("/sdcard/rk_mpp_dump.yuv", "wb"); - fp_buf = mpp_malloc(RK_U8, (MAX_WRITE_HEIGHT * MAX_WRITE_WIDTH * 2)); + fp_buf = mpp_malloc(RK_U8, (MAX_WRITE_HEIGHT * MAX_WRITE_WIDTH * 2)); } mpp_log_f("ok\n"); } @@ -55,11 +55,11 @@ VpuApi::~VpuApi() mpp_log_f("in\n"); if (fp) { fclose(fp); - fp = NULL; + fp = NULL; } - if (fp_buf) { - mpp_free(fp_buf); - fp_buf = NULL; + if (fp_buf) { + mpp_free(fp_buf); + fp_buf = NULL; } mpp_destroy(mpp_ctx); mpp_log_f("ok\n"); @@ -85,10 +85,10 @@ RK_S32 VpuApi::init(VpuCodecContext *ctx, RK_U8 *extraData, RK_U32 extra_size) return MPP_ERR_NULL_PTR; } ret = mpp_init(mpp_ctx, type, (MppCodingType)ctx->videoCoding); - if (ret) { - mpp_err_f(" init error. \n"); - return ret; - } + if (ret) { + mpp_err_f(" init error. \n"); + return ret; + } VPU_GENERIC vpug; vpug.CodecType = ctx->codecType; vpug.ImgWidth = ctx->width; @@ -206,53 +206,53 @@ RK_S32 VpuApi:: decode_getoutframe(DecoderOut_t *aDecOut) vframe->vpumem.vir_addr = (RK_U32*)ptr; frame_count++; //!< Dump yuv - if (fp && !vframe->ErrorInfo) { - if ((vframe->FrameWidth >= 1920) || (vframe->FrameHeight >= 1080)) { - RK_U32 i = 0, j = 0, step = 0; - RK_U32 img_w = 0, img_h = 0; - RK_U8 *pdes = NULL, *psrc = NULL; - step = MPP_MAX(vframe->FrameWidth / MAX_WRITE_WIDTH, vframe->FrameHeight / MAX_WRITE_HEIGHT); - img_w = vframe->FrameWidth / step; - img_h = vframe->FrameHeight / step; - pdes = fp_buf; - psrc = (RK_U8 *)ptr; - for (i = 0; i < img_h; i++) { - for (j = 0; j < img_w; j++) { - pdes[j] = psrc[j * step]; - } - pdes += img_w; - psrc += step * vframe->FrameWidth; - } - pdes = fp_buf + img_w * img_h; - psrc = (RK_U8 *)ptr + vframe->FrameWidth * vframe->FrameHeight; - for (i = 0; i < (img_h / 2); i++) { - for (j = 0; j < (img_w / 2); j++) { - pdes[2 * j + 0] = psrc[2 * j * step + 0]; - pdes[2 * j + 1] = psrc[2 * j * step + 1]; - } - pdes += img_w; - psrc += step * vframe->FrameWidth; - } - fwrite(fp_buf, 1, img_w * img_h * 3 / 2, fp); - if (vpu_api_debug & VPU_API_DBG_DUMP_LOG) { - mpp_log("[write_out_yuv] timeUs=%lld, FrameWidth=%d, FrameHeight=%d", aDecOut->timeUs, img_w, img_h); - } - } else { - fwrite(ptr, 1, vframe->FrameWidth * vframe->FrameHeight * 3 / 2, fp); - if (vpu_api_debug & VPU_API_DBG_DUMP_LOG) { - mpp_log("[write_out_yuv] timeUs=%lld, FrameWidth=%d, FrameHeight=%d", aDecOut->timeUs, vframe->FrameWidth, vframe->FrameHeight); - } - } + if (fp && !vframe->ErrorInfo) { + if ((vframe->FrameWidth >= 1920) || (vframe->FrameHeight >= 1080)) { + RK_U32 i = 0, j = 0, step = 0; + RK_U32 img_w = 0, img_h = 0; + RK_U8 *pdes = NULL, *psrc = NULL; + step = MPP_MAX(vframe->FrameWidth / MAX_WRITE_WIDTH, vframe->FrameHeight / MAX_WRITE_HEIGHT); + img_w = vframe->FrameWidth / step; + img_h = vframe->FrameHeight / step; + pdes = fp_buf; + psrc = (RK_U8 *)ptr; + for (i = 0; i < img_h; i++) { + for (j = 0; j < img_w; j++) { + pdes[j] = psrc[j * step]; + } + pdes += img_w; + psrc += step * vframe->FrameWidth; + } + pdes = fp_buf + img_w * img_h; + psrc = (RK_U8 *)ptr + vframe->FrameWidth * vframe->FrameHeight; + for (i = 0; i < (img_h / 2); i++) { + for (j = 0; j < (img_w / 2); j++) { + pdes[2 * j + 0] = psrc[2 * j * step + 0]; + pdes[2 * j + 1] = psrc[2 * j * step + 1]; + } + pdes += img_w; + psrc += step * vframe->FrameWidth; + } + fwrite(fp_buf, 1, img_w * img_h * 3 / 2, fp); + if (vpu_api_debug & VPU_API_DBG_DUMP_LOG) { + mpp_log("[write_out_yuv] timeUs=%lld, FrameWidth=%d, FrameHeight=%d", aDecOut->timeUs, img_w, img_h); + } + } else { + fwrite(ptr, 1, vframe->FrameWidth * vframe->FrameHeight * 3 / 2, fp); + if (vpu_api_debug & VPU_API_DBG_DUMP_LOG) { + mpp_log("[write_out_yuv] timeUs=%lld, FrameWidth=%d, FrameHeight=%d", aDecOut->timeUs, vframe->FrameWidth, vframe->FrameHeight); + } + } fflush(fp); } vframe->vpumem.phy_addr = fd; vframe->vpumem.size = vframe->FrameWidth * vframe->FrameHeight * 3 / 2; vframe->vpumem.offset = (RK_U32*)buf; } - if (vpu_api_debug & VPU_API_DBG_OUTPUT) { - mpp_log("get one frame timeUs %lld, fd=0x%x, poc=%d, errinfo=%d, discard=%d, eos=%d, verr=%d", aDecOut->timeUs, fd, - mpp_frame_get_poc(mframe), mpp_frame_get_errinfo(mframe), mpp_frame_get_discard(mframe), mpp_frame_get_eos(mframe), vframe->ErrorInfo); - } + if (vpu_api_debug & VPU_API_DBG_OUTPUT) { + mpp_log("get one frame timeUs %lld, fd=0x%x, poc=%d, errinfo=%d, discard=%d, eos=%d, verr=%d", aDecOut->timeUs, fd, + mpp_frame_get_poc(mframe), mpp_frame_get_errinfo(mframe), mpp_frame_get_discard(mframe), mpp_frame_get_eos(mframe), vframe->ErrorInfo); + } if (mpp_frame_get_eos(mframe)) { set_eos = 1; if (buf == NULL) { @@ -267,7 +267,7 @@ RK_S32 VpuApi:: decode_getoutframe(DecoderOut_t *aDecOut) * The we have to clear the buffer pointer in mframe then release mframe. */ mpp_frame_set_buffer(mframe, NULL); - mpp_frame_deinit(&mframe); + mpp_frame_deinit(&mframe); } else { aDecOut->size = 0; } @@ -344,15 +344,15 @@ RK_S32 VpuApi::control(VpuCodecContext *ctx, VPU_API_CMD cmd, void *param) } case VPU_API_SET_DEFAULT_WIDTH_HEIGH: { VPU_GENERIC *p = (VPU_GENERIC *)param; - RK_U32 ImgWidth = p->ImgWidth; + RK_U32 ImgWidth = p->ImgWidth; mpicmd = MPP_CODEC_SET_FRAME_INFO; - /**hightest of p->ImgWidth bit show current dec bitdepth - * 0 - 8bit - * 1 - 10bit - **/ - if(((p->ImgWidth&0x80000000)>>31)){ - p->ImgWidth = (p->ImgWidth&0x7FFFFFFF); - ImgWidth = (p->ImgWidth *10)>>3; + /**hightest of p->ImgWidth bit show current dec bitdepth + * 0 - 8bit + * 1 - 10bit + **/ + if (((p->ImgWidth & 0x80000000) >> 31)) { + p->ImgWidth = (p->ImgWidth & 0x7FFFFFFF); + ImgWidth = (p->ImgWidth * 10) >> 3; } if (ctx->videoCoding == OMX_RK_VIDEO_CodingHEVC) { p->ImgHorStride = hevc_ver_align_256_odd(ImgWidth); @@ -375,10 +375,10 @@ RK_S32 VpuApi::control(VpuCodecContext *ctx, VPU_API_CMD cmd, void *param) mpicmd = MPP_DEC_GET_STREAM_COUNT; break; } - case VPU_API_GET_VPUMEM_USED_COUNT:{ - mpicmd = MPP_CODEC_GET_VPUMEM_USED_COUNT; - break; - } + case VPU_API_GET_VPUMEM_USED_COUNT: { + mpicmd = MPP_CODEC_GET_VPUMEM_USED_COUNT; + break; + } default: { break; } diff --git a/mpp/legacy/vpu_api_legacy.h b/mpp/legacy/vpu_api_legacy.h index c6b99569..1f0ba9e4 100644 --- a/mpp/legacy/vpu_api_legacy.h +++ b/mpp/legacy/vpu_api_legacy.h @@ -50,7 +50,7 @@ private: RK_U32 set_eos; RK_U32 vpu_api_debug; FILE *fp; - RK_U8 *fp_buf; + RK_U8 *fp_buf; }; #endif /*_VPU_API_H_*/ diff --git a/mpp/mpp.cpp b/mpp/mpp.cpp index 14bde2e1..0d74b827 100644 --- a/mpp/mpp.cpp +++ b/mpp/mpp.cpp @@ -188,7 +188,7 @@ MPP_RET Mpp::put_packet(MppPacket packet) if (mPackets->list_size() < 4 || eos) { MppPacket pkt; if (MPP_OK != mpp_packet_copy_init(&pkt, packet)) - return MPP_NOK; + return MPP_NOK; mPackets->add_at_tail(&pkt, sizeof(pkt)); mPacketPutCount++; mThreadCodec->signal(); @@ -297,13 +297,13 @@ MPP_RET Mpp::control(MpiCmd cmd, MppParam param) *((RK_S32 *)param) = mPackets->list_size(); break; } - case MPP_CODEC_GET_VPUMEM_USED_COUNT: { - AutoMutex autoLock(mPackets->mutex()); - if (mType == MPP_CTX_DEC) { - mpp_dec_control(mDec, cmd, param); - } - break; - } + case MPP_CODEC_GET_VPUMEM_USED_COUNT: { + AutoMutex autoLock(mPackets->mutex()); + if (mType == MPP_CTX_DEC) { + mpp_dec_control(mDec, cmd, param); + } + break; + } default : { diff --git a/mpp/test/avsd_test.c b/mpp/test/avsd_test.c index a92c2f7f..8e1f86d2 100644 --- a/mpp/test/avsd_test.c +++ b/mpp/test/avsd_test.c @@ -52,424 +52,419 @@ #define AVSD_TEST_LOG(level, fmt, ...)\ do {\ if (level & rkv_avsd_test_debug)\ - { mpp_log(fmt, ## __VA_ARGS__); }\ + { mpp_log(fmt, ## __VA_ARGS__); }\ } while (0) typedef struct ParserImpl_t { - ParserCfg cfg; + ParserCfg cfg; - const ParserApi *api; - void *ctx; + const ParserApi *api; + void *ctx; } ParserImpl; static RK_U32 rkv_avsd_test_debug = 0; typedef struct inp_par_t { - FILE *fp_in; - FILE *fp_out; - FILE *fp_read; - RK_U8 *pbuf; - RK_U32 bufsize; - RK_U32 len; + FILE *fp_in; + FILE *fp_out; + FILE *fp_read; + RK_U8 *pbuf; + RK_U32 bufsize; + RK_U32 len; - RK_U32 output_dec_pic; // output_dec_pic + RK_U32 output_dec_pic; // output_dec_pic - RK_U32 dec_num; // to be decoded - RK_U32 dec_no; // current decoded number + RK_U32 dec_num; // to be decoded + RK_U32 dec_no; // current decoded number - RK_U32 is_eof; + RK_U32 is_eof; } InputParams; typedef struct avsd_test_ctx_t { - MppDec m_api; - InputParams m_in; - HalTaskInfo m_task; + MppDec m_api; + InputParams m_in; + HalTaskInfo m_task; - MppBuffer m_dec_pkt_buf; - MppBuffer m_dec_pic_buf; - MppBufferGroup mFrameGroup; - MppBufferGroup mStreamGroup; + MppBuffer m_dec_pkt_buf; + MppBuffer m_dec_pic_buf; + MppBufferGroup mFrameGroup; + MppBufferGroup mStreamGroup; } AvsdTestCtx_t; static MPP_RET decoder_deinit(AvsdTestCtx_t *pctx) { - MppDec *pApi = &pctx->m_api; + MppDec *pApi = &pctx->m_api; - if (pApi->parser) { - parser_deinit(pApi->parser); - pApi->parser = NULL; - } - if (pApi->hal) { - mpp_hal_deinit(pApi->hal); - pApi->hal = NULL; - } - if (pApi->frame_slots) { - mpp_buf_slot_deinit(pApi->frame_slots); - pApi->frame_slots = NULL; - } - if (pApi->packet_slots) { - mpp_buf_slot_deinit(pApi->packet_slots); - pApi->packet_slots = NULL; - } - if (pctx->m_dec_pkt_buf) { - mpp_buffer_put(pctx->m_dec_pkt_buf); - pctx->m_dec_pkt_buf = NULL; - } - if (pctx->m_dec_pic_buf) { - mpp_buffer_put(pctx->m_dec_pic_buf); - pctx->m_dec_pic_buf = NULL; - } - if (pctx->mFrameGroup) { - mpp_err("mFrameGroup deInit"); - mpp_buffer_group_put(pctx->mFrameGroup); - pctx->mFrameGroup = NULL; - } - if (pctx->mStreamGroup) { - mpp_err("mStreamGroup deInit"); - mpp_buffer_group_put(pctx->mStreamGroup); - pctx->mStreamGroup = NULL; - } + if (pApi->parser) { + parser_deinit(pApi->parser); + pApi->parser = NULL; + } + if (pApi->hal) { + mpp_hal_deinit(pApi->hal); + pApi->hal = NULL; + } + if (pApi->frame_slots) { + mpp_buf_slot_deinit(pApi->frame_slots); + pApi->frame_slots = NULL; + } + if (pApi->packet_slots) { + mpp_buf_slot_deinit(pApi->packet_slots); + pApi->packet_slots = NULL; + } + if (pctx->m_dec_pkt_buf) { + mpp_buffer_put(pctx->m_dec_pkt_buf); + pctx->m_dec_pkt_buf = NULL; + } + if (pctx->m_dec_pic_buf) { + mpp_buffer_put(pctx->m_dec_pic_buf); + pctx->m_dec_pic_buf = NULL; + } + if (pctx->mFrameGroup) { + mpp_err("mFrameGroup deInit"); + mpp_buffer_group_put(pctx->mFrameGroup); + pctx->mFrameGroup = NULL; + } + if (pctx->mStreamGroup) { + mpp_err("mStreamGroup deInit"); + mpp_buffer_group_put(pctx->mStreamGroup); + pctx->mStreamGroup = NULL; + } - return MPP_OK; + return MPP_OK; } static MPP_RET decoder_init(AvsdTestCtx_t *pctx) { - MPP_RET ret = MPP_ERR_UNKNOW; - ParserCfg parser_cfg; - MppHalCfg hal_cfg; - MppDec *pApi = &pctx->m_api; + MPP_RET ret = MPP_ERR_UNKNOW; + ParserCfg parser_cfg; + MppHalCfg hal_cfg; + MppDec *pApi = &pctx->m_api; - if (pctx->mFrameGroup == NULL) { - ret = mpp_buffer_group_get_internal(&pctx->mFrameGroup, MPP_BUFFER_TYPE_NORMAL); - if (MPP_OK != ret) { - mpp_err("avsd mpp_buffer_group_get failed\n"); - goto __FAILED; - } - } - if (pctx->mStreamGroup == NULL) { - ret = mpp_buffer_group_get_internal(&pctx->mStreamGroup, MPP_BUFFER_TYPE_NORMAL); - if (MPP_OK != ret) { - mpp_err("avsd mpp_buffer_group_get failed\n"); - goto __FAILED; - } - } - // codec - pApi->coding = MPP_VIDEO_CodingAVS; - // malloc slot - FUN_CHECK(ret = mpp_buf_slot_init(&pApi->frame_slots)); - MEM_CHECK(ret, pApi->frame_slots); - ret = mpp_buf_slot_init(&pApi->packet_slots); - MEM_CHECK(ret, pApi->packet_slots); - mpp_buf_slot_setup(pApi->packet_slots, 2); - // init parser part - memset(&parser_cfg, 0, sizeof(parser_cfg)); - parser_cfg.coding = pApi->coding; - parser_cfg.frame_slots = pApi->frame_slots; - parser_cfg.packet_slots = pApi->packet_slots; - parser_cfg.task_count = 2; - FUN_CHECK(ret = parser_init(&pApi->parser, &parser_cfg)); + if (pctx->mFrameGroup == NULL) { + ret = mpp_buffer_group_get_internal(&pctx->mFrameGroup, MPP_BUFFER_TYPE_NORMAL); + if (MPP_OK != ret) { + mpp_err("avsd mpp_buffer_group_get failed\n"); + goto __FAILED; + } + } + if (pctx->mStreamGroup == NULL) { + ret = mpp_buffer_group_get_internal(&pctx->mStreamGroup, MPP_BUFFER_TYPE_NORMAL); + if (MPP_OK != ret) { + mpp_err("avsd mpp_buffer_group_get failed\n"); + goto __FAILED; + } + } + // codec + pApi->coding = MPP_VIDEO_CodingAVS; + // malloc slot + FUN_CHECK(ret = mpp_buf_slot_init(&pApi->frame_slots)); + MEM_CHECK(ret, pApi->frame_slots); + ret = mpp_buf_slot_init(&pApi->packet_slots); + MEM_CHECK(ret, pApi->packet_slots); + mpp_buf_slot_setup(pApi->packet_slots, 2); + // init parser part + memset(&parser_cfg, 0, sizeof(parser_cfg)); + parser_cfg.coding = pApi->coding; + parser_cfg.frame_slots = pApi->frame_slots; + parser_cfg.packet_slots = pApi->packet_slots; + parser_cfg.task_count = 2; + FUN_CHECK(ret = parser_init(&pApi->parser, &parser_cfg)); - // init hal part - memset(&hal_cfg, 0, sizeof(hal_cfg)); - hal_cfg.type = MPP_CTX_DEC; - hal_cfg.coding = pApi->coding; - hal_cfg.work_mode = HAL_MODE_LIBVPU; - hal_cfg.device_id = HAL_RKVDEC; - hal_cfg.frame_slots = pApi->frame_slots; - hal_cfg.packet_slots = pApi->packet_slots; - hal_cfg.task_count = parser_cfg.task_count; - hal_cfg.hal_int_cb.opaque = ((ParserImpl *)(pApi->parser))->ctx; - hal_cfg.hal_int_cb.callBack = api_avsd_parser.callback; - //api_avsd_parser.callback(hal_cfg.hal_int_cb.opaque, NULL); - FUN_CHECK(ret = mpp_hal_init(&pApi->hal, &hal_cfg)); - pApi->tasks = hal_cfg.tasks; + // init hal part + memset(&hal_cfg, 0, sizeof(hal_cfg)); + hal_cfg.type = MPP_CTX_DEC; + hal_cfg.coding = pApi->coding; + hal_cfg.work_mode = HAL_MODE_LIBVPU; + hal_cfg.device_id = HAL_RKVDEC; + hal_cfg.frame_slots = pApi->frame_slots; + hal_cfg.packet_slots = pApi->packet_slots; + hal_cfg.task_count = parser_cfg.task_count; + hal_cfg.hal_int_cb.opaque = ((ParserImpl *)(pApi->parser))->ctx; + hal_cfg.hal_int_cb.callBack = api_avsd_parser.callback; + //api_avsd_parser.callback(hal_cfg.hal_int_cb.opaque, NULL); + FUN_CHECK(ret = mpp_hal_init(&pApi->hal, &hal_cfg)); + pApi->tasks = hal_cfg.tasks; - return MPP_OK; + return MPP_OK; __FAILED: - decoder_deinit(pctx); + decoder_deinit(pctx); - return ret; + return ret; } static MPP_RET avsd_flush_frames(MppDec *pApi, FILE *fp) { - RK_S32 slot_idx = 0; - MppFrame out_frame = NULL; + RK_S32 slot_idx = 0; + MppFrame out_frame = NULL; - while (MPP_OK == mpp_buf_slot_dequeue(pApi->frame_slots, &slot_idx, QUEUE_DISPLAY)) { - mpp_buf_slot_get_prop(pApi->frame_slots, slot_idx, SLOT_FRAME, &out_frame); - if (out_frame) { - RK_U32 stride_w, stride_h; - void *ptr = NULL; - MppBuffer framebuf; - stride_w = mpp_frame_get_hor_stride(out_frame); - stride_h = mpp_frame_get_ver_stride(out_frame); - framebuf = mpp_frame_get_buffer(out_frame); - ptr = mpp_buffer_get_ptr(framebuf); - if (fp) { - fwrite(ptr, 1, stride_w * stride_h * 3 / 2, fp); - fflush(fp); - } - mpp_frame_deinit(&out_frame); - out_frame = NULL; - } - mpp_buf_slot_clr_flag(pApi->frame_slots, slot_idx, SLOT_QUEUE_USE); - } + while (MPP_OK == mpp_buf_slot_dequeue(pApi->frame_slots, &slot_idx, QUEUE_DISPLAY)) { + mpp_buf_slot_get_prop(pApi->frame_slots, slot_idx, SLOT_FRAME, &out_frame); + if (out_frame) { + RK_U32 stride_w, stride_h; + void *ptr = NULL; + MppBuffer framebuf; + stride_w = mpp_frame_get_hor_stride(out_frame); + stride_h = mpp_frame_get_ver_stride(out_frame); + framebuf = mpp_frame_get_buffer(out_frame); + ptr = mpp_buffer_get_ptr(framebuf); + if (fp) { + fwrite(ptr, 1, stride_w * stride_h * 3 / 2, fp); + fflush(fp); + } + mpp_frame_deinit(&out_frame); + out_frame = NULL; + } + mpp_buf_slot_clr_flag(pApi->frame_slots, slot_idx, SLOT_QUEUE_USE); + } - return MPP_OK; + return MPP_OK; } static MPP_RET avsd_input_deinit(InputParams *inp) { - MPP_RET ret = MPP_ERR_UNKNOW; + MPP_RET ret = MPP_ERR_UNKNOW; - MPP_FREE(inp->pbuf); - MPP_FCLOSE(inp->fp_in); - MPP_FCLOSE(inp->fp_out); - MPP_FCLOSE(inp->fp_read); - return ret = MPP_OK; + MPP_FREE(inp->pbuf); + MPP_FCLOSE(inp->fp_in); + MPP_FCLOSE(inp->fp_out); + MPP_FCLOSE(inp->fp_read); + return ret = MPP_OK; } static MPP_RET avsd_input_init(InputParams *inp, RK_S32 ac, char *av[]) { - MPP_RET ret = MPP_ERR_UNKNOW; - char infile_name[128]; //!< Telenor AVS input - char outfile_name[128]; //!< Decoded YUV 4:2:0 output - RK_S32 CLcount = 1; + MPP_RET ret = MPP_ERR_UNKNOW; + char infile_name[128]; //!< Telenor AVS input + char outfile_name[128]; //!< Decoded YUV 4:2:0 output + RK_S32 CLcount = 1; - inp->output_dec_pic = 0; - while (CLcount < ac) { - if (!strncmp(av[CLcount], "-h", 2)) { - mpp_log("Options:"); - mpp_log(" -h : prints help message."); - mpp_log(" -i :[file] Set input AVS+ bitstream file."); - mpp_log(" -o :[file] Set output YUV file."); - mpp_log(" -n :[number] Set decoded frames."); - CLcount += 1; - } - else if (!strncmp(av[CLcount], "-i", 2)) { - strncpy(infile_name, av[CLcount + 1], strlen((const char*)av[CLcount + 1]) + 1); - CLcount += 2; - } - else if (!strncmp(av[CLcount], "-n", 2)) { - if (!sscanf(av[CLcount + 1], "%d", &inp->dec_num)) { - goto __FAILED; - } - CLcount += 2; - } - else if (!strncmp(av[CLcount], "-o", 2)) { - if (rkv_avsd_test_debug & AVSD_TEST_DUMPYUV) { - inp->output_dec_pic = 1; - strncpy(outfile_name, av[CLcount + 1], strlen((const char*)av[CLcount + 1]) + 1); - } - CLcount += 2; - } - else { - mpp_err("error, %s cannot explain command! \n", av[CLcount]); - goto __FAILED; - } - } - if ((inp->fp_in = fopen(infile_name, "rb")) == 0) { - mpp_err("error, open file %s ", infile_name); - goto __FAILED; - } - if (inp->output_dec_pic) { - if ((inp->fp_out = fopen(outfile_name, "wb")) == 0) { - mpp_err("error, open file %s ", outfile_name); - goto __FAILED; - } - } - if ((inp->fp_read = fopen("F:/avs_log/avs_read.txt", "wb")) == 0) { - mpp_log("error, open file %s", "F:/avs_log/avs_read.txt"); - goto __FAILED; - } + inp->output_dec_pic = 0; + while (CLcount < ac) { + if (!strncmp(av[CLcount], "-h", 2)) { + mpp_log("Options:"); + mpp_log(" -h : prints help message."); + mpp_log(" -i :[file] Set input AVS+ bitstream file."); + mpp_log(" -o :[file] Set output YUV file."); + mpp_log(" -n :[number] Set decoded frames."); + CLcount += 1; + } else if (!strncmp(av[CLcount], "-i", 2)) { + strncpy(infile_name, av[CLcount + 1], strlen((const char*)av[CLcount + 1]) + 1); + CLcount += 2; + } else if (!strncmp(av[CLcount], "-n", 2)) { + if (!sscanf(av[CLcount + 1], "%d", &inp->dec_num)) { + goto __FAILED; + } + CLcount += 2; + } else if (!strncmp(av[CLcount], "-o", 2)) { + if (rkv_avsd_test_debug & AVSD_TEST_DUMPYUV) { + inp->output_dec_pic = 1; + strncpy(outfile_name, av[CLcount + 1], strlen((const char*)av[CLcount + 1]) + 1); + } + CLcount += 2; + } else { + mpp_err("error, %s cannot explain command! \n", av[CLcount]); + goto __FAILED; + } + } + if ((inp->fp_in = fopen(infile_name, "rb")) == 0) { + mpp_err("error, open file %s ", infile_name); + goto __FAILED; + } + if (inp->output_dec_pic) { + if ((inp->fp_out = fopen(outfile_name, "wb")) == 0) { + mpp_err("error, open file %s ", outfile_name); + goto __FAILED; + } + } + if ((inp->fp_read = fopen("F:/avs_log/avs_read.txt", "wb")) == 0) { + mpp_log("error, open file %s", "F:/avs_log/avs_read.txt"); + goto __FAILED; + } - //!< malloc read buffer - inp->bufsize = 30*1024; - MEM_CHECK(ret, inp->pbuf = mpp_malloc(RK_U8, inp->bufsize)); + //!< malloc read buffer + inp->bufsize = 30 * 1024; + MEM_CHECK(ret, inp->pbuf = mpp_malloc(RK_U8, inp->bufsize)); - AVSD_TEST_LOG(AVSD_TEST_TRACE, "------------------------------------------------------------"); - AVSD_TEST_LOG(AVSD_TEST_TRACE, "Input AVS+ bitstream : %s", infile_name); - AVSD_TEST_LOG(AVSD_TEST_TRACE, "Output decoded YUV : %s", outfile_name); - AVSD_TEST_LOG(AVSD_TEST_TRACE, "------------------------------------------------------------"); - AVSD_TEST_LOG(AVSD_TEST_TRACE, "Frame TR QP SnrY SnrU SnrV Time(ms) FRM/FLD"); + AVSD_TEST_LOG(AVSD_TEST_TRACE, "------------------------------------------------------------"); + AVSD_TEST_LOG(AVSD_TEST_TRACE, "Input AVS+ bitstream : %s", infile_name); + AVSD_TEST_LOG(AVSD_TEST_TRACE, "Output decoded YUV : %s", outfile_name); + AVSD_TEST_LOG(AVSD_TEST_TRACE, "------------------------------------------------------------"); + AVSD_TEST_LOG(AVSD_TEST_TRACE, "Frame TR QP SnrY SnrU SnrV Time(ms) FRM/FLD"); - return MPP_OK; + return MPP_OK; __FAILED: - avsd_deinit(inp); + avsd_deinit(inp); - return ret; + return ret; } static MPP_RET avsd_read_data(InputParams *inp) { - MPP_RET ret = MPP_ERR_UNKNOW; + MPP_RET ret = MPP_ERR_UNKNOW; - inp->len = (RK_U32)fread(inp->pbuf, sizeof(RK_U8), inp->bufsize, inp->fp_in); - inp->is_eof = feof(inp->fp_in); + inp->len = (RK_U32)fread(inp->pbuf, sizeof(RK_U8), inp->bufsize, inp->fp_in); + inp->is_eof = feof(inp->fp_in); - if (inp->fp_read){ - fwrite(inp->pbuf, inp->len, 1, inp->fp_read); - fflush(inp->fp_read); - } + if (inp->fp_read) { + fwrite(inp->pbuf, inp->len, 1, inp->fp_read); + fflush(inp->fp_read); + } - return ret = MPP_OK; + return ret = MPP_OK; } static MPP_RET decoder_single_test(AvsdTestCtx_t *pctx) { - MppPacket pkt = NULL; - RK_U32 end_of_flag = 0; - MPP_RET ret = MPP_ERR_UNKNOW; + MppPacket pkt = NULL; + RK_U32 end_of_flag = 0; + MPP_RET ret = MPP_ERR_UNKNOW; - MppDec *pApi = &pctx->m_api; - InputParams *inp = &pctx->m_in; - HalTaskInfo *task = &pctx->m_task; - //!< initial task - memset(task, 0, sizeof(HalTaskInfo)); - memset(task->dec.refer, -1, sizeof(task->dec.refer)); - task->dec.input = -1; - do { - //!< get one packet - if (pkt == NULL) { - if (inp->is_eof || - (inp->dec_num && (inp->dec_no >= inp->dec_num))) { - mpp_packet_init(&pkt, NULL, 0); - mpp_packet_set_eos(pkt); - } - else { - FUN_CHECK(ret = avsd_read_data(inp)); - mpp_packet_init(&pkt, inp->pbuf, inp->len); - } - } - //!< prepare - FUN_CHECK(ret = parser_prepare(pApi->parser, pkt, &task->dec)); + MppDec *pApi = &pctx->m_api; + InputParams *inp = &pctx->m_in; + HalTaskInfo *task = &pctx->m_task; + //!< initial task + memset(task, 0, sizeof(HalTaskInfo)); + memset(task->dec.refer, -1, sizeof(task->dec.refer)); + task->dec.input = -1; + do { + //!< get one packet + if (pkt == NULL) { + if (inp->is_eof || + (inp->dec_num && (inp->dec_no >= inp->dec_num))) { + mpp_packet_init(&pkt, NULL, 0); + mpp_packet_set_eos(pkt); + } else { + FUN_CHECK(ret = avsd_read_data(inp)); + mpp_packet_init(&pkt, inp->pbuf, inp->len); + } + } + //!< prepare + FUN_CHECK(ret = parser_prepare(pApi->parser, pkt, &task->dec)); - //!< parse - if (task->dec.valid) { - MppBufferImpl *buf = NULL; + //!< parse + if (task->dec.valid) { + MppBufferImpl *buf = NULL; - task->dec.valid = 0; - if (task->dec.input < 0) { - mpp_buf_slot_get_unused(pApi->packet_slots, &task->dec.input); - } - mpp_buf_slot_get_prop(pApi->packet_slots, task->dec.input, SLOT_BUFFER, &pctx->m_dec_pkt_buf); - if (NULL == pctx->m_dec_pkt_buf) { - size_t stream_size = mpp_packet_get_size(task->dec.input_packet); - mpp_buffer_get(pctx->mStreamGroup, &pctx->m_dec_pkt_buf, stream_size); - if (pctx->m_dec_pkt_buf) - mpp_buf_slot_set_prop(pApi->packet_slots, task->dec.input, SLOT_BUFFER, pctx->m_dec_pkt_buf); - } - buf = (MppBufferImpl *)pctx->m_dec_pkt_buf; - memcpy(buf->info.ptr, mpp_packet_get_data(task->dec.input_packet), mpp_packet_get_length(task->dec.input_packet)); + task->dec.valid = 0; + if (task->dec.input < 0) { + mpp_buf_slot_get_unused(pApi->packet_slots, &task->dec.input); + } + mpp_buf_slot_get_prop(pApi->packet_slots, task->dec.input, SLOT_BUFFER, &pctx->m_dec_pkt_buf); + if (NULL == pctx->m_dec_pkt_buf) { + size_t stream_size = mpp_packet_get_size(task->dec.input_packet); + mpp_buffer_get(pctx->mStreamGroup, &pctx->m_dec_pkt_buf, stream_size); + if (pctx->m_dec_pkt_buf) + mpp_buf_slot_set_prop(pApi->packet_slots, task->dec.input, SLOT_BUFFER, pctx->m_dec_pkt_buf); + } + buf = (MppBufferImpl *)pctx->m_dec_pkt_buf; + memcpy(buf->info.ptr, mpp_packet_get_data(task->dec.input_packet), mpp_packet_get_length(task->dec.input_packet)); - mpp_buf_slot_set_flag(pApi->packet_slots, task->dec.input, SLOT_CODEC_READY); - mpp_buf_slot_set_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT); - FUN_CHECK(ret = parser_parse(pApi->parser, &task->dec)); + mpp_buf_slot_set_flag(pApi->packet_slots, task->dec.input, SLOT_CODEC_READY); + mpp_buf_slot_set_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT); + FUN_CHECK(ret = parser_parse(pApi->parser, &task->dec)); - AVSD_TEST_LOG(AVSD_TEST_TRACE, "[AVSD_TEST] ---- decoder, read_one_frame Frame_no = %d", inp->dec_no); - inp->dec_no++; - } - //!< deinit packet - if (mpp_packet_get_length(pkt) == 0) { - if (mpp_packet_get_eos(pkt)) { - if (task->dec.valid) { - mpp_buf_slot_clr_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT); - mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.output, SLOT_HAL_OUTPUT); - task->dec.valid = 0; - } - end_of_flag = 1; //!< end of stream - } - mpp_packet_deinit(&pkt); - pkt = NULL; - } - //!< run hal module - if (task->dec.valid) { - if (mpp_buf_slot_is_changed(pApi->frame_slots)) { - mpp_buf_slot_ready(pApi->frame_slots); - } - mpp_buf_slot_get_prop(pApi->frame_slots, task->dec.output, SLOT_BUFFER, &pctx->m_dec_pic_buf); - if (NULL == pctx->m_dec_pic_buf) { - RK_U32 size = 1920 * 1088 * 3 / 2;// (RK_U32)mpp_buf_slot_get_size(pApi->frame_slots); - mpp_buffer_get(pctx->mFrameGroup, &pctx->m_dec_pic_buf, size); - if (pctx->m_dec_pic_buf) - mpp_buf_slot_set_prop(pApi->frame_slots, task->dec.output, SLOT_BUFFER, pctx->m_dec_pic_buf); - } - FUN_CHECK(ret = mpp_hal_reg_gen(pApi->hal, task)); + AVSD_TEST_LOG(AVSD_TEST_TRACE, "[AVSD_TEST] ---- decoder, read_one_frame Frame_no = %d", inp->dec_no); + inp->dec_no++; + } + //!< deinit packet + if (mpp_packet_get_length(pkt) == 0) { + if (mpp_packet_get_eos(pkt)) { + if (task->dec.valid) { + mpp_buf_slot_clr_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT); + mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.output, SLOT_HAL_OUTPUT); + task->dec.valid = 0; + } + end_of_flag = 1; //!< end of stream + } + mpp_packet_deinit(&pkt); + pkt = NULL; + } + //!< run hal module + if (task->dec.valid) { + if (mpp_buf_slot_is_changed(pApi->frame_slots)) { + mpp_buf_slot_ready(pApi->frame_slots); + } + mpp_buf_slot_get_prop(pApi->frame_slots, task->dec.output, SLOT_BUFFER, &pctx->m_dec_pic_buf); + if (NULL == pctx->m_dec_pic_buf) { + RK_U32 size = 1920 * 1088 * 3 / 2;// (RK_U32)mpp_buf_slot_get_size(pApi->frame_slots); + mpp_buffer_get(pctx->mFrameGroup, &pctx->m_dec_pic_buf, size); + if (pctx->m_dec_pic_buf) + mpp_buf_slot_set_prop(pApi->frame_slots, task->dec.output, SLOT_BUFFER, pctx->m_dec_pic_buf); + } + FUN_CHECK(ret = mpp_hal_reg_gen(pApi->hal, task)); - FUN_CHECK(ret = mpp_hal_hw_start(pApi->hal, task)); - FUN_CHECK(ret = mpp_hal_hw_wait(pApi->hal, task)); - if (pctx->m_dec_pkt_buf) { - mpp_buffer_put(pctx->m_dec_pkt_buf); - pctx->m_dec_pkt_buf = NULL; - } - mpp_buf_slot_clr_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT); - mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.output, SLOT_HAL_OUTPUT); - //!< write frame out - avsd_flush_frames(pApi, inp->fp_out); - //!< clear refrece flag - { - RK_U32 i = 0; - for (i = 0; i < MPP_ARRAY_ELEMS(task->dec.refer); i++) { - if (task->dec.refer[i] >= 0) { - mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.refer[i], SLOT_HAL_INPUT); - } - } - } - //!< reset task - memset(task, 0, sizeof(HalTaskInfo)); - memset(task->dec.refer, -1, sizeof(task->dec.refer)); - task->dec.input = -1; + FUN_CHECK(ret = mpp_hal_hw_start(pApi->hal, task)); + FUN_CHECK(ret = mpp_hal_hw_wait(pApi->hal, task)); + if (pctx->m_dec_pkt_buf) { + mpp_buffer_put(pctx->m_dec_pkt_buf); + pctx->m_dec_pkt_buf = NULL; + } + mpp_buf_slot_clr_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT); + mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.output, SLOT_HAL_OUTPUT); + //!< write frame out + avsd_flush_frames(pApi, inp->fp_out); + //!< clear refrece flag + { + RK_U32 i = 0; + for (i = 0; i < MPP_ARRAY_ELEMS(task->dec.refer); i++) { + if (task->dec.refer[i] >= 0) { + mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.refer[i], SLOT_HAL_INPUT); + } + } + } + //!< reset task + memset(task, 0, sizeof(HalTaskInfo)); + memset(task->dec.refer, -1, sizeof(task->dec.refer)); + task->dec.input = -1; - } - } while (!end_of_flag); + } + } while (!end_of_flag); - //!< flush dpb and send to display - FUN_CHECK(ret = mpp_dec_flush(pApi)); + //!< flush dpb and send to display + FUN_CHECK(ret = mpp_dec_flush(pApi)); - ret = MPP_OK; + ret = MPP_OK; __FAILED: - return ret; + return ret; } int main(int argc, char **argv) { - MPP_RET ret = MPP_ERR_UNKNOW; - AvsdTestCtx_t m_decoder; - AvsdTestCtx_t *p_dec = &m_decoder; + MPP_RET ret = MPP_ERR_UNKNOW; + AvsdTestCtx_t m_decoder; + AvsdTestCtx_t *p_dec = &m_decoder; #if defined(_MSC_VER) - mpp_env_set_u32("rkv_avsd_test_debug", 0xFF); + mpp_env_set_u32("rkv_avsd_test_debug", 0xFF); #endif - mpp_env_get_u32("rkv_avsd_test_debug", &rkv_avsd_test_debug, 0x0F); - memset(p_dec, 0, sizeof(AvsdTestCtx_t)); - // read file - FUN_CHECK(ret = avsd_input_init(&p_dec->m_in, argc, argv)); - // init - decoder_init(p_dec); - // decode - ret = decoder_single_test(p_dec); - if (ret != MPP_OK) { - AVSD_TEST_LOG(AVSD_TEST_TRACE, "[AVSD_TEST] Single-thread test error."); - goto __FAILED; - } + mpp_env_get_u32("rkv_avsd_test_debug", &rkv_avsd_test_debug, 0x0F); + memset(p_dec, 0, sizeof(AvsdTestCtx_t)); + // read file + FUN_CHECK(ret = avsd_input_init(&p_dec->m_in, argc, argv)); + // init + decoder_init(p_dec); + // decode + ret = decoder_single_test(p_dec); + if (ret != MPP_OK) { + AVSD_TEST_LOG(AVSD_TEST_TRACE, "[AVSD_TEST] Single-thread test error."); + goto __FAILED; + } - ret = MPP_OK; + ret = MPP_OK; __FAILED: - decoder_deinit(p_dec); - avsd_input_deinit(&p_dec->m_in); + decoder_deinit(p_dec); + avsd_input_deinit(&p_dec->m_in); - AVSD_TEST_LOG(AVSD_TEST_TRACE, "[AVSD_TEST] decoder_deinit over."); + AVSD_TEST_LOG(AVSD_TEST_TRACE, "[AVSD_TEST] decoder_deinit over."); - return ret; + return ret; } diff --git a/mpp/test/h264d_test.c b/mpp/test/h264d_test.c index fc342279..716f6a45 100644 --- a/mpp/test/h264d_test.c +++ b/mpp/test/h264d_test.c @@ -303,7 +303,7 @@ static MPP_RET decoder_single_test(H264dTestCtx_t *pctx) FUN_CHECK(ret = mpp_hal_hw_wait(pApi->hal, task)); if (pctx->m_dec_pkt_buf) { mpp_buffer_put(pctx->m_dec_pkt_buf); - pctx->m_dec_pkt_buf = NULL; + pctx->m_dec_pkt_buf = NULL; } mpp_buf_slot_clr_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT); mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.output, SLOT_HAL_OUTPUT); diff --git a/osal/allocator/allocator_drm.c b/osal/allocator/allocator_drm.c index c2edc952..55574324 100644 --- a/osal/allocator/allocator_drm.c +++ b/osal/allocator/allocator_drm.c @@ -75,8 +75,8 @@ static int drm_alloc(int fd, size_t len, size_t align, unsigned int heap_mask, if (ret < 0) return ret; *handle = dmcb.handle; - (void)heap_mask; - (void)flags; + (void)heap_mask; + (void)flags; return ret; } @@ -103,7 +103,7 @@ static int drm_handle_to_fd(int fd, RK_U32 handle, int *map_fd, RK_U32 flags) mpp_err("map ioctl returned negative fd\n"); return -EINVAL; } - (void)flags; + (void)flags; return ret; } @@ -141,7 +141,7 @@ static int drm_map(int fd, RK_U32 handle, size_t length, int prot, mpp_err("mmap failed: %s\n", strerror(errno)); return -errno; } - (void)offset; + (void)offset; return ret; } diff --git a/osal/inc/mpp_thread.h b/osal/inc/mpp_thread.h index d2be98c0..97c63266 100644 --- a/osal/inc/mpp_thread.h +++ b/osal/inc/mpp_thread.h @@ -207,22 +207,26 @@ public: void start(); void stop(); - void lock(MppThreadSignal id = THREAD_WORK) { + void lock(MppThreadSignal id = THREAD_WORK) + { mpp_assert(id < THREAD_SIGNAL_BUTT); mMutexCond[id].lock(); } - void unlock(MppThreadSignal id = THREAD_WORK) { + void unlock(MppThreadSignal id = THREAD_WORK) + { mpp_assert(id < THREAD_SIGNAL_BUTT); mMutexCond[id].unlock(); } - void wait(MppThreadSignal id = THREAD_WORK) { + void wait(MppThreadSignal id = THREAD_WORK) + { mpp_assert(id < THREAD_SIGNAL_BUTT); mMutexCond[id].wait(); } - void signal(MppThreadSignal id = THREAD_WORK) { + void signal(MppThreadSignal id = THREAD_WORK) + { mpp_assert(id < THREAD_SIGNAL_BUTT); mMutexCond[id].signal(); } diff --git a/osal/linux/os_allocator.c b/osal/linux/os_allocator.c index b13bdf67..92fba12d 100644 --- a/osal/linux/os_allocator.c +++ b/osal/linux/os_allocator.c @@ -136,7 +136,7 @@ MPP_RET os_allocator_get(os_allocator *api, MppBufferType type) mpp_err("os_allocator_get Linux MPP_BUFFER_TYPE_V4L2 do not implement yet\n"); *api = allocator_v4l2; } break; - case MPP_BUFFER_TYPE_DRM : { + case MPP_BUFFER_TYPE_DRM : { *api = allocator_drm; } break; default : { diff --git a/osal/mpp_mem.cpp b/osal/mpp_mem.cpp index 33e74b8c..2536cffa 100644 --- a/osal/mpp_mem.cpp +++ b/osal/mpp_mem.cpp @@ -189,7 +189,7 @@ void mpp_show_mem_status() pthread_mutex_lock(&mem_list_lock); list_for_each_entry_safe(pos, n, &mem_list, struct mem_node, list) { mpp_log("unfree memory %p size %d tag %s index %llu", - pos->ptr, pos->size, pos->tag, pos->index); + pos->ptr, pos->size, pos->tag, pos->index); } pthread_mutex_unlock(&mem_list_lock); } @@ -282,14 +282,14 @@ MPP_RET mpp_mem_squash_snapshot(MppMemSnapshot hnd0, MppMemSnapshot hnd1) if (!found_match) { mpp_log_f("snapshot0 %p found mismatch memory %p size %d tag %s index %llu", - p0, pos0->ptr, pos0->size, pos0->tag, pos0->index); + p0, pos0->ptr, pos0->size, pos0->tag, pos0->index); } } /* handle 1 search */ list_for_each_entry_safe(pos1, n1, &p1->list, struct mem_node, list) { mpp_log_f("snapshot1 %p found mismatch memory %p size %d tag %s index %llu", - p1, pos1->ptr, pos1->size, pos1->tag, pos1->index); + p1, pos1->ptr, pos1->size, pos1->tag, pos1->index); } pthread_mutex_unlock(&mem_list_lock); diff --git a/osal/mpp_thread.cpp b/osal/mpp_thread.cpp index 9a6b2b55..ff93334a 100644 --- a/osal/mpp_thread.cpp +++ b/osal/mpp_thread.cpp @@ -95,16 +95,16 @@ void MppThread::stop() const DWORD MS_VC_EXCEPTION = 0x406D1388; #pragma pack(push,8) -typedef struct tagTHREADNAME_INFO -{ +typedef struct tagTHREADNAME_INFO { DWORD dwType; // Must be 0x1000. LPCSTR szName; // Pointer to name (in user addr space). DWORD dwThreadID; // Thread ID (-1=caller thread). DWORD dwFlags; // Reserved for future use, must be zero. - } THREADNAME_INFO; +} THREADNAME_INFO; #pragma pack(pop) -void SetThreadName(DWORD dwThreadID, const char* threadName) { +void SetThreadName(DWORD dwThreadID, const char* threadName) +{ THREADNAME_INFO info; info.dwType = 0x1000; info.szName = threadName; @@ -112,10 +112,9 @@ void SetThreadName(DWORD dwThreadID, const char* threadName) { info.dwFlags = 0; #pragma warning(push) #pragma warning(disable: 6320 6322) - __try{ + __try { RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR), (ULONG_PTR*)&info); - } - __except (EXCEPTION_EXECUTE_HANDLER){ + } __except (EXCEPTION_EXECUTE_HANDLER) { } #pragma warning(pop) }