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