bool HimppVpssChan::enableObject()
{
int grp = _vpss_group->getGroupId();
int chn = _chnid;
VPSS_CHN_ATTR_S chn_attr;
VPSS_CHN_MODE_S chn_mode;
VPSS_EXT_CHN_ATTR_S ext_chn_attr;
HI_S32 s32Ret;
switch (_type) {
case VPSS_CHN_TYPE_PHY:
chn_attr.bSpEn = HI_FALSE;
chn_attr.bBorderEn = HI_FALSE;
chn_attr.bMirror = HI_FALSE;
chn_attr.bFlip = HI_FALSE;
chn_attr.s32SrcFrameRate = -1;
chn_attr.s32DstFrameRate = -1;
if ((s32Ret = HI_MPI_VPSS_SetChnAttr(grp, chn, &chn_attr)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VPSS_SetChnAttr %d-%d failed %#x\n",
grp, chn, s32Ret);
return false;
}
chn_mode.enChnMode = VPSS_CHN_MODE_USER;
chn_mode.u32Width = _resolution.Width;
chn_mode.u32Height = _resolution.Height;
chn_mode.bDouble = HI_FALSE;
chn_mode.enPixelFormat = HIMPP_PIXEL_FORMAT;
if ((s32Ret = HI_MPI_VPSS_SetChnMode(grp, chn, &chn_mode)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VPSS_SetChnMode %d-%d failed %#x\n",
grp, chn, s32Ret);
return false;
}
break;
case VPSS_CHN_TYPE_EXT:
ext_chn_attr.s32BindChn = 0;
ext_chn_attr.s32SrcFrameRate = _framerate;
if ((s32Ret = HI_MPI_VPSS_SetExtChnAttr(grp, chn, &ext_chn_attr)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VPSS_SetExtChnAttr %d-%d failed %#x\n",
grp, chn, s32Ret);
return false;
}
break;
default:
break;
}
if ((s32Ret = HI_MPI_VPSS_EnableChn(grp, chn)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VPSS_EnableChn %d-%d failed [%#x]\n",
grp, chn, s32Ret);
return false;
}
return true;
}
HI_VOID *SAMPLE_MISC_VpssDump(VPSS_GRP Grp,VPSS_CHN Chn,HI_U32 u32FrameCnt,HI_U32 u32Width,HI_U32 u32Height,HI_U32 u32PixelFormat)
{
VIDEO_FRAME_INFO_S stFrame;
HI_CHAR szYuvName[128];
HI_CHAR szPixFrm[10];
FILE *pfd;
VPSS_GRP VpssGrp = Grp;
VPSS_CHN VpssChn = Chn;
HI_U32 u32Cnt = u32FrameCnt;
HI_U32 u32Depth = 1;
VPSS_CHN_MODE_S stOrigVpssMode, stVpssMode;
if (HI_MPI_VPSS_GetChnMode(VpssGrp,VpssChn,&stOrigVpssMode) != HI_SUCCESS)
{
printf("get mode error!!!\n");
return (HI_VOID *)-1;
}
stVpssMode.enChnMode = VPSS_CHN_MODE_USER;
if (u32PixelFormat == 0)
{
stVpssMode.enPixelFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
}
else
{
stVpssMode.enPixelFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_422;
}
stVpssMode.u32Width = u32Width;
stVpssMode.u32Height = u32Height;
if (HI_MPI_VPSS_SetChnMode(VpssGrp,VpssChn,&stVpssMode) != HI_SUCCESS)
{
printf("set mode error!!!\n");
return (HI_VOID *)-1;
}
if (HI_MPI_VPSS_SetDepth(VpssGrp,VpssChn,u32Depth)!=HI_SUCCESS)
{
printf("set depth error!!!\n");
return (HI_VOID *)-1;
}
memset(&stFrame,0,sizeof(stFrame));
while ((HI_MPI_VPSS_UserGetFrame(VpssGrp, VpssChn, &stFrame)!=HI_SUCCESS))
{
printf("get frame error!!!\n");
sleep(1);
}
/* make file name */
strcpy(szPixFrm,
(PIXEL_FORMAT_YUV_SEMIPLANAR_420 == stFrame.stVFrame.enPixelFormat)?"p420":"p422");
sprintf(szYuvName, "./vpss_grp%d_chn%d_w%d_h%d_%s_%d.yuv", VpssGrp, VpssChn,
stFrame.stVFrame.u32Width, stFrame.stVFrame.u32Height,szPixFrm,u32Cnt);
printf("Dump YUV frame of vi chn %d to file: \"%s\"\n", VpssChn, szYuvName);
fflush(stdout);
HI_MPI_VPSS_UserReleaseFrame(VpssGrp, VpssChn, &stFrame);
/* open file */
pfd = fopen(szYuvName, "wb");
if (NULL == pfd)
{
return (HI_VOID *)-1;
}
/* get frame */
while (u32Cnt--)
{
if (HI_MPI_VPSS_UserGetFrame(VpssGrp, VpssChn, &stFrame) != HI_SUCCESS)
{
printf("Get frame fail \n");
usleep(1000);
continue;
}
sample_yuv_dump(&stFrame.stVFrame, pfd);
printf("Get VpssGrp %d frame %d!!\n", VpssGrp,u32Cnt);
/* release frame after using */
HI_MPI_VPSS_UserReleaseFrame(VpssGrp, VpssChn, &stFrame);
}
fclose(pfd);
HI_MPI_VPSS_SetChnMode(VpssGrp,VpssChn,&stOrigVpssMode);
return (HI_VOID *)0;
}
/*****************************************************************************
* function : start vpss. VPSS chn with frame
*****************************************************************************/
static HI_S32 SAMPLE_COMM_IVE_VpssStart(HI_S32 s32VpssGrpCnt, SIZE_S astSize[],
VPSS_CHN aVpssChn[], HI_S32 s32VpssChnCnt, VPSS_GRP_ATTR_S *pstVpssGrpAttr)
{
VPSS_GRP VpssGrp;
VPSS_CHN VpssChn;
VPSS_GRP_ATTR_S stGrpAttr = {0};
//VPSS_CHN_ATTR_S stChnAttr = {0};
VPSS_NR_PARAM_U unNrParam = {{0}};
VPSS_CHN_MODE_S stVpssChnMode = {0};
VPSS_FRAME_RATE_S stVpssFrmRate = {30, 30};
HI_S32 s32Ret = HI_SUCCESS;
HI_S32 i, j;
HI_U32 u32Depth = 1;
HI_ASSERT(s32VpssGrpCnt>0);
HI_ASSERT(s32VpssChnCnt>0);
/*** Set Vpss Grp Attr ***/
if(NULL == pstVpssGrpAttr)
{
stGrpAttr.u32MaxW = astSize[0].u32Width;
stGrpAttr.u32MaxH = astSize[0].u32Height;
stGrpAttr.bIeEn = HI_FALSE;
stGrpAttr.bNrEn = HI_TRUE;
stGrpAttr.bHistEn = HI_FALSE;
stGrpAttr.enDieMode = VPSS_DIE_MODE_NODIE;
stGrpAttr.enPixFmt = SAMPLE_PIXEL_FORMAT;
}
else
{
memcpy(&stGrpAttr,pstVpssGrpAttr,sizeof(VPSS_GRP_ATTR_S));
}
for(i=0; i<s32VpssGrpCnt; i++)
{
VpssGrp = i;
/*** create vpss group ***/
s32Ret = HI_MPI_VPSS_CreateGrp(VpssGrp, &stGrpAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_CreateGrp failed with errno: %#x!\n", s32Ret);
return HI_FAILURE;
}
//*** set vpss param ***/
s32Ret = HI_MPI_VPSS_GetNRParam(VpssGrp, &unNrParam);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_GetNRParam failed with errno: %#x!\n", s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VPSS_SetNRParam(VpssGrp, &unNrParam);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_SetNRParam failed with errno: %#x!\n", s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VPSS_SetGrpFrameRate(VpssGrp, &stVpssFrmRate);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_SetGrpFrameRate failed with errno: %#x!\n", s32Ret);
return HI_FAILURE;
}
/*** enable vpss chn, with frame ***/
for(j=0; j<s32VpssChnCnt; j++)
{
VpssChn = aVpssChn[j];
stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;
stVpssChnMode.u32Width = astSize[j].u32Width;
stVpssChnMode.u32Height = astSize[j].u32Height;
stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;
stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;
s32Ret = HI_MPI_VPSS_SetChnMode(VpssGrp, VpssChn, &stVpssChnMode);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_SetChnMode failed with errno: %#x\n", s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VPSS_SetDepth(VpssGrp, VpssChn, u32Depth);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_SetDepth failed with errno: %#x\n", s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VPSS_EnableChn(VpssGrp, VpssChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_EnableChn failed with errno: %#x\n", s32Ret);
return HI_FAILURE;
}
}
/*** start vpss group ***/
s32Ret = HI_MPI_VPSS_StartGrp(VpssGrp);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_StartGrp failed with %#x\n", s32Ret);
return HI_FAILURE;
}
}
return HI_SUCCESS;
}
HI_S32 SAMPLE_COMM_VPSS_EnableChn(VPSS_GRP VpssGrp, VPSS_CHN VpssChn,
VPSS_CHN_ATTR_S *pstVpssChnAttr,
VPSS_CHN_MODE_S *pstVpssChnMode,
VPSS_EXT_CHN_ATTR_S *pstVpssExtChnAttr)
{
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;
}
if (HI_NULL == pstVpssChnAttr && HI_NULL == pstVpssExtChnAttr)
{
printf("null ptr,line%d. \n", __LINE__);
return HI_FAILURE;
}
if (VpssChn < VPSS_MAX_PHY_CHN_NUM)
{
s32Ret = HI_MPI_VPSS_SetChnAttr(VpssGrp, VpssChn, pstVpssChnAttr);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VPSS_SetChnAttr failed with %#x\n", s32Ret);
return HI_FAILURE;
}
}
else
{
s32Ret = HI_MPI_VPSS_SetExtChnAttr(VpssGrp, VpssChn, pstVpssExtChnAttr);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("%s failed with %#x\n", __FUNCTION__, s32Ret);
return HI_FAILURE;
}
}
if (VpssChn < VPSS_MAX_PHY_CHN_NUM && HI_NULL != pstVpssChnMode)
{
s32Ret = HI_MPI_VPSS_SetChnMode(VpssGrp, VpssChn, pstVpssChnMode);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("%s failed with %#x\n", __FUNCTION__, s32Ret);
return HI_FAILURE;
}
}
s32Ret = HI_MPI_VPSS_EnableChn(VpssGrp, VpssChn);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VPSS_EnableChn failed with %#x\n", s32Ret);
return HI_FAILURE;
}
return HI_SUCCESS;
}
/******************************************************************************
* funciton : bind venc and vpss.
******************************************************************************/
HI_S32 venc_bind_vpss(VENC_CHN VencChn, SIZE_S *stSize, HI_BOOL Bind)
{
HI_S32 s32Ret;
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;
VPSS_CHN_MODE_S stVpssChnMode;
// VENC_GRP VencGrp = VencChn;
VPSS_GRP VpssGrp = VencChn;
VPSS_CHN VpssChn = 1;
stSrcChn.enModId = HI_ID_VPSS;
stSrcChn.s32DevId = VpssGrp;
stSrcChn.s32ChnId = VpssChn;
stDestChn.enModId = HI_ID_VENC;
stDestChn.s32DevId = 0;
stDestChn.s32ChnId = VencChn;
if(Bind == HI_TRUE)
{
s32Ret = HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
if (s32Ret != HI_SUCCESS)
{
Printf("failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
stVpssChnMode.bDouble = HI_FALSE;
stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;
stVpssChnMode.enPixelFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
stVpssChnMode.u32Width = stSize->u32Width;
stVpssChnMode.u32Height = stSize->u32Height;
stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;
s32Ret = HI_MPI_VPSS_SetChnMode(VpssGrp, VpssChn, &stVpssChnMode);
if (HI_SUCCESS != s32Ret)
{
Printf("set vpss grp%d chn%d mode fail, s32Ret: 0x%x.\n", VpssGrp, VpssChn, s32Ret);
return s32Ret;
}
}
else
{
s32Ret = HI_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
if (s32Ret != HI_SUCCESS)
{
Printf("failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
stVpssChnMode.bDouble = HI_FALSE;
stVpssChnMode.enChnMode = VPSS_CHN_MODE_AUTO;
stVpssChnMode.enPixelFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
stVpssChnMode.u32Width = stSize->u32Width;
stVpssChnMode.u32Height = stSize->u32Height;
stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;
s32Ret = HI_MPI_VPSS_SetChnMode(VpssGrp, VpssChn, &stVpssChnMode);
if (HI_SUCCESS != s32Ret)
{
Printf("set vpss grp%d chn%d mode fail, s32Ret: 0x%x.\n", VpssGrp, VpssChn, s32Ret);
return s32Ret;
}
}
return HI_SUCCESS;
}
