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

[h264d] add as hvcC format support

Browse Source 
git-svn-id: https://10.10.10.66:8443/svn/MediaProcessPlatform/trunk/mpp@461 6e48237b-75ef-9749-8fc9-41990f28c85a
This commit is contained in:
DingWei
2015-11-17 04:37:39 +00:00
parent 5f9f4b4805
commit e493378d7f
9 changed files with 229 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -631,7 +631,6 @@ MPP_RET h264d_prepare(void *decoder, MppPacket pkt, HalDecTask *task)
p_Dec->p_Inp->in_pts = mpp_packet_get_pts(pkt);
p_Dec->p_Inp->in_dts = mpp_packet_get_dts(pkt);
//!< restore time stamp
get_pkt_timestamp(&p_Dec->p_Cur->strm, p_Dec->p_Inp, pkt);
//mpp_err("[ pkt_in timeUs ] preprare input_pts=%lld \n",p_Dec->p_Inp->in_pts);
if (mpp_packet_get_eos(pkt)) {
@@ -645,18 +644,46 @@ MPP_RET h264d_prepare(void *decoder, MppPacket pkt, HalDecTask *task)
p_Dec->p_Inp->pkt_eos = 0;
p_Dec->p_Inp->in_size = &((MppPacketImpl *)pkt)->length;
}
//{
// mpp_log("[nal_ff_data] %02x %02x %02x %02x %02x %02x %02x %02x \n",
// p_Dec->p_Inp->in_buf[0],
// p_Dec->p_Inp->in_buf[1],
// p_Dec->p_Inp->in_buf[2],
// p_Dec->p_Inp->in_buf[3],
// p_Dec->p_Inp->in_buf[4],
// p_Dec->p_Inp->in_buf[5],
// p_Dec->p_Inp->in_buf[6],
// p_Dec->p_Inp->in_buf[7]);
//}
//mpp_log("mpp_packet_get_flag(pkt)=%d\n", mpp_packet_get_flag(pkt));
if (mpp_packet_get_flag(pkt)& MPP_PACKET_FLAG_EXTRA_DATA) {
RK_U8 *pdata = p_Dec->p_Inp->in_buf;
p_Dec->p_Inp->is_nalff = (p_Dec->p_Inp->in_length > 3)&& (pdata[0] && pdata[1]);
//mpp_log("p_Dec->p_Inp->is_nalff=%d, len=%d, data=%d,%d,%d\n", p_Dec->p_Inp->is_nalff, p_Dec->p_Inp->in_length, pdata[0], pdata[1],pdata[2]);
if (p_Dec->p_Inp->is_nalff) {
(ret = parse_prepare_extra_header(p_Dec->p_Inp, p_Dec->p_Cur));
}
}
//mpp_err("[timePkt_in] pts=%lld, dts=%lld", p_Dec->p_Inp->pts, p_Dec->p_Inp->dts);
//LogTrace(logctx, "[Prepare_In] in_length=%d, eos=%d, g_framecnt=%d", mpp_packet_get_length(pkt), mpp_packet_get_eos(pkt), p_Dec->p_Vid->g_framecnt);
//FPRINT(g_debug_file0, "[Prepare_In] in_length=%d, eos=%d, g_framecnt=%d \n", mpp_packet_get_length(pkt), mpp_packet_get_eos(pkt), p_Dec->p_Vid->g_framecnt);
do {
while(mpp_packet_get_length(pkt) && !task->valid) {
if (p_Dec->p_Inp->is_nalff) {
(ret = parse_prepare_extra_data(p_Dec->p_Inp, p_Dec->p_Cur));
} else {
(ret = parse_prepare(p_Dec->p_Inp, p_Dec->p_Cur));
}
task->valid = p_Dec->p_Inp->task_valid; //!< prepare valid flag
//LogTrace(logctx, "[Prepare_Ing] length=%d, valid=%d,strm_off=%d, g_framecnt=%d", mpp_packet_get_length(pkt), task->valid, p_Dec->dxva_ctx->strm_offset, p_Dec->p_Vid->g_framecnt);
//FPRINT(g_debug_file0, "[Prepare_Ing] length=%d, valid=%d,strm_off=%d, g_framecnt=%d \n", mpp_packet_get_length(pkt), task->valid, p_Dec->dxva_ctx->strm_offset, p_Dec->p_Vid->g_framecnt);
} while (mpp_packet_get_length(pkt) && !task->valid);
}
//LogTrace(logctx, "Prepare Out: len=%d, valid=%d ", mpp_packet_get_length(pkt), task->valid);
if (task->valid) {

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

@@ -1858,7 +1858,7 @@ MPP_RET prepare_init_dpb_info(H264_SLICE_t *currSlice)
memset(p_Dec->dpb_info, 0, MAX_DPB_SIZE * sizeof(H264_DpbInfo_t));
memset(&p_Dec->in_task->refer, -1, sizeof(p_Dec->in_task->refer));
if (currSlice->idr_flag && !currSlice->layer_id) { // idr_flag==1 && layer_id==0
if (currSlice->idr_flag && (currSlice->layer_id == 0)) { // idr_flag==1 && layer_id==0
memset(p_Dec->dpb_old[0], 0, MAX_DPB_SIZE * sizeof(H264_DpbInfo_t));
memset(p_Dec->dpb_old[1], 0, MAX_DPB_SIZE * sizeof(H264_DpbInfo_t));
goto __RETURN;
@@ -2095,7 +2095,7 @@ MPP_RET prepare_init_ref_info(H264_SLICE_t *currSlice)
memset(p_Dec->refpic_info_b[0], 0, MAX_REF_SIZE * sizeof(H264_RefPicInfo_t));
memset(p_Dec->refpic_info_b[1], 0, MAX_REF_SIZE * sizeof(H264_RefPicInfo_t));
if (currSlice->idr_flag && !currSlice->layer_id) { // idr_flag==1 && layer_id==0
if (currSlice->idr_flag && (currSlice->layer_id == 0)) { // idr_flag==1 && layer_id==0
goto __RETURN;
}
//!<------ set listP -------

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

@@ -39,12 +39,12 @@
#define MAX_MARK_SIZE 35 //!< for malloc buffer mark, can be changed
#define NALU_BUF_MAX_SIZE 1024
#define NALU_BUF_MAX_SIZE 1024*1024
#define NALU_BUF_ADD_SIZE 512
#define HEAD_BUF_MAX_SIZE 10*1024
#define HEAD_BUF_ADD_SIZE 512
#define SODB_BUF_MAX_SIZE 10*1024
#define SODB_BUF_ADD_SIZE 512
#define HEAD_BUF_MAX_SIZE 5*1024*1024
#define HEAD_BUF_ADD_SIZE 1024
#define SODB_BUF_MAX_SIZE 10*1024*1024
#define SODB_BUF_ADD_SIZE 1024
//!< AVC Profile IDC definitions
@@ -840,6 +840,14 @@ typedef struct h264d_input_ctx_t {
RK_U32 out_length;
RK_U8 task_valid;
RK_U32 task_eos;
//!< have extradata
RK_U8 is_nalff;
RK_U8 profile;
RK_U8 level;
RK_U32 nal_size;
RK_S32 sps_num;
RK_S32 pps_num;
} H264dInputCtx_t;
//!< TimeStamp context

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

@@ -43,6 +43,32 @@ typedef struct h264d_nalu_head_t {
RK_U32 sodb_len;
} H264dNaluHead_t;
static RK_U16 U16_AT(const RK_U8 *ptr)
{
return ptr[0] << 8 | ptr[1];
}
static RK_U32 U32_AT(const RK_U8 *ptr)
{
return ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3];
}
static RK_U32 parse_nal_size(RK_U8 nal_size, RK_U8 *data)
{
switch (nal_size) {
case 1:
return *data;
case 2:
return U16_AT(data);
case 3:
return ((RK_U32)data[0] << 16) | U16_AT(&data[1]);
case 4:
return U32_AT(data);
}
return 0;
}
static void reset_slice(H264dVideoCtx_t *p_Vid)
{
RK_U32 i = 0, j = 0;
@@ -75,6 +101,7 @@ static void reset_slice(H264dVideoCtx_t *p_Vid)
static MPP_RET realloc_buffer(RK_U8 **buf, RK_U32 *max_size, RK_U32 add_size)
{
MPP_RET ret = MPP_ERR_UNKNOW;
add_size = MPP_ALIGN(add_size, 16);
(*buf) = mpp_realloc((*buf), RK_U8, ((*max_size) + add_size));
MEM_CHECK(ret, (*buf));
(*max_size) += add_size;
@@ -388,7 +415,6 @@ static MPP_RET add_empty_nalu(H264dCurStream_t *p_strm)
RK_U32 add_size = 0;
add_size = MPP_MAX(sizeof(H264dNaluHead_t), HEAD_BUF_ADD_SIZE);
if ((p_strm->head_offset + add_size) >= p_strm->head_max_size) {
FUN_CHECK(ret = realloc_buffer(&p_strm->head_buf, &p_strm->head_max_size, HEAD_BUF_ADD_SIZE));
}
p_des = &p_strm->head_buf[p_strm->head_offset];
@@ -403,15 +429,12 @@ __FAILED:
return ret;
}
static MPP_RET store_cur_nalu(H264dCurCtx_t *p_Cur)
static MPP_RET store_cur_nalu(H264dCurStream_t *p_strm, H264dDxvaCtx_t *dxva_ctx)
{
MPP_RET ret = MPP_ERR_UNKNOW;
RK_U8 *p_des = NULL;
RK_U32 add_size = 0;
H264dDxvaCtx_t *dxva_ctx = NULL;
H264dCurStream_t *p_strm = &p_Cur->strm;
FunctionIn(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
//!< fill head buffer
if ((p_strm->nal_unit_type == NALU_TYPE_SLICE)
|| (p_strm->nal_unit_type == NALU_TYPE_IDR)
@@ -436,7 +459,6 @@ static MPP_RET store_cur_nalu(H264dCurCtx_t *p_Cur)
//!< fill sodb buffer
if ((p_strm->nal_unit_type == NALU_TYPE_SLICE)
|| (p_strm->nal_unit_type == NALU_TYPE_IDR)) {
dxva_ctx = p_Cur->p_Dec->dxva_ctx;
add_size = MPP_MAX(SODB_BUF_ADD_SIZE, p_strm->nalu_len);
if ((dxva_ctx->strm_offset + add_size) >= dxva_ctx->max_strm_size) {
realloc_buffer(&dxva_ctx->bitstream, &dxva_ctx->max_strm_size, add_size);
@@ -446,8 +468,6 @@ static MPP_RET store_cur_nalu(H264dCurCtx_t *p_Cur)
memcpy(p_des + sizeof(g_start_precode), p_strm->nalu_buf, p_strm->nalu_len);
dxva_ctx->strm_offset += p_strm->nalu_len + sizeof(g_start_precode);
}
FunctionIn(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
return ret = MPP_OK;
__FAILED:
@@ -477,7 +497,6 @@ static void insert_timestamp(H264dCurCtx_t *p_Cur, H264dCurStream_t *p_strm)
//p_Cur->pts = p_Cur->p_Inp->in_pts;
}
static MPP_RET judge_is_new_frame(H264dCurCtx_t *p_Cur, H264dCurStream_t *p_strm)
{
MPP_RET ret = MPP_ERR_UNKNOW;
@@ -543,6 +562,9 @@ __FAILED:
return ret;
}
#if 0
/*!
***********************************************************************
@@ -557,12 +579,12 @@ MPP_RET parse_prepare(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
p_Inp->task_valid = 0;
if (p_Cur->p_Dec->is_new_frame) {
FUN_CHECK(ret = store_cur_nalu(p_Cur));
FUN_CHECK(ret = store_cur_nalu(&p_Cur->strm, p_Cur->p_Dec->dxva_ctx));
p_Cur->p_Dec->is_new_frame = 0;
} else if (p_Cur->p_Inp->pkt_eos) {
if (p_Inp->p_Dec->nalu_ret == HaveNoStream) {
//FUN_CHECK(ret = analyze_cur_nalu(p_Cur));
//FUN_CHECK(ret = store_cur_nalu(p_Cur));
//FUN_CHECK(ret = store_cur_nalu(&p_Cur->strm, p_Cur->p_Dec->dxva_ctx));
}
FUN_CHECK(ret = add_empty_nalu(&p_Cur->strm));
p_Inp->task_valid = 1;
@@ -582,7 +604,7 @@ MPP_RET parse_prepare(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
p_Inp->task_valid = 1;
//FPRINT(g_debug_file1, "----- start of picture ---- \n");
} else {
FUN_CHECK(ret = store_cur_nalu(p_Cur));
FUN_CHECK(ret = store_cur_nalu(&p_Cur->strm, p_Cur->p_Dec->dxva_ctx));
}
}
@@ -612,11 +634,12 @@ MPP_RET parse_prepare(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
p_Inp->task_valid = 0;
if (p_Inp->pkt_eos) {
FUN_CHECK(ret = store_cur_nalu(p_Dec->p_Cur));
FUN_CHECK(ret = store_cur_nalu(&p_Cur->strm, p_Dec->dxva_ctx));
FUN_CHECK(ret = add_empty_nalu(p_strm));
p_Dec->p_Inp->task_valid = 1;
p_Dec->p_Inp->task_eos = 1;
LogInfo(p_Inp->p_Dec->logctx.parr[RUN_PARSE], "----- end of stream ----");
mpp_log("----- eos: end of stream ----\n");
goto __RETURN;
}
@@ -651,7 +674,6 @@ MPP_RET parse_prepare(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
}
}
}
find_prefix_code(p_strm->curdata, p_strm);
if (p_strm->endcode_found) {
@@ -661,7 +683,7 @@ MPP_RET parse_prepare(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
p_strm->nalu_len--;
break;
}
p_Dec->nalu_ret = EndOfNalu;
p_Dec->nalu_ret = EndOfNalu;
FUN_CHECK(ret = store_cur_nalu(&p_Dec->p_Cur->strm, p_Dec->dxva_ctx));
reset_nalu(p_strm);
break;
@@ -680,6 +702,134 @@ __FAILED:
__FAILED:
return ret;
}
#endif
/*!
***********************************************************************
* \brief
* main function for parser extra header
***********************************************************************
*/
MPP_RET parse_prepare_extra_header(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
{
RK_S32 i = 0;
RK_U32 add_size = 0;
MPP_RET ret = MPP_ERR_UNKNOW;
H264dLogCtx_t *logctx = &p_Inp->p_Dec->logctx;
H264_DecCtx_t *p_Dec = p_Inp->p_Dec;
H264dCurStream_t *p_strm = &p_Cur->strm;
RK_U8 *pdata = p_Inp->in_buf;
RK_U32 extrasize = p_Inp->in_length;
FunctionIn(logctx->parr[RUN_PARSE]);
if (p_Inp->in_length < 7) {
goto __FAILED;
}
if(pdata[0] != 1){
goto __FAILED;
}
p_Inp->profile = pdata[1];
p_Inp->level = pdata[3];
p_Inp->nal_size = 1 + (pdata[4] & 3);
p_Inp->sps_num = pdata[5] & 31;
pdata += 6;
extrasize -= 6;
for (i=0; i < p_Inp->sps_num; ++i) {
p_strm->nalu_len = U16_AT(pdata);
pdata += 2;
extrasize -= 2;
p_strm->nal_unit_type = NALU_TYPE_SPS;
p_strm->nalu_buf = pdata;
FUN_CHECK(ret = store_cur_nalu(p_strm, p_Cur->p_Dec->dxva_ctx));
//mpp_log("[SPS] i=%d, nalu_len=%d, %02x, %02x, %02x, %02x, %02x, %02x \n", i, p_strm->nalu_len,
//pdata[0], pdata[1], pdata[2], pdata[3], pdata[4], pdata[5]);
pdata += p_strm->nalu_len;
extrasize -= p_strm->nalu_len;
}
p_Inp->pps_num = *pdata;
++pdata;
--extrasize;
for (i = 0; i < p_Inp->pps_num; ++i) {
p_strm->nalu_len = U16_AT(pdata);
pdata += 2;
extrasize -= 2;
p_strm->nal_unit_type = NALU_TYPE_PPS;
p_strm->nalu_buf = pdata;
FUN_CHECK(ret = store_cur_nalu(p_strm, p_Cur->p_Dec->dxva_ctx));
//mpp_log("[PPS] i=%d, nalu_len=%d, %02x, %02x, %02x, %02x, %02x, %02x \n", i, p_strm->nalu_len,
// pdata[0], pdata[1], pdata[2], pdata[3], pdata[4], pdata[5]);
pdata += p_strm->nalu_len;
extrasize -= p_strm->nalu_len;
}
(*p_Inp->in_size) = 0;
//mpp_log("profile=%d, level=%d, nal_size=%d, sps_num=%d, pps_num=%d \n", p_Inp->profile,
// p_Inp->level, p_Inp->nal_size, p_Inp->sps_num, p_Inp->pps_num);
__RETURN:
FunctionOut(logctx->parr[RUN_PARSE]);
return ret = MPP_OK;
__FAILED:
return ret;
}
/*!
***********************************************************************
* \brief
* main function for parser extra data
***********************************************************************
*/
MPP_RET parse_prepare_extra_data(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
{
RK_U32 i = 0;
RK_U32 add_size = 0;
RK_S32 strm_offset = 0;
MPP_RET ret = MPP_ERR_UNKNOW;
H264dLogCtx_t *logctx = &p_Inp->p_Dec->logctx;
H264dCurStream_t *p_strm = &p_Cur->strm;
RK_U8 *pdata = p_Inp->in_buf;
RK_U32 extrasize = p_Inp->in_length;
FunctionIn(logctx->parr[RUN_PARSE]);
VAL_CHECK(ret, (p_Inp->nal_size > 0));
//mpp_log("in_length=%d, %02x, %02x, %02x, %02x, %02x, %02x \n", p_Inp->in_length,
// pdata[0], pdata[1], pdata[2], pdata[3], pdata[4], pdata[5]);
while(strm_offset < p_Inp->in_length) {
VAL_CHECK(ret, (strm_offset + p_Inp->nal_size < p_Inp->in_length));
p_strm->nalu_len = parse_nal_size(p_Inp->nal_size, pdata);
p_strm->nal_unit_type = NALU_TYPE_SLICE;
pdata += p_Inp->nal_size;
strm_offset += p_Inp->nal_size;
p_strm->nalu_buf = pdata;
//mpp_log("[NALU_DATA] i=%d, nalu_len=%d, max_len=%d, %02x, %02x, %02x, %02x, %02x, %02x \n", i++, p_strm->nalu_len,p_strm->nalu_max_size,
// pdata[0], pdata[1], pdata[2], pdata[3], pdata[4], pdata[5]);
FUN_CHECK(ret = store_cur_nalu(p_strm, p_Cur->p_Dec->dxva_ctx));
pdata += p_strm->nalu_len;
strm_offset += p_strm->nalu_len;
}
//!< one frame end
FUN_CHECK(ret = add_empty_nalu(p_strm));
(*p_Inp->in_size) = 0;
p_strm->head_offset = 0;
p_strm->nalu_offset = 0;
p_Inp->p_Dec->nalu_ret = HaveNoStream;
p_Cur->p_Inp->task_valid = 1;
p_Cur->curr_dts = p_Cur->p_Inp->in_dts;
p_Cur->curr_pts = p_Cur->p_Inp->in_pts;
p_Cur->last_dts = p_Cur->curr_dts;
p_Cur->last_pts = p_Cur->curr_pts;
__RETURN:
FunctionOut(logctx->parr[RUN_PARSE]);
return ret = MPP_OK;
__FAILED:
return ret;
}
/*!
***********************************************************************

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

@@ -28,10 +28,10 @@
extern "C" {
#endif
MPP_RET parse_loop(H264_DecCtx_t *p_Dec);
MPP_RET parse_prepare(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur);
MPP_RET parse_loop (H264_DecCtx_t *p_Dec);
MPP_RET parse_prepare_extra_header(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur);
MPP_RET parse_prepare_extra_data(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur);
#ifdef __cplusplus
}

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

@@ -541,7 +541,7 @@ MPP_RET activate_sps(H264dVideoCtx_t *p_Vid, H264_SPS_t *sps, H264_subSPS_t *sub
update_last_video_pars(p_Vid, p_Vid->active_sps, 1);
//!< init frame slots, store frame buffer size
p_Vid->dpb_size[1] = p_Vid->p_Dpb_layer[1]->size;
mpp_buf_slot_setup(p_Vid->p_Dec->frame_slots, p_Vid->dpb_size[0] + p_Vid->dpb_size[1] + 2);
mpp_buf_slot_setup(p_Vid->p_Dec->frame_slots, p_Vid->dpb_size[0] + p_Vid->dpb_size[1] + 1);
}
} else { //!< layer_id == 0
p_Vid->active_sps = sps;
@@ -556,7 +556,7 @@ MPP_RET activate_sps(H264dVideoCtx_t *p_Vid, H264_SPS_t *sps, H264_subSPS_t *sub
update_last_video_pars(p_Vid, p_Vid->active_sps, 0);
//!< init frame slots, store frame buffer size
p_Vid->dpb_size[0] = p_Vid->p_Dpb_layer[0]->size;
mpp_buf_slot_setup(p_Vid->p_Dec->frame_slots, p_Vid->dpb_size[0] + 2);
mpp_buf_slot_setup(p_Vid->p_Dec->frame_slots, p_Vid->dpb_size[0] + 1);
}
}
update_video_pars(p_Vid, p_Vid->active_sps);

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

@@ -1563,7 +1563,7 @@ static RK_S32 hevc_parser_extradata(HEVCContext *s)
* Temporarily, we support configurationVersion==0 until 14496-15 3rd
* is finalized. When finalized, configurationVersion will be 1 and we
* can recognize hvcC by checking if h265dctx->extradata[0]==1 or not. */
const RK_U8 *ptr = (const uint8_t *)h265dctx->extradata;
const RK_U8 *ptr = (const RK_U8 *)h265dctx->extradata;
RK_U32 size = h265dctx->extradata_size;
RK_U32 numofArrays = 0, numofNals = 0;
RK_U32 j = 0, i = 0;

4
mpp/mpp.cpp
View File

@@ -242,8 +242,10 @@ MPP_RET Mpp::control(MpiCmd cmd, MppParam param)
{
switch (cmd) {
case MPP_DEC_SET_EXT_BUF_GROUP: {
mpp_log("mpi_control group %p", param);
mpp_log("mpi_control group %p\n", param);
mFrameGroup = (MppBufferGroup)param;
mpp_log("signal codec thread\n");
mThreadCodec->signal();
break;
}
case MPP_SET_OUTPUT_BLOCK: {

3
mpp/mpp_buffer.cpp
View File

@@ -152,7 +152,10 @@ int mpp_buffer_get_fd(MppBuffer buffer)
MppBufferImpl *p = (MppBufferImpl*)buffer;
int fd = p->info.fd;
#ifndef _WIN32
mpp_assert(fd >= 0);
#endif
return fd;
}