HI_S32 SAMPLE_COMM_VO_StopChn(VO_LAYER VoLayer, SAMPLE_VO_MODE_E enMode)
{
HI_S32 i;
HI_S32 s32Ret = HI_SUCCESS;
HI_U32 u32WndNum = 0;
switch (enMode)
{
case VO_MODE_1MUX:
{
u32WndNum = 1;
break;
}
case VO_MODE_2MUX:
{
u32WndNum = 2;
break;
}
default:
SAMPLE_PRT("failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
for (i=0; i<u32WndNum; i++)
{
s32Ret = HI_MPI_VO_DisableChn(VoLayer, i);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
}
return s32Ret;
}
HI_S32 SAMPLE_COMM_VO_StartLayer(VO_LAYER VoLayer,const VO_VIDEO_LAYER_ATTR_S *pstLayerAttr, HI_BOOL bVgsBypass)
{
HI_S32 s32Ret = HI_SUCCESS;
if (!bVgsBypass)
{
s32Ret = HI_MPI_VO_SetDispBufLen(VoLayer, 3);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
}
s32Ret = HI_MPI_VO_SetVideoLayerAttr(VoLayer, pstLayerAttr);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VO_EnableVideoLayer(VoLayer);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
return s32Ret;
}
HI_S32 SAMPLE_COMM_VPSS_StopGroup(VPSS_GRP VpssGrp)
{
HI_S32 s32Ret;
if (VpssGrp < 0 || VpssGrp > VPSS_MAX_GRP_NUM)
{
printf("VpssGrp%d is out of rang[0,%d]. \n", VpssGrp, VPSS_MAX_GRP_NUM);
return HI_FAILURE;
}
s32Ret = HI_MPI_VPSS_StopGrp(VpssGrp);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("%s failed with %#x\n", __FUNCTION__, s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VPSS_DestroyGrp(VpssGrp);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("%s failed with %#x\n", __FUNCTION__, s32Ret);
return HI_FAILURE;
}
return HI_SUCCESS;
}
/******************************************************************************
* function : calculate VB Block size of picture.
******************************************************************************/
HI_U32 SAMPLE_COMM_SYS_CalcPicVbBlkSize(VIDEO_NORM_E enNorm, PIC_SIZE_E enPicSize, PIXEL_FORMAT_E enPixFmt, HI_U32 u32AlignWidth)
{
HI_S32 s32Ret = HI_FAILURE;
SIZE_S stSize;
s32Ret = SAMPLE_COMM_SYS_GetPicSize(enNorm, enPicSize, &stSize);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("get picture size[%d] failed!\n", enPicSize);
return HI_FAILURE;
}
if (PIXEL_FORMAT_YUV_SEMIPLANAR_422 != enPixFmt && PIXEL_FORMAT_YUV_SEMIPLANAR_420 != enPixFmt)
{
SAMPLE_PRT("pixel format[%d] input failed!\n", enPixFmt);
return HI_FAILURE;
}
if (16!=u32AlignWidth && 32!=u32AlignWidth && 64!=u32AlignWidth)
{
SAMPLE_PRT("system align width[%d] input failed!\n",\
u32AlignWidth);
return HI_FAILURE;
}
//SAMPLE_PRT("w:%d, u32AlignWidth:%d\n", CEILING_2_POWER(stSize.u32Width,u32AlignWidth), u32AlignWidth);
return (CEILING_2_POWER(stSize.u32Width, u32AlignWidth) * \
CEILING_2_POWER(stSize.u32Height,u32AlignWidth) * \
((PIXEL_FORMAT_YUV_SEMIPLANAR_422 == enPixFmt)?2:1.5));
}
/******************************************************************************
* 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;
}
/*****************************************************************************
* function : get vi parameter, according to vi type
*****************************************************************************/
HI_S32 SAMPLE_COMM_VI_ADStart(SAMPLE_VI_MODE_E enViMode, VIDEO_NORM_E enNorm)
{
VI_WORK_MODE_E enWorkMode;
HI_S32 s32Ret;
switch (enViMode)
{
case SAMPLE_VI_MODE_1_D1:
case SAMPLE_VI_MODE_1_D1Cif:
enWorkMode = VI_WORK_MODE_4Multiplex;
s32Ret = SAMPLE_AD_CfgV_D1(enNorm, enWorkMode);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("SAMPLE_TW2865_CfgV failed with %#x!\n",\
s32Ret);
return HI_FAILURE;
}
break;
case SAMPLE_VI_MODE_16_D1:
case SAMPLE_VI_MODE_8_D1:
case SAMPLE_VI_MODE_4_D1:
case SAMPLE_VI_MODE_16_Cif:
case SAMPLE_VI_MODE_16_2Cif:
case SAMPLE_VI_MODE_8_2Cif:
case SAMPLE_VI_MODE_8_D1Cif:
case SAMPLE_VI_MODE_16_D1Cif:
enWorkMode = VI_WORK_MODE_4Multiplex;
s32Ret = SAMPLE_AD_CfgV_D1(enNorm, enWorkMode);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("SAMPLE_TW2865_CfgV failed with %#x!\n",\
s32Ret);
return HI_FAILURE;
}
break;
case SAMPLE_VI_MODE_16_960H:
enWorkMode = VI_WORK_MODE_4Multiplex;
s32Ret = SAMPLE_AD_CfgV_960H(enNorm, enWorkMode);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("SAMPLE_TW2960_CfgV failed with %#x!\n",\
s32Ret);
return HI_FAILURE;
}
break;
case SAMPLE_VI_MODE_4_720P:
case SAMPLE_VI_MODE_1_720P:
break;
case SAMPLE_VI_MODE_4_1080P:
case SAMPLE_VI_MODE_1_1080P:
break;
default:
SAMPLE_PRT("AD not support!\n");
return HI_FAILURE;
}
return HI_SUCCESS;
}
/******************************************************************************
* funciton : vda OD mode thread process
******************************************************************************/
HI_VOID *SAMPLE_COMM_VDA_OdGetResult(HI_VOID *pdata)
{
HI_S32 i;
HI_S32 s32Ret;
VDA_CHN VdaChn;
VDA_DATA_S stVdaData;
HI_U32 u32RgnNum;
VDA_OD_PARAM_S *pgs_stOdParam;
//FILE *fp=stdout;
int num = 0;
pgs_stOdParam = (VDA_OD_PARAM_S *)pdata;
VdaChn = pgs_stOdParam->VdaChn;
while(HI_TRUE == pgs_stOdParam->bThreadStart)
{
s32Ret = HI_MPI_VDA_GetData(VdaChn,&stVdaData,HI_TRUE);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VDA_GetData failed with %#x!\n", s32Ret);
return NULL;
}
// fprintf(stdout, "HI_MPI_VDA_GetData od succeed\n");
//SAMPLE_COMM_VDA_OdPrt(fp, &stVdaData);
u32RgnNum = stVdaData.unData.stOdData.u32RgnNum;
// fprintf(stdout, "u32RgnNum = %d\n", u32RgnNum);
for(i=0; i<u32RgnNum; i++)
{
if(HI_TRUE == stVdaData.unData.stOdData.abRgnAlarm[i])
{
num++;
printf("%d Rgn--%d,Occ!\n", num, i);
// gettimeofday(&start, NULL);
// Log("\n");
s32Ret = HI_MPI_VDA_ResetOdRegion(VdaChn,i);
// Print_Time_Diff(start);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VDA_ResetOdRegion failed with %#x!\n", s32Ret);
return NULL;
}
}
}
s32Ret = HI_MPI_VDA_ReleaseData(VdaChn,&stVdaData);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VDA_ReleaseData failed with %#x!\n", s32Ret);
return NULL;
}
usleep(200*1000);
}
return HI_NULL;
}
HI_S32 SAMPLE_TW2960_CfgV(VIDEO_NORM_E enVideoMode,VI_WORK_MODE_E enWorkMode)
{
int fd, i;
int video_mode;
tw2865_video_norm stVideoMode;
tw2865_work_mode work_mode;
int chip_cnt = 4;
fd = open(TW2960_FILE, O_RDWR);
if (fd < 0)
{
SAMPLE_PRT("open 2960(%s) fail\n", TW2960_FILE);
return -1;
}
video_mode = (VIDEO_ENCODING_MODE_PAL == enVideoMode) ? TW2960_PAL : TW2960_NTSC ;
for (i=0; i<chip_cnt; i++)
{
stVideoMode.chip = i;
stVideoMode.mode = video_mode;
if (ioctl(fd, TW2960_SET_VIDEO_NORM, &stVideoMode))
{
SAMPLE_PRT("set tw2865(%d) video mode fail\n", i);
close(fd);
return -1;
}
}
for (i=0; i<chip_cnt; i++)
{
work_mode.chip = i;
if (VI_WORK_MODE_4Multiplex== enWorkMode)
{
work_mode.mode = TW2960_4D1_MODE;
}
else if (VI_WORK_MODE_2Multiplex== enWorkMode)
{
work_mode.mode = TW2960_2D1_MODE;
}
else if (VI_WORK_MODE_1Multiplex == enWorkMode)
{
work_mode.mode = TW2960_1D1_MODE;
}
else
{
SAMPLE_PRT("work mode not support\n");
return -1;
}
ioctl(fd, TW2960_SET_WORK_MODE, &work_mode);
}
close(fd);
return 0;
}
/*****************************************************************************
* function : stop vi accroding to product type
*****************************************************************************/
HI_S32 SAMPLE_COMM_VI_Stop(SAMPLE_VI_MODE_E enViMode)
{
VI_DEV ViDev;
VI_CHN ViChn;
HI_S32 i;
HI_S32 s32Ret;
SAMPLE_VI_PARAM_S stViParam;
/*** get parameter from Sample_Vi_Mode ***/
s32Ret = SAMPLE_COMM_VI_Mode2Param(enViMode, &stViParam);
if (HI_SUCCESS !=s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_VI_Mode2Param failed!\n");
return HI_FAILURE;
}
/*** Stop VI Chn ***/
for(i=0;i<stViParam.s32ViChnCnt;i++)
{
/* Stop vi phy-chn */
ViChn = i * stViParam.s32ViChnInterval;
s32Ret = HI_MPI_VI_DisableChn(ViChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_VI_StopChn failed with %#x\n",s32Ret);
return HI_FAILURE;
}
/* HD mode, we will stop vi sub-chn */
if (HI_TRUE == SAMPLE_COMM_VI_IsHd(enViMode))
{
ViChn += 16;
s32Ret = HI_MPI_VI_DisableChn(ViChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_VI_StopChn failed with %#x\n", s32Ret);
return HI_FAILURE;
}
}
}
/*** Stop VI Dev ***/
for(i=0; i<stViParam.s32ViDevCnt; i++)
{
ViDev = i * stViParam.s32ViDevInterval;
s32Ret = HI_MPI_VI_DisableDev(ViDev);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_VI_StopDev failed with %#x\n", s32Ret);
return HI_FAILURE;
}
}
return HI_SUCCESS;
}
/******************************************************************************
* function : show part canny sample
******************************************************************************/
static HI_VOID SAMPLE_IVE_Part_Canny(SAMPLE_IVE_CANNY_INFO_S* pstCannyInfo)
{
HI_S32 s32Ret = HI_SUCCESS;
HI_BOOL bInstant = HI_TRUE;
HI_BOOL bBlock = HI_TRUE;
HI_BOOL bFinish = HI_FALSE;
IVE_HANDLE IveHandle;
IVE_DST_IMAGE_S stDstAng;
memset(&stDstAng, 0, sizeof(IVE_DST_IMAGE_S));
s32Ret = SAMPLE_COMM_IVE_ReadFile(&pstCannyInfo->stSrc, pstCannyInfo->pFpSrc);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("SAMPLE_COMM_IVE_ReadFile fail\n");
return;
}
bInstant = HI_FALSE;
s32Ret = HI_MPI_IVE_MagAndAng(&IveHandle, &pstCannyInfo->stSrc, &pstCannyInfo->stMag, \
&stDstAng, &pstCannyInfo->stMagAndAngCtrl, bInstant);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_IVE_MagAndAng fail,Error(%#x)\n", s32Ret);
return;
}
bInstant = HI_TRUE;
s32Ret = HI_MPI_IVE_Thresh_U16(&IveHandle, &pstCannyInfo->stMag, &pstCannyInfo->stEdge, \
&pstCannyInfo->stThrU16Ctrl, bInstant);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_IVE_Thresh_U16 fail,Error(%#x)\n", s32Ret);
return;
}
s32Ret = HI_MPI_IVE_Query(IveHandle, &bFinish, bBlock);
while (HI_ERR_IVE_QUERY_TIMEOUT == s32Ret)
{
usleep(100);
s32Ret = HI_MPI_IVE_Query(IveHandle, &bFinish, bBlock);
}
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_IVE_Query fail,Error(%#x)\n", s32Ret);
return;
}
s32Ret = SAMPLE_COMM_IVE_WriteFile(&pstCannyInfo->stEdge, pstCannyInfo->pFpDst);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("SAMPLE_COMM_IVE_WriteFile fail\n");
return;
}
}
/******************************************************************************
* function : show complate canny sample
******************************************************************************/
static HI_VOID SAMPLE_IVE_Complate_Canny(SAMPLE_IVE_CANNY_INFO_S *pstCannyInfo)
{
HI_S32 s32Ret = HI_SUCCESS;
HI_BOOL bInstant = HI_TRUE;
HI_BOOL bBlock = HI_TRUE;
HI_BOOL bFinish = HI_FALSE;
IVE_HANDLE IveHandle;
s32Ret = SAMPLE_COMM_IVE_ReadFile(&(pstCannyInfo->stSrc),pstCannyInfo->pFpSrc);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("SAMPLE_COMM_IVE_ReadFile fail\n");
return;
}
s32Ret = HI_MPI_IVE_CannyHysEdge(&IveHandle, &pstCannyInfo->stSrc, \
&pstCannyInfo->stEdge, &pstCannyInfo->stStack, \
&pstCannyInfo->stCannyHysEdgeCtrl, bInstant);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_IVE_CannyHysEdge fail,Error(%#x)\n",s32Ret);
return;
}
s32Ret = HI_MPI_IVE_Query(IveHandle, &bFinish, bBlock);
while(HI_ERR_IVE_QUERY_TIMEOUT == s32Ret)
{
usleep(100);
s32Ret = HI_MPI_IVE_Query(IveHandle,&bFinish,bBlock);
}
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_IVE_Query fail,Error(%#x)\n",s32Ret);
return;
}
s32Ret = HI_MPI_IVE_CannyEdge(&pstCannyInfo->stEdge, &pstCannyInfo->stStack);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_IVE_CannyEdge fail,Error(%#x)\n",s32Ret);
return;
}
s32Ret = SAMPLE_COMM_IVE_WriteFile(&pstCannyInfo->stEdge,pstCannyInfo->pFpDst);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("SAMPLE_COMM_IVE_WriteFile fail\n");
return;
}
}
HI_S32 SAMPLE_COMM_VPSS_StartGroup(VPSS_GRP VpssGrp, VPSS_GRP_ATTR_S *pstVpssGrpAttr)
{
HI_S32 s32Ret;
VPSS_GRP_PARAM_S stVpssParam;
if (VpssGrp < 0 || VpssGrp > VPSS_MAX_GRP_NUM)
{
printf("VpssGrp%d is out of rang. \n", VpssGrp);
return HI_FAILURE;
}
if (HI_NULL == pstVpssGrpAttr)
{
printf("null ptr,line%d. \n", __LINE__);
return HI_FAILURE;
}
s32Ret = HI_MPI_VPSS_CreateGrp(VpssGrp, pstVpssGrpAttr);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VPSS_CreateGrp failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
/*** set vpss param ***/
s32Ret = HI_MPI_VPSS_GetGrpParam(VpssGrp, &stVpssParam);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
stVpssParam.u32MotionThresh = 0;
s32Ret = HI_MPI_VPSS_SetGrpParam(VpssGrp, &stVpssParam);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VPSS_StartGrp(VpssGrp);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VPSS_StartGrp failed with %#x\n", s32Ret);
return HI_FAILURE;
}
return HI_SUCCESS;
}
HI_S32 SAMPLE_COMM_VGS_FillRect(VIDEO_FRAME_INFO_S *pstFrmInfo, SAMPLE_RECT_ARRAY_S *pstRect,HI_U32 u32Color)
{
VGS_HANDLE VgsHandle;
HI_S32 s32Ret = HI_SUCCESS;
HI_U16 i;
VGS_TASK_ATTR_S stVgsTask;
VGS_ADD_COVER_S stVgsAddCover;
if(0 == pstRect->u16Num)
{
return s32Ret;
}
s32Ret = HI_MPI_VGS_BeginJob(&VgsHandle);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("Vgs begin job fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
memcpy(&stVgsTask.stImgIn,pstFrmInfo,sizeof(VIDEO_FRAME_INFO_S));
memcpy(&stVgsTask.stImgOut,pstFrmInfo,sizeof(VIDEO_FRAME_INFO_S));
stVgsAddCover.enCoverType = COVER_QUAD_RANGLE;
stVgsAddCover.u32Color = u32Color;
for(i = 0;i < pstRect->u16Num;i++)
{
stVgsAddCover.stQuadRangle.bSolid = HI_FALSE;
stVgsAddCover.stQuadRangle.u32Thick = 2;
memcpy(stVgsAddCover.stQuadRangle.stPoint,pstRect->astRect[i].astPoint,sizeof(pstRect->astRect[i].astPoint));
s32Ret = HI_MPI_VGS_AddCoverTask(VgsHandle, &stVgsTask, &stVgsAddCover);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VGS_AddCoverTask fail,Error(%#x)\n",s32Ret);
HI_MPI_VGS_CancelJob(VgsHandle);
return s32Ret;
}
}
s32Ret = HI_MPI_VGS_EndJob(VgsHandle);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VGS_EndJob fail,Error(%#x)\n",s32Ret);
HI_MPI_VGS_CancelJob(VgsHandle);
return s32Ret;
}
return s32Ret;
}
/******************************************************************************
* function : Dma frame info to ive image
******************************************************************************/
HI_S32 SAMPLE_COMM_DmaImage(VIDEO_FRAME_INFO_S *pstFrameInfo,IVE_DST_IMAGE_S *pstDst,HI_BOOL bInstant)
{
HI_S32 s32Ret;
IVE_HANDLE hIveHandle;
IVE_SRC_DATA_S stSrcData;
IVE_DST_DATA_S stDstData;
IVE_DMA_CTRL_S stCtrl = {IVE_DMA_MODE_DIRECT_COPY,0};
HI_BOOL bFinish = HI_FALSE;
HI_BOOL bBlock = HI_TRUE;
//fill src
stSrcData.pu8VirAddr = (HI_U8*)pstFrameInfo->stVFrame.pVirAddr[0];
stSrcData.u32PhyAddr = pstFrameInfo->stVFrame.u32PhyAddr[0];
stSrcData.u16Width = (HI_U16)pstFrameInfo->stVFrame.u32Width;
stSrcData.u16Height = (HI_U16)pstFrameInfo->stVFrame.u32Height;
stSrcData.u16Stride = (HI_U16)pstFrameInfo->stVFrame.u32Stride[0];
//fill dst
stDstData.pu8VirAddr = pstDst->pu8VirAddr[0];
stDstData.u32PhyAddr = pstDst->u32PhyAddr[0];
stDstData.u16Width = pstDst->u16Width;
stDstData.u16Height = pstDst->u16Height;
stDstData.u16Stride = pstDst->u16Stride[0];
s32Ret = HI_MPI_IVE_DMA(&hIveHandle,&stSrcData,&stDstData,&stCtrl,bInstant);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_IVE_DMA fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
if (HI_TRUE == bInstant)
{
s32Ret = HI_MPI_IVE_Query(hIveHandle,&bFinish,bBlock);
while(HI_ERR_IVE_QUERY_TIMEOUT == s32Ret)
{
usleep(100);
s32Ret = HI_MPI_IVE_Query(hIveHandle,&bFinish,bBlock);
}
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_IVE_Query fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
}
return HI_SUCCESS;
}
/******************************************************************************
* function : Set venc memory location
******************************************************************************/
HI_S32 SAMPLE_COMM_VENC_MemConfig(HI_VOID)
{
HI_S32 i = 0;
HI_S32 s32Ret;
HI_CHAR * pcMmzName;
MPP_CHN_S stMppChnVENC;
/* group, venc max chn is 64*/
for(i=0;i<64;i++)
{
stMppChnVENC.enModId = HI_ID_VENC;
stMppChnVENC.s32DevId = 0;
stMppChnVENC.s32ChnId = i;
pcMmzName = NULL;
/*venc*/
s32Ret = HI_MPI_SYS_SetMemConf(&stMppChnVENC,pcMmzName);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_SYS_SetMemConf with %#x!\n", s32Ret);
return HI_FAILURE;
}
}
return HI_SUCCESS;
}
/******************************************************************************
* function : Set system memory location
******************************************************************************/
HI_S32 SAMPLE_COMM_VDEC_MemConfig(HI_VOID)
{
HI_S32 i = 0;
HI_S32 s32Ret = HI_SUCCESS;
HI_CHAR * pcMmzName;
MPP_CHN_S stMppChnVDEC;
/* VDEC chn max is 32*/
for(i=0;i<32;i++)
{
stMppChnVDEC.enModId = HI_ID_VDEC;
stMppChnVDEC.s32DevId = 0;
stMppChnVDEC.s32ChnId = i;
if(0 == (i%2))
{
pcMmzName = NULL;
}
else
{
pcMmzName = "ddr1";
}
s32Ret = HI_MPI_SYS_SetMemConf(&stMppChnVDEC,pcMmzName);
if (s32Ret)
{
SAMPLE_PRT("HI_MPI_SYS_SetMemConf ERR !\n");
return HI_FAILURE;
}
}
return HI_SUCCESS;
}
HI_VOID SAMPLE_IVE_Gmm2(HI_VOID)
{
HI_S32 s32Ret;
HI_U16 u16Width = 352;
HI_U16 u16Height = 288;
HI_CHAR *pchSrcFileName = "./data/input/gmm2/gmm2_352x288_sp400_frm1000.yuv";
HI_CHAR *pchFgFileName = "./data/output/gmm2/fg_352x288_sp400.yuv";
HI_CHAR *pchBgFileName = "./data/output/gmm2/bg_352x288_sp400.yuv";
memset(&s_stGmm2,0,sizeof(s_stGmm2));
SAMPLE_COMM_IVE_CheckIveMpiInit();
s32Ret = SAMPLE_IVE_Gmm2_Init(&s_stGmm2, u16Width,u16Height,pchSrcFileName,
pchFgFileName,pchBgFileName);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_IVE_Gmm2_Init fail\n");
goto GMM2_FAIL;
}
SAMPLE_IVE_Gmm2Proc(&s_stGmm2);
SAMPLE_IVE_Gmm2_Uninit(&s_stGmm2);
memset(&s_stGmm2,0,sizeof(s_stGmm2));
GMM2_FAIL:
SAMPLE_COMM_IVE_IveMpiExit();
}
/******************************************************************************
* funciton : Start snap
******************************************************************************/
HI_S32 SAMPLE_COMM_VENC_SnapStart(VENC_CHN VencChn, SIZE_S *pstSize)
{
HI_S32 s32Ret;
VENC_CHN_ATTR_S stVencChnAttr;
VENC_ATTR_JPEG_S stJpegAttr;
/******************************************
step 1: Create Venc Channel
******************************************/
stVencChnAttr.stVeAttr.enType = PT_JPEG;
stJpegAttr.u32MaxPicWidth = pstSize->u32Width;
stJpegAttr.u32MaxPicHeight = pstSize->u32Height;
stJpegAttr.u32PicWidth = pstSize->u32Width;
stJpegAttr.u32PicHeight = pstSize->u32Height;
stJpegAttr.u32BufSize = pstSize->u32Width * pstSize->u32Height * 2;
stJpegAttr.bByFrame = HI_TRUE;/*get stream mode is field mode or frame mode*/
memcpy(&stVencChnAttr.stVeAttr.stAttrJpeg, &stJpegAttr, sizeof(VENC_ATTR_JPEG_S));
s32Ret = HI_MPI_VENC_CreateChn(VencChn, &stVencChnAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_CreateChn [%d] faild with %#x!\n",\
VencChn, s32Ret);
return s32Ret;
}
return HI_SUCCESS;
}
HI_S32 SAMPLE_COMM_VO_GetWH(VO_INTF_SYNC_E enIntfSync, HI_U32 *pu32W,HI_U32 *pu32H, HI_U32 *pu32Frm)
{
switch (enIntfSync)
{
case VO_OUTPUT_PAL : *pu32W = 720; *pu32H = 576; *pu32Frm = 25; break;
case VO_OUTPUT_NTSC : *pu32W = 720; *pu32H = 480; *pu32Frm = 30; break;
case VO_OUTPUT_800x600_60: *pu32W = 800; *pu32H = 600; *pu32Frm = 60; break;
case VO_OUTPUT_720P50 : *pu32W = 1280; *pu32H = 720; *pu32Frm = 50; break;
case VO_OUTPUT_1080P24 : *pu32W = 1920; *pu32H = 1080; *pu32Frm = 24; break;
case VO_OUTPUT_720P60 : *pu32W = 1280; *pu32H = 720; *pu32Frm = 60; break;
case VO_OUTPUT_1080P30 : *pu32W = 1920; *pu32H = 1080; *pu32Frm = 30; break;
case VO_OUTPUT_1080P25 : *pu32W = 1920; *pu32H = 1080; *pu32Frm = 25; break;
case VO_OUTPUT_1080P50 : *pu32W = 1920; *pu32H = 1080; *pu32Frm = 50; break;
case VO_OUTPUT_1080P60 : *pu32W = 1920; *pu32H = 1080; *pu32Frm = 60; break;
case VO_OUTPUT_1024x768_60: *pu32W = 1024; *pu32H = 768; *pu32Frm = 60; break;
case VO_OUTPUT_1280x1024_60: *pu32W = 1280; *pu32H = 1024; *pu32Frm = 60; break;
case VO_OUTPUT_1366x768_60: *pu32W = 1366; *pu32H = 768; *pu32Frm = 60; break;
case VO_OUTPUT_1440x900_60: *pu32W = 1440; *pu32H = 900; *pu32Frm = 60; break;
case VO_OUTPUT_1280x800_60: *pu32W = 1280; *pu32H = 800; *pu32Frm = 60; break;
default:
SAMPLE_PRT("vo enIntfSync not support!\n");
return HI_FAILURE;
}
return HI_SUCCESS;
}
/******************************************************************************
* function : Set vpss system memory location
******************************************************************************/
HI_S32 SAMPLE_COMM_VPSS_MemConfig()
{
HI_CHAR * pcMmzName;
MPP_CHN_S stMppChnVpss;
HI_S32 s32Ret, i;
/*vpss group max is 64, not need config vpss chn.*/
for(i=0;i<64;i++)
{
stMppChnVpss.enModId = HI_ID_VPSS;
stMppChnVpss.s32DevId = i;
stMppChnVpss.s32ChnId = 0;
if(0 == (i%2))
{
pcMmzName = NULL;
}
else
{
pcMmzName = "ddr1";
}
/*vpss*/
s32Ret = HI_MPI_SYS_SetMemConf(&stMppChnVpss, pcMmzName);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Vpss HI_MPI_SYS_SetMemConf ERR !\n");
return HI_FAILURE;
}
}
return HI_SUCCESS;
}
/******************************************************************************
* funciton : get file postfix according palyload_type.
******************************************************************************/
HI_S32 SAMPLE_COMM_VENC_GetFilePostfix(PAYLOAD_TYPE_E enPayload, char *szFilePostfix)
{
if (PT_H264 == enPayload)
{
strcpy(szFilePostfix, ".h264");
}
else if (PT_JPEG == enPayload)
{
strcpy(szFilePostfix, ".jpg");
}
else if (PT_MJPEG == enPayload)
{
strcpy(szFilePostfix, ".mjp");
}
else if (PT_MP4VIDEO == enPayload)
{
strcpy(szFilePostfix, ".mp4");
}
else
{
SAMPLE_PRT("payload type err!\n");
return HI_FAILURE;
}
return HI_SUCCESS;
}
/******************************************************************************
* function : show canny sample
******************************************************************************/
HI_VOID SAMPLE_IVE_Canny(HI_CHAR chComplete)
{
SAMPLE_IVE_CANNY_INFO_S stCannyInfo;
HI_U16 u16Width = 720;
HI_U16 u16Height = 576;
HI_CHAR *pchSrcFileName = "./data/input/canny/canny.yuv";
HI_CHAR achDstFileName[IVE_FILE_NAME_LEN];
HI_S32 s32Ret;
SAMPLE_COMM_IVE_CheckIveMpiInit();
sprintf(achDstFileName,"./data/output/canny/cannyout_complete_%c.yuv",chComplete);
s32Ret = SAMPLE_IVE_Canny_Init(&stCannyInfo,pchSrcFileName,achDstFileName,u16Width,u16Height);
if(HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_IVE_Canny_Init fail\n");
goto CANNY_FAIL;
}
if('0' == chComplete)
{
SAMPLE_IVE_Part_Canny(&stCannyInfo);
}
else
{
SAMPLE_IVE_Complate_Canny(&stCannyInfo);
}
SAMPLE_IVE_Canny_Uninit(&stCannyInfo);
CANNY_FAIL:
SAMPLE_COMM_IVE_IveMpiExit();
}
HI_S32 SAMPLE_COMM_VPSS_DisableChn(VPSS_GRP VpssGrp, VPSS_CHN VpssChn)
{
HI_S32 s32Ret;
if (VpssGrp < 0 || VpssGrp > VPSS_MAX_GRP_NUM)
{
printf("VpssGrp%d is out of rang[0,%d]. \n", VpssGrp, VPSS_MAX_GRP_NUM);
return HI_FAILURE;
}
if (VpssChn < 0 || VpssChn > VPSS_MAX_CHN_NUM)
{
printf("VpssChn%d is out of rang[0,%d]. \n", VpssChn, VPSS_MAX_CHN_NUM);
return HI_FAILURE;
}
s32Ret = HI_MPI_VPSS_DisableChn(VpssGrp, VpssChn);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("%s failed with %#x\n", __FUNCTION__, s32Ret);
return HI_FAILURE;
}
return HI_SUCCESS;
}
HI_S32 SAMPLE_COMM_IVE_IveMpiExit(HI_VOID)
{
bMpiInit = HI_FALSE;
if (HI_MPI_SYS_Exit())
{
SAMPLE_PRT("Sys exit failed!\n");
return HI_FAILURE;
}
if (HI_MPI_VB_Exit())
{
SAMPLE_PRT("Vb exit failed!\n");
return HI_FAILURE;
}
return HI_SUCCESS;
}
/*****************************************************************************
* function : Vi chn unbind vpss group
*****************************************************************************/
HI_S32 SAMPLE_COMM_VI_UnBindVpss(SAMPLE_VI_MODE_E enViMode)
{
HI_S32 i, j, s32Ret;
VPSS_GRP VpssGrp;
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;
SAMPLE_VI_PARAM_S stViParam;
VI_DEV ViDev;
VI_CHN ViChn;
s32Ret = SAMPLE_COMM_VI_Mode2Param(enViMode, &stViParam);
if (HI_SUCCESS !=s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_VI_Mode2Param failed!\n");
return HI_FAILURE;
}
VpssGrp = 0;
for (i=0; i<stViParam.s32ViDevCnt; i++)
{
ViDev = i * stViParam.s32ViDevInterval;
for (j=0; j<stViParam.s32ViChnCnt; j++)
{
ViChn = j * stViParam.s32ViChnInterval;
stSrcChn.enModId = HI_ID_VIU;
stSrcChn.s32DevId = ViDev;
stSrcChn.s32ChnId = ViChn;
stDestChn.enModId = HI_ID_VPSS;
stDestChn.s32DevId = VpssGrp;
stDestChn.s32ChnId = 0;
s32Ret = HI_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
VpssGrp ++;
}
}
return HI_SUCCESS;
}
/******************************************************************************
* function : vb init & MPI system init
******************************************************************************/
HI_S32 SAMPLE_COMM_SYS_Init(VB_CONF_S *pstVbConf)
{
MPP_SYS_CONF_S stSysConf = {0};
HI_S32 s32Ret = HI_FAILURE;
HI_MPI_SYS_Exit();
HI_MPI_VB_Exit();
if (NULL == pstVbConf)
{
SAMPLE_PRT("input parameter is null, it is invaild!\n");
return HI_FAILURE;
}
s32Ret = HI_MPI_VB_SetConf(pstVbConf);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VB_SetConf failed!\n");
return HI_FAILURE;
}
s32Ret = HI_MPI_VB_Init();
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VB_Init failed!\n");
return HI_FAILURE;
}
stSysConf.u32AlignWidth = SAMPLE_SYS_ALIGN_WIDTH;
s32Ret = HI_MPI_SYS_SetConf(&stSysConf);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_SYS_SetConf failed\n");
return HI_FAILURE;
}
s32Ret = HI_MPI_SYS_Init();
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_SYS_Init failed!\n");
return HI_FAILURE;
}
return HI_SUCCESS;
}
static HI_S32 SAMPLE_IVE_MPI_Init(HI_VOID)
{
HI_S32 s32Ret;
VB_CONF_S struVbConf;
MPP_SYS_CONF_S struSysConf;
HI_MPI_SYS_Exit();
HI_MPI_VB_Exit();
memset(&struVbConf,0,sizeof(VB_CONF_S));
struVbConf.u32MaxPoolCnt = 128;
struVbConf.astCommPool[0].u32BlkSize = 1920*1080*3/2;
struVbConf.astCommPool[0].u32BlkCnt = 4;
s32Ret = HI_MPI_VB_SetConf(&struVbConf);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VB_SetConf fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
s32Ret = HI_MPI_VB_Init();
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VB_Init fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
struSysConf.u32AlignWidth = 64;
s32Ret = HI_MPI_SYS_SetConf(&struSysConf);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_SYS_SetConf fail,Error(%#x)\n",s32Ret);
(HI_VOID)HI_MPI_VB_Exit();
return s32Ret;
}
s32Ret = HI_MPI_SYS_Init();
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_SYS_Init fail,Error(%#x)\n",s32Ret);
(HI_VOID)HI_MPI_VB_Exit();
return s32Ret;
}
return HI_SUCCESS;
}
/******************************************************************************
* funciton : stop vda, and stop vda thread -- MD
******************************************************************************/
HI_VOID SAMPLE_COMM_VDA_MdStop(VDA_CHN VdaChn, VI_CHN ViChn)
{
HI_S32 s32Ret = HI_SUCCESS;
MPP_CHN_S stSrcChn, stDestChn;
/* join thread */
if (HI_TRUE == gs_stMdParam.bThreadStart)
{
gs_stMdParam.bThreadStart = HI_FALSE;
pthread_join(gs_VdaPid[SAMPLE_VDA_MD_CHN], 0);
}
/* vda stop recv picture */
s32Ret = HI_MPI_VDA_StopRecvPic(VdaChn);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("err(0x%x)!!!!\n",s32Ret);
}
/* unbind vda chn & vi chn */
stSrcChn.enModId = HI_ID_VIU;
stSrcChn.s32ChnId = ViChn;
stSrcChn.s32DevId = 0;
stDestChn.enModId = HI_ID_VDA;
stDestChn.s32ChnId = VdaChn;
stDestChn.s32DevId = 0;
s32Ret = HI_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("err(0x%x)!!!!\n", s32Ret);
}
/* destroy vda chn */
s32Ret = HI_MPI_VDA_DestroyChn(VdaChn);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("err(0x%x)!!!!\n", s32Ret);
}
return;
}
/******************************************************************************
* function : calculate VB Block size of Histogram.
******************************************************************************/
HI_U32 SAMPLE_COMM_SYS_CalcHistVbBlkSize(VIDEO_NORM_E enNorm, PIC_SIZE_E enPicSize, SIZE_S *pstHistBlkSize, HI_U32 u32AlignWidth)
{
HI_S32 s32Ret;
SIZE_S stPicSize;
s32Ret = SAMPLE_COMM_SYS_GetPicSize(enNorm, enPicSize, &stPicSize);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("get picture size[%d] failed!\n", enPicSize);
return HI_FAILURE;
}
SAMPLE_PRT("stPicSize.u32Width%d,pstHistBlkSize->u32Width%d\n,stPicSize.u32Height%d,pstHistBlkSize->u32Height%d\n",
stPicSize.u32Width,pstHistBlkSize->u32Width,
stPicSize.u32Height,pstHistBlkSize->u32Height );
return (CEILING_2_POWER(44, u32AlignWidth)*CEILING_2_POWER(44, u32AlignWidth)*16*4);
return HI_SUCCESS;
}
/*****************************************************************************
* function : star vi chn
*****************************************************************************/
HI_S32 SAMPLE_COMM_VI_StartChn(VI_CHN ViChn, RECT_S *pstCapRect, SIZE_S *pstTarSize,
SAMPLE_VI_MODE_E enViMode, SAMPLE_VI_CHN_SET_E enViChnSet)
{
HI_S32 s32Ret;
VI_CHN_ATTR_S stChnAttr;
/* step 5: config & start vicap dev */
memcpy(&stChnAttr.stCapRect, pstCapRect, sizeof(RECT_S));
if (SAMPLE_VI_MODE_16_Cif == enViMode)
{
stChnAttr.enCapSel = VI_CAPSEL_BOTTOM;
}
else
{
stChnAttr.enCapSel = VI_CAPSEL_BOTH;
}
/* to show scale. this is a sample only, we want to show dist_size = D1 only */
stChnAttr.stDestSize.u32Width = pstTarSize->u32Width;
stChnAttr.stDestSize.u32Height = pstTarSize->u32Height;
stChnAttr.enPixFormat = SAMPLE_PIXEL_FORMAT; /* sp420 or sp422 */
stChnAttr.bMirror = (VI_CHN_SET_MIRROR == enViChnSet)?HI_TRUE:HI_FALSE;
stChnAttr.bFlip = (VI_CHN_SET_FILP == enViChnSet)?HI_TRUE:HI_FALSE;
stChnAttr.bChromaResample = HI_FALSE;
stChnAttr.s32SrcFrameRate = -1;
stChnAttr.s32FrameRate = -1;
s32Ret = HI_MPI_VI_SetChnAttr(ViChn, &stChnAttr);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VI_EnableChn(ViChn);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
return HI_SUCCESS;
}
