[h264d] add as hvcC format support

git-svn-id: https://10.10.10.66:8443/svn/MediaProcessPlatform/trunk/mpp@461 6e48237b-75ef-9749-8fc9-41990f28c85a

mpp/codec/dec/h264/h264d_api.c

@@ -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) {
-        (ret = parse_prepare(p_Dec->p_Inp, p_Dec->p_Cur));
+		if (p_Dec->p_Inp->is_nalff)	{
-        task->valid = p_Dec->p_Inp->task_valid;  //!< prepare valid flag		
+			(ret = parse_prepare_extra_data(p_Dec->p_Inp, p_Dec->p_Cur));
-        //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);
+		} 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) {

mpp/codec/dec/h264/h264d_dpb.c

@@ -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 -------
@@ -2168,10 +2168,10 @@ MPP_RET prepare_init_ref_info(H264_SLICE_t *currSlice)
                           ? currSlice->listB[k][j]->bot_poc_mmco5 : currSlice->listB[k][j]->bottom_poc;
                 }
                 for (i = 0; i < 16; i++) {
-                    picbuf = p_Dec->dpb_info[i].picbuf;
+                    picbuf  = p_Dec->dpb_info[i].picbuf;
                     TOP_POC = p_Dec->dpb_info[i].TOP_POC;
                     BOT_POC = p_Dec->dpb_info[i].BOT_POC;
-                    voidx = p_Dec->dpb_info[i].voidx;
+                    voidx   = p_Dec->dpb_info[i].voidx;
                     is_used = p_Dec->dpb_info[i].is_used;
                     if (currSlice->structure == FRAME && picbuf) {
                         if (poc == MPP_MIN(TOP_POC, BOT_POC) && (layer_id == voidx))

mpp/codec/dec/h264/h264d_global.h

@@ -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_MAX_SIZE         5*1024*1024	
-#define HEAD_BUF_ADD_SIZE         512
+#define HEAD_BUF_ADD_SIZE         1024		    
-#define SODB_BUF_MAX_SIZE         10*1024
+#define SODB_BUF_MAX_SIZE         10*1024*1024
-#define SODB_BUF_ADD_SIZE         512
+#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

mpp/codec/dec/h264/h264d_parse.c

@@ -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;
+}
+
+
 
 /*!
 ***********************************************************************

mpp/codec/dec/h264/h264d_parse.h

@@ -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
 }

mpp/codec/dec/h264/h264d_sps.c

@@ -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);

mpp/codec/dec/h265/h265d_parser.c

@@ -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;

mpp/mpp.cpp

@@ -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: {

mpp/mpp_buffer.cpp

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