LiveVideoStreamSource::LiveVideoStreamSource(UsageEnvironment& env, StreamChannel chn)
: FramedSource(env), fChannelNo(chn), fReferenceCount(1)
{
TaskScheduler &scheduler = envir().taskScheduler();
ClearVideoStreamBuffer(fChannelNo);
HI_MPI_VENC_RequestIDRInst(fChannelNo);
vencFd = HI_MPI_VENC_GetFd(fChannelNo);
}
static HI_VOID* SampleGetH264StreamAndSend(HI_VOID *p)
{
HI_S32 s32Ret;
HI_S32 s32VencFd;
VENC_CHN VeChn;
VENC_CHN_STAT_S stStat;
VENC_STREAM_S stStream;
fd_set read_fds;
FILE *pFile = NULL;
struct timeval TimeoutVal;
VeChn = (HI_S32)p;
pFile = fopen("stream.h264","wb");
if(pFile == NULL)
{
HI_ASSERT(0);
return NULL;
}
s32VencFd = HI_MPI_VENC_GetFd(VeChn);
while (HI_TRUE != g_bVencStopFlag)
{
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)
{
printf("select err\n");
return NULL;
}
else if (0 == s32Ret)
{
printf("time out\n");
return NULL;
}
else
{
if (FD_ISSET(s32VencFd, &read_fds))
{
s32Ret = HI_MPI_VENC_Query(VeChn, &stStat);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_Query:0x%x err\n",s32Ret);
fflush(stdout);
return NULL;
}
stStream.pstPack = (VENC_PACK_S*)malloc(sizeof(VENC_PACK_S)*stStat.u32CurPacks);
if (NULL == stStream.pstPack)
{
printf("malloc memory err!\n");
return NULL;
}
stStream.u32PackCount = stStat.u32CurPacks;
s32Ret = HI_MPI_VENC_GetStream(VeChn, &stStream, HI_IO_NOBLOCK);
if (HI_SUCCESS != s32Ret)
{
printf("HI_MPI_VENC_GetStream:0x%x\n",s32Ret);
free(stStream.pstPack);
stStream.pstPack = NULL;
return NULL;
}
/* if you need to save current stream, open this switch. */
#ifdef SAVE_STREAM_SWITCH
SampleSaveH264Stream(pFile, &stStream);
#endif
/* send stream to VDEC while encoding... */
if(HI_SUCCESS != SendStreamToVdec(VeChn, &stStream))
{
printf("SendStreamToVdec failed!\n");
return NULL;
}
s32Ret = HI_MPI_VENC_ReleaseStream(VeChn,&stStream);
if (s32Ret)
{
printf("HI_MPI_VENC_ReleaseStream:0x%x\n",s32Ret);
free(stStream.pstPack);
stStream.pstPack = NULL;
return NULL;
}
free(stStream.pstPack);
stStream.pstPack = NULL;
}
}
}
fclose(pFile);
return NULL;
}
/******************************************************************************
* funciton : get stream from each channels and save them
******************************************************************************/
HI_VOID* SAMPLE_COMM_VENC_GetVencStreamProc(HI_VOID *p)
{
HI_S32 i;
HI_S32 s32ChnTotal;
VENC_CHN_ATTR_S stVencChnAttr;
SAMPLE_VENC_GETSTREAM_PARA_S *pstPara;
HI_S32 maxfd = 0;
struct timeval TimeoutVal;
fd_set read_fds;
HI_S32 VencFd[VENC_MAX_CHN_NUM];
HI_CHAR aszFileName[VENC_MAX_CHN_NUM][64];
FILE *pFile[VENC_MAX_CHN_NUM];
char szFilePostfix[10];
VENC_CHN_STAT_S stStat;
VENC_STREAM_S stStream;
HI_S32 s32Ret;
VENC_CHN VencChn;
PAYLOAD_TYPE_E enPayLoadType[VENC_MAX_CHN_NUM];
pstPara = (SAMPLE_VENC_GETSTREAM_PARA_S*)p;
s32ChnTotal = pstPara->s32Cnt;
/******************************************
step 1: check & prepare save-file & venc-fd
******************************************/
if (s32ChnTotal >= VENC_MAX_CHN_NUM)
{
SAMPLE_PRT("input count invaild\n");
return NULL;
}
for (i = 0; i < s32ChnTotal; i++)
{
/* decide the stream file name, and open file to save stream */
VencChn = i;
s32Ret = HI_MPI_VENC_GetChnAttr(VencChn, &stVencChnAttr);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VENC_GetChnAttr chn[%d] failed with %#x!\n", \
VencChn, s32Ret);
return NULL;
}
enPayLoadType[i] = stVencChnAttr.stVeAttr.enType;
s32Ret = SAMPLE_COMM_VENC_GetFilePostfix(enPayLoadType[i], szFilePostfix);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("SAMPLE_COMM_VENC_GetFilePostfix [%d] failed with %#x!\n", \
stVencChnAttr.stVeAttr.enType, s32Ret);
return NULL;
}
sprintf(aszFileName[i], "stream_chn%d%s", i, szFilePostfix);
pFile[i] = fopen(aszFileName[i], "wb");
if (!pFile[i])
{
SAMPLE_PRT("open file[%s] failed!\n",
aszFileName[i]);
return NULL;
}
/* Set Venc Fd. */
VencFd[i] = HI_MPI_VENC_GetFd(i);
if (VencFd[i] < 0)
{
SAMPLE_PRT("HI_MPI_VENC_GetFd failed with %#x!\n",
VencFd[i]);
return NULL;
}
if (maxfd <= VencFd[i])
{
maxfd = VencFd[i];
}
}
/******************************************
step 2: Start to get streams of each channel.
******************************************/
while (HI_TRUE == pstPara->bThreadStart)
{
FD_ZERO(&read_fds);
for (i = 0; i < s32ChnTotal; i++)
{
FD_SET(VencFd[i], &read_fds);
}
TimeoutVal.tv_sec = 2;
TimeoutVal.tv_usec = 0;
s32Ret = select(maxfd + 1, &read_fds, NULL, NULL, &TimeoutVal);
if (s32Ret < 0)
{
SAMPLE_PRT("select failed!\n");
break;
}
else if (s32Ret == 0)
{
SAMPLE_PRT("get venc stream time out, exit thread\n");
continue;
}
else
{
for (i = 0; i < s32ChnTotal; i++)
{
if (FD_ISSET(VencFd[i], &read_fds))
{
/*******************************************************
step 2.1 : query how many packs in one-frame stream.
*******************************************************/
memset(&stStream, 0, sizeof(stStream));
s32Ret = HI_MPI_VENC_Query(i, &stStat);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_Query chn[%d] failed with %#x!\n", i, s32Ret);
break;
}
/*******************************************************
step 2.2 : malloc corresponding number of pack nodes.
*******************************************************/
stStream.pstPack = (VENC_PACK_S*)malloc(sizeof(VENC_PACK_S) * stStat.u32CurPacks);
if (NULL == stStream.pstPack)
{
SAMPLE_PRT("malloc stream pack failed!\n");
break;
}
/*******************************************************
step 2.3 : call mpi to get one-frame stream
*******************************************************/
stStream.u32PackCount = stStat.u32CurPacks;
s32Ret = HI_MPI_VENC_GetStream(i, &stStream, HI_TRUE);
if (HI_SUCCESS != s32Ret)
{
free(stStream.pstPack);
stStream.pstPack = NULL;
SAMPLE_PRT("HI_MPI_VENC_GetStream failed with %#x!\n", \
s32Ret);
break;
}
/*******************************************************
step 2.4 : save frame to file
*******************************************************/
s32Ret = SAMPLE_COMM_VENC_SaveStream(enPayLoadType[i], pFile[i], &stStream);
if (HI_SUCCESS != s32Ret)
{
free(stStream.pstPack);
stStream.pstPack = NULL;
SAMPLE_PRT("save stream failed!\n");
break;
}
/*******************************************************
step 2.5 : release stream
*******************************************************/
s32Ret = HI_MPI_VENC_ReleaseStream(i, &stStream);
if (HI_SUCCESS != s32Ret)
{
free(stStream.pstPack);
stStream.pstPack = NULL;
break;
}
/*******************************************************
step 2.6 : free pack nodes
*******************************************************/
free(stStream.pstPack);
stStream.pstPack = NULL;
}
}
}
}
/*******************************************************
* step 3 : close save-file
*******************************************************/
for (i = 0; i < s32ChnTotal; i++)
{
fclose(pFile[i]);
}
return NULL;
}
/******************************************************************************
* 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;
}
int HimppVideoEncoder::fileDescriptor()
{
return HI_MPI_VENC_GetFd(_venc_chan.channelId());
}
HI_VOID * SampleGet1D1Mjpeg1CifH264Stream(HI_VOID *p)
{
HI_S32 i;
HI_S32 maxfd = 0;
HI_S32 s32ret;
HI_S32 VencFd[2] = {0};
HI_U32 u32FrameIdx = 0;
VENC_CHN_STAT_S stStat;
VENC_STREAM_S stStream;
HI_CHAR *pszStreamFile[] = {"CIFH264stream.h264","D1MJPEGstream.mjp"};
struct timeval TimeoutVal;
fd_set read_fds;
FILE *pFd[2] = {0};
for (i=0;i<2;i++)
{
VencFd[i] = HI_MPI_VENC_GetFd(i);
if (VencFd[i] <= 0)
{
printf("HI_MPI_VENC_GetFd err 0x%x\n",s32ret);
return NULL;
}
/*open file to save stream */
pFd[i] = fopen(pszStreamFile[i], "wb");
if (!pFd[i])
{
printf("open file err!\n");
return NULL;
}
if(maxfd <= VencFd[i])
{
maxfd = VencFd[i];
}
}
do{
FD_ZERO(&read_fds);
for (i=0; i<2;i++)
{
FD_SET(VencFd[i],&read_fds);
}
TimeoutVal.tv_sec = 2;
TimeoutVal.tv_usec = 0;
s32ret = select(maxfd + 1,&read_fds,NULL,NULL,&TimeoutVal);
if(s32ret < 0)
{
printf("select err\n");
return NULL;
}
else if(s32ret == 0)
{
printf("time out\n");
return NULL;
}
else
{
for (i=0; i<2;i++)
{
if(FD_ISSET(VencFd[i],&read_fds))
{
memset(&stStream,0,sizeof(stStream));
s32ret = HI_MPI_VENC_Query(i, &stStat);
if (s32ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_Query:0x%x\n",s32ret);
fflush(stdout);
return NULL;
}
stStream.pstPack = (VENC_PACK_S*)malloc(sizeof(VENC_PACK_S)*stStat.u32CurPacks);
if (NULL == stStream.pstPack)
{
printf("malloc stream pack faild!\n");
return NULL;
}
stStream.u32PackCount = stStat.u32CurPacks;
s32ret = HI_MPI_VENC_GetStream(i, &stStream, HI_IO_NOBLOCK);
if (s32ret != HI_SUCCESS)
{
free(stStream.pstPack);
stStream.pstPack = NULL;
printf("HI_MPI_VENC_GetStream err 0x%x\n",s32ret);
return NULL;
}
if(0 == i)
{
SampleSaveH264Stream(pFd[i], &stStream);
}
else if(1 == i)
{
SampleSaveJpegStream(pFd[i],&stStream);
}
s32ret = HI_MPI_VENC_ReleaseStream(i,&stStream);
if (s32ret)
{
free(stStream.pstPack);
stStream.pstPack = NULL;
printf("HI_MPI_VENC_ReleaseStream err 0x%x\n",s32ret);
return NULL;
}
free(stStream.pstPack);
stStream.pstPack = NULL;
}
}
}
u32FrameIdx ++;
}while(u32FrameIdx <= 1000);
for (i=0;i<2;i++)
{
fclose(pFd[i]);
}
return HI_SUCCESS;
}
/*获取单路H264码流*/
HI_VOID* SampleGetH264Stream(HI_VOID *p)
{
HI_S32 s32Ret;
HI_S32 s32VencFd;
HI_U32 u32FrameIdx = 0;
VENC_CHN VeChn;
VENC_CHN_STAT_S stStat;
VENC_STREAM_S stStream;
fd_set read_fds;
FILE *pFile = NULL;
pFile = fopen("stream.h264","wb");
if(pFile == NULL)
{
HI_ASSERT(0);
return NULL;
}
VeChn = (HI_S32)p;
s32VencFd = HI_MPI_VENC_GetFd(VeChn);
do{
FD_ZERO(&read_fds);
FD_SET(s32VencFd,&read_fds);
s32Ret = select(s32VencFd+1, &read_fds, NULL, NULL, NULL);
if (s32Ret < 0)
{
printf("select err\n");
return NULL;
}
else if (0 == s32Ret)
{
printf("time out\n");
return NULL;
}
else
{
if (FD_ISSET(s32VencFd, &read_fds))
{
s32Ret = HI_MPI_VENC_Query(VeChn, &stStat);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_Query:0x%x err\n",s32Ret);
fflush(stdout);
return NULL;
}
stStream.pstPack = (VENC_PACK_S*)malloc(sizeof(VENC_PACK_S)*stStat.u32CurPacks);
if (NULL == stStream.pstPack)
{
printf("malloc memory err!\n");
return NULL;
}
stStream.u32PackCount = stStat.u32CurPacks;
s32Ret = HI_MPI_VENC_GetStream(VeChn, &stStream, HI_TRUE);
if (HI_SUCCESS != s32Ret)
{
printf("HI_MPI_VENC_GetStream:0x%x\n",s32Ret);
free(stStream.pstPack);
stStream.pstPack = NULL;
return NULL;
}
SampleSaveH264Stream(pFile, &stStream);
s32Ret = HI_MPI_VENC_ReleaseStream(VeChn,&stStream);
if (s32Ret)
{
printf("HI_MPI_VENC_ReleaseStream:0x%x\n",s32Ret);
free(stStream.pstPack);
stStream.pstPack = NULL;
return NULL;
}
free(stStream.pstPack);
stStream.pstPack = NULL;
}
}
u32FrameIdx ++;
}while (bVencStopFlag != HI_TRUE);
fclose(pFile);
return HI_SUCCESS;
}
HI_VOID * SampleGet4HD1Stream(HI_VOID *p)
{
HI_S32 i;
HI_S32 maxfd = 0;
HI_S32 s32ret;
HI_S32 VencFd[4] = {0};
HI_U32 u32FrameIdx = 0;
VENC_CHN_STAT_S stStat;
VENC_STREAM_S stStream;
HI_CHAR *pszStreamFile[] = {"HD1stream0.h264","HD1stream1.h264",
"HD1stream2.h264","HD1stream3.h264"};
struct timeval TimeoutVal;
fd_set read_fds;
FILE *pFd[4] = {0};
for (i=0;i<4;i++)
{
VencFd[i] = HI_MPI_VENC_GetFd(i);
if (VencFd[i] <= 0)
{
printf("HI_MPI_VENC_GetFd err 0x%x\n",s32ret);
return NULL;
}
/*open file to save stream */
pFd[i] = fopen(pszStreamFile[i], "wb");
if (!pFd[i])
{
printf("open file err!\n");
return NULL;
}
if(maxfd <= VencFd[i]) maxfd = VencFd[i] ;
}
do{
FD_ZERO(&read_fds);
for (i=0; i<4;i++)
{
FD_SET(VencFd[i],&read_fds);
}
TimeoutVal.tv_sec = 2;
TimeoutVal.tv_usec = 0;
s32ret = select(maxfd + 1,&read_fds,NULL,NULL,&TimeoutVal);
if(s32ret < 0)
{
printf("select err\n");
return NULL;
}
else if(s32ret == 0)
{
printf("time out\n");
continue;
}
else
{
for (i=0; i<4;i++)
{
if(FD_ISSET(VencFd[i],&read_fds))
{
memset(&stStream,0,sizeof(stStream));
s32ret = HI_MPI_VENC_Query(i, &stStat);
if (s32ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_Query:0x%x\n",s32ret);
return NULL;
}
stStream.pstPack = (VENC_PACK_S*)malloc(sizeof(VENC_PACK_S)*stStat.u32CurPacks);
if (NULL == stStream.pstPack)
{
printf("malloc stream pack err!\n");
return NULL;
}
stStream.u32PackCount = stStat.u32CurPacks;
s32ret = HI_MPI_VENC_GetStream(i, &stStream, HI_TRUE);
if (s32ret != HI_SUCCESS)
{
free(stStream.pstPack);
stStream.pstPack = NULL;
printf("HI_MPI_VENC_GetStream err 0x%x\n",s32ret);
return NULL;
}
SampleSaveH264Stream(pFd[i], &stStream);
s32ret = HI_MPI_VENC_ReleaseStream(i,&stStream);
if (s32ret != HI_SUCCESS)
{
free(stStream.pstPack);
stStream.pstPack = NULL;
printf("HI_MPI_VENC_ReleaseStream err 0x%x\n",s32ret);
return NULL;
}
free(stStream.pstPack);
stStream.pstPack = NULL;
}
}
}
u32FrameIdx ++;
}while(u32FrameIdx <= 0xfff);
for (i=0;i<4;i++)
{
fclose(pFd[i]);
}
return HI_SUCCESS;
}
HI_S32 SampleSaveSnapPic(VENC_CHN SnapChn,FILE *pFile)
{
HI_S32 s32Ret;
HI_S32 s32VencFd;
VENC_CHN_STAT_S stStat;
VENC_STREAM_S stStream;
fd_set read_fds;
s32VencFd = HI_MPI_VENC_GetFd(SnapChn);
if(s32VencFd < 0)
{
printf("HI_MPI_VENC_GetFd err \n");
return HI_FAILURE;
}
FD_ZERO(&read_fds);
FD_SET(s32VencFd,&read_fds);
s32Ret = select(s32VencFd+1, &read_fds, NULL, NULL, NULL);
if (s32Ret < 0)
{
printf("select err\n");
return HI_FAILURE;
}
else if (0 == s32Ret)
{
printf("time out\n");
return HI_FAILURE;
}
else
{
if (FD_ISSET(s32VencFd, &read_fds))
{
s32Ret = HI_MPI_VENC_Query(SnapChn, &stStat);
if (s32Ret != HI_SUCCESS)
{
printf("HI_MPI_VENC_Query:0x%x\n",s32Ret);
fflush(stdout);
return HI_FAILURE;
}
stStream.pstPack = (VENC_PACK_S*)malloc(sizeof(VENC_PACK_S)*stStat.u32CurPacks);
if (NULL == stStream.pstPack)
{
printf("malloc memory err!\n");
return HI_FAILURE;
}
stStream.u32PackCount = stStat.u32CurPacks;
s32Ret = HI_MPI_VENC_GetStream(SnapChn, &stStream, HI_TRUE);
if (HI_SUCCESS != s32Ret)
{
printf("HI_MPI_VENC_GetStream:0x%x\n",s32Ret);
fflush(stdout);
free(stStream.pstPack);
stStream.pstPack = NULL;
return HI_FAILURE;
}
s32Ret = SampleSaveJpegStream(pFile, &stStream);
if (HI_SUCCESS != s32Ret)
{
printf("HI_MPI_VENC_GetStream:0x%x\n",s32Ret);
fflush(stdout);
free(stStream.pstPack);
stStream.pstPack = NULL;
return HI_FAILURE;
}
s32Ret = HI_MPI_VENC_ReleaseStream(SnapChn,&stStream);
if (s32Ret)
{
printf("HI_MPI_VENC_ReleaseStream:0x%x\n",s32Ret);
free(stStream.pstPack);
stStream.pstPack = NULL;
return HI_FAILURE;
}
free(stStream.pstPack);
stStream.pstPack = NULL;
}
}
return HI_SUCCESS;
}
void SendVideoStream(int Sockfd)
{
HI_S32 s32Ret;
HI_S32 Vencfd, maxfd = 0;
PAYLOAD_TYPE_E enPayLoad = PT_H264;
SAMPLE_RC_E enRcMode = SAMPLE_RC_CBR;
struct timeval TimeoutVal;
fd_set read_fds;
int connfd;
VENC_STREAM_S stStream;
VENC_CHN_STAT_S stStat;
HI_S32 i;
int SendSockfd;
struct sockaddr_in SendServaddr;
SendSockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (SendSockfd == -1)
{
perror("send socket error");
exit(0);
}
memset(&SendServaddr, 0, sizeof(SendServaddr));
SendServaddr.sin_family = AF_INET;
SendServaddr.sin_addr.s_addr = inet_addr("10.1.2.60");
SendServaddr.sin_port = htons(6666);
while (!isThreadStop)
{
#if 0
if (!isChangePic)
{
connfd = accept(SendSockfd, NULL, NULL);
printf("connect!\n");
}
isChangePic = HI_FALSE;
#endif
s32Ret = SAMPLE_COMM_VENC_Start(SendVencGrp, SendVencChn, enPayLoad,
gs_enNorm, enSize, enRcMode);
if (HI_SUCCESS != s32Ret)
{
printf("SAMPLE_COMM_VENC_Start failed with err code %#x\n", s32Ret);
continue;
}
s32Ret = SAMPLE_COMM_VENC_BindVpss(SendVencGrp, VpssGrp, VpssChn);
if (HI_SUCCESS != s32Ret)
{
printf("SAMPLE_COMM_VENC_BindVpss failed with err code %#x\n", s32Ret);
continue;
}
Vencfd = HI_MPI_VENC_GetFd(SendVencChn);
if (Vencfd < 0)
{
printf("HI_MPI_VENC_GetFd faild with%#x!\n", Vencfd);
return HI_FAILURE;
}
while (isSend)
{
FD_ZERO(&read_fds);
FD_SET(Vencfd, &read_fds);
TimeoutVal.tv_sec = 20000;
TimeoutVal.tv_usec = 0;
s32Ret = select(Vencfd + 1, &read_fds, NULL, NULL, &TimeoutVal);
if (s32Ret < 0)
{
perror("select failed!\n");
break;
}
else if (s32Ret == 0)
{
printf("get sendvenc stream time out,exit thread\n");
continue;
}
else
{
if (FD_ISSET(Vencfd, &read_fds))
{
memset(&stStream, 0, sizeof(stStream));
s32Ret = HI_MPI_VENC_Query(SendVencChn, &stStat);
if (HI_SUCCESS != s32Ret)
{
printf("HI_MPI_VENC_Query failed with err code %#x!\n", s32Ret);
break;
}
stStream.pstPack = (VENC_PACK_S*)malloc(sizeof(VENC_PACK_S) * stStat.u32CurPacks);
if (NULL == stStream.pstPack)
{
printf("malloc stream pack failed!\n");
break;
}
stStream.u32PackCount = stStat.u32CurPacks;
s32Ret = HI_MPI_VENC_GetStream(SendVencChn, &stStream, HI_TRUE);
if (HI_SUCCESS != s32Ret)
{
free(stStream.pstPack);
stStream.pstPack = NULL;
printf("HI_MPI_VENC_GetStream failed with %#x!\n", s32Ret);
break;
}
for (i = 0; i < stStream.u32PackCount; i++)
{
//write(connfd, stStream.pstPack[i].pu8Addr[0],
// stStream.pstPack[i].u32Len[0]);
sendto(SendSockfd,stStream.pstPack[i].pu8Addr[0],
stStream.pstPack[i].u32Len[0],0,
(struct sockaddr*)&SendServaddr,
sizeof(SendServaddr));
if (stStream.pstPack[i].u32Len[1] > 0)
{
//write(connfd, stStream.pstPack[i].pu8Addr[1],
// stStream.pstPack[i].u32Len[1]);
sendto(SendSockfd,stStream.pstPack[i].pu8Addr[1],
stStream.pstPack[i].u32Len[1],0,
(struct sockaddr*)&SendServaddr,
sizeof(SendServaddr));
}
}
s32Ret = HI_MPI_VENC_ReleaseStream(SendVencChn, &stStream);
if (HI_SUCCESS != s32Ret)
{
free(stStream.pstPack);
stStream.pstPack = NULL;
break;
}
free(stStream.pstPack);
stStream.pstPack = NULL;
}
}
}
SAMPLE_COMM_VENC_StopGetStream();
SAMPLE_COMM_VENC_UnBindVpss(SendVencGrp, VpssGrp, VpssChn);
SAMPLE_COMM_VENC_Stop(SendVencGrp, SendVencChn);
usleep(100);
}
}
void *venc_get_stream(void *p)
{
struct timeval TimeoutVal;
fd_set read_fds;
HI_S32 s32VencFd[VENC_MAX_CHN_NUM];
int s32ChnTotal = 0;
VENC_CHN_STAT_S stStat;
VENC_STREAM_S stStream;
// VENC_PACK_S *packet = NULL;
HI_S32 s32Ret,i;
VENC_CHN VencChn;
int maxfd = 0;
HI_CHAR snapPathFile[100] = "/tmp/";
VENC_GETSTREAM_PARA_S *pstPara;
pstPara = (VENC_GETSTREAM_PARA_S *)p;
s32ChnTotal = pstPara->s32Cnt;
if (s32ChnTotal > VENC_MAX_CHN_NUM)
{
Printf("input count invaild\n");
return NULL ;
}
/* get Venc Fd. */
for(i = 0; i < s32ChnTotal; i++)
{
s32VencFd[i] = HI_MPI_VENC_GetFd(i);
if (s32VencFd[i] < 0)
{
Printf("HI_MPI_VENC_GetFd failed with %#x!\n", s32VencFd[i]);
return NULL;
}
if (maxfd <= s32VencFd[i])
{
maxfd = s32VencFd[i];
}
}
/* Start to get streams of each channel.*/
while(HI_TRUE == pstPara->bThreadStart)
{
FD_ZERO(&read_fds);
for (i = 0; i < s32ChnTotal; i++)
{
FD_SET(s32VencFd[i], &read_fds);
}
/*select return success, all packages in the complete frame*/
TimeoutVal.tv_sec = 1;
TimeoutVal.tv_usec = 0;
s32Ret = select(maxfd+1, &read_fds, NULL, NULL, &TimeoutVal);
if (s32Ret < 0)
{
Printf("snap select failed!\n");
return NULL;
}
else if (0 == s32Ret)
{
continue;
}
else
{
for(i = 0; i < s32ChnTotal; i++)
{
VencChn = i;
if (FD_ISSET(s32VencFd[VencChn], &read_fds))
{
/*query how many packs in one-frame stream.*/
s32Ret = HI_MPI_VENC_Query(VencChn, &stStat);
if (s32Ret != HI_SUCCESS)
{
Printf("HI_MPI_VENC_Query chn[%d] failed with %#x!\n", VencChn, s32Ret);
return NULL;
}
/*malloc corresponding number of pack nodes*/
stStream.pstPack = (VENC_PACK_S*)malloc(sizeof(VENC_PACK_S) * stStat.u32CurPacks);
if (NULL == stStream.pstPack)
{
Printf("malloc memory failed!\n");
return NULL;
}
/* call mpi to get one-frame stream*/
stStream.u32PackCount = stStat.u32CurPacks;
s32Ret = HI_MPI_VENC_GetStream(VencChn, &stStream, HI_TRUE);
if (HI_SUCCESS != s32Ret)
{
Printf("HI_MPI_VENC_GetStream failed with %#x!\n", s32Ret);
free(stStream.pstPack);
stStream.pstPack = NULL;
return NULL;
}
/* save frame to file*/
s32Ret = venc_save_stream(VencChn, &stStream, snapPathFile);
if (HI_SUCCESS != s32Ret)
{
Printf("venc_save_stream failed with %#x!\n", s32Ret);
free(stStream.pstPack);
stStream.pstPack = NULL;
return NULL;
}
/* release stream*/
s32Ret = HI_MPI_VENC_ReleaseStream(VencChn, &stStream);
if (s32Ret)
{
Printf("HI_MPI_VENC_ReleaseStream failed with %#x!\n", s32Ret);
free(stStream.pstPack);
stStream.pstPack = NULL;
return NULL;
}
/*free pack nodes*/
free(stStream.pstPack);
stStream.pstPack = NULL;
}
}
}
}
return NULL;
}
