HI_S32 SampleDisable1D1Mjpeg1CifH264(HI_VOID)
{
HI_S32 s32Ret;
s32Ret = HI_MPI_VENC_StopRecvPic(1);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_StartRecvPic err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_StopRecvPic(0);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_StartRecvPic err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_UnRegisterChn(1);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_UnRegisterChn err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_UnRegisterChn(0);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_UnRegisterChn err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_DestroyChn(1);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_DestroyChn err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_DestroyChn(0);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_DestroyChn err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_DestroyGroup(0);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_DestroyGroup err 0x%x\n",s32Ret);
return HI_FAILURE;
}
return HI_SUCCESS;
}
static HI_S32 SampleDisableEncodeH264(VENC_GRP VeGroup, VENC_CHN VeChn)
{
HI_S32 s32Ret;
s32Ret = HI_MPI_VENC_StopRecvPic(VeChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_StartRecvPic err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_UnRegisterChn(VeChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_UnRegisterChn err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_DestroyChn(VeChn);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_DestroyChn err 0x%x\n",s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_DestroyGroup(VeGroup);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_DestroyGroup err 0x%x\n",s32Ret);
return HI_FAILURE;
}
return HI_SUCCESS;
}
/******************************************************************************
* funciton : Stop venc ( stream mode -- H264, MJPEG )
******************************************************************************/
HI_S32 SAMPLE_COMM_VENC_Stop(VENC_CHN VencChn)
{
HI_S32 s32Ret;
/******************************************
step 1: Stop Recv Pictures
******************************************/
s32Ret = HI_MPI_VENC_StopRecvPic(VencChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_StopRecvPic vechn[%d] failed with %#x!\n",\
VencChn, s32Ret);
return HI_FAILURE;
}
/******************************************
step 2: Distroy Venc Channel
******************************************/
s32Ret = HI_MPI_VENC_DestroyChn(VencChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_DestroyChn vechn[%d] failed with %#x!\n",\
VencChn, s32Ret);
return HI_FAILURE;
}
return HI_SUCCESS;
}
HI_S32 PCIV_Slave_StopVenc(PCIV_MSGHEAD_S *pMsg)
{
HI_S32 s32Ret;
VENC_CHN vencChn;
VENC_CHN_ATTR_S *pAttr = NULL;
PCIV_VENCCMD_DESTROY_S *pCmd = (PCIV_VENCCMD_DESTROY_S *)pMsg->cMsgBody;
PCIV_VENCCMD_ECHO_S *pCmdEcho = (PCIV_VENCCMD_ECHO_S *)pMsg->cMsgBody;
vencChn = pCmd->vencChn;
s32Ret = HI_MPI_VENC_StopRecvPic(vencChn);/*main chn start rev */
HI_ASSERT(HI_SUCCESS == s32Ret);
s32Ret = HI_MPI_VENC_UnRegisterChn(vencChn);/*register to group 0 */
HI_ASSERT(HI_SUCCESS == s32Ret);
s32Ret = HI_MPI_VENC_DestroyChn(vencChn);
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;
}
static int enc_release_h264_stream(int vin, int stream)
{
SDK_ENC_H264_STREAM_ATTR_t* stream_attr = &_sdk_enc.attr.video_stream_attr[vin][stream];
if(vin < HI_VENC_CH_BACKLOG_REF && stream < HI_VENC_STREAM_BACKLOG_REF){
if(ENC_H264_STREAM_ATTR_MAGIC == stream_attr->magic){
int const venc_group = vin;
int const venc_ch = vin * HI_VENC_STREAM_BACKLOG_REF + stream;
SOC_TRACE("Release video encode (%d,%d)", vin, stream);
SOC_CHECK(HI_MPI_VENC_StopRecvPic(venc_ch));
SOC_CHECK(HI_MPI_VENC_UnRegisterChn(venc_ch));
SOC_CHECK(HI_MPI_VENC_DestroyChn(venc_ch));
if(0 == stream){
SOC_CHECK(HI_MPI_VENC_UnbindInput(venc_group));
SOC_CHECK(HI_MPI_VENC_DestroyGroup(venc_group));
}
// clear the magic
stream_attr->magic = 0;
return SDK_SUCCESS;
}
}
return SDK_FAILURE;
}
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;
}
/******************************************************************************
* funciton : Create venc and Start recv pic .
******************************************************************************/
HI_S32 venc_snap_stop(VENC_CHN VencChn)
{
HI_S32 s32Ret;
// VPSS_GRP VpssGrp = VencChn;
// MPP_CHN_S stSrcChn;
// MPP_CHN_S stDestChn;
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;
}
/******************************************
step : stop recv pic
******************************************/
s32Ret = HI_MPI_VENC_StopRecvPic(VencChn);
if (HI_SUCCESS != s32Ret)
{
Printf("HI_MPI_VENC_StopRecvPic [%d] faild with %#x!\n",VencChn, s32Ret);
return HI_FAILURE;
}
/******************************************
step : venc unbind vpss
******************************************/
s32Ret = venc_bind_vpss(VencChn, &picSize, HI_FALSE);
if (HI_SUCCESS != s32Ret)
{
Printf("venc_bind_vpss failed!\n");
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_DestroyChn(VencChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_DestroyChn vechn[%d] failed with %#x!\n", VencChn, s32Ret);
return HI_FAILURE;
}
return HI_SUCCESS;
}
bool HimppVencChan::disableObject()
{
HI_S32 s32Ret;
GROUP_CROP_CFG_S dis_crop = { .bEnable = HI_FALSE };
MPP_CHN_S dst_chn = {
.enModId = HI_ID_GROUP,
.s32DevId = _grpid,
.s32ChnId = 0
};
if ((s32Ret = HI_MPI_SYS_UnBind(*source(), &dst_chn)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_SYS_UnBind %d failed [%#x]\n",
_chnid, s32Ret);
}
if ((s32Ret = HI_MPI_VENC_StopRecvPic(_chnid)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VENC_StopRecvPic %d failed [%#x]\n",
_chnid, s32Ret);
}
if ((s32Ret = HI_MPI_VENC_SetGrpCrop(_grpid, &dis_crop)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VENC_SetGrpCrop [%d] failed [%#x]!\n",
_grpid, s32Ret);
}
if ((s32Ret = HI_MPI_VENC_UnRegisterChn(_chnid)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VENC_UnRegisterChn %d failed [%#x]\n",
_chnid, s32Ret);
}
if ((s32Ret = HI_MPI_VENC_DestroyChn(_chnid)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VENC_DestroyChn %d failed [%#x]\n",
_chnid, s32Ret);
}
if ((s32Ret = HI_MPI_VENC_DestroyGroup(_grpid)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VENC_DestroyGroup %d failed [%#x]\n",
_grpid, s32Ret);
}
return true;
}
/******************************************************************************
* funciton : Stop snap
******************************************************************************/
HI_S32 SAMPLE_COMM_VENC_SnapStop(VENC_CHN VencChn)
{
HI_S32 s32Ret;
s32Ret = HI_MPI_VENC_StopRecvPic(VencChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_StopRecvPic vechn[%d] failed with %#x!\n", VencChn, s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_DestroyChn(VencChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_DestroyChn vechn[%d] failed with %#x!\n", VencChn, s32Ret);
return HI_FAILURE;
}
return HI_SUCCESS;
}
static int enc_release_h264_stream(int vin, int stream)
{
SDK_ENC_H264_STREAM_ATTR_t* stream_attr = &_sdk_enc.attr.video_stream_attr[vin][stream];
if(stream_attr && vin < HI_VENC_CH_BACKLOG_REF && stream < HI_VENC_STREAM_BACKLOG_REF){
if(ENC_H264_STREAM_ATTR_MAGIC == stream_attr->magic){
int const venc_ch = __HI_VENC_CH(vin, stream);
int const venc_group = venc_ch;
int const vpss_group = vin;
int const vpss_ch = (venc_ch % HI_VENC_STREAM_BACKLOG_REF);
MPP_CHN_S mpp_chn_vpss;
MPP_CHN_S mpp_chn_venc;
memset(&mpp_chn_vpss, 0, sizeof(mpp_chn_vpss));
memset(&mpp_chn_venc, 0, sizeof(mpp_chn_venc));
// unbind 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_TRACE("Stoping recv venc %d", venc_ch);
SOC_CHECK(HI_MPI_VENC_StopRecvPic(venc_ch));
SOC_CHECK(HI_MPI_SYS_UnBind(&mpp_chn_vpss, &mpp_chn_venc));
SOC_CHECK(HI_MPI_VENC_UnRegisterChn(venc_ch));
SOC_CHECK(HI_MPI_VENC_DestroyChn(venc_ch));
SOC_CHECK(HI_MPI_VENC_DestroyGroup(venc_group));
// clear the magic
stream_attr->magic = 0;
return SDK_SUCCESS;
}
}
return SDK_FAILURE;
}
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 : snap process
******************************************************************************/
HI_S32 SAMPLE_COMM_VENC_SnapProcess(VENC_CHN VencChn, VPSS_GRP VpssGrp, VPSS_CHN VpssChn)
{
struct timeval TimeoutVal;
fd_set read_fds;
HI_S32 s32VencFd;
VENC_CHN_STAT_S stStat;
VENC_STREAM_S stStream;
HI_S32 s32Ret;
printf("press any key to snap one pic\n");
getchar();
/******************************************
step 1: Venc Chn bind to Vpss Chn
******************************************/
s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_VENC_BindVpss failed!\n");
return HI_FAILURE;
}
/******************************************
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;
}
/******************************************
step 3: recv picture
******************************************/
s32VencFd = HI_MPI_VENC_GetFd(VencChn);
if (s32VencFd < 0)
{
SAMPLE_PRT("HI_MPI_VENC_GetFd faild with%#x!\n", s32VencFd);
return HI_FAILURE;
}
FD_ZERO(&read_fds);
FD_SET(s32VencFd, &read_fds);
TimeoutVal.tv_sec = 2;
TimeoutVal.tv_usec = 0;
s32Ret = select(s32VencFd+1, &read_fds, NULL, NULL, &TimeoutVal);
if (s32Ret < 0)
{
SAMPLE_PRT("snap select failed!\n");
return HI_FAILURE;
}
else if (0 == s32Ret)
{
SAMPLE_PRT("snap time out!\n");
return HI_FAILURE;
}
else
{
if (FD_ISSET(s32VencFd, &read_fds))
{
s32Ret = HI_MPI_VENC_Query(VencChn, &stStat);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VENC_Query failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
stStream.pstPack = (VENC_PACK_S*)malloc(sizeof(VENC_PACK_S) * stStat.u32CurPacks);
if (NULL == stStream.pstPack)
{
SAMPLE_PRT("malloc memory failed!\n");
return HI_FAILURE;
}
stStream.u32PackCount = stStat.u32CurPacks;
s32Ret = HI_MPI_VENC_GetStream(VencChn, &stStream, -1);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_GetStream failed with %#x!\n", s32Ret);
free(stStream.pstPack);
stStream.pstPack = NULL;
return HI_FAILURE;
}
s32Ret = SAMPLE_COMM_VENC_SaveSnap(&stStream);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_GetStream failed with %#x!\n", s32Ret);
free(stStream.pstPack);
stStream.pstPack = NULL;
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_ReleaseStream(VencChn, &stStream);
if (s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_ReleaseStream failed with %#x!\n", s32Ret);
free(stStream.pstPack);
stStream.pstPack = NULL;
return HI_FAILURE;
}
free(stStream.pstPack);
stStream.pstPack = NULL;
}
}
/******************************************
step 4: stop recv picture
******************************************/
s32Ret = HI_MPI_VENC_StopRecvPic(VencChn);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VENC_StopRecvPic failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
/******************************************
step 5: unbind
******************************************/
s32Ret = SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_VENC_UnBindVpss failed!\n");
return HI_FAILURE;
}
return HI_SUCCESS;
}
void *venc_start_snap_query(void *p)
{
HI_S32 s32VencStartRecv[VENC_MAX_CHN_NUM] = {0};
int s32ChnTotal = 0;
HI_S32 s32Ret, i;
static HI_S32 MdOnFlag = 0;
SNAP_GETSTAT_S *pstPara;
VENC_RECV_PIC_PARAM_S pstRecvParam;
pstPara = (SNAP_GETSTAT_S*)p;
s32ChnTotal = pstPara->s32Cnt;
if (s32ChnTotal > VENC_MAX_CHN_NUM)
{
Printf("input count invaild\n");
return NULL;
}
/* Start to get mdStat of each channel.*/
while(HI_TRUE == pstPara->bThreadMd)
{
for (i = 0; i < s32ChnTotal; i++)
{
/*motion on with chn*/
// if((getActionAlarmStatus(i) == 1))
{
if(gs_s32Snap[i] == 0)
{
/*Create venc chn*/
venc_snap_start(i);
/*start get stream thread*/
if(!gs_s32GetStream)
{
get_stream_pthread(s32ChnTotal);
gs_s32GetStream = 1;
Printf("get stream thread running!\n");
}
gs_s32Snap[i] = 1;
MdOnFlag++;
}
/*stop recv pic with chn, don't care whether the last complete receiving all pictures*/
if(1 == s32VencStartRecv[i])
{
s32Ret = HI_MPI_VENC_StopRecvPic(i);
if (HI_SUCCESS != s32Ret)
{
Printf("HI_MPI_VENC_StopRecvPic faild with%#x!\n", s32Ret);
return NULL;
}
//Printf("stop recv pic with chn = %d!\n", i);
s32VencStartRecv[i] = 0;
}
/*motion status*/
// if((VideoMDGetStatus(i) != 1))
// {
// // // continue;
// }
/*start a new recv pic with chn .*/
if(pstPara->bSnapEn[i] == HI_TRUE && s32VencStartRecv[i] == 0)
{
//Printf("MD !!! start recv pic with chn = %d!\n", i);
pstRecvParam.s32RecvPicNum = 3;
s32Ret = HI_MPI_VENC_StartRecvPicEx(i,&pstRecvParam);
if (HI_SUCCESS != s32Ret)
{
Printf("HI_MPI_VENC_StartRecvPicEx faild with %#x!\n", s32Ret);
return NULL;
}
s32VencStartRecv[i] = 1;
}
}
/*motion off with chn ,stop venc*/
// if((getActionAlarmStatus(i) == 0))
{
if(gs_s32Snap[i] == 1)
{
venc_snap_stop(i);
gs_s32Snap[i] = 0;
MdOnFlag--;
}
/*wait all motion off exit get stream thread*/
if(MdOnFlag == 0)
{
if (HI_TRUE == gs_stParaSnap.bThreadStart && gs_s32GetStream == 1)
{
gs_stParaSnap.bThreadStart = HI_FALSE;
pthread_join(SnapTh, 0);
gs_s32GetStream = 0;
Printf("get stream thread exit!\n");
}
}
}
}
usleep(200*1000);/*wait until all pictures have been encoded*/
}
return NULL;
}
/*****************************************************************************
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;
}
