static void video_InputInit() { // int i = 0; // init sdk { VI_PUB_ATTR_S stViDevAttr; VI_CHN_ATTR_S stViChnAttr; // vi0 1-16 ch cif input 1d1 // vi2 1-16 ch d1 input mutex d1 live //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// // vi0 stViDevAttr.enInputMode = VI_MODE_BT656; stViDevAttr.enWorkMode = VI_WORK_MODE_1D1; stViDevAttr.enViNorm = (VIDEO_IS_PAL() ? VIDEO_ENCODING_MODE_PAL : VIDEO_ENCODING_MODE_NTSC); // channel attribute stViChnAttr.stCapRect.s32X = 0; stViChnAttr.stCapRect.s32Y = 0; stViChnAttr.stCapRect.u32Width = VI_CIF_WIDTH; stViChnAttr.stCapRect.u32Height = 8 * VI_CIF_HEIGHT + 7 * 2; // half field height combo frame stViChnAttr.bChromaResample = HI_FALSE; stViChnAttr.enCapSel = VI_CAPSEL_BOTH; stViChnAttr.bDownScale = HI_FALSE; stViChnAttr.bHighPri = HI_FALSE; stViChnAttr.enViPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420; DVR_ASSERT(HI_MPI_VI_Disable(0)); DVR_ASSERT(HI_MPI_VI_SetPubAttr(0, &stViDevAttr)); DVR_ASSERT(HI_MPI_VI_Enable(0)); DVR_ASSERT(HI_MPI_VI_SetChnAttr(0, 0, &stViChnAttr)); DVR_ASSERT(HI_MPI_VI_EnableChn(0, 0)); DVR_ASSERT(HI_MPI_VI_SetSrcFrameRate(0, 0, MAX_CIF_LIVE_FPS)); DVR_ASSERT(HI_MPI_VI_SetFrameRate(0, 0, MAX_CIF_LIVE_FPS)); //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// // vi2 must be d1 stViChnAttr.enCapSel = VI_CAPSEL_BOTH; stViChnAttr.bDownScale = HI_FALSE; stViChnAttr.stCapRect.s32Y = 0; stViChnAttr.stCapRect.u32Height = VIDEO_IS_PAL() ? 288 : 240; stViChnAttr.bChromaResample = HI_FALSE; stViChnAttr.bHighPri = HI_FALSE; VI_CIF_ATTR_CONF(&stViChnAttr); // vi2 DVR_ASSERT(HI_MPI_VI_Disable(2)); DVR_ASSERT(HI_MPI_VI_SetPubAttr(2, &stViDevAttr)); DVR_ASSERT(HI_MPI_VI_Enable(2)); DVR_ASSERT(HI_MPI_VI_SetChnAttr(2, 0, &stViChnAttr)); DVR_ASSERT(HI_MPI_VI_EnableChn(2, 0)); DVR_ASSERT(HI_MPI_VI_SetSrcFrameRate(2, 0, MAX_D1_LIVE_FPS)); DVR_ASSERT(HI_MPI_VI_SetFrameRate(2, 0, MAX_D1_LIVE_FPS)); } }
HI_S32 PCIV_Slave_StartVi(PCIV_MSGHEAD_S *pMsg) { HI_S32 s32Ret; VI_DEV viDev; VI_CHN viChn; PCIV_VICMD_CREATE_S *pCmd = (PCIV_VICMD_CREATE_S *)pMsg->cMsgBody; PCIV_VICMD_ECHO_S *pCmdEcho = (PCIV_VICMD_ECHO_S *)pMsg->cMsgBody; /* Start the VI first */ viDev = pCmd->viDev; viChn = pCmd->viChn; s32Ret = HI_MPI_VI_SetChnAttr(viDev, viChn, &pCmd->stAttr); HI_ASSERT((HI_SUCCESS == s32Ret)); s32Ret = HI_MPI_VI_EnableChn(viDev, viChn); HI_ASSERT((HI_SUCCESS == s32Ret)); /* Echo the cmd */ pMsg->enMsgType = PCIV_MSGTYPE_CMDECHO; pMsg->enDevType = PCIV_DEVTYPE_VICHN; pMsg->u32Target = 0; pMsg->u32MsgLen = sizeof(PCIV_VICMD_ECHO_S); pCmdEcho->viDev = viDev; pCmdEcho->viChn = viChn; pCmdEcho->s32Echo = HI_SUCCESS; s32Ret = PCIV_SendMsg(0, PCIV_MSGPORT_USERCMD, pMsg); HI_ASSERT((HI_FAILURE != s32Ret)); return HI_SUCCESS; }
HI_S32 SampleEnableVi(VI_DEV ViDev,VI_CHN ViChn, VI_PUB_ATTR_S *pViPubAttr,VI_CHN_ATTR_S *pViChnAttr) { HI_S32 s32Ret; s32Ret = HI_MPI_VI_SetPubAttr(ViDev, pViPubAttr); if (HI_SUCCESS != s32Ret) { printf("set VI attribute failed 0x%x!\n",s32Ret); return HI_FAILURE; } s32Ret = HI_MPI_VI_SetChnAttr(ViDev, ViChn, pViChnAttr); if (HI_SUCCESS != s32Ret) { printf("set VI Chn attribute failed 0x%x!\n",s32Ret); return HI_FAILURE; } s32Ret = HI_MPI_VI_Enable(ViDev); if (HI_SUCCESS != s32Ret) { printf("set VI enable failed 0x%x!\n",s32Ret); return HI_FAILURE; } s32Ret = HI_MPI_VI_EnableChn(ViDev, ViChn); if (HI_SUCCESS != s32Ret) { printf("set VI Chn enable failed 0x%x!\n",s32Ret); return HI_FAILURE; } return HI_SUCCESS; }
/***************************************************************************** * function : star vi chn *****************************************************************************/ static HI_S32 s32ViStartChn(VI_CHN ViChn, VI_ATTR_S * pstViAttr) { HI_S32 s32Ret; VI_CHN_ATTR_S * pstChnAttr; if (NULL == pstViAttr) { printf("Func %s() Line[%d], parament is null\n", __FUNCTION__, __LINE__); return HI_FAILURE; } pstChnAttr = pstViAttr->pstChnAttr; s32Ret = HI_MPI_VI_SetChnAttr(ViChn, pstChnAttr); if (s32Ret != HI_SUCCESS) { printf("failed with %#x!\n", s32Ret); return HI_FAILURE; } s32Ret = HI_MPI_VI_EnableChn(ViChn); if (s32Ret != HI_SUCCESS) { printf("failed with %#x!\n", s32Ret); return HI_FAILURE; } return HI_SUCCESS; }
HI_S32 SampleEnableVi4HD1(HI_VOID) { HI_U32 i,j; VI_PUB_ATTR_S ViAttr; VI_CHN_ATTR_S ViChnAttr; memset(&ViAttr,0,sizeof(VI_PUB_ATTR_S)); memset(&ViChnAttr,0,sizeof(VI_CHN_ATTR_S)); ViAttr.enInputMode = VI_MODE_BT656; ViAttr.enWorkMode = VI_WORK_MODE_2D1; ViChnAttr.bDownScale = HI_FALSE; ViChnAttr.bHighPri = 0; ViChnAttr.enCapSel = VI_CAPSEL_BOTTOM; ViChnAttr.enViPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420; ViChnAttr.stCapRect.s32X = 0; ViChnAttr.stCapRect.s32Y = 0; ViChnAttr.stCapRect.u32Width = 704; ViChnAttr.stCapRect.u32Height = 288; for(i=0;i<2;i++) { if (HI_SUCCESS!=HI_MPI_VI_SetPubAttr(i,&ViAttr)) { printf("HI_MPI_VI_SetPubAttr faild!\n"); return HI_FAILURE; } if (HI_SUCCESS!=HI_MPI_VI_Enable(i)) { printf("HI_MPI_VI_Enable faild!\n"); return HI_FAILURE; } for(j=0;j<2;j++) { if (HI_SUCCESS!=HI_MPI_VI_SetChnAttr(i,j,&ViChnAttr)) { printf("HI_MPI_VI_SetChnAttr faild!\n"); return HI_FAILURE; } if (HI_SUCCESS!=HI_MPI_VI_EnableChn(i,j)) { printf("HI_MPI_VI_EnableChn faild!\n"); return HI_FAILURE; } } } return HI_SUCCESS; }
static void video_InputInit() { int i = 0, ii = 0; // init sdk { int nDev = 0; int nChnCnt = 0; VI_PUB_ATTR_S stViDevAttr; VI_CHN_ATTR_S stViChnAttr; int const vi_fps = (VIDEO_IS_PAL() ? 25 : 30); // vi0 1-4 ch cif input 4d1 // vi2 5-8 ch d1 input 4d1 // device attributes stViDevAttr.enInputMode = VI_MODE_BT656; stViDevAttr.enWorkMode = VI_WORK_MODE_4D1; stViDevAttr.enViNorm = (VIDEO_IS_PAL() ? VIDEO_ENCODING_MODE_PAL : VIDEO_ENCODING_MODE_NTSC); // channel attributes stViChnAttr.stCapRect.s32Y = 0; stViChnAttr.stCapRect.u32Height = (VIDEO_IS_PAL() ? 288 : 240); stViChnAttr.bHighPri = HI_FALSE; stViChnAttr.bChromaResample = HI_FALSE; stViChnAttr.enViPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420; VI_CIF_ATTR_CONF(&stViChnAttr); for(ii = 0; ii < MAX_CAM_CH; ii += 4) { if(VIMAP_Get(ii, &nDev, NULL) < 0) { continue; } DVR_ASSERT(HI_MPI_VI_Disable(nDev)); DVR_ASSERT(HI_MPI_VI_SetPubAttr(nDev, &stViDevAttr)); DVR_ASSERT(HI_MPI_VI_Enable(nDev)); for(i = 0; i < 4; ++i) { if(nChnCnt++ < MAX_D1_CNT){ VI_D1_ATTR_CONF(&stViChnAttr); }else{ VI_CIF_ATTR_CONF(&stViChnAttr); } DVR_ASSERT(HI_MPI_VI_SetChnAttr(nDev, i, &stViChnAttr)); DVR_ASSERT(HI_MPI_VI_EnableChn(nDev, i)); DVR_ASSERT(HI_MPI_VI_SetSrcFrameRate(nDev, i, vi_fps)); DVR_ASSERT(HI_MPI_VI_SetFrameRate(nDev, i, vi_fps)); } } } }
/***************************************************************************** * 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; }
static void video_InputInit() { int ii, jj; VI_PUB_ATTR_S stViDevAttr; VI_CHN_ATTR_S stViChnAttr; // vi0 1-4 ch cif input 4d1 // vi1 5-8 ch cif input 4d1 // vi2 9-12 ch cif input 4d1 // vi3 13-16 ch cif input 4d1 //////////////////////////////////////////////////////////////// // vi stViDevAttr.enInputMode = VI_MODE_BT656; stViDevAttr.enWorkMode = VI_WORK_MODE_4D1; stViDevAttr.enViNorm = (VIDEO_IS_PAL() ? VIDEO_ENCODING_MODE_PAL : VIDEO_ENCODING_MODE_NTSC); // 4d1 input stViChnAttr.stCapRect.u32Width = 704; stViChnAttr.stCapRect.u32Height = VI_CIF_HEIGHT; stViChnAttr.stCapRect.s32X = VI_X_OFFSET; stViChnAttr.stCapRect.s32Y = 0; stViChnAttr.bChromaResample = HI_FALSE; stViChnAttr.enCapSel = VO_FIELD_BOTTOM; stViChnAttr.bDownScale = HI_TRUE; stViChnAttr.bHighPri = HI_FALSE; stViChnAttr.enViPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420; for(ii = 0; ii < 4; ii ++) { // interface DVR_ASSERT(HI_MPI_VI_Disable(ii)); DVR_ASSERT(HI_MPI_VI_SetPubAttr(ii, &stViDevAttr)); DVR_ASSERT(HI_MPI_VI_Enable(ii)); for(jj = 0; jj < 4; jj ++) { DVR_ASSERT(HI_MPI_VI_SetChnAttr(ii, jj, &stViChnAttr)); DVR_ASSERT(HI_MPI_VI_EnableChn(ii, jj)); DVR_ASSERT(HI_MPI_VI_SetSrcFrameRate(ii, jj, MAX_CIF_LIVE_FPS)); DVR_ASSERT(HI_MPI_VI_SetFrameRate(ii, jj, MAX_CIF_LIVE_FPS)); } } }
HI_S32 PCIV_Test_Slave_StartVi(VI_DEV viDev, VI_CHN viChn) { HI_S32 s32Ret; VI_PUB_ATTR_S ViAttr; VI_CHN_ATTR_S ViChnAttr; memset(&ViAttr,0,sizeof(VI_PUB_ATTR_S)); memset(&ViChnAttr,0,sizeof(VI_CHN_ATTR_S)); ViAttr.enInputMode = VI_MODE_BT656; ViAttr.enWorkMode = VI_WORK_MODE_2D1; ViAttr.u32AdType = AD_2815; ViAttr.enViNorm = VIDEO_ENCODING_MODE_PAL; ViChnAttr.stCapRect.u32Width = 704; ViChnAttr.stCapRect.u32Height = 288; ViChnAttr.stCapRect.s32X = 8; ViChnAttr.stCapRect.s32Y = 0; ViChnAttr.enCapSel = VI_CAPSEL_BOTTOM; ViChnAttr.bDownScale = HI_TRUE; ViChnAttr.bChromaResample = HI_FALSE; ViChnAttr.enViPixFormat = PCIV_TEST_VI_PIXEL_FORMAT; /* VI device may be enabled, so we don't care the result */ HI_MPI_VI_SetPubAttr(viDev, &ViAttr); HI_MPI_VI_Enable(viDev); s32Ret = HI_MPI_VI_SetChnAttr(viDev, viChn, &ViChnAttr); HI_ASSERT(HI_SUCCESS == s32Ret); s32Ret = HI_MPI_VI_EnableChn(viDev, viChn); HI_ASSERT(HI_SUCCESS == s32Ret); return 0; }
int main(int argc, char const *argv[]) { PAYLOAD_TYPE_E enPayLoad = PT_H264; VB_CONF_S stVbConf; SAMPLE_VI_CONFIG_S stViConfig; VPSS_GRP_ATTR_S stVpssGrpAttr; VPSS_CHN_ATTR_S stVpssChnAttr; VPSS_CHN_MODE_S stVpssChnMode; VI_EXT_CHN_ATTR_S stExtChnAttr; SAMPLE_RC_E enRcMode = SAMPLE_RC_CBR; HI_S32 s32ChnNum = 1; HI_S32 s32Ret = HI_SUCCESS; HI_U32 u32BlkSize; SIZE_S stSize; int sockfd, SendSockfd; struct sockaddr_in SendServaddr; pthread_t sendvideotid, AnalyzePictid, snaptid, accepttid; int ret; MPP_CHN_S stSrcChn; MPP_CHN_S stDestChn; memset(&stVbConf, 0 , sizeof(VB_CONF_S)); stVbConf.u32MaxPoolCnt = 128; u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm, enSize, SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH); stVbConf.astCommPool[0].u32BlkSize = u32BlkSize; stVbConf.astCommPool[0].u32BlkCnt = 10; // u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm, // PIC_QVGA, SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH); // stVbConf.astCommPool[0].u32BlkSize = u32BlkSize; // stVbConf.astCommPool[0].u32BlkCnt = 10; //初始化系统 printf("-----------------------V0.01-----------------------\n"); s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf); if (HI_SUCCESS != s32Ret) { printf("system init failed with err code %#x!\n", s32Ret ); } stViConfig.enViMode = SENSOR_TYPE; //stViConfig.enViMode = SONY_IMX122_DC_1080P_30FPS; stViConfig.enRotate = ROTATE_NONE; stViConfig.enNorm = VIDEO_ENCODING_MODE_AUTO; stViConfig.enViChnSet = VI_CHN_SET_NORMAL; //配置并启动VI s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig); if (HI_SUCCESS != s32Ret) { printf("start vi failed with err code %#x!\n", s32Ret); goto END_1; } stExtChnAttr.enPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420; stExtChnAttr.s32BindChn = ViChn; stExtChnAttr.stDestSize.u32Width = WIDTH; stExtChnAttr.stDestSize.u32Height = HEIGHT; stExtChnAttr.s32FrameRate = -1; stExtChnAttr.s32SrcFrameRate = -1; s32Ret = HI_MPI_VI_SetExtChnAttr(ExtChn, &stExtChnAttr); if (HI_SUCCESS != s32Ret) { printf("HI_MPI_VI_SetExtChnAttr failed with err code %#x\n", s32Ret); return -1; } s32Ret = HI_MPI_VI_SetFrameDepth(1, 5); if (HI_SUCCESS != s32Ret) { printf("HI_MPI_VI_SetFrameDepth failed with err code %#x\n", s32Ret); return -1; } s32Ret = HI_MPI_VI_EnableChn(ExtChn); if (HI_SUCCESS != s32Ret) { printf("HI_MPI_VI_EnableChn failed with err code %#x\n", s32Ret); return -1; } stExtChnAttr.enPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420; stExtChnAttr.s32BindChn = ViChn; stExtChnAttr.stDestSize.u32Width = WIDTH; stExtChnAttr.stDestSize.u32Height = HEIGHT; stExtChnAttr.s32FrameRate = -1; stExtChnAttr.s32SrcFrameRate = -1; s32Ret = HI_MPI_VI_SetExtChnAttr(SnapExtChn, &stExtChnAttr); if (HI_SUCCESS != s32Ret) { printf("HI_MPI_VI_SetExtChnAttr failed with err code %#x\n", s32Ret); return -1; } s32Ret = HI_MPI_VI_EnableChn(SnapExtChn); if (HI_SUCCESS != s32Ret) { printf("HI_MPI_VI_EnableChn failed with err code %#x\n", s32Ret); return -1; } #if 1 s32Ret = SAMPLE_COMM_SYS_GetPicSize(gs_enNorm, enSize, &stSize); if (HI_SUCCESS != s32Ret) { printf("SAMPLE_COMM_SYS_GetPicSize failed with err code %#x!\n", s32Ret); goto END_2; } //配置并启动VPSS组 stVpssGrpAttr.u32MaxW = stSize.u32Width; stVpssGrpAttr.u32MaxH = stSize.u32Height; stVpssGrpAttr.bDrEn = HI_FALSE; stVpssGrpAttr.bDbEn = HI_FALSE; stVpssGrpAttr.bIeEn = HI_TRUE; stVpssGrpAttr.bNrEn = HI_TRUE; stVpssGrpAttr.bHistEn = HI_TRUE; stVpssGrpAttr.enDieMode = VPSS_DIE_MODE_AUTO; stVpssGrpAttr.enPixFmt = SAMPLE_PIXEL_FORMAT; s32Ret = SAMPLE_COMM_VPSS_StartGroup(VpssGrp, &stVpssGrpAttr); if (HI_SUCCESS != s32Ret) { printf("SAMPLE_COMM_VPSS_StartGroup failed with err code %#x!\n", s32Ret); goto END_3; } //绑定VI和VPSS s32Ret = SAMPLE_COMM_VI_BindVpss(stViConfig.enViMode); if (HI_SUCCESS != s32Ret) { printf("SAMPLE_COMM_vi_BindVpss failed with err code %#x\n", s32Ret); goto END_4; } //配置并启动VPSS通道 memset(&stVpssChnAttr, 0, sizeof(stVpssChnAttr)); stVpssChnAttr.bFrameEn = HI_FALSE; stVpssChnAttr.bSpEn = HI_TRUE; stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER; stVpssChnMode.bDouble = HI_FALSE; stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT; stVpssChnMode.u32Width = 1920; stVpssChnMode.u32Height = 1080; s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL); if (HI_SUCCESS != s32Ret) { printf("SAMPLE_COMM_VPSS_EnableChn failed with err code %#x\n", s32Ret); goto END_5; } #if 0 s32Ret = SAMPLE_COMM_VENC_BindVpss(SnapVencGrp, VpssGrp, VpssChn); if (HI_SUCCESS != s32Ret) { printf("SAMPLE_COMM_VENC_BindVpss failed with err code %#x\n", s32Ret); } gs_enNorm = PIC_D1; s32Ret = SAMPLE_COMM_SYS_GetPicSize(gs_enNorm, enSize, &stSize); if (HI_SUCCESS != s32Ret) { printf("SAMPLE_COMM_SYS_GetPicSize failed with err code %#x\n", s32Ret); } #endif #endif stSrcChn.enModId = HI_ID_VIU; stSrcChn.s32DevId = 0; stSrcChn.s32ChnId = SnapExtChn; stDestChn.enModId = HI_ID_GROUP; stDestChn.s32DevId = SnapVencGrp; stDestChn.s32ChnId = 0; s32Ret = HI_MPI_SYS_Bind(&stSrcChn, &stDestChn); if (s32Ret != HI_SUCCESS) { SAMPLE_PRT("failed with %#x!\n", s32Ret); //return HI_FAILURE; } stSize.u32Width = 720; stSize.u32Height = 576; //printf("%d,%d\n",stSize.u32Width,stSize.u32Height); s32Ret = SAMPLE_COMM_VENC_SnapStart(SnapVencGrp, SnapVencChn, &stSize); if (HI_SUCCESS != s32Ret) { printf("SAMPLE_COMM_VENC_SnapStart failed with err code %#x\n", s32Ret); } #if 1 #if 0 //创建发送视频流socket //SendSockfd = socket(AF_INET, SOCK_STREAM, 0); SendSockfd = socket(AF_INET, SOCK_DGRAM, 0); if (SendSockfd == -1) { perror("send socket error"); exit(0); } memset(&SendServaddr, 0, sizeof(SendServaddr)); SendServaddr.sin_family = AF_INET; //SendServaddr.sin_addr.s_addr = htonl(INADDR_ANY); SendServaddr.sin_addr.s_addr = inet_addr("10.1.2.60"); SendServaddr.sin_port = htons(6666); #endif #if 0 if (bind(SendSockfd, (struct sockaddr *)&SendServaddr, sizeof(SendServaddr)) == -1) { perror("send bind error"); exit(0); } if (listen(SendSockfd, 10) == -1) { perror("send listen error"); exit(0); } #endif #if 0 //ret = pthread_create(&sendvideotid, 0, (HI_VOID*)SendVideoStream, SendSockfd); ret = pthread_create(&sendvideotid, 0, (HI_VOID*)SendVideoStream, 0); if (ret != 0) { perror("create SendVideoStream error"); exit(0); } printf("create SendVideoStream thread successfully!\n"); #endif #endif ret = pthread_create(&AnalyzePictid, 0, (HI_VOID*)AnalyzePic, NULL); if (ret != 0) { perror("create AnalyzePic error"); exit(0); } ret = pthread_create(&snaptid, 0, (HI_VOID*)SnapPic, NULL); if (ret != 0) { perror("create SnapPic error"); exit(0); } ret = pthread_create(&accepttid, 0, (HI_VOID*)accept_thread, NULL); if (ret != 0) { perror("create accept_thread error"); exit(0); } while (1) { sleep(10); } END_5: SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn); END_4: SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode); END_3: SAMPLE_COMM_VPSS_StopGroup(VpssGrp); END_2: SAMPLE_COMM_VI_StopVi(&stViConfig); END_1: SAMPLE_COMM_SYS_Exit(); close(SendSockfd); pthread_join(sendvideotid, NULL); return 0; }
/****************************************************************************** * function : VI: DC(720P); VO: SD0(CVBS). Embeded isp, one ExtChn preview. ******************************************************************************/ HI_S32 SAMPLE_VIO_720P_Extchn_Preview(SAMPLE_VI_CONFIG_S* pstViConfig) { HI_U32 u32ViChnCnt = 2; VB_CONF_S stVbConf; VO_DEV VoDev = SAMPLE_VO_DEV_DSD0;; VO_CHN VoChn = 0; VI_CHN ViChn = 0; VO_PUB_ATTR_S stVoPubAttr; SAMPLE_VO_MODE_E enVoMode = VO_MODE_1MUX; HI_S32 s32Ret = HI_SUCCESS; HI_U32 u32BlkSize; SIZE_S stSize; VI_EXT_CHN_ATTR_S stExtChnAttr; VI_CHN ExtChn = 1; PIC_SIZE_E enPicSize = g_enPicSize; /****************************************** step 1: init global variable ******************************************/ gs_u32ViFrmRate = (VIDEO_ENCODING_MODE_PAL == gs_enNorm)? 25: 30; memset(&stVbConf,0,sizeof(VB_CONF_S)); u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm, enPicSize, SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH); stVbConf.u32MaxPoolCnt = 128; /*ddr0 video buffer*/ stVbConf.astCommPool[0].u32BlkSize = u32BlkSize; stVbConf.astCommPool[0].u32BlkCnt = u32ViChnCnt * 8; u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm, PIC_D1, SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH); stVbConf.astCommPool[1].u32BlkSize = u32BlkSize; stVbConf.astCommPool[1].u32BlkCnt = 8; /****************************************** step 2: mpp system init. ******************************************/ s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("system init failed with %d!\n", s32Ret); goto END_720P_0; } /****************************************** step 3: start vi dev & chn to capture ******************************************/ s32Ret = SAMPLE_COMM_VI_StartVi(pstViConfig); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("start vi failed!\n"); goto END_720P_0; } stExtChnAttr.enPixFormat = SAMPLE_PIXEL_FORMAT; stExtChnAttr.s32BindChn = ViChn; stExtChnAttr.stDestSize.u32Width = 720; stExtChnAttr.stDestSize.u32Height = 576; stExtChnAttr.s32FrameRate = -1; stExtChnAttr.s32SrcFrameRate = -1; s32Ret = HI_MPI_VI_SetExtChnAttr(ExtChn, &stExtChnAttr); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("HI_MPI_VI_SetExtChnAttr failed!\n"); goto END_720P_0; } s32Ret = HI_MPI_VI_EnableChn(ExtChn); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("HI_MPI_VI_EnableChn failed!\n"); goto END_720P_0; } /****************************************** step 4: start vpss and vi bind vpss (subchn needn't bind vpss in this mode) ******************************************/ s32Ret = SAMPLE_COMM_SYS_GetPicSize(gs_enNorm, enPicSize, &stSize); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n"); goto END_720P_1; } /****************************************** step 5: start VO SD0 (bind * vi ) ******************************************/ stVoPubAttr.enIntfType = g_enVoIntfType; if(VO_INTF_BT1120 == g_enVoIntfType) { stVoPubAttr.enIntfSync = VO_OUTPUT_720P50; } else { stVoPubAttr.enIntfSync = VO_OUTPUT_PAL; } stVoPubAttr.u32BgColor = 0x000000ff; /* In HD, this item should be set to HI_FALSE */ stVoPubAttr.bDoubleFrame = HI_FALSE; s32Ret = SAMPLE_COMM_VO_StartDevLayer(VoDev, &stVoPubAttr, gs_u32ViFrmRate); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("SAMPLE_COMM_VO_StartDevLayer failed!\n"); goto END_720P_1; } s32Ret = SAMPLE_COMM_VO_StartChn(VoDev, &stVoPubAttr, enVoMode); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("SAMPLE_COMM_VO_StartChn failed!\n"); goto END_720P_2; } s32Ret = SAMPLE_COMM_VO_BindVi(VoDev, VoChn, ExtChn); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("SAMPLE_COMM_VO_BindVi(vo:%d)-(vichn:%d) failed with %#x!\n", VoDev, VoChn, s32Ret); goto END_720P_3; } VI_PAUSE(); /****************************************** step 6: exit process ******************************************/ END_720P_3: SAMPLE_COMM_VO_UnBindVi(VoDev,VoChn); SAMPLE_COMM_VO_StopChn(VoDev, enVoMode); END_720P_2: SAMPLE_COMM_VO_StopDevLayer(VoDev); END_720P_1: s32Ret = HI_MPI_VI_DisableChn(ExtChn); SAMPLE_COMM_VI_StopVi(pstViConfig); END_720P_0: SAMPLE_COMM_SYS_Exit(); return s32Ret; }
HI_S32 SampleInitViMScreen(HI_U32 ScreenCnt) { HI_U32 i,j,tmp; ScreenCnt = (ScreenCnt == 9 ? 8 : ScreenCnt); VI_PUB_ATTR_S ViAttr; VI_CHN_ATTR_S ViChnAttr[ScreenCnt]; memset(&ViAttr, 0, sizeof(VI_PUB_ATTR_S)); memset(ViChnAttr, 0, ScreenCnt * sizeof(VI_CHN_ATTR_S)); ViAttr.enInputMode = VI_MODE_BT656; ViAttr.enWorkMode = VI_WORK_MODE_2D1; switch (ScreenCnt) { case 1 : { ViChnAttr[0].bDownScale = HI_FALSE; ViChnAttr[0].bHighPri = 0; ViChnAttr[0].enCapSel = VI_CAPSEL_BOTH; ViChnAttr[0].enViPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420; ViChnAttr[0].stCapRect.s32X = 0; ViChnAttr[0].stCapRect.s32Y = 0; ViChnAttr[0].stCapRect.u32Width = g_u32ScreenWidth; ViChnAttr[0].stCapRect.u32Height = g_u32ScreenHeight/2; break; } case 4 : /* fall through */ case 8 : { for (i = 0; i < ScreenCnt; i++) { ViChnAttr[i].bDownScale = HI_TRUE; ViChnAttr[i].bHighPri = 0; ViChnAttr[i].enCapSel = VI_CAPSEL_BOTTOM; ViChnAttr[i].enViPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420; ViChnAttr[i].stCapRect.s32X = 0; ViChnAttr[i].stCapRect.s32Y = 0; ViChnAttr[i].stCapRect.u32Width = g_u32ScreenWidth; ViChnAttr[i].stCapRect.u32Height = g_u32ScreenHeight/2; } break; } default: printf("Unsupport screen num %d!\n", ScreenCnt); return HI_FAILURE; } if (1 == ScreenCnt) { tmp = 1; }else { tmp = ScreenCnt/2; } for (i = 0; i < tmp; i++) { if (HI_SUCCESS != HI_MPI_VI_SetPubAttr(i, &ViAttr)) { return HI_FAILURE; } if (HI_SUCCESS != HI_MPI_VI_Enable(i)) { return HI_FAILURE; } for(j = 0; j < 2; j++) { if (HI_SUCCESS != HI_MPI_VI_SetChnAttr(i,j,&ViChnAttr[i*2+j])) { return HI_FAILURE; } if (HI_SUCCESS != HI_MPI_VI_EnableChn(i,j)) { return HI_FAILURE; } } } return HI_SUCCESS; }
int main(int argc, char const *argv[]) { VI_EXT_CHN_ATTR_S stExtChnAttr; VB_BLK hBlock; VB_POOL hPool = VB_INVALID_POOLID; HI_S32 s32Ret = HI_SUCCESS; HI_U32 u32BlkSize, u32DstBlkSize; VIDEO_FRAME_INFO_S FrameInfo; IVE_HANDLE IveHandle; IVE_SRC_IMAGE_S stSrc; IVE_DST_IMAGE_S stDst; IVE_CSC_CTRL_S stCscCtrl; HI_BOOL bInstant = HI_TRUE; HI_BOOL bFinish; IplImage *iplImage; FILE *fp,*fp2; int k=1; #if 0 memset(&stVbConf, 0, sizeof(VB_CONF_S)); stVbConf.u32MaxPoolCnt = 128; SAMPLE_COMM_VI_GetSizeBySensor(&enSize); u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm, enSize, SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH); stVbConf.astCommPool[0].u32BlkSize = u32BlkSize; stVbConf.astCommPool[0].u32BlkCnt = 12; s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf); if (HI_SUCCESS != s32Ret) { printf("system init failed with err code %#x!\n", s32Ret ); } stViConfig.enViMode = SENSOR_TYPE; stViConfig.enRotate = ROTATE_NONE; stViConfig.enNorm = VIDEO_ENCODING_MODE_AUTO; stViConfig.enViChnSet = VI_CHN_SET_NORMAL; s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig); if (HI_SUCCESS != s32Ret) { printf("start vi failed with err code %#x!\n", s32Ret); // goto END_1; } #endif iplImage = cvCreateImageHeader(cvSize(WIDTH,HEIGHT), IPL_DEPTH_8U, 3); stExtChnAttr.enPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420; stExtChnAttr.s32BindChn = ViChn; stExtChnAttr.stDestSize.u32Width = WIDTH; stExtChnAttr.stDestSize.u32Height = HEIGHT; stExtChnAttr.s32DstFrameRate = -1; stExtChnAttr.s32SrcFrameRate = -1; stExtChnAttr.enCompressMode = COMPRESS_MODE_NONE; HI_MPI_VI_DisableChn(ExtChn); s32Ret = HI_MPI_VI_SetExtChnAttr(ExtChn, &stExtChnAttr); if (HI_SUCCESS != s32Ret) { printf("HI_MPI_VI_SetExtChnAttr failed with err code %#x\n", s32Ret); return -1; } s32Ret = HI_MPI_VI_SetFrameDepth(ExtChn, 1); if (HI_SUCCESS != s32Ret) { printf("HI_MPI_VI_SetFrameDepth failed with err code %#x\n", s32Ret); return -1; } stSrc.enType = IVE_IMAGE_TYPE_YUV420SP; //stDst.enType = IVE_IMAGE_TYPE_U8C3_PLANAR; stDst.enType = IVE_IMAGE_TYPE_U8C3_PACKAGE; stCscCtrl.enMode = IVE_CSC_MODE_PIC_BT709_YUV2RGB; #if 1 s32Ret = HI_MPI_VI_EnableChn(ExtChn); if (HI_SUCCESS != s32Ret) { printf("HI_MPI_VI_EnableChn failed with err code %#x\n", s32Ret); return -1; } #endif printf("begin\n"); det_t *pdet = det_open("bd_detect_trace.config"); while(k) { s32Ret = HI_MPI_VI_GetFrame(ExtChn, &FrameInfo, -1); if(HI_SUCCESS != s32Ret) { printf("HI_MPI_VI_GetFrame failed with err code %#x!\n",s32Ret); } printf("get frame!\n"); u32DstBlkSize = FrameInfo.stVFrame.u32Stride[0] * FrameInfo.stVFrame.u32Height * 3; s32Ret = HI_MPI_SYS_MmzAlloc_Cached(&stDst.u32PhyAddr[0],(void**) &stDst.pu8VirAddr[0], "user", HI_NULL, u32DstBlkSize); HI_MPI_SYS_MmzFlushCache(stDst.u32PhyAddr[0], (void *)stDst.pu8VirAddr[0], u32DstBlkSize); #if 0 stDst.u32PhyAddr[1] = stDst.u32PhyAddr[0] + FrameInfo.stVFrame.u32Stride[0] * FrameInfo.stVFrame.u32Height; stDst.u32PhyAddr[2] = stDst.u32PhyAddr[1] + FrameInfo.stVFrame.u32Stride[0] * FrameInfo.stVFrame.u32Height; stDst.pu8VirAddr[0] = (HI_U8*) HI_MPI_SYS_Mmap(stDst.u32PhyAddr[0], u32DstBlkSize); stDst.pu8VirAddr[1] = stDst.pu8VirAddr[0] + FrameInfo.stVFrame.u32Stride[0] * FrameInfo.stVFrame.u32Height; stDst.pu8VirAddr[2] = stDst.pu8VirAddr[1] + FrameInfo.stVFrame.u32Stride[0] * FrameInfo.stVFrame.u32Height; stDst.u16Stride[0] = FrameInfo.stVFrame.u32Stride[0]; stDst.u16Stride[1] = FrameInfo.stVFrame.u32Stride[0]; stDst.u16Stride[2] = FrameInfo.stVFrame.u32Stride[0]; stDst.u16Width = FrameInfo.stVFrame.u32Width; stDst.u16Height = FrameInfo.stVFrame.u32Height; #endif #if 1 stDst.pu8VirAddr[0] = (HI_U8*) HI_MPI_SYS_Mmap(stDst.u32PhyAddr[0], u32DstBlkSize); stDst.u16Stride[0] = FrameInfo.stVFrame.u32Stride[0]; stDst.u16Width = FrameInfo.stVFrame.u32Width; stDst.u16Height = FrameInfo.stVFrame.u32Height; #endif stSrc.u32PhyAddr[0] = FrameInfo.stVFrame.u32PhyAddr[0]; stSrc.u32PhyAddr[1] = FrameInfo.stVFrame.u32PhyAddr[1]; stSrc.u32PhyAddr[2] = FrameInfo.stVFrame.u32PhyAddr[2]; stSrc.pu8VirAddr[0] = (HI_U8*)HI_MPI_SYS_Mmap(FrameInfo.stVFrame.u32PhyAddr[0], u32DstBlkSize / 2); stSrc.pu8VirAddr[1] = stSrc.pu8VirAddr[0] + FrameInfo.stVFrame.u32Stride[0] * FrameInfo.stVFrame.u32Height; stSrc.pu8VirAddr[2] = stSrc.pu8VirAddr[1] + 1; stSrc.u16Stride[1] = FrameInfo.stVFrame.u32Stride[0]; stSrc.u16Stride[0] = FrameInfo.stVFrame.u32Stride[0]; stSrc.u16Stride[2] = 0; stSrc.u16Width = FrameInfo.stVFrame.u32Width; stSrc.u16Height = FrameInfo.stVFrame.u32Height; #if 0 for(k = 0; k < 720 * 576 * 3 / 2;k++) *(stSrc.pu8VirAddr[0] + k) = 130; k = 0; #endif s32Ret = HI_MPI_IVE_CSC(&IveHandle, &stSrc, &stDst, &stCscCtrl, bInstant); if(s32Ret != HI_SUCCESS) { printf("HI_MPI_IVE_CSC failed with error code %#x\n",s32Ret); continue; } s32Ret = HI_MPI_IVE_Query(IveHandle, &bFinish, HI_TRUE); if(s32Ret != HI_SUCCESS) { printf("HI_MPI_IVE_Query failed with error code %#x\n",s32Ret); continue; } #if 0 fp = fopen("image.rgb","wb"); fwrite(stDst.pu8VirAddr[0], WIDTH * HEIGHT * 3, 1, fp); fclose(fp); fp2 = fopen("image2.yuv","wb"); fwrite(stSrc.pu8VirAddr[0], WIDTH * HEIGHT * 3 / 2, 1, fp2); fclose(fp2); #endif //printf("u16Width:%d,u16Height:%d\n",stDst.u16Width,stDst.u16Height); //printf("widthStep:%d\n",iplImage->widthStep); //cvSetData(iplImage, stDst.pu8VirAddr[0], iplImage->widthStep); //cvSaveImage("saveImage.jpg",iplImage); char *str = det_detect(pdet, HEIGHT, WIDTH, (char *)stDst.pu8VirAddr[0]); printf("%s\n",str); HI_MPI_SYS_Munmap(stDst.pu8VirAddr[0], u32DstBlkSize); HI_MPI_SYS_Munmap(stSrc.pu8VirAddr[0], u32DstBlkSize / 2); HI_MPI_SYS_MmzFree(stDst.u32PhyAddr[0], NULL); HI_MPI_VI_ReleaseFrame(ExtChn, &FrameInfo); } det_close(pdet); }
static void video_InputInit() { int i = 0; // init sdk { VI_PUB_ATTR_S stViDevAttr; VI_CHN_ATTR_S stViChnAttr; // vi0 1-16 ch cif input 1d1 // vi1 1-16 ch selecting input 1d1 // vi2 17-20 ch d1 input 4d1 // vi3 21-24 ch d1 input 4d1 //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// // vi0 stViDevAttr.enInputMode = VI_MODE_BT656; stViDevAttr.enWorkMode = VI_WORK_MODE_1D1; stViDevAttr.enViNorm = (VIDEO_IS_PAL() ? VIDEO_ENCODING_MODE_PAL : VIDEO_ENCODING_MODE_NTSC); // channel attribute stViChnAttr.stCapRect.s32X = 0; stViChnAttr.stCapRect.s32Y = 0; stViChnAttr.stCapRect.u32Width = VI_CIF_WIDTH; stViChnAttr.stCapRect.u32Height = 8 * VI_CIF_HEIGHT + 7 * 2; // half field height combo frame stViChnAttr.bChromaResample = HI_FALSE; stViChnAttr.enCapSel = VI_CAPSEL_BOTH; stViChnAttr.bDownScale = HI_FALSE; stViChnAttr.bHighPri = HI_FALSE; stViChnAttr.enViPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420; DVR_ASSERT(HI_MPI_VI_Disable(0)); DVR_ASSERT(HI_MPI_VI_SetPubAttr(0, &stViDevAttr)); DVR_ASSERT(HI_MPI_VI_Enable(0)); DVR_ASSERT(HI_MPI_VI_SetChnAttr(0, 0, &stViChnAttr)); DVR_ASSERT(HI_MPI_VI_EnableChn(0, 0)); DVR_ASSERT(HI_MPI_VI_SetSrcFrameRate(0, 0, MAX_CIF_LIVE_FPS)); //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// // vi1 stViDevAttr.enInputMode = VI_MODE_BT656; stViDevAttr.enWorkMode = VI_WORK_MODE_1D1; stViDevAttr.enViNorm = (VIDEO_IS_PAL() ? VIDEO_ENCODING_MODE_PAL : VIDEO_ENCODING_MODE_NTSC); // channel attribute stViChnAttr.stCapRect.u32Width = 704; stViChnAttr.stCapRect.u32Height = VI_CIF_HEIGHT; stViChnAttr.stCapRect.s32X = 8; stViChnAttr.stCapRect.s32Y = 0; stViChnAttr.bChromaResample = HI_FALSE; stViChnAttr.enCapSel = VI_CAPSEL_BOTH; stViChnAttr.bDownScale = HI_FALSE; stViChnAttr.bHighPri = HI_FALSE; stViChnAttr.enViPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420; // interface DVR_ASSERT(HI_MPI_VI_Disable(1)); DVR_ASSERT(HI_MPI_VI_SetPubAttr(1, &stViDevAttr)); DVR_ASSERT(HI_MPI_VI_Enable(1)); DVR_ASSERT(HI_MPI_VI_SetChnAttr(1, 0, &stViChnAttr)); DVR_ASSERT(HI_MPI_VI_EnableChn(1, 0)); DVR_ASSERT(HI_MPI_VI_SetSrcFrameRate(1, 0, MAX_D1_LIVE_FPS)); //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// // vi2 stViDevAttr.enInputMode = VI_MODE_BT656; stViDevAttr.enWorkMode = VI_WORK_MODE_4D1; stViDevAttr.enViNorm = (VIDEO_IS_PAL() ? VIDEO_ENCODING_MODE_PAL : VIDEO_ENCODING_MODE_NTSC); // cif input stViChnAttr.stCapRect.u32Width = 704; stViChnAttr.stCapRect.u32Height = VI_CIF_HEIGHT; stViChnAttr.stCapRect.s32X = 8; stViChnAttr.stCapRect.s32Y = 0; stViChnAttr.bChromaResample = HI_FALSE; stViChnAttr.enCapSel = VI_CAPSEL_BOTTOM; stViChnAttr.bDownScale = HI_TRUE; stViChnAttr.bHighPri = HI_FALSE; stViChnAttr.enViPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420; // interface DVR_ASSERT(HI_MPI_VI_Disable(2)); DVR_ASSERT(HI_MPI_VI_SetPubAttr(2, &stViDevAttr)); DVR_ASSERT(HI_MPI_VI_Enable(2)); for(i = 0; i < 4; ++i){ DVR_ASSERT(HI_MPI_VI_SetChnAttr(2, i, &stViChnAttr)); DVR_ASSERT(HI_MPI_VI_EnableChn(2, i)); DVR_ASSERT(HI_MPI_VI_SetSrcFrameRate(2, i, MAX_CIF_LIVE_FPS)); } //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// // vi3 stViDevAttr.enInputMode = VI_MODE_BT656; stViDevAttr.enWorkMode = VI_WORK_MODE_4D1; stViDevAttr.enViNorm = (VIDEO_IS_PAL() ? VIDEO_ENCODING_MODE_PAL : VIDEO_ENCODING_MODE_NTSC); // cif input stViChnAttr.stCapRect.u32Width = 704; stViChnAttr.stCapRect.u32Height = VI_CIF_HEIGHT; stViChnAttr.stCapRect.s32X = 8; stViChnAttr.stCapRect.s32Y = 0; stViChnAttr.bChromaResample = HI_FALSE; stViChnAttr.enCapSel = VI_CAPSEL_BOTTOM; stViChnAttr.bDownScale = HI_TRUE; stViChnAttr.bHighPri = HI_FALSE; stViChnAttr.enViPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420; // interface DVR_ASSERT(HI_MPI_VI_Disable(3)); DVR_ASSERT(HI_MPI_VI_SetPubAttr(3, &stViDevAttr)); DVR_ASSERT(HI_MPI_VI_Enable(3)); for(i = 0; i < 4; ++i){ DVR_ASSERT(HI_MPI_VI_SetChnAttr(3, i, &stViChnAttr)); DVR_ASSERT(HI_MPI_VI_EnableChn(3, i)); DVR_ASSERT(HI_MPI_VI_SetSrcFrameRate(3, i, MAX_CIF_LIVE_FPS)); } } }
/***************************************************************************** * function : star vi chn *****************************************************************************/ HI_S32 SAMPLE_COMM_VI_StartChn(VI_CHN ViChn, RECT_S *pstCapRect, SIZE_S *pstTarSize, SAMPLE_VI_CONFIG_S* pstViConfig) { HI_S32 s32Ret; VI_CHN_ATTR_S stChnAttr; ROTATE_E enRotate = ROTATE_NONE; SAMPLE_VI_CHN_SET_E enViChnSet = VI_CHN_SET_NORMAL; if (pstViConfig) { enViChnSet = pstViConfig->enViChnSet; enRotate = pstViConfig->enRotate; } /* step 5: config & start vicap dev */ memcpy(&stChnAttr.stCapRect, pstCapRect, sizeof(RECT_S)); 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 = HI_FALSE; stChnAttr.bFlip = HI_FALSE; switch (enViChnSet) { case VI_CHN_SET_MIRROR: stChnAttr.bMirror = HI_TRUE; break; case VI_CHN_SET_FLIP: stChnAttr.bFlip = HI_TRUE; break; case VI_CHN_SET_FLIP_MIRROR: stChnAttr.bMirror = HI_TRUE; stChnAttr.bFlip = HI_TRUE; break; default: break; } stChnAttr.bChromaResample = HI_FALSE; stChnAttr.s32SrcFrameRate = 30; stChnAttr.s32FrameRate = 30; s32Ret = HI_MPI_VI_SetChnAttr(ViChn, &stChnAttr); if (s32Ret != HI_SUCCESS) { SAMPLE_PRT("failed with %#x!\n", s32Ret); return HI_FAILURE; } if (ROTATE_NONE != enRotate) { s32Ret = HI_MPI_VI_SetRotate(ViChn, enRotate); if (s32Ret != HI_SUCCESS) { SAMPLE_PRT("HI_MPI_VI_SetRotate 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; }
/***************************************************************************** * function : star vi according to product type * only for Hi3520D MixCap *****************************************************************************/ HI_S32 SAMPLE_COMM_VI_MixCap_Start(SAMPLE_VI_MODE_E enViMode, VIDEO_NORM_E enNorm) { VI_DEV ViDev; VI_CHN ViChn; HI_S32 i; HI_S32 s32Ret; SAMPLE_VI_PARAM_S stViParam; VI_CHN_ATTR_S stChnAttr,stChnMinorAttr; /*** get parameter from Sample_Vi_Mode ***/ s32Ret = SAMPLE_COMM_VI_Mode2Param(enViMode, &stViParam); if (HI_SUCCESS !=s32Ret) { SAMPLE_PRT("vi get param failed!\n"); return HI_FAILURE; } /*** Start AD ***/ s32Ret = SAMPLE_COMM_VI_ADStart(enViMode, enNorm); if (HI_SUCCESS !=s32Ret) { SAMPLE_PRT("Start AD failed!\n"); return HI_FAILURE; } /*** Start VI Dev ***/ for(i=0; i<stViParam.s32ViDevCnt; i++) { ViDev = i * stViParam.s32ViDevInterval; s32Ret = SAMPLE_COMM_VI_StartDev(ViDev, enViMode); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("SAMPLE_COMM_VI_StartDev failed with %#x\n", s32Ret); return HI_FAILURE; } } /*** Start VI Chn ***/ for(i=0; i<stViParam.s32ViChnCnt; i++) { ViChn = i * stViParam.s32ViChnInterval; stChnAttr.stCapRect.s32X = 0; stChnAttr.stCapRect.s32Y = 0; stChnAttr.enCapSel = VI_CAPSEL_BOTH; stChnAttr.enPixFormat = SAMPLE_PIXEL_FORMAT; /* sp420 or sp422 */ stChnAttr.bMirror = HI_FALSE; stChnAttr.bFlip = HI_FALSE; stChnAttr.bChromaResample = HI_FALSE; stChnAttr.s32SrcFrameRate = -1; stChnAttr.s32FrameRate = -1; stChnAttr.stCapRect.u32Width= D1_WIDTH; stChnAttr.stCapRect.u32Height= (VIDEO_ENCODING_MODE_PAL==enNorm)?576:480; stChnAttr.stDestSize.u32Width= D1_WIDTH; stChnAttr.stDestSize.u32Height= (VIDEO_ENCODING_MODE_PAL==enNorm)?576:480; memcpy(&stChnMinorAttr, &stChnAttr, sizeof(VI_CHN_ATTR_S)); stChnMinorAttr.stDestSize.u32Width= D1_WIDTH / 2; stChnMinorAttr.stDestSize.u32Height= (VIDEO_ENCODING_MODE_PAL==enNorm)?576:480; stChnAttr.s32SrcFrameRate = (VIDEO_ENCODING_MODE_PAL== enNorm)?25:30; stChnAttr.s32FrameRate = 6; s32Ret = HI_MPI_VI_SetChnAttr(ViChn, &stChnAttr); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("call HI_MPI_VI_SetChnAttr failed with %#x\n", s32Ret); return HI_FAILURE; } s32Ret = HI_MPI_VI_SetChnMinorAttr(ViChn, &stChnMinorAttr); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("call HI_MPI_VI_SetChnMinorAttr failed with %#x\n", s32Ret); return HI_FAILURE; } s32Ret = HI_MPI_VI_EnableChn(ViChn); if (s32Ret != HI_SUCCESS) { SAMPLE_PRT("HI_MPI_VI_EnableChn failed with %#x!\n", s32Ret); return HI_FAILURE; } } return HI_SUCCESS; }
/****************************************************************************** * function : Start BT1120 720P vi/vo/venc ******************************************************************************/ HI_S32 SAMPLE_COMM_IVE_BT1120_720P_PreView(SAMPLE_IVE_VI_VO_CONFIG_S *pstViVoConfig, HI_BOOL bOpenVi,HI_BOOL bOpenViExt,HI_BOOL bOpenVo,HI_BOOL bOpenVenc,HI_BOOL bOpenVpss,HI_U32 u32VpssChnNum) { HI_U32 u32ViChnCnt = 1; VB_CONF_S stVbConf; VO_DEV VoDev = SAMPLE_VO_DEV_DSD0; VI_CHN ViChn = 0; VI_CHN ViExtChn = 1; VO_PUB_ATTR_S stVoPubAttr; SAMPLE_VO_MODE_E enVoMode = VO_MODE_1MUX; PIC_SIZE_E enPicSize = pstViVoConfig->enPicSize; VI_EXT_CHN_ATTR_S stExtChnAttr; HI_S32 s32Ret = HI_SUCCESS; HI_U32 u32BlkSize; SIZE_S stSize; VO_LAYER VoLayer = 0; VO_VIDEO_LAYER_ATTR_S stLayerAttr; SAMPLE_VI_CONFIG_S *pstViConfig = &(pstViVoConfig->stViConfig); VENC_CHN VencChn = 0; HI_U32 u32ViDepth = 4; VI_CHN_ATTR_S stChnAttr; HI_U32 u32VpssGrpCnt = 1; VPSS_CHN aVpssChn[2] = {VPSS_CHN0, VPSS_CHN3}; VPSS_GRP_ATTR_S stVpssGrpAttr; SIZE_S astSize[2]; memset(&stVbConf,0,sizeof(VB_CONF_S)); u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(pstViVoConfig->enNorm, enPicSize, SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH); stVbConf.u32MaxPoolCnt = 64; /*ddr0 video buffer*/ stVbConf.astCommPool[0].u32BlkSize = u32BlkSize; stVbConf.astCommPool[0].u32BlkCnt = u32ViChnCnt * 3; if ((HI_TRUE == bOpenViExt) || (HI_TRUE == bOpenVpss)) { u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(pstViVoConfig->enNorm,PIC_CIF, SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH); stVbConf.astCommPool[1].u32BlkSize = u32BlkSize; stVbConf.astCommPool[1].u32BlkCnt = 3; } // mpp system init. s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("SAMPLE_COMM_SYS_Init fail,Error(%#x)\n", s32Ret); goto END_720P_0; } if (HI_TRUE == bOpenVi) { s32Ret = SAMPLE_COMM_VI_StartVi(pstViConfig); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("SAMPLE_COMM_VI_StartVi fail,Error(%#x)\n",s32Ret); goto END_720P_0; } s32Ret = HI_MPI_VI_SetFrameDepth(ViChn,u32ViDepth); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("HI_MPI_VI_SetFrameDepth fail,ViChn(%d),Error(%#x)\n",ViChn,s32Ret); goto END_720P_1; } s32Ret = HI_MPI_VI_GetChnAttr(ViChn,&stChnAttr); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("HI_MPI_VI_GetChnAttr fail,ViChn(%d),Error(%#x)\n",ViChn,s32Ret); goto END_720P_1; } //Set Vi frame rate,because vi from BT1120 is 720P@30 stChnAttr.s32SrcFrameRate = 3; stChnAttr.s32DstFrameRate = 1; s32Ret = HI_MPI_VI_SetChnAttr(ViChn,&stChnAttr); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("HI_MPI_VI_SetChnAttr,ViChn(%d),Error(%#x)\n",ViChn,s32Ret); goto END_720P_1; } } //Open vi ext chn if (HI_TRUE == bOpenViExt) { stExtChnAttr.enPixFormat = SAMPLE_PIXEL_FORMAT; stExtChnAttr.s32BindChn = ViChn; stExtChnAttr.stDestSize.u32Width = 352; stExtChnAttr.stDestSize.u32Height = 288; stExtChnAttr.s32DstFrameRate = -1; stExtChnAttr.s32SrcFrameRate = -1; stExtChnAttr.enCompressMode = COMPRESS_MODE_NONE; s32Ret = HI_MPI_VI_SetExtChnAttr(ViExtChn, &stExtChnAttr); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("HI_MPI_VI_SetExtChnAttr fail,ViChn(%d),Error(%#x)\n",ViExtChn,s32Ret); goto END_720P_1; } s32Ret = HI_MPI_VI_EnableChn(ViExtChn); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("HI_MPI_VI_EnableChn fail,ViChn(%d),Error(%#x)\n",ViExtChn,s32Ret); goto END_720P_1; } s32Ret = HI_MPI_VI_SetFrameDepth(ViExtChn,u32ViDepth); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("HI_MPI_VI_SetFrameDepth fail,ViChn(%d),Error(%#x)\n",ViExtChn,s32Ret); goto END_720P_1; } } //Open vo if (HI_TRUE == bOpenVo) { s32Ret = SAMPLE_COMM_SYS_GetPicSize(pstViVoConfig->enNorm, enPicSize, &stSize); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize fail,Error(%#x)\n",s32Ret); goto END_720P_2; } stVoPubAttr.enIntfType = pstViVoConfig->enVoIntfType; //hi3518e Vo only suppurt pal //if(VO_INTF_BT1120 == pstViVoConfig->enVoIntfType) //{ // stVoPubAttr.enIntfSync = /*VO_OUTPUT_720P60*/VO_OUTPUT_1080P30; //} // if(SAMPLE_VI_MODE_BT1120_1080P == pstViVoConfig->stViConfig.enViMode) // { // stVoPubAttr.enIntfSync = VO_OUTPUT_1080P30; // } //else if(SAMPLE_VI_MODE_BT1120_720P == pstViVoConfig->stViConfig.enViMode) // { // stVoPubAttr.enIntfSync = VO_OUTPUT_720P60; // } // else { stVoPubAttr.enIntfSync = VO_OUTPUT_PAL; } stVoPubAttr.u32BgColor = 0x000000ff; /* In HD, this item should be set to HI_FALSE */ s32Ret = SAMPLE_COMM_VO_StartDev(VoDev, &stVoPubAttr); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("SAMPLE_COMM_VO_StartDevLayer fail,VoDev(%d),Error(%#x)!\n",VoDev,s32Ret); goto END_720P_2; } stLayerAttr.bClusterMode = HI_FALSE; stLayerAttr.bDoubleFrame = HI_FALSE; stLayerAttr.enPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420; memcpy(&stLayerAttr.stImageSize,&stSize,sizeof(stSize)); stLayerAttr.u32DispFrmRt = 60 ; stLayerAttr.stDispRect.s32X = 0; stLayerAttr.stDispRect.s32Y = 0; if((stVoPubAttr.enIntfSync == VO_OUTPUT_720P60) || (stVoPubAttr.enIntfSync == VO_OUTPUT_1080P30)) { stLayerAttr.stDispRect.u32Width = stSize.u32Width; stLayerAttr.stDispRect.u32Height = stSize.u32Height; } else if(stVoPubAttr.enIntfSync == VO_OUTPUT_PAL) { stLayerAttr.stDispRect.u32Width = 720; stLayerAttr.stDispRect.u32Height = 576; } s32Ret = SAMPLE_COMM_VO_StartLayer(VoLayer, &stLayerAttr, HI_TRUE); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("SAMPLE_COMM_VO_StartLayer fail,VoLayer(%d),Error(%#x)\n",VoLayer,s32Ret); goto END_720P_3; } s32Ret = SAMPLE_COMM_VO_StartChn(VoDev, enVoMode); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("SAMPLE_COMM_VO_StartChn fail,VoDev(%d),Error(%#x)\n",VoDev,s32Ret); goto END_720P_4; } } if (HI_TRUE == bOpenVenc) { s32Ret = SAMPLE_COMM_VENC_Start(VencChn, PT_H264, pstViVoConfig->enNorm, enPicSize, SAMPLE_RC_CBR,0); if(s32Ret != HI_SUCCESS) { SAMPLE_PRT("SAMPLE_COMM_VENC_Start fail,VencChn(%d),Error(%#x)\n",VencChn,s32Ret); goto END_720P_5; } s32Ret = SAMPLE_COMM_VENC_StartGetStream(1); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("SAMPLE_COMM_VENC_StartGetStream fail,Error(%#x)\n",s32Ret); goto END_720P_6; } } if (HI_TRUE == bOpenVpss) { s32Ret = SAMPLE_COMM_SYS_GetPicSize(pstViVoConfig->enNorm, enPicSize, &astSize[0]); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize fail,Error(%#x)\n",s32Ret); goto END_720P_6; } astSize[1].u32Width = 352; astSize[1].u32Height = 288; SAMPLE_COMM_IVE_VpssGrpAttr(u32VpssGrpCnt, &stVpssGrpAttr, &stSize); s32Ret = SAMPLE_COMM_IVE_VpssStart(u32VpssGrpCnt, astSize, aVpssChn, u32VpssChnNum, &stVpssGrpAttr); if (HI_SUCCESS != s32Ret) { SAMPLE_PRT("SAMPLE_COMM_IVE_VpssStart fail,Error(%#x)\n",s32Ret); goto END_720P_6; } } return s32Ret; //END_720P_7: //if (HI_TRUE == bOpenVpss) //{ // SAMPLE_COMM_IVE_StopVpss(u32VpssGrpCnt,u32VpssChnNum); //} END_720P_6: if (HI_TRUE == bOpenVenc) { SAMPLE_COMM_VENC_Stop(VencChn); } END_720P_5: if (HI_TRUE == bOpenVo) { SAMPLE_COMM_VO_StopChn(VoDev, enVoMode); } END_720P_4: if (HI_TRUE == bOpenVo) { SAMPLE_COMM_VO_StopLayer(VoLayer); } END_720P_3: if (HI_TRUE == bOpenVo) { SAMPLE_COMM_VO_StopDev(VoDev); } END_720P_2: if(HI_TRUE == bOpenViExt) { (HI_VOID)HI_MPI_VI_DisableChn(ViExtChn); } END_720P_1: if (HI_TRUE == bOpenVi) { SAMPLE_COMM_VI_StopVi(pstViConfig); } END_720P_0: SAMPLE_COMM_SYS_Exit(); return s32Ret; }