各个模块的功能：开启VI、VPSS、VENC，VI与VPSS绑定，VNEC不做任何绑定，但是会开启VENC接收。
流程：通过VI与VPSS绑定后，可以在VPSS中获取原始图像数据，原始图像数据memcpy出两个图像数据，一个备份数据，一个算法数据；算法数据经过一系列的操作，反馈结果满足条件，则备份数据通过HI_MPI_VENC_SendFrame函数，保存到本地图片；
现象：通过保存算法数据图像与本地图片进行比对，发现本地图片是算法数据图像的后面某一帧数据。
HI_S32 SAMPLE_VI_VPSS_VENC_OFFLINE()
{
HI_S32 i;
HI_S32 s32Ret = HI_SUCCESS;
/************************************************
获取一路通道的图像尺寸，检查是否过大
*************************************************/
PIC_SIZE_E enDispPicSize = PIC_4096x2160; //图片的尺寸类型
SIZE_S stDispSize; //图片的尺寸(分辨率A*B)
s32Ret = SAMPLE_COMM_SYS_GetPicSize(enDispPicSize, &stDispSize); //(stDispSize.u32Width)*(stDispSize.u32Height) 3840*2160
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("sys get pic size fail for %#x!\n", s32Ret);
return s32Ret;
}
/************************************************
设置SYS/VB
*************************************************/
VB_CONFIG_S stVbConfig; //VB结构体
memset(&stVbConfig, 0, sizeof(VB_CONFIG_S));
stVbConfig.u32MaxPoolCnt = 2;
stVbConfig.astCommPool[0].u32BlkCnt = 15;
stVbConfig.astCommPool[0].u64BlkSize = COMMON_GetPicBufferSize(
stDispSize.u32Width,
stDispSize.u32Height,
PIXEL_FORMAT_YVU_SEMIPLANAR_420,
DATA_BITWIDTH_10,
COMPRESS_MODE_NONE,
0
);
stVbConfig.astCommPool[1].u32BlkCnt = 4;
stVbConfig.astCommPool[1].u64BlkSize = VI_GetRawBufferSize(
stDispSize.u32Width,
stDispSize.u32Height,
PIXEL_FORMAT_RGB_BAYER_16BPP,
COMPRESS_MODE_NONE,
0
);
s32Ret = SAMPLE_COMM_SYS_Init(&stVbConfig);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("init sys fail for %#x!\n", s32Ret);
return s32Ret;
}
/************************************************
获取sensor信息
检查sensor
*************************************************/
SAMPLE_VI_CONFIG_S stViConfig;
SAMPLE_COMM_VI_GetSensorInfo(&stViConfig);
if(SAMPLE_SNS_TYPE_BUTT == stViConfig.astViInfo[0].stSnsInfo.enSnsType)
{
SAMPLE_PRT("Not set SENSOR%d_TYPE !\n",0);
//goto END1; //关SYS
}
s32Ret = SAMPLE_VENC_CheckSensor(stViConfig.astViInfo[0].stSnsInfo.enSnsType,stDispSize);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("Check Sensor err!\n");
// goto END1; //关SYS
return s32Ret;
}
/************************************************
VI初始化
*************************************************/
HI_U32 u32FrameRate;
ISP_CTRL_PARAM_S stIspCtrlParam;
VI_DEV ViDev = 0;
VI_PIPE ViPipe = 0;
VI_CHN ViChn = 0;
stViConfig.s32WorkingViNum = 1;
stViConfig.as32WorkingViId[0] = 0;
stViConfig.astViInfo[0].stSnsInfo.MipiDev = SAMPLE_COMM_VI_GetComboDevBySensor(stViConfig.astViInfo[0].stSnsInfo.enSnsType, 0);
stViConfig.astViInfo[0].stSnsInfo.s32BusId = 0;
stViConfig.astViInfo[0].stDevInfo.ViDev = ViDev;
stViConfig.astViInfo[0].stDevInfo.enWDRMode = WDR_MODE_NONE;
stViConfig.astViInfo[0].stPipeInfo.enMastPipeMode = VI_OFFLINE_VPSS_OFFLINE;//VI_ONLINE_VPSS_OFFLINE
stViConfig.astViInfo[0].stPipeInfo.aPipe[0] = ViPipe;
stViConfig.astViInfo[0].stPipeInfo.aPipe[1] = -1;
stViConfig.astViInfo[0].stPipeInfo.aPipe[2] = -1;
stViConfig.astViInfo[0].stPipeInfo.aPipe[3] = -1;
stViConfig.astViInfo[0].stChnInfo.ViChn = ViChn;
stViConfig.astViInfo[0].stChnInfo.enDynamicRange = DYNAMIC_RANGE_SDR8;
stViConfig.astViInfo[0].stChnInfo.enPixFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
stViConfig.astViInfo[0].stChnInfo.enVideoFormat = VIDEO_FORMAT_LINEAR;
stViConfig.astViInfo[0].stChnInfo.enCompressMode = COMPRESS_MODE_SEG;
SAMPLE_COMM_VI_GetFrameRateBySensor(stViConfig.astViInfo[0].stSnsInfo.enSnsType, &u32FrameRate);
s32Ret = HI_MPI_ISP_GetCtrlParam(stViConfig.astViInfo[0].stPipeInfo.aPipe[0], &stIspCtrlParam);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_ISP_GetCtrlParam failed with %d\n",s32Ret);
//goto END1; //关SYS
return s32Ret;
}
stIspCtrlParam.u32StatIntvl = u32FrameRate/30;
s32Ret = HI_MPI_ISP_SetCtrlParam(stViConfig.astViInfo[0].stPipeInfo.aPipe[0], &stIspCtrlParam);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_ISP_SetCtrlParam failed with %d\n",s32Ret);
//goto END1; //关SYS
return s32Ret;
}
///开启VI
s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("SAMPLE_COMM_VI_StartVi failed with %d\n",s32Ret);
//goto END1; //关SYS
return s32Ret;
}
/************************************************
设置VPSS
*************************************************/
VPSS_GRP VpssGrp = 0; //VPSS 1个GROUP GROUP号 0
VPSS_CHN VpssChn = 0;
VPSS_CHN VpssChn1 = 1;
VPSS_CHN VpssChn2 = 2;
VPSS_CHN_ATTR_S stVpssChnAttr[VPSS_MAX_CHN_NUM]; //VPSS通道属性
VPSS_GRP_ATTR_S stVpssGrpAttr; //VPSS Group属性
HI_BOOL abChnEnable[VPSS_MAX_CHN_NUM]; //VPSS通道使能 {1,1,1,0}
///初始化VPSS
stVpssGrpAttr.u32MaxW = stDispSize.u32Width;
stVpssGrpAttr.u32MaxH = stDispSize.u32Height;
stVpssGrpAttr.stFrameRate.s32SrcFrameRate = -1;
stVpssGrpAttr.stFrameRate.s32DstFrameRate = -1;
stVpssGrpAttr.enDynamicRange = DYNAMIC_RANGE_SDR8;
stVpssGrpAttr.enPixelFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
stVpssGrpAttr.bNrEn = HI_FALSE;
memset(abChnEnable, 0, sizeof(abChnEnable));
abChnEnable[0] = HI_TRUE;
stVpssChnAttr[0].u32Width = stDispSize.u32Width;
stVpssChnAttr[0].u32Height = stDispSize.u32Height;
stVpssChnAttr[0].enChnMode = VPSS_CHN_MODE_USER; //modified by zl
stVpssChnAttr[0].enCompressMode = COMPRESS_MODE_NONE; ///COMPRESS_MODE_SEG;
stVpssChnAttr[0].enDynamicRange = DYNAMIC_RANGE_SDR8;
stVpssChnAttr[0].enPixelFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
stVpssChnAttr[0].stFrameRate.s32SrcFrameRate = -1;
stVpssChnAttr[0].stFrameRate.s32DstFrameRate = -1;
stVpssChnAttr[0].u32Depth = 4; //modified by zl
stVpssChnAttr[0].bMirror = HI_FALSE;
stVpssChnAttr[0].bFlip = HI_FALSE;
stVpssChnAttr[0].stAspectRatio.enMode = ASPECT_RATIO_NONE;
stVpssChnAttr[0].enVideoFormat = VIDEO_FORMAT_LINEAR;
abChnEnable[1] = HI_TRUE;
stVpssChnAttr[1].u32Width = stDispSize.u32Width;
stVpssChnAttr[1].u32Height = stDispSize.u32Height;
stVpssChnAttr[1].enChnMode = VPSS_CHN_MODE_USER; //modified by zl
stVpssChnAttr[1].enCompressMode = COMPRESS_MODE_NONE; ///COMPRESS_MODE_SEG;
stVpssChnAttr[1].enDynamicRange = DYNAMIC_RANGE_SDR8;
stVpssChnAttr[1].enPixelFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
stVpssChnAttr[1].stFrameRate.s32SrcFrameRate = -1;
stVpssChnAttr[1].stFrameRate.s32DstFrameRate = -1;
stVpssChnAttr[1].u32Depth = 4; //modified by zl
stVpssChnAttr[1].bMirror = HI_FALSE;
stVpssChnAttr[1].bFlip = HI_FALSE;
stVpssChnAttr[1].stAspectRatio.enMode = ASPECT_RATIO_NONE;
stVpssChnAttr[1].enVideoFormat = VIDEO_FORMAT_LINEAR;
abChnEnable[2] = HI_TRUE;
stVpssChnAttr[2].u32Width = stDispSize.u32Width;
stVpssChnAttr[2].u32Height = stDispSize.u32Height;
stVpssChnAttr[2].enChnMode = VPSS_CHN_MODE_USER; //modified by zl
stVpssChnAttr[2].enCompressMode = COMPRESS_MODE_NONE; ///COMPRESS_MODE_SEG;
stVpssChnAttr[2].enDynamicRange = DYNAMIC_RANGE_SDR8;
stVpssChnAttr[2].enPixelFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
stVpssChnAttr[2].stFrameRate.s32SrcFrameRate = -1;
stVpssChnAttr[2].stFrameRate.s32DstFrameRate = -1;
stVpssChnAttr[2].u32Depth = 4; //modified by zl
stVpssChnAttr[2].bMirror = HI_FALSE;
stVpssChnAttr[2].bFlip = HI_FALSE;
stVpssChnAttr[2].stAspectRatio.enMode = ASPECT_RATIO_NONE;
stVpssChnAttr[2].enVideoFormat = VIDEO_FORMAT_LINEAR;
///开启VPSS 3个通道
s32Ret = SAMPLE_COMM_VPSS_Start(VpssGrp, abChnEnable, &stVpssGrpAttr, stVpssChnAttr);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("start VPSS fail for %#x!\n", s32Ret);
// goto END2; //关VI
return s32Ret;
}
/******************************************
VPSS绑定VI VI在线模式不需要绑定VPSS
******************************************/
s32Ret = SAMPLE_COMM_VI_Bind_VPSS(ViPipe, ViChn, VpssGrp);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("VI Bind VPSS err for %#x!\n", s32Ret);
// goto END5; //关VENC
return s32Ret;
}
/************************************************
设置VENC
*************************************************/
SAMPLE_RC_E enRcMode = SAMPLE_RC_CBR;
VENC_GOP_MODE_E enGopMode = VENC_GOPMODE_NORMALP;
VENC_CHN VencChn[3] = {0,1,2};
PAYLOAD_TYPE_E enPayLoad[3] = {PT_H264,PT_JPEG,PT_JPEG};
PIC_SIZE_E enSize[3] = {PIC_1080P,PIC_1080P,PIC_4096x2160};
HI_U32 u32Profile[3] = {1,0,0};
//初始化VENC
VENC_GOP_ATTR_S stGopAttr;
s32Ret = SAMPLE_COMM_VENC_GetGopAttr(enGopMode,&stGopAttr);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("Venc Get GopAttr for %#x!\n", s32Ret);
// goto END4; //关VO
return s32Ret;
}
//开启VENC 通道0 ENCODE H264 PIC_1080P
s32Ret = SAMPLE_COMM_VENC_Start(VencChn[0], enPayLoad[0], enSize[0], enRcMode,u32Profile[0],&stGopAttr);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("H264 Venc Start failed for %#x!\n", s32Ret);
// goto END4; //关VO
return s32Ret;
}
//开启VENC 通道1 ENCODE JPEG PIC_1080P
s32Ret = SAMPLE_COMM_VENC_Start(VencChn[1], enPayLoad[1], enSize[1], enRcMode,u32Profile[1],&stGopAttr);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("JPEG Venc Start failed for %#x!\n", s32Ret);
// goto END4; //关VO
return s32Ret;
}
//开启VENC 通道2 ENCODE JPEG 4096*2160
s32Ret = SAMPLE_COMM_VENC_Start(VencChn[2], enPayLoad[2], enSize[2], enRcMode,u32Profile[2],&stGopAttr);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("JPEG Venc Start failed for %#x!\n", s32Ret);
// goto END4; //关VO
return s32Ret;
}
/******************************************
VENC绑定VPSS
******************************************/
// s32Ret = SAMPLE_COMM_VPSS_Bind_VENC(VpssGrp, VpssChn,VencChn[0]);
// if (s32Ret != HI_SUCCESS)
// {
// SAMPLE_PRT("H264 Venc bind Vpss failed for %#x!\n", s32Ret);
// // goto END6; //VPSS_UnBind_VI
// return s32Ret;
// }
// s32Ret = SAMPLE_COMM_VPSS_Bind_VENC(VpssGrp, VpssChn1,VencChn[1]);
// if (s32Ret != HI_SUCCESS)
// {
// SAMPLE_PRT("JPEG Venc bind Vpss failed for %#x!\n", s32Ret);
// // goto END6; //VPSS_UnBind_VI
// return s32Ret;
// }
// s32Ret = SAMPLE_COMM_VPSS_Bind_VENC(VpssGrp, VpssChn2, VencChn[2]);
// if (s32Ret != HI_SUCCESS)
// {
// SAMPLE_PRT("JPEG Venc bind Vpss failed for %#x!\n", s32Ret);
// // goto END6; //VPSS_UnBind_VI
// return s32Ret;
// }
s32Ret = SAMPLE_COMM_VENC_StartGetStream(VencChn, 3);
if (s32Ret != HI_SUCCESS)
{
printf("0-SAMPLE_COMM_VENC_StartGetStream fail:0x%x\n",s32Ret);
return HI_FAILURE;
}
SAMPLE_PRT("exit \n");
}
HI_S32 SAMPLE_COMM_VENC_StartGetStream(VENC_CHN VeChn[],HI_S32 s32Cnt)
{
HI_U32 i;
gs_stPara.bThreadStart = HI_TRUE;
gs_stPara.s32Cnt = s32Cnt;
for(i=0; i<s32Cnt; i++)
{
gs_stPara.VeChn[i] = VeChn[i];
}
return pthread_create(&gs_VencPid, 0, SAMPLE_COMM_VENC_GetVencStreamProc, (HI_VOID*)&gs_stPara);
}
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_U32 u32PictureCnt[VENC_MAX_CHN_NUM]={0};
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_STATUS_S stStat;
VENC_STREAM_S stStream;
HI_S32 s32Ret;
VENC_CHN VencChn;
PAYLOAD_TYPE_E enPayLoadType[VENC_MAX_CHN_NUM];
VENC_STREAM_BUF_INFO_S stStreamBufInfo[VENC_MAX_CHN_NUM];
struct timeval t_start, t_end;
struct timeval t_start_h264, t_end_h264;
gettimeofday(&t_start_h264, NULL);
prctl(PR_SET_NAME, "GetVencStream", 0,0,0);
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 = pstPara->VeChn[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.stVencAttr.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.stVencAttr.enType, s32Ret);
return NULL;
}
if(PT_JPEG != enPayLoadType[i])
{
// snprintf(aszFileName[i],32, "pic/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];
}
s32Ret = HI_MPI_VENC_GetStreamBufInfo (i, &stStreamBufInfo[i]);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_GetStreamBufInfo failed with %#x!\n", s32Ret);
return (void *)HI_FAILURE;
}
}
int while_count=0;
/******************************************
step 2: Start to get streams of each channel.
******************************************/
while (HI_TRUE == pstPara->bThreadStart)
{
//while_count++;
//SAMPLE_PRT("%d\n",while_count);
FD_ZERO(&read_fds);
for (i = 0; i < s32ChnTotal; i++)
{
FD_SET(VencFd[i], &read_fds);
}
TimeoutVal.tv_sec = 2;
TimeoutVal.tv_usec = 0;
//SAMPLE_PRT("a\n");
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
{
//SAMPLE_PRT("b\n");
for (i = 0; i < s32ChnTotal; i++)
{
if (FD_ISSET(VencFd[i], &read_fds))
{
//SAMPLE_PRT("c\n");
/*******************************************************
step 2.1 : query how many packs in one-frame stream.
*******************************************************/
memset(&stStream, 0, sizeof(stStream));
s32Ret = HI_MPI_VENC_QueryStatus(i, &stStat);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_QueryStatus chn[%d] failed with %#x!\n", i, s32Ret);
break;
}
//SAMPLE_PRT("d\n");
/*******************************************************
step 2.2 :suggest to check both u32CurPacks and u32LeftStreamFrames at the same time,for example:
if(0 == stStat.u32CurPacks || 0 == stStat.u32LeftStreamFrames)
{
SAMPLE_PRT("NOTE: Current frame is NULL!\n");
continue;
}
*******************************************************/
if(0 == stStat.u32CurPacks)
{
SAMPLE_PRT("NOTE: Current frame is NULL!\n");
continue;
}
/*******************************************************
step 2.3 : 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;
}
//SAMPLE_PRT("e\n");
/*******************************************************
step 2.4 : call mpi to get one-frame stream
*******************************************************/
stStream.u32PackCount = stStat.u32CurPacks;
s32Ret = HI_MPI_VENC_GetStream(i, &stStream, -1); //HI_TRUE
if (HI_SUCCESS != s32Ret)
{
free(stStream.pstPack);
stStream.pstPack = NULL;
SAMPLE_PRT("HI_MPI_VENC_GetStream failed with %#x!\n", \
s32Ret);
break;
}
//SAMPLE_PRT("f\n");
/*******************************************************
step 2.5 : save frame to file
*******************************************************/
if(PT_JPEG == enPayLoadType[i] && i==2)
{
SAMPLE_PRT("snap data test!\n");
gettimeofday(&t_start, NULL);
SAMPLE_PRT("picname = %s\n",g_save_path);
pFile[i] = fopen(g_save_path, "wb+");
if (!pFile[i])
{
SAMPLE_PRT("open file err! \n");
}
s32Ret = SAMPLE_COMM_VENC_SaveStream(pFile[i], &stStream);
if (HI_SUCCESS != s32Ret)
{
// free(pstStream->pstPack);
// pstStream->pstPack = NULL;
SAMPLE_PRT("save stream failed! %#x \n",s32Ret);
}
gettimeofday(&t_end, NULL);
SAMPLE_PRT("save stream file time = %ld us \n",t_end.tv_usec-t_start.tv_usec);
//g_snap_picture_flag = 0;
fclose(pFile[i]);
pFile[i]=NULL;
}
// #ifndef __HuaweiLite__
// s32Ret = SAMPLE_COMM_VENC_SaveStream(pFile[i], &stStream);
// #else
// s32Ret = SAMPLE_COMM_VENC_SaveStream_PhyAddr(pFile[i], &stStreamBufInfo[i], &stStream);
// //SAMPLE_PRT("write data!\n");
// #endif
// if (HI_SUCCESS != s32Ret)
// {
// free(stStream.pstPack);
// stStream.pstPack = NULL;
// SAMPLE_PRT("save stream failed!\n");
// break;
// }
/*******************************************************
step 2.6 : release stream
*******************************************************/
s32Ret = HI_MPI_VENC_ReleaseStream(i, &stStream);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_ReleaseStream failed!\n");
free(stStream.pstPack);
stStream.pstPack = NULL;
break;
}
//SAMPLE_PRT("g\n");
/*******************************************************
step 2.7 : free pack nodes
*******************************************************/
free(stStream.pstPack);
stStream.pstPack = NULL;
u32PictureCnt[i]++;
// if(PT_JPEG == enPayLoadType[i])
// {
// fclose(pFile[i]);
// }
//SAMPLE_PRT("h\n");
}
}
}
}
/*******************************************************
* step 3 : close save-file
*******************************************************/
for (i = 0; i < s32ChnTotal; i++)
{
// if(PT_JPEG != enPayLoadType[i])
// {
// fclose(pFile[i]);
// }
}
SAMPLE_PRT("Exit Process!\n");
return NULL;
}
