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