diff --git a/mpp/codec/dec/h264/h264d_api.c b/mpp/codec/dec/h264/h264d_api.c index 72727c69..f28858ce 100644 --- a/mpp/codec/dec/h264/h264d_api.c +++ b/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 { - (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); + 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) { diff --git a/mpp/codec/dec/h264/h264d_dpb.c b/mpp/codec/dec/h264/h264d_dpb.c index 8425a264..6e08ed61 100644 --- a/mpp/codec/dec/h264/h264d_dpb.c +++ b/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)) diff --git a/mpp/codec/dec/h264/h264d_global.h b/mpp/codec/dec/h264/h264d_global.h index 1b937acd..162e56da 100644 --- a/mpp/codec/dec/h264/h264d_global.h +++ b/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_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 NALU_BUF_MAX_SIZE 1024*1024 +#define NALU_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 diff --git a/mpp/codec/dec/h264/h264d_parse.c b/mpp/codec/dec/h264/h264d_parse.c index 56d61db7..715d9dae 100644 --- a/mpp/codec/dec/h264/h264d_parse.c +++ b/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) break; } p_Dec->nalu_ret = EndOfNalu; - FUN_CHECK(ret = store_cur_nalu(p_Dec->p_Cur)); + 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: 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; +} + + + /*! *********************************************************************** * \brief diff --git a/mpp/codec/dec/h264/h264d_parse.h b/mpp/codec/dec/h264/h264d_parse.h index 02d0640b..183e031d 100644 --- a/mpp/codec/dec/h264/h264d_parse.h +++ b/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 } diff --git a/mpp/codec/dec/h264/h264d_sps.c b/mpp/codec/dec/h264/h264d_sps.c index d4278219..be09b69e 100644 --- a/mpp/codec/dec/h264/h264d_sps.c +++ b/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); diff --git a/mpp/codec/dec/h265/h265d_parser.c b/mpp/codec/dec/h265/h265d_parser.c index ce7443fd..6dbc6259 100644 --- a/mpp/codec/dec/h265/h265d_parser.c +++ b/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; diff --git a/mpp/mpp.cpp b/mpp/mpp.cpp index 3964358b..917ade07 100644 --- a/mpp/mpp.cpp +++ b/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: { diff --git a/mpp/mpp_buffer.cpp b/mpp/mpp_buffer.cpp index 1f3b0da2..46fa580f 100644 --- a/mpp/mpp_buffer.cpp +++ b/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; }