/******************************************************************************
* funciton : Start snap
******************************************************************************/
HI_S32 SAMPLE_COMM_VENC_SnapStart(VENC_CHN VencChn, SIZE_S *pstSize)
{
HI_S32 s32Ret;
VENC_CHN_ATTR_S stVencChnAttr;
VENC_ATTR_JPEG_S stJpegAttr;
/******************************************
step 1: Create Venc Channel
******************************************/
stVencChnAttr.stVeAttr.enType = PT_JPEG;
stJpegAttr.u32MaxPicWidth = pstSize->u32Width;
stJpegAttr.u32MaxPicHeight = pstSize->u32Height;
stJpegAttr.u32PicWidth = pstSize->u32Width;
stJpegAttr.u32PicHeight = pstSize->u32Height;
stJpegAttr.u32BufSize = pstSize->u32Width * pstSize->u32Height * 2;
stJpegAttr.bByFrame = HI_TRUE;/*get stream mode is field mode or frame mode*/
memcpy(&stVencChnAttr.stVeAttr.stAttrJpeg, &stJpegAttr, sizeof(VENC_ATTR_JPEG_S));
s32Ret = HI_MPI_VENC_CreateChn(VencChn, &stVencChnAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_CreateChn [%d] faild with %#x!\n",\
VencChn, s32Ret);
return s32Ret;
}
return HI_SUCCESS;
}
HI_S32 PCIV_Slave_StartVenc(PCIV_MSGHEAD_S *pMsg)
{
HI_S32 s32Ret;
VENC_CHN vencChn;
VENC_CHN_ATTR_S *pAttr = NULL;
PCIV_VENCCMD_CREATE_S *pCmd = (PCIV_VENCCMD_CREATE_S *)pMsg->cMsgBody;
PCIV_VENCCMD_ECHO_S *pCmdEcho = (PCIV_VENCCMD_ECHO_S *)pMsg->cMsgBody;
/* If start the local vi then just do it */
pAttr = &(pCmd->stAttr);
pAttr->pValue = pCmd + 1;
vencChn = pCmd->vencChn;
s32Ret = HI_MPI_VENC_CreateChn(vencChn, pAttr, NULL);
HI_ASSERT(HI_SUCCESS == s32Ret);
/* register to group */
s32Ret = HI_MPI_VENC_RegisterChn(pCmd->vencGrp,vencChn);
HI_ASSERT(HI_SUCCESS == s32Ret);
s32Ret = HI_MPI_VENC_StartRecvPic(vencChn);/*main chn start rev */
HI_ASSERT(HI_SUCCESS == s32Ret);
/* Echo the cmd */
pMsg->enMsgType = PCIV_MSGTYPE_CMDECHO;
pMsg->enDevType = PCIV_DEVTYPE_VENCCHN;
pMsg->u32Target = 0;
pMsg->u32MsgLen = sizeof(PCIV_VENCCMD_ECHO_S);
pCmdEcho->vencChn = vencChn;
pCmdEcho->s32Echo = HI_SUCCESS;
s32Ret = PCIV_SendMsg(0, PCIV_MSGPORT_USERCMD, pMsg);
HI_ASSERT((HI_FAILURE != s32Ret));
return HI_SUCCESS;
}
HI_S32 SampleCreateSnapChn(VENC_GRP VeGroup,VENC_CHN SnapChn)
{
HI_S32 s32Ret;
VENC_CHN_ATTR_S stAttr;
VENC_ATTR_JPEG_S stJpegAttr;
stJpegAttr.u32BufSize = 704*576*2;
stJpegAttr.u32PicWidth = 704;
stJpegAttr.u32PicHeight = 576;
stJpegAttr.bVIField = HI_TRUE;
stJpegAttr.bByFrame = HI_TRUE;
stJpegAttr.u32MCUPerECS = 1620;
stJpegAttr.u32ImageQuality = 0;
memset(&stAttr, 0 ,sizeof(VENC_CHN_ATTR_S));
stAttr.enType = PT_JPEG;
stAttr.pValue = (HI_VOID *)&stJpegAttr;
/*创建抓拍通道*/
s32Ret = HI_MPI_VENC_CreateGroup(VeGroup);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_CreateGroup err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_CreateChn(SnapChn, &stAttr, HI_NULL);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_CreateChn err 0x%x\n",s32Ret);
return HI_FAILURE;
}
return HI_SUCCESS;
}
/******************************************************************************
* funciton : Create venc and Start recv pic .
******************************************************************************/
HI_S32 venc_snap_start(VENC_CHN VencChn)
{
HI_S32 s32Ret;
VENC_CHN_ATTR_S stVencChnAttr;
VENC_ATTR_JPEG_S stJpegAttr;
// VPSS_GRP VpssGrp = VencChn;
SIZE_S picSize;
VIDEO_NORM_E enNorm = VIDEO_ENCODING_MODE_PAL;
PIC_SIZE_E enPicSize = PIC_CIF;
s32Ret = get_snap_pic_size(enNorm, enPicSize, &picSize);
if(s32Ret != HI_SUCCESS)
{
Printf("get_snap_pic_size err \n");
return HI_FAILURE;
}
stVencChnAttr.stVeAttr.enType = PT_JPEG;
stJpegAttr.u32MaxPicWidth = picSize.u32Width;
stJpegAttr.u32MaxPicHeight = picSize.u32Height;
stJpegAttr.u32PicWidth = picSize.u32Width;
stJpegAttr.u32PicHeight = picSize.u32Height;
stJpegAttr.u32BufSize = picSize.u32Width * picSize.u32Height * 2;
stJpegAttr.bByFrame = HI_TRUE;
memcpy(&stVencChnAttr.stVeAttr.stAttrJpeg, &stJpegAttr, sizeof(VENC_ATTR_JPEG_S));
s32Ret = HI_MPI_VENC_CreateChn(VencChn, &stVencChnAttr);
if (HI_SUCCESS != s32Ret)
{
Printf("HI_MPI_VENC_CreateChn [%d] faild with %#x!\n",VencChn, s32Ret);
return HI_FAILURE;
}
/******************************************
step : venc bind vpss
******************************************/
s32Ret = venc_bind_vpss(VencChn, &picSize, HI_TRUE);
if (HI_SUCCESS != s32Ret)
{
Printf("venc_bind_vpss failed!\n");
return HI_FAILURE;
}
return HI_SUCCESS;
}
static HI_S32 SampleEnableEncodeH264(VENC_GRP VeGroup, VENC_CHN VeChn,
VI_DEV ViDev, VI_CHN ViChn, VENC_CHN_ATTR_S *pstAttr)
{
HI_S32 s32Ret;
s32Ret = HI_MPI_VENC_CreateGroup(VeGroup);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_CreateGroup err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_BindInput(VeGroup, ViDev, ViChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_BindInput err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_CreateChn(VeChn, pstAttr, HI_NULL);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_CreateChn err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_RegisterChn(VeGroup, VeChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_RegisterChn err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_StartRecvPic(VeChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_StartRecvPic err 0x%x\n",s32Ret);
return HI_FAILURE;
}
return HI_SUCCESS;
}
bool HimppVencChan::enableObject()
{
HI_S32 s32Ret;
GROUP_CROP_CFG_S dis_crop = { .bEnable = HI_FALSE };
if ((s32Ret = HI_MPI_VENC_CreateGroup(_grpid)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VENC_CreateGroup %d failed [%#x]\n",
_grpid, s32Ret);
return false;
}
VENC_CHN_ATTR_S attr;
prepareVencChnAttr(attr);
if ((s32Ret = HI_MPI_VENC_CreateChn(_chnid, &attr)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VENC_CreateChn %d faild [%#x]\n",
_chnid, s32Ret);
goto err_destroy_grp;
}
if ((s32Ret = HI_MPI_VENC_SetMaxStreamCnt(_chnid, 4)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VENC_SetMaxStreamCnt %d failed [%#x]\n",
_chnid, s32Ret);
}
if ((s32Ret = HI_MPI_VENC_RegisterChn(_grpid, _chnid)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VENC_RegisterChn %d-%d failed [%#x]\n",
_grpid, _chnid, s32Ret);
goto err_destroy_chn;
}
if ((s32Ret = HI_MPI_VENC_SetGrpCrop(_grpid, &_crop_cfg)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VENC_SetGrpCrop [%d] faild [%#x]!\n",
_grpid, s32Ret);
goto err_unregister_chn;
}
if ((s32Ret = HI_MPI_VENC_StartRecvPic(_chnid)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VENC_StartRecvPic %d failed [%#x]\n",
_chnid, s32Ret);
goto err_disable_crop;
}
MPP_CHN_S dst_chn;
dst_chn.enModId = HI_ID_GROUP;
dst_chn.s32DevId = _grpid;
dst_chn.s32ChnId = 0;
if ((s32Ret = HI_MPI_SYS_Bind(*source(), &dst_chn)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_SYS_Bind %d failed [%#x]\n",
_chnid, s32Ret);
goto err_stop_recv_pic;
}
return true;
err_stop_recv_pic:
HI_MPI_VENC_StopRecvPic(_chnid);
err_disable_crop:
HI_MPI_VENC_SetGrpCrop(_grpid, &dis_crop);
err_unregister_chn:
HI_MPI_VENC_UnRegisterChn(_chnid);
err_destroy_chn:
HI_MPI_VENC_DestroyChn(_chnid);
err_destroy_grp:
HI_MPI_VENC_DestroyGroup(_grpid);
return false;
}
/******************************************************************************
* funciton : Start venc stream mode (h264, mjpeg)
* note : rate control parameter need adjust, according your case.
******************************************************************************/
HI_S32 SAMPLE_COMM_VENC_Start(VENC_CHN VencChn, PAYLOAD_TYPE_E enType, VIDEO_NORM_E enNorm, PIC_SIZE_E enSize, SAMPLE_RC_E enRcMode)
{
HI_S32 s32Ret;
VENC_CHN_ATTR_S stVencChnAttr;
VENC_ATTR_H264_S stH264Attr;
VENC_ATTR_H264_CBR_S stH264Cbr;
VENC_ATTR_H264_VBR_S stH264Vbr;
VENC_ATTR_H264_FIXQP_S stH264FixQp;
VENC_ATTR_MJPEG_S stMjpegAttr;
VENC_ATTR_MJPEG_FIXQP_S stMjpegeFixQp;
VENC_ATTR_JPEG_S stJpegAttr;
SIZE_S stPicSize;
s32Ret = SAMPLE_COMM_SYS_GetPicSize(enNorm, enSize, &stPicSize);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Get picture size failed!\n");
return HI_FAILURE;
}
/******************************************
step 1: Create Venc Channel
******************************************/
stVencChnAttr.stVeAttr.enType = enType;
switch(enType)
{
case PT_H264:
{
stH264Attr.u32MaxPicWidth = stPicSize.u32Width;
stH264Attr.u32MaxPicHeight = stPicSize.u32Height;
stH264Attr.u32PicWidth = stPicSize.u32Width;/*the picture width*/
stH264Attr.u32PicHeight = stPicSize.u32Height;/*the picture height*/
stH264Attr.u32BufSize = stPicSize.u32Width * stPicSize.u32Height * 2;/*stream buffer size*/
stH264Attr.u32Profile = 0;/*0: baseline; 1:MP; 2:HP ? */
stH264Attr.bByFrame = HI_TRUE;/*get stream mode is slice mode or frame mode?*/
memcpy(&stVencChnAttr.stVeAttr.stAttrH264e, &stH264Attr, sizeof(VENC_ATTR_H264_S));
if(SAMPLE_RC_CBR == enRcMode)
{
stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_H264CBR;
stH264Cbr.u32Gop = (VIDEO_ENCODING_MODE_PAL== enNorm)?25:30;
stH264Cbr.u32StatTime = 1; /* stream rate statics time(s) */
stH264Cbr.u32SrcFrmRate = (VIDEO_ENCODING_MODE_PAL== enNorm)?25:30;/* input (vi) frame rate */
stH264Cbr.fr32DstFrmRate = (VIDEO_ENCODING_MODE_PAL== enNorm)?25:30;/* target frame rate */
switch (enSize)
{
case PIC_QCIF:
stH264Cbr.u32BitRate = 256; /* average bit rate */
break;
case PIC_QVGA: /* 320 * 240 */
case PIC_CIF:
stH264Cbr.u32BitRate = 512;
break;
case PIC_D1:
case PIC_VGA: /* 640 * 480 */
stH264Cbr.u32BitRate = 1024*2;
break;
case PIC_HD720: /* 1280 * 720 */
stH264Cbr.u32BitRate = 1024*3;
break;
case PIC_HD1080: /* 1920 * 1080 */
stH264Cbr.u32BitRate = 1024*6;
break;
default :
stH264Cbr.u32BitRate = 1024*4;
break;
}
stH264Cbr.u32FluctuateLevel = 0; /* average bit rate */
memcpy(&stVencChnAttr.stRcAttr.stAttrH264Cbr, &stH264Cbr, sizeof(VENC_ATTR_H264_CBR_S));
}
else if (SAMPLE_RC_FIXQP == enRcMode)
{
stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_H264FIXQP;
stH264FixQp.u32Gop = (VIDEO_ENCODING_MODE_PAL== enNorm)?25:30;
stH264FixQp.u32SrcFrmRate = (VIDEO_ENCODING_MODE_PAL== enNorm)?25:30;
stH264FixQp.fr32DstFrmRate = (VIDEO_ENCODING_MODE_PAL== enNorm)?25:30;
stH264FixQp.u32IQp = 20;
stH264FixQp.u32PQp = 23;
memcpy(&stVencChnAttr.stRcAttr.stAttrH264FixQp, &stH264FixQp,sizeof(VENC_ATTR_H264_FIXQP_S));
}
else if (SAMPLE_RC_VBR == enRcMode)
{
stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_H264VBR;
stH264Vbr.u32Gop = (VIDEO_ENCODING_MODE_PAL== enNorm)?25:30;
stH264Vbr.u32StatTime = 1;
stH264Vbr.u32SrcFrmRate = (VIDEO_ENCODING_MODE_PAL== enNorm)?25:30;
stH264Vbr.fr32DstFrmRate = (VIDEO_ENCODING_MODE_PAL== enNorm)?25:30;
stH264Vbr.u32MinQp = 10;
stH264Vbr.u32MaxQp = 40;
switch (enSize)
{
case PIC_QCIF:
stH264Vbr.u32MaxBitRate= 256*3; /* average bit rate */
break;
case PIC_QVGA: /* 320 * 240 */
case PIC_CIF:
stH264Vbr.u32MaxBitRate = 512*3;
break;
case PIC_D1:
case PIC_VGA: /* 640 * 480 */
stH264Vbr.u32MaxBitRate = 1024*2;
break;
case PIC_HD720: /* 1280 * 720 */
stH264Vbr.u32MaxBitRate = 1024*3;
break;
case PIC_HD1080: /* 1920 * 1080 */
stH264Vbr.u32MaxBitRate = 1024*6;
break;
default :
stH264Vbr.u32MaxBitRate = 1024*4*3;
break;
}
memcpy(&stVencChnAttr.stRcAttr.stAttrH264Vbr, &stH264Vbr, sizeof(VENC_ATTR_H264_VBR_S));
}
else
{
return HI_FAILURE;
}
}
break;
case PT_MJPEG:
{
stMjpegAttr.u32MaxPicWidth = stPicSize.u32Width;
stMjpegAttr.u32MaxPicHeight = stPicSize.u32Height;
stMjpegAttr.u32PicWidth = stPicSize.u32Width;
stMjpegAttr.u32PicHeight = stPicSize.u32Height;
stMjpegAttr.u32BufSize = stPicSize.u32Width * stPicSize.u32Height * 2;
stMjpegAttr.bByFrame = HI_TRUE; /*get stream mode is field mode or frame mode*/
memcpy(&stVencChnAttr.stVeAttr.stAttrMjpeg, &stMjpegAttr, sizeof(VENC_ATTR_MJPEG_S));
if(SAMPLE_RC_FIXQP == enRcMode)
{
stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_MJPEGFIXQP;
stMjpegeFixQp.u32Qfactor = 90;
stMjpegeFixQp.u32SrcFrmRate = (VIDEO_ENCODING_MODE_PAL== enNorm)?25:30;
stMjpegeFixQp.fr32DstFrmRate = (VIDEO_ENCODING_MODE_PAL== enNorm)?25:30;
memcpy(&stVencChnAttr.stRcAttr.stAttrMjpegeFixQp, &stMjpegeFixQp,
sizeof(VENC_ATTR_MJPEG_FIXQP_S));
}
else if (SAMPLE_RC_CBR == enRcMode)
{
stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_MJPEGCBR;
stVencChnAttr.stRcAttr.stAttrMjpegeCbr.u32StatTime = 1;
stVencChnAttr.stRcAttr.stAttrMjpegeCbr.u32SrcFrmRate = (VIDEO_ENCODING_MODE_PAL== enNorm)?25:30;
stVencChnAttr.stRcAttr.stAttrMjpegeCbr.fr32DstFrmRate = (VIDEO_ENCODING_MODE_PAL== enNorm)?25:30;
stVencChnAttr.stRcAttr.stAttrMjpegeCbr.u32FluctuateLevel = 0;
switch (enSize)
{
case PIC_QCIF:
stVencChnAttr.stRcAttr.stAttrMjpegeCbr.u32BitRate = 384*3; /* average bit rate */
break;
case PIC_QVGA: /* 320 * 240 */
case PIC_CIF:
stVencChnAttr.stRcAttr.stAttrMjpegeCbr.u32BitRate = 768*3;
break;
case PIC_D1:
case PIC_VGA: /* 640 * 480 */
stVencChnAttr.stRcAttr.stAttrMjpegeCbr.u32BitRate = 1024*3*3;
break;
case PIC_HD720: /* 1280 * 720 */
stVencChnAttr.stRcAttr.stAttrMjpegeCbr.u32BitRate = 1024*5*3;
break;
case PIC_HD1080: /* 1920 * 1080 */
stVencChnAttr.stRcAttr.stAttrMjpegeCbr.u32BitRate = 1024*10*3;
break;
default :
stVencChnAttr.stRcAttr.stAttrMjpegeCbr.u32BitRate = 1024*7*3;
break;
}
}
else if (SAMPLE_RC_VBR == enRcMode)
{
stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_MJPEGVBR;
stVencChnAttr.stRcAttr.stAttrMjpegeVbr.u32StatTime = 1;
stVencChnAttr.stRcAttr.stAttrMjpegeVbr.u32SrcFrmRate = (VIDEO_ENCODING_MODE_PAL == enNorm)?25:30;
stVencChnAttr.stRcAttr.stAttrMjpegeVbr.fr32DstFrmRate = 5;
stVencChnAttr.stRcAttr.stAttrMjpegeVbr.u32MinQfactor = 50;
stVencChnAttr.stRcAttr.stAttrMjpegeVbr.u32MaxQfactor = 95;
switch (enSize)
{
case PIC_QCIF:
stVencChnAttr.stRcAttr.stAttrMjpegeVbr.u32MaxBitRate= 256*3; /* average bit rate */
break;
case PIC_QVGA: /* 320 * 240 */
case PIC_CIF:
stVencChnAttr.stRcAttr.stAttrMjpegeVbr.u32MaxBitRate = 512*3;
break;
case PIC_D1:
case PIC_VGA: /* 640 * 480 */
stVencChnAttr.stRcAttr.stAttrMjpegeVbr.u32MaxBitRate = 1024*2*3;
break;
case PIC_HD720: /* 1280 * 720 */
stVencChnAttr.stRcAttr.stAttrMjpegeVbr.u32MaxBitRate = 1024*3*3;
break;
case PIC_HD1080: /* 1920 * 1080 */
stVencChnAttr.stRcAttr.stAttrMjpegeVbr.u32MaxBitRate = 1024*6*3;
break;
default :
stVencChnAttr.stRcAttr.stAttrMjpegeVbr.u32MaxBitRate = 1024*4*3;
break;
}
}
else
{
SAMPLE_PRT("cann't support other mode in this version!\n");
return HI_FAILURE;
}
}
break;
case PT_JPEG:
stJpegAttr.u32PicWidth = stPicSize.u32Width;
stJpegAttr.u32PicHeight = stPicSize.u32Height;
stJpegAttr.u32BufSize = stPicSize.u32Width * stPicSize.u32Height * 2;
stJpegAttr.bByFrame = HI_TRUE;/*get stream mode is field mode or frame mode*/
// 这里的stMjpegAttr是不是应该改为stJpegAttr?
//memcpy(&stVencChnAttr.stVeAttr.stAttrMjpeg, &stMjpegAttr, sizeof(VENC_ATTR_MJPEG_S));
memcpy(&stVencChnAttr.stVeAttr.stAttrMjpeg, &stJpegAttr, sizeof(VENC_ATTR_MJPEG_S));
break;
default:
return HI_ERR_VENC_NOT_SUPPORT;
}
s32Ret = HI_MPI_VENC_CreateChn(VencChn, &stVencChnAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_CreateChn [%d] faild with %#x!\n",\
VencChn, s32Ret);
return s32Ret;
}
/******************************************
step 2: Start Recv Venc Pictures
******************************************/
s32Ret = HI_MPI_VENC_StartRecvPic(VencChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_StartRecvPic faild with%#x!\n", s32Ret);
return HI_FAILURE;
}
return HI_SUCCESS;
}
static int enc_create_h264_stream(const char* name, int vin, int stream, SDK_ENC_H264_STREAM_ATTR_t* stream_attr)
{
if(stream_attr && vin < HI_VENC_CH_BACKLOG_REF && stream < HI_VENC_STREAM_BACKLOG_REF){
SDK_ENC_H264_STREAM_ATTR_t* this_stream_attr = &_sdk_enc.attr.video_stream_attr[vin][stream];
if(0 == this_stream_attr->magic){
int const venc_group = vin * HI_VENC_STREAM_BACKLOG_REF + stream;
int const venc_ch = venc_group;
int const vpss_group = vin;
int const vpss_ch = (0 == stream) ? VPSS_BSTR_CHN : VPSS_LSTR_CHN;
int bps_regular = 0;
// hisilicon structure
//VPSS_CHN_MODE_S vpss_chn_mode;
//VPSS_CHN_ATTR_S vpss_chn_attr;
MPP_CHN_S mpp_chn_vpss;
MPP_CHN_S mpp_chn_venc;
VENC_CHN_ATTR_S venc_chn_attr;
VENC_ATTR_H264_REF_MODE_E venc_attr_h264_ref_mode;
VENC_ATTR_S* const p_venc_attr = &venc_chn_attr.stVeAttr; // the attribute of video encoder
VENC_RC_ATTR_S* const p_venc_rc_attr = &venc_chn_attr.stRcAttr; // the attribute of rate ctrl
VENC_ATTR_H264_S* const p_venc_attr_h264 = &p_venc_attr->stAttrH264e;
VENC_ATTR_H264_CBR_S* const p_h264_cbr = &p_venc_rc_attr->stAttrH264Cbr;
VENC_ATTR_H264_VBR_S* const p_h264_vbr = &p_venc_rc_attr->stAttrH264Vbr;
VENC_ATTR_H264_FIXQP_S* const p_h264_fixqp = &p_venc_rc_attr->stAttrH264FixQp;
VENC_ATTR_H264_ABR_S* const p_h264_abr = &p_venc_rc_attr->stAttrH264Abr;
// only magic is null could be init
// init this stream attribute;
memcpy(this_stream_attr, stream_attr, sizeof(SDK_ENC_H264_STREAM_ATTR_t));
strncpy(this_stream_attr->name, name, sizeof(this_stream_attr->name));
this_stream_attr->magic = ENC_H264_STREAM_ATTR_MAGIC;
this_stream_attr->vin = vin;
this_stream_attr->stream = stream;
this_stream_attr->start = false; // very important, declare the encode status
// Greate Venc Group
SOC_CHECK(HI_MPI_VENC_CreateGroup(venc_group));
// Create Venc Channel
memset(&venc_chn_attr, 0, sizeof(venc_chn_attr));
p_venc_attr->enType = PT_H264; // must be h264 for this interface
p_venc_attr_h264->u32MaxPicWidth = stream_attr->width;
p_venc_attr_h264->u32MaxPicHeight = stream_attr->height;
p_venc_attr_h264->u32PicWidth = stream_attr->width; // the picture width
p_venc_attr_h264->u32PicHeight = stream_attr->height;// the picture height
//p_venc_attr_h264->u32BufSize = p_venc_attr_h264->u32MaxPicWidth * p_venc_attr_h264->u32MaxPicHeight * 3 / 2; // stream buffer size
p_venc_attr_h264->u32BufSize = p_venc_attr_h264->u32MaxPicWidth * p_venc_attr_h264->u32MaxPicHeight*3/4; // stream buffer size
if(0 < (p_venc_attr_h264->u32BufSize%64)) {
p_venc_attr_h264->u32BufSize += 64 - (p_venc_attr_h264->u32BufSize%64);
}
switch(stream_attr->profile){
default:
case SDK_ENC_H264_PROFILE_BASELINE:
p_venc_attr_h264->u32Profile = 0;
break;
case SDK_ENC_H264_PROFILE_DEFAULT:
case SDK_ENC_H264_PROFILE_MAIN:
p_venc_attr_h264->u32Profile = 1;
break;
}
p_venc_attr_h264->bByFrame = HI_TRUE;// get stream mode is slice mode or frame mode
p_venc_attr_h264->bField = HI_FALSE; // surpport frame code only for hi3516, bfield = HI_FALSE
p_venc_attr_h264->bMainStream = HI_TRUE; // surpport main stream only for hi3516, bMainStream = HI_TRUE
p_venc_attr_h264->u32Priority = 0; // channels precedence level. invalidate for hi3516
p_venc_attr_h264->bVIField = HI_FALSE; // the sign of the VI picture is field or frame. Invalidate for hi3516
switch(stream_attr->profile){
case SDK_ENC_H264_PROFILE_BASELINE:
{
p_venc_attr_h264->u32Profile = 0;
break;
}
case SDK_ENC_H264_PROFILE_DEFAULT:
case SDK_ENC_H264_PROFILE_MAIN:
{
p_venc_attr_h264->u32Profile = 1;
break;
}
}
bps_regular = bitrate_regulate(this_stream_attr->width, this_stream_attr->height, this_stream_attr->bps);
switch(stream_attr->mode){
case SDK_ENC_H264_MODE_VBR:
case SDK_ENC_H264_MODE_AUTO:
{
venc_chn_attr.stRcAttr.enRcMode = VENC_RC_MODE_H264VBRv2;
p_h264_vbr->u32Gop = stream_attr->gop;
p_h264_vbr->u32StatTime = (stream_attr->gop + stream_attr->fps - 1) / stream_attr->fps;
p_h264_vbr->u32ViFrmRate = stream_attr->vin_fps;
p_h264_vbr->fr32TargetFrmRate = (typeof(p_h264_vbr->fr32TargetFrmRate))stream_attr->fps;
p_h264_vbr->u32MaxBitRate = bps_regular * 4 /3;
p_h264_vbr->u32MinQp = 24;
p_h264_vbr->u32MaxQp = 32;
break;
}
case SDK_ENC_H264_MODE_CBR:
case SDK_ENC_H264_MODE_ABR:
{
p_venc_rc_attr->enRcMode = VENC_RC_MODE_H264CBRv2;
p_h264_cbr->u32Gop = stream_attr->gop;
p_h264_cbr->u32StatTime = (stream_attr->gop + stream_attr->fps - 1) / stream_attr->fps;
p_h264_cbr->u32ViFrmRate = stream_attr->vin_fps;
p_h264_cbr->fr32TargetFrmRate = (typeof(p_h264_vbr->fr32TargetFrmRate))stream_attr->fps;
p_h264_cbr->u32BitRate = bps_regular;
p_h264_cbr->u32FluctuateLevel = 0;
break;
}
case SDK_ENC_H264_MODE_FIXQP:
{
p_venc_rc_attr->enRcMode = VENC_RC_MODE_H264FIXQP;
p_h264_fixqp->u32Gop = stream_attr->gop;
p_h264_fixqp->u32ViFrmRate = stream_attr->vin_fps;
p_h264_fixqp->fr32TargetFrmRate = (typeof(p_h264_vbr->fr32TargetFrmRate))stream_attr->fps;
p_h264_fixqp->u32IQp = 20;
p_h264_fixqp->u32PQp = 23;
break;
}
default:
{
SOC_TRACE("H264 encode mode %d not supported!", stream_attr->mode);
break;
}
}
SOC_CHECK(HI_MPI_VENC_CreateChn(venc_ch, &venc_chn_attr));
SOC_CHECK(HI_MPI_VENC_RegisterChn(venc_ch, venc_group));
memset(&mpp_chn_vpss, 0, sizeof(mpp_chn_vpss));
memset(&mpp_chn_venc, 0, sizeof(mpp_chn_venc));
// binding venc to vpss
mpp_chn_vpss.enModId = HI_ID_VPSS;
mpp_chn_vpss.s32DevId = vpss_group;
mpp_chn_vpss.s32ChnId = vpss_ch;
mpp_chn_venc.enModId = HI_ID_GROUP;
mpp_chn_venc.s32DevId = venc_group;
mpp_chn_venc.s32ChnId = venc_ch;
SOC_CHECK(HI_MPI_SYS_Bind(&mpp_chn_vpss, &mpp_chn_venc));
// set h264 reference mode
SOC_CHECK(HI_MPI_VENC_GetH264eRefMode(venc_ch, &venc_attr_h264_ref_mode));
switch(stream_attr->ref_mode) {
case SDK_ENC_H264_REF_MODE_1X:
venc_attr_h264_ref_mode = H264E_REF_MODE_1X;
break;
case SDK_ENC_H264_REF_MODE_2X:
venc_attr_h264_ref_mode = H264E_REF_MODE_2X;
break;
case SDK_ENC_H264_REF_MODE_4X:
venc_attr_h264_ref_mode = H264E_REF_MODE_4X;
break;
}
SOC_CHECK(HI_MPI_VENC_SetH264eRefMode(venc_ch, venc_attr_h264_ref_mode));
// create a new video encode engine
return SDK_SUCCESS;
}
}
return SDK_FAILURE;
}
static int enc_create_h264_stream(const char* name, int vin, int stream, SDK_ENC_H264_STREAM_ATTR_t* stream_attr)
{
if(vin < HI_VENC_CH_BACKLOG_REF){
if(stream < HI_VENC_STREAM_BACKLOG_REF){
SDK_ENC_H264_STREAM_ATTR_t* const main_stream_attr = &_sdk_enc.attr.video_stream_attr[vin][0];
SDK_ENC_H264_STREAM_ATTR_t* const this_stream_attr = &_sdk_enc.attr.video_stream_attr[vin][stream];
if(0 == this_stream_attr->magic){
VENC_ATTR_H264_REF_MODE_E venc_attr_h264_ref_mode;
VENC_CHN_ATTR_S venc_chn_attr;
VENC_ATTR_H264_S venc_attr_h264;
VENC_ATTR_H264_RC_S venc_attr_h264_rc = {0};
int const venc_group = vin;
int const venc_ch = vin * HI_VENC_STREAM_BACKLOG_REF + stream;
bool is_main = (0 == stream) ? true : false;
// only magic is null could be init
// init this stream attribute;
memcpy(this_stream_attr, stream_attr, sizeof(SDK_ENC_H264_STREAM_ATTR_t));
strncpy(this_stream_attr->name, name, sizeof(this_stream_attr->name));
this_stream_attr->magic = ENC_H264_STREAM_ATTR_MAGIC; // mark it
this_stream_attr->vin = vin;
this_stream_attr->stream = stream;
if(stream > 0){
// the size of stream depands on the main stream size
if((this_stream_attr->width != main_stream_attr->width && this_stream_attr->width * 2 != main_stream_attr->width)
|| (this_stream_attr->height != main_stream_attr->height && this_stream_attr->height * 2 != main_stream_attr->height)){
this_stream_attr->width = main_stream_attr->width / 2;
this_stream_attr->height = main_stream_attr->height / 2;
}
}
this_stream_attr->start = false; // very important, declare the encode status
SDK_ZERO_VAL(venc_chn_attr);
venc_chn_attr.enType = PT_H264; // both h264
venc_chn_attr.pValue = &venc_attr_h264;
SDK_ZERO_VAL(venc_attr_h264);
venc_attr_h264.bMainStream = is_main ? HI_TRUE : HI_FALSE;
venc_attr_h264.bField = HI_FALSE;
venc_attr_h264.bVIField = HI_FALSE;
venc_attr_h264.u32PicWidth = this_stream_attr->width;
venc_attr_h264.u32PicHeight = this_stream_attr->height;
venc_attr_h264.u32ViFramerate = this_stream_attr->vin_fps;
venc_attr_h264.u32TargetFramerate = this_stream_attr->fps;
venc_attr_h264.u32Gop = this_stream_attr->gop;
venc_attr_h264.u32MaxDelay = 100;
venc_attr_h264.u32Priority = 0;
venc_attr_h264.bByFrame = HI_TRUE;
venc_attr_h264.u32BufSize = venc_attr_h264.u32PicWidth * venc_attr_h264.u32PicHeight * 3 / 2;
venc_attr_h264.enRcMode = RC_MODE_CBR;
venc_attr_h264.u32PicLevel = 0;
//venc_attr_h264.u32Bitrate = this_stream_attr->bps;
venc_attr_h264.u32Bitrate = bitrate_regulate(this_stream_attr->width, this_stream_attr->height, this_stream_attr->bps);
SOC_TRACE("Creating h264 %d,%d", vin, stream);
// create video encode group
if(is_main){
int vi_dev = 0;
int vi_chn = 0;
vimap_hi3515(vin, &vi_dev, &vi_chn);
SOC_TRACE("Binding to (%d,%d)", vi_dev, vi_chn);
SOC_CHECK(HI_MPI_VENC_CreateGroup(venc_group));
SOC_CHECK(HI_MPI_VENC_BindInput(venc_group, vi_dev, vi_chn));
}
// create video encode channel and register it
SOC_CHECK(HI_MPI_VENC_CreateChn(venc_ch, &venc_chn_attr, HI_NULL));
SOC_CHECK(HI_MPI_VENC_RegisterChn(venc_group, venc_ch));
// set h264 rc parameter
SOC_CHECK(HI_MPI_VENC_GetH264eRcPara(venc_ch, &venc_attr_h264_rc));
venc_attr_h264_rc.s32IdrQpMax = 42; // 050 version description point 9
venc_attr_h264_rc.bFrameLostAllow = HI_TRUE;
venc_attr_h264_rc.s32OsdProtectEn = HI_FALSE;
venc_attr_h264_rc.bSceneChangeClip = HI_FALSE; // 050 version description point 13
venc_attr_h264_rc.bVbrQpDownAllowed = HI_TRUE;
SOC_CHECK(HI_MPI_VENC_SetH264eRcPara(venc_ch, &venc_attr_h264_rc));
// set h264 reference mode
SOC_CHECK(HI_MPI_VENC_GetH264eRefMode(venc_ch, &venc_attr_h264_ref_mode));
switch(stream_attr->ref_mode) {
case SDK_ENC_H264_REF_MODE_1X:
venc_attr_h264_ref_mode = H264E_REF_MODE_1X;
break;
case SDK_ENC_H264_REF_MODE_2X:
venc_attr_h264_ref_mode = H264E_REF_MODE_2X;
break;
case SDK_ENC_H264_REF_MODE_4X:
venc_attr_h264_ref_mode = H264E_REF_MODE_4X;
break;
}
SOC_CHECK(HI_MPI_VENC_SetH264eRefMode(venc_ch, venc_attr_h264_ref_mode));
return SDK_SUCCESS;
}
}
}
return SDK_FAILURE;
}
HI_S32 SampleEnable1D1H2641CifH264(HI_VOID)
{
HI_S32 s32Ret;
VENC_GRP VeGroup = 0;
VENC_CHN VeChn = 0, VeChn2 = 1;
VI_DEV ViDev = VIDEVID;
VI_CHN ViChn = VICHNID;
VENC_CHN_ATTR_S stAttr[2];
VENC_ATTR_H264_S stH264Attr;
VENC_ATTR_H264_S stH264Attr2;
stH264Attr.u32PicWidth = 704;
stH264Attr.u32PicHeight = 576;
stH264Attr.bMainStream = HI_TRUE;
stH264Attr.bByFrame = HI_TRUE;
stH264Attr.bCBR = HI_TRUE;
stH264Attr.bField = HI_FALSE;
stH264Attr.bVIField = HI_FALSE;
stH264Attr.u32Bitrate = 1024;
stH264Attr.u32ViFramerate = 25;
stH264Attr.u32TargetFramerate = 25;
stH264Attr.u32BufSize = 704*576*2;
stH264Attr.u32Gop = 100;
stH264Attr.u32MaxDelay = 100;
stH264Attr.u32PicLevel = 0;
stH264Attr2.u32PicWidth = 352;
stH264Attr2.u32PicHeight = 288;
stH264Attr2.bMainStream = HI_FALSE;
stH264Attr2.bByFrame = HI_TRUE;
stH264Attr2.bCBR = HI_TRUE;
stH264Attr2.bField = HI_FALSE;
stH264Attr2.bVIField = HI_FALSE;
stH264Attr2.u32Bitrate = 512;
stH264Attr2.u32ViFramerate = 25;
stH264Attr2.u32TargetFramerate = 25;
stH264Attr2.u32BufSize = 352*288*2;
stH264Attr2.u32Gop = 100;
stH264Attr2.u32MaxDelay = 100;
stH264Attr2.u32PicLevel = 0;
memset(&stAttr[0], 0 ,sizeof(VENC_CHN_ATTR_S));
stAttr[0].enType = PT_H264;
stAttr[0].pValue = (HI_VOID *)&stH264Attr;
memset(&stAttr[1], 0 ,sizeof(VENC_CHN_ATTR_S));
stAttr[1].enType = PT_H264;
stAttr[1].pValue = (HI_VOID *)&stH264Attr2;
s32Ret = HI_MPI_VENC_CreateGroup(VeGroup);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_CreateGroup err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_BindInput(VeGroup, ViDev, ViChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_BindInput err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_CreateChn(VeChn, &stAttr[0], HI_NULL);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_CreateChn err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_CreateChn(VeChn2, &stAttr[1], HI_NULL);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_CreateChn err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_RegisterChn(VeGroup, VeChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_RegisterChn err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_RegisterChn(VeGroup, VeChn2);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_RegisterChn err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_StartRecvPic(VeChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_StartRecvPic err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_StartRecvPic(VeChn2);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_StartRecvPic err 0x%x\n",s32Ret);
return HI_FAILURE;
}
return HI_SUCCESS;
}
