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