HI_S32 PCIV_Slave_StartGrp(PCIV_MSGHEAD_S *pMsg)
{
HI_S32 s32Ret;
VENC_GRP vencGrp;
PCIV_GRPCMD_CREATE_S *pCmd = (PCIV_GRPCMD_CREATE_S *)pMsg->cMsgBody;
PCIV_GRPCMD_ECHO_S *pCmdEcho = (PCIV_GRPCMD_ECHO_S *)pMsg->cMsgBody;
/* Start the VI first */
vencGrp = pCmd->vencGrp;
/* Create new group first */
s32Ret = HI_MPI_VENC_CreateGroup(vencGrp);
HI_ASSERT((HI_SUCCESS == s32Ret));
s32Ret = HI_MPI_VENC_BindInput(vencGrp, pCmd->viDev, pCmd->viChn);
HI_ASSERT((HI_SUCCESS == s32Ret));
/* Echo the cmd */
pMsg->enMsgType = PCIV_MSGTYPE_CMDECHO;
pMsg->enDevType = PCIV_DEVTYPE_GROUP;
pMsg->u32Target = 0;
pMsg->u32MsgLen = sizeof(PCIV_GRPCMD_ECHO_S);
pCmdEcho->vencGrp = vencGrp;
pCmdEcho->s32Echo = HI_SUCCESS;
s32Ret = PCIV_SendMsg(0, PCIV_MSGPORT_USERCMD, pMsg);
HI_ASSERT((HI_FAILURE != s32Ret));
return HI_SUCCESS;
}
HI_S32 SampleStartSnap(VENC_GRP VeGroup,VENC_CHN SnapChn,
VI_DEV ViDev,VI_CHN ViChn,FILE *pFile)
{
HI_S32 s32Ret;
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_RegisterChn(VeGroup, SnapChn);
if(s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_RegisterChn err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_StartRecvPic(SnapChn);
if(s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_StartRecvPic err 0x%x\n",s32Ret);
return HI_FAILURE;
}
/*save jpeg picture*/
s32Ret = SampleSaveSnapPic(SnapChn,pFile);
if(s32Ret != HI_SUCCESS)
{
printf("SampleSaveSnapPic err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_StopRecvPic(SnapChn);
if(s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_StopRecvPic err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_UnRegisterChn(SnapChn);
if(s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_UnRegisterChn err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_UnbindInput(VeGroup);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_UnbindInput err 0x%x\n",s32Ret);
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;
}
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;
}
/*****************************************************************************
snap by mode 2
how to snap:
1)create snap group for each vichn,and bind them (not unbind until program end),
that is muti snap group exit, instead of only one
2)create one snap channel for each snap group
3)register snap chn to its corresponding group, snapping, and then unregister
4)repeat 3) to snap muti pictures of the channel
features:
1)need more memory than mode 1, because muti snap group and snap channel exit
2)higher efficiency, because all snap chn run simultaneity.
*****************************************************************************/
HI_VOID* thread_StartSnapByMode2(HI_VOID *p)
{
HI_S32 s32Ret;
VENC_GRP VeGroup;
VENC_CHN SnapChn;
VI_DEV ViDev;
VI_CHN ViChn;
FILE *pFile = NULL;
HI_S32 s32SnapCnt;
HI_S32 s32SnapTotal;
SNAP_SINGLE_CHN_S *pstSnapSingleChn = NULL;
pstSnapSingleChn = (SNAP_SINGLE_CHN_S*)p;
VeGroup = pstSnapSingleChn->VeGroup;
SnapChn = pstSnapSingleChn->SnapChn;
ViDev = pstSnapSingleChn->ViDev;
ViChn = pstSnapSingleChn->ViChn;
s32SnapTotal = pstSnapSingleChn->s32SnapTotal;
/*note: bind snap group to vichn, not unbind while snapping*/
s32Ret = HI_MPI_VENC_BindInput(VeGroup, ViDev, ViChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_BindInput err 0x%x\n", s32Ret);
return NULL;
}
s32SnapCnt = 0;
while (HI_TRUE == pstSnapSingleChn->bThreadStart)
{
s32Ret = HI_MPI_VENC_RegisterChn(VeGroup, SnapChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_RegisterChn err 0x%x\n", s32Ret);
return NULL;
}
s32Ret = HI_MPI_VENC_StartRecvPic(SnapChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_StartRecvPic err 0x%x\n", s32Ret);
return NULL;
}
{
/*save jpeg picture*/
char acFile[128] = {0};
//struct timeval timenow;
sprintf(acFile, "Vichn%d_num%d.jpg", ViChn, s32SnapCnt);
pFile = fopen(acFile, "wb");
if (pFile == NULL)
{
printf("open file err\n");
return NULL;
}
s32Ret = SAMPLE_GetSnapPic(SnapChn, pFile);
if (s32Ret != HI_SUCCESS)
{
printf("SAMPLE_GetSnapPic err 0x%x\n", s32Ret);
fclose(pFile);
return NULL;
}
fclose(pFile);
}
s32Ret = HI_MPI_VENC_StopRecvPic(SnapChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_StopRecvPic err 0x%x\n", s32Ret);
return NULL;
}
s32Ret = HI_MPI_VENC_UnRegisterChn(SnapChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_UnRegisterChn err 0x%x\n", s32Ret);
return NULL;
}
s32SnapCnt++;
}
s32Ret = HI_MPI_VENC_UnbindInput(VeGroup);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_UnbindInput err 0x%x\n", s32Ret);
return NULL;
}
return NULL;
}
/*****************************************************************************
snap by mode 1
how to snap:
1)only creat one snap group
2)bind to a vichn to snap and then unbind
3)repeat 2) to snap all vichn in turn
features:
1)save memory, because only one snap group and snap channel
2)efficiency lower than mode 2, pictures snapped will not more than 8.
*****************************************************************************/
HI_VOID* thread_StartSnapByMode1(HI_VOID *p)
{
HI_S32 s32Ret;
VENC_GRP VeGroup = 0;
VENC_CHN SnapChn = 0;
VI_DEV ViDev = 0;
VI_CHN ViChn = 0;
FILE *pFile = NULL;
HI_S32 s32SnapCnt = 0;
HI_S32 s32SnapTotal;
SNAP_MULTI_CHN_S *pstSnapMultiChn = NULL;
HI_S32 s32ViChnTotal;
pstSnapMultiChn = (SNAP_MULTI_CHN_S*)p;
VeGroup = pstSnapMultiChn->SnapGroup;
SnapChn = pstSnapMultiChn->SnapChn;
ViDev = pstSnapMultiChn->ViDev;
s32ViChnTotal = pstSnapMultiChn->s32ViChnCnt;
s32SnapTotal = pstSnapMultiChn->s32SnapTotal;
/* snap all vi channels in sequence.
* step 1: bind vi
* step 2: register snap channel to group.
* step 3: start snap channel to receiver picture.
* step 4: get one-picture stream and save as jpeg file.
* step 5: undo step 3, step 2, step 1.
* step 6: chose next vi to snap, then go to step 1
*/
ViChn = 0;
while (HI_TRUE == pstSnapMultiChn->bThreadStart)
{
s32Ret = HI_MPI_VENC_BindInput(VeGroup, ViDev, ViChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_BindInput err 0x%x\n", s32Ret);
return NULL;
}
s32Ret = HI_MPI_VENC_RegisterChn(VeGroup, SnapChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_RegisterChn err 0x%x\n", s32Ret);
return NULL;
}
s32Ret = HI_MPI_VENC_StartRecvPic(SnapChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_StartRecvPic err 0x%x\n", s32Ret);
return NULL;
}
{
/*save jpeg picture*/
char acFile[128] = {0};
//struct timeval timenow;
//gettimeofday(&timenow, NULL);
sprintf(acFile, "Vichn%d_num%d.jpg", ViChn, s32SnapCnt);
pFile = fopen(acFile, "wb");
if (pFile == NULL)
{
printf("open file err\n");
return NULL;
}
s32Ret = SAMPLE_GetSnapPic(SnapChn, pFile);
if (s32Ret != HI_SUCCESS)
{
printf("SAMPLE_GetSnapPic err 0x%x\n", s32Ret);
fclose(pFile);
return NULL;
}
fclose(pFile);
}
s32Ret = HI_MPI_VENC_StopRecvPic(SnapChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_StopRecvPic err 0x%x\n", s32Ret);
return NULL;
}
s32Ret = HI_MPI_VENC_UnRegisterChn(SnapChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_UnRegisterChn err 0x%x\n", s32Ret);
return NULL;
}
s32Ret = HI_MPI_VENC_UnbindInput(VeGroup);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_UnbindInput err 0x%x\n", s32Ret);
return NULL;
}
/* continue to snap next vi channel */
ViChn++;
if(ViChn >= s32ViChnTotal)
{
ViChn = 0;
s32SnapCnt++;
}
}
return NULL;
}
