海思媒体处理平台VI视频输入模块

最新推荐文章于 2024-09-23 09:53:11 发布
最新推荐文章于 2024-09-23 09:53:11 发布
阅读量1.5w 收藏 87
点赞数 23
分类专栏： 音视频/流媒体/ffmpeg 文章标签： Hi3516A 海思媒体处理平台 Vi视频输入
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_17308321/article/details/80004319
版权

海思媒体处理平台VI视频输入模块

[Hi3516A||Vi视频输入||海思媒体处理平台]

文章目录

VI模块的概念

Vi是海思媒体处理平台的视频输入模块,负责捕获视频图像,可对其进行剪切、缩放等处理,并输出多路不同分辨率的图像数据.

VI模块的功能、作用、内部单元工作流程

硬件单元功能框图

Hi3516A/Hi3518EV200/Hi3519V200 VI硬件单元功能框图.

Alt text

VI可通过ITU-R BT656/601/1120 接口或 Digital Camera接口、 MIPI Rx(含 MIPI 接口、 LVDS 接口和 HISPI 接口)接收视频数据。
Vi还可以对接收到的原始视频图像数据进行裁剪(Crop)等处理,并实现一路原始视频图像输入,输出一路视频图像功能.

我们使用的是海思样例的SENSOR类型PANASONIC_MN34220_SUBLVDS_1080P_30FPS(传感器为松下的MN34220,采用SubLVDS的信号传输技术,使用1080P的分辨率,30帧率).

__MIPI__和__LVDS__的概念：
MIPI：移动产业处理器接口（Mobile Industry Processor Interface 简称MIPI）是为移动应用处理器制定的开放标准和一个规范。
LVDS：Low Voltage Differential Signaling，是一种低压差分信号技术接口。它是为克服以TTL电平方式传输宽带高码率数据时功耗大、EMI电磁干扰大等缺点而研制的一种数字视频信号传输方式,SubLVDS则是LVDS的发展.

VI内部单元工作流程

摄像机通过镜头(lens)聚焦光线,将光信号投射到 sensor 的感光区域,sensor经过光电转换，将 Bayer 格式的原始图像送给 ISP(Image Signal Processing 图像信号处理) 经过算法处理，输出 RGB 空间域的图像给后端的视频采集单元。在这个过程中，ISP 通过运行在其上的 firmware 对 lens 和 sensor 进行相应控制，进而完成自动光圈、自动曝光、自动白平衡等功能。其中，firmware 的运转靠视频采集单元的中断驱动。

ISP控制结构:

Alt text

VIU视频采集单元

VIU视频采集单元负责接收ISP传过来的视频图像,经过视频输入设备Dev0的加工,通过物理通道Chn0发送给接收者,也可通过扩展通道,进行缩放后发送出去.

视频输入设备Dev0:
Hi3516A/Hi3518EV200/Hi3519V100 芯片只有一个 VI 设备，即 Dev0。 Dev0 支持BT.656、 BT.601、 DC、 MIPI Rx（MIPI、 LVDS、 HISPI 接口）输入。 Dev0 不支持非连续 pixel clock 时序。

视频物理通道Chn0:
Hi3516A/Hi3518EV200/Hi3519V100 VI 硬件单元仅包含 1 个 VI 视频物理通道，即Chn0。不存在次通道，但支持扩展通道。

视频扩展通道ext_ChnN:
扩展通道是物理通道的扩展，主要实现缩放功能，其数据来源于物理通道，Hi3516A/Hi3518EV200/Hi3519V100 最多支持 16 个扩展通道。

参阅Api实现VI

下面程序是初始化Vi后直接绑定Vi到Venc编码的例子，没有写清理工作，已测试可以运行，可供参考.

main.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <pthread.h>
#include <string.h>
#include <fcntl.h>

#include "My_Head.h"

static pthread_t gs_IspPid;
static HI_S32 gs_s32SnapCnt = 0;

HI_VOID WB_VENC_HandleSig(HI_S32 signo)
{
	if(SIGINT == signo || SIGTERM == signo)
	{
		LOG_D("Interrupt Happen! exit\n");
	}
	exit(HI_FAILURE);
}

HI_S32 WB_MPI_SYS_Init()
{
	LOG_D("******************************************\n");
    LOG_D("step 1: Mpi System Init\n");
 	LOG_D("******************************************\n");
	HI_S32 s32Ret;
	VB_CONF_S struVbConf;
	MPP_SYS_CONF_S struSysConf = {0};

	memset(&struVbConf, 0, sizeof(VB_CONF_S));
	//memcpy(&struVbConf, &VB_SYS_CONF_BASE, sizeof(struVbConf));
	struVbConf.u32MaxPoolCnt = 128;
	struVbConf.astCommPool[0].u32BlkSize = 3159360;
	struVbConf.astCommPool[0].u32BlkCnt = 12;

	HI_MPI_SYS_Exit();
    HI_MPI_VB_Exit();

	s32Ret = HI_MPI_VB_SetConf(&struVbConf);
	if(HI_SUCCESS != s32Ret)
	{
		LOG_E("SetConf failed!\n");
		return s32Ret;
	}

	s32Ret = HI_MPI_VB_Init();
	if(HI_SUCCESS != s32Ret)
	{
		LOG_E("Vb Init failed!\n");
		return s32Ret;
	}

	struSysConf.u32AlignWidth = 64;
	/*set config of mpp system*/
	s32Ret = HI_MPI_SYS_SetConf(&struSysConf);
	if(HI_SUCCESS != s32Ret)
	{
		LOG_E("Set mpp sys config failed!\n");
		return s32Ret;
	}

	/*init system*/
	s32Ret = HI_MPI_SYS_Init();
	if(HI_SUCCESS != s32Ret)
	{
		LOG_E("Mpi sys init failed!\n");	
		return s32Ret;
	}

	LOG_D("******************************************\n");
    LOG_D("Mpi Sys Init Success\n");
 	LOG_D("******************************************\n");

	return HI_SUCCESS;
	/**/
}

HI_S32 WB_MIPI_Init()
{
	HI_S32 fd;
	combo_dev_attr_t* pstcomboDevAttr = NULL;
	fd = open("/dev/hi_mipi", O_RDWR);
	if( fd < 0)
	{
		LOG_W("open hi_mipi dev failed\n");
		return -1;
	}

	pstcomboDevAttr = &SUBLVDS_4lane_SENSOR_MN34220_12BIT_1080_NOWDR_ATTR;
	
	if (ioctl(fd, _IOW(HI_MIPI_IOC_MAGIC, 0x01, combo_dev_attr_t), pstcomboDevAttr))	
	{
		LOG_E("set mipi attr failed\n");
		close(fd);
		return HI_FAILURE;
	}
	close(fd);
	return HI_SUCCESS;
}

HI_S32 WB_Mpp_Vi_Init(HI_VOID)
{
	LOG_D("******************************************\n");
    LOG_D("step 2: Init vi dev and chn to capture\n");
 	LOG_D("******************************************\n");
	HI_S32 s32Ret;
	VI_DEV ViDev = 0;
	VI_CHN ViChn = 0;
	VI_DEV_ATTR_S stViDevAttr;
	VI_CHN_ATTR_S stChnAttr;
    ISP_WDR_MODE_S stWdrMode;

    memset(&stViDevAttr, 0, sizeof(stViDevAttr));
    memcpy(&stViDevAttr, &DEV_ATTR_LVDS_BASE, sizeof(stViDevAttr));
    stViDevAttr.stDevRect.s32X = 0;
    stViDevAttr.stDevRect.s32Y = 20;
    stViDevAttr.stDevRect.u32Width  = 1920;
    stViDevAttr.stDevRect.u32Height = 1080;
/*
	LOG_D("----%d\n",stViDevAttr.enIntfMode);
    LOG_D("----%d\n",stViDevAttr.enWorkMode);
    LOG_D("----%d\n",stViDevAttr.au32CompMask[0]);
    LOG_D("----%d\n",stViDevAttr.au32CompMask[1]);
    LOG_D("----%d\n",stViDevAttr.enScanMode);
    LOG_D("----%d\n",stViDevAttr.enDataSeq);
    LOG_D("----%d\n",stViDevAttr.enDataPath);
    LOG_D("----%d\n",stViDevAttr.enInputDataType);
    LOG_D("----%d\n",stViDevAttr.stDevRect.s32X);
    LOG_D("----%d\n",stViDevAttr.stDevRect.s32Y);
    LOG_D("----%d\n",stViDevAttr.stDevRect.u32Width);
    LOG_D("----%d\n",stViDevAttr.stDevRect.u32Height);
    LOG_D("----%d\n",stViDevAttr.bDataRev);
*/	
	s32Ret = HI_MPI_VI_SetDevAttr(ViDev, &stViDevAttr);
	if (s32Ret != HI_SUCCESS)
	{
	LOG_E("Set dev attributes failed with error code %#x!\n", s32Ret);
	return HI_FAILURE;
	}

    s32Ret = HI_MPI_ISP_GetWDRMode(0, &stWdrMode);
    if (s32Ret != HI_SUCCESS)
    {
        LOG_E("HI_MPI_ISP_GetWDRMode failed with %#x!\n", s32Ret);
        return HI_FAILURE;
    }

    if (stWdrMode.enWDRMode)  //wdr mode
    {
        VI_WDR_ATTR_S stWdrAttr;

        stWdrAttr.enWDRMode = stWdrMode.enWDRMode;
        stWdrAttr.bCompress = HI_FALSE;

        s32Ret = HI_MPI_VI_SetWDRAttr(0, &stWdrAttr);
        if (s32Ret)
        {
            LOG_E("HI_MPI_VI_SetWDRAttr failed with %#x!\n", s32Ret);
            return HI_FAILURE;
        }
    }

	s32Ret = HI_MPI_VI_EnableDev(ViDev);
	if (s32Ret != HI_SUCCESS)
	{
	LOG_E("Enable dev failed with error code %#x!\n", s32Ret);
	return HI_FAILURE;
	}

	stChnAttr.stCapRect.s32X = 0;
	stChnAttr.stCapRect.s32Y = 0;
	stChnAttr.stCapRect.u32Width = 1920;
	stChnAttr.stCapRect.u32Height = 1080;
	stChnAttr.stDestSize.u32Width = 1920;
	stChnAttr.stDestSize.u32Height = 1080;
	stChnAttr.enCapSel = VI_CAPSEL_BOTH;
	stChnAttr.enPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
	stChnAttr.bMirror = HI_FALSE;
	stChnAttr.bFlip = HI_FALSE;
	stChnAttr.s32SrcFrameRate = -1;
	stChnAttr.s32DstFrameRate = -1;
	stChnAttr.enCompressMode = COMPRESS_MODE_NONE;

/*
	LOG_D("----%d\n",stChnAttr.stCapRect.s32X);
    LOG_D("----%d\n",stChnAttr.stCapRect.s32Y);
    LOG_D("----%d\n",stChnAttr.stCapRect.u32Width);
    LOG_D("----%d\n",stChnAttr.stCapRect.u32Height);
    LOG_D("----%d\n",stChnAttr.stDestSize.u32Width );
    LOG_D("----%d\n",stChnAttr.stDestSize.u32Height );
    LOG_D("----%d\n",stChnAttr.enCapSel);
    LOG_D("----%d\n",stChnAttr.enPixFormat);
    LOG_D("----%d\n",stChnAttr.bMirror);
    LOG_D("----%d\n",stChnAttr.bFlip);
    LOG_D("----%d\n",stChnAttr.s32SrcFrameRate);
    LOG_D("----%d\n",stChnAttr.s32DstFrameRate);
    LOG_D("----%d\n",stChnAttr. enCompressMode);
*/
	s32Ret = HI_MPI_VI_SetChnAttr(ViChn,&stChnAttr);
	if (s32Ret != HI_SUCCESS)
	{
	LOG_E("Set chn attributes failed with error code %#x!\n", s32Ret);
	return HI_FAILURE;
	}

	s32Ret = HI_MPI_VI_EnableChn(ViChn);
	if (s32Ret != HI_SUCCESS)
	{
	LOG_E("Enable chn failed with error code %#x!\n", s32Ret);
	return HI_FAILURE;
	}

	LOG_D("******************************************\n");
    LOG_D("now, vi is capturing images\n");
 	LOG_D("******************************************\n");

 	return HI_SUCCESS;
 	/* now, vi is capturing images, you can do something else ... */
	/*s32Ret = HI_MPI_VI_DisableChn(ViChn);
	if (s32Ret != HI_SUCCESS)
	{
	LOG_D("Disable chn failed with error code %#x!\n", s32Ret);
	return HI_FAILURE;
	}
	s32Ret = HI_MPI_VI_DisableDev(ViDev);
	if (s32Ret != HI_SUCCESS)
	{
	LOG_D("Disable dev failed with error code %#x!\n", s32Ret);
	return HI_FAILURE;
	}*/

}

HI_S32 WB_MPI_VENC_Init()
{

	LOG_D("******************************************\n");
    LOG_D("step 3:  Create Venc Chn\n");
 	LOG_D("******************************************\n");

	HI_S32 s32Ret;
	VI_CHN ViChn = 0;
	VENC_CHN VencChn = 0;
	VENC_ATTR_JPEG_S stJpegAttr;	

	VENC_CHN_ATTR_S stVencChnAttr;
	MPP_CHN_S stSrcChn, stDestChn;

	stVencChnAttr.stVeAttr.enType = PT_JPEG;
	stJpegAttr.u32PicWidth = 1920;
	stJpegAttr.u32PicHeight = 1080;
	stJpegAttr.u32MaxPicWidth = 1920;
	stJpegAttr.u32MaxPicHeight = 1080;
	stJpegAttr.u32BufSize = 1920*1080*2;
	stJpegAttr.bByFrame = HI_TRUE;
	stJpegAttr.bSupportDCF = HI_FALSE;
	memcpy(&stVencChnAttr.stVeAttr.stAttrJpeg, &stJpegAttr, sizeof(VENC_ATTR_JPEG_S));

	s32Ret = HI_MPI_VENC_CreateChn(VencChn, &stVencChnAttr);
	if(HI_SUCCESS != s32Ret)
	{
		LOG_E("Hi Mpi Venc CreateChn Failed with %#x!\n", s32Ret);
		return s32Ret;
	}

	LOG_D("******************************************\n");
    LOG_D("step 4:  Start Recv Venc Pictures\n");
 	LOG_D("******************************************\n");

 	//s32Ret = HI_MPI_VENC_StartRecvPic(VencChn);
 	//if(HI_SUCCESS != s32Ret)
 	//{
 	//	LOG_E("Hi Mpi Venc Start Recv Failed with %#x!\n", s32Ret);
	//	return s32Ret;
 	//}

 	stSrcChn.enModId = HI_ID_VIU;
 	stSrcChn.s32DevId = 0;
 	stSrcChn.s32ChnId = ViChn;

 	stDestChn.enModId = HI_ID_VENC;
 	stDestChn.s32DevId = 0;
 	stDestChn.s32ChnId = 0;

 	s32Ret = HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);

	return HI_SUCCESS;
}

HI_S32 WB_VENC_SaveJpeg(FILE* pFile, VENC_STREAM_S* pstVencStream)
{
	VENC_PACK_S* pstData;
	HI_U32 i;

	for(i = 0; i < pstVencStream->u32PackCount; i++)
	{
		pstData = &pstVencStream->pstPack[i];
		fwrite(pstData->pu8Addr + pstData->u32Offset, pstData->u32Len - pstData->u32Offset, 1, pFile);
		fflush(pFile);
	}

	return HI_SUCCESS;
}

HI_S32 WB_Venc_SaveSnap(VENC_STREAM_S* pstVencStream)
{
	char acFile[FILE_NAME_LEN] = {0};
	FILE* pFile;
	HI_S32 s32Ret;

	snprintf(acFile, FILE_NAME_LEN, "Mysnap.jpg" );
	pFile = fopen(acFile, "wb");
	if(pFile == NULL)
	{
		LOG_E("open file error");
		return HI_FAILURE;
	}
	s32Ret = WB_VENC_SaveJpeg(pFile, pstVencStream);
	if(HI_SUCCESS != s32Ret)
	{
		LOG_E("save snap picture failed!\n");
		return HI_FAILURE;
	}
	fclose(pFile);
	gs_s32SnapCnt++;
	return HI_SUCCESS;

}

HI_S32 WB_VENC_GetVencSnapProc(VENC_CHN VencChn)
{
	LOG_D("******************************************\n");
    LOG_D("step 5:  Get Venc Snap Start\n");
 	LOG_D("******************************************\n");
 	sleep(2);

	HI_S32 s32Ret;
	//HI_S32 s32Cnt = 0;
	HI_S32 s32VencFd;
	fd_set read_fds;
	struct timeval timeout;
	VENC_STREAM_S stVencStream;
	VENC_CHN_STAT_S stVencChnStat;
	VENC_RECV_PIC_PARAM_S stRecvParam;

	//HI_CHAR aszFileName[VENC_MAX_CHN_NUM][64];
	//char szFilePostfix[10];

    stRecvParam.s32RecvPicNum = 1;
    s32Ret = HI_MPI_VENC_StartRecvPicEx(VencChn, &stRecvParam);
    if(HI_SUCCESS != s32Ret)
    {
    	LOG_E("HI_MPI_VENC_StartRecvPic faild with%#x!\n", s32Ret);
    }

	s32VencFd = HI_MPI_VENC_GetFd(VencChn);
	if(s32VencFd < 0)
	{
		LOG_E("HI_MPI Venc GetFd failed with %#x!\n", s32VencFd);
		return -1;
	}

	FD_ZERO(&read_fds);
	FD_SET(s32VencFd, &read_fds);

	timeout.tv_sec = 2;
	timeout.tv_usec = 0;

	LOG_D(" Venc GetFd is %d\n", s32VencFd);
	s32Ret = select(s32VencFd +1, &read_fds, NULL, NULL, &timeout);
	if(s32Ret < 0)
	{
		LOG_E("snap select failed!\n");
	}
	else if (s32Ret == 0)
	{
		LOG_E("Get Venc Stream time out !\n");
 		return s32Ret;
	}
	else
	{	
		if(FD_ISSET(s32VencFd, &read_fds))
		{
			s32Ret = HI_MPI_VENC_Query(VencChn, &stVencChnStat);
			if(HI_SUCCESS != s32Ret)
			{
			LOG_E("Mpi Venc Query failed with %#x!\n", s32Ret);
			return s32Ret;
			}

			if(0 == stVencChnStat.u32CurPacks)
			{
				LOG_E("NOTE: Current Frame is NULL!\n");
				return HI_SUCCESS;
			}

			stVencStream.pstPack = (VENC_PACK_S* )malloc(sizeof(VENC_PACK_S) * stVencChnStat.u32CurPacks);
			if(NULL == stVencStream.pstPack)
			{
				LOG_E("malloc memory failed!\n");
				return s32Ret;
			}

			stVencStream.u32PackCount = stVencChnStat.u32CurPacks;
			s32Ret = HI_MPI_VENC_GetStream(VencChn, &stVencStream, -1);
			if(HI_SUCCESS != s32Ret)
			{
				LOG_E("Hi Mpi Venc GetStream failed with %#x!\n", s32Ret);
				free(stVencStream.pstPack);
				stVencStream.pstPack = NULL;
				return s32Ret;
			}

			s32Ret = WB_Venc_SaveSnap(&stVencStream);
			if(HI_SUCCESS != s32Ret)
			{
				LOG_E("Venc SaveSnap failed with %#x!\n", s32Ret);
				free(stVencStream.pstPack);
				stVencStream.pstPack = NULL;
				return s32Ret;
			}

			s32Ret = HI_MPI_VENC_ReleaseStream(VencChn, &stVencStream);
			if(s32Ret)
			{
				LOG_E("Release Stream failed with %#x!\n",s32Ret);
				free(stVencStream.pstPack);
				stVencStream.pstPack = NULL;
				return s32Ret;
			}
			free(stVencStream.pstPack);
			stVencStream.pstPack = NULL;
		}
	}

    s32Ret = HI_MPI_VENC_StopRecvPic(VencChn);

    if (s32Ret != HI_SUCCESS)
    {
        LOG_E("MPI VENC StopRecvPic failed with %#x!\n",  s32Ret);
        return s32Ret;
    }


    return HI_SUCCESS;
}

void* WB_Isp_Run_Proc(void* arg)
{
	ISP_DEV IspDev = 0;
	HI_MPI_ISP_Run(IspDev);
	return HI_NULL;
}

HI_S32 WB_VENC_ISP_Init()
{
	ISP_DEV IspDev = 0;
	HI_S32 s32Ret;
	ISP_PUB_ATTR_S stPubAttr;
	ALG_LIB_S stLib;

	s32Ret = sensor_set_inifile_path("configs/");
	if(s32Ret != HI_SUCCESS)
	{
		LOG_E("set cmos iniparser file path failed with %#x!\n", s32Ret);
		return s32Ret;
	}

	s32Ret = sensor_register_callback();
	if(s32Ret != HI_SUCCESS)
	{
		LOG_E("sensor_register_callback failed with %#x!\n", s32Ret);
		return s32Ret;
	}

	stLib.s32Id = 0;
	strcpy(stLib.acLibName, HI_AE_LIB_NAME);
	s32Ret = HI_MPI_AE_Register(IspDev, &stLib);
	if(s32Ret != HI_SUCCESS)
	{
		LOG_E("HI_MPI_AE_Register failed!\n");
		return s32Ret;
	}

	stLib.s32Id = 0;
	strcpy(stLib.acLibName, HI_AWB_LIB_NAME);
	s32Ret = HI_MPI_AWB_Register(IspDev, &stLib);
	if(s32Ret != HI_SUCCESS)
	{
		LOG_E("HI_MPI_AWB Register failed!\n");
		return s32Ret;
	}

	stLib.s32Id = 0;
    strcpy(stLib.acLibName, HI_AF_LIB_NAME);
    s32Ret = HI_MPI_AF_Register(IspDev, &stLib);
    if (s32Ret != HI_SUCCESS)
    {
		LOG_E("HI_MPI_AF Register failed!\n");
        return s32Ret;
    }

	s32Ret = HI_MPI_ISP_MemInit(IspDev);
	if(s32Ret != HI_SUCCESS)
	{
		LOG_E("HI Mpi Isp Init failed!\n");
		return s32Ret;
	}

	ISP_WDR_MODE_S stWdrMode;
	stWdrMode.enWDRMode = WDR_MODE_NONE;
	s32Ret = HI_MPI_ISP_SetWDRMode(0, &stWdrMode);
	if(HI_SUCCESS != s32Ret)
	{
		LOG_E("start ISP WDR failed!\n");
		return s32Ret;
	}

	switch(SENSOR_TYPE)
	{
		case APTINA_9M034_DC_720P_30FPS:
		LOG_E("Wrong Sensor Type\n");
		break;

		case PANASONIC_MN34220_SUBLVDS_1080P_30FPS:
		stPubAttr.enBayer				= BAYER_GRBG;
		stPubAttr.f32FrameRate			= 30;
		stPubAttr.stWndRect.s32X		= 0;
		stPubAttr.stWndRect.s32Y		= 0;
		stPubAttr.stWndRect.u32Width	= 1920;
		stPubAttr.stWndRect.u32Height 	= 1080;
		break;
	}

	s32Ret = HI_MPI_ISP_SetPubAttr(IspDev, &stPubAttr);
	if(s32Ret != HI_SUCCESS)
	{
		LOG_E("Mpi Isp SetPubAttr failed with %#x!\n", s32Ret);
		return s32Ret;
	}
	s32Ret = HI_MPI_ISP_Init(IspDev);
	if(s32Ret != HI_SUCCESS)
	{
		LOG_E("Mpi ISP Init failed!\n");
	}

	if( 0 != pthread_create(&gs_IspPid, 0, (void * (*)(void *))WB_Isp_Run_Proc, NULL))
	{
		LOG_E("Create Isp Run thread failed!\n");
		return HI_FAILURE;
	}

	return HI_SUCCESS;

}


int main(int argc,char *argv[])
{
	HI_S32 s32Ret;

	signal(SIGINT, WB_VENC_HandleSig);
	signal(SIGTERM, WB_VENC_HandleSig);

	s32Ret = WB_MPI_SYS_Init();
	if(HI_SUCCESS != s32Ret)
	{
		LOG_E("Mpi sys init failed!\n");
		exit(-1);
	}

	LOG_D("******************************************\n");
    LOG_D("step 1~2:  WB_MIPI_Init start\n");
 	LOG_D("******************************************\n");
	
	s32Ret = WB_MIPI_Init();
	if(HI_SUCCESS != s32Ret)
	{
		LOG_E("MIPI init failed!\n");
		exit(-1);
	}

	LOG_D("******************************************\n");
    LOG_D("step 1~2:  WB_ISP_Init start\n");
 	LOG_D("******************************************\n");
	s32Ret = WB_VENC_ISP_Init();
	if(HI_SUCCESS != s32Ret)
	{
		LOG_E("ISP init failed!\n");
		exit(-1);
	}

	s32Ret = WB_Mpp_Vi_Init();
	if(HI_SUCCESS != s32Ret)
	{
		LOG_E("Mpi vi init failed!\n");
		exit(-1);
	}

	s32Ret = WB_MPI_VENC_Init();
	if(HI_SUCCESS != s32Ret)
	{
		LOG_E("Mpi venc init failed!\n");
		exit(-1);
	}

 	s32Ret = WB_VENC_GetVencSnapProc(0);
 	if(s32Ret != HI_SUCCESS)
 	{
 		LOG_E("GetVencSnapProc is Failed!\n");
 		return HI_FAILURE;
 	}

	getchar();

	exit(s32Ret);
}

My_Head.h

//#include <sys/time.h>

#include "hi_comm_venc.h"
#include "hi_type.h"
#include "hi_comm_vi.h"
#include "hi_comm_video.h"
#include "hi_comm_vb.h"
#include "hi_comm_sys.h"
#include "hi_mipi.h"
#include "hi_comm_3a.h"
#include "hi_comm_isp.h"
#include "hi_ae_comm.h"
#include "hi_sns_ctrl.h"
#include "hi_af_comm.h"
#include "hi_awb_comm.h"

#include "mpi_venc.h"
#include "mpi_sys.h"
#include "mpi_isp.h"
#include "mpi_af.h"
#include "mpi_vb.h"
#include "mpi_vi.h"
#include "mpi_ae.h"
#include "mpi_awb.h"

#include "sys/ioctl.h"

#define FILE_NAME_LEN 128

#define TRUE 1
#define FALSE 0

#define TAG "TEST"
#define DEBUG TRUE

/*
#define TIMEPRINT \
	do{\
	struct timeval now;\
	struct tm* ptime = NULL;\
	suseconds_t mstime;\
	\
	gettimeofday(&now, NULL);\
	ptime = gmtime(&now.tv_sec);\
	mstime = now.tv_usec/10000;\
	\
	printf("%d-%d-%d-%d-%d-%d:%02d  ", 1900 + ptime->tm_year, 1 + ptime->tm_mon, ptime->tm_mday, ptime->tm_hour, ptime->tm_min, ptime->tm_sec, mstime);\
	}while(0)
*/

#define TIMEPRINT 

#if DEBUG
#define LOG_D(...) \
		do{\
			TIMEPRINT\
			printf("D/%s ",TAG);\
			printf("(%s, %d): ", __FILE__,__LINE__);\
			printf(__VA_ARGS__);\
		}while(0)
#else
#define LOG_D(...) printf(__VA_ARGS__)
#endif

#if DEBUG
#define LOG_W(...) \
		do{\
			TIMEPRINT\
			printf("W/%s ",TAG);\
			printf("(%s, %d): ", __FILE__,__LINE__);\
			printf(__VA_ARGS__);\
		}while(0)
#else
#define LOG_W(...) printf(__VA_ARGS__)
#endif

#if DEBUG
#define LOG_E(...) \
		do{\
			TIMEPRINT\
			printf("E/%s ",TAG);\
			printf("(%s, %d): ", __FILE__,__LINE__);\
			printf(__VA_ARGS__);\
		}while(0)
#else
#define LOG_E(...) printf(__VA_ARGS__)
#endif

#if DEBUG
#define LOG_B(...) \
		do{\
			TIMEPRINT\
			printf("B/%s ",TAG);\
			printf("(%s, %d):", __FILE__,__LINE__);\
			printf(__VA_ARGS__);\
			getchar();\
		}while(0)
#else
#define LOG_B(...)  \
		do{\
			printf("Break Here!\n");\
			printf(__VA_ARGS__);\
			getchar();\
		}while(0)
#endif

typedef enum wb_vi_mode_e
{
    APTINA_AR0130_DC_720P_30FPS = 0,
    APTINA_9M034_DC_720P_30FPS,
    SAMPLE_VI_MODE_1_D1,
    SAMPLE_VI_MODE_BT1120_1080I,
    SAMPLE_VI_MODE_BT1120_720P,
    SAMPLE_VI_MODE_BT1120_1080P,
    PANASONIC_MN34220_SUBLVDS_1080P_30FPS,
    PANASONIC_MN34220_SUBLVDS_720P_120FPS,
    SONY_IMX178_LVDS_1080P_30FPS,
    SONY_IMX185_MIPI_1080P_30FPS,
    PANASONIC_MN34220_MIPI_1080P_30FPS,
    PANASONIC_MN34220_MIPI_720P_120FPS,
    SONY_IMX178_LVDS_5M_30FPS,
    SONY_IMX117_LVDS_1080P_30FPS,
    SONY_IMX117_LVDS_720P_30FPS,
    SONY_IMX123_LVDS_QXGA_30FPS,
    APTINA_AR0230_HISPI_1080P_30FPS,
    APTINA_AR0237_HISPI_1080P_30FPS,
    APTINA_AR0330_MIPI_1080P_30FPS,
    APTINA_AR0330_MIPI_1536P_25FPS,
    APTINA_AR0330_MIPI_1296P_25FPS,
    OMNIVISION_OV4689_MIPI_4M_30FPS,
    OMNIVISION_OV4689_MIPI_1080P_30FPS,
    OMNIVISION_OV5658_MIPI_5M_30FPS,
}Vi_Mode_E;

typedef struct VENC_GETSTREAMPARA_S
{
	HI_BOOL bTreadStart;
	HI_S32 s32Cnt;
}Venc_GetStreamPara_S;

VI_DEV_ATTR_S DEV_ATTR_LVDS_BASE =
{
    /* interface mode */
    VI_MODE_LVDS,
    /* multiplex mode */
    VI_WORK_MODE_1Multiplex,
    /* r_mask    g_mask    b_mask*/
    {0xFFF00000,    0x0},
    /* progessive or interleaving */
    VI_SCAN_PROGRESSIVE,
    /*AdChnId*/
    { -1, -1, -1, -1},
    /*enDataSeq, only support yuv*/
    VI_INPUT_DATA_YUYV,

    /* synchronization information */
    {
        /*port_vsync   port_vsync_neg     port_hsync        port_hsync_neg        */
        VI_VSYNC_PULSE, VI_VSYNC_NEG_LOW, VI_HSYNC_VALID_SINGNAL, VI_HSYNC_NEG_HIGH, VI_VSYNC_VALID_SINGAL, VI_VSYNC_VALID_NEG_HIGH,

        /*hsync_hfb    hsync_act    hsync_hhb*/
        {
            0,            1280,        0,
            /*vsync0_vhb vsync0_act vsync0_hhb*/
            0,            720,        0,
            /*vsync1_vhb vsync1_act vsync1_hhb*/
            0,            0,            0
        }
    },
    /* use interior ISP */
    VI_PATH_ISP,
    /* input data type */
    VI_DATA_TYPE_RGB,
    /* bRever */
    HI_FALSE,
    /* DEV CROP */
    {0, 0, 1920, 1080}
};

//VB_CONF_S VB_SYS_CONF_BASE =
//{
	/*Max Pool count*/
//	128,
	/*Vb Pool Stru*/
//	{
		/*BlkSize*/ 
//		3159360,
		/* BlkCnt  */
//		20
		/*acMmzName*/
//	}
//};

combo_dev_attr_t MIPI_4lane_SENSOR_MN34220_MIPI_12BIT_ATTR =
{
    .input_mode = INPUT_MODE_MIPI,
    {
        .mipi_attr =
        {
            RAW_DATA_12BIT,
            {0, 1, 2, 3, -1, -1, -1, -1}
        }
    }

};

combo_dev_attr_t SUBLVDS_4lane_SENSOR_MN34220_12BIT_1080_NOWDR_ATTR =
{
    /* input mode */
    .input_mode = INPUT_MODE_SUBLVDS,

    {
        .lvds_attr = {
            .img_size = {1920, 1080},
            HI_WDR_MODE_NONE,
            LVDS_SYNC_MODE_SOL,
            RAW_DATA_12BIT,
            LVDS_ENDIAN_BIG,
            LVDS_ENDIAN_BIG,
            .lane_id = {0, 2, -1, -1, 1, 3, -1, -1},
            .sync_code =  {
                {   {0x002, 0x003, 0x000, 0x001}, //PHY0_lane0
                    {0x202, 0x203, 0x200, 0x201},
                    {0x102, 0x103, 0x100, 0x101},
                    {0x302, 0x303, 0x300, 0x301}
                },

                {   {0x006, 0x007, 0x004, 0x005}, //PHY0_lane1
                    {0x206, 0x207, 0x204, 0x205},
                    {0x106, 0x107, 0x104, 0x105},
                    {0x306, 0x307, 0x304, 0x305}
                },

                {   {0x00a, 0x00b, 0x008, 0x009}, //PHY0_lane2
                    {0x20a, 0x20b, 0x208, 0x209},
                    {0x10a, 0x10b, 0x108, 0x109},
                    {0x30a, 0x30b, 0x308, 0x309}
                },

                {   {0x00a, 0x00b, 0x008, 0x009}, //PHY0_lane3  INPUT_MODE_LVDS
                    {0x20a, 0x20b, 0x208, 0x209},
                    {0x10a, 0x10b, 0x108, 0x109},
                    {0x30a, 0x30b, 0x308, 0x309}
                },

                {   {0x012, 0x013, 0x010, 0x011},//PHY1_lane0
                    {0x212, 0x213, 0x210, 0x211},
                    {0x112, 0x113, 0x110, 0x111},
                    {0x312, 0x313, 0x310, 0x311}
                },

                {   {0x016, 0x017, 0x014, 0x015}, //PHY1_lane1
                    {0x216, 0x217, 0x214, 0x215},
                    {0x116, 0x117, 0x114, 0x115},
                    {0x316, 0x317, 0x314, 0x315}
                },

                {   {0x01a, 0x01b, 0x018, 0x019}, //PHY1_lane2
                    {0x21a, 0x21b, 0x218, 0x219},
                    {0x11a, 0x11b, 0x118, 0x119},
                    {0x31a, 0x31b, 0x318, 0x319}
                },

                {   {0x01a, 0x01b, 0x018, 0x019}, //PHY1_lane3
                    {0x21a, 0x21b, 0x218, 0x219},
                    {0x11a, 0x11b, 0x118, 0x119},
                    {0x31a, 0x31b, 0x318, 0x319}
                }
            }
        }
    }
};

Makefile

#
#
#
#
SRC := $(wildcard *.c)
OBJ := $(SRC:%.c=%.o)
TARGET := sample
#CC :=gcc
CC := arm-hisiv300-linux-gcc

CFLAGS := -g -Wall -ldl -DSENSOR_TYPE=PANASONIC_MN34220_SUBLVDS_1080P_30FPS
CFLAGS += -I../include/
CFLAGS += -Dhi3516a -DHICHIP=0x3516A100 -DISP_V2 -DHI_MIPI_ENABLE -DHI_ACODEC_TYPE_INNER -mcpu=cortex-a7 -mfloat-abi=softfp -mfpu=neon-vfpv4 -ffunction-sections -mno-unaligned-access -fno-aggressive-loop-optimizations

MPILIB := ../lib/libmpi.a
ISPLIB := ../lib/libisp.a ../lib/lib_hiae.a
SENSORLIB := ../lib/libsns_mn34220.a 
AUDIO_LIBS :=../lib/libupvqe.a ../lib/libdnvqe.a ../lib/libVoiceEngine.a
OTHERLIB := ../lib/lib_hiawb.a ../lib/lib_hidefog.a ../lib/lib_hiaf.a

all: $(OBJ) $(TARGET)
$(TARGET):
	@echo "SRC is " $(SRC)
	@echo "OBJ is " $(OBJ)
	@echo "TARGET is " $(TARGET)
	$(CC) $(CFLAGS) $(OBJ) -lpthread -lm -o $(TARGET) $(ISPLIB) $(MPILIB) $(SENSORLIB) $(OTHERLIB) $(AUDIO_LIBS)

.PHONY: clean target
clean:
	rm -rf $(OBJ) $(TARGET)

target:
#@source /etc/profile
	rm -rf $(OBJ) $(TARGET)
	make

测试: ./sample
这里写图片描述

通过其他设置接口增加功能

我们已经实现了最简化的VI视频采集了，接着可以在此基础上通过其他设置接口进行更复杂功能的设计如HI_MPI_VI_SetExtChnCrop()进行裁剪、HI_MPI_VI_SetLDCAttr()设置 VI 镜头畸变校正（LDC）属性、HI_MPI_VI_SetCSCAttr()调节图像的亮度、色调、对比度、饱和度等等。

至此本文关于海思VI模块的学习就结束了，学习中会遇到很多音视频方面的东西，像隔行扫描制式，YUV颜色图像编码方法等等，这些还没有做详细的解释，如果有机会再追加写一篇关于这些音视频方面的知识。

青丶空゛
关注
专栏目录
HI3516A_V100R001C01SPC070 (含IMX178/IMX185/MN34220 PCB和原理图)
10-14
HI3516A_V100R001C01SPC070 (含IMX178/IMX185/MN34220 PCB和原理图) A7内核芯片Hi3516A HI3516D最新SPC070海思原厂SDK 版本， 支持H.265 包含软件资源 PCB图 原理图 (HI3516A是ORCAD格式的原理图，ALLEGRO格式的PCB图 ) 另含IMX178/IMX185和MN34220的原理图和PCB图( IMX178/IMX185和MN34220的原理图是PDF格式的，PCB图是ALLEGRO格式)
嵌入式视频方案学习第六篇——视频输入
笑傲江湖
05-23 4281
视频输入模块定义： 通过BT656/601/1120等接口采集视频数据，传送到内存区域的模块。可以对图像进行缩放，裁剪，翻转 常用接口： 1、设置VI设备属性 HI_S32 HI_MPI_VI_SetDevAttr(VI_DEV ViDev, const  VI_DEV_ATTR_S  *pstDevAttr) 参数：参数比较多具体参照文档说明，主要是VI的工作模式，接口模式等
Sony IMX334LQR-C 1/1.8寸 8.42 M像素
最新发布
芯片代理商，AI视觉从业者
09-23 1199
IMX334LQR-C是⼀个对⾓线8.86 mm（类型1/1.8）的cmos活动像素型固态图像传感器，带有。IMX334LQR是属于星光级别的，封装：128pin ceramic LGA,可⽤于监测⽅⾯，如安防监控摄像头、⼯业摄像头、360全景⾏车记录仪、索尼IMX334LQR宽动态超星光级交通监测CMOS 封装：LGA。此芯⽚使⽤模拟2.9v、数字1.2v和接⼝1.8v。读取模式：全尺⼨扫描/⾏合成/窗⼝截取/反向读取。⾼清录像、⽆⼈机、流媒体后视镜芯⽚等成像领域。⽅形像素阵列和8.42⽶有效像素。
海思编码：1、mpp系统详谈以及VI、VPSS、VENC之间的关系
qq_40170041的博客
04-14 5385
在HiMPP手册中都会有这么一张图。
海思Hi3519A MPP从入门到精通（三 视频输入）
Enjoy Coding
12-21 9230
视频输入(VI)模块实现的功能:通过 MIPI Rx(含 MIPI 接口、LVDS 接口和 HISPI 接 口),SLVS-EC,BT.1120,BT.656,BT.601,DC 等接口接收视频数据。VI 将接收到的数据存入到指定的内存区域,在此过程中,VI 可以对接收到的原始视频图像数据进行处理,实现视频数据的采集。 1. 模块划分 VI 在软件层次上划分了4 个部分： - 输入设备(DE...
海思多媒体(MPP)开发(2)——视频输入(VI)
Biao
03-25 1万+
前言： 海思多媒体处理平台(MPP)分为：视频输入(VI),视频处理(VPSS),视频编码(VENC),视频解码(VDEC),视频输出(VO)、视频侦测分析(VDA),音频输入(AI),音频输出(AO),音频编码(AENC),音频解码(ADEC),区域管理(REGION）等模块. 这里介绍视频输入模块(VI)。VI与AD密切相关，AD的输出模式必须与海思的VI先对应，AD的输出才能正确.........
海思HI35XX视频编解码代码
11-14
2. **视频输入模块（VI，Video Input）**： VI模块负责接收来自摄像头或其他视频源的数据，进行初步的信号处理，如去噪、同步信号检测等。该模块的代码可能涉及帧率控制、分辨率调整以及不同格式的视频流输入支持，...
海思3531A_HDMI输入.docx
01-28
海思3531A作为一款高性能的视频处理芯片，其HDMI输入功能是实现高质量视频传输的重要组成部分。本文将详细探讨海思3531A HDMI输入的调试方法及相关注意事项。 #### 二、调试步骤详解 ##### 1. 删除启动vi中的...
海思HiMPP视频编解码媒体处理软件V3.0开发文档.rar
08-17
视频输入模块（VI）是处理视频源的入口，它负责捕获和预处理来自各种设备（如摄像头）的原始视频数据。此模块支持多种视频格式和分辨率，开发者需要熟悉如何配置VI模块来正确读取和处理不同来源的视频流。 视频前...
海思 3518EV200 媒体模块API开发参考
12-23
在音视频开发方面，海思3518EV200芯片支持多种媒体处理功能，包括但不限于音频和视频的编解码、数据流处理、视频输入输出接口操作等。这些操作都涉及到相应API的调用。例如，文档中提到了VI（Video Input）相关的API...
mpp_海思rtsp_rtsp_海思_rtspmpp_h264_
10-02
RTSP-MPP可能是指海思的多媒体处理平台（Media Processing Platform）的一个组件，专门针对RTSP协议进行了优化。MPP可能是一个软件框架，包含了一系列模块，如编码、解码、流处理等，支持开发者快速构建多媒体应用...
海思3531DV100视频输入模块
baidu_39256460的博客
04-28 1619
海思3531DV100视频输入模块（VI） VI 可以对接收到的原始视频图像数据进行裁剪（Crop）、水平垂直缩小（Down Scaling）和水平垂直翻转（Mirror、Flip）等处理，并实现一路或多路原始视频图像输入，输出一路或多路视频图像功能。 视频输入设备支持标准 BT.656、标准 BT.1120、自定义时序等若干种时序输入，负责对时序进行解析。 Hi3531DV100 芯片有 5 个 BT.1120 接口，除第 5 个 BT.1120 接口外，每个 BT.1120 接口依次对应两个 VI 设备
海思平台的视频输入（VI）模块的介绍（以hi3559av100为例）
热门推荐
仗劍走天涯
09-18 1万+
当前是从海思平台的mpp角度理解VI这一部分的。 视频输入（VI）模块实现的功能：通过 MIPI Rx(含 MIPI 接口、LVDS 接口和 HISPI 接口)，SLVS-EC，BT.1120，BT.656，BT.601，DC 等接口接收视频数据。VI 将接收到的数据存入到指定的内存区域，在此过程中，VI 可以对接收到的原始视频图像数据进行处理，实现视频数据的采集。 VI的功能框图...
hisi平台VI模块之个人理解（DEV、PIPE）
科嵌工作室的专栏
03-24 2921
在海思vi模块中，存在sensor -> dev -> pipe -> phy_chn -> ext_chn的关系。 其中dev为输入设备，可以理解为对外的sensor接入设备，如mipi、bt1120、bt565、DC等等，不同的dev能够支持的接口类型也有所不同，以SD3403为例，如mipi接口可以支持4路，对应dev0-dev3；bt1120或bt656及DC接口都只支持一路，对应dev3，因此当sensor为DC模式时，只能绑定到DEV3。 pipe为输入图像数据管道.
海思mpp之VENC（视频编码）流程分析
仗劍走天涯
08-29 7801
通道和变量说明： 编码通道s32ChnNum=2;//一个是4k120一个是1080p30 enPayLoad[2] = {PT_H265, PT_H264};//两种编码方式 VpssGrp = 0; VpssChn[2] = {0,1}; 一、获取两个编码通道的需要编码的具体分辨率 二、获取sensor的信息 三、检查sensor 主要的工作内容是获取sensor的宽...
HISI VENC 实际输出帧率控制
wmdshhzsmile的博客
01-14 1575
平台：HI3516EV100 SDK : Hi3516CV300_SDK_V1.0.2.0 系统 : LiteOS 海思MPP文档里写的我就不多说了，不知道是我理解有问题还是什么，反正很多次都不能准确的控制实际的编码（VENC）输出帧率，就是 cat /proc/venc 能看到的通道输出帧率，今天特地花时间来研究下，发下有如下规律： 海思的帧率控制无非就是如下这些地方涉及到： ISP --...
海思3559A解码多路独立的码流时，可使用多路VDEC-多路VPASS-VO多通道的方式？VO一个视频层，多个通道可以吗？
whx_huxin的博客
03-21 2241
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
Camera接口(一)
weixin_38975819的博客
04-28 6982
Camera接口分类 Camera接口实在多种多样，总的来说分为两大类：Parallel（并口）和Serial（串口），两种大类下面又分为很多子类，类似于软件中提到Class 和SubClass。下面就是干货部分。 Parallel–并口 并口又称为DVP接口； Serial–串口 串口可以理解为将数据排队传输， ...
海思媒体处理平台与UNF构架解析
海思媒体处理平台架构是海思芯片在视频处理中的核心设计，它主要用于处理从视频输入到输出的整个流程。该架构包括了多个关键模块，如视频输入（VI）、视频处理（VPSS）、视频编码（VENC）、视频解码（VDEC）、视频...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值