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_S32 main(int argc, char *argv[])
{
HI_S32 s32Ret;
VPSS_GRP_ATTR_S stVpssGrpAttr;
VPSS_CHN_ATTR_S stVpssChnAttr;
VPSS_GRP_PARAM_S stVpssGrpParam;
VPSS_CHN_SP_PARAM_S stChnSpParam;
VPSS_CHN_NR_PARAM_S stChnNrParam;
HI_U8 para[16];
HI_U32 value = 0;
VPSS_GRP VpssGrp = 0;
VPSS_CHN VpssChn = 0;
if (argc < 4)
{
USAGE_HELP();
return -1;
}
strcpy(para,argv[1]);
value = atoi(argv[2]);
VpssGrp = atoi(argv[3]);
if (5 == argc)
{
VpssChn = atoi(argv[4]);
}
s32Ret = HI_MPI_VPSS_GetGrpAttr(VpssGrp, &stVpssGrpAttr);
CHECK_RET(s32Ret, "HI_MPI_VPSS_GetGrpAttr");
s32Ret = HI_MPI_VPSS_GetChnAttr(VpssGrp, VpssChn, &stVpssChnAttr);
CHECK_RET(s32Ret, "HI_MPI_VPSS_GetChnAttr");
s32Ret = HI_MPI_VPSS_GetGrpParam(VpssGrp, &stVpssGrpParam);
CHECK_RET(s32Ret, "HI_MPI_VPSS_GetGrpParam");
s32Ret = HI_MPI_VPSS_GetChnSpParam(VpssGrp, VpssChn, &stChnSpParam);
CHECK_RET(s32Ret, "HI_MPI_VPSS_GetChnSpParam");
#ifndef HI_3518
s32Ret = HI_MPI_VPSS_GetChnNrParam(VpssGrp, VpssChn, &stChnNrParam);
CHECK_RET(s32Ret, "HI_MPI_VPSS_GetChnNrParam");
#endif
if (0 == strcmp(para, "enIE"))
{
stVpssGrpAttr.bIeEn = value;
}
else if (0 == strcmp(para, "enNR"))
{
stVpssGrpAttr.bNrEn = value;
}
else if (0 == strcmp(para, "enDEI"))
{
if (value > 2)
{
printf("invalid enDEI param %d\n", value);
return -1;
}
stVpssGrpAttr.enDieMode = (VPSS_DIE_MODE_E)value;
}
else if (0 == strcmp(para,"enHIST"))
{
stVpssGrpAttr.bHistEn = value;
}
else if (0 == strcmp(para, "ie"))
{
stVpssGrpParam.u32IeStrength = value;
}
else if (0 == strcmp(para, "iesp"))
{
stVpssGrpParam.u32IeSharp = value;
}
else if (0 == strcmp(para, "lum"))
{
stVpssGrpParam.u32Luminance = value;
}
else if (0 == strcmp(para, "con"))
{
stVpssGrpParam.u32Contrast = value;
}
else if (0 == strcmp(para, "de"))
{
stVpssGrpParam.u32DarkEnhance = value;
}
else if (0 == strcmp(para, "be"))
{
stVpssGrpParam.u32BrightEnhance = value;
}
else if (0 == strcmp(para, "dei"))
{
stVpssGrpParam.u32DiStrength = value;
}
#ifndef HI_3518
else if (0 == strcmp(para, "sf"))
{
stChnNrParam.u32SfStrength = value;
}
else if (0 == strcmp(para, "tf"))
{
stChnNrParam.u32TfStrength = value;
}
else if (0 == strcmp(para, "mt"))
{
stChnNrParam.u32MotionThresh = value;
}
else if (0 == strcmp(para, "cs"))
{
stChnNrParam.u32ChromaRange = value;
}
#else
else if (0 == strcmp(para, "sf"))
{
stVpssGrpParam.u32SfStrength = value;
}
else if (0 == strcmp(para, "tf"))
{
stVpssGrpParam.u32TfStrength = value;
}
else if (0 == strcmp(para, "mt"))
{
stVpssGrpParam.u32MotionThresh = value;
}
else if (0 == strcmp(para, "cs"))
{
stVpssGrpParam.u32ChromaRange = value;
}
#endif
else if (0 == strcmp(para, "enSP"))
{
stVpssChnAttr.bSpEn = value;
}
else if (0 == strcmp(para, "chnsp"))
{
stChnSpParam.u32LumaGain = value;
}
else
{
printf("err para\n");
USAGE_HELP();
}
s32Ret = HI_MPI_VPSS_SetGrpAttr(VpssGrp, &stVpssGrpAttr);
CHECK_RET(s32Ret, "HI_MPI_VPSS_SetGrpAttr");
s32Ret = HI_MPI_VPSS_SetChnAttr(VpssGrp, VpssChn, &stVpssChnAttr);
CHECK_RET(s32Ret, "HI_MPI_VPSS_SetChnAttr");
s32Ret = HI_MPI_VPSS_SetGrpParam(VpssGrp, &stVpssGrpParam);
CHECK_RET(s32Ret, "HI_MPI_VPSS_SetGrpParam");
s32Ret = HI_MPI_VPSS_SetChnSpParam(VpssGrp, VpssChn, &stChnSpParam);
CHECK_RET(s32Ret, "HI_MPI_VPSS_SetChnSpParam");
#ifndef HI_3518
s32Ret = HI_MPI_VPSS_SetChnNrParam(VpssGrp, VpssChn, &stChnNrParam);
CHECK_RET(s32Ret, "HI_MPI_VPSS_SetChnNrParam");
#endif
printf("\t\tenIE %d\n", stVpssGrpAttr.bIeEn);
printf("\t\tenNR %d\n", stVpssGrpAttr.bNrEn);
printf("\t\tenDEI %d\n", (stVpssGrpAttr.enDieMode == VPSS_DIE_MODE_NODIE)? 0:1);
printf("\t\tenHIST %d\n", stVpssGrpAttr.bHistEn);
printf("\t\tie %d\n", stVpssGrpParam.u32IeStrength);
printf("\t\tiesp %d\n", stVpssGrpParam.u32IeSharp);
printf("\t\tlum %d\n", stVpssGrpParam.u32Luminance);
printf("\t\tcon %d\n", stVpssGrpParam.u32Contrast);
printf("\t\tde %d\n", stVpssGrpParam.u32DarkEnhance);
printf("\t\tbe %d\n", stVpssGrpParam.u32BrightEnhance);
printf("\t\tdei %d\n", stVpssGrpParam.u32DiStrength);
#ifndef HI_3518
printf("\t\tsf %d\n", stChnNrParam.u32SfStrength);
printf("\t\ttf %d\n", stChnNrParam.u32TfStrength);
printf("\t\tmt %d\n", stChnNrParam.u32MotionThresh);
#else
printf("\t\tsf %d\n", stVpssGrpParam.u32SfStrength);
printf("\t\ttf %d\n", stVpssGrpParam.u32TfStrength);
printf("\t\tmt %d\n", stVpssGrpParam.u32MotionThresh);
printf("\t\tcs %d\n", stVpssGrpParam.u32ChromaRange);
#endif
printf("\t\tenSP %d\n", stVpssChnAttr.bSpEn);
printf("\t\tchnsp %d\n", stChnSpParam.u32LumaGain);
return 0;
}
/*****************************************************************************
* function : start vpss. VPSS chn with frame
*****************************************************************************/
HI_S32 SAMPLE_COMM_VPSS_Start(HI_S32 s32GrpCnt, SIZE_S *pstSize, HI_S32 s32ChnCnt,VPSS_GRP_ATTR_S *pstVpssGrpAttr)
{
VPSS_GRP VpssGrp;
VPSS_CHN VpssChn;
VPSS_GRP_ATTR_S stGrpAttr;
VPSS_CHN_ATTR_S stChnAttr;
VPSS_GRP_PARAM_S stVpssParam;
HI_S32 s32Ret;
HI_S32 i, j;
/*** Set Vpss Grp Attr ***/
if(NULL == pstVpssGrpAttr)
{
stGrpAttr.u32MaxW = pstSize->u32Width;
stGrpAttr.u32MaxH = pstSize->u32Height;
stGrpAttr.bDrEn = HI_FALSE;
stGrpAttr.bDbEn = HI_FALSE;
stGrpAttr.bIeEn = HI_TRUE;
stGrpAttr.bNrEn = HI_TRUE;
stGrpAttr.bHistEn = HI_FALSE;
stGrpAttr.enDieMode = VPSS_DIE_MODE_AUTO;
stGrpAttr.enPixFmt = SAMPLE_PIXEL_FORMAT;
}
else
{
memcpy(&stGrpAttr,pstVpssGrpAttr,sizeof(VPSS_GRP_ATTR_S));
}
for(i=0; i<s32GrpCnt; i++)
{
VpssGrp = i;
/*** create vpss group ***/
s32Ret = HI_MPI_VPSS_CreateGrp(VpssGrp, &stGrpAttr);
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;
}
/*** enable vpss chn, with frame ***/
for(j=0; j<s32ChnCnt; j++)
{
VpssChn = j;
/* Set Vpss Chn attr */
stChnAttr.bSpEn = HI_FALSE;
stChnAttr.bFrameEn = HI_TRUE;
stChnAttr.stFrame.u32Color[VPSS_FRAME_WORK_LEFT] = 0xff00;
stChnAttr.stFrame.u32Color[VPSS_FRAME_WORK_RIGHT] = 0xff00;
stChnAttr.stFrame.u32Color[VPSS_FRAME_WORK_BOTTOM] = 0xff00;
stChnAttr.stFrame.u32Color[VPSS_FRAME_WORK_TOP] = 0xff00;
stChnAttr.stFrame.u32Width[VPSS_FRAME_WORK_LEFT] = 2;
stChnAttr.stFrame.u32Width[VPSS_FRAME_WORK_RIGHT] = 2;
stChnAttr.stFrame.u32Width[VPSS_FRAME_WORK_TOP] = 2;
stChnAttr.stFrame.u32Width[VPSS_FRAME_WORK_BOTTOM] = 2;
s32Ret = HI_MPI_VPSS_SetChnAttr(VpssGrp, VpssChn, &stChnAttr);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VPSS_SetChnAttr failed with %#x\n", 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;
}
}
/*** start vpss group ***/
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_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;
}
